LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: SethKasmann[P]clever-girl/src/state.cpp
// Function: State::makeNull()
void State::makeNull()
{
    assert(mCheckers == 0);
    // Remove the ep file and castle rights from the zobrist key.
    if (mEnPassant)
        mKey ^= Zobrist::key(get_file(mEnPassant));

    // Reset the en-passant square.
    mEnPassant = 0;

    // Swap the turn.
    swapTurn();

    // Set check squares.
    mCheckSquares[pawn] = getAttackBB<pawn>(getKingSquare(mThem), mThem);
    mCheckSquares[knight] = getAttackBB<knight>(getKingSquare(mThem));
    mCheckSquares[bishop] = getAttackBB<bishop>(getKingSquare(mThem));
    mCheckSquares[rook] = getAttackBB<rook>(getKingSquare(mThem));
    mCheckSquares[queen] = mCheckSquares[bishop] | mCheckSquares[rook];
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x30(%rax)
je 0x3882f
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x39b20
movl %eax, %edi
callq 0x39b00
movq %rax, %rcx
movq 0x38(%rsp), %rax
xorq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0x38(%rsp), %rdi
movq $0x0, 0x30(%rdi)
callq 0x3b270
movq 0x38(%rsp), %rdi
movl 0x4(%rdi), %esi
callq 0x24ea0
movq 0x38(%rsp), %rdi
movl %eax, %esi
movl 0x4(%rdi), %edx
callq 0x257b0
movq 0x38(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x24c40
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rdi
movq %rcx, (%rax)
movl 0x4(%rdi), %esi
callq 0x24ea0
movq 0x38(%rsp), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x25160
movq 0x38(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x38, %rdi
movl $0x1, %esi
callq 0x24c40
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rdi
movq %rcx, (%rax)
movl 0x4(%rdi), %esi
callq 0x24ea0
movq 0x38(%rsp), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x25370
movq 0x38(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x38, %rdi
movl $0x2, %esi
callq 0x24c40
movq 0x18(%rsp), %rcx
movq 0x38(%rsp), %rdi
movq %rcx, (%rax)
movl 0x4(%rdi), %esi
callq 0x24ea0
movq 0x38(%rsp), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x25480
movq 0x38(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x38, %rdi
movl $0x3, %esi
callq 0x24c40
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %rdi
movq %rcx, (%rax)
addq $0x38, %rdi
movl $0x2, %esi
callq 0x24c40
movq 0x38(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x28(%rsp)
addq $0x38, %rdi
movl $0x3, %esi
callq 0x24c40
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movq 0x28(%rsp), %rax
orq (%rcx), %rax
movq %rax, 0x30(%rsp)
addq $0x38, %rdi
movl $0x4, %esi
callq 0x24c40
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/state.h
// Function: State::setCheckers()
inline
void State::setCheckers()
{
    mCheckers = getAttackersBB(getKingSquare(mUs), mThem);
    mCheckSquares[pawn] = getAttackBB<pawn>(getKingSquare(mThem), mThem);
    mCheckSquares[knight] = getAttackBB<knight>(getKingSquare(mThem));
    mCheckSquares[bishop] = getAttackBB<bishop>(getKingSquare(mThem));
    mCheckSquares[rook] = getAttackBB<rook>(getKingSquare(mThem));
    mCheckSquares[queen] = mCheckSquares[bishop] | mCheckSquares[rook];
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl (%rdi), %esi
callq 0x24ea0
movq 0x28(%rsp), %rdi
movl %eax, %esi
movl 0x4(%rdi), %edx
callq 0x3b6d0
movq 0x28(%rsp), %rdi
movq %rax, 0x28(%rdi)
movl 0x4(%rdi), %esi
callq 0x24ea0
movq 0x28(%rsp), %rdi
movl %eax, %esi
movl 0x4(%rdi), %edx
callq 0x257b0
movq 0x28(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x24c40
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rdi
movq %rcx, (%rax)
movl 0x4(%rdi), %esi
callq 0x24ea0
movq 0x28(%rsp), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x25160
movq 0x28(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x38, %rdi
movl $0x1, %esi
callq 0x24c40
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rdi
movq %rcx, (%rax)
movl 0x4(%rdi), %esi
callq 0x24ea0
movq 0x28(%rsp), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x25370
movq 0x28(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x38, %rdi
movl $0x2, %esi
callq 0x24c40
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rdi
movq %rcx, (%rax)
movl 0x4(%rdi), %esi
callq 0x24ea0
movq 0x28(%rsp), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x25480
movq 0x28(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x38, %rdi
movl $0x3, %esi
callq 0x24c40
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rdi
movq %rcx, (%rax)
addq $0x38, %rdi
movl $0x2, %esi
callq 0x24c40
movq 0x28(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x30(%rsp)
addq $0x38, %rdi
movl $0x3, %esi
callq 0x24c40
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movq 0x30(%rsp), %rax
orq (%rcx), %rax
movq %rax, 0x38(%rsp)
addq $0x38, %rdi
movl $0x4, %esi
callq 0x24c40
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/state.h
// Function: State::setGamePhase()
inline void State::setGamePhase()
{
    float phase = totalPhase
                - getPieceCount<pawn>()   * pawnPhase
                - getPieceCount<knight>() * knightPhase
                - getPieceCount<bishop>() * bishopPhase
                - getPieceCount<rook>()   * rookPhase
                - getPieceCount<queen>()  * queenPhase;

    mPhase = (phase * 256 + (totalPhase / 2)) / totalPhase;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x24990
movq 0x10(%rsp), %rdi
imull $0x0, %eax, %ecx
movl $0x18, %eax
subl %ecx, %eax
movl %eax, (%rsp)
callq 0x3b3a0
movq 0x10(%rsp), %rdi
movl %eax, %ecx
movl (%rsp), %eax
shll $0x0, %ecx
subl %ecx, %eax
movl %eax, 0x4(%rsp)
callq 0x3b480
movq 0x10(%rsp), %rdi
movl %eax, %ecx
movl 0x4(%rsp), %eax
shll $0x0, %ecx
subl %ecx, %eax
movl %eax, 0x8(%rsp)
callq 0x3b2c0
movq 0x10(%rsp), %rdi
movl %eax, %ecx
movl 0x8(%rsp), %eax
shll %ecx
subl %ecx, %eax
movl %eax, 0xc(%rsp)
callq 0x3b330
movl 0xc(%rsp), %ecx
movl %eax, %edx
movq 0x10(%rsp), %rax
shll $0x2, %edx
subl %edx, %ecx
cvtsi2ss %ecx, %xmm0
movss %xmm0, 0x1c(%rsp)
movss 0x1c(%rsp), %xmm0
movss 0x7290(%rip), %xmm1     # 0x40ff0
mulss %xmm1, %xmm0
movss 0x96a8(%rip), %xmm1     # 0x43414
addss %xmm1, %xmm0
movss 0x9698(%rip), %xmm1     # 0x43410
divss %xmm1, %xmm0
movss %xmm0, 0x10(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: SethKasmann[P]clever-girl/src/state.h
// Function: State::allAttackers(Square) const
inline
U64 State::allAttackers(Square s) const
{
    return (getAttackBB<pawn>(s, mUs) & getPieceBB<pawn>(mThem))
         | (getAttackBB<pawn>(s, mThem) & getPieceBB<pawn>(mUs))
         | (getAttackBB<knight>(s) & getPieceBB<knight>())
         | (getAttackBB<bishop>(s) & (getPieceBB<bishop>() | getPieceBB<queen>()))
         | (getAttackBB<rook>(s) & (getPieceBB<rook>() | getPieceBB<queen>()))
         | (getAttackBB<king>(s) & getPieceBB<king>());
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x60(%rsp)
movl 0x7c(%rsp), %esi
movl (%rdi), %edx
callq 0x257b0
movq 0x60(%rsp), %rdi
movq %rax, 0x8(%rsp)
movl 0x4(%rdi), %esi
callq 0x24b80
movq 0x60(%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
andq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0x7c(%rsp), %esi
movl 0x4(%rdi), %edx
callq 0x257b0
movq 0x60(%rsp), %rdi
movq %rax, 0x10(%rsp)
movl (%rdi), %esi
callq 0x24b80
movq 0x10(%rsp), %rcx
movq 0x60(%rsp), %rdi
movq %rax, %rdx
movq 0x18(%rsp), %rax
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0x7c(%rsp), %esi
xorl %edx, %edx
callq 0x25160
movq 0x60(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x3b850
movq 0x20(%rsp), %rcx
movq 0x60(%rsp), %rdi
movq %rax, %rdx
movq 0x28(%rsp), %rax
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x40(%rsp)
movl 0x7c(%rsp), %esi
xorl %edx, %edx
callq 0x25370
movq 0x60(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x3b410
movq 0x60(%rsp), %rdi
movq %rax, 0x30(%rsp)
callq 0x3b8c0
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x60(%rsp), %rdi
movq %rax, %rsi
movq 0x40(%rsp), %rax
orq %rsi, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x58(%rsp)
movl 0x7c(%rsp), %esi
xorl %edx, %edx
callq 0x25480
movq 0x60(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x3b930
movq 0x60(%rsp), %rdi
movq %rax, 0x48(%rsp)
callq 0x3b8c0
movq 0x48(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x60(%rsp), %rdi
movq %rax, %rsi
movq 0x58(%rsp), %rax
orq %rsi, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x70(%rsp)
movl 0x7c(%rsp), %esi
xorl %edx, %edx
callq 0x2a790
movq 0x60(%rsp), %rdi
movq %rax, 0x68(%rsp)
callq 0x3b9a0
movq 0x68(%rsp), %rcx
movq %rax, %rdx
movq 0x70(%rsp), %rax
andq %rdx, %rcx
orq %rcx, %rax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: SethKasmann[P]clever-girl/src/state.h
// Function: State::getAttackersBB(Square, Color) const
inline
U64 State::getAttackersBB(Square s, Color c) const
{
    return (getAttackBB<pawn>(s, !c) &  getPieceBB< pawn >(c))
         | (getAttackBB<knight>(s)   &  getPieceBB<knight>(c))
         | (getAttackBB<bishop>(s)   & (getPieceBB<bishop>(c) | getPieceBB<queen>(c)))
         | (getAttackBB< rook >(s)   & (getPieceBB< rook >(c) | getPieceBB<queen>(c)));
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movl %edx, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x58(%rsp), %edi
callq 0x24ce0
movl 0x4(%rsp), %esi
movq 0x38(%rsp), %rdi
movl %eax, %edx
callq 0x257b0
movq 0x38(%rsp), %rdi
movq %rax, 0x8(%rsp)
movl 0x58(%rsp), %esi
callq 0x24b80
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
andq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0x5c(%rsp), %esi
xorl %edx, %edx
callq 0x25160
movq 0x38(%rsp), %rdi
movq %rax, 0x10(%rsp)
movl 0x58(%rsp), %esi
callq 0x25bb0
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rdi
movq %rax, %rdx
movq 0x18(%rsp), %rax
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x30(%rsp)
movl 0x5c(%rsp), %esi
xorl %edx, %edx
callq 0x25370
movq 0x38(%rsp), %rdi
movq %rax, 0x28(%rsp)
movl 0x58(%rsp), %esi
callq 0x25bf0
movq 0x38(%rsp), %rdi
movq %rax, 0x20(%rsp)
movl 0x58(%rsp), %esi
callq 0x2b3d0
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rdi
movq %rax, %rsi
movq 0x30(%rsp), %rax
orq %rsi, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x50(%rsp)
movl 0x5c(%rsp), %esi
xorl %edx, %edx
callq 0x25480
movq 0x38(%rsp), %rdi
movq %rax, 0x48(%rsp)
movl 0x58(%rsp), %esi
callq 0x2b410
movq 0x38(%rsp), %rdi
movq %rax, 0x40(%rsp)
movl 0x58(%rsp), %esi
callq 0x2b3d0
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq %rax, %rsi
movq 0x50(%rsp), %rax
orq %rsi, %rdx
andq %rdx, %rcx
orq %rcx, %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: SethKasmann[P]clever-girl/src/timer.h
// Function: allocate_time(int, int, int)
inline int64_t allocate_time(int time_left, int moves, int moves_to_go)
{
    int64_t num_moves, target, time;
    float factor;

    num_moves = std::min(moves, 10);
    factor = 2 - num_moves / 10.0;
    target = time_left / (moves_to_go ? moves_to_go : 30);
    time = factor * target;
    return time > min_time ? time : min_time;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl $0xa, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3c980
movslq (%rax), %rax
movq %rax, 0x30(%rsp)
cvtsi2sdq 0x30(%rsp), %xmm1
movsd 0x85da(%rip), %xmm0     # 0x44df8
divsd %xmm0, %xmm1
movsd 0x43a6(%rip), %xmm0     # 0x40bd0
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0x3c851
movl 0x3c(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x3c85c
movl $0x1e, %eax
movl %eax, 0x10(%rsp)
jmp 0x3c85c
movl 0x14(%rsp), %eax
movl 0x10(%rsp), %ecx
cltd
idivl %ecx
cltq
movq %rax, 0x28(%rsp)
movss 0x1c(%rsp), %xmm0
cvtsi2ssq 0x28(%rsp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movq %rax, 0x20(%rsp)
cmpq $0x1f4, 0x20(%rsp)      # imm = 0x1F4
jle 0x3c8a0
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x3c8ac
movl $0x1f4, %eax            # imm = 0x1F4
movq %rax, 0x8(%rsp)
jmp 0x3c8ac
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: SethKasmann[P]clever-girl/src/uci.cpp
// Function: get_uci_move(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, State&)
Move get_uci_move(std::string & token, State & s)
{
    Move m;

    token.erase(std::remove(token.begin(), token.end(), ','),
                    token.end());
    MoveList mlist(s);
    while (mlist.size() > 0)
    {
        m = mlist.pop();
        if (toString(m) == token)
            return m;
        if (mlist.size() == 0)
            return nullMove;
    }
    return nullMove;
}

// Assembly:
subq $0x918, %rsp            # imm = 0x918
movq %rdi, 0x908(%rsp)
movq %rsi, 0x900(%rsp)
movq 0x908(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x908(%rsp), %rdi
callq 0x5200
movq %rax, 0x8e0(%rsp)
movq 0x908(%rsp), %rdi
callq 0x5160
movq %rax, 0x8d8(%rsp)
movb $0x2c, 0x8d7(%rsp)
movq 0x8e0(%rsp), %rdi
movq 0x8d8(%rsp), %rsi
leaq 0x8d7(%rsp), %rdx
callq 0x3ea20
movq %rax, 0x8e8(%rsp)
leaq 0x8f0(%rsp), %rdi
leaq 0x8e8(%rsp), %rsi
callq 0x3ea80
movq 0x908(%rsp), %rdi
callq 0x5160
movq %rax, 0x8c0(%rsp)
leaq 0x8c8(%rsp), %rdi
leaq 0x8c0(%rsp), %rsi
callq 0x3ea80
movq 0x20(%rsp), %rdi
movq 0x8f0(%rsp), %rsi
movq 0x8c8(%rsp), %rdx
callq 0x5070
movq %rax, 0x8b8(%rsp)
movq 0x900(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x28590
leaq 0x60(%rsp), %rdi
callq 0x26dd0
movq %rax, 0x18(%rsp)
jmp 0x3d98f
movq 0x18(%rsp), %rax
cmpq $0x0, %rax
jbe 0x3da63
leaq 0x60(%rsp), %rdi
callq 0x26e40
movw %ax, 0x16(%rsp)
jmp 0x3d9af
movw 0x16(%rsp), %ax
movw %ax, 0x8fe(%rsp)
movzwl 0x8fe(%rsp), %esi
leaq 0x30(%rsp), %rdi
callq 0x263f0
jmp 0x3d9d0
movq 0x908(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x3eac0
movb %al, 0x15(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5538
movb 0x15(%rsp), %al
testb $0x1, %al
jne 0x3d9fa
jmp 0x3da2e
movw 0x8fe(%rsp), %ax
movw %ax, 0x916(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0x3da75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x263d0
jmp 0x3da8f
leaq 0x60(%rsp), %rdi
callq 0x26dd0
movq %rax, 0x8(%rsp)
jmp 0x3da3f
movq 0x8(%rsp), %rax
cmpq $0x0, %rax
jne 0x3da5e
movw $0x0, 0x916(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0x3da75
jmp 0x3d97e
movw $0x0, 0x916(%rsp)
movl $0x1, 0x2c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x263d0
movw 0x916(%rsp), %ax
addq $0x918, %rsp            # imm = 0x918
retq
movq 0x58(%rsp), %rdi
callq 0x54b0
nopl (%rax)
// File: SethKasmann[P]clever-girl/src/uci.cpp
// Function: set_option(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 set_option(std::string & name, std::string & value)
{
    if (name == "Hash")
        ttable.resize(std::stoi(value));
    else if (name == "ClearHash")
        ttable.clear();

    return;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x7080(%rip), %rsi      # 0x4553a
callq 0x35540
testb $0x1, %al
jne 0x3e4c5
jmp 0x3e4e8
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x3ee60
movl %eax, %esi
leaq 0x2121af(%rip), %rdi    # 0x250690
callq 0x3ee10
jmp 0x3e50d
movq 0x10(%rsp), %rdi
leaq 0x7041(%rip), %rsi      # 0x45535
callq 0x35540
testb $0x1, %al
jne 0x3e4ff
jmp 0x3e50b
leaq 0x21218a(%rip), %rdi    # 0x250690
callq 0x35b40
jmp 0x3e50d
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: SethKasmann[P]clever-girl/src/history.h
// Function: History::init()
void init()
	{
		mKillers = {};
		mHistory = {};
		mGameHistory.clear();
		for (std::array<int, Board_size>& arr : mButterfly)
			arr.fill(1);
	}

// Assembly:
subq $0x4128, %rsp           # imm = 0x4128
movq %rdi, 0x4120(%rsp)
movq 0x4120(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x4058(%rsp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x5150
leaq 0x4058(%rsp), %rax
movq %rax, %rcx
addq $0xc8, %rcx
movq %rcx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x308d0
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
addq $0x4, %rax
cmpq %rcx, %rax
movq %rax, 0x28(%rsp)
jne 0x3ec2c
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
leaq 0x4058(%rsp), %rsi
callq 0x31650
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
callq 0x5150
leaq 0x58(%rsp), %rax
movq %rax, %rcx
addq $0x4000, %rcx           # imm = 0x4000
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
addq $0x100, %rax            # imm = 0x100
cmpq %rcx, %rax
movq %rax, 0x8(%rsp)
jne 0x3ec92
movq 0x18(%rsp), %rdi
addq $0x40e0, %rdi           # imm = 0x40E0
leaq 0x58(%rsp), %rsi
movl $0x4000, %edx           # imm = 0x4000
callq 0x51f0
movq 0x18(%rsp), %rdi
callq 0x3eed0
movq 0x18(%rsp), %rax
addq $0xe0, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x30a00
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x30a10
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x40(%rsp), %rax
je 0x3ed3d
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, 0x34(%rsp)
leaq 0x34(%rsp), %rsi
callq 0x30a30
movq 0x48(%rsp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x48(%rsp)
jmp 0x3ecfe
addq $0x4128, %rsp           # imm = 0x4128
retq
nopw %cs:(%rax,%rax)
nop
// File: SethKasmann[P]clever-girl/src/zobrist.cpp
// Function: Zobrist::init()
void init()
	{
		srand(6736199);
		for (PieceType p = pawn; p < none; ++p)
		{
			for (Square s = first_sq; s <= last_sq; ++s)
			{
				piece_rand[white][p][s] = rand_64();
				piece_rand[black][p][s] = rand_64();
			}
		}
		for (File f = a_file; f <= h_file; ++f)
		{
			ep_file_rand[f] = rand_64();
		}
		for (int i = 0; i < 16; ++i)
		{
			castle_rand[i] = rand_64();
		}
		side_to_move_rand = rand_64();
	}

// Assembly:
subq $0x18, %rsp
movl $0x66c947, %edi         # imm = 0x66C947
callq 0x5280
movl $0x0, 0x14(%rsp)
cmpl $0x6, 0x14(%rsp)
jge 0x3fea4
movl $0x0, 0x10(%rsp)
cmpl $0x3f, 0x10(%rsp)
ja 0x3fe96
callq 0x3fde0
movq %rax, %rdx
movl 0x14(%rsp), %eax
movl %eax, %ecx
leaq 0x24189f(%rip), %rax    # 0x2816f0
shlq $0x9, %rcx
addq %rcx, %rax
movl 0x10(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
callq 0x3fde0
movq %rax, %rdx
movl 0x14(%rsp), %eax
movl %eax, %ecx
leaq 0x24187b(%rip), %rax    # 0x2816f0
addq $0xc00, %rax            # imm = 0xC00
shlq $0x9, %rcx
addq %rcx, %rax
movl 0x10(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
leaq 0x10(%rsp), %rdi
callq 0x218f0
jmp 0x3fe35
jmp 0x3fe98
leaq 0x14(%rsp), %rdi
callq 0x3ff20
jmp 0x3fe26
movl $0x0, 0xc(%rsp)
cmpl $0x7, 0xc(%rsp)
jg 0x3fed8
callq 0x3fde0
movq %rax, %rdx
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x243028(%rip), %rax    # 0x282ef0
movq %rdx, (%rax,%rcx,8)
leaq 0xc(%rsp), %rdi
callq 0x3ff40
jmp 0x3feac
movl $0x0, 0x8(%rsp)
cmpl $0x10, 0x8(%rsp)
jge 0x3ff0c
callq 0x3fde0
movq %rax, %rdx
movslq 0x8(%rsp), %rcx
leaq 0x243035(%rip), %rax    # 0x282f30
movq %rdx, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3fee0
callq 0x3fde0
movq %rax, 0x243098(%rip)    # 0x282fb0
addq $0x18, %rsp
retq
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/main.cpp
// Function: print_usage()
void print_usage()
{
    std::cerr << "Usage: ./jacobi <input_A> <input_b> <output_x>" << std::endl;
    std::cerr << "                  Reads the input A and b from the given binary files and" << std::endl;
    std::cerr << "                  writes the result to the given file in binary format." << std::endl;
    std::cerr << "       ./jacobi -n <n> [-d <difficulty>]" << std::endl;
    std::cerr << "                  Creates random input of size <n> (A has size n-by-n) of" << std::endl;
    std::cerr << "                  the given difficulty, a value between 0.0 (easiest) and 1.0" << std::endl;
    std::cerr << "                  (optional, default = 0.5)." << std::endl;
}

// Assembly:
pushq %rax
movq 0xfab0(%rip), %rdi      # 0x19fe8
leaq 0x9b21(%rip), %rsi      # 0x14060
callq 0x96c0
movq %rax, %rdi
movq 0xfa4a(%rip), %rsi      # 0x19f98
callq 0x9700
movq 0xfa8e(%rip), %rdi      # 0x19fe8
leaq 0x9b2e(%rip), %rsi      # 0x1408f
callq 0x96c0
movq %rax, %rdi
movq 0xfa28(%rip), %rsi      # 0x19f98
callq 0x9700
movq 0xfa6c(%rip), %rdi      # 0x19fe8
leaq 0x9b56(%rip), %rsi      # 0x140d9
callq 0x96c0
movq %rax, %rdi
movq 0xfa06(%rip), %rsi      # 0x19f98
callq 0x9700
movq 0xfa4a(%rip), %rdi      # 0x19fe8
leaq 0x9b7c(%rip), %rsi      # 0x14121
callq 0x96c0
movq %rax, %rdi
movq 0xf9e4(%rip), %rsi      # 0x19f98
callq 0x9700
movq 0xfa28(%rip), %rdi      # 0x19fe8
leaq 0x9b83(%rip), %rsi      # 0x1414a
callq 0x96c0
movq %rax, %rdi
movq 0xf9c2(%rip), %rsi      # 0x19f98
callq 0x9700
movq 0xfa06(%rip), %rdi      # 0x19fe8
leaq 0x9bab(%rip), %rsi      # 0x14194
callq 0x96c0
movq %rax, %rdi
movq 0xf9a0(%rip), %rsi      # 0x19f98
callq 0x9700
movq 0xf9e4(%rip), %rdi      # 0x19fe8
leaq 0x9bd7(%rip), %rsi      # 0x141e2
callq 0x96c0
movq %rax, %rdi
movq 0xf97e(%rip), %rsi      # 0x19f98
callq 0x9700
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./io.h
// Function: void write_binary_file<double>(char const*, std::vector<double, std::allocator<double>> const&)
void write_binary_file(const char* filename, const std::vector<T>& data)
{
    // open file in binary mode
    std::ofstream out(filename, std::ios::binary);
    if (!(out.good() && out.is_open()))
        throw std::runtime_error(std::string("Couldn't open file ") + filename);
    // write data to file
    out.write(reinterpret_cast<const char*>(&data[0]), sizeof(T)*data.size());
    out.close();
}

// Assembly:
subq $0x288, %rsp            # imm = 0x288
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq 0x280(%rsp), %rsi
leaq 0x78(%rsp), %rdi
movl $0x4, %edx
callq 0x9790
movq 0x78(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x78(%rsp,%rax), %rdi
callq 0x9c50
movb %al, 0x25(%rsp)
jmp 0xc267
movb 0x25(%rsp), %al
testb $0x1, %al
jne 0xc271
jmp 0xc28f
leaq 0x78(%rsp), %rdi
callq 0x94e0
movb %al, 0x24(%rsp)
jmp 0xc281
movb 0x24(%rsp), %al
testb $0x1, %al
jne 0xc38a
jmp 0xc28f
movb $0x1, 0x26(%rsp)
movl $0x10, %edi
callq 0x92c0
movq %rax, 0x10(%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x9cd0
movq 0x18(%rsp), %rdx
leaq 0x806a(%rip), %rsi      # 0x14328
leaq 0x28(%rsp), %rdi
callq 0xbd60
jmp 0xc2ca
movq 0x280(%rsp), %rdx
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x11800
jmp 0xc2e3
movq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x9b80
jmp 0xc2f4
movq 0x10(%rsp), %rdi
movb $0x0, 0x26(%rsp)
movq 0xdceb(%rip), %rsi      # 0x19ff0
movq 0xdcac(%rip), %rdx      # 0x19fb8
callq 0x9c70
jmp 0xc3f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0xc3e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0xc36b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0xc361
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x93e0
leaq 0x28(%rsp), %rdi
callq 0x93e0
leaq 0x27(%rsp), %rdi
callq 0x9770
testb $0x1, 0x26(%rsp)
jne 0xc37e
jmp 0xc388
movq 0x10(%rsp), %rdi
callq 0x9480
jmp 0xc3e3
movq 0x278(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11860
movq %rax, 0x8(%rsp)
movq 0x278(%rsp), %rdi
callq 0xc200
movq 0x8(%rsp), %rsi
movq %rax, %rdx
shlq $0x3, %rdx
leaq 0x78(%rsp), %rdi
callq 0x9940
jmp 0xc3c5
leaq 0x78(%rsp), %rdi
callq 0x9a40
jmp 0xc3d1
leaq 0x78(%rsp), %rdi
callq 0x9aa0
addq $0x288, %rsp            # imm = 0x288
retq
leaq 0x78(%rsp), %rdi
callq 0x9aa0
movq 0x70(%rsp), %rdi
callq 0x9cc0
nopw (%rax,%rax)
// File: j-faria[P]kima/examples/K2-24/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    datafile = "K2-24.rv"; // set the RV data file
    load(datafile, "ms", 1);

    /// set the sampler and run it!
    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50); // the optional argument to run() sets the print thining

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x6f0, %rsp            # imm = 0x6F0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xaf068(%rip), %rdi     # 0x11c7b8
movq %rdi, -0x6f0(%rbp)
leaq 0x59262(%rip), %rsi     # 0xc69c0
callq 0x6690
movq -0x6f0(%rbp), %rdi
movl $0x1, -0x14(%rbp)
leaq 0x4ad71(%rip), %rsi     # 0xb84e9
leaq -0x14(%rbp), %rdx
callq 0x6df70
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x6d0(%rbp), %rdi
movq %rdi, -0x6e8(%rbp)
callq 0x6e0b0
movq -0x6e8(%rbp), %rdi
movl $0x32, %esi
callq 0x6e150
jmp 0x6d7ae
movl $0x0, -0x4(%rbp)
leaq -0x6d0(%rbp), %rdi
callq 0x6e570
movl -0x4(%rbp), %eax
addq $0x6f0, %rsp            # imm = 0x6F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x6d8(%rbp)
movl %eax, -0x6dc(%rbp)
leaq -0x6d0(%rbp), %rdi
callq 0x6e570
movq -0x6d8(%rbp), %rdi
callq 0x6830
nopw (%rax,%rax)
// File: zengfenfei[P]codility/src/MaxCounters.cpp
// Function: solution(int, std::vector<int, std::allocator<int>>&)
vector<int> solution(int N, vector<int> &A) {
	vector<int> counters(N, 0);
	int max = 0;
	int lastMax = 0;
	for (int i = 0; i < A.size(); i++) {
		int op = A[i];
		if (op >= 1 && op <= N) {
			int count = counters[op - 1];
			if (count < lastMax) {
				count = lastMax;
			}
			count++;
			if (count > max) {
				max = count;
			}
			counters[op - 1] = count;
		} else if (op == N + 1) {
			lastMax = max;
		}
	}
	for (int i = 0; i < N; i++) {
		if (counters[i] < lastMax) {
			counters[i] = lastMax;
		}
	}
	return counters;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x15c0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rcx
leaq -0x20(%rbp), %rdx
callq 0x15e0
jmp 0x1288
leaq -0x21(%rbp), %rdi
callq 0x1660
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movslq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1680
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x1383
movq -0x18(%rbp), %rdi
movslq -0x40(%rbp), %rsi
callq 0x16a0
movl (%rax), %eax
movl %eax, -0x44(%rbp)
cmpl $0x1, -0x44(%rbp)
jl 0x135e
movl -0x44(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x135e
movq -0x68(%rbp), %rdi
movl -0x44(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x16a0
movl (%rax), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x1328
movl -0x3c(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x1328
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x1660
jmp 0x13eb
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x38(%rbp), %eax
jle 0x133f
movl -0x48(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x68(%rbp), %rdi
movl -0x48(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x44(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x16a0
movl -0x7c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x1373
movl -0x44(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1371
movl -0x38(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x1373
jmp 0x1375
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x12a6
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x13cb
movq -0x68(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x16a0
movl (%rax), %eax
cmpl -0x3c(%rbp), %eax
jge 0x13be
movq -0x68(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, -0x80(%rbp)
movslq -0x4c(%rbp), %rsi
callq 0x16a0
movl -0x80(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x13c0
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x138a
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x13de
movq -0x68(%rbp), %rdi
callq 0x16c0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x10e0
nopw %cs:(%rax,%rax)
// File: zengfenfei[P]codility/src/MaxCounters.cpp
// Function: main
int main() {
	vector<int> A(7);
	A[0] = 3;
	A[1] = 4;
	A[2] = 4;
	A[3] = 6;
	A[4] = 1;
	A[5] = 4;
	A[6] = 4;
	vector<int> counters = solution(5, A);
	for (int i = 0; i < counters.size(); i++) {
		cout << counters[i] << ',';
	}
	cout << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x15c0
movq -0x60(%rbp), %rdx
leaq -0x20(%rbp), %rdi
movl $0x7, %esi
callq 0x1720
jmp 0x1433
leaq -0x21(%rbp), %rdi
callq 0x1660
xorl %eax, %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x16a0
movq -0x68(%rbp), %rdi
movl $0x3, (%rax)
movl $0x1, %esi
callq 0x16a0
movq -0x68(%rbp), %rdi
movl $0x4, (%rax)
movl $0x2, %esi
callq 0x16a0
movq -0x68(%rbp), %rdi
movl $0x4, (%rax)
movl $0x3, %esi
callq 0x16a0
movq -0x68(%rbp), %rdi
movl $0x6, (%rax)
movl $0x4, %esi
callq 0x16a0
movq -0x68(%rbp), %rdi
movl $0x1, (%rax)
movl $0x5, %esi
callq 0x16a0
movq -0x68(%rbp), %rdi
movl $0x4, (%rax)
movl $0x6, %esi
callq 0x16a0
movq -0x68(%rbp), %rdx
movl $0x4, (%rax)
leaq -0x50(%rbp), %rdi
movl $0x5, %esi
callq 0x1230
jmp 0x14df
movl $0x0, -0x54(%rbp)
movslq -0x54(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1680
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x157d
movslq -0x54(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x16a0
movl (%rax), %esi
movq 0x3abf(%rip), %rdi      # 0x4fd8
callq 0x10d0
movq %rax, -0x78(%rbp)
jmp 0x1524
movq -0x78(%rbp), %rdi
movl $0x2c, %esi
callq 0x10b0
jmp 0x1534
jmp 0x1536
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x14e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x1660
jmp 0x15b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x15ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x16c0
jmp 0x15ae
movq 0x3a54(%rip), %rdi      # 0x4fd8
movl $0xa, %esi
callq 0x10b0
jmp 0x1590
leaq -0x50(%rbp), %rdi
callq 0x16c0
leaq -0x20(%rbp), %rdi
callq 0x16c0
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x16c0
movq -0x30(%rbp), %rdi
callq 0x10e0
// File: iZhangHui[P]CppPrimer/CH04_Expressions/examples/prec.cc
// Function: main
int main() 
{
	cout << 6 + 3 * 4 / 2 + 2 << endl;

	// parentheses in this expression match default precedence and associativity
	cout << ((6 + ((3 * 4) / 2)) + 2) << endl; // prints 14

	int temp = 3 * 4;         // 12
	int temp2 = temp / 2;     // 6
	int temp3 = temp2 + 6;    // 12
	int result = temp3 + 2;   // 14
	cout << result << endl;

	// parentheses result in alternative groupings
	cout << (6 + 3) * (4 / 2 + 2) << endl;     // prints 36
	cout << ((6 + 3) * 4) / 2 + 2 << endl;     // prints 20
	cout << 6 + 3 * 4 / (2 + 2) << endl;       // prints 9

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2e12(%rip), %rdi      # 0x3fd8
movl $0xe, %esi
callq 0x1060
movq %rax, %rdi
movq 0x2dee(%rip), %rsi      # 0x3fc8
callq 0x1040
movq 0x2df2(%rip), %rdi      # 0x3fd8
movl $0xe, %esi
callq 0x1060
movq %rax, %rdi
movq 0x2dce(%rip), %rsi      # 0x3fc8
callq 0x1040
movl $0xc, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x6, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
movq 0x2da8(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2d89(%rip), %rsi      # 0x3fc8
callq 0x1040
movq 0x2d8d(%rip), %rdi      # 0x3fd8
movl $0x24, %esi
callq 0x1060
movq %rax, %rdi
movq 0x2d69(%rip), %rsi      # 0x3fc8
callq 0x1040
movq 0x2d6d(%rip), %rdi      # 0x3fd8
movl $0x14, %esi
callq 0x1060
movq %rax, %rdi
movq 0x2d49(%rip), %rsi      # 0x3fc8
callq 0x1040
movq 0x2d4d(%rip), %rdi      # 0x3fd8
movl $0x9, %esi
callq 0x1060
movq %rax, %rdi
movq 0x2d29(%rip), %rsi      # 0x3fc8
callq 0x1040
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::(anonymous namespace)::getTheRegistryHub()
inline RegistryHub*& getTheRegistryHub() {
            static RegistryHub* theRegistryHub = NULL;
            if( !theRegistryHub )
                theRegistryHub = new RegistryHub();
            return theRegistryHub;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0xa0990(%rip)     # 0xad600
jne 0xccb6
movl $0xd8, %edi
callq 0xb530
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x18(%rbp)
callq 0x12d60
jmp 0xcc8d
movq -0x18(%rbp), %rax
movq %rax, 0xa0968(%rip)     # 0xad600
jmp 0xccb6
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl $0xd8, %esi
callq 0xb550
jmp 0xccc3
leaq 0xa0943(%rip), %rax     # 0xad600
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0xb920
nopl (%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Stream::release()
void Stream::release() {
        if( isOwned ) {
            delete streamBuf;
            streamBuf = NULL;
            isOwned = false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x8(%rax)
je 0xcff4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xcfe5
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movb $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::createStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Stream createStream( std::string const& streamName ) {
        if( streamName == "stdout" ) return Stream( std::cout.rdbuf(), false );
        if( streamName == "stderr" ) return Stream( std::cerr.rdbuf(), false );
        if( streamName == "debug" ) return Stream( new StreamBufImpl<OutputDebugWriter>, true );

        throw std::domain_error( "Unknown stream: " + streamName );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x6b60c(%rip), %rsi     # 0x78693
callq 0x13680
testb $0x1, %al
jne 0xd092
jmp 0xd0bf
movq 0x9ff1f(%rip), %rax     # 0xacfb8
movq (%rax), %rax
movq 0x9ff15(%rip), %rdi     # 0xacfb8
addq -0x18(%rax), %rdi
callq 0xb240
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
xorl %edx, %edx
callq 0xcf80
jmp 0xd1f3
movq -0x18(%rbp), %rdi
leaq 0x6b5d0(%rip), %rsi     # 0x7869a
callq 0x13680
testb $0x1, %al
jne 0xd0d5
jmp 0xd102
movq 0x9ff0c(%rip), %rax     # 0xacfe8
movq (%rax), %rax
movq 0x9ff02(%rip), %rdi     # 0xacfe8
addq -0x18(%rax), %rdi
callq 0xb240
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
xorl %edx, %edx
callq 0xcf80
jmp 0xd1f3
movq -0x18(%rbp), %rdi
leaq 0x6b594(%rip), %rsi     # 0x786a1
callq 0x13680
testb $0x1, %al
jne 0xd118
jmp 0xd169
movl $0x148, %edi            # imm = 0x148
callq 0xb530
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x136b0
jmp 0xd133
movq -0x58(%rbp), %rsi
leaq -0x10(%rbp), %rdi
movl $0x1, %edx
callq 0xcf80
jmp 0xd1f3
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x148, %esi            # imm = 0x148
callq 0xb550
jmp 0xd200
movb $0x1, -0x49(%rbp)
movl $0x10, %edi
callq 0xb290
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x6b521(%rip), %rsi     # 0x786a7
leaq -0x48(%rbp), %rdi
callq 0x13720
jmp 0xd191
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb650
jmp 0xd1a0
movq -0x60(%rbp), %rdi
movb $0x0, -0x49(%rbp)
movq 0x9fdd9(%rip), %rsi     # 0xacf88
movq 0x9fde2(%rip), %rdx     # 0xacf98
callq 0xb8d0
jmp 0xd209
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xd1e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb330
testb $0x1, -0x49(%rbp)
jne 0xd1e8
jmp 0xd1f1
movq -0x60(%rbp), %rdi
callq 0xb400
jmp 0xd200
movq -0x10(%rbp), %rax
movb -0x8(%rbp), %dl
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xb920
nopl (%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::toString(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
std::string toString( std::wstring const& value ) {

    std::string s;
    s.reserve( value.size() );
    for(size_t i = 0; i < value.size(); ++i )
        s += value[i] <= 0xff ? static_cast<char>( value[i] ) : '?';
    return toString( s );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xb720
movq -0x10(%rbp), %rdi
callq 0xb410
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xb790
jmp 0xfccf
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb410
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0xfd5c
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xb7c0
cmpl $0xff, (%rax)
jg 0xfd1d
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xb7c0
movl (%rax), %eax
movb %al, -0x69(%rbp)
jmp 0xfd24
movb $0x3f, %al
movb %al, -0x69(%rbp)
jmp 0xfd24
movb -0x69(%rbp), %al
movsbl %al, %esi
leaq -0x30(%rbp), %rdi
callq 0xb340
jmp 0xfd35
jmp 0xfd37
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xfcd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xb330
jmp 0xfd7e
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xf950
jmp 0xfd6b
leaq -0x30(%rbp), %rdi
callq 0xb330
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xb920
nopw (%rax,%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::toString[abi:cxx11](unsigned long)
std::string toString( unsigned long value ) {
    std::ostringstream oss;
    if( value > 8192 )
        oss << "0x" << std::hex << value;
    else
        oss << value;
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1a8(%rbp)
movq %rdi, %rax
movq %rax, -0x1a0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xb700
cmpq $0x2000, -0x10(%rbp)    # imm = 0x2000
jbe 0x101e6
leaq 0x68562(%rip), %rsi     # 0x786e3
leaq -0x188(%rbp), %rdi
callq 0xb520
movq %rax, -0x1b0(%rbp)
jmp 0x10196
movq -0x1b0(%rbp), %rdi
leaq 0x471c(%rip), %rsi      # 0x148c0
callq 0xb180
movq %rax, -0x1b8(%rbp)
jmp 0x101b2
movq -0x1b8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb0f0
jmp 0x101c4
jmp 0x101fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xb100
jmp 0x1022b
movq -0x10(%rbp), %rsi
leaq -0x188(%rbp), %rdi
callq 0xb0f0
jmp 0x101f8
jmp 0x101fa
movq -0x1a8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xb560
jmp 0x1020f
leaq -0x188(%rbp), %rdi
callq 0xb100
movq -0x1a0(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0xb920
nopw (%rax,%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::ResultBuilder::captureExpression()
void ResultBuilder::captureExpression() {
        AssertionResult result = build();
        getResultCapture().assertionEnded( result );

        if( !result.isOk() ) {
            if( getCurrentContext().getConfig()->shouldDebugBreak() )
                m_shouldDebugBreak = true;
            if( getCurrentContext().getRunner()->aborting() || m_assertionInfo.resultDisposition == ResultDisposition::Normal )
                m_shouldThrow = true;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xe8(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0xea10
callq 0xc380
movq %rax, -0xe0(%rbp)
jmp 0x10844
movq -0xe0(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0xc0(%rbp), %rsi
callq *%rax
jmp 0x1085d
leaq -0xc0(%rbp), %rdi
callq 0xd5d0
movb %al, -0xe9(%rbp)
jmp 0x10871
movb -0xe9(%rbp), %al
testb $0x1, %al
jne 0x1099c
jmp 0x10881
callq 0xc410
movq %rax, -0xf8(%rbp)
jmp 0x1088f
movq -0xf8(%rbp), %rsi
movq (%rsi), %rax
movq 0x30(%rax), %rax
leaq -0xd8(%rbp), %rdi
callq *%rax
jmp 0x108a8
leaq -0xd8(%rbp), %rdi
callq 0x14910
movq %rax, -0x100(%rbp)
jmp 0x108bd
movq -0x100(%rbp), %rdi
movq (%rdi), %rax
movq 0x40(%rax), %rax
callq *%rax
movb %al, -0x101(%rbp)
jmp 0x108d5
leaq -0xd8(%rbp), %rdi
callq 0x14930
movb -0x101(%rbp), %al
testb $0x1, %al
jne 0x108ed
jmp 0x10934
movq -0xe8(%rbp), %rax
movb $0x1, 0x298(%rax)
jmp 0x10934
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x109b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x14930
jmp 0x109b1
callq 0xc410
movq %rax, -0x110(%rbp)
jmp 0x10942
movq -0x110(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq %rax, -0x118(%rbp)
jmp 0x1095b
movq -0x118(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movb %al, -0x119(%rbp)
jmp 0x10973
movb -0x119(%rbp), %al
testb $0x1, %al
jne 0x1098c
jmp 0x1097f
movq -0xe8(%rbp), %rax
cmpl $0x0, 0x68(%rax)
jne 0x1099a
movq -0xe8(%rbp), %rax
movb $0x1, 0x299(%rax)
jmp 0x1099c
leaq -0xc0(%rbp), %rdi
callq 0xd570
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0xc0(%rbp), %rdi
callq 0xd570
movq -0xc8(%rbp), %rdi
callq 0xb920
nopl (%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::RegistrarForTagAliases::RegistrarForTagAliases(char const*, char const*, Catch::SourceLineInfo const&)
RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
        try {
            TagAliasRegistry::get().add( alias, tag, lineInfo );
        }
        catch( std::exception& ex ) {
            Colour colourGuard( Colour::Red );
            std::cerr << ex.what() << std::endl;
            exit(1);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x11de0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x11520
jmp 0x11e93
jmp 0x11f3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x11f41
movq -0x28(%rbp), %rdi
callq 0xb1e0
movq %rax, -0x38(%rbp)
leaq -0x39(%rbp), %rdi
movl $0x2, %esi
callq 0xd210
jmp 0x11ed1
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rsi
movq 0x9b100(%rip), %rdi     # 0xacfe8
callq 0xb520
movq %rax, -0x48(%rbp)
jmp 0x11ef3
movq -0x48(%rbp), %rdi
movq 0x9b082(%rip), %rsi     # 0xacf80
callq 0xb5a0
jmp 0x11f05
movl $0x1, %edi
callq 0xb660
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x11f32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xd290
callq 0xb870
jmp 0x11f39
jmp 0x11f41
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xb920
movq %rax, %rdi
callq 0x13830
nopw %cs:(%rax,%rax)
// File: minimind[P]simple-graph/unittest/main.cpp
// Function: ensureGraphTestLink()
void ensureGraphTestLink()
{
  ensureGraphConstructionTestLink();
  ensureGraphVisitorTestLink();
  ensureGraphCopyTopologyTestLink();
  ensureGraphAddTestLink();
  ensureGraphVisitorIgnoreKeyTestLink();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x5ebe0
callq 0x77540
callq 0x65390
callq 0x54bd0
callq 0x71260
popq %rbp
retq
nop
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::enforceNotReservedTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&)
inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
        if( isReservedTag( tag ) ) {
            {
                Colour colourGuard( Colour::Red );
                std::cerr
                    << "Tag name [" << tag << "] not allowed.\n"
                    << "Tag names starting with non alpha-numeric characters are reserved\n";
            }
            {
                Colour colourGuard( Colour::FileName );
                std::cerr << _lineInfo << std::endl;
            }
            exit(1);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ff40
testb $0x1, %al
jne 0x13cc2
jmp 0x13da4
leaq -0x11(%rbp), %rdi
movl $0x2, %esi
callq 0xd210
movq 0x99311(%rip), %rdi     # 0xacfe8
leaq 0x64c05(%rip), %rsi     # 0x788e3
callq 0xb520
movq %rax, -0x30(%rbp)
jmp 0x13ce9
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xb4c0
movq %rax, -0x38(%rbp)
jmp 0x13cfc
movq -0x38(%rbp), %rdi
leaq 0x64be7(%rip), %rsi     # 0x788ee
callq 0xb520
movq %rax, -0x40(%rbp)
jmp 0x13d12
movq -0x40(%rbp), %rdi
leaq 0x64be1(%rip), %rsi     # 0x788fe
callq 0xb520
jmp 0x13d24
leaq -0x11(%rbp), %rdi
callq 0xd290
leaq -0x25(%rbp), %rdi
movl $0x17, %esi
callq 0xd210
movq -0x10(%rbp), %rsi
movq 0x992a2(%rip), %rdi     # 0xacfe8
callq 0xcef0
movq %rax, -0x48(%rbp)
jmp 0x13d51
movq -0x48(%rbp), %rdi
movq 0x99224(%rip), %rsi     # 0xacf80
callq 0xb5a0
jmp 0x13d63
leaq -0x25(%rbp), %rdi
callq 0xd290
movl $0x1, %edi
callq 0xb660
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0xd290
jmp 0x13daa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0xd290
jmp 0x13daa
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xb920
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::parseSpecialTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
        if( tag == "." ||
            tag == "hide" ||
            tag == "!hide" )
            return TestCaseInfo::IsHidden;
        else if( tag == "!throws" )
            return TestCaseInfo::Throws;
        else if( tag == "!shouldfail" )
            return TestCaseInfo::ShouldFail;
        else if( tag == "!mayfail" )
            return TestCaseInfo::MayFail;
        else
            return TestCaseInfo::None;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x657cd(%rip), %rsi     # 0x797c4
callq 0x13680
testb $0x1, %al
jne 0x1402a
movq -0x10(%rbp), %rdi
leaq 0x64937(%rip), %rsi     # 0x78942
callq 0x13680
testb $0x1, %al
jne 0x1402a
movq -0x10(%rbp), %rdi
leaq 0x64922(%rip), %rsi     # 0x78941
callq 0x13680
testb $0x1, %al
jne 0x1402a
jmp 0x14033
movl $0x2, -0x4(%rbp)
jmp 0x14097
movq -0x10(%rbp), %rdi
leaq 0x64909(%rip), %rsi     # 0x78947
callq 0x13680
testb $0x1, %al
jne 0x14049
jmp 0x14052
movl $0x10, -0x4(%rbp)
jmp 0x14097
movq -0x10(%rbp), %rdi
leaq 0x648f2(%rip), %rsi     # 0x7894f
callq 0x13680
testb $0x1, %al
jne 0x14068
jmp 0x14071
movl $0x4, -0x4(%rbp)
jmp 0x14097
movq -0x10(%rbp), %rdi
leaq 0x648df(%rip), %rsi     # 0x7895b
callq 0x13680
testb $0x1, %al
jne 0x14087
jmp 0x14090
movl $0x8, -0x4(%rbp)
jmp 0x14097
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq