// File: /workspace/github_cpp_makefile_star2_O1/SethKasmann[P]clever-girl/src/evaluation.cpp
// Function: Evaluate::evalPieces(Color)
void Evaluate::evalPieces(const Color c)
{
    U64 moves, pins;
    U64 mobilityNet;
    int king_threats = 0;
    U64 bottomRank = c == white ? Rank_1 : Rank_8;
    Square kingSq = mState.getKingSquare(c);

    // The mobilityNet is all empty squares not attacked by enemy pawns.
    mobilityNet = mState.getEmptyBB();
    if (c == white)
        mobilityNet &= ~((mState.getPieceBB<pawn>(black) & Not_a_file) >> 7
                       | (mState.getPieceBB<pawn>(black) & Not_h_file) >> 9);
    else
        mobilityNet &= ~((mState.getPieceBB<pawn>(white) & Not_a_file) << 9
                       | (mState.getPieceBB<pawn>(white) & Not_h_file) << 7);

    // Get the pinned pieces for the current player.
    pins = mState.getPinsBB(c);

    // Knight evaluation.
    for (Square p : mState.getPieceList<knight>(c))
    {
        if (p == no_sq)
            break;
        mMaterial[c] += Knight_wt;
        mMaterial[c] += outpost<knight>(p, c);

        if (square_bb[p] & pins)
        {
            mMobility[c] += knightMobility[0];
            continue;
        }

        moves = mState.getAttackBB<knight>(p);
        mPieceAttacksBB[c][knight] |= moves & mState.getOccupancyBB();
        mAllAttacksBB[c] |= mPieceAttacksBB[c][knight];

        mMobility[c] += knightMobility[pop_count(moves & mobilityNet)];

        if (moves & king_net_bb[!c][mState.getKingSquare(!c)] & mobilityNet)
            king_threats += Knight_th;
    }

    // Bishop evaluation.
    for (Square p : mState.getPieceList<bishop>(c))
    {
        if (p == no_sq)
            break;
        mMaterial[c] += Bishop_wt;
        mMaterial[c] += outpost<bishop>(p, c);

        moves = mState.getAttackBB<bishop>(p);

        if (square_bb[p] & pins)
            moves &= coplanar[p][kingSq];

        mPieceAttacksBB[c][bishop] = moves & mState.getOccupancyBB();
        mAllAttacksBB[c] |= mPieceAttacksBB[c][bishop];

        if (moves & king_net_bb[!c][mState.getKingSquare(!c)] & mobilityNet)
            king_threats += Bishop_th;

        mMobility[c] += bishopMobility[pop_count(moves & mobilityNet)];

        // Check for a bad bishop (penalty for pawns on the same square);
        mMaterial[c] += BadBishop * 
            pop_count(squares_of_color(p) & mState.getPieceBB<pawn>(c));
    }

    // Rook evaluation.
    for (Square p : mState.getPieceList<rook>(c))
    {
        if (p == no_sq)
            break;
        mMaterial[c] += Rook_wt;

        moves = mState.getAttackBB<rook>(p);
        if (square_bb[p] & pins)
            moves &= coplanar[p][kingSq];

        mPieceAttacksBB[c][rook] = moves & mState.getOccupancyBB();
        mAllAttacksBB[c] |= mPieceAttacksBB[c][rook];

        if (moves & king_net_bb[!c][mState.getKingSquare(!c)] & mobilityNet)
            king_threats += Rook_th;

        mMobility[c] += rookMobility[pop_count(moves & mobilityNet)];

        // Check if the rook is trapped.
        // TODO: more testing to confirm this is working propertly.
        if (mState.getPieceBB<king>(c) & bottomRank 
            && square_bb[p] & bottomRank)
        {
            if ((kingSq > p && !mState.canCastleKingside(c) &&
                square_bb[kingSq] & Rightside) ||
                (kingSq < p && !mState.canCastleQueenside(c) &&
                square_bb[kingSq] & Leftside)) 
            {
                if (pop_count(moves & mobilityNet & ~(bottomRank)) <= 3)
                    mMaterial[c] += TrappedRook;
            }
        }
    }

    // Queen evaluation.
    for (Square p : mState.getPieceList<queen>(c))
    {
        if (p == no_sq)
            break;
        mMaterial[c] += Queen_wt;
        moves = mState.getAttackBB<queen>(p);
        if (square_bb[p] & pins)
            moves &= coplanar[p][kingSq];

        mPieceAttacksBB[c][queen] = moves & mState.getOccupancyBB();
        mAllAttacksBB[c] |= mPieceAttacksBB[c][queen];

        if (moves & king_net_bb[!c][mState.getKingSquare(!c)] & mobilityNet)
            king_threats += Queen_th;

        // Calculate queen mobility.
        mMobility[c] += queenMobility[pop_count(moves & mobilityNet)];
    }

    // King evaluation.
    mKingSafety[!c] -= Safety_table[king_threats];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq 0x328(%rax), %rcx
movl %esi, %r15d
imulq $0xf0, %r15, %rdi
movq 0x80(%rax), %r8
orq 0x78(%rax), %r8
movl $0xff, %edx
movabsq $-0x100000000000000, %r9 # imm = 0xFF00000000000000
movq %rdi, 0x30(%rsp)
movl 0x3f0(%rax,%rdi), %edi
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
testl %esi, %esi
cmoveq %rdx, %r9
movq %r9, 0x50(%rsp)
je 0xe593
movq 0x288(%rax), %rsi
movq %rsi, %rdx
shlq $0x9, %rdx
movabsq $-0x101010101010200, %rdi # imm = 0xFEFEFEFEFEFEFE00
andq %rdx, %rdi
shlq $0x7, %rsi
movabsq $0x7f7f7f7f7f7f7f00, %rdx # imm = 0x7F7F7F7F7F7F7F00
jmp 0xe5bc
movq 0x2b8(%rax), %rsi
movq %rsi, %rdx
shrq $0x7, %rdx
movabsq $0xfefefefefefefe, %rdi # imm = 0xFEFEFEFEFEFEFE
andq %rdx, %rdi
shrq $0x9, %rsi
movabsq $0x7f7f7f7f7f7f7f, %rdx # imm = 0x7F7F7F7F7F7F7F
andq %rsi, %rdx
orq %rdi, %rdx
xorl %esi, %esi
cmpl $0x0, 0xc(%rsp)
sete %sil
orq %rdx, %r8
notq %r8
movq %r8, 0x38(%rsp)
movq 0x68(%rax,%r15,8), %rax
movq %rax, 0x40(%rsp)
movq 0x30(%rsp), %rax
leaq (%rcx,%rax), %r13
addq $0x28, %r13
leaq (%r15,%r15,2), %rax
shlq $0x4, %rax
movq %rax, 0x48(%rsp)
addq %rbx, %rax
addq $0x48, %rax
movq %rax, 0x20(%rsp)
xorl %ebp, %ebp
movq $-0x28, %r12
movq %rsi, 0x28(%rsp)
imulq $0xf0, %rsi, %rax
movq %rax, 0x18(%rsp)
movl 0x28(%r13,%r12), %r14d
movl $0x2, %eax
cmpq $0x40, %r14
je 0xe747
addl $0x12c, 0x2c(%rbx,%r15,4) # imm = 0x12C
movq %rbx, %rdi
movl %r14d, %esi
movl 0xc(%rsp), %edx
callq 0xf662
addl %eax, 0x2c(%rbx,%r15,4)
movq 0x40(%rsp), %rax
leaq 0xea411(%rip), %rcx     # 0xf8a70
testq %rax, (%rcx,%r14,8)
je 0xe675
addl $-0x1e, 0x14(%rbx,%r15,4)
movl $0x3, %eax
jmp 0xe747
leaq 0xd4c4(%rip), %rax      # 0x1bb40
movq (%rax,%r14,8), %rax
movq 0x8(%rbx), %rcx
movq 0x80(%rcx), %rdx
orq 0x78(%rcx), %rdx
andq %rax, %rdx
movq 0x20(%rsp), %rsi
orq (%rsi), %rdx
movq %rdx, (%rsi)
orq %rdx, 0xa0(%rbx,%r15,8)
movq %rax, %rdx
movq 0x38(%rsp), %rdi
andq %rdi, %rdx
movq %rdx, %rsi
shrq %rsi
movabsq $0x5555555555555555, %r8 # imm = 0x5555555555555555
andq %r8, %rsi
subq %rsi, %rdx
movq %rdx, %rsi
movabsq $0x3333333333333333, %r8 # imm = 0x3333333333333333
andq %r8, %rsi
shrq $0x2, %rdx
andq %r8, %rdx
addq %rsi, %rdx
movq %rdx, %rsi
shrq $0x4, %rsi
addq %rdx, %rsi
movabsq $0xf0f0f0f0f0f0f0f, %rdx # imm = 0xF0F0F0F0F0F0F0F
andq %rdx, %rsi
movabsq $0x101010101010101, %rdx # imm = 0x101010101010101
imulq %rdx, %rsi
shrq $0x38, %rsi
leaq 0xd850(%rip), %rdx      # 0x1bf60
movl (%rdx,%rsi,4), %edx
addl %edx, 0x14(%rbx,%r15,4)
movq 0x18(%rsp), %rdx
movl 0x3f0(%rcx,%rdx), %ecx
movq 0x28(%rsp), %rdx
shll $0x9, %edx
addq 0x16885(%rip), %rdx     # 0x24fb8
movq (%rdx,%rcx,8), %rcx
andq %rdi, %rcx
testq %rax, %rcx
leal 0x2(%rbp), %ecx
cmovel %ebp, %ecx
xorl %eax, %eax
movl %ecx, %ebp
cmpl $0x3, %eax
je 0xe750
testl %eax, %eax
jne 0xe75a
addq $0x4, %r12
jne 0xe622
xorl %edx, %edx
cmpl $0x0, 0xc(%rsp)
sete %dl
movq 0x8(%rbx), %rax
movq 0x30(%rsp), %rcx
leaq 0x378(%rax,%rcx), %r13
movq 0x48(%rsp), %rax
leaq 0x50(%rbx,%rax), %rax
movq %rax, 0x20(%rsp)
movq $-0x24, %r12
movq %rdx, 0x28(%rsp)
imulq $0xf0, %rdx, %rax
movq %rax, 0x18(%rsp)
movl 0x24(%r13,%r12), %r14d
cmpq $0x40, %r14
je 0xe959
addl $0x12c, 0x2c(%rbx,%r15,4) # imm = 0x12C
movq %rbx, %rdi
movl %r14d, %esi
movl 0xc(%rsp), %edx
callq 0xf730
addl 0x2c(%rbx,%r15,4), %eax
movl %eax, 0x2c(%rbx,%r15,4)
movq 0x8(%rbx), %rdx
movq 0x80(%rdx), %rdi
orq 0x78(%rdx), %rdi
leaq 0xd05d(%rip), %rcx      # 0x1b840
movq (%rcx,%r14,8), %rsi
andq %rdi, %rsi
leaq 0xce4f(%rip), %rcx      # 0x1b640
imulq (%rcx,%r14,8), %rsi
leaq 0xcd43(%rip), %rcx      # 0x1b540
movb (%rcx,%r14,4), %cl
shrq %cl, %rsi
leaq 0x16a05(%rip), %rcx     # 0x25210
movq (%rcx,%r14,8), %rcx
movq (%rcx,%rsi,8), %rsi
movq 0x40(%rsp), %rcx
leaq 0xea251(%rip), %r8      # 0xf8a70
testq %rcx, (%r8,%r14,8)
je 0xe83c
movq %r14, %rcx
shlq $0x9, %rcx
addq 0x16735(%rip), %rcx     # 0x24f68
movq 0x10(%rsp), %r8
andq (%rcx,%r8,8), %rsi
andq %rsi, %rdi
movq 0x20(%rsp), %rcx
movq %rdi, (%rcx)
orq %rdi, 0xa0(%rbx,%r15,8)
movq 0x18(%rsp), %rcx
movl 0x3f0(%rdx,%rcx), %ecx
movq 0x28(%rsp), %rdi
shll $0x9, %edi
addq 0x1674e(%rip), %rdi     # 0x24fb8
movq (%rdi,%rcx,8), %rcx
movq 0x38(%rsp), %rdi
andq %rdi, %rcx
testq %rsi, %rcx
leal 0x2(%rbp), %ecx
cmovel %ebp, %ecx
andq %rdi, %rsi
movq %rsi, %rdi
shrq %rdi
movabsq $0x5555555555555555, %r8 # imm = 0x5555555555555555
andq %r8, %rdi
subq %rdi, %rsi
movq %rsi, %rdi
movabsq $0x3333333333333333, %r9 # imm = 0x3333333333333333
andq %r9, %rdi
shrq $0x2, %rsi
andq %r9, %rsi
addq %rdi, %rsi
movq %rsi, %rdi
shrq $0x4, %rdi
addq %rsi, %rdi
movabsq $0xf0f0f0f0f0f0f0f, %r10 # imm = 0xF0F0F0F0F0F0F0F
andq %r10, %rdi
movabsq $0x101010101010101, %r11 # imm = 0x101010101010101
imulq %r11, %rdi
shrq $0x38, %rdi
leaq 0xd6ae(%rip), %rsi      # 0x1bf90
movl (%rsi,%rdi,4), %esi
addl %esi, 0x14(%rbx,%r15,4)
leaq 0xea17f(%rip), %rsi     # 0xf8a70
movabsq $0x55aa55aa55aa55aa, %rdi # imm = 0x55AA55AA55AA55AA
testq %rdi, (%rsi,%r14,8)
movq %rdi, %rsi
movabsq $-0x55aa55aa55aa55ab, %rdi # imm = 0xAA55AA55AA55AA55
cmoveq %rdi, %rsi
movq 0x48(%rsp), %rdi
andq 0x288(%rdx,%rdi), %rsi
movq %rsi, %rdx
shrq %rdx
andq %r8, %rdx
subq %rdx, %rsi
movq %rsi, %rdx
andq %r9, %rdx
shrq $0x2, %rsi
andq %r9, %rsi
addq %rdx, %rsi
movq %rsi, %rdx
shrq $0x4, %rdx
addq %rsi, %rdx
andq %r10, %rdx
imulq %r11, %rdx
shrq $0x38, %rdx
addl %edx, %edx
subl %edx, %eax
movl %eax, 0x2c(%rbx,%r15,4)
movl %ecx, %ebp
cmpl $0x40, %r14d
je 0xe970
leaq 0x4(%r12), %rax
testq %r12, %r12
movq %rax, %r12
jne 0xe79c
movq 0x8(%rbx), %rax
leaq 0x328(%rax), %rcx
movq %rcx, 0x58(%rsp)
movq %r15, %rcx
shlq $0x4, %rcx
xorl %esi, %esi
xorl %r10d, %r10d
cmpl $0x0, 0xc(%rsp)
setne %sil
sete %r10b
movq 0x30(%rsp), %rdx
leaq 0x3a0(%rax,%rdx), %r11
leaq (%rcx,%rcx,2), %rcx
leaq 0x58(%rbx,%rcx), %rdx
movq %rdx, 0x28(%rsp)
movl $0x2, %edx
movl $0x8, %edi
cmovel %edx, %edi
movl %edi, 0x18(%rsp)
imulq $0xf0, %r10, %rdx
leaq (%rax,%rdx), %r9
addq $0x3f0, %r9             # imm = 0x3F0
leaq 0x2b0(%rax,%rcx), %rdx
leal 0x1(%rsi,%rsi,2), %ecx
movl %ecx, 0x20(%rsp)
movq 0x50(%rsp), %rcx
notq %rcx
movq %rcx, 0x60(%rsp)
movq $-0x24, %rsi
movl 0x24(%r11,%rsi), %edi
cmpq $0x40, %rdi
je 0xec27
movl 0x2c(%rbx,%r15,4), %r12d
leal 0x1f4(%r12), %ecx
movl %ecx, 0x2c(%rbx,%r15,4)
movq 0x80(%rax), %r13
orq 0x78(%rax), %r13
leaq 0xc912(%rip), %rcx      # 0x1b340
movq (%rcx,%rdi,8), %r8
andq %r13, %r8
leaq 0xc704(%rip), %rcx      # 0x1b140
imulq (%rcx,%rdi,8), %r8
leaq 0xc5f8(%rip), %rcx      # 0x1b040
movb (%rcx,%rdi,4), %cl
shrq %cl, %r8
leaq 0x169bb(%rip), %rcx     # 0x25410
movq (%rcx,%rdi,8), %rcx
movq (%rcx,%r8,8), %rcx
movq 0x40(%rsp), %r8
leaq 0xea007(%rip), %r14     # 0xf8a70
testq %r8, (%r14,%rdi,8)
je 0xea86
movq %rdi, %r8
shlq $0x9, %r8
addq 0x164eb(%rip), %r8      # 0x24f68
movq 0x10(%rsp), %r14
andq (%r8,%r14,8), %rcx
andq %rcx, %r13
movq 0x28(%rsp), %r8
movq %r13, (%r8)
orq %r13, 0xa0(%rbx,%r15,8)
movl (%r9), %r8d
movl %r10d, %r13d
shll $0x9, %r13d
addq 0x1650e(%rip), %r13     # 0x24fb8
movq (%r13,%r8,8), %r8
movq 0x38(%rsp), %r14
andq %r14, %r8
leal 0x3(%rbp), %r13d
testq %rcx, %r8
cmovnel %r13d, %ebp
andq %r14, %rcx
movq %rcx, %r8
shrq %r8
movabsq $0x5555555555555555, %r14 # imm = 0x5555555555555555
andq %r14, %r8
movq %rcx, %r13
subq %r8, %r13
movq %r13, %r8
movabsq $0x3333333333333333, %r14 # imm = 0x3333333333333333
andq %r14, %r8
shrq $0x2, %r13
andq %r14, %r13
addq %r8, %r13
movq %r13, %r8
shrq $0x4, %r8
addq %r13, %r8
movabsq $0xf0f0f0f0f0f0f0f, %r14 # imm = 0xF0F0F0F0F0F0F0F
andq %r14, %r8
movabsq $0x101010101010101, %r14 # imm = 0x101010101010101
imulq %r14, %r8
shrq $0x38, %r8
leaq 0xd4a8(%rip), %r14      # 0x1bfd0
movl (%r14,%r8,4), %r8d
addl %r8d, 0x14(%rbx,%r15,4)
movq 0x50(%rsp), %r14
testq %r14, (%rdx)
je 0xec27
leaq 0xe9f2a(%rip), %r8      # 0xf8a70
testq %r14, (%r8,%rdi,8)
je 0xec27
cmpl %edi, 0x10(%rsp)
jbe 0xeb61
movl 0x20(%rsp), %r8d
testl %r8d, 0xc(%rax)
je 0xeb9b
cmpl %edi, 0x10(%rsp)
jae 0xec27
movl 0x18(%rsp), %r8d
testl %r8d, 0xc(%rax)
jne 0xec27
movq 0x10(%rsp), %r8
leaq 0xe9eea(%rip), %r14     # 0xf8a70
movabsq $-0xf0f0f0f0f0f0f10, %r13 # imm = 0xF0F0F0F0F0F0F0F0
testq %r13, (%r14,%r8,8)
jne 0xebb7
jmp 0xec27
movq 0x10(%rsp), %r8
leaq 0xe9ec9(%rip), %r14     # 0xf8a70
movabsq $0xf0f0f0f0f0f0f0f, %r13 # imm = 0xF0F0F0F0F0F0F0F
testq %r13, (%r14,%r8,8)
je 0xeb61
andq 0x60(%rsp), %rcx
movq %rcx, %r8
shrq %r8
movabsq $0x5555555555555555, %r14 # imm = 0x5555555555555555
andq %r14, %r8
subq %r8, %rcx
movq %rcx, %r8
movabsq $0x3333333333333333, %r14 # imm = 0x3333333333333333
andq %r14, %r8
shrq $0x2, %rcx
andq %r14, %rcx
addq %r8, %rcx
movq %rcx, %r8
shrq $0x4, %r8
addq %rcx, %r8
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %r8
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rcx, %r8
shrq $0x38, %r8
cmpl $0x3, %r8d
ja 0xec27
addl $0x1db, %r12d           # imm = 0x1DB
movl %r12d, 0x2c(%rbx,%r15,4)
cmpl $0x40, %edi
je 0xec3c
leaq 0x4(%rsi), %rcx
testq %rsi, %rsi
movq %rcx, %rsi
jne 0xe9fb
xorl %edx, %edx
cmpl $0x0, 0xc(%rsp)
sete %dl
movq 0x30(%rsp), %rcx
movq 0x58(%rsp), %r8
leaq (%r8,%rcx), %rsi
addq $0xa0, %rsi
movq 0x48(%rsp), %rcx
leaq (%rbx,%rcx), %rdi
addq $0x60, %rdi
imulq $0xf0, %rdx, %rcx
leaq (%r8,%rcx), %r9
addq $0xc8, %r9
movq $-0x24, %r11
leaq 0xd388(%rip), %r10      # 0x1c010
movl 0x24(%rsi,%r11), %r14d
cmpq $0x40, %r14
je 0xede3
addl $0x3b6, 0x2c(%rbx,%r15,4) # imm = 0x3B6
movq 0x80(%rax), %r12
orq 0x78(%rax), %r12
leaq 0xcb8e(%rip), %rcx      # 0x1b840
movq (%rcx,%r14,8), %r8
andq %r12, %r8
leaq 0xc980(%rip), %rcx      # 0x1b640
imulq (%rcx,%r14,8), %r8
leaq 0xc874(%rip), %rcx      # 0x1b540
movb (%rcx,%r14,4), %cl
shrq %cl, %r8
leaq 0xc666(%rip), %rcx      # 0x1b340
movq (%rcx,%r14,8), %r13
andq %r12, %r13
leaq 0xc458(%rip), %rcx      # 0x1b140
imulq (%rcx,%r14,8), %r13
leaq 0xc34c(%rip), %rcx      # 0x1b040
movb (%rcx,%r14,4), %cl
shrq %cl, %r13
leaq 0x1670e(%rip), %rcx     # 0x25410
movq (%rcx,%r14,8), %rcx
movq (%rcx,%r13,8), %rcx
leaq 0x164ff(%rip), %r13     # 0x25210
movq (%r13,%r14,8), %r13
orq (%r13,%r8,8), %rcx
movq 0x40(%rsp), %r8
leaq 0xe9d49(%rip), %r13     # 0xf8a70
testq %r8, (%r13,%r14,8)
je 0xed45
movq %r14, %r8
shlq $0x9, %r8
addq 0x1622c(%rip), %r8      # 0x24f68
movq 0x10(%rsp), %r13
andq (%r8,%r13,8), %rcx
andq %rcx, %r12
movq %r12, (%rdi)
orq %r12, 0xa0(%rbx,%r15,8)
movl (%r9), %r8d
movl %edx, %r12d
shll $0x9, %r12d
addq 0x16254(%rip), %r12     # 0x24fb8
movq (%r12,%r8,8), %r8
movq 0x38(%rsp), %r13
andq %r13, %r8
testq %rcx, %r8
leal 0x5(%rbp), %r12d
cmovel %ebp, %r12d
andq %r13, %rcx
movq %rcx, %r8
shrq %r8
movabsq $0x5555555555555555, %r13 # imm = 0x5555555555555555
andq %r13, %r8
subq %r8, %rcx
movq %rcx, %r8
movabsq $0x3333333333333333, %r13 # imm = 0x3333333333333333
andq %r13, %r8
shrq $0x2, %rcx
andq %r13, %rcx
addq %r8, %rcx
movq %rcx, %r8
shrq $0x4, %r8
addq %rcx, %r8
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %r8
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rcx, %r8
shrq $0x38, %r8
movl (%r10,%r8,4), %ecx
addl %ecx, 0x14(%rbx,%r15,4)
movl %r12d, %ebp
cmpl $0x40, %r14d
je 0xedf9
leaq 0x4(%r11), %rcx
testq %r11, %r11
movq %rcx, %r11
jne 0xec88
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
sete %al
movslq %ebp, %rcx
leaq 0xd273(%rip), %rdx      # 0x1c080
movl (%rdx,%rcx,4), %ecx
subl %ecx, 0x1c(%rbx,%rax,4)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop