LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2c60(%rip), %rdi      # 0xdab3
callq 0x2160
leaq 0x20(%rbx), %rdi
callq 0x4d2e
leaq 0x58(%rbx), %rdi
callq 0x680c
movq 0x8(%rbx), %rdi
callq 0x8126
movq %r14, %rdi
callq 0x934a
movq 0xa14e(%rip), %rdi      # 0x14fd0
leaq 0x2c30(%rip), %rsi      # 0xdab9
callq 0x21b0
movl 0x80(%rbx), %esi
movq %rax, %rdi
callq 0x2290
leaq 0x2c72(%rip), %rsi      # 0xdb15
movq %rax, %rdi
callq 0x21b0
movl 0x84(%rbx), %esi
movq %rax, %rdi
callq 0x2290
leaq 0x2c5c(%rip), %rsi      # 0xdb1c
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/whitefusion[P]Jaipur_cardgame-/Game.cpp
// Function: Game::play_a_turn(Player&)
void Game::play_a_turn(Player &p){
    int act;
    int take;
    vector<vector<int> > trade;
    vector<int> sell;

    act = p.setAction(market);

    // verify the input and carry out action
    switch (act){
        // take
        case 1:
        {
            take = takeInputVerify(market);
            p.Take(take, market, deck);
            break;
        }
        // trade
        case 2:
        {
            trade = tradeInputVerify(p,market);
            p.Trade(trade.at(0), trade.at(1), market);
            break;
        }
        //sell
        case 3:
        {
            sell = sellInputVerify(p);
            p.Sell(sell, tokens, bonus);
            break;
        }
        //take camels
        case 4:
        {
            p.TakeCamel(market, deck); 
            break;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r14
andq $0x0, 0x10(%rsp)
xorps %xmm0, %xmm0
andq $0x0, 0x30(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x20(%rsp)
movq 0x8(%rdi), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
decl %eax
cmpl $0x3, %eax
ja 0xb045
leaq 0x2a66(%rip), %rcx      # 0xd988
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rsi
movq %r14, %rdi
callq 0xb130
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movl %eax, %esi
callq 0x8efa
jmp 0xb045
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xb63c
leaq 0x20(%rsp), %r12
leaq 0x50(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0xc0f4
movq %r15, %rdi
callq 0x57aa
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x59ec
leaq 0x20(%r14), %rdx
addq $0x58, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x8cd4
jmp 0xb03d
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x91ca
jmp 0xb045
movq 0x8(%r14), %rcx
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xb258
movq %rsp, %r15
leaq 0x50(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xc0a2
movq %r12, %rdi
callq 0x52ca
movq %r15, %rdi
xorl %esi, %esi
callq 0x533a
leaq 0x68(%rsp), %rdi
movq %rax, %rsi
callq 0x59ec
movq %rsp, %rdi
pushq $0x1
popq %rsi
callq 0x533a
leaq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x59ec
movq 0x8(%r14), %rcx
leaq 0x68(%rsp), %r15
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8f96
leaq 0x38(%rsp), %rdi
callq 0x57aa
movq %r15, %rdi
callq 0x57aa
leaq 0x20(%rsp), %rdi
callq 0x57aa
movq %rsp, %rdi
callq 0x52ca
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x57aa
jmp 0xb089
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
jmp 0xb08e
jmp 0xb095
jmp 0xb095
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x57aa
jmp 0xb098
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x57aa
movq %rsp, %rdi
callq 0x52ca
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rdi), %rdi
pushq $0x2
popq %rbp
movl %ebp, %esi
callq 0x8c9c
movl %eax, %r15d
movq 0x18(%r14), %rdi
movl %ebp, %esi
callq 0x8c9c
pushq $0x1
popq %rbx
cmpl %eax, %r15d
jg 0xb123
movq 0x10(%r14), %rdi
movl %ebp, %esi
callq 0x8c9c
movl %eax, %r15d
movq 0x18(%r14), %rdi
movl %ebp, %esi
callq 0x8c9c
cmpl %eax, %r15d
jge 0xb102
movl %ebp, %ebx
jmp 0xb123
movq 0x10(%r14), %rcx
movq 0x18(%r14), %rax
movl 0x5c(%rax), %edx
cmpl %edx, 0x5c(%rcx)
jg 0xb123
movl %ebp, %ebx
jl 0xb123
movl 0x58(%rcx), %ecx
xorl %ebx, %ebx
cmpl 0x58(%rax), %ecx
setle %bl
incl %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/whitefusion[P]Jaipur_cardgame-/Game.cpp
// Function: Game::takeInputVerify(Market&)
int Game::takeInputVerify(Market &m){
    int take;
    char tmp[256];
    char *token;

    cout << "Choose the ID of the card want to take: ";
    cin.getline(tmp,256);
    token = strtok(tmp, " \t\n\r\f");
    while (!token){
        cout << "Invalid choice! Try again." << endl;
        cout << "Choose the ID of the card want to take: ";
        cin.getline(tmp, 256);
        token = strtok(tmp, " \t\n\r\f");
    }
    take = atoi(token);

    while(!takeVerify(m, take)){
        cout << "Invalid choice! Try again: ";
        cin.getline(tmp,256);
        token = strtok(tmp, " \t\n\r\f");
        while (!token){
            cout << "Invalid choice! Try again." << endl;
            cout << "Choose the ID of the card want to take: ";
            cin.getline(tmp, 256);
            token = strtok(tmp, " \t\n\r\f");
        }
        take = atoi(token);
    }
    return take;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, 0x8(%rsp)
movq 0x9e83(%rip), %rbx      # 0x14fd0
leaq 0x28cc(%rip), %r14      # 0xda20
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21b0
movq 0x9e7a(%rip), %r15      # 0x14fe0
leaq 0x10(%rsp), %r12
leaq 0x1ef0(%rip), %r13      # 0xd062
leaq 0x1eef(%rip), %rbp      # 0xd068
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
movq %r12, %rsi
callq 0x2080
movq %r12, %rdi
movq %r13, %rsi
callq 0x2250
testq %rax, %rax
jne 0xb1b9
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x21b0
movq %rax, %rdi
callq 0x20f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21b0
jmp 0xb179
movq 0x9e10(%rip), %r12      # 0x14fd0
movq 0x9e19(%rip), %r13      # 0x14fe0
leaq 0x10(%rsp), %rbp
leaq 0x1e8f(%rip), %r15      # 0xd062
leaq 0x1e8e(%rip), %rbx      # 0xd068
movq %rax, %rdi
callq 0x2240
movl %eax, (%rsp)
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0xb872
testb %al, %al
jne 0xb243
leaq 0x2846(%rip), %rsi      # 0xda49
movq %r12, %rdi
callq 0x21b0
movl $0x100, %edx            # imm = 0x100
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2080
movq %rbp, %rdi
movq %r15, %rsi
callq 0x2250
testq %rax, %rax
jne 0xb1da
movq %r12, %rdi
movq %rbx, %rsi
callq 0x21b0
movq %rax, %rdi
callq 0x20f0
movq %r14, %rsi
jmp 0xb203
movl (%rsp), %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb887
xorl %ebx, %ebx
jmp 0xb8cc
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x7ff6
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x7d18
leaq 0x18db(%rip), %rsi      # 0xd183
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x83b7
movl %eax, %ebx
movq %r14, %rdi
callq 0x20e0
leaq 0x8(%rsp), %rdi
callq 0x7d12
xorb $0x1, %bl
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7d12
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/whitefusion[P]Jaipur_cardgame-/Game.cpp
// Function: Game::finalWinner()
int Game::finalWinner(){
    if (p1.getPoints(3) == 2)
        return 1;
    else 
        return 2;
}

// Assembly:
pushq %rax
movq 0x10(%rdi), %rdi
pushq $0x3
popq %rsi
callq 0x8c9c
xorl %ecx, %ecx
cmpl $0x2, %eax
setne %cl
incl %ecx
movl %ecx, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x125d
movq %rax, 0x8(%rbx)
andl $0x0, 0x2e4c(%rip)      # 0x40b0
movq 0x8(%r14), %rax
pushq $0x1
popq %rcx
leaq 0x2e3e(%rip), %r13      # 0x40b0
cmpq %rcx, %rax
jbe 0x12b0
movq (%r14), %rsi
movl %ecx, %edx
movslq %edx, %rdx
movslq -0x4(%r13,%rdx,4), %rdx
movl %edx, (%r13,%rcx,4)
testq %rdx, %rdx
jle 0x129a
movb (%rsi,%rcx), %dil
cmpb (%rsi,%rdx), %dil
jne 0x127c
jmp 0x12a4
movb (%rsi,%rcx), %dil
cmpb (%rsi,%rdx), %dil
jne 0x12ab
incl %edx
movl %edx, (%r13,%rcx,4)
incq %rcx
jmp 0x1272
xorl %ebp, %ebp
xorl %eax, %eax
cmpq %rbp, 0x8(%r15)
jbe 0x131b
movq (%r15), %rdx
movq (%r14), %rcx
testl %eax, %eax
jle 0x12d9
movb (%rdx,%rbp), %sil
movl %eax, %edi
cmpb (%rcx,%rdi), %sil
je 0x12dd
decl %eax
movl (%r13,%rax,4), %eax
jmp 0x12c0
movb (%rdx,%rbp), %sil
movslq %eax, %rdi
xorl %edx, %edx
cmpb (%rcx,%rdi), %sil
sete %dl
addl %eax, %edx
movslq %edx, %r12
cmpq %r12, 0x8(%r14)
jne 0x1314
incq %rbp
movl %ebp, %eax
subl %r12d, %eax
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
leaq 0x4(%rsp), %rsi
callq 0x145a
movl -0x4(%r13,%r12,4), %eax
jmp 0x12b4
incq %rbp
movl %edx, %eax
jmp 0x12b4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x68, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0xcba(%rip), %rsi       # 0x2004
leaq 0x48(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1040
leaq 0xcb7(%rip), %rsi       # 0x2017
leaq 0x28(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1040
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x123c
leaq 0x28(%rsp), %rdi
callq 0x1050
leaq 0x48(%rsp), %rdi
callq 0x1050
movq 0x2c3a(%rip), %rdi      # 0x3fd8
leaq 0xc77(%rip), %rsi       # 0x201c
callq 0x10b0
movq %rax, %rdi
callq 0x1060
movq 0x2c1f(%rip), %rdi      # 0x3fd8
leaq 0xc6d(%rip), %rsi       # 0x202d
callq 0x10b0
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %r12
movq 0x2c02(%rip), %rbx      # 0x3fd8
leaq 0xc59(%rip), %r14       # 0x2036
cmpq %r12, %r15
je 0x13fe
movl (%r15), %esi
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x10b0
addq $0x4, %r15
jmp 0x13dd
movq 0x2bd3(%rip), %rdi      # 0x3fd8
callq 0x1060
leaq 0x10(%rsp), %rdi
callq 0x15ba
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1050
jmp 0x1434
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1050
jmp 0x1447
jmp 0x1444
jmp 0x1444
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x15ba
movq %rbx, %rdi
callq 0x1100
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH14_OverloadedOperationsAndConversions/examples/add.cc
// Function: main
int main()
{
    Sales_item item1, item2;
    // read a pair of transactions
    cin >> item1 >> item2;
    // print the sum of two Sales_items
    cout << item1 + item2 << endl;

	Sales_data data1, data2;
    /**
     * read a pair of transactions
     * std::istream& read(std::istream&, Sales_data&)
     */
    read(read(cin, data1), data2);
    // print the sum of two Sales_datas
    print(cout, add(data1, data2));
 	cout << std::endl;

    // use input operator to read Sales_datas
	cin >> data1 >> data2;
    // use operators to print the sum of two Sales_datas
    cout << data1 + data2 << endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xf8, %rsp
leaq -0xe8(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq -0xb8(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq 0x2b54(%rip), %rdi      # 0x3fe0
leaq -0xf8(%rbp), %rsi
callq 0x12cc
movq 0x2b41(%rip), %rdi      # 0x3fe0
leaq -0xc8(%rbp), %rsi
callq 0x12cc
leaq -0x38(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x129a
movq 0x2b07(%rip), %rdi      # 0x3fd0
leaq -0x38(%rbp), %rsi
callq 0x1363
movq 0x2af7(%rip), %rdi      # 0x3fd0
callq 0x1040
leaq -0x38(%rbp), %rdi
callq 0x1030
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq -0x88(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq 0x2abd(%rip), %rdi      # 0x3fe0
leaq -0x38(%rbp), %rsi
callq 0x18ad
leaq -0x98(%rbp), %rsi
movq %rax, %rdi
callq 0x18ad
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x19c0
movq 0x2a7a(%rip), %rdi      # 0x3fd0
leaq -0x68(%rbp), %rsi
callq 0x1901
leaq -0x68(%rbp), %rdi
callq 0x1030
movq 0x2a61(%rip), %rdi      # 0x3fd0
callq 0x1040
movq 0x2a65(%rip), %rdi      # 0x3fe0
leaq -0x38(%rbp), %rsi
callq 0x16e6
leaq -0x98(%rbp), %rsi
movq %rax, %rdi
callq 0x16e6
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x17bc
movq 0x2a22(%rip), %rdi      # 0x3fd0
leaq -0x68(%rbp), %rsi
callq 0x17ee
movq %rax, %rdi
callq 0x1040
leaq -0x68(%rbp), %rdi
callq 0x1030
leaq -0x98(%rbp), %rdi
callq 0x1030
leaq -0x38(%rbp), %rdi
callq 0x1030
leaq -0xc8(%rbp), %rdi
callq 0x1030
leaq -0xf8(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0xf8, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1621
jmp 0x1609
jmp 0x1621
jmp 0x161c
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x1030
jmp 0x1624
movq %rax, %rbx
jmp 0x1630
movq %rax, %rbx
jmp 0x1639
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x1030
leaq -0x38(%rbp), %rdi
callq 0x1030
leaq -0xc8(%rbp), %rdi
callq 0x1030
leaq -0xf8(%rbp), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1100
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq 0x2cf4(%rip), %rbx      # 0x4fd8
leaq 0xd19(%rip), %rsi       # 0x3004
movq %rbx, %rdi
callq 0x20e0
leaq 0xd22(%rip), %rsi       # 0x301c
movq %rbx, %rdi
callq 0x20e0
xorl %edi, %edi
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movq 0x8(%rdi), %r14
subq (%rdi), %r14
sarq $0x3, %r14
leaq -0x1(%r14), %rax
movq %rax, %xmm0
punpckldq 0x114c(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1154(%rip), %xmm0     # 0x3030
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, -0x30(%rbp)
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x1f34
cvtsi2sd %r15d, %xmm0
mulsd 0x1106(%rip), %xmm0     # 0x3008
divsd -0x30(%rbp), %xmm0
callq 0x1170
movsd 0x119c(%rip), %xmm1     # 0x30b0
subsd %xmm0, %xmm1
mulsd 0x1198(%rip), %xmm1     # 0x30b8
movq (%rbx), %rax
mulsd (%rax,%r15,8), %xmm1
movsd %xmm1, (%rax,%r15,8)
incq %r15
jmp 0x1ef0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x520, %rsp            # imm = 0x520
movq %rdi, %rbx
callq 0x6978
leaq -0x90(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x5079
leaq 0x3317(%rip), %rsi      # 0x70c7
leaq -0x30(%rbp), %rdi
movq %r14, %rdx
callq 0x504b
leaq 0x3322(%rip), %rdx      # 0x70e5
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4ec0
leaq -0x518(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq %rbx, %rdx
callq 0x4f5f
leaq 0x3281(%rip), %rdx      # 0x706b
leaq -0x70(%rbp), %rdi
leaq -0x518(%rbp), %rsi
callq 0x4ec0
leaq -0x518(%rbp), %rdi
callq 0x3110
leaq -0x50(%rbp), %rdi
callq 0x3110
leaq -0x30(%rbp), %rdi
callq 0x3110
leaq -0x90(%rbp), %rdi
callq 0x3110
leaq -0x518(%rbp), %rdi
callq 0x3130
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
leaq 0x31e2(%rip), %rsi      # 0x7020
leaq 0x31e5(%rip), %rdx      # 0x702a
leaq 0x7424(%rip), %rcx      # 0xb270
leaq 0x31dc(%rip), %r8       # 0x702f
leaq -0x518(%rbp), %rdi
xorl %r9d, %r9d
callq 0x3170
testq %rax, %rax
je 0x3e93
movq -0x70(%rbp), %rsi
leaq -0x518(%rbp), %rdi
callq 0x31d0
testl %eax, %eax
sete %bl
leaq -0x70(%rbp), %rdi
callq 0x3110
movl %ebx, %eax
addq $0x520, %rsp            # imm = 0x520
popq %rbx
popq %r14
popq %rbp
retq
movq 0x713e(%rip), %rdi      # 0xafd8
leaq 0x3193(%rip), %rsi      # 0x7034
callq 0x32b0
pushq $0x1
popq %rdi
callq 0x3340
movq %rax, %rbx
leaq -0x518(%rbp), %rdi
callq 0x3110
jmp 0x3ec2
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3110
jmp 0x3ed0
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3110
jmp 0x3ede
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x3eee
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/QZzcoder[P]LiveChat/server.cpp
// Function: userCheck(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool userCheck(string name,string password){
    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);
    }
    string sql = "select * from User where name = \"" + name + "\" and password = "+password+";";
    if(!mysql_query(&mysql_conn,sql.c_str())){
        ptr_res = mysql_use_result(&mysql_conn);
        return mysql_fetch_row(ptr_res)!=NULL;
    }
    cout<<"query error"<<endl;
    mysql_close(&mysql_conn);
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x518, %rsp            # imm = 0x518
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x520(%rbp), %r15
movq %r15, %rdi
callq 0x3130
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
leaq 0x30f2(%rip), %rsi      # 0x7020
leaq 0x30f5(%rip), %rdx      # 0x702a
leaq 0x7334(%rip), %rcx      # 0xb270
leaq 0x30ec(%rip), %r8       # 0x702f
movq %r15, %rdi
xorl %r9d, %r9d
callq 0x3170
testq %rax, %rax
je 0x4037
leaq 0x3196(%rip), %rsi      # 0x70f4
leaq -0x98(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x4ee9
leaq 0x319f(%rip), %rdx      # 0x7116
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x4ec0
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq %rbx, %rdx
callq 0x4f5f
leaq 0x30d2(%rip), %rdx      # 0x706c
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4ec0
leaq -0x58(%rbp), %rdi
callq 0x3110
leaq -0x38(%rbp), %rdi
callq 0x3110
leaq -0x98(%rbp), %rdi
callq 0x3110
movq -0x78(%rbp), %rsi
leaq -0x520(%rbp), %rdi
callq 0x31d0
testl %eax, %eax
je 0x4004
movq 0x6ff8(%rip), %rdi      # 0xafd8
leaq 0x3141(%rip), %rsi      # 0x7128
callq 0x32b0
movq %rax, %rdi
callq 0x3140
leaq -0x520(%rbp), %rdi
callq 0x3370
xorl %ebx, %ebx
jmp 0x401e
leaq -0x520(%rbp), %rdi
callq 0x3470
movq %rax, %rdi
callq 0x32e0
testq %rax, %rax
setne %bl
leaq -0x78(%rbp), %rdi
callq 0x3110
movl %ebx, %eax
addq $0x518, %rsp            # imm = 0x518
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x6f9a(%rip), %rdi      # 0xafd8
leaq 0x2fef(%rip), %rsi      # 0x7034
callq 0x32b0
pushq $0x1
popq %rdi
callq 0x3340
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3110
jmp 0x4063
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3110
jmp 0x4071
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
jmp 0x4081
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/QZzcoder[P]LiveChat/server.cpp
// Function: newUser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool newUser(string name,string password){
    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);
    }
    string sql = "select * from User where name = \"" + name + "\"";
    mysql_query(&mysql_conn,sql.c_str());
    ptr_res = mysql_store_result(&mysql_conn);
    if(!ptr_res){return false;}

    sql = "insert into User values(\""+name+"\",\""+password+"\",0);";
    return !mysql_query(&mysql_conn,sql.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x538, %rsp            # imm = 0x538
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x540(%rbp), %r15
movq %r15, %rdi
callq 0x3130
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
leaq 0x2f5f(%rip), %rsi      # 0x7020
leaq 0x2f62(%rip), %rdx      # 0x702a
leaq 0x71a1(%rip), %rcx      # 0xb270
leaq 0x2f59(%rip), %r8       # 0x702f
movq %r15, %rdi
xorl %r9d, %r9d
callq 0x3170
testq %rax, %rax
je 0x4205
leaq 0x3003(%rip), %rsi      # 0x70f4
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x4ee9
leaq 0x300d(%rip), %rdx      # 0x7114
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x4ec0
leaq -0x38(%rbp), %rdi
callq 0x3110
movq -0x58(%rbp), %rsi
leaq -0x540(%rbp), %rdi
callq 0x31d0
leaq -0x540(%rbp), %rdi
callq 0x3180
testq %rax, %rax
je 0x41ea
leaq 0x2fec(%rip), %rsi      # 0x7134
leaq -0x78(%rbp), %rdi
movq %r14, %rdx
callq 0x4ee9
leaq 0x2ff3(%rip), %rdx      # 0x714e
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x4ec0
leaq -0xb8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
movq %rbx, %rdx
callq 0x4f5f
leaq 0x2fca(%rip), %rdx      # 0x7152
leaq -0x38(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x4ec0
leaq -0x58(%rbp), %rbx
leaq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3350
movq %r14, %rdi
callq 0x3110
leaq -0xb8(%rbp), %rdi
callq 0x3110
leaq -0x98(%rbp), %rdi
callq 0x3110
leaq -0x78(%rbp), %rdi
callq 0x3110
movq (%rbx), %rsi
leaq -0x540(%rbp), %rdi
callq 0x31d0
testl %eax, %eax
sete %bl
jmp 0x41ec
xorl %ebx, %ebx
leaq -0x58(%rbp), %rdi
callq 0x3110
movl %ebx, %eax
addq $0x538, %rsp            # imm = 0x538
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x6dcc(%rip), %rdi      # 0xafd8
leaq 0x2e21(%rip), %rsi      # 0x7034
callq 0x32b0
pushq $0x1
popq %rdi
callq 0x3340
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x3110
jmp 0x4234
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x3110
jmp 0x4245
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3110
jmp 0x425e
jmp 0x425b
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x4262
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5bce
leaq 0x28(%rbx), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5bee
movq 0x68(%rbx), %rax
addq $0x58, %rbx
movl (%rax), %r14d
movq %rbx, %rdi
callq 0x5c26
leaq -0x20(%rbp), %rdi
callq 0x5c4c
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x5c4c
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
leaq 0x1bc7(%rip), %rdi      # 0x4020
movl $0x902, %esi            # imm = 0x902
xorl %eax, %eax
callq 0x2150
movl %eax, %ebx
cmpl $-0x1, %eax
je 0x248f
pushq $0x4
popq %rsi
movl %ebx, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2110
leaq 0x1d47(%rip), %rdi      # 0x41c8
callq 0x2290
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1bdd(%rip), %rdi      # 0x4073
callq 0x2190
jmp 0x2486
// File: /workspace/github_cpp_makefile_star2_O2/pehublove[P]GPS-neo7n-forBaiduMap/test.cpp
// Function: set_speed_and_parity(int, int)
void set_speed_and_parity(int fd, int speed)
{
	int i=0;		//设置循环标志——注意不要在for内设置，否则会出错
	struct termios Opt;	//定义termios结构
	if(tcgetattr(fd,&Opt)!=0)
	{
		perror("tcgetattr fd");
		return;
	}
	tcflush(fd, TCIOFLUSH);
	cfsetispeed(&Opt, speed);
	cfsetospeed(&Opt, speed);
	/*tcsetattr函数标志：
	TCSANOW：立即执行而不等待数据发送或者接受完成。
	TCSADRAIN：等待所有数据传递完成后执行。
	TCSAFLUSH：Flush input and output buffers and make the change
	*/
	if(tcsetattr(fd, TCSANOW, &Opt) != 0)
	{	
		perror("tcsetattr fd");
		return;
	}
	tcflush(fd, TCIOFLUSH);
	//设置奇偶校验——默认8个数据位、没有校验位
        
    	Opt.c_cflag &= ~PARENB;
   	 Opt.c_cflag &= ~CSTOPB;
    	Opt.c_cflag &= ~CSIZE;
    	Opt.c_cflag |= CS8;
	
	//其他的一些配置
	//原始输入，输入字符只是被原封不动的接收
	Opt.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
	//软件流控制无效，因为硬件没有硬件流控制，所以就不需要管了
	Opt.c_iflag &= ~(IXON | IXOFF | IXANY);
	//原始输出方式可以通过在c_oflag中重置OPOST选项来选择：
	Opt.c_oflag |= ~OPOST;
	//VMIN可以指定读取的最小字符数。如果它被设置为0，那么VTIME值则会指定每个字符读取的等待时间。
    	Opt.c_cc[VTIME] = 0;
    	Opt.c_cc[VMIN] = 0;
//    	Opt.c_cflag &= ~INPCK;
//    	Opt.c_cflag |= (CLOCAL | CREAD);
//	
//    	Opt.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
// 
//    	Opt.c_oflag &= ~OPOST;
   	Opt.c_oflag &= ~(ONLCR | OCRNL);    
//
   	Opt.c_iflag &= ~(ICRNL | INLCR);
//    	Opt.c_iflag &= ~(IXON | IXOFF | IXANY);    
//    
//    	Opt.c_cc[VTIME] = 0;
//    	Opt.c_cc[VMIN] = 0;
    
    	tcflush(fd, TCIOFLUSH);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %r14d
movl %edi, %ebx
leaq -0x54(%rbp), %rsi
callq 0x2210
testl %eax, %eax
jne 0x2541
pushq $0x2
popq %rsi
movl %ebx, %edi
callq 0x2270
leaq -0x54(%rbp), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0x2120
movq %r15, %rdi
movl %r14d, %esi
callq 0x2200
movl %ebx, %edi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2220
testl %eax, %eax
jne 0x254a
pushq $0x2
popq %r14
movl %ebx, %edi
movl %r14d, %esi
callq 0x2270
movl $0xfffffe8f, %eax       # imm = 0xFFFFFE8F
andl -0x4c(%rbp), %eax
orl $0x30, %eax
movl %eax, -0x4c(%rbp)
andb $-0x1c, -0x48(%rbp)
movl -0x50(%rbp), %eax
andw $0x0, -0x3e(%rbp)
andl $0x1, %eax
orl $-0xe, %eax
movl %eax, -0x50(%rbp)
andl $0xffffe2bf, -0x54(%rbp) # imm = 0xFFFFE2BF
movl %ebx, %edi
movl %r14d, %esi
callq 0x2270
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b52(%rip), %rdi      # 0x409a
jmp 0x2551
leaq 0x1b56(%rip), %rdi      # 0x40a7
callq 0x2190
jmp 0x2536
// File: /workspace/github_cpp_makefile_star2_O2/pehublove[P]GPS-neo7n-forBaiduMap/test.cpp
// Function: serial_read(int, char*, int)
int serial_read(int fd,char buff[],int datalen)
{
	int nread=0;
	//printf("Ready for receiving data...");
	nread=read(fd,buff,datalen);
	if(nread>0)
	{
	//	printf("readlength=%d\n",nread);
		buff[nread]='\0';
	//	printf("%s\n",buff);
	}
	return nread;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq %edx, %rdx
callq 0x2240
testl %eax, %eax
jle 0x25a3
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movb $0x0, (%rbx,%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pehublove[P]GPS-neo7n-forBaiduMap/test.cpp
// Function: serialport()
int serialport()
{
	int fd;	
	//打开串口
	if((fd=open_port())<0)
    	{
        	perror("open_port error");
        	return 0;
    	}
	//设置波特率和校验位
	set_speed_and_parity(fd,9600);
	return (fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x244c
testl %eax, %eax
js 0x25d0
movl %eax, %ebx
movl %eax, %edi
movl $0x2580, %esi           # imm = 0x2580
callq 0x249d
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1af7(%rip), %rdi      # 0x40ce
callq 0x2190
xorl %ebx, %ebx
jmp 0x25c7
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rdi, -0x30(%rbp)
movq %rdx, -0x48(%rbp)
movq 0x8(%rdx), %rax
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x269d
movq %rsi, %r14
movq 0x8(%rsi), %rax
movq %rax, -0x40(%rbp)
xorl %ebx, %ebx
leaq -0x68(%rbp), %r12
movq -0x40(%rbp), %r15
subq %rbx, %r15
jbe 0x269d
movq %r14, %rdi
movq -0x48(%rbp), %rsi
movq %rbx, %rdx
callq 0x2300
movq %rax, %r13
testl %r13d, %r13d
js 0x2673
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
movq %r13, %rcx
subq %rbx, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21f0
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x2cfe
movq %r12, %rdi
callq 0x20d0
addq -0x38(%rbp), %r13
movq %r13, %rbx
jmp 0x261b
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x21f0
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x2cfe
leaq -0x68(%rbp), %rdi
callq 0x20d0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26ae
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/pehublove[P]GPS-neo7n-forBaiduMap/gpsBaidu.cpp
// Function: GpsBaidu::transformLat(double, double)
double GpsBaidu::transformLat(double x, double y)
{
	double ret = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * sqrt(abs(x));
	ret += (20.0 * sin(6.0 * x * pi) + 20.0 * sin(2.0 * x * pi)) * 2.0 / 3.0;
	ret += (20.0 * sin(y * pi) + 40.0 * sin(y / 3.0 * pi)) * 2.0 / 3.0;
	ret += (160.0 * sin(y / 12.0 * pi) + 320 * sin(y * pi / 30.0)) * 2.0 / 3.0;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm1, -0x10(%rbp)
movapd %xmm0, %xmm2
addsd %xmm0, %xmm2
movapd %xmm2, -0x30(%rbp)
movsd 0x125e(%rip), %xmm3     # 0x41f8
addsd %xmm2, %xmm3
movapd %xmm1, %xmm2
mulsd 0x1256(%rip), %xmm2     # 0x4200
addsd %xmm3, %xmm2
movsd 0x1252(%rip), %xmm4     # 0x4208
movapd %xmm1, %xmm3
mulsd %xmm4, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd 0x1242(%rip), %xmm2     # 0x4210
mulsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
movapd 0x12ee(%rip), %xmm3     # 0x42d0
andpd %xmm0, %xmm3
sqrtsd %xmm3, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, -0x8(%rbp)
mulsd 0x1219(%rip), %xmm0     # 0x4218
mulsd 0x1219(%rip), %xmm0     # 0x4220
callq 0x2060
movsd %xmm0, -0x18(%rbp)
movapd -0x30(%rbp), %xmm0
mulsd 0x1202(%rip), %xmm0     # 0x4220
callq 0x2060
movsd 0x11fd(%rip), %xmm1     # 0x4228
mulsd %xmm1, %xmm0
movsd -0x18(%rbp), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
addsd %xmm0, %xmm0
divsd 0x11b8(%rip), %xmm0     # 0x4200
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd 0x11c1(%rip), %xmm0     # 0x4220
movsd %xmm0, -0x30(%rbp)
callq 0x2060
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
divsd 0x1185(%rip), %xmm0     # 0x4200
mulsd 0x119d(%rip), %xmm0     # 0x4220
callq 0x2060
mulsd 0x11a0(%rip), %xmm0     # 0x4230
movsd -0x18(%rbp), %xmm1
mulsd 0x118b(%rip), %xmm1     # 0x4228
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
divsd 0x1153(%rip), %xmm0     # 0x4200
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
divsd 0x1174(%rip), %xmm0     # 0x4238
mulsd 0x1154(%rip), %xmm0     # 0x4220
callq 0x2060
movsd %xmm0, -0x10(%rbp)
movsd -0x30(%rbp), %xmm0
divsd 0x115d(%rip), %xmm0     # 0x4240
callq 0x2060
mulsd 0x1158(%rip), %xmm0     # 0x4248
movsd -0x10(%rbp), %xmm1
mulsd 0x1153(%rip), %xmm1     # 0x4250
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
divsd 0x10f3(%rip), %xmm0     # 0x4200
addsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pehublove[P]GPS-neo7n-forBaiduMap/gpsBaidu.cpp
// Function: GpsBaidu::transformLon(double, double)
double GpsBaidu::transformLon(double x, double y)
{
	double ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * sqrt(abs(x));
	ret += (20.0 * sin(6.0 * x * pi) + 20.0 * sin(2.0 * x * pi)) * 2.0 / 3.0;
	ret += (20.0 * sin(x * pi) + 40.0 * sin(x / 3.0 * pi)) * 2.0 / 3.0;
	ret += (150.0 * sin(x / 12.0 * pi) + 300.0 * sin(x / 30.0 * pi)) * 2.0 / 3.0;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movapd %xmm0, %xmm5
movapd %xmm0, -0x20(%rbp)
addsd 0x1127(%rip), %xmm0     # 0x4258
movsd 0x10d7(%rip), %xmm2     # 0x4210
movapd %xmm5, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm3, %xmm4
mulsd %xmm1, %xmm3
addsd %xmm1, %xmm1
addsd %xmm0, %xmm1
mulsd %xmm5, %xmm4
addsd %xmm1, %xmm4
addsd %xmm4, %xmm3
movapd 0x116b(%rip), %xmm0     # 0x42d0
andpd %xmm5, %xmm0
sqrtsd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x1096(%rip), %xmm0     # 0x4218
mulsd %xmm5, %xmm0
mulsd 0x1092(%rip), %xmm0     # 0x4220
callq 0x2060
movsd %xmm0, -0x8(%rbp)
movapd -0x20(%rbp), %xmm0
addsd %xmm0, %xmm0
mulsd 0x1077(%rip), %xmm0     # 0x4220
callq 0x2060
movsd 0x1072(%rip), %xmm1     # 0x4228
mulsd %xmm1, %xmm0
movsd -0x8(%rbp), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
addsd %xmm0, %xmm0
divsd 0x102d(%rip), %xmm0     # 0x4200
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movapd -0x20(%rbp), %xmm0
mulsd 0x1036(%rip), %xmm0     # 0x4220
callq 0x2060
movsd %xmm0, -0x8(%rbp)
movapd -0x20(%rbp), %xmm0
divsd 0xfff(%rip), %xmm0      # 0x4200
mulsd 0x1017(%rip), %xmm0     # 0x4220
callq 0x2060
mulsd 0x101a(%rip), %xmm0     # 0x4230
movsd -0x8(%rbp), %xmm1
mulsd 0x1005(%rip), %xmm1     # 0x4228
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
divsd 0xfcd(%rip), %xmm0      # 0x4200
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movapd -0x20(%rbp), %xmm0
divsd 0xfee(%rip), %xmm0      # 0x4238
mulsd 0xfce(%rip), %xmm0      # 0x4220
callq 0x2060
movsd %xmm0, -0x8(%rbp)
movapd -0x20(%rbp), %xmm0
divsd 0xfd7(%rip), %xmm0      # 0x4240
mulsd 0xfaf(%rip), %xmm0      # 0x4220
callq 0x2060
mulsd 0xfda(%rip), %xmm0      # 0x4258
movsd -0x8(%rbp), %xmm1
mulsd 0xfd5(%rip), %xmm1      # 0x4260
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
divsd 0xf65(%rip), %xmm0      # 0x4200
addsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pehublove[P]GPS-neo7n-forBaiduMap/gpsBaidu.cpp
// Function: GpsBaidu::gps_transform(double, double, double&, double&)
void GpsBaidu::gps_transform( double wgLat, double wgLon, double& mgLat, double& mgLon)
{
	double dLat = transformLat(wgLon - 105.0, wgLat - 35.0);
	double dLon = transformLon(wgLon - 105.0, wgLat - 35.0);
	double radLat = wgLat / 180.0 * pi;
       	double magic = sin(radLat);
	magic = 1 - ee * magic * magic;
       	double sqrtMagic = sqrt(magic);
	dLat = (dLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * pi);
	dLon = (dLon * 180.0) / (a / sqrtMagic * cos(radLat) * pi);
	mgLat = wgLat + dLat;
       	mgLon = wgLon + dLon;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, -0x38(%rbp)
movsd 0xfa4(%rip), %xmm2      # 0x4268
movsd %xmm1, -0x40(%rbp)
addsd %xmm1, %xmm2
movsd %xmm2, -0x18(%rbp)
movsd 0xf96(%rip), %xmm1      # 0x4270
addsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movapd %xmm2, %xmm0
callq 0x2f78
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x3118
movsd %xmm0, -0x18(%rbp)
movsd -0x38(%rbp), %xmm0
divsd 0xf66(%rip), %xmm0      # 0x4278
mulsd 0xf06(%rip), %xmm0      # 0x4220
movsd %xmm0, -0x28(%rbp)
callq 0x2060
movsd 0xf54(%rip), %xmm3      # 0x4280
mulsd %xmm0, %xmm3
mulsd %xmm0, %xmm3
addsd 0xf4c(%rip), %xmm3      # 0x4288
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
jb 0x334c
sqrtsd %xmm3, %xmm0
jmp 0x335f
movapd %xmm3, %xmm0
movsd %xmm3, -0x20(%rbp)
callq 0x2170
movsd -0x20(%rbp), %xmm3
movsd 0xf11(%rip), %xmm1      # 0x4278
movsd -0x30(%rbp), %xmm2
mulsd %xmm1, %xmm2
movapd %xmm2, %xmm4
mulsd %xmm0, %xmm3
movsd 0xf10(%rip), %xmm2      # 0x4290
divsd %xmm3, %xmm2
mulsd 0xe94(%rip), %xmm2      # 0x4220
divsd %xmm2, %xmm4
movsd %xmm4, -0x30(%rbp)
movsd -0x18(%rbp), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, -0x18(%rbp)
movsd 0xeed(%rip), %xmm1      # 0x4298
divsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x22e0
mulsd -0x20(%rbp), %xmm0
mulsd 0xe55(%rip), %xmm0      # 0x4220
movsd -0x18(%rbp), %xmm1
divsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, (%r14)
addsd -0x40(%rbp), %xmm1
movsd %xmm1, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pehublove[P]GPS-neo7n-forBaiduMap/gpsBaidu.cpp
// Function: GpsBaidu::bd_encrypt(double, double, double&, double&)
void GpsBaidu::bd_encrypt(double gg_lat, double gg_lon, double &bd_lat, double &bd_lon)
{
	double x = gg_lon, y = gg_lat;
	double z = sqrt(x * x + y * y) + 0.00002 * sin(y * x_pi);
	double theta = atan2(y, x) + 0.000003 * cos(x * x_pi);
	bd_lon = z * cos(theta) + 0.0065;
	bd_lat = z * sin(theta) + 0.006;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd %xmm1, -0x18(%rbp)
movapd %xmm0, %xmm3
movsd %xmm0, -0x28(%rbp)
mulsd %xmm0, %xmm0
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
sqrtsd %xmm2, %xmm0
movsd %xmm0, -0x20(%rbp)
mulsd 0xe6a(%rip), %xmm3      # 0x42a0
movapd %xmm3, %xmm0
callq 0x2060
mulsd 0xe61(%rip), %xmm0      # 0x42a8
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x2050
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
mulsd 0xe2e(%rip), %xmm0      # 0x42a0
callq 0x22e0
mulsd 0xe31(%rip), %xmm0      # 0x42b0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x22e0
mulsd -0x20(%rbp), %xmm0
addsd 0xe1d(%rip), %xmm0      # 0x42b8
movsd %xmm0, (%r14)
movsd -0x18(%rbp), %xmm0
callq 0x2060
mulsd -0x20(%rbp), %xmm0
addsd 0xe09(%rip), %xmm0      # 0x42c0
movsd %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH09_SequentialContainers/examples/useConvs.cc
// Function: main
int main()
{
    int i = 42;
    // converts the int i to its character representation
    string s = to_string(i);

    double d = stod(s);   // converts the string s to floating-point
    cout << "i = " << i << " s = " << s << " d is: " << d << endl;

    // convert the first substring in s that starts with a digit,  d = 3.14
    string s2 = "pi = 3.14";
    d = stod(s2.substr(s2.find_first_of("+-.0123456789")));

    cout << "d = " << d << " s = " << s << " s2 is: " << s2 << endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
leaq -0x70(%rbp), %rbx
pushq $0x2a
popq %rsi
movq %rbx, %rdi
callq 0x13f1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1451
movsd %xmm0, -0x10(%rbp)
movq 0x2d3e(%rip), %rdi      # 0x3fd8
leaq 0xd63(%rip), %rsi       # 0x2004
callq 0x10b0
pushq $0x2a
popq %rsi
movq %rax, %rdi
callq 0x1110
leaq 0xd51(%rip), %rsi       # 0x2009
movq %rax, %rdi
callq 0x10b0
leaq -0x70(%rbp), %rsi
movq %rax, %rdi
callq 0x10a0
leaq 0xd3c(%rip), %rsi       # 0x200f
movq %rax, %rdi
callq 0x10b0
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x1100
movq %rax, %rdi
callq 0x1060
leaq 0xd20(%rip), %rsi       # 0x2017
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x1040
leaq 0xd16(%rip), %rsi       # 0x2021
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1070
leaq -0x30(%rbp), %rdi
pushq $-0x1
popq %rcx
movq %rbx, %rsi
movq %rax, %rdx
callq 0x10c0
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x1451
movsd %xmm0, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1050
movq 0x2c8d(%rip), %rdi      # 0x3fd8
leaq 0xcdd(%rip), %rsi       # 0x202f
callq 0x10b0
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x1100
leaq 0xc9e(%rip), %rsi       # 0x2009
movq %rax, %rdi
callq 0x10b0
leaq -0x70(%rbp), %rsi
movq %rax, %rdi
callq 0x10a0
leaq 0xcae(%rip), %rsi       # 0x2034
movq %rax, %rdi
callq 0x10b0
leaq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x10a0
movq %rax, %rdi
callq 0x1060
leaq -0x50(%rbp), %rdi
callq 0x1050
leaq -0x70(%rbp), %rdi
callq 0x1050
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x1050
jmp 0x13d2
jmp 0x13cf
jmp 0x13dd
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1050
jmp 0x13e0
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O2/dtsaras[P]GCW/./hypergraph.hpp
// Function: addHyperedge(Graph&, HyperGraph&, int, long long, bool, sampler<int>&, int)
long long addHyperedge(Graph & g, HyperGraph & hg, int t, long long num, bool lt, sampler<int> &samp, int p)
{
	int numNodes = g.getSize();

	omp_set_num_threads(t);
	
	long long iter = 0;
	int c = 100;
	// cout << "@@@@@@@@@@ 1" << endl;
    #pragma omp parallel
	{
		vector<int> visit_mark(numNodes+1,0);
		vector<bool> visit(numNodes+1,false);
		vector<unsigned int> link;
		// cout << "@@@@@@@@@@ 2" << endl;     
		if (lt == 0){
			while (iter < num){
				// cout << "@@@@@@@@@@ 3" << endl;
            	for (int i = 0; i < c; ++i){
					vector<int> he;
           	        hg.pollingLT1(g,visit,visit_mark, samp, p);
               	}
               	// cout << "@@@@@@@@@@ 4" << endl;
				#pragma omp atomic
				iter += c;
			}
		} else {
			while (iter < num){
                for (int i = 0; i < c; ++i){
                    vector<int> he;
                    hg.pollingIC1(g,visit,visit_mark, samp, p);
                }
                #pragma omp atomic
                iter += c;
        	}
		}
	}
	// cout << "@@@@@@@@@@ 5" << endl;
	hg.updateDeg();
	// cout << "@@@@@@@@@@ 6" << endl;
	return hg.getNumEdge();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r14
movl %r8d, %r15d
movq %rcx, 0x28(%rsp)
movq %rsi, %rbx
movq %rdi, %r12
callq 0xba86
incl %eax
movslq %eax, %r13
leaq 0x60(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rbp
movq %r13, %rsi
movq %rbp, %rcx
callq 0x83b6
movb $0x0, (%rbp)
leaq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r13, %rsi
callq 0x840c
movl 0xc0(%rsp), %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
xorl %eax, %eax
leaq 0x10(%rsp), %r13
testb %r15b, %r15b
je 0x3909
cmpq 0x28(%rsp), %rax
jge 0x395d
movq %rax, 0x8(%rsp)
pushq $0x64
popq %r15
subl $0x1, %r15d
jb 0x38fe
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
leaq 0x60(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movq %r14, %r8
movl %ebp, %r9d
callq 0xced6
movq %r13, %rdi
callq 0x90a0
jmp 0x38c5
movq 0x8(%rsp), %rax
addq $0x64, %rax
jmp 0x38b1
cmpq 0x28(%rsp), %rax
jge 0x395d
movq %rax, 0x8(%rsp)
pushq $0x64
popq %r15
subl $0x1, %r15d
jb 0x3952
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
leaq 0x60(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movq %r14, %r8
movl %ebp, %r9d
callq 0xcbe2
movq %r13, %rdi
callq 0x90a0
jmp 0x3919
movq 0x8(%rsp), %rax
addq $0x64, %rax
jmp 0x3909
leaq 0x30(%rsp), %rdi
callq 0x9066
leaq 0x60(%rsp), %rdi
callq 0x8470
leaq 0x48(%rsp), %rdi
callq 0x90a0
movq %rbx, %rdi
callq 0xc854
movq %rbx, %rdi
callq 0xca4e
cltq
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x39c7
jmp 0x39a6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x90a0
leaq 0x30(%rsp), %rdi
callq 0x9066
leaq 0x60(%rsp), %rdi
callq 0x8470
leaq 0x48(%rsp), %rdi
callq 0x90a0
movq %rbx, %rdi
callq 0x3590