LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::shuffleDeck(int)
void Game::shuffleDeck(int start)
{
    // Use a different seed value so that we don't get same
    // result each time we run this program
    srand (time(NULL));
 
    // Start from the last element and swap one by one. We don't
    // need to run for the first element that's why i > 0
    for (int i = TOTAL_CARDS-1; i >= start; i--)
    {
        // Pick a random index from 0 to i
        int j = rand() % (i+1);
 
        // Swap arr[i] with the element at random index
        swap(&deck[i], &deck[j]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2160
movl %eax, %edi
callq 0x2170
movl $0x33, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x55bf
callq 0x2050
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movq %rdi, %rsi
addq $0x40, %rsi
movslq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq %rdi, %rdx
addq $0x40, %rdx
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
callq 0x5500
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x556e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::determineWinner()
int Game::determineWinner()
{
    //Check if everyone folded but one person
    for (int i = 0; i < numPlayers; ++i)
    {
        if (checkLastPlayerRemaining(players[i]) == true)
        {
            givePotToWinner(players[i]);
            return i;
        }
    }
    
    int equalHands = 0;
    Hand hands[numPlayers];
    Hand best = NOTHING;
    int playerIndex = 0;
    for (int i = 0; i < numPlayers; ++i) 
    {
        hands[i] = players[i]->bestHand(flop, turn, river, true);
        if (hands[i] > best)
        {
            best = hands[i];
            playerIndex = i;
            equalHands = 0;
        }
        else if (hands[i] == best)
        {
            equalHands = 1;
        }        
    }

    if (equalHands == 1)
    {
        splitPot();
        return SPLIT;
    }
    else
    {
        givePotToWinner(players[playerIndex]);
    }

    return playerIndex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x40(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x5641
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x5770
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x5634
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x5830
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5767
jmp 0x5636
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x55eb
movq -0x40(%rbp), %rax
movl $0x0, -0x18(%rbp)
movl 0x8(%rax), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x5720
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq %rax, %rsi
addq $0x10, %rsi
movq 0x28(%rax), %rdx
movq 0x30(%rax), %rcx
movl $0x1, %r8d
callq 0x4020
movl %eax, %edx
movq -0x48(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x2c(%rbp), %eax
jle 0x56f7
movq -0x48(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x18(%rbp)
jmp 0x5710
movq -0x48(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x2c(%rbp), %eax
jne 0x570e
movl $0x1, -0x18(%rbp)
jmp 0x5710
jmp 0x5712
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5688
cmpl $0x1, -0x18(%rbp)
jne 0x573f
movq -0x40(%rbp), %rdi
callq 0x5930
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x38(%rbp)
jmp 0x5760
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x5830
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nop
// File: fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::checkLastPlayerRemaining(Player*)
bool Game::checkLastPlayerRemaining(Player *player)
{
    bool ret = true;
    if (player->getState().move == FOLD)
        return false;

    for (int i = 0; i < numPlayers; ++i)
    {
        if (players[i] != player)
        {
            ret &= (players[i]->getState().move == FOLD);
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x1, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3690
movq %rax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x57a5
movb $0x0, -0x1(%rbp)
jmp 0x581b
movl $0x0, -0x28(%rbp)
movq -0x38(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x5813
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
je 0x5806
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3690
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %ecx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x5808
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x57ac
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::givePotToWinner(Player*)
void Game::givePotToWinner(Player *winner)
{
    winner->addChips(pot);
    cout << "Winner: Player " << getPlayerIndex(winner) << endl;
    for (int i = 0; i < numPlayers; ++i)
    {
        cout << "Player " << i << ": $" << players[i]->getChipCount() << endl;
    }
    pot = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl 0xc(%rax), %esi
callq 0x3280
movq 0xa775(%rip), %rdi      # 0xffd0
leaq 0x58ab(%rip), %rsi      # 0xb10d
callq 0x2180
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5000
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x2290
movq %rax, %rdi
movq 0xa733(%rip), %rsi      # 0xffc0
callq 0x21b0
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x5912
movq 0xa724(%rip), %rdi      # 0xffd0
leaq 0x5957(%rip), %rsi      # 0xb20a
callq 0x2180
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2290
movq %rax, %rdi
leaq 0x5922(%rip), %rsi      # 0xb1ef
callq 0x2180
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3250
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x2290
movq %rax, %rdi
movq 0xa6be(%rip), %rsi      # 0xffc0
callq 0x21b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5899
movq -0x28(%rbp), %rax
movl $0x0, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::splitPot()
void Game::splitPot()
{
    cout << "Split pot" << endl;
    for (int i = 0; i < numPlayers; ++i)
    {
        players[i]->addChips((int)(pot/numPlayers));
        cout << "Player " << i << ": $" << players[i]->getChipCount() << endl;
    }
    pot = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0xa685(%rip), %rdi      # 0xffd0
leaq 0x57b1(%rip), %rsi      # 0xb103
callq 0x2180
movq %rax, %rdi
movq 0xa65f(%rip), %rsi      # 0xffc0
callq 0x21b0
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x5a0a
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
movslq -0xc(%rbp), %rdx
movq (%rax,%rdx,8), %rdi
movl 0xc(%rcx), %eax
cltd
idivl 0x8(%rcx)
movl %eax, %esi
callq 0x3280
movq 0xa62f(%rip), %rdi      # 0xffd0
leaq 0x5862(%rip), %rsi      # 0xb20a
callq 0x2180
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2290
movq %rax, %rdi
leaq 0x582d(%rip), %rsi      # 0xb1ef
callq 0x2180
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3250
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x2290
movq %rax, %rdi
movq 0xa5c9(%rip), %rsi      # 0xffc0
callq 0x21b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x596d
movq -0x18(%rbp), %rax
movl $0x0, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::printPot()
void Game::printPot()
{
    cout << endl;
    for (int i = 0; i < numPlayers; ++i)
    {
        cout << "Player " << i << ": $" << players[i]->getChipCount() << endl;
    }
    cout << "Pot: $" << pot << endl;
    cin.ignore();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0xa595(%rip), %rdi      # 0xffd0
movq 0xa57e(%rip), %rsi      # 0xffc0
callq 0x21b0
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x5ac7
movq 0xa56f(%rip), %rdi      # 0xffd0
leaq 0x57a2(%rip), %rsi      # 0xb20a
callq 0x2180
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2290
movq %rax, %rdi
leaq 0x576d(%rip), %rsi      # 0xb1ef
callq 0x2180
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3250
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x2290
movq %rax, %rdi
movq 0xa509(%rip), %rsi      # 0xffc0
callq 0x21b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5a4e
movq 0xa502(%rip), %rdi      # 0xffd0
leaq 0x5648(%rip), %rsi      # 0xb11d
callq 0x2180
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x2290
movq %rax, %rdi
movq 0xa4cd(%rip), %rsi      # 0xffc0
callq 0x21b0
movq 0xa4e1(%rip), %rdi      # 0xffe0
callq 0x22d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::getMove()
Move Game::getMove()
{
    Move move;
    string moveStr = "";

    while (moveStr.compare("c") != 0 && moveStr.compare("b") != 0 && moveStr.compare("f") != 0)
    {
        cout << "Check/Call (c), Bet/Raise (b), Fold (f)" << endl;
        cin >> moveStr;
    }
    if (moveStr.compare("c") == 0)
    {
        move = CHECK;
    }
    if (moveStr.compare("b") == 0)
    {
        move = BET;
    }
    if (moveStr.compare("f") == 0)
    {
        move = FOLD;
    }

    return move;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x22b0
movq -0x50(%rbp), %rdx
leaq 0x5289(%rip), %rsi      # 0xb09d
leaq -0x30(%rbp), %rdi
callq 0x2da0
jmp 0x5e1f
leaq -0x31(%rbp), %rdi
callq 0x21d0
leaq -0x30(%rbp), %rdi
leaq 0x52f1(%rip), %rsi      # 0xb124
callq 0x2070
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x51(%rbp)
je 0x5e79
leaq -0x30(%rbp), %rdi
leaq 0x52d7(%rip), %rsi      # 0xb126
callq 0x2070
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x51(%rbp)
je 0x5e79
leaq -0x30(%rbp), %rdi
leaq 0x52bd(%rip), %rsi      # 0xb128
callq 0x2070
cmpl $0x0, %eax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x5e82
jmp 0x5ef5
movq 0xa147(%rip), %rdi      # 0xffd0
leaq 0x529a(%rip), %rsi      # 0xb12a
callq 0x2180
movq %rax, -0x60(%rbp)
jmp 0x5e9b
movq -0x60(%rbp), %rdi
movq 0xa11a(%rip), %rsi      # 0xffc0
callq 0x21b0
jmp 0x5ead
movq 0xa12c(%rip), %rdi      # 0xffe0
leaq -0x30(%rbp), %rsi
callq 0x2210
jmp 0x5ebf
jmp 0x5e28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x21d0
jmp 0x5f61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20c0
jmp 0x5f61
leaq -0x30(%rbp), %rdi
leaq 0x5224(%rip), %rsi      # 0xb124
callq 0x2070
cmpl $0x0, %eax
jne 0x5f11
movl $0x1, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
leaq 0x520a(%rip), %rsi      # 0xb126
callq 0x2070
cmpl $0x0, %eax
jne 0x5f2d
movl $0x2, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
leaq 0x51f0(%rip), %rsi      # 0xb128
callq 0x2070
cmpl $0x0, %eax
jne 0x5f49
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20c0
movl -0x64(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22a0
nopw (%rax,%rax)
// File: fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::aiSwap(Player*, bool, bool, bool)
void Game::aiSwap(Player *player, bool fl, bool tu, bool ri)
{
    shuffleDeck(3);
    player->getHand()[0] = deck[4];
    player->getHand()[1] = deck[5];
    if (fl)
    {
        flop[0] = deck[6];
        flop[1] = deck[7];
        flop[2] = deck[8];
        swap(&flop[0], &deck[5]);
        swap(&flop[1], &deck[6]);
        swap(&flop[2], &deck[7]);
    }
    if (tu)
    {
        turn = deck[9];
        swap(&turn, &deck[9]);
    }
    if (ri)
    {
        river = deck[10];
        swap(&river, &deck[11]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
andb $0x1, %cl
movb %cl, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x3, %esi
callq 0x5540
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3270
movq -0x30(%rbp), %rdx
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rdx, (%rcx)
movq 0x68(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3270
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
testb $0x1, -0x11(%rbp)
je 0x673c
movq -0x28(%rbp), %rdi
movq 0x70(%rdi), %rax
movq %rax, 0x10(%rdi)
movq 0x78(%rdi), %rax
movq %rax, 0x18(%rdi)
movq 0x80(%rdi), %rax
movq %rax, 0x20(%rdi)
movq %rdi, %rsi
addq $0x10, %rsi
movq %rdi, %rdx
addq $0x40, %rdx
addq $0x28, %rdx
callq 0x5500
movq -0x28(%rbp), %rdi
movq %rdi, %rsi
addq $0x10, %rsi
addq $0x8, %rsi
movq %rdi, %rdx
addq $0x40, %rdx
addq $0x30, %rdx
callq 0x5500
movq -0x28(%rbp), %rdi
movq %rdi, %rsi
addq $0x10, %rsi
addq $0x10, %rsi
movq %rdi, %rdx
addq $0x40, %rdx
addq $0x38, %rdx
callq 0x5500
testb $0x1, -0x12(%rbp)
je 0x6768
movq -0x28(%rbp), %rdi
movq 0x88(%rdi), %rax
movq %rax, 0x28(%rdi)
movq %rdi, %rsi
addq $0x28, %rsi
movq %rdi, %rdx
addq $0x40, %rdx
addq $0x48, %rdx
callq 0x5500
testb $0x1, -0x13(%rbp)
je 0x6794
movq -0x28(%rbp), %rdi
movq 0x90(%rdi), %rax
movq %rax, 0x30(%rdi)
movq %rdi, %rsi
addq $0x30, %rsi
movq %rdi, %rdx
addq $0x40, %rdx
addq $0x58, %rdx
callq 0x5500
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: fredericmarchand[P]TexasHoldem/Node.cpp
// Function: Node::Node(NodeState*)
Node::Node(NodeState *state)
{
    parent = NULL;
    visits = 0;
    this->state = state;
    untriedMoves = *(state->getMoves());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x18, %rdi
movq %rdi, -0x40(%rbp)
callq 0x7150
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x38(%rbp)
callq 0x7170
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rdi
callq 0x9500
movq %rax, -0x28(%rbp)
jmp 0x6c30
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x7190
jmp 0x6c43
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x73e0
movq -0x40(%rbp), %rdi
callq 0x7440
movq -0x18(%rbp), %rdi
callq 0x22a0
// File: fredericmarchand[P]TexasHoldem/Node.cpp
// Function: Node::Node(moves, Node*, NodeState*)
Node::Node(Move move, Node *parent, NodeState *state)
{
    this->parent = parent;
    visits = 0;
    this->move = move;
    this->state = state;
    untriedMoves = *(state->getMoves());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
movq %rdi, -0x50(%rbp)
callq 0x7150
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x48(%rbp)
callq 0x7170
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rdi
callq 0x9500
movq %rax, -0x38(%rbp)
jmp 0x6cdd
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x7190
jmp 0x6cf0
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x73e0
movq -0x50(%rbp), %rdi
callq 0x7440
movq -0x28(%rbp), %rdi
callq 0x22a0
nopl (%rax)
// File: fredericmarchand[P]TexasHoldem/Node.cpp
// Function: Node::getUCB()
Node* Node::getUCB()
{
	if (children.size() == 0)
	{
		return NULL;
	}

	Node *child = NULL;
	float UCB = 0.0;
	for (int i = 1; i < children.size(); ++i)
	{
		Node *c = children.at(i);
		float temp = (c->getWins()/c->getVisits() + sqrt(2*log(this->getVisits()/c->getVisits())));
		if (UCB > temp)
		{
			UCB = temp;
			child = c;
		}

	}
    return child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
callq 0x6880
cmpq $0x0, %rax
jne 0x6e00
movq $0x0, -0x8(%rbp)
jmp 0x6efc
movq $0x0, -0x18(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
callq 0x6880
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x6ef4
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movslq -0x20(%rbp), %rsi
callq 0x68a0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6f10
movl %eax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6f20
movq -0x38(%rbp), %rdi
movl %eax, %ecx
movl -0x50(%rbp), %eax
cltd
idivl %ecx
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x48(%rbp)
callq 0x6f20
movl %eax, -0x4c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6f20
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cltd
idivl %ecx
movl %eax, %edi
callq 0x74a0
movaps %xmm0, %xmm1
movsd 0x42ff(%rip), %xmm0     # 0xb1a8
mulsd %xmm1, %xmm0
callq 0x2100
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x1c(%rbp), %xmm0
ucomiss -0x2c(%rbp), %xmm0
jbe 0x6ee4
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6ee6
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6e17
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fredericmarchand[P]TexasHoldem/Node.cpp
// Function: Node::addChild(moves, NodeState*)
Node* Node::addChild(Move move, NodeState *state)
{
	Node *child = new Node(move, this, state);
	for (int i = 0; i < untriedMoves.size(); i++)
	{
    	if (untriedMoves.at(i) == move)
    	{
    		untriedMoves.erase(untriedMoves.begin()+i);
    	}
	}
	children.push_back(child);

	return child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x50, %edi
callq 0x2190
movq -0x60(%rbp), %rdx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rcx
callq 0x6c70
jmp 0x7061
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x60(%rbp), %rdi
movslq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x30, %rdi
callq 0x6860
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x7126
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
movslq -0x30(%rbp), %rsi
callq 0x6820
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x7116
movq -0x60(%rbp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x70(%rbp)
addq $0x30, %rdi
callq 0x7530
movq %rax, -0x48(%rbp)
movslq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x7560
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x75a0
movq -0x70(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x74c0
movq %rax, -0x50(%rbp)
jmp 0x7116
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x50, %esi
callq 0x21a0
jmp 0x7141
jmp 0x7118
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7070
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
leaq -0x20(%rbp), %rsi
callq 0x75e0
movq -0x20(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x22a0
nopw (%rax,%rax)
// File: fredericmarchand[P]TexasHoldem/NodeState.cpp
// Function: NodeState::doMove(moves)
void NodeState::doMove(Move move)
{
	player->doMove(move, game->getPlayerIndex(player), game->getPreviousPlayer(player), true);
	for (int i = 0; i < moves.size(); ++i)
	{
		if (moves.at(i) == move)
		{
			moves.erase(moves.begin()+i);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x40(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, -0x38(%rbp)
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x5000
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, -0x34(%rbp)
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x4f50
movq -0x40(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x34(%rbp), %edx
movq %rax, %rcx
movl $0x1, %r8d
callq 0x37a0
movl $0x0, -0x10(%rbp)
movq -0x48(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x10, %rdi
callq 0x6860
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x9619
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
movslq -0x10(%rbp), %rsi
callq 0x6820
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x9609
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x58(%rbp)
addq $0x10, %rdi
callq 0x7530
movq %rax, -0x28(%rbp)
movslq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x7560
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x75a0
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x74c0
movq %rax, -0x30(%rbp)
jmp 0x960b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9585
addq $0x60, %rsp
popq %rbp
retq
nop
// File: fredericmarchand[P]TexasHoldem/NodeState.cpp
// Function: NodeState::getResult(bool)
int NodeState::getResult(bool playerJustMoved)
{
	if (this->game == NULL)
		cout << "FUCKA" << endl;
	int p1 = game->getPlayers()[0]->bestHand(game->getFlop(), game->getTurn(), game->getRiver(), false);
	int p2 = game->getPlayers()[1]->bestHand(game->getFlop(), game->getTurn(), game->getRiver(), false);
	if (game->getPlayerIndex(player) == 0)
	{
		if (p1 > p2)
			return 2;
		else if (p1 == p2)
			return 1;
		else return 0;
	}
	else
	{
		if (p1 < p2)
			return 2;
		else if (p1 == p2)
			return 1;
		else return 0;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
jne 0x9664
movq 0x6987(%rip), %rdi      # 0xffd0
leaq 0x1b7a(%rip), %rsi      # 0xb1ca
callq 0x2180
movq %rax, %rdi
movq 0x6961(%rip), %rsi      # 0xffc0
callq 0x21b0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x4a00
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x58(%rbp)
movq (%rax), %rdi
callq 0x63f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq (%rax), %rdi
callq 0x6410
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq (%rax), %rdi
callq 0x6430
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x4020
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x18(%rbp)
movq (%rax), %rdi
callq 0x4a00
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq 0x8(%rcx), %rcx
movq %rcx, -0x40(%rbp)
movq (%rax), %rdi
callq 0x63f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq (%rax), %rdi
callq 0x6410
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
callq 0x6430
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x4020
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x5000
cmpl $0x0, %eax
jne 0x976d
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x9753
movl $0x2, -0x4(%rbp)
jmp 0x9796
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x9764
movl $0x1, -0x4(%rbp)
jmp 0x9796
movl $0x0, -0x4(%rbp)
jmp 0x9796
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x977e
movl $0x2, -0x4(%rbp)
jmp 0x9796
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x978f
movl $0x1, -0x4(%rbp)
jmp 0x9796
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: fredericmarchand[P]TexasHoldem/main.cpp
// Function: printLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void printLabel(string label)
{
    for (int i = 0; i < label.length(); ++i)
    {
        cout << "=";
    }
    cout << endl << label << endl;
    for (int i = 0; i < label.length(); ++i)
    {
        cout << "=";
    }
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2240
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x9ea2
movq 0x6145(%rip), %rdi      # 0xffd0
leaq 0x133e(%rip), %rsi      # 0xb1d0
callq 0x2180
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9e67
movq 0x6127(%rip), %rdi      # 0xffd0
movq 0x6110(%rip), %rsi      # 0xffc0
callq 0x21b0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
movq 0x60f5(%rip), %rsi      # 0xffc0
callq 0x21b0
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2240
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x9f12
movq 0x60d5(%rip), %rdi      # 0xffd0
leaq 0x12ce(%rip), %rsi      # 0xb1d0
callq 0x2180
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9ed7
movq 0x60b7(%rip), %rdi      # 0xffd0
movq 0x60a0(%rip), %rsi      # 0xffc0
callq 0x21b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 01joy[P]test-gperftools/main/main.cpp
// Function: calculateSum(long long)
long long calculateSum(long long n) {
	long long s = 0;
	for (int i = 1; i <= n; ++i) {
		s += i;
		recordSum(s);
	}
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x8(%rbp), %rax
jg 0x1375
movslq -0x14(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x134b
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 01joy[P]test-gperftools/main/main.cpp
// Function: main
int main() {
	long long n = 1000000000;
	Complex c;
	double p = c.calculatePI(n);
	long long s = calculateSum(n);
	cout << "pi=" << fixed << setprecision(13) << p << endl;
	cout << "1+2+...+" << n << "=" << s << endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movq $0x3b9aca00, -0x10(%rbp) # imm = 0x3B9ACA00
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1140
movq -0x60(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1100
movsd %xmm0, -0x58(%rbp)
jmp 0x13ba
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1330
movq %rax, -0x68(%rbp)
jmp 0x13d3
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x3bf6(%rip), %rdi      # 0x4fd8
leaq 0x1c1b(%rip), %rsi      # 0x3004
callq 0x10b0
movq %rax, -0x70(%rbp)
jmp 0x13f4
movq -0x70(%rbp), %rdi
leaq 0x251(%rip), %rsi       # 0x1650
callq 0x1040
movq %rax, -0x78(%rbp)
jmp 0x140a
movl $0xd, %edi
callq 0x1680
movl %eax, -0x7c(%rbp)
jmp 0x1419
movq -0x78(%rbp), %rdi
movl -0x7c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %esi
callq 0x1120
movq %rax, -0x88(%rbp)
jmp 0x1434
movq -0x88(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
callq 0x1160
movq %rax, -0x90(%rbp)
jmp 0x144e
movq -0x90(%rbp), %rdi
movq 0x3b6c(%rip), %rsi      # 0x4fc8
callq 0x10e0
jmp 0x1463
movq 0x3b6e(%rip), %rdi      # 0x4fd8
leaq 0x1b97(%rip), %rsi      # 0x3008
callq 0x10b0
movq %rax, -0x98(%rbp)
jmp 0x147f
movq -0x98(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1080
movq %rax, -0xa0(%rbp)
jmp 0x1498
movq -0xa0(%rbp), %rdi
leaq 0x1b60(%rip), %rsi      # 0x3006
callq 0x10b0
movq %rax, -0xa8(%rbp)
jmp 0x14b4
movq -0xa8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x1080
movq %rax, -0xb0(%rbp)
jmp 0x14cd
movq -0xb0(%rbp), %rdi
movq 0x3aed(%rip), %rsi      # 0x4fc8
callq 0x10e0
jmp 0x14e2
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10f0
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10f0
movq -0x38(%rbp), %rdi
callq 0x1150
nopl (%rax)
// File: leobru[P]ACPUfont/splitter.cc
// Function: smooth(std::vector<double, std::allocator<double>> const&, int)
vector<double> smooth(const vector<double> & vec, int n) {
    vector<double> smoothed(vec.size());
    for (int i = 0; i < vec.size(); ++i) {
        smoothed[i] = smooth(&vec[std::max(0, i-n)], &vec[std::min(i+n, (int)vec.size()-1)]);
    }
    return smoothed;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movl %edx, 0x84(%rsp)
movb $0x0, 0x83(%rsp)
movq 0x88(%rsp), %rdi
callq 0x2480
movq %rax, 0x50(%rsp)
leaq 0x82(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x24a0
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x24b0
jmp 0x13ed
leaq 0x82(%rsp), %rdi
callq 0x2530
movl $0x0, 0x70(%rsp)
movslq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x88(%rsp), %rdi
callq 0x2480
movq %rax, %rcx
movq 0x38(%rsp), %rax
cmpq %rcx, %rax
jae 0x154b
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x6c(%rsp)
movl 0x70(%rsp), %eax
movl 0x84(%rsp), %ecx
subl %ecx, %eax
movl %eax, 0x68(%rsp)
leaq 0x6c(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x2560
movq %rax, 0x30(%rsp)
jmp 0x1466
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movslq (%rax), %rsi
callq 0x2540
movq %rax, 0x10(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x70(%rsp), %eax
movl 0x84(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x64(%rsp)
movq 0x88(%rsp), %rdi
callq 0x2480
decl %eax
movl %eax, 0x60(%rsp)
leaq 0x64(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x25a0
movq %rax, 0x20(%rsp)
jmp 0x14c4
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movslq (%rax), %rsi
callq 0x2540
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x1340
movsd %xmm0, 0x8(%rsp)
jmp 0x14eb
movq 0x48(%rsp), %rdi
movslq 0x70(%rsp), %rsi
callq 0x25e0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x70(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x70(%rsp)
jmp 0x1402
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x82(%rsp), %rdi
callq 0x2530
jmp 0x1574
movq 0x48(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
callq 0x2600
jmp 0x1574
movb $0x1, 0x83(%rsp)
testb $0x1, 0x83(%rsp)
jne 0x1567
movq 0x48(%rsp), %rdi
callq 0x2600
movq 0x40(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x11d0
nop
// File: leobru[P]ACPUfont/splitter.cc
// Function: centers(std::vector<double, std::allocator<double>> const&, int)
vector<int> centers(const vector<double> & vec, int cellsize) {
    vector<int> centers;
    for (int i = cellsize/2; i < vec.size()-cellsize/2; ++i) {
        if (vec[i] < vec[i-1] && vec[i] < vec[i+1]) centers.push_back(i);
    }
    return centers;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movb $0x0, 0x43(%rsp)
callq 0x2660
movl 0x44(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x3c(%rsp)
movslq 0x3c(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x2480
movq %rax, %rcx
movl 0x44(%rsp), %eax
movl $0x2, %esi
cltd
idivl %esi
movl %eax, %edx
movq 0x10(%rsp), %rax
movslq %edx, %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jae 0x16a9
movq 0x48(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0x2540
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl 0x3c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x2540
movsd 0x8(%rsp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1697
movq 0x48(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0x2540
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x48(%rsp), %rdi
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x2540
movsd (%rsp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1697
movq 0x18(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x2670
jmp 0x167b
jmp 0x1697
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x26e0
jmp 0x16c9
jmp 0x1699
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x15b9
movb $0x1, 0x43(%rsp)
testb $0x1, 0x43(%rsp)
jne 0x16bf
movq 0x18(%rsp), %rdi
callq 0x26e0
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x11d0
nopw %cs:(%rax,%rax)
// File: leobru[P]ACPUfont/splitter.cc
// Function: Picture::average_lines(int, int)
vector<double> average_lines(int start, int finish) {
        vector<double> avgs(height);
        for (int i = 0; i < height; ++i) {
            avgs[i] = std::accumulate(&p(i, start), &p(i, finish+1), 0.0) / (double) (finish-start+1);
        }
        return avgs;
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movl %ecx, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0x5f(%rsp)
movslq 0x420(%rax), %rax
movq %rax, 0x38(%rsp)
leaq 0x5e(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x24a0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x24b0
jmp 0x2ab3
leaq 0x5e(%rsp), %rdi
callq 0x2530
movl $0x0, 0x48(%rsp)
movq 0x28(%rsp), %rcx
movl 0x48(%rsp), %eax
cmpl 0x420(%rcx), %eax
jge 0x2ba2
movq 0x28(%rsp), %rdi
movl 0x48(%rsp), %esi
movl 0x64(%rsp), %edx
callq 0x4410
movq %rax, 0x18(%rsp)
jmp 0x2af3
movq 0x28(%rsp), %rdi
movl 0x48(%rsp), %esi
movl 0x60(%rsp), %edx
incl %edx
callq 0x4410
movq %rax, 0x10(%rsp)
jmp 0x2b0e
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
xorps %xmm0, %xmm0
callq 0x43c0
movsd %xmm0, 0x8(%rsp)
jmp 0x2b28
movq 0x30(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movl 0x60(%rsp), %eax
subl 0x64(%rsp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movslq 0x48(%rsp), %rsi
callq 0x25e0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x2ac5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x5e(%rsp), %rdi
callq 0x2530
jmp 0x2bc2
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x2600
jmp 0x2bc2
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0x2bb8
movq 0x30(%rsp), %rdi
callq 0x2600
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x11d0
nopl (%rax)
// File: leobru[P]ACPUfont/splitter.cc
// Function: Picture::average_columns(int, int)
vector<double> average_columns(int start, int finish) {
        vector<double> avgs(width);
        for (int i = 0; i < width; ++i) {
            avgs[i] = std::accumulate(column_begin(i)+start, column_begin(i)+finish+1, 0.0) / (double) (finish-start+1);
        }
        return avgs;
    }

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x70(%rsp)
movq %rdi, %rax
movq %rax, 0x60(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movl %edx, 0xf4(%rsp)
movl %ecx, 0xf0(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x68(%rsp)
movb $0x0, 0xef(%rsp)
movslq 0x41c(%rax), %rax
movq %rax, 0x78(%rsp)
leaq 0xee(%rsp), %rdi
movq %rdi, 0x80(%rsp)
callq 0x24a0
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
callq 0x24b0
jmp 0x2c91
leaq 0xee(%rsp), %rdi
callq 0x2530
movl $0x0, 0xd8(%rsp)
movq 0x68(%rsp), %rcx
movl 0xd8(%rsp), %eax
cmpl 0x41c(%rcx), %eax
jge 0x2e92
movq 0x68(%rsp), %rdi
movl 0xd8(%rsp), %esi
callq 0x44d0
movq %rdx, 0x50(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x2cdd
movq 0x50(%rsp), %rax
movl 0x5c(%rsp), %ecx
movl %ecx, 0xb8(%rsp)
movq %rax, 0xc0(%rsp)
movl 0xf4(%rsp), %esi
leaq 0xb8(%rsp), %rdi
callq 0x4520
movq %rdx, 0x40(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x2d14
movq 0x68(%rsp), %rdi
movq 0x40(%rsp), %rax
movl 0x4c(%rsp), %ecx
movl %ecx, 0xc8(%rsp)
movq %rax, 0xd0(%rsp)
movl 0xd8(%rsp), %esi
callq 0x44d0
movq %rdx, 0x30(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x2d48
movq 0x30(%rsp), %rax
movl 0x3c(%rsp), %ecx
movl %ecx, 0x88(%rsp)
movq %rax, 0x90(%rsp)
movl 0xf0(%rsp), %esi
leaq 0x88(%rsp), %rdi
callq 0x4520
movq %rdx, 0x20(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x2d7f
movq 0x20(%rsp), %rax
movl 0x2c(%rsp), %ecx
movl %ecx, 0x98(%rsp)
movq %rax, 0xa0(%rsp)
leaq 0x98(%rsp), %rdi
movl $0x1, %esi
callq 0x4520
movq %rdx, 0x10(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x2db4
movq 0x10(%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0xa8(%rsp)
movq %rax, 0xb0(%rsp)
movl 0xc8(%rsp), %edi
movq 0xd0(%rsp), %rsi
movl 0xa8(%rsp), %edx
movq 0xb0(%rsp), %rcx
xorps %xmm0, %xmm0
callq 0x4450
movsd %xmm0, 0x8(%rsp)
jmp 0x2dfa
movq 0x70(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movl 0xf0(%rsp), %eax
subl 0xf4(%rsp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movslq 0xd8(%rsp), %rsi
callq 0x25e0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0xd8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd8(%rsp)
jmp 0x2ca9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
leaq 0xee(%rsp), %rdi
callq 0x2530
jmp 0x2ebb
movq 0x70(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
callq 0x2600
jmp 0x2ebb
movb $0x1, 0xef(%rsp)
testb $0x1, 0xef(%rsp)
jne 0x2eae
movq 0x70(%rsp), %rdi
callq 0x2600
movq 0x60(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
movq 0xe0(%rsp), %rdi
callq 0x11d0
nopl (%rax,%rax)
// File: leobru[P]ACPUfont/splitter.cc
// Function: Picture::rectavg(int, int, int, int)
double rectavg(int cline, int ccol, int hspread, int vspread) {
        double sum = 0;
        for (int i = -hspread/2; i <= hspread/2; ++i) {
            for (int j = -vspread/2; j <= vspread/2; ++j) {
                if (cline+i >= 0 && cline+i < height && ccol+j >= 0 && ccol+j < width) {
                    sum += p(cline+i,ccol+j);
                }
            }
        }
        return sum/(hspread|1)/(vspread|1);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
xorl %eax, %eax
subl 0x24(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x24(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jg 0x3265
xorl %eax, %eax
subl 0x20(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, (%rsp)
movl 0x20(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jg 0x3253
movl 0x2c(%rsp), %eax
addl 0x14(%rsp), %eax
cmpl $0x0, %eax
jl 0x3241
movq 0x8(%rsp), %rcx
movl 0x2c(%rsp), %eax
addl 0x14(%rsp), %eax
cmpl 0x420(%rcx), %eax
jge 0x3241
movl 0x28(%rsp), %eax
addl 0x10(%rsp), %eax
cmpl $0x0, %eax
jl 0x3241
movq 0x8(%rsp), %rcx
movl 0x28(%rsp), %eax
addl 0x10(%rsp), %eax
cmpl 0x41c(%rcx), %eax
jge 0x3241
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
addl 0x14(%rsp), %esi
movl 0x28(%rsp), %edx
addl 0x10(%rsp), %edx
callq 0x4410
movsd (%rax), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x3243
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x31b3
jmp 0x3255
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x317f
movsd 0x18(%rsp), %xmm0
movl 0x24(%rsp), %eax
orl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movl 0x20(%rsp), %eax
orl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
addq $0x38, %rsp
retq
nop
// File: npazosmendez[P]branchsearch/branchsearch.cpp
// Function: kbhit()
int kbhit(void){
    int ch = getch();
    if (ch != ERR) {
        ungetch(ch);
        return 1;
    } else {
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x4c639(%rip), %rax     # 0x51fa8
movq (%rax), %rdi
callq 0x5180
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
je 0x5991
movl -0x8(%rbp), %edi
callq 0x55d0
movl $0x1, -0x4(%rbp)
jmp 0x5998
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: npazosmendez[P]branchsearch/branchsearch.cpp
// Function: delete_branch(std::vector<branch_t*, std::allocator<branch_t*>>&, int)
void delete_branch(vector<branch_t*> &branches, int target_index){
    erase();
    string branch_name = branches[target_index]->name;
    printw("Delete '%s'? [Y/N]\n", branch_name.c_str());
    while (1) {
        if (kbhit()) {
            int c = getch();
            if(c == 'Y' or c == 'y') run_command("git branch -d " + branch_name + " 2>&1");
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x5490
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x7c40
movq (%rax), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x51e0
movq -0x88(%rbp), %rdi
callq 0x51c0
movq %rax, %rsi
leaq 0x30bc1(%rip), %rdi     # 0x371ee
xorl %eax, %eax
callq 0x5420
jmp 0x6636
jmp 0x6638
jmp 0x663a
callq 0x5960
movl %eax, -0x8c(%rbp)
jmp 0x6647
movl -0x8c(%rbp), %eax
cmpl $0x0, %eax
je 0x6718
movq 0x4b94b(%rip), %rax     # 0x51fa8
movq (%rax), %rdi
callq 0x5180
movl %eax, -0x90(%rbp)
jmp 0x666d
movl -0x90(%rbp), %eax
movl %eax, -0x40(%rbp)
cmpl $0x59, -0x40(%rbp)
je 0x6686
cmpl $0x79, -0x40(%rbp)
jne 0x6716
leaq 0x30b75(%rip), %rsi     # 0x37202
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x7cb0
jmp 0x669c
leaq 0x30b6e(%rip), %rdx     # 0x37211
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7c60
jmp 0x66b2
xorl %eax, %eax
movl %eax, %esi
leaq -0x60(%rbp), %rdi
movl $0x1, %edx
callq 0x59b0
jmp 0x66c6
leaq -0x60(%rbp), %rdi
callq 0x52c0
leaq -0x80(%rbp), %rdi
callq 0x52c0
jmp 0x6716
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x672f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x670b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x52c0
leaq -0x80(%rbp), %rdi
callq 0x52c0
jmp 0x672f
jmp 0x671d
jmp 0x6638
leaq -0x30(%rbp), %rdi
callq 0x52c0
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x52c0
movq -0x38(%rbp), %rdi
callq 0x5780
nopw %cs:(%rax,%rax)
// File: npazosmendez[P]branchsearch/branchsearch.cpp
// Function: switch_to_branch(branch_t, bool)
void switch_to_branch(branch_t branch, bool pull_after_checkout){
    endwin();
    string command = "git checkout " + branch.name;
    system(command.c_str());
    if (pull_after_checkout) {
        system("git pull");
    }
    exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
callq 0x5550
movq -0x50(%rbp), %rdx
leaq 0x30a9f(%rip), %rsi     # 0x37217
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x7cb0
movq -0x48(%rbp), %rdi
callq 0x51c0
movq %rax, %rdi
callq 0x53c0
jmp 0x6798
testb $0x1, -0x9(%rbp)
je 0x67c5
leaq 0x30a80(%rip), %rdi     # 0x37225
callq 0x53c0
jmp 0x67ac
jmp 0x67c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52c0
jmp 0x67cc
xorl %edi, %edi
callq 0x5560
movq -0x38(%rbp), %rdi
callq 0x5780
nopw %cs:(%rax,%rax)
// File: npazosmendez[P]branchsearch/branchsearch.cpp
// Function: filter_branches(std::vector<branch_t, std::allocator<branch_t>>&, char*, std::vector<branch_t*, std::allocator<branch_t*>>&)
void filter_branches(vector<branch_t> &all_branches, char* regex_value, vector<branch_t*> &filtered_branches){
    filtered_branches.clear();
    try{
        regex regex_(regex_value, regex_constants::icase);
        for (int i = 0; i < all_branches.size(); ++i){
            if (regex_search(all_branches[i].name, regex_)){
                filtered_branches.push_back(&all_branches[i]);
            }
        }
    } catch(exception e){
        return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7dc0
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movl $0x1, %edx
callq 0x7890
jmp 0x6814
movl $0x0, -0x48(%rbp)
movslq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7de0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x6903
movq -0x8(%rbp), %rdi
movslq -0x48(%rbp), %rsi
callq 0x7e60
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x7e10
movb %al, -0x61(%rbp)
jmp 0x685c
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x6868
jmp 0x68f3
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x48(%rbp), %rsi
callq 0x7e60
movq -0x70(%rbp), %rdi
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x7e80
jmp 0x6890
jmp 0x68f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x68b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7930
movl -0x44(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x6915
movq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5590
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x7eb0
movq -0x78(%rbp), %rdi
callq 0x51b0
leaq -0x58(%rbp), %rdi
callq 0x5810
callq 0x56e0
jmp 0x690c
jmp 0x68f5
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x681b
leaq -0x38(%rbp), %rdi
callq 0x7930
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5780
nop