LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Player.cpp
// Function: Player::Take(int, Market&, Deck&)
void Player::Take(int location, Market &M, Deck &D){
    //check the current size of hand cards: not exceed 7 
    if (size[0] < 7){
        //take the card,update card size
        setHand(M.getGoods(location));
        M.delGoods(location);
        //draw a card from deck to market
        M.setGoods(D);
    }
    else
        cout << "Take: Cannot take card: already 7 cards!" << endl;
}

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x28(%rsp)
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
movq %rsi, %rdi
callq 0x96f6
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
testl %eax, %eax
jle 0xb1c4
movl %eax, %ebp
xorl %edx, %edx
leaq 0x78(%rsp), %r12
leaq 0x58(%rsp), %r13
leaq 0x38(%rsp), %r15
incl %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x96fa
movq %r13, %rdi
movq %r12, %rsi
callq 0x92fe
movq %r13, %rdi
leaq 0x505e(%rip), %rsi      # 0x1017e
callq 0x2080
movl %eax, %ebx
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0xb143
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x21a0
testl %ebx, %ebx
jne 0xb1aa
leaq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x3f5e
movq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0xa626
movq %r15, %rdi
callq 0x92e2
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0xb19b
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0xb1aa
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0xc2ac
movq %r12, %rdi
callq 0x92e2
movl 0xc(%rsp), %edx
incl %edx
movl %edx, 0xc(%rsp)
cmpl %ebp, %edx
jl 0xb0fe
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rbx
subq %rax, %rbx
sarq $0x2, %rbx
cmpq %rax, %rcx
je 0xb281
movl (%rax), %esi
incl %esi
movq %r14, %rdi
callq 0x97c0
movl $0x1, 0xc(%rsp)
cmpl $0x2, %ebx
jl 0xb237
movl $0x1, %eax
movslq %eax, %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rsi, %rcx
jbe 0xb26d
movl (%rax,%rsi,4), %eax
subl %esi, %eax
incl %eax
movq %r14, %rdi
movl %eax, %esi
callq 0x97c0
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl %ebx, %eax
jl 0xb1ff
movq %r14, %rdi
movq 0x28(%rsp), %rsi
callq 0x97e0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xb25b
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %rbx
leaq 0x50d1(%rip), %rdi      # 0x10348
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21f0
xorl %esi, %esi
jmp 0xb270
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x92e2
jmp 0xb2a2
jmp 0xb29f
jmp 0xb29a
jmp 0xb29a
movq %rax, %rbx
jmp 0xb2ac
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x92e2
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xb2c3
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Game.cpp
// Function: Game::Game(Deck&, Market&, Human&, Human&)
Game::Game(Deck &dd, Market &mm, Human &pp1, Human &pp2) : deck(dd), market(mm), p1(pp1), p2(pp2) { //construct a game for Human vs. Human
    bonus.shuffle();//initialize all bonus
    setRound(1);//initialize round to 1
    setTurn(1);//initialize turn to 1
    srand(time(NULL));
    /*for demo*/

    currplayer = 1;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x10(%rbx), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0xa912
negl %eax
movq %r15, %rdi
movl %r14d, %esi
movl %eax, %edx
callq 0xa5e8
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %r15
movl %r14d, %esi
callq 0xa912
negl %eax
movq %r15, %rdi
movl %r14d, %esi
movl %eax, %edx
callq 0xa5e8
incl %r14d
cmpl $0x3, %r14d
jne 0xca83
movl $0x1, 0x84(%rbx)
movl %ebp, 0x88(%rbx)
movq (%rbx), %rdi
callq 0x85d2
movq (%rbx), %rdi
callq 0x8c08
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
callq 0x9568
leaq 0x20(%rbx), %rdi
callq 0x514a
leaq 0x58(%rbx), %rdi
callq 0x7038
movq (%rbx), %rsi
movq 0x10(%rbx), %rdi
callq 0xa3c4
movq (%rbx), %rsi
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa3c4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x36a6(%rip), %rdi      # 0x10a9b
callq 0x2140
leaq 0x20(%rbx), %rdi
callq 0x56d8
leaq 0x58(%rbx), %rdi
callq 0x760e
movq 0x8(%rbx), %rdi
callq 0x988e
movq %r14, %rdi
callq 0xb2cc
movq 0x8bac(%rip), %r14      # 0x15fd0
leaq 0x3676(%rip), %rsi      # 0x10aa1
movl $0x5b, %edx
movq %r14, %rdi
callq 0x21d0
movl 0x80(%rbx), %esi
movq %r14, %rdi
callq 0x2270
movq %rax, %r14
leaq 0x36ad(%rip), %rsi      # 0x10afd
movl $0x6, %edx
movq %rax, %rdi
callq 0x21d0
movl 0x84(%rbx), %esi
movq %r14, %rdi
callq 0x2270
movq %rax, %rbx
leaq 0x368f(%rip), %rsi      # 0x10b04
movl $0x59, %edx
movq %rax, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Game.cpp
// Function: Game::roundWinner()
int Game::roundWinner(){
    

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl $0x2, %esi
callq 0xa912
movl %eax, %ebp
movq 0x18(%r14), %rdi
movl $0x2, %esi
callq 0xa912
movl $0x1, %ebx
cmpl %eax, %ebp
jg 0xd847
movq 0x10(%r14), %rdi
movl $0x2, %esi
callq 0xa912
movl %eax, %ebp
movq 0x18(%r14), %rdi
movl $0x2, %esi
callq 0xa912
cmpl %eax, %ebp
jge 0xd823
movl $0x2, %ebx
jmp 0xd847
movq 0x10(%r14), %rcx
movq 0x18(%r14), %rax
movl 0x5c(%rax), %edx
cmpl %edx, 0x5c(%rcx)
jg 0xd847
movl $0x2, %ebx
jl 0xd847
movl 0x58(%rcx), %ecx
xorl %ebx, %ebx
cmpl 0x58(%rax), %ecx
setle %bl
incl %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
subq $0x48, %rsp
movl (%rdx), %edx
leal -0x1(%rdx), %ebp
cmpl $0x4, %ebp
ja 0xe4c4
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x96fa
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x92fe
leaq 0x1ccb(%rip), %rsi      # 0x1017e
leaq 0x8(%rsp), %rdi
callq 0x2080
testl %eax, %eax
setne %bl
jmp 0xe4c6
xorl %ebx, %ebx
cmpl $0x4, %ebp
ja 0xe4f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe4e6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x28(%rsp), %rdi
callq 0x92e2
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x92e2
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/ruippeixotog[P]algo-lib/knuth-morris-pratt.cpp
// Function: kmp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<int, std::allocator<int>>&)
void kmp(string str, string pattern, vector<int>& res) {
  res.clear();

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x129d
movq %rax, 0x8(%rbx)
movl $0x0, 0x2e29(%rip)      # 0x40d0
movq 0x8(%r14), %rax
leaq 0x2e1e(%rip), %r13      # 0x40d0
cmpq $0x2, %rax
jb 0x12fa
movq (%r14), %rcx
movl $0x1, %edx
movl %edx, %esi
movslq %esi, %rsi
movslq -0x4(%r13,%rsi,4), %rsi
movl %esi, (%r13,%rdx,4)
testq %rsi, %rsi
jle 0x12e1
movq (%r14), %rdi
movb (%rdi,%rdx), %r8b
cmpb (%rdi,%rsi), %r8b
jne 0x12c2
movb (%rcx,%rdx), %dil
cmpb (%rcx,%rsi), %dil
jne 0x12f2
incl %esi
movl %esi, (%r13,%rdx,4)
incq %rdx
cmpq %rax, %rdx
jne 0x12c0
cmpq $0x0, 0x8(%r15)
je 0x137e
xorl %ebp, %ebp
xorl %eax, %eax
testl %eax, %eax
jle 0x1324
movq (%r15), %rcx
movb (%rcx,%rbp), %cl
movq (%r14), %rdx
movl %eax, %esi
cmpb (%rdx,%rsi), %cl
je 0x1324
decl %eax
movl (%r13,%rax,4), %eax
testl %eax, %eax
jg 0x1312
movq (%r15), %rcx
movb (%rcx,%rbp), %cl
cltq
movq (%r14), %rdx
xorl %esi, %esi
cmpb (%rdx,%rax), %cl
sete %sil
addl %esi, %eax
movslq %eax, %r12
cmpq %r12, 0x8(%r14)
jne 0x1375
movl %ebp, %ecx
subl %eax, %ecx
incl %ecx
movl %ecx, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1363
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1370
movq %rbx, %rdi
leaq 0x4(%rsp), %rdx
callq 0x154c
movl -0x4(%r13,%r12,4), %eax
incq %rbp
cmpq %rbp, 0x8(%r15)
ja 0x1305
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ruippeixotog[P]algo-lib/knuth-morris-pratt.cpp
// Function: main
int main() {
  vector<int> res;
  kmp("AABAACAADAABAAABAA", "AABA", res);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc4a(%rip), %rsi       # 0x2004
leaq 0xc55(%rip), %rdx       # 0x2016
leaq 0x40(%rsp), %rdi
callq 0x1680
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc3c(%rip), %rsi       # 0x2017
leaq 0xc39(%rip), %rdx       # 0x201b
leaq 0x20(%rsp), %rdi
callq 0x1680
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0x127c
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x140d
callq 0x10b0
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x141c
callq 0x10b0
movq 0x2bb5(%rip), %rbx      # 0x3fd8
leaq 0xbf2(%rip), %rsi       # 0x201c
movl $0x10, %edx
movq %rbx, %rdi
callq 0x10e0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x10c0
movsbl %al, %esi
movq 0x2b83(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq 0x2b6f(%rip), %rbx      # 0x3fd8
leaq 0xbbd(%rip), %rsi       # 0x202d
movl $0xa, %edx
movq %rbx, %rdi
callq 0x10e0
movq (%rsp), %r12
movq 0x8(%rsp), %r13
cmpq %r13, %r12
je 0x14be
movq 0x2b46(%rip), %r14      # 0x3fd8
leaq 0xb9d(%rip), %r15       # 0x2036
movl (%r12), %esi
movq %r14, %rdi
callq 0x1110
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x10e0
addq $0x4, %r12
cmpq %r13, %r12
jne 0x1499
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x10c0
movsbl %al, %esi
movq 0x2afc(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x14f7
callq 0x10b0
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x151e
callq 0x10b0
jmp 0x151e
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x1536
callq 0x10b0
jmp 0x1536
jmp 0x1533
jmp 0x1533
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1544
callq 0x10b0
movq %rbx, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d04(%rip), %rbx      # 0x4fd8
leaq 0xd29(%rip), %rsi       # 0x3004
movq %rbx, %rdi
callq 0x20c0
leaq 0xd32(%rip), %rsi       # 0x301c
movq %rbx, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O1/hdlguy[P]fft_demo/demo.cpp
// Function: window(std::vector<double, std::allocator<double>>*)
void window(vector<double> *vec) 
{
    // Hamming.
    //const double a = 0.54;
    //const double b = 1.0 - a;
    //vector<double>::size_type n = vec->size();
    //for(int i=0; i<n; i++) (*vec)[i] *= a - b*cos(2.0*M_PI*i/(n-1));

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r14
movq %rdi, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x6ce0
movb $0x1, 0x8(%r14)
movq 0x88(%rbx), %rax
cmpq 0x68(%rbx), %rax
jne 0x6186
leaq 0x28(%rbx), %r14
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x30b0
movq 0x88(%rbx), %rax
cmpq 0x68(%rbx), %rax
je 0x616e
movq 0x68(%rbx), %rax
addq $0x58, %rbx
movl (%rax), %r14d
movq %rbx, %rdi
callq 0x6c72
leaq -0x28(%rbp), %rdi
callq 0x6cc6
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1be7(%rip), %rdi      # 0x4020
movl $0x902, %esi            # imm = 0x902
xorl %eax, %eax
callq 0x2130
movl %eax, %ebx
cmpl $-0x1, %eax
je 0x2471
movl %ebx, %edi
movl $0x4, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x20e0
leaq 0x1d65(%rip), %rdi      # 0x41c8
callq 0x2270
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1bfb(%rip), %rdi      # 0x4073
callq 0x2180
jmp 0x2468
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21f0
testl %eax, %eax
jne 0x2526
movl %ebx, %edi
movl $0x2, %esi
callq 0x2250
leaq -0x54(%rbp), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0x20f0
movq %r15, %rdi
movl %r14d, %esi
callq 0x21e0
movl %ebx, %edi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2210
testl %eax, %eax
jne 0x252f
movl %ebx, %edi
movl $0x2, %esi
callq 0x2250
movl $0xfffffe8f, %eax       # imm = 0xFFFFFE8F
andl -0x4c(%rbp), %eax
orl $0x30, %eax
movl %eax, -0x4c(%rbp)
andb $-0x1c, -0x48(%rbp)
movl -0x50(%rbp), %eax
orl $-0xe, %eax
movw $0x0, -0x3e(%rbp)
andl $-0xd, %eax
movl %eax, -0x50(%rbp)
andl $0xffffe2bf, -0x54(%rbp) # imm = 0xFFFFE2BF
movl %ebx, %edi
movl $0x2, %esi
callq 0x2250
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b6d(%rip), %rdi      # 0x409a
jmp 0x2536
leaq 0x1b71(%rip), %rdi      # 0x40a7
callq 0x2180
jmp 0x251b
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2220
testl %eax, %eax
jle 0x2588
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_O1/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 0x242c
testl %eax, %eax
js 0x25b5
movl %eax, %ebx
movl %eax, %edi
movl $0x2580, %esi           # imm = 0x2580
callq 0x247f
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1b12(%rip), %rdi      # 0x40ce
callq 0x2180
xorl %ebx, %ebx
jmp 0x25ac
// File: /workspace/github_cpp_makefile_star2_O1/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, -0x50(%rbp)
movq %rdx, -0x70(%rbp)
movq 0x8(%rdx), %rax
movq %rax, -0x58(%rbp)
testq %rax, %rax
je 0x26c3
movq %rsi, %rbx
movq 0x8(%rsi), %rax
movq %rax, -0x68(%rbp)
xorl %r15d, %r15d
movq %rsi, -0x60(%rbp)
movq -0x68(%rbp), %r12
subq %r15, %r12
jbe 0x26c3
movq -0x70(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x22a0
movq %rax, %r13
testl %r13d, %r13d
js 0x267c
movl %r13d, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
movq %r12, %rcx
subq %r15, %rcx
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x21d0
movq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x2fdc
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2673
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
addq -0x58(%rbp), %r12
movq %r12, %r15
jmp 0x26b6
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x21d0
movq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x2fdc
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x26b6
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
testl %r13d, %r13d
movq -0x60(%rbp), %rbx
jns 0x2601
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26d4
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x26f0
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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
movapd %xmm0, %xmm3
movapd %xmm0, %xmm2
addsd %xmm0, %xmm2
movsd 0xf80(%rip), %xmm0      # 0x41f8
movapd %xmm2, -0x30(%rbp)
addsd %xmm2, %xmm0
movsd 0xf77(%rip), %xmm2      # 0x4200
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
movsd 0xf6f(%rip), %xmm0      # 0x4208
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movsd 0xf63(%rip), %xmm2      # 0x4210
mulsd %xmm3, %xmm2
movsd %xmm1, -0x10(%rbp)
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
movapd 0x100a(%rip), %xmm0     # 0x42d0
andpd %xmm3, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x32da
sqrtsd %xmm0, %xmm0
jmp 0x32f3
movapd %xmm3, -0x20(%rbp)
movsd %xmm2, -0x8(%rbp)
callq 0x2160
movsd -0x8(%rbp), %xmm2
movapd -0x20(%rbp), %xmm3
mulsd 0xf0d(%rip), %xmm0      # 0x4208
addsd %xmm2, %xmm0
movsd %xmm0, -0x20(%rbp)
mulsd 0xf0c(%rip), %xmm3      # 0x4218
mulsd 0xf0c(%rip), %xmm3      # 0x4220
movapd %xmm3, %xmm0
callq 0x2070
movsd %xmm0, -0x8(%rbp)
movapd -0x30(%rbp), %xmm0
mulsd 0xef1(%rip), %xmm0      # 0x4220
callq 0x2070
movsd 0xeec(%rip), %xmm1      # 0x4228
mulsd %xmm1, %xmm0
movsd -0x8(%rbp), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
addsd %xmm0, %xmm0
divsd 0xea7(%rip), %xmm0      # 0x4200
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd 0xeb0(%rip), %xmm0      # 0x4220
movsd %xmm0, -0x30(%rbp)
callq 0x2070
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
divsd 0xe74(%rip), %xmm0      # 0x4200
mulsd 0xe8c(%rip), %xmm0      # 0x4220
callq 0x2070
mulsd 0xe8f(%rip), %xmm0      # 0x4230
movsd -0x8(%rbp), %xmm1
mulsd 0xe7a(%rip), %xmm1      # 0x4228
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
divsd 0xe42(%rip), %xmm0      # 0x4200
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
divsd 0xe63(%rip), %xmm0      # 0x4238
mulsd 0xe43(%rip), %xmm0      # 0x4220
callq 0x2070
movsd %xmm0, -0x10(%rbp)
movsd -0x30(%rbp), %xmm0
divsd 0xe4c(%rip), %xmm0      # 0x4240
callq 0x2070
mulsd 0xe47(%rip), %xmm0      # 0x4248
movsd -0x10(%rbp), %xmm1
mulsd 0xe42(%rip), %xmm1      # 0x4250
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
divsd 0xde2(%rip), %xmm0      # 0x4200
addsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %xmm3
movsd 0xe1a(%rip), %xmm0      # 0x4258
addsd %xmm3, %xmm0
movsd 0xdc6(%rip), %xmm4      # 0x4210
mulsd %xmm3, %xmm4
movapd %xmm4, %xmm2
mulsd %xmm1, %xmm4
addsd %xmm1, %xmm1
addsd %xmm0, %xmm1
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
addsd %xmm2, %xmm4
movapd 0xe5e(%rip), %xmm0      # 0x42d0
movapd %xmm3, -0x20(%rbp)
andpd %xmm3, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x348b
sqrtsd %xmm0, %xmm0
jmp 0x349a
movsd %xmm4, -0x8(%rbp)
callq 0x2160
movsd -0x8(%rbp), %xmm4
mulsd 0xd6e(%rip), %xmm0      # 0x4210
addsd %xmm4, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd 0xd65(%rip), %xmm0      # 0x4218
mulsd -0x20(%rbp), %xmm0
mulsd 0xd60(%rip), %xmm0      # 0x4220
callq 0x2070
movsd %xmm0, -0x10(%rbp)
movapd -0x20(%rbp), %xmm0
addsd %xmm0, %xmm0
mulsd 0xd45(%rip), %xmm0      # 0x4220
callq 0x2070
movsd 0xd40(%rip), %xmm1      # 0x4228
mulsd %xmm1, %xmm0
movsd -0x10(%rbp), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
addsd %xmm0, %xmm0
divsd 0xcfb(%rip), %xmm0      # 0x4200
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movapd -0x20(%rbp), %xmm0
mulsd 0xd04(%rip), %xmm0      # 0x4220
callq 0x2070
movsd %xmm0, -0x10(%rbp)
movapd -0x20(%rbp), %xmm0
divsd 0xccd(%rip), %xmm0      # 0x4200
mulsd 0xce5(%rip), %xmm0      # 0x4220
callq 0x2070
mulsd 0xce8(%rip), %xmm0      # 0x4230
movsd -0x10(%rbp), %xmm1
mulsd 0xcd3(%rip), %xmm1      # 0x4228
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
divsd 0xc9b(%rip), %xmm0      # 0x4200
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movapd -0x20(%rbp), %xmm0
divsd 0xcbc(%rip), %xmm0      # 0x4238
mulsd 0xc9c(%rip), %xmm0      # 0x4220
callq 0x2070
movsd %xmm0, -0x10(%rbp)
movapd -0x20(%rbp), %xmm0
divsd 0xca5(%rip), %xmm0      # 0x4240
mulsd 0xc7d(%rip), %xmm0      # 0x4220
callq 0x2070
mulsd 0xca8(%rip), %xmm0      # 0x4258
movsd -0x10(%rbp), %xmm1
mulsd 0xca3(%rip), %xmm1      # 0x4260
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
divsd 0xc33(%rip), %xmm0      # 0x4200
addsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc72(%rip), %xmm2      # 0x4268
movsd %xmm1, -0x40(%rbp)
addsd %xmm1, %xmm2
movsd %xmm2, -0x18(%rbp)
movsd 0xc64(%rip), %xmm1      # 0x4270
addsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movapd %xmm2, %xmm0
callq 0x325c
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x342a
movsd %xmm0, -0x18(%rbp)
movsd -0x38(%rbp), %xmm0
divsd 0xc34(%rip), %xmm0      # 0x4278
mulsd 0xbd4(%rip), %xmm0      # 0x4220
movsd %xmm0, -0x28(%rbp)
callq 0x2070
movsd 0xc22(%rip), %xmm3      # 0x4280
mulsd %xmm0, %xmm3
mulsd %xmm0, %xmm3
addsd 0xc1a(%rip), %xmm3      # 0x4288
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
jb 0x3681
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
jmp 0x3694
movapd %xmm3, %xmm0
movsd %xmm3, -0x20(%rbp)
callq 0x2160
movsd -0x20(%rbp), %xmm3
movsd 0xbdc(%rip), %xmm1      # 0x4278
movsd -0x30(%rbp), %xmm2
mulsd %xmm1, %xmm2
movapd %xmm2, %xmm4
mulsd %xmm0, %xmm3
movsd 0xbdb(%rip), %xmm2      # 0x4290
divsd %xmm3, %xmm2
mulsd 0xb5f(%rip), %xmm2      # 0x4220
divsd %xmm2, %xmm4
movsd %xmm4, -0x30(%rbp)
movsd -0x18(%rbp), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, -0x18(%rbp)
movsd 0xbb8(%rip), %xmm1      # 0x4298
divsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x22d0
mulsd -0x20(%rbp), %xmm0
mulsd 0xb20(%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
// File: /workspace/github_cpp_makefile_star2_O1/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 %xmm0, -0x20(%rbp)
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movsd %xmm1, -0x28(%rbp)
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3769
sqrtsd %xmm0, %xmm0
jmp 0x376e
callq 0x2160
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd 0xb20(%rip), %xmm0      # 0x42a0
callq 0x2070
mulsd 0xb1b(%rip), %xmm0      # 0x42a8
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x2060
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
mulsd 0xae8(%rip), %xmm0      # 0x42a0
callq 0x22d0
mulsd 0xaeb(%rip), %xmm0      # 0x42b0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x22d0
mulsd -0x18(%rbp), %xmm0
addsd 0xad7(%rip), %xmm0      # 0x42b8
movsd %xmm0, (%r14)
movsd -0x28(%rbp), %xmm0
callq 0x2070
mulsd -0x18(%rbp), %xmm0
addsd 0xac3(%rip), %xmm0      # 0x42c0
movsd %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/GCW.cpp
// Function: create_dist(Graph&, int, std::vector<float, std::allocator<float>>&)
void create_dist(Graph & g, int p, vector<float> &RR_user_Prs){
	float IP;
	float not_AP;
	// cout << "Event: " << p << endl; 
	for(int v = 1; v <= g.getSize(); v++){
		not_AP = 1.0;
		map<double, int>::iterator it = g.A[v].begin();
		while (it->second != p and not_AP != 0){
			not_AP *= 1 - g.AP[it->second][v]; //Probability not influenced by the stronger competitors
			++it;
		}
		// if (v <= g.getSize()){
		// 	cout << v << " " << not_AP << endl;
		// }
		IP = (g.similarities[v][p]/g.tsim_V_p[p]) * not_AP;
		RR_user_Prs[v - 1] = IP;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movl %esi, %ebp
movq %rdi, %r14
callq 0xe16e
testl %eax, %eax
jle 0x5736
movslq %ebp, %r15
movl $0x1, %r12d
movq 0xaf8(%r14), %rax
leaq (%r12,%r12,2), %r13
movq %r13, %rcx
shlq $0x4, %rcx
movq 0x18(%rax,%rcx), %rax
movl 0x28(%rax), %ecx
movsd 0x129e3(%rip), %xmm0    # 0x18070
cmpl %ebp, %ecx
je 0x56e3
movq 0xb18(%r14), %rbx
movss 0x12a1c(%rip), %xmm0    # 0x180bc
movslq %ecx, %rcx
movq (%rbx,%rcx,8), %rcx
movss 0x12a0d(%rip), %xmm1    # 0x180bc
subss (%rcx,%r12,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movq %rax, %rdi
callq 0x3250
movss 0xc(%rsp), %xmm0
movl 0x28(%rax), %ecx
cmpl %ebp, %ecx
je 0x56df
ucomiss 0x129ed(%rip), %xmm0    # 0x180c8
jne 0x56a0
jp 0x56a0
cvtss2sd %xmm0, %xmm0
movq 0xae0(%r14), %rax
movq 0xb00(%r14), %rcx
movq (%rax,%r13,8), %rax
movsd (%rax,%r15,8), %xmm1
divsd (%rcx,%r15,8), %xmm1
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movss %xmm0, -0x4(%rax,%r12,4)
leaq 0x1(%r12), %rbx
movq %r14, %rdi
callq 0xe16e
cltq
cmpq %rax, %r12
movq %rbx, %r12
jl 0x566b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/GCW.cpp
// Function: count_change_strat(Graph&, Locations*, int)
int count_change_strat(Graph & g, Locations * usersLocations, int p){
	int changedSeedsets = 0;
	for (int seed : g.seedSets[p]){
		// Did not find it in the previous seedset
		if (g.seedSets_before[p].find(seed) == g.seedSets_before[p].end()){
			bool not_same_location = true;
			for (int old_seed : g.seedSets_before[p]){
				if (usersLocations->same_location(seed, old_seed)){
					not_same_location = false;
					break;	
				}
			}
			if (not_same_location)
				++changedSeedsets;
		}
	}		
	if(changedSeedsets > 0){
		g.seedSets_before[p].clear();
		for (int seed : g.seedSets[p])
			g.seedSets_before[p].insert(seed);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
movq 0xad0(%rdi), %rax
movslq %edx, %rcx
movq %rcx, 0x8(%rsp)
leaq (%rcx,%rcx,2), %r13
shlq $0x4, %r13
leaq (%rax,%r13), %r15
addq $0x8, %r15
movq 0x10(%r15), %rdi
xorl %r12d, %r12d
movq %r15, 0x10(%rsp)
movl 0x20(%rdi), %ebp
movq 0xad8(%rbx), %rax
leaq (%rax,%r13), %r14
addq $0x8, %r14
movq 0x8(%r14), %rdx
movq %r14, %rcx
testq %rdx, %rdx
je 0x57be
movq %r14, %rcx
xorl %esi, %esi
cmpl %ebp, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x57a7
movq %r14, %rdx
cmpq %r14, %rcx
je 0x57d0
cmpl 0x20(%rcx), %ebp
cmovlq %r14, %rcx
movq %rcx, %rdx
cmpq %r14, %rdx
jne 0x583f
movl %r12d, (%rsp)
addq %r13, %rax
movq 0x18(%rax), %r12
cmpq %r14, %r12
je 0x5833
movq %rdi, 0x18(%rsp)
movb $0x1, %r15b
movl 0x20(%r12), %edx
movq 0x20(%rsp), %rdi
movl %ebp, %esi
callq 0xcf98
movzbl %r15b, %r15d
testb %al, %al
movl $0x0, %eax
cmovnel %eax, %r15d
jne 0x581f
movq %r12, %rdi
callq 0x33c0
movq %rax, %r12
cmpq %r14, %rax
jne 0x57ed
andb $0x1, %r15b
movzbl %r15b, %eax
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rdi
jmp 0x5838
movl $0x1, %eax
movl (%rsp), %r12d
addl %eax, %r12d
callq 0x33c0
movq %rax, %rdi
cmpq %r15, %rax
jne 0x5786
movq 0x8(%rsp), %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %r14
movq 0xad8(%rbx), %rdi
addq %r14, %rdi
callq 0xbe12
movq 0xad0(%rbx), %rax
movq 0x18(%rax,%r14), %r15
leaq 0x4(%rsp), %r14
movl 0x20(%r15), %eax
movl %eax, 0x4(%rsp)
movq 0xad8(%rbx), %rdi
addq %r13, %rdi
movq %r14, %rsi
callq 0xbe76
movq %r15, %rdi
callq 0x33c0
movq %rax, %r15
jmp 0x587d
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/GCW.cpp
// Function: output_stats_q_and_t(std::ostream*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<double, std::allocator<double>>*, std::vector<double, std::allocator<double>>*, int)
void output_stats_q_and_t(ostream * output, string algorithms, vector<double> * round_data_time, vector<double> * round_data_score, int rounds){
	for (int i = 0; i < algorithms.size(); i += 2){
		*output << algorithms.substr(i,2) << endl;
		for (int j = 0; j <= rounds; ++j){
			*output << round_data_time[i/2][j] << "\t" << round_data_score[i/2][j] << endl;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, (%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x8(%rsi)
je 0x5da3
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsp), %rax
leal 0x1(%rax), %ebp
xorl %r12d, %r12d
movq %rsi, 0x20(%rsp)
movl $0x2, %ecx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3380
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x33b0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3360
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3240
movq %rbp, %r13
movq %r12, 0x8(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5cef
callq 0x3340
cmpl $0x0, (%rsp)
js 0x5d88
movq 0x8(%rsp), %rax
leaq (,%rax,4), %rax
leaq (%rax,%rax,2), %r12
movq 0x10(%rsp), %rax
leaq (%rax,%r12), %rbp
addq 0x18(%rsp), %r12
xorl %r14d, %r14d
movq (%rbp), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbx, %rdi
callq 0x3520
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
leaq 0x123b3(%rip), %rsi     # 0x180f2
callq 0x33b0
movq (%r12), %rax
movsd (%rax,%r14,8), %xmm0
movq %r15, %rdi
callq 0x3520
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3360
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3240
incq %r14
cmpq %r14, %r13
jne 0x5d1b
movq 0x8(%rsp), %r12
addq $0x2, %r12
movq 0x20(%rsp), %r14
cmpq %r12, 0x8(%r14)
movq %r13, %rbp
ja 0x5c82
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5dc9
callq 0x3340
movq %rbx, %rdi
callq 0x35c0
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/GCW.cpp
// Function: output_clust(std::ostream*, double***, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void output_clust(ostream * output, double *** data, string variable, string algorithms){
	for (int i = 0; i < algorithms.size(); i += 2){
		if (algorithms.substr(i,2) == "EG"){
			*output << setw(16) << "GCW";
		}
		else{
			*output << setw(16) << algorithms.substr(i,2);
		}
		*output << setw(16) << data[0][i/2][0] << setw(16) << data[1][i/2][0] << setw(16) << data[2][i/2][0] << endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x8(%rcx)
je 0x6d70
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x10, %r13d
movl $0x2, %ecx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3380
movq %rbp, %rdi
leaq 0x1149b(%rip), %rsi     # 0x180eb
callq 0x3100
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6c6b
callq 0x3340
movq (%r15), %rax
movq -0x18(%rax), %rax
testl %ebp, %ebp
je 0x6cbc
movq $0x10, 0x10(%r15,%rax)
movl $0x2, %ecx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3380
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x33b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6cd9
callq 0x3340
jmp 0x6cd9
movq $0x10, 0x10(%r15,%rax)
movl $0x3, %edx
movq %r15, %rdi
leaq 0x1141a(%rip), %rsi     # 0x180ee
callq 0x33b0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r13, 0x10(%r15,%rax)
movq (%r14), %rax
movq (%rax,%r12,4), %rax
movsd (%rax), %xmm0
movq %r15, %rdi
callq 0x3520
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r13, 0x10(%rax,%rcx)
movq 0x8(%r14), %rcx
movq (%rcx,%r12,4), %rcx
movsd (%rcx), %xmm0
movq %rax, %rdi
callq 0x3520
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r13, 0x10(%rax,%rcx)
movq 0x10(%r14), %rcx
movq (%rcx,%r12,4), %rcx
movsd (%rcx), %xmm0
movq %rax, %rdi
callq 0x3520
movq %rax, %rbp
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x3360
movsbl %al, %esi
movq %rbp, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3240
addq $0x2, %r12
cmpq %r12, 0x8(%rbx)
ja 0x6c2e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6d96
callq 0x3340
movq %rbx, %rdi
callq 0x35c0
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/./mappedHeap.hpp
// Function: MappedHeap<InfCost<int>>::MappedHeap(std::vector<int, std::allocator<int>> const&, InfCost<int>)
MappedHeap<CompareLess>::MappedHeap(const vector<int> &v,CompareLess cl):compLess(cl) {
	if (v.empty())
		n = 0;
	else {
		n = v.size();
		heap.resize(n + 1);
		position.resize(max<int> (*max_element(v.begin(), v.end()), n) + 3, -1);
		for (int i = 0; i < n; i++) {
			heap[i + 1] = v[i];
			position[v[i]] = i + 1;
		}
		for (size_t i = n/ 2; i >= 1; i--)
			down_heap(i);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x38(%rdi)
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
cmpq %rax, %rcx
je 0xa6ce
movq %rsi, %r15
leaq 0x18(%rbx), %r14
subq %rcx, %rax
movq %rax, %rcx
shrq $0x2, %rcx
movl %ecx, 0x30(%rbx)
shlq $0x1e, %rax
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %rax, %rsi
sarq $0x20, %rsi
movq %rbx, %rdi
callq 0xb4e8
movq (%r15), %rdx
movq 0x8(%r15), %rax
cmpq %rax, %rdx
sete %sil
movq %rdx, %rcx
addq $0x4, %rcx
cmpq %rax, %rcx
sete %dil
orb %sil, %dil
je 0xa63b
movq %rdx, %rsi
jmp 0xa653
movl (%rdx), %edi
movq %rcx, %rsi
cmpl (%rcx), %edi
jl 0xa647
movq %rdx, %rsi
addq $0x4, %rcx
movq %rsi, %rdx
cmpq %rax, %rcx
jne 0xa63b
movl (%rsi), %eax
movl 0x30(%rbx), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
addl $0x3, %ecx
movslq %ecx, %rsi
leaq 0xc(%rsp), %rdx
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0xb51a
movl 0x30(%rbx), %eax
testl %eax, %eax
jle 0xa6a8
movq (%r15), %rcx
movq (%rbx), %rdx
movq 0x18(%rbx), %rsi
xorl %edi, %edi
movl (%rcx,%rdi,4), %eax
movl %eax, 0x4(%rdx,%rdi,4)
movslq (%rcx,%rdi,4), %rax
leaq 0x1(%rdi), %r8
movl %r8d, (%rsi,%rax,4)
movslq 0x30(%rbx), %rax
movq %r8, %rdi
cmpq %rax, %r8
jl 0xa689
leal 0x1(%rax), %ecx
cmpl $0x3, %ecx
jb 0xa6d5
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movslq %ecx, %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0xb54e
decq %r15
jne 0xa6bc
jmp 0xa6d5
movl $0x0, 0x30(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xa6e3
jmp 0xa6e3
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa6f3
callq 0x3340
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa700
callq 0x3340
movq %r15, %rdi
callq 0x35c0
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/./mappedHeap.hpp
// Function: MappedHeap<InfCost<int>>::down_heap(int)
int MappedHeap<CompareLess>::down_heap(int k) {
	while (k * 2 <= n) {
		int child = k * 2, right_child = child + 1;
		if ((right_child <= n)
				&& (compLess(heap[child], heap[right_child])))
                    child = right_child;
		if ((compLess(heap[k], heap[child]))) {
			swap(position[heap[k]], position[heap[child]]);
            swap(heap[k], heap[child]);			
			k = child;
		} else
			break;
	}
	return k;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %eax
movq (%rdi), %rcx
movq 0x18(%rdi), %rdx
movq 0x38(%rdi), %rsi
leal (%rax,%rax), %r8d
cmpl 0x30(%rdi), %r8d
jg 0xb5d5
jge 0xb592
movl %r8d, %r9d
orl $0x1, %r9d
movslq %r8d, %r10
movslq %r9d, %r11
movslq (%rcx,%r10,4), %r10
movl (%rsi,%r10,4), %r10d
movslq (%rcx,%r11,4), %r11
cmpl (%rsi,%r11,4), %r10d
jl 0xb58f
movl %r8d, %r9d
movl %r9d, %r8d
movslq %eax, %r10
movslq %r8d, %r11
movslq (%rcx,%r10,4), %r14
movl (%rsi,%r14,4), %r9d
movslq (%rcx,%r11,4), %r15
movl (%rsi,%r15,4), %ebx
cmpl %ebx, %r9d
jge 0xb5d0
movl (%rdx,%r14,4), %eax
movl (%rdx,%r15,4), %ebp
movl %ebp, (%rdx,%r14,4)
movl %eax, (%rdx,%r15,4)
movl (%rcx,%r10,4), %eax
movl (%rcx,%r11,4), %ebp
movl %ebp, (%rcx,%r10,4)
movl %eax, (%rcx,%r11,4)
movl %r8d, %eax
cmpl %ebx, %r9d
jl 0xb561
popq %rbx
popq %r14
popq %r15
popq %rbp
retq