LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/bitboards__test.cpp
// Function: test_isolate_lsb_bit()
void test_isolate_lsb_bit() {
    uint64 mask = bb_squares[A8] | bb_squares[E4] | bb_squares[F4] | bb_squares[D1];

    assert(isolate_lsb_bit(mask,0)==bb_squares[A8]);
    assert(isolate_lsb_bit(mask,1)==bb_squares[E4]);
    assert(isolate_lsb_bit(mask,2)==bb_squares[F4]);
    assert(isolate_lsb_bit(mask,3)==bb_squares[D1]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xed787(%rip), %r14     # 0xfd4b0
movq 0x120(%r14), %rbx
orq (%r14), %rbx
orq 0x128(%r14), %rbx
orq 0x1d8(%r14), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3abb
cmpq (%r14), %rax
jne 0xfd94
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3abb
cmpq 0x120(%r14), %rax
jne 0xfdad
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3abb
cmpq 0x128(%r14), %rax
jne 0xfdc6
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3abb
cmpq 0x1d8(%r14), %rax
jne 0xfddf
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1c8f1(%rip), %rdi     # 0x2c68c
leaq 0x1c7fa(%rip), %rsi     # 0x2c59c
leaq 0x1c90b(%rip), %rcx     # 0x2c6b4
pushq $0x1e
jmp 0xfdf6
leaq 0x1c91c(%rip), %rdi     # 0x2c6d0
leaq 0x1c7e1(%rip), %rsi     # 0x2c59c
leaq 0x1c8f2(%rip), %rcx     # 0x2c6b4
pushq $0x1f
jmp 0xfdf6
leaq 0x1c92b(%rip), %rdi     # 0x2c6f8
leaq 0x1c7c8(%rip), %rsi     # 0x2c59c
leaq 0x1c8d9(%rip), %rcx     # 0x2c6b4
pushq $0x20
jmp 0xfdf6
leaq 0x1c93a(%rip), %rdi     # 0x2c720
leaq 0x1c7af(%rip), %rsi     # 0x2c59c
leaq 0x1c8c0(%rip), %rcx     # 0x2c6b4
pushq $0x21
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/bitboards__test.cpp
// Function: test_pawn_attacks()
void test_pawn_attacks() {
    assert(bb_pawn_attacks[E4][WHITE]==(bb_squares[D5] | bb_squares[F5]));
    assert(bb_pawn_attacks[E4][BLACK]==(bb_squares[D3] | bb_squares[F3]));

    assert(bb_pawn_attacks[A2][WHITE]==bb_squares[B3]);
    assert(bb_pawn_attacks[A2][BLACK]==bb_squares[B1]);

    assert(bb_pawn_attacks[H7][WHITE]==bb_squares[G8]);
    assert(bb_pawn_attacks[H7][BLACK]==bb_squares[G6]);
}

// Assembly:
pushq %rax
leaq 0xed706(%rip), %rax     # 0xfdab0
leaq 0xed0ff(%rip), %rcx     # 0xfd4b0
movq 0xe8(%rcx), %rdx
orq 0xd8(%rcx), %rdx
cmpq %rdx, 0x248(%rax)
jne 0x10422
movq 0x168(%rcx), %rdx
orq 0x158(%rcx), %rdx
cmpq %rdx, 0x240(%rax)
jne 0x1043b
movq 0x308(%rax), %rdx
cmpq 0x148(%rcx), %rdx
jne 0x10454
movq 0x300(%rax), %rdx
cmpq 0x1c8(%rcx), %rdx
jne 0x1046d
movq 0xf8(%rax), %rdx
cmpq 0x30(%rcx), %rdx
jne 0x1048a
movq 0xf0(%rax), %rax
cmpq 0xb0(%rcx), %rax
jne 0x104a9
popq %rax
retq
leaq 0x1c58d(%rip), %rdi     # 0x2c9b6
leaq 0x1c16c(%rip), %rsi     # 0x2c59c
leaq 0x1c5bd(%rip), %rcx     # 0x2c9f4
pushq $0x7b
jmp 0x10484
leaq 0x1c5cb(%rip), %rdi     # 0x2ca0d
leaq 0x1c153(%rip), %rsi     # 0x2c59c
leaq 0x1c5a4(%rip), %rcx     # 0x2c9f4
pushq $0x7c
jmp 0x10484
leaq 0x1c5f0(%rip), %rdi     # 0x2ca4b
leaq 0x1c13a(%rip), %rsi     # 0x2c59c
leaq 0x1c58b(%rip), %rcx     # 0x2c9f4
pushq $0x7e
jmp 0x10484
leaq 0x1c602(%rip), %rdi     # 0x2ca76
leaq 0x1c121(%rip), %rsi     # 0x2c59c
leaq 0x1c572(%rip), %rcx     # 0x2c9f4
pushq $0x7f
popq %rdx
callq 0x20c0
leaq 0x1c610(%rip), %rdi     # 0x2caa1
leaq 0x1c104(%rip), %rsi     # 0x2c59c
leaq 0x1c555(%rip), %rcx     # 0x2c9f4
movl $0x81, %edx
callq 0x20c0
leaq 0x1c61c(%rip), %rdi     # 0x2cacc
leaq 0x1c0e5(%rip), %rsi     # 0x2c59c
leaq 0x1c536(%rip), %rcx     # 0x2c9f4
movl $0x82, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/bitboards__test.cpp
// Function: test_rays()
void test_rays() {
    assert(bb_rays[D5][NORTH] == (bb_squares[D6] | bb_squares[D7] | bb_squares[D8]));
    assert(bb_rays[D5][SOUTH] == (bb_squares[D4] | bb_squares[D3] | bb_squares[D2] | bb_squares[D1]));
    assert(bb_rays[D5][WEST] == (bb_squares[C5] | bb_squares[B5] | bb_squares[A5]));
    assert(bb_rays[D5][EAST] == (bb_squares[E5] | bb_squares[F5] | bb_squares[G5] | bb_squares[H5]));
    assert(bb_rays[D5][NORTHEAST] == (bb_squares[E6] | bb_squares[F7] | bb_squares[G8]));
    assert(bb_rays[D5][SOUTHEAST] == (bb_squares[E4] | bb_squares[F3] | bb_squares[G2] | bb_squares[H1]));
    assert(bb_rays[D5][SOUTHWEST] == (bb_squares[C4] | bb_squares[B3] | bb_squares[A2]));
    assert(bb_rays[D5][NORTHWEST] == (bb_squares[C6] | bb_squares[B7] | bb_squares[A8]));
}

// Assembly:
pushq %rax
leaq 0xed9e0(%rip), %rax     # 0xfdeb0
leaq 0xecfd9(%rip), %rcx     # 0xfd4b0
movq 0x58(%rcx), %rdx
orq 0x98(%rcx), %rdx
orq 0x18(%rcx), %rdx
cmpq %rdx, 0x6c0(%rax)
jne 0x105ed
movq 0x158(%rcx), %rdx
orq 0x118(%rcx), %rdx
orq 0x198(%rcx), %rdx
orq 0x1d8(%rcx), %rdx
cmpq %rdx, 0x6e0(%rax)
jne 0x1060c
movq 0xc8(%rcx), %rdx
orq 0xd0(%rcx), %rdx
orq 0xc0(%rcx), %rdx
cmpq %rdx, 0x6f0(%rax)
jne 0x1062b
movdqa 0xe0(%rcx), %xmm0
por 0xf0(%rcx), %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
por %xmm0, %xmm1
movq %xmm1, %rdx
cmpq %rdx, 0x6d0(%rax)
jne 0x1064a
movq 0x68(%rcx), %rdx
orq 0xa0(%rcx), %rdx
orq 0x30(%rcx), %rdx
cmpq %rdx, 0x6c8(%rax)
jne 0x10669
movq 0x168(%rcx), %rdx
orq 0x120(%rcx), %rdx
orq 0x1b0(%rcx), %rdx
orq 0x1f8(%rcx), %rdx
cmpq %rdx, 0x6d8(%rax)
jne 0x10688
movq 0x148(%rcx), %rdx
orq 0x110(%rcx), %rdx
orq 0x180(%rcx), %rdx
cmpq %rdx, 0x6e8(%rax)
jne 0x106a7
movq 0x48(%rcx), %rdx
orq 0x90(%rcx), %rdx
orq (%rcx), %rdx
cmpq %rdx, 0x6f8(%rax)
jne 0x106c6
popq %rax
retq
leaq 0x1c503(%rip), %rdi     # 0x2caf7
leaq 0x1bfa1(%rip), %rsi     # 0x2c59c
leaq 0x1c53e(%rip), %rcx     # 0x2cb40
movl $0x86, %edx
callq 0x20c0
leaq 0x1c53e(%rip), %rdi     # 0x2cb51
leaq 0x1bf82(%rip), %rsi     # 0x2c59c
leaq 0x1c51f(%rip), %rcx     # 0x2cb40
movl $0x87, %edx
callq 0x20c0
leaq 0x1c579(%rip), %rdi     # 0x2cbab
leaq 0x1bf63(%rip), %rsi     # 0x2c59c
leaq 0x1c500(%rip), %rcx     # 0x2cb40
movl $0x88, %edx
callq 0x20c0
leaq 0x1c5a2(%rip), %rdi     # 0x2cbf3
leaq 0x1bf44(%rip), %rsi     # 0x2c59c
leaq 0x1c4e1(%rip), %rcx     # 0x2cb40
movl $0x89, %edx
callq 0x20c0
leaq 0x1c5dc(%rip), %rdi     # 0x2cc4c
leaq 0x1bf25(%rip), %rsi     # 0x2c59c
leaq 0x1c4c2(%rip), %rcx     # 0x2cb40
movl $0x8a, %edx
callq 0x20c0
leaq 0x1c60a(%rip), %rdi     # 0x2cc99
leaq 0x1bf06(%rip), %rsi     # 0x2c59c
leaq 0x1c4a3(%rip), %rcx     # 0x2cb40
movl $0x8b, %edx
callq 0x20c0
leaq 0x1c649(%rip), %rdi     # 0x2ccf7
leaq 0x1bee7(%rip), %rsi     # 0x2c59c
leaq 0x1c484(%rip), %rcx     # 0x2cb40
movl $0x8c, %edx
callq 0x20c0
leaq 0x1c677(%rip), %rdi     # 0x2cd44
leaq 0x1bec8(%rip), %rsi     # 0x2c59c
leaq 0x1c465(%rip), %rcx     # 0x2cb40
movl $0x8d, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/bitboards__test.cpp
// Function: test_bitboards()
void test_bitboards() {
    test_get_num_bits();
    test_get_lsb();
    test_get_msb();
    test_isolate_lsb_bit();
    test_knight_moves();
    test_king_moves();
    test_pawn_attacks();
    test_rays();
}

// Assembly:
pushq %rax
callq 0xfbf0
callq 0xfc52
callq 0xfcb8
callq 0xfd1e
callq 0xfdfc
callq 0x100b8
callq 0x103a2
popq %rax
jmp 0x104c8
nop
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/book__test.cpp
// Function: test_build_book_key()
void test_build_book_key() {
    position pos;
    reset_pos(&pos);

    int64 bkey = build_book_key(&pos);
    assert(bkey==8683256505108505948L);

    set_pos(&pos,"8/4Pk1p/6p1/1r6/8/5N2/2B2PPP/b5K1 w - - ");
    bkey = build_book_key(&pos);
    assert(bkey==5404474865777589476L);

    set_pos(&pos,"8/8/3k4/2n1P3/8/8/3rP3/RN2K2R w KQ - 0 1");
    bkey = build_book_key(&pos);
    assert(bkey==-6221215072275532145L);

    set_pos(&pos,"rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1");
    bkey = build_book_key(&pos);
    assert(bkey==8410219886346271288L);

    set_pos(&pos,"r3k2r/8/8/8/8/5Q2/8/4K3 b kq - 0 1");
    bkey = build_book_key(&pos);
    assert(bkey==-7818203441519759474);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa187
movq %rbx, %rdi
callq 0x4376
movabsq $0x78811fc91897a55c, %rcx # imm = 0x78811FC91897A55C
cmpq %rcx, %rax
jne 0x107fd
leaq 0x1c694(%rip), %rsi     # 0x2cddb
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
callq 0x4376
movabsq $0x4b008d419c333ce4, %rcx # imm = 0x4B008D419C333CE4
cmpq %rcx, %rax
jne 0x10816
leaq 0x1c6a9(%rip), %rsi     # 0x2ce1f
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
callq 0x4376
movabsq $-0x56563225964a0971, %rcx # imm = 0xA9A9CDDA69B5F68F
cmpq %rcx, %rax
jne 0x1082f
leaq 0x1acfe(%rip), %rsi     # 0x2b4a3
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
callq 0x4376
movabsq $0x74b71a6d68987a38, %rcx # imm = 0x74B71A6D68987A38
cmpq %rcx, %rax
jne 0x10848
leaq 0x1c6af(%rip), %rsi     # 0x2ce7f
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
callq 0x4376
movabsq $-0x6c7fd69b81859072, %rcx # imm = 0x938029647E7A6F8E
cmpq %rcx, %rax
jne 0x10861
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c58d(%rip), %rdi     # 0x2cd91
leaq 0x1c5a1(%rip), %rsi     # 0x2cdac
leaq 0x1c5ae(%rip), %rcx     # 0x2cdc0
pushq $0x12
jmp 0x10878
leaq 0x1c5e7(%rip), %rdi     # 0x2ce04
leaq 0x1c588(%rip), %rsi     # 0x2cdac
leaq 0x1c595(%rip), %rcx     # 0x2cdc0
pushq $0x16
jmp 0x10878
leaq 0x1c612(%rip), %rdi     # 0x2ce48
leaq 0x1c56f(%rip), %rsi     # 0x2cdac
leaq 0x1c57c(%rip), %rcx     # 0x2cdc0
pushq $0x1a
jmp 0x10878
leaq 0x1c615(%rip), %rdi     # 0x2ce64
leaq 0x1c556(%rip), %rsi     # 0x2cdac
leaq 0x1c563(%rip), %rcx     # 0x2cdc0
pushq $0x1e
jmp 0x10878
leaq 0x1c63a(%rip), %rdi     # 0x2cea2
leaq 0x1c53d(%rip), %rsi     # 0x2cdac
leaq 0x1c54a(%rip), %rcx     # 0x2cdc0
pushq $0x22
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/draw__test.cpp
// Function: test_is_draw_by_50()
void test_is_draw_by_50() {
    position pos;
    reset_pos(&pos);
    assert(!is_draw_by_50(&pos));

    pos.fifty_counter=pos.move_counter=49;
    assert(!is_draw_by_50(&pos));

    pos.fifty_counter=pos.move_counter=50;
    assert(!is_draw_by_50(&pos));

    pos.fifty_counter=pos.move_counter=51;
    assert(!is_draw_by_50(&pos));

    pos.fifty_counter=pos.move_counter=99;
    assert(!is_draw_by_50(&pos));

    pos.fifty_counter=pos.move_counter=100;
    assert(is_draw_by_50(&pos));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa187
movq %rbx, %rdi
callq 0x490a
testb %al, %al
jne 0x10969
movabsq $0x3100000031, %rax     # imm = 0x3100000031
leaq 0x8(%rsp), %rdi
movq %rax, 0x144(%rdi)
callq 0x490a
testb %al, %al
jne 0x10982
movabsq $0x3200000032, %rax     # imm = 0x3200000032
leaq 0x8(%rsp), %rdi
movq %rax, 0x144(%rdi)
callq 0x490a
testb %al, %al
jne 0x1099b
movabsq $0x3300000033, %rax     # imm = 0x3300000033
leaq 0x8(%rsp), %rdi
movq %rax, 0x144(%rdi)
callq 0x490a
testb %al, %al
jne 0x109b4
movabsq $0x6300000063, %rax     # imm = 0x6300000063
leaq 0x8(%rsp), %rdi
movq %rax, 0x144(%rdi)
callq 0x490a
testb %al, %al
jne 0x109cd
movabsq $0x6400000064, %rax     # imm = 0x6400000064
leaq 0x8(%rsp), %rdi
movq %rax, 0x144(%rdi)
callq 0x490a
testb %al, %al
je 0x109e6
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c54d(%rip), %rdi     # 0x2cebd
leaq 0x1c55b(%rip), %rsi     # 0x2ced2
leaq 0x1c568(%rip), %rcx     # 0x2cee6
pushq $0xf
jmp 0x109fd
leaq 0x1c534(%rip), %rdi     # 0x2cebd
leaq 0x1c542(%rip), %rsi     # 0x2ced2
leaq 0x1c54f(%rip), %rcx     # 0x2cee6
pushq $0x12
jmp 0x109fd
leaq 0x1c51b(%rip), %rdi     # 0x2cebd
leaq 0x1c529(%rip), %rsi     # 0x2ced2
leaq 0x1c536(%rip), %rcx     # 0x2cee6
pushq $0x15
jmp 0x109fd
leaq 0x1c502(%rip), %rdi     # 0x2cebd
leaq 0x1c510(%rip), %rsi     # 0x2ced2
leaq 0x1c51d(%rip), %rcx     # 0x2cee6
pushq $0x18
jmp 0x109fd
leaq 0x1c4e9(%rip), %rdi     # 0x2cebd
leaq 0x1c4f7(%rip), %rsi     # 0x2ced2
leaq 0x1c504(%rip), %rcx     # 0x2cee6
pushq $0x1b
jmp 0x109fd
leaq 0x1c4d1(%rip), %rdi     # 0x2cebe
leaq 0x1c4de(%rip), %rsi     # 0x2ced2
leaq 0x1c4eb(%rip), %rcx     # 0x2cee6
pushq $0x1e
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_start_pos_is_0()
void test_start_pos_is_0() {
    position pos;
    reset_pos(&pos);
    int32 score=eval(&pos,false);
    assert(score==0);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa187
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
testl %eax, %eax
jne 0x11128
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1bf81(%rip), %rdi     # 0x2d0b0
leaq 0x1bf83(%rip), %rsi     # 0x2d0b9
leaq 0x1bf90(%rip), %rcx     # 0x2d0cd
pushq $0x12
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_pawn()
void test_eval_pawn() {
    position pos;
    reset_pos(&pos);
    assert(eval_pawn(&pos,E2,true)==pawn_pst[E2]);
    assert(eval_pawn(&pos,B7,false)==pawn_pst[B2]);
    assert(eval_pawn(&pos,B7,false)==eval_pawn(&pos,B2,true));
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xa187
pushq $0x34
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x5794
cmpl $-0x3, %eax
jne 0x111ab
movq %rsp, %rdi
pushq $0x9
popq %rsi
xorl %edx, %edx
callq 0x5794
testl %eax, %eax
jne 0x111c4
movq %rsp, %rbx
pushq $0x9
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5794
movl %eax, %ebp
pushq $0x31
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x5794
cmpl %eax, %ebp
jne 0x111dd
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %rbp
retq
leaq 0x1bf36(%rip), %rdi     # 0x2d0e8
leaq 0x1bf00(%rip), %rsi     # 0x2d0b9
leaq 0x1bf4e(%rip), %rcx     # 0x2d10e
pushq $0x18
jmp 0x111f4
leaq 0x1bf59(%rip), %rdi     # 0x2d124
leaq 0x1bee7(%rip), %rsi     # 0x2d0b9
leaq 0x1bf35(%rip), %rcx     # 0x2d10e
pushq $0x19
jmp 0x111f4
leaq 0x1bf67(%rip), %rdi     # 0x2d14b
leaq 0x1bece(%rip), %rsi     # 0x2d0b9
leaq 0x1bf1c(%rip), %rcx     # 0x2d10e
pushq $0x1a
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_knight()
void test_eval_knight() {
    position pos;
    reset_pos(&pos);
    assert(eval_knight(&pos,F3,true)==knight_pst[F3] + knight_tropism * distance(F3,E8));
    assert(eval_knight(&pos,D6,true)==knight_pst[D6] + knight_tropism * distance(D6,E8));
    assert(eval_knight(&pos,H3,false)==knight_pst[H6] + knight_tropism * distance(H6,E8));
    assert(eval_knight(&pos,F7,false)==knight_pst[F2] + knight_tropism * distance(F2,E8));
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xa187
pushq $0x2d
popq %rbp
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4deb
movl %eax, %ebx
pushq $0x4
popq %rsi
movl %ebp, %edi
callq 0xc136
addl %eax, %eax
pushq $0x8
popq %rcx
subl %eax, %ecx
cmpl %ecx, %ebx
jne 0x112ab
movq %rsp, %rdi
pushq $0x13
popq %rbx
pushq $0x1
popq %rdx
movl %ebx, %esi
callq 0x4deb
movl %eax, %ebp
pushq $0x4
popq %rsi
movl %ebx, %edi
callq 0xc136
addl %eax, %eax
pushq $0x14
popq %rcx
subl %eax, %ecx
cmpl %ecx, %ebp
jne 0x112c4
movq %rsp, %rdi
pushq $0x2f
popq %rsi
xorl %edx, %edx
callq 0x4deb
movl %eax, %ebx
pushq $0x17
popq %rdi
pushq $0x4
popq %rsi
callq 0xc136
addl %eax, %eax
pushq $-0x5
popq %rcx
subl %eax, %ecx
cmpl %ecx, %ebx
jne 0x112dd
movq %rsp, %rdi
pushq $0xd
popq %rsi
xorl %edx, %edx
callq 0x4deb
movl %eax, %ebx
pushq $0x35
popq %rdi
pushq $0x4
popq %rsi
callq 0xc136
addl %eax, %eax
addl %ebx, %eax
jne 0x112f6
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %rbp
retq
leaq 0x1becb(%rip), %rdi     # 0x2d17d
leaq 0x1be00(%rip), %rsi     # 0x2d0b9
leaq 0x1bf0a(%rip), %rcx     # 0x2d1ca
pushq $0x20
jmp 0x1130d
leaq 0x1bf17(%rip), %rdi     # 0x2d1e2
leaq 0x1bde7(%rip), %rsi     # 0x2d0b9
leaq 0x1bef1(%rip), %rcx     # 0x2d1ca
pushq $0x21
jmp 0x1130d
leaq 0x1bf4b(%rip), %rdi     # 0x2d22f
leaq 0x1bdce(%rip), %rsi     # 0x2d0b9
leaq 0x1bed8(%rip), %rcx     # 0x2d1ca
pushq $0x22
jmp 0x1130d
leaq 0x1bf80(%rip), %rdi     # 0x2d27d
leaq 0x1bdb5(%rip), %rsi     # 0x2d0b9
leaq 0x1bebf(%rip), %rcx     # 0x2d1ca
pushq $0x23
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_bishop()
void test_eval_bishop() {
    position pos;

    set_pos(&pos,"6k1/3B4/8/8/8/8/8/K7 w - - 0 1");
    assert(eval(&pos,false)==bishop_val + bishop_pst[D7]);

    set_pos(&pos,"6k1/8/8/3B4/8/8/8/K7 w - - 0 1");
    assert(eval(&pos,false)==bishop_val + bishop_pst[D5]);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1bfa9(%rip), %rsi     # 0x2d2cb
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
cmpl $0x147, %eax            # imm = 0x147
jne 0x1136e
leaq 0x1bfe9(%rip), %rsi     # 0x2d330
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
cmpl $0x154, %eax            # imm = 0x154
jne 0x11387
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1bf75(%rip), %rdi     # 0x2d2ea
leaq 0x1bd3d(%rip), %rsi     # 0x2d0b9
leaq 0x1bf95(%rip), %rcx     # 0x2d318
pushq $0x2a
jmp 0x1139e
leaq 0x1bfc1(%rip), %rdi     # 0x2d34f
leaq 0x1bd24(%rip), %rsi     # 0x2d0b9
leaq 0x1bf7c(%rip), %rcx     # 0x2d318
pushq $0x2d
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_rook_on_7th()
void test_eval_rook_on_7th() {
    position pos;
    set_pos(&pos,"7k/8/8/8/8/8/r7/7K w - - 0 1");
    int32_pair npmat = eval_nonpawn_material(&pos);
    assert(npmat.val1==0);
    assert(npmat.val2==rook_val);

    assert(eval(&pos,false)==-rook_val - rook_on_7th - rook_open_file);

    // move king out
    set_pos(&pos,"7k/8/8/8/8/7K/r7/8 w - - 0 1");
    assert(eval(&pos,false)==-rook_val - rook_open_file);

    // flipped
    set_pos(&pos,"7k/8/8/8/8/7K/r7/8 b - - 0 1");
    assert(eval(&pos,false)==rook_val  + rook_open_file);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c0f2(%rip), %rsi     # 0x2d659
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
callq 0x52f7
testl %eax, %eax
jne 0x115fd
movabsq $0x1f400000000, %rcx    # imm = 0x1F400000000
cmpq %rcx, %rax
jne 0x11616
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x547b
cmpl $0xfffffdc1, %eax       # imm = 0xFFFFFDC1
jne 0x1162f
leaq 0x1c140(%rip), %rsi     # 0x2d6f1
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
cmpl $0xfffffdf3, %eax       # imm = 0xFFFFFDF3
jne 0x11648
leaq 0x1c165(%rip), %rsi     # 0x2d73b
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
cmpl $0x20d, %eax            # imm = 0x20D
jne 0x11661
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c072(%rip), %rdi     # 0x2d676
leaq 0x1baae(%rip), %rsi     # 0x2d0b9
leaq 0x1c072(%rip), %rcx     # 0x2d684
pushq $0x55
jmp 0x11678
leaq 0x1c084(%rip), %rdi     # 0x2d6a1
leaq 0x1ba95(%rip), %rsi     # 0x2d0b9
leaq 0x1c059(%rip), %rcx     # 0x2d684
pushq $0x56
jmp 0x11678
leaq 0x1c080(%rip), %rdi     # 0x2d6b6
leaq 0x1ba7c(%rip), %rsi     # 0x2d0b9
leaq 0x1c040(%rip), %rcx     # 0x2d684
pushq $0x58
jmp 0x11678
leaq 0x1c0bf(%rip), %rdi     # 0x2d70e
leaq 0x1ba63(%rip), %rsi     # 0x2d0b9
leaq 0x1c027(%rip), %rcx     # 0x2d684
pushq $0x5c
jmp 0x11678
leaq 0x1c0f0(%rip), %rdi     # 0x2d758
leaq 0x1ba4a(%rip), %rsi     # 0x2d0b9
leaq 0x1c00e(%rip), %rcx     # 0x2d684
pushq $0x60
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_connected_majors_7th()
void test_eval_connected_majors_7th() {
    position pos;
    set_pos(&pos,"7k/R2R4/8/8/8/8/8/7K w - - 0 1");
    assert(eval(&pos,false)==rook_val*2 + rook_on_7th*2 + connected_majors_on_7th
            + rook_open_file*2);

    set_pos(&pos,"7k/R2RQ3/8/8/8/8/8/7K w - - 0 1");
    int32 expected = rook_val*2 + queen_val
            + rook_on_7th*3
            + connected_majors_on_7th*2
            + rook_open_file*2
            - eval_scale(king_safety_pawn_far_away // f file
                       + king_safety_pawn_far_away // g file
                       + (king_safety_pawn_far_away/2), // h file
                       rook_val*2+queen_val);
    assert(eval(&pos,false)==expected);

    // flip it
    set_pos(&pos,"7k/R2QR3/8/8/8/8/8/7K b - - 0 1");
    assert(eval(&pos,false)==-expected);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c0f4(%rip), %rsi     # 0x2d784
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
cmpl $0x4ce, %eax            # imm = 0x4CE
jne 0x1171a
leaq 0x1c16e(%rip), %rsi     # 0x2d823
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa1b8
pushq $-0x4b
popq %rdi
movl $0x76c, %esi            # imm = 0x76C
callq 0x5162
movl %eax, %ebx
movl $0x8d4, %ebp            # imm = 0x8D4
subl %eax, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0x547b
cmpl %ebp, %eax
jne 0x11733
addl $0xfffff72c, %ebx       # imm = 0xFFFFF72C
leaq 0x1c16b(%rip), %rsi     # 0x2d85e
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa1b8
movq %r14, %rdi
xorl %esi, %esi
callq 0x547b
cmpl %ebx, %eax
jne 0x1174c
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1c082(%rip), %rdi     # 0x2d7a3
leaq 0x1b991(%rip), %rsi     # 0x2d0b9
leaq 0x1c0ce(%rip), %rcx     # 0x2d7fd
pushq $0x67
jmp 0x11763
leaq 0x1c109(%rip), %rdi     # 0x2d843
leaq 0x1b978(%rip), %rsi     # 0x2d0b9
leaq 0x1c0b5(%rip), %rcx     # 0x2d7fd
pushq $0x72
jmp 0x11763
leaq 0x1c12b(%rip), %rdi     # 0x2d87e
leaq 0x1b95f(%rip), %rsi     # 0x2d0b9
leaq 0x1c09c(%rip), %rcx     # 0x2d7fd
pushq $0x76
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_rook_open_file()
void test_eval_rook_open_file() {
    position pos;

    set_pos(&pos,"3r3k/8/8/8/8/8/8/7K b - - 0 1");
    assert(eval(&pos,false)==rook_val + rook_open_file);

    set_pos(&pos,"3r3k/3r4/8/8/8/8/8/7K b - - 0 1");
    assert(eval(&pos,false)==rook_val*2 + rook_open_file*2);

    set_pos(&pos,"3r3k/8/3p4/8/8/8/8/7K b - - 0 1");
    assert(eval(&pos,false)==rook_val+pawn_val +passed_pawn+isolated_pawn
            + pawn_pst[fliprank[D6]]);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c122(%rip), %rsi     # 0x2d89a
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
cmpl $0x20d, %eax            # imm = 0x20D
jne 0x117e9
leaq 0x1c13b(%rip), %rsi     # 0x2d8d8
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
cmpl $0x41a, %eax            # imm = 0x41A
jne 0x11806
leaq 0x1c166(%rip), %rsi     # 0x2d928
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
cmpl $0x25d, %eax            # imm = 0x25D
jne 0x11825
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1bf68(%rip), %rdi     # 0x2d758
leaq 0x1b8c2(%rip), %rsi     # 0x2d0b9
leaq 0x1c0ba(%rip), %rcx     # 0x2d8b8
pushq $0x7d
popq %rdx
callq 0x20c0
leaq 0x1c0eb(%rip), %rdi     # 0x2d8f8
leaq 0x1b8a5(%rip), %rsi     # 0x2d0b9
leaq 0x1c09d(%rip), %rcx     # 0x2d8b8
movl $0x80, %edx
callq 0x20c0
leaq 0x1c11c(%rip), %rdi     # 0x2d948
leaq 0x1b886(%rip), %rsi     # 0x2d0b9
leaq 0x1c07e(%rip), %rcx     # 0x2d8b8
movl $0x84, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_rook_half_open_file()
void test_eval_rook_half_open_file() {
    position pos;

    set_pos(&pos,"8/2P5/8/2R5/K7/8/7k/8 w - - 0 1");
    assert(eval(&pos,false)==rook_val + pawn_val  + passed_pawn + isolated_pawn
            + pawn_pst[C7]);

    set_pos(&pos,"8/2p5/8/2R5/K7/8/7k/8 w - - 0 1");
    assert(eval(&pos,false)==rook_val-pawn_val -passed_pawn-isolated_pawn
            + pawn_pst[fliprank[C7]]
            + rook_half_open_file);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c14d(%rip), %rsi     # 0x2d9a0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
cmpl $0x276, %eax            # imm = 0x276
jne 0x1189f
leaq 0x1c1c0(%rip), %rsi     # 0x2da38
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
cmpl $0x19f, %eax            # imm = 0x19F
jne 0x118be
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c11a(%rip), %rdi     # 0x2d9c0
leaq 0x1b80c(%rip), %rsi     # 0x2d0b9
leaq 0x1c15f(%rip), %rcx     # 0x2da13
movl $0x8c, %edx
callq 0x20c0
leaq 0x1c193(%rip), %rdi     # 0x2da58
leaq 0x1b7ed(%rip), %rsi     # 0x2d0b9
leaq 0x1c140(%rip), %rcx     # 0x2da13
movl $0x91, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_queen()
void test_eval_queen() {
    position pos;

    set_pos(&pos,"3kq3/8/8/8/8/8/8/3K4 b - - 0 1");
    assert(eval(&pos,false)==queen_val + queen_pst[fliprank[E8]]);
    int32_pair npmat = eval_nonpawn_material(&pos);
    assert(npmat.val1==0);
    assert(npmat.val2==queen_val);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c1da(%rip), %rsi     # 0x2dac6
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
cmpl $0x383, %eax            # imm = 0x383
jne 0x11930
leaq 0x8(%rsp), %rdi
callq 0x52f7
testl %eax, %eax
jne 0x1194f
movabsq $0x38400000000, %rcx    # imm = 0x38400000000
cmpq %rcx, %rax
jne 0x1196e
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c1ae(%rip), %rdi     # 0x2dae5
leaq 0x1b77b(%rip), %rsi     # 0x2d0b9
leaq 0x1c1d6(%rip), %rcx     # 0x2db1b
movl $0x98, %edx
callq 0x20c0
leaq 0x1bd20(%rip), %rdi     # 0x2d676
leaq 0x1b75c(%rip), %rsi     # 0x2d0b9
leaq 0x1c1b7(%rip), %rcx     # 0x2db1b
movl $0x9a, %edx
callq 0x20c0
leaq 0x1c1bd(%rip), %rdi     # 0x2db32
leaq 0x1b73d(%rip), %rsi     # 0x2d0b9
leaq 0x1c198(%rip), %rcx     # 0x2db1b
movl $0x9b, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_king_pst()
void test_king_pst() {
    position pos;

    set_pos(&pos,"rnbqkbnr/pppppppp/8/8/3P4/3BPN2/PPP2PPP/RNBQR1K1 w - - 0 1");
    int32_pair npmat = eval_nonpawn_material(&pos);
    assert(0==npmat.val1-npmat.val2);

    int32_pair pmat = eval_pawn_material(&pos);
    assert(0==pmat.val1-pmat.val2);

    int32 score = eval(&pos,false);

    int32 tropism_delta = knight_tropism * distance(F3,pos.black_king)
        - knight_tropism * distance(G1,pos.black_king);

    assert(score==pawn_pst[D4] -pawn_pst[D2] + pawn_pst[E3] -pawn_pst[E2]
                 + bishop_pst[D3] - bishop_pst[F1]
                 + knight_pst[F3] - knight_pst[G1]
                 + rook_pst[E1] - rook_pst[H1]
                 + king_pst[G1] - king_pst[E1]
                 + tropism_delta);

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c1a9(%rip), %rsi     # 0x2db48
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
callq 0x52f7
movq %rax, %rcx
shrq $0x20, %rcx
cmpl %ecx, %eax
jne 0x11a1e
leaq 0x8(%rsp), %rdi
callq 0x540b
movq %rax, %rcx
shrq $0x20, %rcx
cmpl %ecx, %eax
jne 0x11a3d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
movl %eax, %ebp
movl 0x150(%rbx), %esi
pushq $0x2d
popq %rdi
callq 0xc136
movl %eax, %r14d
movl 0x150(%rbx), %esi
pushq $0x3e
popq %rdi
callq 0xc136
subl %r14d, %eax
leal 0x47(,%rax,2), %eax
cmpl %eax, %ebp
jne 0x11a5c
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1c15e(%rip), %rdi     # 0x2db83
leaq 0x1b68d(%rip), %rsi     # 0x2d0b9
leaq 0x1c169(%rip), %rcx     # 0x2db9c
movl $0xa3, %edx
callq 0x20c0
leaq 0x1c16d(%rip), %rdi     # 0x2dbb1
leaq 0x1b66e(%rip), %rsi     # 0x2d0b9
leaq 0x1c14a(%rip), %rcx     # 0x2db9c
movl $0xa6, %edx
callq 0x20c0
leaq 0x1c165(%rip), %rdi     # 0x2dbc8
leaq 0x1b64f(%rip), %rsi     # 0x2d0b9
leaq 0x1c12b(%rip), %rcx     # 0x2db9c
movl $0xb2, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_king_endgame_pst()
void test_king_endgame_pst() {
    position pos;

    set_pos(&pos,"8/8/8/4k3/8/8/8/RNB2K2 w - - 0 1");

    int32_pair npmat = eval_nonpawn_material(&pos);
    int32 expected = rook_val + knight_val + bishop_val;
    assert(expected==npmat.val1);
    assert(0==npmat.val2);

    expected += rook_open_file + knight_pst[B1]
            + knight_tropism * distance(B1,pos.black_king)
            + king_endgame_pst[F1] - king_pst[E5]
            - eval_scale(king_safety_middle_open_file,rook_val+knight_val+bishop_val);
    assert(expected==eval(&pos,false));

    // by removing a bishop both sides should be evaluated as in the endgame
    set_pos(&pos,"8/8/8/4k3/8/8/8/RN3K2 b - - 0 1");

    expected = -rook_val - knight_val - rook_open_file
            - knight_pst[B1]
            - knight_tropism * distance(B1,pos.black_king)
            - king_endgame_pst[F1]
            + king_endgame_pst[E5];
    assert(expected==eval(&pos,false));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c20a(%rip), %rsi     # 0x2dc97
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
callq 0x52f7
cmpl $0x460, %eax            # imm = 0x460
jne 0x11b3a
shrq $0x20, %rax
jne 0x11b59
leaq 0x8(%rsp), %rbx
movl 0x150(%rbx), %esi
pushq $0x39
popq %rdi
callq 0xc136
movl %eax, %r14d
pushq $-0x32
popq %rdi
movl $0x460, %esi            # imm = 0x460
callq 0x5162
leal (%rax,%r14,2), %eax
movl $0x48d, %ebp            # imm = 0x48D
subl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
cmpl %eax, %ebp
jne 0x11b78
leaq 0x1c215(%rip), %rsi     # 0x2dd13
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movl 0x150(%rbx), %esi
pushq $0x39
popq %rdi
callq 0xc136
leal -0x316(,%rax,2), %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
cmpl %eax, %ebp
jne 0x11b97
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1c177(%rip), %rdi     # 0x2dcb8
leaq 0x1b571(%rip), %rsi     # 0x2d0b9
leaq 0x1c17e(%rip), %rcx     # 0x2dccd
movl $0xbd, %edx
callq 0x20c0
leaq 0x1c18a(%rip), %rdi     # 0x2dcea
leaq 0x1b552(%rip), %rsi     # 0x2d0b9
leaq 0x1c15f(%rip), %rcx     # 0x2dccd
movl $0xbe, %edx
callq 0x20c0
leaq 0x1c179(%rip), %rdi     # 0x2dcf8
leaq 0x1b533(%rip), %rsi     # 0x2d0b9
leaq 0x1c140(%rip), %rcx     # 0x2dccd
movl $0xc4, %edx
callq 0x20c0
leaq 0x1c15a(%rip), %rdi     # 0x2dcf8
leaq 0x1b514(%rip), %rsi     # 0x2d0b9
leaq 0x1c121(%rip), %rcx     # 0x2dccd
movl $0xce, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_king_safety_middle_files()
void test_king_safety_middle_files() {
    position pos;

    // initial position then e3... no penalty
    set_pos(&pos,"rnbqkbnr/pppppppp/8/8/8/4P3/PPPP1PPP/RNBQKBNR w KQkq - 0 1");
    int32 score = eval(&pos,false);
    assert(score==pawn_pst[E3]-pawn_pst[E2]);

    // open file for both, so still no penalty
    set_pos(&pos,"rnbqkbnr/pppp1ppp/8/8/8/8/PPPP1PPP/RNBQKBNR w KQkq - 0 1");
    score = eval(&pos,false);
    assert(score==0);

    // remove both queens.  open e file.  put black king on d8
    set_pos(&pos,"rnbk1bnr/pppp1ppp/8/8/8/8/PPPP1PPP/RNB1KBNR b KQ - 0 1");
    score = eval(&pos,false);
    assert(score== -eval_scale(king_safety_middle_open_file,
            rook_val*2 + knight_val*2 + bishop_val*2) + king_pst[fliprank[D8]]);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c16e(%rip), %rsi     # 0x2dd33
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
cmpl $0x8, %eax
jne 0x11c42
leaq 0x1c1cc(%rip), %rsi     # 0x2ddb4
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
testl %eax, %eax
jne 0x11c61
leaq 0x1c1e3(%rip), %rsi     # 0x2dded
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
movl %eax, %ebx
pushq $-0x32
popq %rdi
movl $0x8c0, %esi            # imm = 0x8C0
callq 0x5162
pushq $-0x19
popq %rcx
subl %eax, %ecx
cmpl %ecx, %ebx
jne 0x11c80
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c125(%rip), %rdi     # 0x2dd6e
leaq 0x1b469(%rip), %rsi     # 0x2d0b9
leaq 0x1c138(%rip), %rcx     # 0x2dd8f
movl $0xd7, %edx
callq 0x20c0
leaq 0x1b448(%rip), %rdi     # 0x2d0b0
leaq 0x1b44a(%rip), %rsi     # 0x2d0b9
leaq 0x1c119(%rip), %rcx     # 0x2dd8f
movl $0xdc, %edx
callq 0x20c0
leaq 0x1c19d(%rip), %rdi     # 0x2de24
leaq 0x1b42b(%rip), %rsi     # 0x2d0b9
leaq 0x1c0fa(%rip), %rcx     # 0x2dd8f
movl $0xe2, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_king_safety_kingside()
void test_king_safety_kingside() {
    position pos;

    // no pawns advanced
    set_pos(&pos,"rnbq1rk1/pppppppp/8/8/8/8/PPPPPPPP/RNBQ1RK1 w kq - 0 1");
    assert(eval(&pos,false)==0);

    // white pawn on f4
    set_pos(&pos,"rnbq1rk1/pppppppp/8/8/8/5P2/PPPPP1PP/RNBQ1RK1 w kq - 0 1");
    assert(eval(&pos,false)==pawn_pst[F3]-pawn_pst[F2]
        + eval_scale(king_safety_pawn_one_away,rook_val*2+knight_val+bishop_val+queen_val));

    // white pawn on g4
    set_pos(&pos,"rnbq1rk1/pppppppp/8/8/6P1/8/PPPPPP1P/RNBQ1RK1 w kq - 0 1");
    assert(eval(&pos,false)==pawn_pst[G4]-pawn_pst[G2]+eval_scale(king_safety_pawn_two_away,rook_val*2+knight_val+bishop_val+queen_val));

    // black pawn on h4
    set_pos(&pos,"rnbq1rk1/ppppppp1/8/8/7p/8/PPPPPPPP/RNBQ1RK1 b KQkq - 0 1");
    assert(eval(&pos,false)==pawn_pst[fliprank[H4]]-pawn_pst[fliprank[H7]]
         +eval_scale(king_safety_pawn_far_away/2,rook_val*2+knight_val+bishop_val+queen_val));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c1eb(%rip), %rsi     # 0x2de99
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
testl %eax, %eax
jne 0x11d76
leaq 0x1c231(%rip), %rsi     # 0x2df05
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
movl %eax, %ebx
pushq $-0xa
popq %rdi
movl $0x9d8, %esi            # imm = 0x9D8
callq 0x5162
addl $0x3, %eax
cmpl %eax, %ebx
jne 0x11d95
leaq 0x1c2b1(%rip), %rsi     # 0x2dfbd
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
movl %eax, %ebx
pushq $-0x14
popq %rdi
movl $0x9d8, %esi            # imm = 0x9D8
callq 0x5162
addl $0x5, %eax
cmpl %eax, %ebx
jne 0x11db4
leaq 0x1c333(%rip), %rsi     # 0x2e073
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
movl %eax, %ebx
pushq $-0xf
popq %rdi
movl $0x9d8, %esi            # imm = 0x9D8
callq 0x5162
addl $0x7, %eax
cmpl %eax, %ebx
jne 0x11dd3
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c153(%rip), %rdi     # 0x2ded0
leaq 0x1b335(%rip), %rsi     # 0x2d0b9
leaq 0x1c159(%rip), %rcx     # 0x2dee4
movl $0xea, %edx
callq 0x20c0
leaq 0x1c1a2(%rip), %rdi     # 0x2df3e
leaq 0x1b316(%rip), %rsi     # 0x2d0b9
leaq 0x1c13a(%rip), %rcx     # 0x2dee4
movl $0xef, %edx
callq 0x20c0
leaq 0x1c23b(%rip), %rdi     # 0x2dff6
leaq 0x1b2f7(%rip), %rsi     # 0x2d0b9
leaq 0x1c11b(%rip), %rcx     # 0x2dee4
movl $0xf3, %edx
callq 0x20c0
leaq 0x1c2d3(%rip), %rdi     # 0x2e0ad
leaq 0x1b2d8(%rip), %rsi     # 0x2d0b9
leaq 0x1c0fc(%rip), %rcx     # 0x2dee4
movl $0xf8, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_king_safety_queenside()
void test_king_safety_queenside() {
    position pos;

    // white pawn on c3
    set_pos(&pos,"1krq1bnr/pppppppp/8/8/8/2P5/PP1PPPPP/1KRQ1BNR w kq - 0 1");
    assert(eval(&pos,false)==pawn_pst[C3]-pawn_pst[C2]+eval_scale(king_safety_pawn_one_away,rook_val*2+queen_val+bishop_val+knight_val));

    // white pawn on b4
    set_pos(&pos,"1krq1bnr/pppppppp/8/8/1P6/8/P1PPPPPP/1KRQ1BNR w kq - 0 1");
    assert(eval(&pos,false)==pawn_pst[B4]-pawn_pst[B2]+eval_scale(king_safety_pawn_two_away,rook_val*2+queen_val+bishop_val+knight_val));

    // black pawn on a4
    set_pos(&pos,"1krq1bnr/1ppppppp/8/8/p7/8/PPPPPPPP/1KRQ1BNR b kq - 0 1");
    assert(eval(&pos,false)==pawn_pst[fliprank[A4]]-pawn_pst[fliprank[A7]]
       +eval_scale(king_safety_pawn_far_away/2,rook_val*2+queen_val+bishop_val+knight_val));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c340(%rip), %rsi     # 0x2e141
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
movl %eax, %ebx
pushq $-0xa
popq %rdi
movl $0x9d8, %esi            # imm = 0x9D8
callq 0x5162
addl $0x3, %eax
cmpl %eax, %ebx
jne 0x11e9f
leaq 0x1c3e4(%rip), %rsi     # 0x2e219
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
movl %eax, %ebx
pushq $-0x14
popq %rdi
movl $0x9d8, %esi            # imm = 0x9D8
callq 0x5162
addl $0x5, %eax
cmpl %eax, %ebx
jne 0x11ebe
leaq 0x1c466(%rip), %rsi     # 0x2e2cf
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
movl %eax, %ebx
pushq $-0xf
popq %rdi
movl $0x9d8, %esi            # imm = 0x9D8
callq 0x5162
addl $0x7, %eax
cmpl %eax, %ebx
jne 0x11edd
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c2d4(%rip), %rdi     # 0x2e17a
leaq 0x1b20c(%rip), %rsi     # 0x2d0b9
leaq 0x1c343(%rip), %rcx     # 0x2e1f7
movl $0x100, %edx            # imm = 0x100
callq 0x20c0
leaq 0x1c38d(%rip), %rdi     # 0x2e252
leaq 0x1b1ed(%rip), %rsi     # 0x2d0b9
leaq 0x1c324(%rip), %rcx     # 0x2e1f7
movl $0x104, %edx            # imm = 0x104
callq 0x20c0
leaq 0x1c423(%rip), %rdi     # 0x2e307
leaq 0x1b1ce(%rip), %rsi     # 0x2d0b9
leaq 0x1c305(%rip), %rcx     # 0x2e1f7
movl $0x109, %edx            # imm = 0x109
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_double_and_isolated_pawns()
void test_double_and_isolated_pawns() {
    position pos;

    set_pos(&pos,"k7/p1p3p1/3p3p/1P5P/1PP1P3/8/8/K7 b - - 0 1");
    int32_pair npmat = eval_nonpawn_material(&pos);
    assert(0==npmat.val1);
    assert(0==npmat.val2);

    int32_pair pmat = eval_pawn_material(&pos);
    assert(pawn_val*5==pmat.val1);
    assert(pawn_val*5==pmat.val2);

    int32 expected = king_endgame_pst[fliprank[A8]]
           + pawn_pst[fliprank[A7]] + pawn_pst[fliprank[C7]] + pawn_pst[fliprank[D6]]
           + pawn_pst[fliprank[G7]] + pawn_pst[fliprank[H6]]
           + isolated_pawn // black pawn on a7
           - king_endgame_pst[A1]
           - pawn_pst[B5] - pawn_pst[B4] - pawn_pst[C4] - pawn_pst[E4] - pawn_pst[H5]
           - isolated_pawn*2 // white pawns on e4 and h1
           - doubled_pawn*2;  // white pawns on b4 and b5
    assert(eval(&pos,false)==expected);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c490(%rip), %rsi     # 0x2e39b
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
callq 0x52f7
testl %eax, %eax
jne 0x11f63
testq %rax, %rax
jne 0x11f82
leaq 0x8(%rsp), %rdi
callq 0x540b
cmpl $0x1f4, %eax            # imm = 0x1F4
jne 0x11fa1
shrq $0x20, %rax
cmpl $0x1f4, %eax            # imm = 0x1F4
jne 0x11fc0
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x547b
cmpl $0x11, %eax
jne 0x11fdf
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c45d(%rip), %rdi     # 0x2e3c7
leaq 0x1b148(%rip), %rsi     # 0x2d0b9
leaq 0x1c45d(%rip), %rcx     # 0x2e3d5
movl $0x111, %edx            # imm = 0x111
callq 0x20c0
leaq 0x1bd61(%rip), %rdi     # 0x2dcea
leaq 0x1b129(%rip), %rsi     # 0x2d0b9
leaq 0x1c43e(%rip), %rcx     # 0x2e3d5
movl $0x112, %edx            # imm = 0x112
callq 0x20c0
leaq 0x1c453(%rip), %rdi     # 0x2e3fb
leaq 0x1b10a(%rip), %rsi     # 0x2d0b9
leaq 0x1c41f(%rip), %rcx     # 0x2e3d5
movl $0x115, %edx            # imm = 0x115
callq 0x20c0
leaq 0x1c44a(%rip), %rdi     # 0x2e411
leaq 0x1b0eb(%rip), %rsi     # 0x2d0b9
leaq 0x1c400(%rip), %rcx     # 0x2e3d5
movl $0x116, %edx            # imm = 0x116
callq 0x20c0
leaq 0x1b85d(%rip), %rdi     # 0x2d843
leaq 0x1b0cc(%rip), %rsi     # 0x2d0b9
leaq 0x1c3e1(%rip), %rcx     # 0x2e3d5
movl $0x120, %edx            # imm = 0x120
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_symmetry(int, position*)
bool test_eval_symmetry(int32 score,position *pos) {
    position flip_pos;

    memcpy(&flip_pos,pos,sizeof(position));
    flip_board(&flip_pos);

    int32 score2=eval(&flip_pos,false);
    assert(score==score2);

    flip_board(&flip_pos);
    assert(equal_pos(pos,&flip_pos,true));

    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movl $0x1c8, %edx            # imm = 0x1C8
movq %r14, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0xa64d
movq %r14, %rdi
xorl %esi, %esi
callq 0x547b
cmpl %ebp, %eax
jne 0x12127
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa64d
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x98c8
testb %al, %al
je 0x12146
movb $0x1, %al
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1c3e5(%rip), %rdi     # 0x2e513
leaq 0x1af84(%rip), %rsi     # 0x2d0b9
leaq 0x1c3e5(%rip), %rcx     # 0x2e521
movl $0x13e, %edx            # imm = 0x13E
callq 0x20c0
leaq 0x1c3ff(%rip), %rdi     # 0x2e54c
leaq 0x1af65(%rip), %rsi     # 0x2d0b9
leaq 0x1c3c6(%rip), %rcx     # 0x2e521
movl $0x141, %edx            # imm = 0x141
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_material()
void test_eval_material() {
    position pos;

    set_pos(&pos,"8/k7/prb5/K7/QN6/8/8/8 b - - 0 1");
    int32_pair np = eval_nonpawn_material(&pos);
    assert(np.val1==queen_val+knight_val);
    assert(np.val2==rook_val+bishop_val);

    int32_pair p = eval_pawn_material(&pos);
    assert(p.val1==0);
    assert(p.val2==pawn_val);

    assert(eval(&pos,true)==pawn_val+rook_val+bishop_val-queen_val-knight_val);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c847(%rip), %rsi     # 0x2ebc0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
callq 0x52f7
cmpl $0x4b0, %eax            # imm = 0x4B0
jne 0x123de
shrq $0x20, %rax
cmpl $0x334, %eax            # imm = 0x334
jne 0x123fd
leaq 0x8(%rsp), %rdi
callq 0x540b
testl %eax, %eax
jne 0x1241c
movabsq $0x6400000000, %rcx     # imm = 0x6400000000
cmpq %rcx, %rax
jne 0x1243b
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x547b
cmpl $0xfffffee8, %eax       # imm = 0xFFFFFEE8
jne 0x1245a
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c7fc(%rip), %rdi     # 0x2ebe1
leaq 0x1accd(%rip), %rsi     # 0x2d0b9
leaq 0x1c80c(%rip), %rcx     # 0x2ebff
movl $0x170, %edx            # imm = 0x170
callq 0x20c0
leaq 0x1c815(%rip), %rdi     # 0x2ec19
leaq 0x1acae(%rip), %rsi     # 0x2d0b9
leaq 0x1c7ed(%rip), %rcx     # 0x2ebff
movl $0x171, %edx            # imm = 0x171
callq 0x20c0
leaq 0x1c813(%rip), %rdi     # 0x2ec36
leaq 0x1ac8f(%rip), %rsi     # 0x2d0b9
leaq 0x1c7ce(%rip), %rcx     # 0x2ebff
movl $0x174, %edx            # imm = 0x174
callq 0x20c0
leaq 0x1c7fe(%rip), %rdi     # 0x2ec40
leaq 0x1ac70(%rip), %rsi     # 0x2d0b9
leaq 0x1c7af(%rip), %rcx     # 0x2ebff
movl $0x175, %edx            # imm = 0x175
callq 0x20c0
leaq 0x1c7f0(%rip), %rdi     # 0x2ec51
leaq 0x1ac51(%rip), %rsi     # 0x2d0b9
leaq 0x1c790(%rip), %rcx     # 0x2ebff
movl $0x177, %edx            # imm = 0x177
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_evalfunc()
void test_evalfunc() {
    position pos;

    reset_pos(&pos);
    assert(eval(&pos,false)==0);

    // ensure the score is from the player POV
    set_pos(&pos,"rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1");
    int32 score=eval(&pos,false);
    pos.player=WHITE;
    int32 score2=eval(&pos,false);
    assert(score==-score2);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xa187
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
testl %eax, %eax
jne 0x12540
leaq 0x18f9c(%rip), %rsi     # 0x2b4a3
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
movl %eax, %ebp
movl $0x1, 0x138(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x547b
addl %ebp, %eax
jne 0x1255f
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %rbp
retq
leaq 0x1b989(%rip), %rdi     # 0x2ded0
leaq 0x1ab6b(%rip), %rsi     # 0x2d0b9
leaq 0x1c791(%rip), %rcx     # 0x2ece6
movl $0x185, %edx            # imm = 0x185
callq 0x20c0
leaq 0x1c795(%rip), %rdi     # 0x2ecfb
leaq 0x1ab4c(%rip), %rsi     # 0x2d0b9
leaq 0x1c772(%rip), %rcx     # 0x2ece6
movl $0x18c, %edx            # imm = 0x18C
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval()
void test_eval() {
    test_start_pos_is_0();
    test_eval_pawn();
    test_eval_knight();
    test_eval_bishop();
    test_eval_rook();
    test_eval_rook_on_7th();
    test_eval_connected_majors_7th();
    test_eval_rook_open_file();
    test_eval_rook_half_open_file();
    test_eval_queen();
    test_king_pst();
    test_king_endgame_pst();
    test_king_safety_middle_files();
    test_king_safety_kingside();
    test_king_safety_queenside();
    test_double_and_isolated_pawns();
    test_score1();
    test_score2();
    test_vertical_symmetry();
    test_eval_material();
    test_eval_scale();
    test_evalfunc();
}

// Assembly:
pushq %rax
callq 0x110fc
callq 0x11145
callq 0x111fa
callq 0x11313
callq 0x113a4
callq 0x11558
callq 0x1167e
callq 0x11769
callq 0x11844
callq 0x118dd
callq 0x1198d
callq 0x11a7b
callq 0x11bb6
callq 0x11c9f
callq 0x11df2
callq 0x11efc
callq 0x11ffe
callq 0x12051
callq 0x12165
callq 0x1236a
callq 0x12479
popq %rax
jmp 0x124de
nop
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/evalp__test.cpp
// Function: test_passed_pawn_initial_pos()
void test_passed_pawn_initial_pos() {
    position pos;
    reset_pos(&pos);

    for (int i=0;i<64;i++) {
        if (pos.piece[i]==PAWN || pos.piece[i]==-PAWN) {
            assert(!is_passed(&pos,(square_t)i,pos.piece[i]==PAWN));
            assert(!is_doubled(&pos,(square_t)i,pos.piece[i]==PAWN));
            assert(!is_isolated(&pos,(square_t)i,pos.piece[i]==PAWN));
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xa187
xorl %r14d, %r14d
cmpq $0x40, %r14
je 0x1266a
movl (%rsp,%r14,4), %eax
cmpl $0x1, %eax
je 0x1261c
cmpl $-0x1, %eax
jne 0x12665
xorl %edx, %edx
cmpl $0x1, %eax
sete %dl
movq %rbx, %rdi
movl %r14d, %esi
callq 0x580e
testb %al, %al
jne 0x12675
xorl %edx, %edx
cmpl $0x1, (%rsp,%r14,4)
sete %dl
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5866
testb %al, %al
jne 0x1268e
xorl %edx, %edx
cmpl $0x1, (%rsp,%r14,4)
sete %dl
movq %rbx, %rdi
movl %r14d, %esi
callq 0x58e2
testb %al, %al
jne 0x126a7
incq %r14
jmp 0x12608
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x1c68e(%rip), %rdi     # 0x2ed0a
leaq 0x1c6b7(%rip), %rsi     # 0x2ed3a
leaq 0x1c6c5(%rip), %rcx     # 0x2ed4f
pushq $0x13
jmp 0x126be
leaq 0x1c6de(%rip), %rdi     # 0x2ed73
leaq 0x1c69e(%rip), %rsi     # 0x2ed3a
leaq 0x1c6ac(%rip), %rcx     # 0x2ed4f
pushq $0x14
jmp 0x126be
leaq 0x1c6f6(%rip), %rdi     # 0x2eda4
leaq 0x1c685(%rip), %rsi     # 0x2ed3a
leaq 0x1c693(%rip), %rcx     # 0x2ed4f
pushq $0x15
popq %rdx
callq 0x20c0