LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: SethKasmann[P]clever-girl/src/line_manager.cpp
// Function: LineManager::pushToPv(unsigned short, unsigned long long, int, int)
void LineManager::pushToPv(Move pMove, U64 pKey, int pPly, int pScore)
{
    // Check if this is a mating line.
    mMatingLine = std::abs(pScore) + Max_ply >= Checkmate ? true : false;

    // Find the indicies using the triangular forumla.
    int copyTo = triangularIndex(pPly);
    int copyFromStart = triangularIndex(pPly + 1);
    int copyFromEnd = copyFromStart + Max_ply - pPly - 1;

    // Store the current move.
    mPv[copyTo++] = std::make_pair(pMove, pKey);

    // Copy from the previous iteration.
    std::copy(std::make_move_iterator(mPv.begin() + copyFromStart), 
              std::make_move_iterator(mPv.begin() + copyFromEnd), 
              mPv.begin() + copyTo);
}

// Assembly:
subq $0x58, %rsp
movw %si, %ax
movq %rdi, 0x50(%rsp)
movw %ax, 0x4e(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movl %r8d, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movl 0x38(%rsp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
addl $0x32, %ecx
subl $0x7fff, %ecx           # imm = 0x7FFF
setge %cl
negb %cl
andb $0x1, %cl
movb %cl, 0x4fb0(%rax)
movl 0x3c(%rsp), %edi
callq 0x261d0
movl %eax, 0x34(%rsp)
movl 0x3c(%rsp), %edi
addl $0x1, %edi
callq 0x261d0
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %eax
addl $0x32, %eax
subl 0x3c(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x2c(%rsp)
leaq 0x4e(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x261f0
movq (%rsp), %rdi
movw %ax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movl 0x34(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rsp)
movslq %eax, %rsi
callq 0x26230
movq %rax, %rdi
leaq 0x18(%rsp), %rsi
callq 0x26260
movq (%rsp), %rdi
callq 0x26320
movq %rax, %rdi
movslq 0x30(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x262f0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x26320
movq %rax, %rdi
movslq 0x2c(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x262f0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x26320
movq %rax, %rdx
movslq 0x34(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdx
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x26290
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/line_manager.cpp
// Function: LineManager::checkPv(State&)
void LineManager::checkPv(State& pState)
{
    State c;
    Move nextMove;
    std::memmove(&c, &pState, sizeof(pState));
    for (int i = 0; i < Max_ply; ++i)
    {
        nextMove = mPv[i].first;
        if (nextMove == nullMove)
        {
            mSize = i;
            break;
        }
        // Push moves to the move list.
        MoveList moveList(c);

        // If the next pv move is in the move list, make the move.
        if (moveList.contains(nextMove))
            c.make_t(nextMove);
        // If the next pv move is not found, break the loop.
        else
        {
            mSize = i;
            break;
        }
    }
}

// Assembly:
subq $0xda8, %rsp            # imm = 0xDA8
movq %rdi, 0xda0(%rsp)
movq %rsi, 0xd98(%rsp)
movq 0xda0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x890(%rsp), %rdi
callq 0x263c0
movq 0xd98(%rsp), %rsi
leaq 0x890(%rsp), %rdi
movl $0x508, %edx            # imm = 0x508
callq 0x5430
movl $0x0, 0x888(%rsp)
cmpl $0x32, 0x888(%rsp)
jge 0x26067
movq 0x18(%rsp), %rdi
movslq 0x888(%rsp), %rsi
callq 0x26230
movw (%rax), %ax
movw %ax, 0x88e(%rsp)
movzwl 0x88e(%rsp), %eax
cmpl $0x0, %eax
jne 0x25fa7
movq 0x18(%rsp), %rax
movslq 0x888(%rsp), %rcx
movq %rcx, 0x4fb8(%rax)
jmp 0x26067
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x890(%rsp), %rsi
callq 0x28590
movq 0x8(%rsp), %rdi
movzwl 0x88e(%rsp), %esi
callq 0x26e70
movb %al, 0x17(%rsp)
jmp 0x25fd6
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x25fe0
jmp 0x26013
movzwl 0x88e(%rsp), %esi
leaq 0x890(%rsp), %rdi
callq 0x38340
jmp 0x25ff7
jmp 0x26031
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x263d0
jmp 0x2606f
movq 0x18(%rsp), %rax
movslq 0x888(%rsp), %rcx
movq %rcx, 0x4fb8(%rax)
movl $0x2, 0x20(%rsp)
jmp 0x26039
movl $0x0, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x263d0
movl 0x20(%rsp), %eax
testl %eax, %eax
je 0x2604f
jmp 0x2604d
jmp 0x26067
jmp 0x26051
movl 0x888(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x888(%rsp)
jmp 0x25f56
addq $0xda8, %rsp            # imm = 0xDA8
retq
movq 0x28(%rsp), %rdi
callq 0x54b0
nopl (%rax)
// File: SethKasmann[P]clever-girl/src/move.h
// Function: toString[abi:cxx11](unsigned short)
inline std::string toString(Move m)
{
	std::string ret;
	Square src, dst;

	src = getSrc(m);
	dst = getDst(m);

	ret = SQ[src] + SQ[dst];

	switch (getPiecePromo(m))
	{
		case knight:
			ret += "n";
			break;
		case bishop:
			ret += "b";
			break;
		case rook:
			ret += "r";
			break;
		case queen:
			ret += "q";
			break;
		default:
			break;
	}

	return ret;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movw %si, %ax
movq %rdi, %rcx
movq %rcx, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movw %ax, 0x6e(%rsp)
movb $0x0, 0x6d(%rsp)
callq 0x5390
movzwl 0x6e(%rsp), %edi
callq 0x26810
movl %eax, 0x2c(%rsp)
jmp 0x26428
movl 0x2c(%rsp), %eax
movl %eax, 0x68(%rsp)
movzwl 0x6e(%rsp), %edi
callq 0x26830
movl %eax, 0x14(%rsp)
jmp 0x26440
movl 0x14(%rsp), %eax
movl %eax, 0x64(%rsp)
movl 0x68(%rsp), %eax
shlq $0x5, %rax
leaq 0x180ee9(%rip), %rdx    # 0x1a7340
movq %rdx, %rsi
addq %rax, %rsi
movl 0x64(%rsp), %eax
shlq $0x5, %rax
addq %rax, %rdx
leaq 0x30(%rsp), %rdi
callq 0x26850
jmp 0x26474
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x5310
movq 0x8(%rsp), %rdi
callq 0x5538
movzwl 0x6e(%rsp), %edi
callq 0x268e0
movl %eax, 0x10(%rsp)
jmp 0x264a2
movl 0x10(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x3, %eax
ja 0x26539
movq (%rsp), %rax
leaq 0x1b34e(%rip), %rcx     # 0x41810
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0x5538
jmp 0x2655b
movq 0x18(%rsp), %rdi
leaq 0x1f028(%rip), %rsi     # 0x45519
callq 0x5270
jmp 0x264f8
jmp 0x2653b
movq 0x18(%rsp), %rdi
leaq 0x1ea8f(%rip), %rsi     # 0x44f95
callq 0x5270
jmp 0x2650d
jmp 0x2653b
movq 0x18(%rsp), %rdi
leaq 0x1efb7(%rip), %rsi     # 0x454d2
callq 0x5270
jmp 0x26522
jmp 0x2653b
movq 0x18(%rsp), %rdi
leaq 0x1e981(%rip), %rsi     # 0x44eb1
callq 0x5270
jmp 0x26537
jmp 0x2653b
jmp 0x2653b
movb $0x1, 0x6d(%rsp)
testb $0x1, 0x6d(%rsp)
jne 0x26551
movq 0x18(%rsp), %rdi
callq 0x5538
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x54b0
nopw %cs:(%rax,%rax)
nop
// File: SethKasmann[P]clever-girl/src/move_generator.cpp
// Function: void MoveList::generateMoves<(MoveType)2>()
void MoveList::generateMoves<MoveType::Evasions>()
{
    assert(mState.inCheck());

    Square k, c;

    mValid = mState.getOccupancyBB(mState.getTheirColor()) | mState.getEmptyBB();
    pushMoves<MoveType::Evasions, king>();

    if (mState.inDoubleCheck())
        return;

    k = mState.getKingSquare(mState.getOurColor());
    c = get_lsb(mState.getCheckersBB());
    mValid = between[k][c] | mState.getCheckersBB();

    mState.getOurColor() == white ? pushPawnMoves<MoveType::Evasions, white>() 
                                  : pushPawnMoves<MoveType::Evasions, black>();
    pushMoves<MoveType::Evasions, knight>();
    pushMoves<MoveType::Evasions, bishop>();
    pushMoves<MoveType::Evasions, rook>();
    pushMoves<MoveType::Evasions, queen>();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rdi
callq 0x28740
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x25740
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq 0x18(%rax), %rdi
callq 0x24ef0
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movq 0x18(%rsp), %rax
orq %rcx, %rax
movq %rax, 0x8(%rdi)
callq 0x28750
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x28840
testb $0x1, %al
jne 0x27054
jmp 0x27059
jmp 0x2712b
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rcx
movq %rcx, (%rsp)
movq 0x18(%rax), %rdi
callq 0x24ca0
movq (%rsp), %rdi
movl %eax, %esi
callq 0x24ea0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x2c(%rsp)
movq 0x18(%rax), %rdi
callq 0x286a0
movq %rax, %rdi
callq 0x25a20
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x28(%rsp)
movl 0x2c(%rsp), %ecx
movl %ecx, %edx
leaq 0x13ec62(%rip), %rcx    # 0x165d10
shlq $0x9, %rdx
addq %rdx, %rcx
movl 0x28(%rsp), %edx
movq (%rcx,%rdx,8), %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rax), %rdi
callq 0x286a0
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq 0x20(%rsp), %rax
orq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rax), %rdi
callq 0x24ca0
cmpl $0x0, %eax
jne 0x270f9
movq 0x20(%rsp), %rdi
callq 0x28860
jmp 0x27103
movq 0x20(%rsp), %rdi
callq 0x28b00
movq 0x20(%rsp), %rdi
callq 0x28db0
movq 0x20(%rsp), %rdi
callq 0x28ea0
movq 0x20(%rsp), %rdi
callq 0x28f90
movq 0x20(%rsp), %rdi
callq 0x29080
addq $0x38, %rsp
retq
// File: SethKasmann[P]clever-girl/src/move_generator.cpp
// Function: void MoveList::generateMoves<(MoveType)4>()
void MoveList::generateMoves<MoveType::All>()
{
    if (mState.inCheck())
    {
        generateMoves<MoveType::Evasions>();
        return;
    }

    mValid = mState.getOccupancyBB(mState.getTheirColor()) | mState.getEmptyBB();

    mState.getOurColor() == white ? pushPawnMoves<MoveType::All, white>() 
                                  : pushPawnMoves<MoveType::All, black>();
    pushMoves<MoveType::All, knight>();
    pushMoves<MoveType::All, bishop>();
    pushMoves<MoveType::All, rook>();
    pushMoves<MoveType::All, queen>();
    pushMoves<MoveType::All, king>();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rax), %rdi
callq 0x28680
testb $0x1, %al
jne 0x27152
jmp 0x27161
movq 0x18(%rsp), %rdi
callq 0x26fe0
jmp 0x27204
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rax), %rdi
callq 0x28740
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x25740
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rdi
callq 0x24ef0
movq 0x10(%rsp), %rcx
movq %rax, %rdx
movq 0x18(%rsp), %rax
orq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rax), %rdi
callq 0x24ca0
cmpl $0x0, %eax
jne 0x271c8
movq 0x18(%rsp), %rdi
callq 0x29170
jmp 0x271d2
movq 0x18(%rsp), %rdi
callq 0x293f0
movq 0x18(%rsp), %rdi
callq 0x29670
movq 0x18(%rsp), %rdi
callq 0x29760
movq 0x18(%rsp), %rdi
callq 0x29850
movq 0x18(%rsp), %rdi
callq 0x29940
movq 0x18(%rsp), %rdi
callq 0x29a30
addq $0x28, %rsp
retq
nopl (%rax)
// File: SethKasmann[P]clever-girl/src/move_generator.cpp
// Function: void MoveList::pushMoves<(MoveType)4, (PieceType)5>()
void MoveList::pushMoves()
{
    U64 m;
    Square dst;
    Color c = mState.getOurColor();

    for (Square src : mState.getPieceList<P>(c))
    {
        if (src == no_sq)
            break;

        m = mState.getAttackBB<P>(src) & mValid;

        if (T == MoveType::QuietChecks)
        {
            if (square_bb[src] & mDiscover)
            {
                if (P == king)
                    m &= ~coplanar[src][mState.getKingSquare(!c)];
            }
            else
                m &= mState.getCheckSquaresBB(P);
        }

        while (m)
            push(makeMove(src, pop_lsb(m)));

        if (P == king && T != MoveType::Attacks && T != MoveType::Evasions)
            pushCastle<T>();
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rax), %rdi
callq 0x24ca0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x30(%rsp)
movq 0x18(%rax), %rdi
movl 0x30(%rsp), %esi
callq 0x2a750
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x24dc0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x24dd0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x29b1e
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
cmpl $0x40, 0x14(%rsp)
jne 0x29aab
jmp 0x29b1e
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x14(%rsp), %esi
xorl %edx, %edx
callq 0x2a790
movq 0x8(%rsp), %rcx
andq 0x8(%rcx), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x29b01
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x25770
movl 0x4(%rsp), %edi
movl %eax, %esi
callq 0x2a7b0
movq 0x8(%rsp), %rdi
movzwl %ax, %esi
callq 0x26df0
jmp 0x29acd
movq 0x8(%rsp), %rdi
callq 0x2af90
movq 0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x20(%rsp)
jmp 0x29a87
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: SethKasmann[P]clever-girl/src/move_generator.cpp
// Function: void MoveList::generateMoves<(MoveType)0>()
void MoveList::generateMoves()
{
    assert(!mState.inCheck());

    if (T == MoveType::QuietChecks)
        mDiscover = mState.getDiscoveredChecks(mState.getOurColor());

    mValid = T == MoveType::Attacks 
                ? mState.getOccupancyBB(mState.getTheirColor())
                : mState.getEmptyBB();

    mState.getOurColor() == white ? pushPawnMoves<T, white>() 
                                  : pushPawnMoves<T, black>();
    pushMoves<T, knight>();
    pushMoves<T, bishop>();
    pushMoves<T, rook>();
    pushMoves<T, queen>();
    pushMoves<T, king>();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, (%rsp)
movq 0x18(%rax), %rdi
callq 0x28740
movq (%rsp), %rdi
movl %eax, %esi
callq 0x25740
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rax), %rdi
callq 0x24ca0
cmpl $0x0, %eax
jne 0x29b85
movq 0x8(%rsp), %rdi
callq 0x2b450
jmp 0x29b8f
movq 0x8(%rsp), %rdi
callq 0x2b5f0
movq 0x8(%rsp), %rdi
callq 0x2b7a0
movq 0x8(%rsp), %rdi
callq 0x2b890
movq 0x8(%rsp), %rdi
callq 0x2b980
movq 0x8(%rsp), %rdi
callq 0x2ba70
movq 0x8(%rsp), %rdi
callq 0x2bb60
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: SethKasmann[P]clever-girl/src/state.h
// Function: State::attacked(Square) const
inline
bool State::attacked(Square s) const
{
    return getAttackBB< pawn >(s, mUs) &  getPieceBB< pawn >(mThem)
        || getAttackBB<knight>(s) &  getPieceBB<knight>(mThem)
        || getAttackBB<bishop>(s) & (getPieceBB<bishop>(mThem) | getPieceBB<queen>(mThem))
        || getAttackBB< rook >(s) & (getPieceBB< rook >(mThem) | getPieceBB<queen>(mThem));
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl 0x3c(%rsp), %esi
movl (%rdi), %edx
callq 0x257b0
movq 0x28(%rsp), %rdi
movq %rax, 0x30(%rsp)
movl 0x4(%rdi), %esi
callq 0x24b80
movq 0x30(%rsp), %rcx
andq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, 0x3b(%rsp)
jne 0x2b339
movq 0x28(%rsp), %rdi
movl 0x3c(%rsp), %esi
xorl %edx, %edx
callq 0x25160
movq 0x28(%rsp), %rdi
movq %rax, 0x20(%rsp)
movl 0x4(%rdi), %esi
callq 0x25bb0
movq 0x20(%rsp), %rcx
andq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, 0x3b(%rsp)
jne 0x2b339
movq 0x28(%rsp), %rdi
movl 0x3c(%rsp), %esi
xorl %edx, %edx
callq 0x25370
movq 0x28(%rsp), %rdi
movq %rax, 0x10(%rsp)
movl 0x4(%rdi), %esi
callq 0x25bf0
movq 0x28(%rsp), %rdi
movq %rax, 0x18(%rsp)
movl 0x4(%rdi), %esi
callq 0x2b3d0
movq 0x10(%rsp), %rcx
movq %rax, %rdx
movq 0x18(%rsp), %rax
orq %rdx, %rax
andq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, 0x3b(%rsp)
jne 0x2b339
movq 0x28(%rsp), %rdi
movl 0x3c(%rsp), %esi
xorl %edx, %edx
callq 0x25480
movq 0x28(%rsp), %rdi
movq %rax, 0x8(%rsp)
movl 0x4(%rdi), %esi
callq 0x2b410
movq 0x28(%rsp), %rdi
movq %rax, (%rsp)
movl 0x4(%rdi), %esi
callq 0x2b3d0
movq (%rsp), %rcx
movq %rax, %rdx
movq 0x8(%rsp), %rax
orq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
movb %al, 0x3b(%rsp)
movb 0x3b(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: SethKasmann[P]clever-girl/src/perft.cpp
// Function: perft(State&, int)
int perft(State & s, int depth)
{
	int nodes = 0;

	if (s.getFiftyMoveRule() > 99)
		return nodes;

	MoveList mlist(s);

	if (depth == 1)
		return mlist.size();

	Move m;

	while (m = mlist.getBestMove())
	{
		State c(s);
		c.make_t(m);
		nodes += perft(c, depth-1);
	}

	return nodes;
}

// Assembly:
subq $0xda8, %rsp            # imm = 0xDA8
movq %rdi, 0xd98(%rsp)
movl %esi, 0xd94(%rsp)
movl $0x0, 0xd90(%rsp)
movq 0xd98(%rsp), %rdi
callq 0x30090
cmpl $0x63, %eax
jle 0x2f2f6
movl 0xd90(%rsp), %eax
movl %eax, 0xda4(%rsp)
jmp 0x2f40f
movq 0xd98(%rsp), %rsi
leaq 0x538(%rsp), %rdi
callq 0x28590
cmpl $0x1, 0xd94(%rsp)
jne 0x2f36b
leaq 0x538(%rsp), %rdi
callq 0x26dd0
movq %rax, 0x10(%rsp)
jmp 0x2f329
movq 0x10(%rsp), %rax
movl %eax, 0xda4(%rsp)
movl $0x1, 0x528(%rsp)
jmp 0x2f402
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x530(%rsp)
movl %eax, 0x52c(%rsp)
leaq 0x538(%rsp), %rdi
callq 0x263d0
jmp 0x2f41e
jmp 0x2f36d
leaq 0x538(%rsp), %rdi
callq 0x27210
movw %ax, 0xe(%rsp)
jmp 0x2f381
movw 0xe(%rsp), %ax
movw %ax, 0x526(%rsp)
cmpw $0x0, %ax
je 0x2f3e9
movq 0xd98(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x36210
jmp 0x2f3a8
movzwl 0x526(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x38340
jmp 0x2f3bc
movl 0xd94(%rsp), %esi
decl %esi
leaq 0x18(%rsp), %rdi
callq 0x2f2b0
movl %eax, 0x8(%rsp)
jmp 0x2f3d5
movl 0x8(%rsp), %eax
addl 0xd90(%rsp), %eax
movl %eax, 0xd90(%rsp)
jmp 0x2f36d
movl 0xd90(%rsp), %eax
movl %eax, 0xda4(%rsp)
movl $0x1, 0x528(%rsp)
leaq 0x538(%rsp), %rdi
callq 0x263d0
movl 0xda4(%rsp), %eax
addq $0xda8, %rsp            # imm = 0xDA8
retq
movq 0x530(%rsp), %rdi
callq 0x54b0
nopl (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/perft.cpp
// Function: test(State, MoveList*, int, int)
void test(State s, MoveList* mList, int depth, int id)
{
	{
		std::unique_lock<std::mutex> lk(qMutex);
		cv.wait(lk, [] { return ready; });
	}

	Move m;

	{
		std::lock_guard<std::mutex> lk(qMutex);
		m = mList->getBestMove();
	}

	while (m != nullMove)
	{
		State c(s);
		c.make_t(m);
		int nodes = perft(c, depth - 1);
		
		{
			std::lock_guard<std::mutex> lk(qMutex);
			nodeCount.push_back(nodes);
			m = mList->getBestMove();
		} 
	}
}

// Assembly:
subq $0x588, %rsp            # imm = 0x588
movq %rdi, 0x18(%rsp)
movq %rdi, 0x580(%rsp)
movq %rsi, 0x578(%rsp)
movl %edx, 0x574(%rsp)
movl %ecx, 0x570(%rsp)
leaq 0x1b1a77(%rip), %rsi    # 0x1e0ed8
leaq 0x560(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x30110
movq 0x20(%rsp), %rsi
leaq 0x1b1a29(%rip), %rdi    # 0x1e0ea8
callq 0x2f600
jmp 0x2f486
leaq 0x560(%rsp), %rdi
callq 0x30150
leaq 0x1b1a3e(%rip), %rsi    # 0x1e0ed8
leaq 0x540(%rsp), %rdi
callq 0x30190
movq 0x578(%rsp), %rdi
callq 0x27210
movw %ax, 0x16(%rsp)
jmp 0x2f4bb
movw 0x16(%rsp), %ax
movw %ax, 0x54a(%rsp)
leaq 0x540(%rsp), %rdi
callq 0x301c0
movzwl 0x54a(%rsp), %eax
cmpl $0x0, %eax
je 0x2f5dd
movq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x36210
movq 0x8(%rsp), %rdi
movzwl 0x54a(%rsp), %esi
callq 0x38340
movq 0x8(%rsp), %rdi
movl 0x574(%rsp), %esi
decl %esi
callq 0x2f2b0
movl %eax, 0x34(%rsp)
leaq 0x1b19ae(%rip), %rsi    # 0x1e0ed8
leaq 0x28(%rsp), %rdi
callq 0x30190
leaq 0x1b1a15(%rip), %rdi    # 0x1e0f50
leaq 0x34(%rsp), %rsi
callq 0x301e0
jmp 0x2f547
movq 0x578(%rsp), %rdi
callq 0x27210
movw %ax, 0x6(%rsp)
jmp 0x2f55b
movw 0x6(%rsp), %ax
movw %ax, 0x54a(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x301c0
jmp 0x2f4d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x550(%rsp)
movl %eax, 0x54c(%rsp)
leaq 0x560(%rsp), %rdi
callq 0x30150
jmp 0x2f5e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x550(%rsp)
movl %eax, 0x54c(%rsp)
leaq 0x540(%rsp), %rdi
callq 0x301c0
jmp 0x2f5e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x550(%rsp)
movl %eax, 0x54c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x301c0
jmp 0x2f5e5
addq $0x588, %rsp            # imm = 0x588
retq
movq 0x550(%rsp), %rdi
callq 0x54b0
nopw %cs:(%rax,%rax)
// File: SethKasmann[P]clever-girl/src/perft.cpp
// Function: MTperft(State&, int)
int MTperft(State& s, int depth)
{
	unsigned int nThreads = std::thread::hardware_concurrency();
	std::vector<std::thread> threads;
	nodeCount.clear();
	MoveList mlist(s);

	for (unsigned int i = 0; i < nThreads; ++i)
		threads.push_back(std::thread(test, s, &mlist, depth, i));

	{
		std::lock_guard<std::mutex> lk(qMutex);
		ready = true;
		cv.notify_all();
	}

	for (std::thread& thread : threads)
		thread.join();

	return std::accumulate(nodeCount.begin(), nodeCount.end(), 0);
}

// Assembly:
subq $0x8e8, %rsp            # imm = 0x8E8
movq %rdi, 0x8e0(%rsp)
movl %esi, 0x8dc(%rsp)
callq 0x5380
movl %eax, 0x8d8(%rsp)
leaq 0x8c0(%rsp), %rdi
callq 0x30250
leaq 0x1b18da(%rip), %rdi    # 0x1e0f50
callq 0x30260
movq 0x8e0(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x28590
jmp 0x2f68f
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x8d8(%rsp), %eax
jae 0x2f74d
movq 0x8e0(%rsp), %rdx
leaq 0x68(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq -0x291(%rip), %rsi      # 0x2f430
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rcx
leaq 0x8dc(%rsp), %r8
leaq 0x58(%rsp), %r9
callq 0x302b0
jmp 0x2f6df
leaq 0x8c0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x30280
jmp 0x2f6f3
leaq 0x50(%rsp), %rdi
callq 0x303a0
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x2f697
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x2f84d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x2f843
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x303a0
jmp 0x2f843
leaq 0x1b1784(%rip), %rsi    # 0x1e0ed8
leaq 0x40(%rsp), %rdi
callq 0x30190
jmp 0x2f760
movb $0x1, 0x1b1739(%rip)    # 0x1e0ea0
leaq 0x1b173a(%rip), %rdi    # 0x1e0ea8
callq 0x5470
leaq 0x40(%rsp), %rdi
callq 0x301c0
leaq 0x8c0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x303c0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x303f0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x30420
testb $0x1, %al
jne 0x2f7bd
jmp 0x2f7e6
leaq 0x30(%rsp), %rdi
callq 0x30460
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5480
jmp 0x2f7d8
jmp 0x2f7da
leaq 0x30(%rsp), %rdi
callq 0x30470
jmp 0x2f7a8
leaq 0x1b1763(%rip), %rdi    # 0x1e0f50
movq %rdi, (%rsp)
callq 0x304f0
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x30520
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x30490
movl %eax, 0xc(%rsp)
jmp 0x2f820
leaq 0x68(%rsp), %rdi
callq 0x263d0
leaq 0x8c0(%rsp), %rdi
callq 0x30550
movl 0xc(%rsp), %eax
addq $0x8e8, %rsp            # imm = 0x8E8
retq
leaq 0x68(%rsp), %rdi
callq 0x263d0
leaq 0x8c0(%rsp), %rdi
callq 0x30550
movq 0x60(%rsp), %rdi
callq 0x54b0
nopw %cs:(%rax,%rax)
// File: SethKasmann[P]clever-girl/src/perft.cpp
// Function: perftTestDebug()
void perftTestDebug()
{
	int nodes;
	for (int i = 0; i < totalTests; ++i)
	{
		history.clear();
		State s(perftFen[i]);
		history.push(std::make_pair(nullMove, s.getKey()));
		nodes = MTperft(s, perftDepth[i]);
		//std::cout << perftFen[i] << std::endl;
		std::cout << (nodes == perftResults[i] ? "Success " : "Fail ")
		          << nodes << " == " << perftResults[i] << std::endl;
	}
}

// Assembly:
subq $0x528, %rsp            # imm = 0x528
movl $0x0, 0x520(%rsp)
cmpl $0x13, 0x520(%rsp)
jge 0x2fe4d
leaq 0x1a9089(%rip), %rdi    # 0x1d8dc0
callq 0x306e0
movslq 0x520(%rsp), %rax
leaq 0x1a8e15(%rip), %rsi    # 0x1d8b60
shlq $0x5, %rax
addq %rax, %rsi
leaq 0x18(%rsp), %rdi
callq 0x36550
leaq 0x18(%rsp), %rdi
callq 0x308b0
movq %rax, (%rsp)
leaq 0x1357b(%rip), %rdi     # 0x432ec
movq %rsp, %rsi
callq 0x30870
movw %ax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x1a9036(%rip), %rdi    # 0x1d8dc0
leaq 0x8(%rsp), %rsi
callq 0x30840
movslq 0x520(%rsp), %rcx
leaq 0x134fd(%rip), %rax     # 0x432a0
movl (%rax,%rcx,4), %esi
leaq 0x18(%rsp), %rdi
callq 0x2f640
movl %eax, 0x524(%rsp)
movl 0x524(%rsp), %ecx
movslq 0x520(%rsp), %rdx
leaq 0x13523(%rip), %rax     # 0x432f0
movl (%rax,%rdx,4), %edx
leaq 0x134a8(%rip), %rsi     # 0x4327f
leaq 0x13498(%rip), %rax     # 0x43276
cmpl %edx, %ecx
cmoveq %rax, %rsi
movq 0x211cd(%rip), %rdi     # 0x50fb8
callq 0x5290
movq %rax, %rdi
movl 0x524(%rsp), %esi
callq 0x5490
movq %rax, %rdi
leaq 0x1347c(%rip), %rsi     # 0x43285
callq 0x5290
movq %rax, %rdi
movslq 0x520(%rsp), %rcx
leaq 0x134d0(%rip), %rax     # 0x432f0
movl (%rax,%rcx,4), %esi
callq 0x5490
movq %rax, %rdi
movq 0x2115e(%rip), %rsi     # 0x50f90
callq 0x52c0
movl 0x520(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x520(%rsp)
jmp 0x2fd22
addq $0x528, %rsp            # imm = 0x528
retq
nopw %cs:(%rax,%rax)
// File: SethKasmann[P]clever-girl/src/history.h
// Function: History::History()
History()
	: mKillers{}, mHistory{}
	{
		mGameHistory.reserve(1024);
		for (std::array<int, Board_size>& arr : mButterfly)
			arr.fill(1);
	}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x308c0
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x30(%rsp)
xorl %esi, %esi
movl $0xc8, %edx
callq 0x5150
movq 0x30(%rsp), %rax
movq %rax, %rcx
addq $0xc8, %rcx
movq %rcx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x308d0
jmp 0x2ff65
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %rax
addq $0x4, %rax
cmpq %rcx, %rax
movq %rax, 0x40(%rsp)
jne 0x2ff54
movq 0x28(%rsp), %rdi
addq $0x40e0, %rdi           # imm = 0x40E0
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
callq 0x5150
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x4000, %rcx           # imm = 0x4000
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
addq $0x100, %rax            # imm = 0x100
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x2ffb3
movq 0x28(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x308f0
jmp 0x2ffde
movq 0x28(%rsp), %rax
addq $0xe0, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x30a00
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x30a10
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0x30069
movq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movl $0x1, 0x4c(%rsp)
leaq 0x4c(%rsp), %rsi
callq 0x30a30
jmp 0x3003b
jmp 0x3003d
movq 0x60(%rsp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x60(%rsp)
jmp 0x3000c
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
callq 0x30a80
jmp 0x30071
addq $0x88, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x54b0
nopl (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/history.h
// Function: History::clear()
void clear()
	{
		mKillers = {};
		mHistory = {};
		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 0x3072c
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 0x30792
movq 0x18(%rsp), %rdi
addq $0x40e0, %rdi           # imm = 0x40E0
leaq 0x58(%rsp), %rsi
movl $0x4000, %edx           # imm = 0x4000
callq 0x51f0
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 0x30833
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 0x307f4
addq $0x4128, %rsp           # imm = 0x4128
retq
nopl (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/search.cpp
// Function: interrupt(SearchInfo&)
bool interrupt(SearchInfo& si)
{
    // Check to see if we have run out of time.
    if (si.clock.elapsed<std::chrono::milliseconds>() >= si.moveTime
        && !si.infinite)
    {
        si.quit = true;
        return true;
    }

    if (input_waiting())
    {
        std::string command(get_input());
        if (command == "quit" || command == "stop")
        {
            si.quit = true;
            return true;
        }
    }

    // The GUI should be able to send quit commands as well.
    // I may need multiple threads for this.
    return false;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
addq $0x30, %rdi
callq 0x35340
movq 0x48(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jl 0x33a90
movq 0x48(%rsp), %rax
testb $0x1, 0x38(%rax)
jne 0x33a90
movq 0x48(%rsp), %rax
movb $0x1, 0x3a(%rax)
movb $0x1, 0x57(%rsp)
jmp 0x33b46
callq 0x35390
cmpl $0x0, %eax
je 0x33b41
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x354c0
movq 0x8(%rsp), %rdi
leaq 0xf8d7(%rip), %rsi      # 0x43390
callq 0x35540
movb %al, 0x17(%rsp)
jmp 0x33ac4
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x33aef
jmp 0x33ace
leaq 0xf8c0(%rip), %rsi      # 0x43395
leaq 0x28(%rsp), %rdi
callq 0x35540
movb %al, 0x7(%rsp)
jmp 0x33ae5
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x33aef
jmp 0x33b21
movq 0x48(%rsp), %rax
movb $0x1, 0x3a(%rax)
movb $0x1, 0x57(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x33b29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5538
jmp 0x33b51
movl $0x0, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5538
movl 0x18(%rsp), %eax
testl %eax, %eax
je 0x33b3f
jmp 0x33b3d
jmp 0x33b46
jmp 0x33b41
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x54b0
nopl (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/search.cpp
// Function: setup_search(State&, SearchInfo&)
void setup_search(State& s, SearchInfo& si)
{
    //ttable.setAncient();
    ttable.clear();
    lineManager.clearPv();
    init_eval();
    history.clear();
    iterative_deepening(s, si);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x21b38b(%rip), %rdi    # 0x250690
callq 0x35b40
leaq 0x1dc46f(%rip), %rdi    # 0x211780
callq 0x25e80
callq 0x35bf0
leaq 0x1e141e(%rip), %rdi    # 0x216740
callq 0x306e0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x34f50
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: SethKasmann[P]clever-girl/src/misc.h
// Function: input_waiting()
inline int input_waiting()
{
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
	static int init = 0, pipe;
	static HANDLE inh;
	DWORD dw;

	if (!init)
	{
		init = 1;
		inh = GetStdHandle(STD_INPUT_HANDLE);
		pipe = !GetConsoleMode(inh, &dw);
		if (!pipe)
		{
			SetConsoleMode(inh, dw & ~(ENABLE_MOUSE_INPUT|ENABLE_WINDOW_INPUT));
			FlushConsoleInputBuffer(inh);
		}
	}
	if (pipe)
	{
		if (!PeekNamedPipe(inh, NULL, 0, NULL, &dw, NULL))
			return 1;
		return dw;
	}
	else
	{
		GetNumberOfConsoleInputEvents(inh, &dw);
		return dw <= 1 ? 0 : dw;
	}
#else
	fd_set readfds;
	timeval tv;
	FD_ZERO(&readfds);
	FD_SET(fileno(stdin), &readfds);
	tv.tv_sec = 0;
	tv.tv_usec = 0;
	select(16, &readfds, 0, 0, &tv);
	return (FD_ISSET(fileno(stdin), &readfds));
#endif
}

// Assembly:
subq $0xb8, %rsp
leaq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpq $0x10, %rax
jae 0x353d1
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
movq $0x0, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x353a9
jmp 0x353d3
movq 0x1bbd6(%rip), %rax     # 0x50fb0
movq (%rax), %rdi
callq 0x52d0
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x8(%rsp)
movq 0x1bbae(%rip), %rax     # 0x50fb0
movq (%rax), %rdi
callq 0x52d0
movq 0x8(%rsp), %rcx
movl $0x40, %esi
cltd
idivl %esi
cltq
orq 0x38(%rsp,%rax,8), %rcx
movq %rcx, 0x38(%rsp,%rax,8)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x10, %edi
leaq 0x38(%rsp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x28(%rsp), %r8
movq %rcx, %rdx
callq 0x5250
movq 0x1bb59(%rip), %rax     # 0x50fb0
movq (%rax), %rdi
callq 0x52d0
movl $0x40, %ecx
cltd
idivl %ecx
cltq
movq 0x38(%rsp,%rax,8), %rax
movq %rax, 0x10(%rsp)
movq 0x1bb36(%rip), %rax     # 0x50fb0
movq (%rax), %rdi
callq 0x52d0
movl $0x40, %ecx
cltd
idivl %ecx
movq 0x10(%rsp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: SethKasmann[P]clever-girl/src/history.h
// Function: History::isThreefoldRepetition(State&) const
bool isThreefoldRepetition(State& pState) const
	{
		if (mGameHistory.size() < 5)
			return false;
		int candidate = mGameHistory.size() - 5;
		if (mGameHistory[candidate].second == mGameHistory.back().second)
			return true;
		return false;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x30bb0
cmpq $0x5, %rax
jae 0x3559a
movb $0x0, 0x37(%rsp)
jmp 0x355e8
movq 0x10(%rsp), %rdi
callq 0x30bb0
movq 0x10(%rsp), %rdi
subq $0x5, %rax
movl %eax, 0x1c(%rsp)
movslq 0x1c(%rsp), %rsi
callq 0x35c40
movq 0x10(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x35c60
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq 0x8(%rcx), %rax
jne 0x355e3
movb $0x1, 0x37(%rsp)
jmp 0x355e8
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: SethKasmann[P]clever-girl/src/history.h
// Function: History::update(unsigned short, int, int, bool)
void update(Move pBest, int pDepth, int ply, bool causedCutoff)
	{
		if (causedCutoff)
		{
			if (mKillers[ply].first != pBest)
			{
				mKillers[ply].second = mKillers[ply].first;
				mKillers[ply].first = pBest;
			}
			mHistory[getSrc(pBest)][getDst(pBest)] += pDepth * pDepth;
		}
		else
			mButterfly[getSrc(pBest)][getDst(pBest)] += pDepth;
	}

// Assembly:
subq $0x58, %rsp
movb %r8b, %al
movq %rdi, 0x50(%rsp)
movw %si, 0x4e(%rsp)
movl %edx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
andb $0x1, %al
movb %al, 0x43(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
testb $0x1, 0x43(%rsp)
je 0x3599b
movq 0x38(%rsp), %rdi
addq $0x18, %rdi
movslq 0x44(%rsp), %rsi
callq 0x35ec0
movzwl (%rax), %eax
movzwl 0x4e(%rsp), %ecx
cmpl %ecx, %eax
je 0x3593f
movq 0x38(%rsp), %rdi
addq $0x18, %rdi
movslq 0x44(%rsp), %rsi
callq 0x35ec0
movq 0x38(%rsp), %rdi
movw (%rax), %ax
movw %ax, 0x34(%rsp)
addq $0x18, %rdi
movslq 0x44(%rsp), %rsi
callq 0x35ec0
movw 0x34(%rsp), %cx
movq 0x38(%rsp), %rdi
movw %cx, 0x2(%rax)
movw 0x4e(%rsp), %ax
movw %ax, 0x36(%rsp)
addq $0x18, %rdi
movslq 0x44(%rsp), %rsi
callq 0x35ec0
movw 0x36(%rsp), %cx
movw %cx, (%rax)
movq 0x38(%rsp), %rax
movl 0x48(%rsp), %ecx
imull 0x48(%rsp), %ecx
movl %ecx, 0x30(%rsp)
addq $0x40e0, %rax           # imm = 0x40E0
movq %rax, 0x20(%rsp)
movzwl 0x4e(%rsp), %edi
callq 0x26810
movq 0x20(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x35ef0
movq %rax, 0x28(%rsp)
movzwl 0x4e(%rsp), %edi
callq 0x26830
movq 0x28(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x35f20
movl 0x30(%rsp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x359f0
movq 0x38(%rsp), %rax
movl 0x48(%rsp), %ecx
movl %ecx, 0x1c(%rsp)
addq $0xe0, %rax
movq %rax, 0x8(%rsp)
movzwl 0x4e(%rsp), %edi
callq 0x26810
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x35ef0
movq %rax, 0x10(%rsp)
movzwl 0x4e(%rsp), %edi
callq 0x26830
movq 0x10(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x35f20
movl 0x1c(%rsp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: SethKasmann[P]clever-girl/src/transpositiontable.h
// Function: TranspositionTable::store(unsigned long long, unsigned short, NodeType, int, int)
void store(U64 key, Move best, NodeType type, int depth, int score)
    {
        int i = key % table.size();
        if (table[i].depth < depth ||
            table[i].ancient ||
            type == pv)
        {
            table[i].key     = key;
            table[i].best    = best;
            table[i].type    = type;
            table[i].depth   = depth;
            table[i].score   = score;
            table[i].ancient = false;
        }
    }

// Assembly:
subq $0x58, %rsp
movw %dx, %ax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movw %ax, 0x46(%rsp)
movl %ecx, 0x40(%rsp)
movl %r8d, 0x3c(%rsp)
movl %r9d, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x35e90
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movq 0x28(%rsp), %rax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x34(%rsp)
movslq 0x34(%rsp), %rsi
callq 0x35f50
movl 0x10(%rax), %eax
cmpl 0x3c(%rsp), %eax
jl 0x35a88
movq 0x20(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0x35f50
testb $0x1, 0x18(%rax)
jne 0x35a88
cmpl $0x0, 0x40(%rsp)
jne 0x35b38
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x34(%rsp), %rsi
callq 0x35f50
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rdi
movq %rcx, (%rax)
movw 0x46(%rsp), %ax
movw %ax, 0x12(%rsp)
movslq 0x34(%rsp), %rsi
callq 0x35f50
movw 0x12(%rsp), %cx
movq 0x20(%rsp), %rdi
movw %cx, 0x8(%rax)
movl 0x40(%rsp), %eax
movl %eax, 0x14(%rsp)
movslq 0x34(%rsp), %rsi
callq 0x35f50
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rdi
movl %ecx, 0xc(%rax)
movl 0x3c(%rsp), %eax
movl %eax, 0x18(%rsp)
movslq 0x34(%rsp), %rsi
callq 0x35f50
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rdi
movl %ecx, 0x10(%rax)
movl 0x38(%rsp), %eax
movl %eax, 0x1c(%rsp)
movslq 0x34(%rsp), %rsi
callq 0x35f50
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rdi
movl %ecx, 0x14(%rax)
movslq 0x34(%rsp), %rsi
callq 0x35f50
movb $0x0, 0x18(%rax)
addq $0x58, %rsp
retq
nopl (%rax)
// File: SethKasmann[P]clever-girl/src/transpositiontable.h
// Function: TranspositionTable::clear()
void clear()
    {
        for (TableEntry& tableEntry : table)
        {
            tableEntry.key     = 0;
            tableEntry.best    = nullMove;
            tableEntry.type    = pv;
            tableEntry.depth   = 0;
            tableEntry.score   = 0;
            tableEntry.ancient = true;
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x35f70
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x35fa0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x35fd0
testb $0x1, %al
jne 0x35b86
jmp 0x35bde
leaq 0x10(%rsp), %rdi
callq 0x36010
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movw $0x0, 0x8(%rax)
movq (%rsp), %rax
movl $0x0, 0xc(%rax)
movq (%rsp), %rax
movl $0x0, 0x10(%rax)
movq (%rsp), %rax
movl $0x0, 0x14(%rax)
movq (%rsp), %rax
movb $0x1, 0x18(%rax)
leaq 0x10(%rsp), %rdi
callq 0x36020
jmp 0x35b71
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: SethKasmann[P]clever-girl/src/state.cpp
// Function: State::operator=(State const&)
void State::operator=(const State & s)
{
    mUs = s.mUs;
    mThem = s.mThem;
    mFiftyMoveRule = s.mFiftyMoveRule;
    mCastleRights = s.mCastleRights;
    mPhase = s.mPhase;
    mKey = s.mKey;
    mPawnKey = s.mPawnKey;
    mCheckers = s.mCheckers;
    mEnPassant = s.mEnPassant;
    mCheckSquares = s.mCheckSquares;
    mPinned = s.mPinned;
    mOccupancy = s.mOccupancy;
    mPieceIndex = s.mPieceIndex;
    mBoard = s.mBoard;
    mPieces = s.mPieces;
    mPieceCount = s.mPieceCount;
    mPstScore = s.mPstScore;
    mPieceList = s.mPieceList;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rdi)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rdi)
movq 0x8(%rsp), %rax
movss 0x10(%rax), %xmm0
movss %xmm0, 0x10(%rdi)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rdi)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rdi)
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x28(%rdi)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x30(%rdi)
movq 0x8(%rsp), %rsi
addq $0x38, %rsi
addq $0x38, %rdi
movl $0x30, %edx
callq 0x51f0
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rcx
movq %rcx, 0x68(%rdi)
movq 0x70(%rax), %rax
movq %rax, 0x70(%rdi)
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rcx
movq %rcx, 0x78(%rdi)
movq 0x80(%rax), %rax
movq %rax, 0x80(%rdi)
movq 0x8(%rsp), %rsi
addq $0x88, %rsi
addq $0x88, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0x51f0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x188, %rsi            # imm = 0x188
addq $0x188, %rdi            # imm = 0x188
movl $0x100, %edx            # imm = 0x100
callq 0x51f0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x288, %rsi            # imm = 0x288
addq $0x288, %rdi            # imm = 0x288
movl $0x60, %edx
callq 0x51f0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x2e8, %rsi            # imm = 0x2E8
addq $0x2e8, %rdi            # imm = 0x2E8
movl $0x30, %edx
callq 0x51f0
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x318(%rax), %rcx
movq %rcx, 0x318(%rdi)
movq 0x320(%rax), %rax
movq %rax, 0x320(%rdi)
movq 0x8(%rsp), %rsi
addq $0x328, %rsi            # imm = 0x328
addq $0x328, %rdi            # imm = 0x328
movl $0x1e0, %edx            # imm = 0x1E0
callq 0x51f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: SethKasmann[P]clever-girl/src/state.cpp
// Function: State::init()
void State::init()
{
    mUs = white;
    mThem = black;
    mFiftyMoveRule = 0;
    mCastleRights = 0;
    mKey = 0;
    mPawnKey = 0;
    mCheckers = 0;
    mEnPassant = 0;
    mCheckSquares.fill({});
    mPinned.fill({});
    mOccupancy.fill({});
    mPieceIndex.fill({});
    mBoard.fill(none);
    mPieces.fill({});
    mPieceCount.fill({});
    mPstScore.fill({});
    for (auto i = mPieceList.begin(); i != mPieceList.end(); ++i)
        for (auto j = i->begin(); j != i->end(); ++j)
            j->fill(no_sq);
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movl $0x0, (%rdi)
movl $0x1, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movq $0x0, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
addq $0x38, %rdi
movq $0x0, 0xb8(%rsp)
leaq 0xb8(%rsp), %rsi
callq 0x39d90
movq 0x30(%rsp), %rdi
addq $0x68, %rdi
movq $0x0, 0xb0(%rsp)
leaq 0xb0(%rsp), %rsi
callq 0x39de0
movq 0x30(%rsp), %rdi
addq $0x78, %rdi
movq $0x0, 0xa8(%rsp)
leaq 0xa8(%rsp), %rsi
callq 0x39de0
movq 0x30(%rsp), %rdi
addq $0x88, %rdi
movl $0x0, 0xa4(%rsp)
leaq 0xa4(%rsp), %rsi
callq 0x30a30
movq 0x30(%rsp), %rdi
addq $0x188, %rdi            # imm = 0x188
movl $0x6, 0xa0(%rsp)
leaq 0xa0(%rsp), %rsi
callq 0x39e30
movq 0x30(%rsp), %rax
addq $0x288, %rax            # imm = 0x288
movq %rax, 0x18(%rsp)
leaq 0x70(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x5150
movq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x39e80
movq 0x30(%rsp), %rax
addq $0x2e8, %rax            # imm = 0x2E8
movq %rax, 0x20(%rsp)
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x5150
movq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x39ed0
movq 0x30(%rsp), %rax
addq $0x318, %rax            # imm = 0x318
movq %rax, 0x28(%rsp)
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x5150
movq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x39f20
movq 0x30(%rsp), %rdi
addq $0x328, %rdi            # imm = 0x328
callq 0x39f70
movq %rax, 0x48(%rsp)
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x328, %rdi            # imm = 0x328
callq 0x39f80
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x36bdc
movq 0x48(%rsp), %rdi
callq 0x39fa0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x39fb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x36bc5
movq 0x40(%rsp), %rdi
movl $0x40, 0x3c(%rsp)
leaq 0x3c(%rsp), %rsi
callq 0x39fd0
movq 0x40(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x40(%rsp)
jmp 0x36b7d
jmp 0x36bc7
movq 0x48(%rsp), %rax
addq $0xf0, %rax
movq %rax, 0x48(%rsp)
jmp 0x36b46
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: SethKasmann[P]clever-girl/src/state.cpp
// Function: State::getDiscoveredChecks(Color) const
U64 State::getDiscoveredChecks(Color c) const
{
    U64 pinners, ray, discover = 0;
    Square kingSq = getKingSquare(!c);

    pinners = bishopMoves[kingSq] & (getPieceBB<bishop>(c) | getPieceBB<queen>(c));

    while (pinners)
    {
        ray = between_dia[pop_lsb(pinners)][kingSq] & getOccupancyBB();
        if (pop_count(ray) == 1)
            discover |= ray & getOccupancyBB(c);
    }

    pinners = rookMoves[kingSq] & (getPieceBB<rook>(c) | getPieceBB<queen>(c));

    while (pinners)
    {
        ray = between_hor[pop_lsb(pinners)][kingSq] & getOccupancyBB();
        if (pop_count(ray) == 1)
            discover |= ray & getOccupancyBB(c);
    }

    return discover;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
movq $0x0, 0x50(%rsp)
movl 0x6c(%rsp), %edi
callq 0x24ce0
movq 0x30(%rsp), %rdi
movl %eax, %esi
callq 0x24ea0
movq 0x30(%rsp), %rdi
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, %ecx
leaq 0x13f885(%rip), %rax    # 0x176720
movq (%rax,%rcx,8), %rax
movq %rax, 0x40(%rsp)
movl 0x6c(%rsp), %esi
callq 0x25bf0
movq 0x30(%rsp), %rdi
movq %rax, 0x38(%rsp)
movl 0x6c(%rsp), %esi
callq 0x2b3d0
movq 0x38(%rsp), %rcx
movq %rax, %rdx
movq 0x40(%rsp), %rax
orq %rdx, %rcx
andq %rcx, %rax
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x36f68
leaq 0x60(%rsp), %rdi
callq 0x25770
movq 0x30(%rsp), %rdi
movl %eax, %eax
movl %eax, %ecx
leaq 0x11ee12(%rip), %rax    # 0x155d10
shlq $0x9, %rcx
addq %rcx, %rax
movl 0x4c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
callq 0x24bc0
movq %rax, %rcx
movq 0x28(%rsp), %rax
andq %rcx, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x24df0
cmpl $0x1, %eax
jne 0x36f63
movq 0x30(%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x6c(%rsp), %esi
callq 0x25740
movq %rax, %rcx
movq 0x20(%rsp), %rax
andq %rcx, %rax
orq 0x50(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x36ed8
movq 0x30(%rsp), %rdi
movl 0x4c(%rsp), %eax
movl %eax, %ecx
leaq 0x13f9a6(%rip), %rax    # 0x176920
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movl 0x6c(%rsp), %esi
callq 0x2b410
movq 0x30(%rsp), %rdi
movq %rax, 0x10(%rsp)
movl 0x6c(%rsp), %esi
callq 0x2b3d0
movq 0x10(%rsp), %rcx
movq %rax, %rdx
movq 0x18(%rsp), %rax
orq %rdx, %rcx
andq %rcx, %rax
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x37045
leaq 0x60(%rsp), %rdi
callq 0x25770
movq 0x30(%rsp), %rdi
movl %eax, %eax
movl %eax, %ecx
leaq 0x126d33(%rip), %rax    # 0x15dd10
shlq $0x9, %rcx
addq %rcx, %rax
movl 0x4c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
callq 0x24bc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
andq %rcx, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x24df0
cmpl $0x1, %eax
jne 0x37040
movq 0x30(%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movl 0x6c(%rsp), %esi
callq 0x25740
movq %rax, %rcx
movq (%rsp), %rax
andq %rcx, %rax
orq 0x50(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x36fb7
movq 0x50(%rsp), %rax
addq $0x78, %rsp
retq
nop