LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: whitefusion[P]Jaipur_cardgame-/AllTokens.cpp
// Function: All_Tokens::getSize(int)
int All_Tokens::getSize(int id){
    if (id >= 1 && id <= 7){
        return number[id-1];
    }
    
    cout << "getSize:Invalid type of token!" << endl;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x8c69
cmpl $0x7, -0x14(%rbp)
jg 0x8c69
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl 0x18(%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x8c92
movq 0x22360(%rip), %rdi     # 0x2afd0
leaq 0x1555c(%rip), %rsi     # 0x1e1d3
callq 0x2200
movq %rax, %rdi
movq 0x2233a(%rip), %rsi     # 0x2afc0
callq 0x2240
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x8d11
cmpl $0x7, -0x14(%rbp)
jg 0x8d11
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x9d60
movq -0x20(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %esi
callq 0x8c30
movq -0x38(%rbp), %rdi
subl $0x1, %eax
movslq %eax, %rsi
callq 0x9dc0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x9e00
jmp 0x8d6e
movq 0x222b8(%rip), %rdi     # 0x2afd0
leaq 0x154d3(%rip), %rsi     # 0x1e1f2
callq 0x2200
movq %rax, %rdi
movq 0x22292(%rip), %rsi     # 0x2afc0
callq 0x2240
movq -0x20(%rbp), %rdi
movl $0x6, %esi
callq 0x9d60
movq -0x20(%rbp), %rdi
movq %rax, -0x40(%rbp)
movl $0x6, %esi
callq 0x8c30
movq -0x40(%rbp), %rdi
subl $0x1, %eax
movslq %eax, %rsi
callq 0x9dc0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x9e00
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: whitefusion[P]Jaipur_cardgame-/AllBonus.cpp
// Function: All_Bonus::All_Bonus()
All_Bonus::All_Bonus(): size{6,6,6}{
  int i;
  size_t j;
  Token temp;
  vector<Token> tempvec;

  for(i = 0; i < 3 ; ++i){
    temp.setType(BonusName[i+1]);
    for( j = 0; j < Bonus.at(i).size(); ++j){
      temp.setVal(Bonus.at(i).at(j));
      tempvec.push_back(temp);
    }
    allBonus.push_back(tempvec);
    tempvec.clear();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
callq 0x99e0
movq -0x98(%rbp), %rax
movl $0x6, 0x18(%rax)
movl $0x6, 0x1c(%rax)
movl $0x6, 0x20(%rax)
leaq -0x40(%rbp), %rdi
callq 0x53d0
jmp 0xf110
leaq -0x68(%rbp), %rdi
callq 0x9a00
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0xf296
movl -0xc(%rbp), %eax
incl %eax
movl %eax, -0x8c(%rbp)
leaq 0x1c174(%rip), %rdi     # 0x2b2b0
leaq -0x8c(%rbp), %rsi
callq 0x9a20
movq %rax, -0xa8(%rbp)
jmp 0xf151
movq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x20e0
jmp 0xf166
leaq -0x40(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x5460
jmp 0xf178
leaq -0x88(%rbp), %rdi
callq 0x2130
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb8(%rbp)
movslq -0xc(%rbp), %rsi
leaq 0x1c13e(%rip), %rdi     # 0x2b2e0
callq 0x9b00
movq %rax, -0xb0(%rbp)
jmp 0xf1b0
movq -0xb0(%rbp), %rdi
callq 0x9b40
movq %rax, %rcx
movq -0xb8(%rbp), %rax
cmpq %rcx, %rax
jae 0xf26d
movslq -0xc(%rbp), %rsi
leaq 0x1c106(%rip), %rdi     # 0x2b2e0
callq 0x9b00
movq %rax, -0xc0(%rbp)
jmp 0xf1e8
movq -0xc0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9b60
movq %rax, -0xc8(%rbp)
jmp 0xf201
movq -0xc8(%rbp), %rax
movl (%rax), %esi
leaq -0x40(%rbp), %rdi
callq 0x56a0
jmp 0xf215
leaq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9ba0
jmp 0xf224
jmp 0xf226
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xf18c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xf2c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xf2b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2130
jmp 0xf2b1
movq -0xa0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x9c10
jmp 0xf27f
leaq -0x68(%rbp), %rdi
callq 0x9c80
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf120
leaq -0x68(%rbp), %rdi
callq 0x9ca0
leaq -0x40(%rbp), %rdi
callq 0x5440
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x9ca0
leaq -0x40(%rbp), %rdi
callq 0x5440
movq -0x98(%rbp), %rdi
callq 0x9d00
movq -0x48(%rbp), %rdi
callq 0x2360
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0xcce37, -0xc(%rbp)    # imm = 0xCCE37
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0xf5d4
movq -0x30(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x9d60
movq %rax, %rdi
callq 0xd730
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
movslq -0x10(%rbp), %rsi
callq 0x9d60
movq %rax, %rdi
callq 0x9eb0
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x100e0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xfe70
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xf572
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: whitefusion[P]Jaipur_cardgame-/AllBonus.cpp
// Function: All_Bonus::getSize(int)
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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x3, -0x14(%rbp)
jl 0xf689
cmpl $0x5, -0x14(%rbp)
jg 0xf689
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x3, %ecx
movslq %ecx, %rcx
movl 0x18(%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0xf6b2
movq 0x1b940(%rip), %rdi     # 0x2afd0
leaq 0xedbd(%rip), %rsi      # 0x1e454
callq 0x2200
movq %rax, %rdi
movq 0x1b91a(%rip), %rsi     # 0x2afc0
callq 0x2240
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x3, -0x14(%rbp)
jl 0xf731
cmpl $0x5, -0x14(%rbp)
jg 0xf731
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x3, %eax
movslq %eax, %rsi
callq 0x9d60
movq -0x20(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %esi
callq 0xf650
movq -0x38(%rbp), %rdi
subl $0x1, %eax
movslq %eax, %rsi
callq 0x9dc0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x9e00
jmp 0xf78d
movq 0x1b898(%rip), %rdi     # 0x2afd0
leaq 0xed35(%rip), %rsi      # 0x1e474
callq 0x2200
movq %rax, %rdi
movq 0x1b872(%rip), %rsi     # 0x2afc0
callq 0x2240
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9d60
movq -0x20(%rbp), %rdi
movq %rax, -0x40(%rbp)
movl $0x3, %esi
callq 0xf650
movq -0x40(%rbp), %rdi
subl $0x1, %eax
movslq %eax, %rsi
callq 0x9dc0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x9e00
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: whitefusion[P]Jaipur_cardgame-/Deck.cpp
// Function: Deck::pDeck()
void Deck::pDeck()
{
  vector<Card>::iterator dit = deck.begin();
  while( dit != deck.end()){
      cout << (*dit).getCard()<<endl;
      dit++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x11760
movq %rax, -0x10(%rbp)
movq -0x58(%rbp), %rdi
callq 0x117d0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x11790
testb $0x1, %al
jne 0x1149d
jmp 0x1150f
leaq -0x10(%rbp), %rdi
callq 0x11800
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x12d60
movq -0x68(%rbp), %rsi
movq 0x19b0f(%rip), %rdi     # 0x2afd0
callq 0x21d0
movq %rax, -0x60(%rbp)
jmp 0x114cc
movq -0x60(%rbp), %rdi
movq 0x19ae9(%rip), %rsi     # 0x2afc0
callq 0x2240
jmp 0x114de
leaq -0x38(%rbp), %rdi
callq 0x2130
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x11820
movq %rax, -0x50(%rbp)
jmp 0x1147d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2130
jmp 0x11515
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2360
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x12c90
movq -0x58(%rbp), %rdi
callq 0x117d0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x11ad0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x11800
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x11b10
jmp 0x115e2
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11bb0
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x11b40
movq %rax, -0x68(%rbp)
jmp 0x11602
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x11636
jmp 0x1162d
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x12d40
jmp 0x11640
movq -0x50(%rbp), %rdi
callq 0x12d40
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2360
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x11650
leaq -0x28(%rbp), %rdi
callq 0x12c90
jmp 0x12e0e
leaq -0x59(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2370
movq -0x78(%rbp), %rdx
leaq 0xb35d(%rip), %rsi      # 0x1e183
leaq -0x58(%rbp), %rdi
callq 0x4cb0
jmp 0x12e31
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x12d90
jmp 0x12e40
leaq -0x58(%rbp), %rdi
callq 0x2130
leaq -0x59(%rbp), %rdi
callq 0x2260
movl $0x0, -0x60(%rbp)
cmpl $0x5, -0x60(%rbp)
jge 0x12ec5
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x11670
jmp 0x12e6e
jmp 0x12e70
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x12e59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x12eeb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x12eac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2130
leaq -0x59(%rbp), %rdi
callq 0x2260
jmp 0x12ee2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x12ee2
movq -0x68(%rbp), %rax
movl $0x5, 0x18(%rax)
leaq -0x28(%rbp), %rdi
callq 0x12d40
addq $0x80, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x12d40
movq -0x70(%rbp), %rdi
callq 0x116e0
movq -0x30(%rbp), %rdi
callq 0x2360
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
callq 0x11650
leaq -0x30(%rbp), %rdi
callq 0x12c90
jmp 0x12f38
leaq -0x61(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x2370
movq -0xa8(%rbp), %rdx
leaq 0xb22d(%rip), %rsi      # 0x1e183
leaq -0x60(%rbp), %rdi
callq 0x4cb0
jmp 0x12f61
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x12d90
jmp 0x12f70
leaq -0x60(%rbp), %rdi
callq 0x2130
leaq -0x61(%rbp), %rdi
callq 0x2260
movl $0x0, -0x68(%rbp)
cmpl $0x3, -0x68(%rbp)
jge 0x13001
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x11670
jmp 0x12fa1
jmp 0x12fa3
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x12f89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x130a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x12fe2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2130
leaq -0x61(%rbp), %rdi
callq 0x2260
jmp 0x13097
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x13097
movl $0x0, -0x6c(%rbp)
cmpl $0x2, -0x6c(%rbp)
jge 0x13077
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x11580
jmp 0x13020
leaq -0x30(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x11b10
jmp 0x13032
leaq -0x90(%rbp), %rdi
callq 0x12d40
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x11670
jmp 0x13050
jmp 0x13052
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x13008
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x12d40
jmp 0x13097
movq -0x98(%rbp), %rax
movl $0x5, 0x18(%rax)
leaq -0x30(%rbp), %rdi
callq 0x12d40
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x12d40
movq -0xa0(%rbp), %rdi
callq 0x116e0
movq -0x38(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x11740
movq -0xa0(%rbp), %rax
movl $0x0, 0x18(%rax)
leaq -0x30(%rbp), %rdi
callq 0x12c90
leaq -0x51(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2370
movq -0x98(%rbp), %rdx
leaq 0xb06b(%rip), %rsi      # 0x1e183
leaq -0x50(%rbp), %rdi
callq 0x4cb0
jmp 0x13123
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x12d90
jmp 0x13132
leaq -0x50(%rbp), %rdi
callq 0x2130
leaq -0x51(%rbp), %rdi
callq 0x2260
movl $0x0, -0x68(%rbp)
cmpl $0x3, -0x68(%rbp)
jge 0x131b2
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x11670
jmp 0x13163
jmp 0x13165
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x1314b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x13193
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2130
leaq -0x51(%rbp), %rdi
callq 0x2260
jmp 0x13248
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x13248
movl $0x0, -0x6c(%rbp)
cmpl $0x2, -0x6c(%rbp)
jge 0x13228
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x11580
jmp 0x131d1
leaq -0x30(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x11b10
jmp 0x131e3
leaq -0x90(%rbp), %rdi
callq 0x12d40
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x11670
jmp 0x13201
jmp 0x13203
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x131b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x12d40
jmp 0x13248
movq -0xa0(%rbp), %rax
movl $0x5, 0x18(%rax)
leaq -0x30(%rbp), %rdi
callq 0x12d40
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x12d40
movq -0x60(%rbp), %rdi
callq 0x2360
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x12c90
cmpl $0x0, -0x14(%rbp)
jle 0x13350
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
movl 0x18(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x13350
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
decl %eax
movslq %eax, %rsi
callq 0x13890
movq %rax, -0x48(%rbp)
jmp 0x1331d
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x11b10
jmp 0x1332c
movb $0x1, -0x15(%rbp)
movl $0x1, -0x28(%rbp)
jmp 0x133aa
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x12d40
jmp 0x133c3
movq 0x17c79(%rip), %rdi     # 0x2afd0
leaq 0xb262(%rip), %rsi      # 0x1e5c0
callq 0x2200
movq %rax, -0x50(%rbp)
jmp 0x13369
movq -0x50(%rbp), %rdi
movq 0x17c4c(%rip), %rsi     # 0x2afc0
callq 0x2240
jmp 0x1337b
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13890
movq %rax, -0x58(%rbp)
jmp 0x1338e
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x11b10
jmp 0x1339d
jmp 0x1339f
movb $0x1, -0x15(%rbp)
movl $0x1, -0x28(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x133b9
movq -0x40(%rbp), %rdi
callq 0x12d40
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2360
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movl $0x5, %eax
subl 0x18(%rcx), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x138d0
cmpl $0x0, %eax
je 0x134fa
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x134f8
movq -0x10(%rbp), %rdi
callq 0x138d0
cmpl $0x0, %eax
jne 0x134a0
jmp 0x134f8
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x11580
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x138f0
jmp 0x134c0
leaq -0x38(%rbp), %rdi
callq 0x12d40
movq -0x50(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x13488
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x12d40
jmp 0x13500
jmp 0x134fa
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2360
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x12d60
movq -0x48(%rbp), %rdi
leaq 0x99ff(%rip), %rsi      # 0x1e183
callq 0x13920
movb %al, -0x3d(%rbp)
jmp 0x1478e
leaq -0x30(%rbp), %rdi
callq 0x2130
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x147a0
jmp 0x147e4
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x15e70
movq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x11670
movq -0x50(%rbp), %rax
movl 0x44(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x44(%rax)
jmp 0x1480e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2130
jmp 0x14814
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15e70
movq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x11670
movq -0x50(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2360
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x148ef
cmpl $0x1, -0x14(%rbp)
jg 0x148ef
cmpl $0x0, -0x18(%rbp)
jl 0x148a2
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
movslq -0x14(%rbp), %rdx
cmpl 0x40(%rcx,%rdx,4), %eax
jge 0x148a2
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x15ed0
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x15f10
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x121a0
jmp 0x1493a
movq 0x16727(%rip), %rdi     # 0x2afd0
leaq 0x9e27(%rip), %rsi      # 0x1e6d7
callq 0x2200
movq %rax, %rdi
movq 0x16701(%rip), %rsi     # 0x2afc0
callq 0x2240
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x15ed0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15f10
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x121a0
jmp 0x1493a
movq 0x166da(%rip), %rdi     # 0x2afd0
leaq 0x9e19(%rip), %rsi      # 0x1e716
callq 0x2200
movq %rax, %rdi
movq 0x166b4(%rip), %rsi     # 0x2afc0
callq 0x2240
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15ed0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15f10
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x121a0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x14a24
cmpl $0x3, -0x14(%rbp)
jg 0x14a24
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x48(%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x14a50
movq 0x165a5(%rip), %rdi     # 0x2afd0
leaq 0x9d29(%rip), %rsi      # 0x1e75b
callq 0x2200
movq %rax, %rdi
movq 0x1657f(%rip), %rsi     # 0x2afc0
callq 0x2240
movq -0x20(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x7, 0x40(%rax)
jge 0x14e93
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x132c0
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x14750
jmp 0x14e58
leaq -0x40(%rbp), %rdi
callq 0x12d40
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x133d0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13450
jmp 0x14eb5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x12d40
jmp 0x14ebb
movq 0x16136(%rip), %rdi     # 0x2afd0
leaq 0x98f5(%rip), %rsi      # 0x1e796
callq 0x2200
movq %rax, %rdi
movq 0x16110(%rip), %rsi     # 0x2afc0
callq 0x2240
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x18(%rdi)
addq $0x20, %rdi
movq %rdi, -0x50(%rbp)
callq 0x8720
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x40(%rbp)
callq 0xf0c0
jmp 0x191c3
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
callq 0xf550
jmp 0x191d2
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x19250
jmp 0x191e2
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x19270
jmp 0x191f2
xorl %eax, %eax
movl %eax, %edi
callq 0x21e0
movl %eax, %edi
callq 0x21f0
movq -0x48(%rbp), %rax
movl $0x1, 0x88(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x19239
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xf5e0
movq -0x50(%rbp), %rdi
callq 0x8bc0
movq -0x30(%rbp), %rdi
callq 0x2360
nopl (%rax,%rax)
// File: whitefusion[P]Jaipur_cardgame-/Game.cpp
// Function: Game::~Game()
Game::~Game(){
    deck.clear(); 
    market.clear();
    p1.clear();
    p2.clear();
    tokens.clear();
    bonus.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x11440
jmp 0x192ae
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x13280
jmp 0x192bd
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x143b0
jmp 0x192cc
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x143b0
jmp 0x192db
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x8be0
jmp 0x192ea
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0xf600
jmp 0x192f9
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0xf5e0
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x8bc0
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x50f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x193bf
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x38(%rbp)
movl -0x10(%rbp), %ecx
movl %ecx, -0x2c(%rbp)
movq 0x10(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0x149f0
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
imull $0xffffffff, %eax, %edx # imm = 0xFFFFFFFF
callq 0x146a0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x28(%rbp)
movl -0x10(%rbp), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x10(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0x149f0
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
imull $0xffffffff, %eax, %edx # imm = 0xFFFFFFFF
callq 0x146a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1934e
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x19270
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x19450
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x10e00
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x11520
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rax), %rsi
callq 0x130c0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x8940
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
callq 0xf2e0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rax), %rsi
callq 0x14410
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rax), %rsi
callq 0x14410
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: whitefusion[P]Jaipur_cardgame-/Game.cpp
// Function: Game::RoundTermination()
bool Game::RoundTermination(){
    // check the size of deck
    if (getDeck().getsize() == 0)
        return true;
    // check the number of tokens
    int numZero = 0;
    for (int i = 0; i < 6; ++i){
        if (getATokens().getSize(i+1) == 0)
            numZero++;
    }
    if(numZero > 2)
        return true;

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1bde0
movq %rax, %rdi
callq 0x138d0
cmpl $0x0, %eax
jne 0x1a012
movb $0x1, -0x1(%rbp)
jmp 0x1a09a
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x6, -0x18(%rbp)
jge 0x1a08a
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1be00
movq -0x78(%rbp), %rdi
movl -0x18(%rbp), %esi
incl %esi
callq 0x8c30
movl %eax, -0x6c(%rbp)
jmp 0x1a04a
leaq -0x50(%rbp), %rdi
callq 0x8bc0
movl -0x6c(%rbp), %eax
cmpl $0x0, %eax
jne 0x1a07d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a07d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8bc0
jmp 0x1a0a8
jmp 0x1a07f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1a020
cmpl $0x2, -0x14(%rbp)
jle 0x1a096
movb $0x1, -0x1(%rbp)
jmp 0x1a09a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x49c4(%rip), %rdi      # 0x1eaa3
callq 0x21b0
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x8e20
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
callq 0xf850
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x13540
movq -0x10(%rbp), %rdi
callq 0x154b0
movq 0x10eb5(%rip), %rdi     # 0x2afd0
leaq 0x4987(%rip), %rsi      # 0x1eaa9
callq 0x2200
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x4d60
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x2350
movq %rax, %rdi
leaq 0x49bc(%rip), %rsi      # 0x1eb05
callq 0x2200
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x1bc50
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x2350
movq %rax, %rdi
leaq 0x499c(%rip), %rsi      # 0x1eb0c
callq 0x2200
movq %rax, %rdi
movq 0x10e41(%rip), %rsi     # 0x2afc0
callq 0x2240
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rax), %rdi
movl $0x2, %esi
callq 0x149f0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x149f0
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jle 0x1a4de
movl $0x1, -0x4(%rbp)
jmp 0x1a5b6
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x2, %esi
callq 0x149f0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x24(%rbp)
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x149f0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x1a51c
movl $0x2, -0x4(%rbp)
jmp 0x1a5b6
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x160a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x28(%rbp)
movq 0x18(%rax), %rdi
callq 0x160a0
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jle 0x1a54d
movl $0x1, -0x4(%rbp)
jmp 0x1a5b6
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x160a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x2c(%rbp)
movq 0x18(%rax), %rdi
callq 0x160a0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x1a57e
movl $0x2, -0x4(%rbp)
jmp 0x1a5b6
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x16080
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x30(%rbp)
movq 0x18(%rax), %rdi
callq 0x16080
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jle 0x1a5af
movl $0x1, -0x4(%rbp)
jmp 0x1a5b6
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movb $0x0, -0x61(%rbp)
movb $0x0, -0x75(%rbp)
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, -0x76(%rbp)
jl 0x1b1fe
movq -0x20(%rbp), %rcx
movb $0x1, %al
cmpl $0x5, (%rcx)
movb %al, -0x76(%rbp)
jg 0x1b1fe
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movl (%rax), %edx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x132c0
movq -0x80(%rbp), %rsi
movb $0x1, -0x61(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x12d60
jmp 0x1b1d7
movb $0x1, -0x75(%rbp)
leaq 0x2fa1(%rip), %rsi      # 0x1e183
leaq -0x40(%rbp), %rdi
callq 0x13920
movb %al, -0x81(%rbp)
jmp 0x1b1f3
movb -0x81(%rbp), %al
movb %al, -0x76(%rbp)
jmp 0x1b1fe
movb -0x76(%rbp), %al
movb %al, -0x82(%rbp)
testb $0x1, -0x75(%rbp)
jne 0x1b20f
jmp 0x1b218
leaq -0x40(%rbp), %rdi
callq 0x2130
testb $0x1, -0x61(%rbp)
jne 0x1b220
jmp 0x1b229
leaq -0x60(%rbp), %rdi
callq 0x12d40
movb -0x82(%rbp), %al
testb $0x1, %al
jne 0x1b235
jmp 0x1b27b
movb $0x0, -0x1(%rbp)
jmp 0x1b27f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1b268
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
testb $0x1, -0x75(%rbp)
jne 0x1b25d
jmp 0x1b266
leaq -0x40(%rbp), %rdi
callq 0x2130
jmp 0x1b268
testb $0x1, -0x61(%rbp)
jne 0x1b270
jmp 0x1b279
leaq -0x60(%rbp), %rdi
callq 0x12d40
jmp 0x1b28d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: whitefusion[P]Jaipur_cardgame-/Game.cpp
// Function: Game::finalWinner()
int Game::finalWinner(){
    if (p1.getPoints(3) == 2)
        return 1;
    else 
        return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x3, %esi
callq 0x149f0
cmpl $0x2, %eax
jne 0x1bc1c
movl $0x1, -0x4(%rbp)
jmp 0x1bc23
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
subq $0xc8, %rsp
movl $0x0, 0xc4(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x1830
leaq 0x87(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1150
movq 0x20(%rsp), %rdx
leaq 0x1a37(%rip), %rsi      # 0x3004
leaq 0x88(%rsp), %rdi
callq 0x1100
jmp 0x15dc
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1150
movq 0x18(%rsp), %rdx
leaq 0x1a20(%rip), %rsi      # 0x3017
leaq 0x50(%rsp), %rdi
callq 0x1100
jmp 0x1603
leaq 0x88(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
callq 0x12b0
jmp 0x161f
leaq 0x50(%rsp), %rdi
callq 0x1070
leaq 0x4f(%rsp), %rdi
callq 0x10f0
leaq 0x88(%rsp), %rdi
callq 0x1070
leaq 0x87(%rsp), %rdi
callq 0x10f0
movq 0x3984(%rip), %rdi      # 0x4fd8
leaq 0x19c1(%rip), %rsi      # 0x301c
callq 0x10c0
movq %rax, 0x10(%rsp)
jmp 0x1667
movq 0x10(%rsp), %rdi
movq 0x3955(%rip), %rsi      # 0x4fc8
callq 0x10e0
jmp 0x167a
movq 0x3957(%rip), %rdi      # 0x4fd8
leaq 0x19a5(%rip), %rsi      # 0x302d
callq 0x10c0
jmp 0x168f
leaq 0xa8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x1840
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x1870
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x18a0
testb $0x1, %al
jne 0x16d2
jmp 0x1788
leaq 0x38(%rsp), %rdi
callq 0x18e0
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %esi
movq 0x38eb(%rip), %rdi      # 0x4fd8
callq 0x1130
movq %rax, 0x8(%rsp)
jmp 0x16f9
movq 0x8(%rsp), %rdi
leaq 0x1931(%rip), %rsi      # 0x3036
callq 0x10c0
jmp 0x170c
jmp 0x170e
leaq 0x38(%rsp), %rdi
callq 0x18f0
jmp 0x16ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x1769
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x1752
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1070
leaq 0x4f(%rsp), %rdi
callq 0x10f0
leaq 0x88(%rsp), %rdi
callq 0x1070
leaq 0x87(%rsp), %rdi
callq 0x10f0
jmp 0x17c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x17c4
movq 0x3849(%rip), %rdi      # 0x4fd8
movq 0x3832(%rip), %rsi      # 0x4fc8
callq 0x10e0
jmp 0x179d
movl $0x0, 0xc4(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x1910
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
leaq 0xa8(%rsp), %rdi
callq 0x1910
movq 0x78(%rsp), %rdi
callq 0x1140
nopl (%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/tests/qmidiin.cpp
// Function: usage()
void usage( void ) {
  // Error function in case of incorrect command-line
  // argument specifications.
  std::cout << "\nusage: qmidiin <port>\n";
  std::cout << "    where port = the device to use (default = 0).\n\n";
  exit( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3c2d(%rip), %rdi      # 0x5fd8
leaq 0x1c52(%rip), %rsi      # 0x4004
callq 0x2100
movq 0x3c1a(%rip), %rdi      # 0x5fd8
leaq 0x1c57(%rip), %rsi      # 0x401c
callq 0x2100
xorl %edi, %edi
callq 0x2190
nopw %cs:(%rax,%rax)
// File: QZzcoder[P]LiveChat/server.cpp
// Function: updateTime(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool updateTime(string name){
    string sql = "update User set logofftime = "+to_string(timeStamp())+" where name =\""+name+"\";";
    MYSQL mysql_conn;
    MYSQL_RES * ptr_res;
    MYSQL_ROW result_row;
    mysql_init(&mysql_conn);
    if(!mysql_real_connect(&mysql_conn,"localhost","root",dbpassword,"Chat",0,NULL,0)){
        cout<<"mysql error";
        exit(1);
    }
    if(!mysql_query(&mysql_conn,sql.c_str())){
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x590, %rsp            # imm = 0x590
movq %rdi, -0x570(%rbp)
movq %rdi, -0x10(%rbp)
callq 0xcef0
movq %rax, %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x568(%rbp)
callq 0x66e0
movq -0x568(%rbp), %rdx
leaq 0x9d9c(%rip), %rsi      # 0xe0ab
leaq -0x90(%rbp), %rdi
callq 0x6690
jmp 0x431d
leaq 0x9da5(%rip), %rdx      # 0xe0c9
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x62f0
jmp 0x4336
movq -0x570(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x6450
jmp 0x434c
leaq 0x9cfc(%rip), %rdx      # 0xe04f
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x62f0
jmp 0x4362
leaq -0x50(%rbp), %rdi
callq 0x3200
leaq -0x70(%rbp), %rdi
callq 0x3200
leaq -0x90(%rbp), %rdi
callq 0x3200
leaq -0xb0(%rbp), %rdi
callq 0x3200
leaq -0x548(%rbp), %rdi
callq 0x3160
jmp 0x439a
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
leaq 0x9c51(%rip), %rsi      # 0xe004
leaq 0x9c54(%rip), %rdx      # 0xe00e
leaq 0x10eff(%rip), %rcx     # 0x152c0
leaq 0x9c4b(%rip), %r8       # 0xe013
leaq -0x548(%rbp), %rdi
xorl %r9d, %r9d
callq 0x3190
movq %rax, -0x578(%rbp)
jmp 0x43e0
movq -0x578(%rbp), %rax
cmpq $0x0, %rax
jne 0x44a7
movq 0x10be0(%rip), %rdi     # 0x14fd8
leaq 0x9c19(%rip), %rsi      # 0xe018
callq 0x3310
jmp 0x4406
movl $0x1, %edi
callq 0x33b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x447c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x4470
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x4467
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3200
leaq -0x70(%rbp), %rdi
callq 0x3200
leaq -0x90(%rbp), %rdi
callq 0x3200
leaq -0xb0(%rbp), %rdi
callq 0x3200
jmp 0x4507
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3200
jmp 0x4507
leaq -0x30(%rbp), %rdi
callq 0x3120
movq %rax, %rsi
leaq -0x548(%rbp), %rdi
callq 0x3210
movl %eax, -0x57c(%rbp)
jmp 0x44c7
movl -0x57c(%rbp), %eax
cmpl $0x0, %eax
jne 0x44e2
movb $0x1, -0x1(%rbp)
movl $0x1, -0x55c(%rbp)
jmp 0x44f0
movb $0x0, -0x1(%rbp)
movl $0x1, -0x55c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3200
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x590, %rsp            # imm = 0x590
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x34d0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x99a0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x99e0
jmp 0x684f
movq -0x40(%rbp), %rdi
addq $0x58, %rdi
callq 0x9a30
movq -0x40(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x30(%rbp)
addq $0x58, %rdi
callq 0x9a60
movl -0x30(%rbp), %eax
movl %eax, -0x44(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x9ad0
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x9ad0
movq -0x28(%rbp), %rdi
callq 0x34d0
nopw %cs:(%rax,%rax)
nop
// File: pehublove[P]GPS-neo7n-forBaiduMap/test.cpp
// Function: open_port()
int open_port(void)
{
	int fd;		//串口的标识符
	//O_NOCTTY用来告诉Linux这个程序不会成为“控制终端”
	//O_NDELAY用来告诉Linux这个程序不关心DCD信号
	fd=open(serial_device,O_RDWR | O_NOCTTY | O_NDELAY);
	if(fd == -1)
	{
		//不能打开串口
		perror("open_port: Unable to open /dev/ttyS0 -");
		return(fd);
	}
	else
	{
		fcntl(fd, F_SETFL, 0);
		printf("open ttys0 .....\n");
		return(fd);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2ae1(%rip), %rdi      # 0x5010
movl $0x902, %esi            # imm = 0x902
movb $0x0, %al
callq 0x2180
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
jne 0x2558
leaq 0x2b18(%rip), %rdi      # 0x5063
callq 0x21c0
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x257d
movl -0x8(%rbp), %edi
movl $0x4, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x2110
leaq 0x2b1a(%rip), %rdi      # 0x508a
movb $0x0, %al
callq 0x2040
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)