LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_transform_upper_bound_mate()
void test_transform_upper_bound_mate() {
    clear_hash_table(&htbl);
    position pos;
    set_pos(&pos,"r4rk1/ppp2ppp/2n5/2bqp3/8/P2PB3/1PP1NPPP/R2Q1RK1 w - -");

    uint64 key = build_hash_key(&pos);
    move mv = to_move(ROOK,F1,E1);
    store_hash_entry(&htbl,key,build_hash_val(UPPER_BOUND,5,CHECKMATE-3,mv));

    uint64 val = get_hash_entry(&htbl,key);
    assert(val!=0);
    assert(get_hash_entry_type(val)==MOVE_ONLY);
    assert(get_hash_entry_move(val)==mv);
    assert(get_hash_entry_depth(val)==5);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0xe0652(%rip), %r14     # 0xf7ef0
movq %r14, %rdi
callq 0x6207
leaq 0x1a6f5(%rip), %rsi     # 0x31fa2
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rbx, %rdi
callq 0x5e40
movq %rax, %r15
movl $0x4, %edi
movl $0x3d, %esi
movl $0x3c, %edx
callq 0x76b8
movq %rax, %rbx
movl $0x2, %edi
movl $0x5, %esi
movl $0xfffc, %edx           # imm = 0xFFFC
movq %rax, %rcx
callq 0x5fa7
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x62c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x6263
testq %rax, %rax
je 0x17947
movq %rax, %r14
movq %rax, %rdi
callq 0x6135
testl %eax, %eax
jne 0x17966
movq %r14, %rdi
callq 0x616d
cmpq %rbx, %rax
jne 0x17985
movq %r14, %rdi
callq 0x613c
cmpl $0x5, %eax
jne 0x179a4
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a608(%rip), %rdi     # 0x31f56
leaq 0x1a1d0(%rip), %rsi     # 0x31b25
leaq 0x1a67d(%rip), %rcx     # 0x31fd9
movl $0x1ae, %edx            # imm = 0x1AE
callq 0x20d0
leaq 0x1a693(%rip), %rdi     # 0x32000
leaq 0x1a1b1(%rip), %rsi     # 0x31b25
leaq 0x1a65e(%rip), %rcx     # 0x31fd9
movl $0x1af, %edx            # imm = 0x1AF
callq 0x20d0
leaq 0x1a3a4(%rip), %rdi     # 0x31d30
leaq 0x1a192(%rip), %rsi     # 0x31b25
leaq 0x1a63f(%rip), %rcx     # 0x31fd9
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x20d0
leaq 0x1a679(%rip), %rdi     # 0x32024
leaq 0x1a173(%rip), %rsi     # 0x31b25
leaq 0x1a620(%rip), %rcx     # 0x31fd9
movl $0x1b1, %edx            # imm = 0x1B1
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_transform_exact_score_mate()
void test_transform_exact_score_mate() {
    clear_hash_table(&htbl);
    position pos;
    set_pos(&pos,"3r2k1/p6p/2Q3p1/4q3/2P1p3/P3Pb2/1P3P1P/2K2BR1 b - - ");

    uint64 key = build_hash_key(&pos);
    move mv = to_move(ROOK,G8,F8);
    store_hash_entry(&htbl,key,build_hash_val(EXACT_SCORE,5,CHECKMATE-7,mv));

    uint64 val = get_hash_entry(&htbl,key);
    assert(val!=0);
    assert(get_hash_entry_type(val)==LOWER_BOUND);
    assert(get_hash_entry_move(val)==mv);
    assert(get_hash_entry_score(val)==CHECKMATE-500);
    assert(get_hash_entry_depth(val)==5);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0xe051a(%rip), %r14     # 0xf7ef0
movq %r14, %rdi
callq 0x6207
leaq 0x1a65c(%rip), %rsi     # 0x32041
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rbx, %rdi
callq 0x5e40
movq %rax, %r15
movl $0x4, %edi
movl $0x6, %esi
movl $0x5, %edx
callq 0x76b8
movq %rax, %rbx
movl $0x3, %edi
movl $0x5, %esi
movl $0xfff8, %edx           # imm = 0xFFF8
movq %rax, %rcx
callq 0x5fa7
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x62c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x6263
testq %rax, %rax
je 0x17a93
movq %rax, %r14
movq %rax, %rdi
callq 0x6135
cmpl $0x1, %eax
jne 0x17ab2
movq %r14, %rdi
callq 0x616d
cmpq %rbx, %rax
jne 0x17ad1
movq %r14, %rdi
callq 0x6143
cmpl $0xfe0b, %eax           # imm = 0xFE0B
jne 0x17af0
movq %r14, %rdi
callq 0x613c
cmpl $0x5, %eax
jne 0x17b0f
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a4bc(%rip), %rdi     # 0x31f56
leaq 0x1a084(%rip), %rsi     # 0x31b25
leaq 0x1a5ce(%rip), %rcx     # 0x32076
movl $0x1be, %edx            # imm = 0x1BE
callq 0x20d0
leaq 0x1a1ee(%rip), %rdi     # 0x31ca7
leaq 0x1a065(%rip), %rsi     # 0x31b25
leaq 0x1a5af(%rip), %rcx     # 0x32076
movl $0x1bf, %edx            # imm = 0x1BF
callq 0x20d0
leaq 0x1a258(%rip), %rdi     # 0x31d30
leaq 0x1a046(%rip), %rsi     # 0x31b25
leaq 0x1a590(%rip), %rcx     # 0x32076
movl $0x1c0, %edx            # imm = 0x1C0
callq 0x20d0
leaq 0x1a482(%rip), %rdi     # 0x31f79
leaq 0x1a027(%rip), %rsi     # 0x31b25
leaq 0x1a571(%rip), %rcx     # 0x32076
movl $0x1c1, %edx            # imm = 0x1C1
callq 0x20d0
leaq 0x1a50e(%rip), %rdi     # 0x32024
leaq 0x1a008(%rip), %rsi     # 0x31b25
leaq 0x1a552(%rip), %rcx     # 0x32076
movl $0x1c2, %edx            # imm = 0x1C2
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_transform_lower_bound_mated()
void test_transform_lower_bound_mated() {
    clear_hash_table(&htbl);
    position pos;
    set_pos(&pos,"2rq1bk1/p4p1p/1p4p1/3b4/3B1Q2/8/P4PpP/3RR1K1 w - - ");

    uint64 key = build_hash_key(&pos);
    move mv = to_move(ROOK,D1,A1);
    store_hash_entry(&htbl,key,build_hash_val(LOWER_BOUND,8,-CHECKMATE+10,mv));

    uint64 val = get_hash_entry(&htbl,key);
    assert(val!=0);
    assert(get_hash_entry_type(val)==MOVE_ONLY);
    assert(get_hash_entry_move(val)==mv);
    assert(get_hash_entry_depth(val)==8);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0xe03af(%rip), %r14     # 0xf7ef0
movq %r14, %rdi
callq 0x6207
leaq 0x1a54d(%rip), %rsi     # 0x3209d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rbx, %rdi
callq 0x5e40
movq %rax, %r15
movl $0x4, %edi
movl $0x3b, %esi
movl $0x38, %edx
callq 0x76b8
movq %rax, %rbx
movl $0x1, %edi
movl $0x8, %esi
movl $0xffff000b, %edx       # imm = 0xFFFF000B
movq %rax, %rcx
callq 0x5fa7
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x62c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x6263
testq %rax, %rax
je 0x17bea
movq %rax, %r14
movq %rax, %rdi
callq 0x6135
testl %eax, %eax
jne 0x17c09
movq %r14, %rdi
callq 0x616d
cmpq %rbx, %rax
jne 0x17c28
movq %r14, %rdi
callq 0x613c
cmpl $0x8, %eax
jne 0x17c47
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a365(%rip), %rdi     # 0x31f56
leaq 0x19f2d(%rip), %rsi     # 0x31b25
leaq 0x1a4d2(%rip), %rcx     # 0x320d1
movl $0x1cf, %edx            # imm = 0x1CF
callq 0x20d0
leaq 0x1a3f0(%rip), %rdi     # 0x32000
leaq 0x19f0e(%rip), %rsi     # 0x31b25
leaq 0x1a4b3(%rip), %rcx     # 0x320d1
movl $0x1d0, %edx            # imm = 0x1D0
callq 0x20d0
leaq 0x1a101(%rip), %rdi     # 0x31d30
leaq 0x19eef(%rip), %rsi     # 0x31b25
leaq 0x1a494(%rip), %rcx     # 0x320d1
movl $0x1d1, %edx            # imm = 0x1D1
callq 0x20d0
leaq 0x1a4ab(%rip), %rdi     # 0x320f9
leaq 0x19ed0(%rip), %rsi     # 0x31b25
leaq 0x1a475(%rip), %rcx     # 0x320d1
movl $0x1d2, %edx            # imm = 0x1D2
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_transform_exact_score_mated()
void test_transform_exact_score_mated() {
    clear_hash_table(&htbl);
    position pos;
    set_pos(&pos,"4r1k1/5bpp/2p5/3pr3/8/1B3pPq/PPR2P2/2R2QK1 b - - ");

    uint64 key = build_hash_key(&pos);
    move mv = to_move(PAWN,G7,G6);
    store_hash_entry(&htbl,key,build_hash_val(EXACT_SCORE,10,-CHECKMATE+2,mv));

    uint64 val = get_hash_entry(&htbl,key);
    assert(val!=0);
    assert(get_hash_entry_type(val)==UPPER_BOUND);
    assert(get_hash_entry_move(val)==mv);
    assert(get_hash_entry_score(val)==-CHECKMATE+500);
    assert(get_hash_entry_depth(val)==10);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0xe0277(%rip), %r14     # 0xf7ef0
movq %r14, %rdi
callq 0x6207
leaq 0x1a48e(%rip), %rsi     # 0x32116
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rbx, %rdi
callq 0x5e40
movq %rax, %r15
movl $0x1, %edi
movl $0xe, %esi
movl $0x16, %edx
callq 0x76b8
movq %rax, %rbx
movl $0x3, %edi
movl $0xa, %esi
movl $0xffff0003, %edx       # imm = 0xFFFF0003
movq %rax, %rcx
callq 0x5fa7
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x62c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x6263
testq %rax, %rax
je 0x17d36
movq %rax, %r14
movq %rax, %rdi
callq 0x6135
cmpl $0x2, %eax
jne 0x17d55
movq %r14, %rdi
callq 0x616d
cmpq %rbx, %rax
jne 0x17d74
movq %r14, %rdi
callq 0x6143
cmpl $0xffff01f5, %eax       # imm = 0xFFFF01F5
jne 0x17d93
movq %r14, %rdi
callq 0x613c
cmpl $0xa, %eax
jne 0x17db2
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a219(%rip), %rdi     # 0x31f56
leaq 0x19de1(%rip), %rsi     # 0x31b25
leaq 0x1a3fd(%rip), %rcx     # 0x32148
movl $0x1df, %edx            # imm = 0x1DF
callq 0x20d0
leaq 0x19ff1(%rip), %rdi     # 0x31d4d
leaq 0x19dc2(%rip), %rsi     # 0x31b25
leaq 0x1a3de(%rip), %rcx     # 0x32148
movl $0x1e0, %edx            # imm = 0x1E0
callq 0x20d0
leaq 0x19fb5(%rip), %rdi     # 0x31d30
leaq 0x19da3(%rip), %rsi     # 0x31b25
leaq 0x1a3bf(%rip), %rcx     # 0x32148
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x20d0
leaq 0x19ffa(%rip), %rdi     # 0x31d94
leaq 0x19d84(%rip), %rsi     # 0x31b25
leaq 0x1a3a0(%rip), %rcx     # 0x32148
movl $0x1e2, %edx            # imm = 0x1E2
callq 0x20d0
leaq 0x1a3b7(%rip), %rdi     # 0x32170
leaq 0x19d65(%rip), %rsi     # 0x31b25
leaq 0x1a381(%rip), %rcx     # 0x32148
movl $0x1e3, %edx            # imm = 0x1E3
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_transform_upper_bound_mated()
void test_transform_upper_bound_mated() {
    clear_hash_table(&htbl);
    position pos;
    set_pos(&pos,"r1b1k2r/1pp1q2p/p1n3p1/3QPp2/8/1BP3B1/P5PP/3R1RK1 w kq - ");

    uint64 key = build_hash_key(&pos);
    move mv = to_move(KING,G1,H1);
    store_hash_entry(&htbl,key,build_hash_val(UPPER_BOUND,7,-CHECKMATE+8,mv));

    uint64 val = get_hash_entry(&htbl,key);
    assert(val!=0);
    assert(get_hash_entry_type(val)==UPPER_BOUND);
    assert(get_hash_entry_move(val)==mv);
    assert(get_hash_entry_score(val)==-CHECKMATE+500);
    assert(get_hash_entry_depth(val)==7);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0xe010c(%rip), %r14     # 0xf7ef0
movq %r14, %rdi
callq 0x6207
leaq 0x1a39b(%rip), %rsi     # 0x3218e
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rbx, %rdi
callq 0x5e40
movq %rax, %r15
movl $0x6, %edi
movl $0x3e, %esi
movl $0x3f, %edx
callq 0x76b8
movq %rax, %rbx
movl $0x2, %edi
movl $0x7, %esi
movl $0xffff0009, %edx       # imm = 0xFFFF0009
movq %rax, %rcx
callq 0x5fa7
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x62c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x6263
testq %rax, %rax
je 0x17ea1
movq %rax, %r14
movq %rax, %rdi
callq 0x6135
cmpl $0x2, %eax
jne 0x17ec0
movq %r14, %rdi
callq 0x616d
cmpq %rbx, %rax
jne 0x17edf
movq %r14, %rdi
callq 0x6143
cmpl $0xffff01f5, %eax       # imm = 0xFFFF01F5
jne 0x17efe
movq %r14, %rdi
callq 0x613c
cmpl $0x7, %eax
jne 0x17f1d
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a0ae(%rip), %rdi     # 0x31f56
leaq 0x19c76(%rip), %rsi     # 0x31b25
leaq 0x1a312(%rip), %rcx     # 0x321c8
movl $0x1f0, %edx            # imm = 0x1F0
callq 0x20d0
leaq 0x19e86(%rip), %rdi     # 0x31d4d
leaq 0x19c57(%rip), %rsi     # 0x31b25
leaq 0x1a2f3(%rip), %rcx     # 0x321c8
movl $0x1f1, %edx            # imm = 0x1F1
callq 0x20d0
leaq 0x19e4a(%rip), %rdi     # 0x31d30
leaq 0x19c38(%rip), %rsi     # 0x31b25
leaq 0x1a2d4(%rip), %rcx     # 0x321c8
movl $0x1f2, %edx            # imm = 0x1F2
callq 0x20d0
leaq 0x19e8f(%rip), %rdi     # 0x31d94
leaq 0x19c19(%rip), %rsi     # 0x31b25
leaq 0x1a2b5(%rip), %rcx     # 0x321c8
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x20d0
leaq 0x1a2cc(%rip), %rdi     # 0x321f0
leaq 0x19bfa(%rip), %rsi     # 0x31b25
leaq 0x1a296(%rip), %rcx     # 0x321c8
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_clear()
void test_clear() {
    clear_hash_table(&htbl);
    position pos;
    set_pos(&pos,"3qrrk1/1pp2pp1/1p2bn1p/5N2/2P5/P1P3B1/1P4PP/2Q1RRK1 w - - ");

    uint64 key = build_hash_key(&pos);
    move mv = to_move(KNIGHT,F5,D4);
    store_hash_entry(&htbl,key,build_hash_val(UPPER_BOUND,4,-93,mv));

    uint64 val = get_hash_entry(&htbl,key);
    assert(val!=0);
    assert(get_hash_entry_type(val)==UPPER_BOUND);
    assert(get_hash_entry_move(val)==mv);
    assert(get_hash_entry_score(val)==-93);
    assert(get_hash_entry_depth(val)==4);

    clear_hash_table(&htbl);
    val = get_hash_entry(&htbl,key);
    assert(val==0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0xdffa1(%rip), %r15     # 0xf7ef0
movq %r15, %rdi
callq 0x6207
leaq 0x1a2af(%rip), %rsi     # 0x3220d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rbx, %rdi
callq 0x5e40
movq %rax, %rbx
movl $0x2, %edi
movl $0x1d, %esi
movl $0x23, %edx
callq 0x76b8
movq %rax, %r14
movl $0x2, %edi
movl $0x4, %esi
movl $0xffffffa3, %edx       # imm = 0xFFFFFFA3
movq %rax, %rcx
callq 0x5fa7
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x62c0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6263
testq %rax, %rax
je 0x18039
movq %rax, %r15
movq %rax, %rdi
callq 0x6135
cmpl $0x2, %eax
jne 0x18058
movq %r15, %rdi
callq 0x616d
cmpq %r14, %rax
jne 0x18077
movq %r15, %rdi
callq 0x6143
cmpl $-0x5d, %eax
jne 0x18096
movq %r15, %rdi
callq 0x613c
cmpl $0x4, %eax
jne 0x180b5
leaq 0xdfee0(%rip), %r14     # 0xf7ef0
movq %r14, %rdi
callq 0x6207
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6263
testq %rax, %rax
jne 0x180d4
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x19f16(%rip), %rdi     # 0x31f56
leaq 0x19ade(%rip), %rsi     # 0x31b25
leaq 0x1a1fa(%rip), %rcx     # 0x32248
movl $0x201, %edx            # imm = 0x201
callq 0x20d0
leaq 0x19cee(%rip), %rdi     # 0x31d4d
leaq 0x19abf(%rip), %rsi     # 0x31b25
leaq 0x1a1db(%rip), %rcx     # 0x32248
movl $0x202, %edx            # imm = 0x202
callq 0x20d0
leaq 0x19cb2(%rip), %rdi     # 0x31d30
leaq 0x19aa0(%rip), %rsi     # 0x31b25
leaq 0x1a1bc(%rip), %rcx     # 0x32248
movl $0x203, %edx            # imm = 0x203
callq 0x20d0
leaq 0x1a1bd(%rip), %rdi     # 0x3225a
leaq 0x19a81(%rip), %rsi     # 0x31b25
leaq 0x1a19d(%rip), %rcx     # 0x32248
movl $0x204, %edx            # imm = 0x204
callq 0x20d0
leaq 0x1a1bd(%rip), %rdi     # 0x32279
leaq 0x19a62(%rip), %rsi     # 0x31b25
leaq 0x1a17e(%rip), %rcx     # 0x32248
movl $0x205, %edx            # imm = 0x205
callq 0x20d0
leaq 0x19d8b(%rip), %rdi     # 0x31e66
leaq 0x19a43(%rip), %rsi     # 0x31b25
leaq 0x1a15f(%rip), %rcx     # 0x32248
movl $0x209, %edx            # imm = 0x209
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_hash()
void test_hash() {
    test_hash_keys1();
    test_hash_keys2();
    test_hash_keys3();
    test_hash_val_lower_bound();
    test_hash_val_upper_bound();
    test_hash_val_exact_score();
    test_store_and_probe();
    test_pawn_store_and_probe();
    test_with_mate_score();
    test_transform_upper_bound_mate();
    test_transform_exact_score_mate();
    test_transform_lower_bound_mated();
    test_transform_exact_score_mated();
    test_transform_upper_bound_mated();
    test_clear();
    test_overwrite();
}

// Assembly:
pushq %rax
callq 0x15635
callq 0x163a8
callq 0x16ad2
callq 0x16f5b
callq 0x17048
callq 0x17116
callq 0x17323
callq 0x1759e
callq 0x1777c
callq 0x1788b
callq 0x179c3
callq 0x17b2e
callq 0x17c66
callq 0x17dd1
callq 0x17f3c
popq %rax
jmp 0x180f3
nop
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/init__test.cpp
// Function: hamming_distance(unsigned long long, unsigned long long)
uint32 hamming_distance(uint64 x,uint64 y) {
    uint32 dist = 0;
    uint64 val = x ^ y;

    while (val != 0L) {
        dist++;
        val &= val - 1;
    }

    assert(dist >= 0 && dist <= 64);

    return dist;
}

// Assembly:
xorl %eax, %eax
cmpq %rdi, %rsi
je 0x18533
xorq %rdi, %rsi
xorl %eax, %eax
incl %eax
leaq -0x1(%rsi), %rcx
andq %rcx, %rsi
jne 0x18528
cmpl $0x41, %eax
jae 0x18539
retq
pushq %rax
leaq 0x19e5f(%rip), %rdi     # 0x323a0
leaq 0x19e70(%rip), %rsi     # 0x323b8
leaq 0x19e7d(%rip), %rcx     # 0x323cc
movl $0x18, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/init__test.cpp
// Function: test_bb_files()
void test_bb_files() {
    assert(bb_files[FILE_A]==
            (bb_squares[A1] | bb_squares[A2] | bb_squares[A3] | bb_squares[A4]
           | bb_squares[A5] | bb_squares[A6] | bb_squares[A7] | bb_squares[A8]));
    assert(bb_files[FILE_E]==
            (bb_squares[E1] | bb_squares[E2] | bb_squares[E3] | bb_squares[E4]
           | bb_squares[E5] | bb_squares[E6] | bb_squares[E7] | bb_squares[E8]));
    assert(bb_files[FILE_H]==
            (bb_squares[H1] | bb_squares[H2] | bb_squares[H3] | bb_squares[H4]
           | bb_squares[H5] | bb_squares[H6] | bb_squares[H7] | bb_squares[H8]));
}

// Assembly:
pushq %rax
leaq 0xe1b6a(%rip), %rax     # 0xfa430
leaq 0xe1be3(%rip), %rcx     # 0xfa4b0
movq 0x180(%rcx), %rdx
orq 0x1c0(%rcx), %rdx
orq 0x140(%rcx), %rdx
orq 0x100(%rcx), %rdx
orq 0xc0(%rcx), %rdx
orq 0x80(%rcx), %rdx
orq 0x40(%rcx), %rdx
orq (%rcx), %rdx
cmpq %rdx, (%rax)
jne 0x18975
movq 0x1a0(%rcx), %rdx
orq 0x1e0(%rcx), %rdx
orq 0x160(%rcx), %rdx
orq 0x120(%rcx), %rdx
orq 0xe0(%rcx), %rdx
orq 0xa0(%rcx), %rdx
orq 0x60(%rcx), %rdx
orq 0x20(%rcx), %rdx
cmpq %rdx, 0x20(%rax)
jne 0x18994
movq 0x1b8(%rcx), %rdx
orq 0x1f8(%rcx), %rdx
orq 0x178(%rcx), %rdx
orq 0x138(%rcx), %rdx
orq 0xf8(%rcx), %rdx
orq 0xb8(%rcx), %rdx
orq 0x78(%rcx), %rdx
orq 0x38(%rcx), %rdx
cmpq %rdx, 0x38(%rax)
jne 0x189b3
popq %rax
retq
leaq 0x19b37(%rip), %rdi     # 0x324b3
leaq 0x19a35(%rip), %rsi     # 0x323b8
leaq 0x19bc4(%rip), %rcx     # 0x3254e
movl $0x94, %edx
callq 0x20d0
leaq 0x19bc8(%rip), %rdi     # 0x32563
leaq 0x19a16(%rip), %rsi     # 0x323b8
leaq 0x19ba5(%rip), %rcx     # 0x3254e
movl $0x97, %edx
callq 0x20d0
leaq 0x19c44(%rip), %rdi     # 0x325fe
leaq 0x199f7(%rip), %rsi     # 0x323b8
leaq 0x19b86(%rip), %rcx     # 0x3254e
movl $0x9a, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/init__test.cpp
// Function: test_bb_ranks()
void test_bb_ranks() {
    assert(bb_ranks[RANK_8]==
            (bb_squares[A8] | bb_squares[B8] | bb_squares[C8] | bb_squares[D8]
           | bb_squares[E8] | bb_squares[F8] | bb_squares[G8] | bb_squares[H8]));
    assert(bb_ranks[RANK_8]==255);
    assert(bb_ranks[RANK_4]==
            (bb_squares[A4] | bb_squares[B4] | bb_squares[C4] | bb_squares[D4]
           | bb_squares[E4] | bb_squares[F4] | bb_squares[G4] | bb_squares[H4]));
    assert(bb_ranks[RANK_1]==
            (bb_squares[A1] | bb_squares[B1] | bb_squares[C1] | bb_squares[D1]
           | bb_squares[E1] | bb_squares[F1] | bb_squares[G1] | bb_squares[H1]));
}

// Assembly:
pushq %rax
leaq 0xe1a96(%rip), %rax     # 0xfa470
leaq 0xe1acf(%rip), %rcx     # 0xfa4b0
movq 0x8(%rcx), %rsi
orq (%rcx), %rsi
orq 0x10(%rcx), %rsi
orq 0x18(%rcx), %rsi
orq 0x20(%rcx), %rsi
orq 0x28(%rcx), %rsi
orq 0x30(%rcx), %rsi
movq (%rax), %rdx
orq 0x38(%rcx), %rsi
cmpq %rsi, %rdx
jne 0x18a97
cmpq $0xff, %rdx
jne 0x18ab6
movq 0x108(%rcx), %rdx
orq 0x100(%rcx), %rdx
orq 0x110(%rcx), %rdx
orq 0x118(%rcx), %rdx
orq 0x120(%rcx), %rdx
orq 0x128(%rcx), %rdx
orq 0x130(%rcx), %rdx
orq 0x138(%rcx), %rdx
cmpq %rdx, 0x20(%rax)
jne 0x18ad5
movq 0x1c8(%rcx), %rdx
orq 0x1c0(%rcx), %rdx
orq 0x1d0(%rcx), %rdx
orq 0x1d8(%rcx), %rdx
orq 0x1e0(%rcx), %rdx
orq 0x1e8(%rcx), %rdx
orq 0x1f0(%rcx), %rdx
orq 0x1f8(%rcx), %rdx
cmpq %rdx, 0x38(%rax)
jne 0x18af4
popq %rax
retq
leaq 0x19bfb(%rip), %rdi     # 0x32699
leaq 0x19913(%rip), %rsi     # 0x323b8
leaq 0x19c88(%rip), %rcx     # 0x32734
movl $0xa0, %edx
callq 0x20d0
leaq 0x19c8c(%rip), %rdi     # 0x32749
leaq 0x198f4(%rip), %rsi     # 0x323b8
leaq 0x19c69(%rip), %rcx     # 0x32734
movl $0xa1, %edx
callq 0x20d0
leaq 0x19c83(%rip), %rdi     # 0x3275f
leaq 0x198d5(%rip), %rsi     # 0x323b8
leaq 0x19c4a(%rip), %rcx     # 0x32734
movl $0xa4, %edx
callq 0x20d0
leaq 0x19cff(%rip), %rdi     # 0x327fa
leaq 0x198b6(%rip), %rsi     # 0x323b8
leaq 0x19c2b(%rip), %rcx     # 0x32734
movl $0xa7, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/init__test.cpp
// Function: test_init()
void test_init() {
    test_hamming_distance();
    test_zkeys();
    test_bb_squares();
    test_bb_files();
    test_bb_ranks();
}

// Assembly:
pushq %rax
callq 0x1855a
callq 0x18b13
callq 0x188be
popq %rax
jmp 0x189d2
nop
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/magic__test.cpp
// Function: test_bishop_moves()
void test_bishop_moves() {
    position pos;
    set_pos(&pos,"8/1r3k2/8/3bB3/8/8/8/3K4 b - - 0 1");

    uint64 bishop_moves = get_bishop_moves(&pos,E5,pos.black_pieces);
    assert(bishop_moves==0);

    bishop_moves = get_bishop_moves(&pos,D5,pos.black_pieces);
    assert(bishop_moves==(bb_squares[B7] | bb_squares[F7]));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1526a(%rip), %rsi     # 0x2de0d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq 0x1b0(%rbx), %rdx
movq %rbx, %rdi
movl $0x1c, %esi
callq 0x665c
testq %rax, %rax
jne 0x18bfc
leaq 0x8(%rsp), %rdi
movq 0x1b0(%rdi), %rdx
movl $0x1b, %esi
callq 0x665c
leaq 0xe18ca(%rip), %rcx     # 0xfa4b0
movq 0x68(%rcx), %rdx
orq 0x48(%rcx), %rdx
cmpq %rdx, %rax
jne 0x18c1b
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x19cdd(%rip), %rdi     # 0x328e0
leaq 0x19ce6(%rip), %rsi     # 0x328f0
leaq 0x19cf4(%rip), %rcx     # 0x32905
movl $0x11, %edx
callq 0x20d0
leaq 0x19cfc(%rip), %rdi     # 0x3291e
leaq 0x19cc7(%rip), %rsi     # 0x328f0
leaq 0x19cd5(%rip), %rcx     # 0x32905
movl $0x14, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/magic__test.cpp
// Function: test_rook_moves()
void test_rook_moves() {
    position pos;
    set_pos(&pos,"8/1r3k2/8/3bB3/8/8/8/3K4 b - - 0 1");

    uint64 rook_moves = get_rook_moves(&pos,B7,pos.black_pieces);
    assert(rook_moves==bb_squares[F7]);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x151c4(%rip), %rsi     # 0x2de0d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq 0x1b0(%rbx), %rdx
movq %rbx, %rdi
movl $0x9, %esi
callq 0x677c
leaq 0xe183f(%rip), %rcx     # 0xfa4b0
cmpq 0x68(%rcx), %rax
jne 0x18c80
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x19cc7(%rip), %rdi     # 0x3294e
leaq 0x19c62(%rip), %rsi     # 0x328f0
leaq 0x19cd4(%rip), %rcx     # 0x32969
movl $0x1c, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/move__test.cpp
// Function: test_to_move()
void test_to_move() {
    move mv = to_move(PAWN,E2,E4);
    assert(get_piece(mv)==PAWN);
    assert(get_from_sq(mv)==E2);
    assert(get_to_sq(mv)==E4);
    assert(!is_epcapture(mv));
    assert(!is_capture(mv));
    assert(!is_castle(mv));
    assert(get_promopiece(mv)==NO_PIECE);
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x34, %esi
movl $0x24, %edx
callq 0x76b8
movq %rax, %rbx
movq %rax, %rdi
callq 0x77c1
cmpl $0x1, %eax
jne 0x18d31
movq %rbx, %rdi
callq 0x77b0
cmpl $0x34, %eax
jne 0x18d50
movq %rbx, %rdi
callq 0x77b7
cmpl $0x24, %eax
jne 0x18d6f
movq %rbx, %rdi
callq 0x77e9
testb %al, %al
jne 0x18d8e
movq %rbx, %rdi
callq 0x77df
testb %al, %al
jne 0x18dad
movq %rbx, %rdi
callq 0x77f3
testb %al, %al
jne 0x18dcc
movq %rbx, %rdi
callq 0x77cb
testl %eax, %eax
jne 0x18deb
popq %rbx
retq
leaq 0x190fd(%rip), %rdi     # 0x31e35
leaq 0x19c41(%rip), %rsi     # 0x32980
leaq 0x19c4e(%rip), %rcx     # 0x32994
movl $0xf, %edx
callq 0x20d0
leaq 0x19c51(%rip), %rdi     # 0x329a8
leaq 0x19c22(%rip), %rsi     # 0x32980
leaq 0x19c2f(%rip), %rcx     # 0x32994
movl $0x10, %edx
callq 0x20d0
leaq 0x19c46(%rip), %rdi     # 0x329bc
leaq 0x19c03(%rip), %rsi     # 0x32980
leaq 0x19c10(%rip), %rcx     # 0x32994
movl $0x11, %edx
callq 0x20d0
leaq 0x19c39(%rip), %rdi     # 0x329ce
leaq 0x19be4(%rip), %rsi     # 0x32980
leaq 0x19bf1(%rip), %rcx     # 0x32994
movl $0x12, %edx
callq 0x20d0
leaq 0x19c2c(%rip), %rdi     # 0x329e0
leaq 0x19bc5(%rip), %rsi     # 0x32980
leaq 0x19bd2(%rip), %rcx     # 0x32994
movl $0x13, %edx
callq 0x20d0
leaq 0x19c1d(%rip), %rdi     # 0x329f0
leaq 0x19ba6(%rip), %rsi     # 0x32980
leaq 0x19bb3(%rip), %rcx     # 0x32994
movl $0x14, %edx
callq 0x20d0
leaq 0x19c0d(%rip), %rdi     # 0x329ff
leaq 0x19b87(%rip), %rsi     # 0x32980
leaq 0x19b94(%rip), %rcx     # 0x32994
movl $0x15, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/move__test.cpp
// Function: test_set_epcapture()
void test_set_epcapture() {
    move mv = to_move(PAWN,D4,C3);
    set_epcapture(&mv);
    assert(get_piece(mv)==PAWN);
    assert(get_from_sq(mv)==D4);
    assert(get_to_sq(mv)==C3);
    assert(is_epcapture(mv));
    assert(is_capture(mv));
    assert(get_captured_piece(mv)==PAWN);
    assert(!is_castle(mv));
    assert(get_promopiece(mv)==NO_PIECE);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x1, %edi
movl $0x23, %esi
movl $0x2a, %edx
callq 0x76b8
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x7797
movq (%rbx), %rdi
callq 0x77c1
cmpl $0x1, %eax
jne 0x198af
movq 0x8(%rsp), %rdi
callq 0x77b0
cmpl $0x23, %eax
jne 0x198ce
movq 0x8(%rsp), %rdi
callq 0x77b7
cmpl $0x2a, %eax
jne 0x198ed
movq 0x8(%rsp), %rdi
callq 0x77e9
testb %al, %al
je 0x1990c
movq 0x8(%rsp), %rdi
callq 0x77df
testb %al, %al
je 0x1992b
movq 0x8(%rsp), %rdi
callq 0x77d5
cmpl $0x1, %eax
jne 0x1994a
movq 0x8(%rsp), %rdi
callq 0x77f3
testb %al, %al
jne 0x19969
movq 0x8(%rsp), %rdi
callq 0x77cb
testl %eax, %eax
jne 0x19988
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1857f(%rip), %rdi     # 0x31e35
leaq 0x190c3(%rip), %rsi     # 0x32980
leaq 0x192a6(%rip), %rcx     # 0x32b6a
movl $0x62, %edx
callq 0x20d0
leaq 0x192af(%rip), %rdi     # 0x32b84
leaq 0x190a4(%rip), %rsi     # 0x32980
leaq 0x19287(%rip), %rcx     # 0x32b6a
movl $0x63, %edx
callq 0x20d0
leaq 0x192a4(%rip), %rdi     # 0x32b98
leaq 0x19085(%rip), %rsi     # 0x32980
leaq 0x19268(%rip), %rcx     # 0x32b6a
movl $0x64, %edx
callq 0x20d0
leaq 0x190bc(%rip), %rdi     # 0x329cf
leaq 0x19066(%rip), %rsi     # 0x32980
leaq 0x19249(%rip), %rcx     # 0x32b6a
movl $0x65, %edx
callq 0x20d0
leaq 0x190af(%rip), %rdi     # 0x329e1
leaq 0x19047(%rip), %rsi     # 0x32980
leaq 0x1922a(%rip), %rcx     # 0x32b6a
movl $0x66, %edx
callq 0x20d0
leaq 0x191fc(%rip), %rdi     # 0x32b4d
leaq 0x19028(%rip), %rsi     # 0x32980
leaq 0x1920b(%rip), %rcx     # 0x32b6a
movl $0x67, %edx
callq 0x20d0
leaq 0x19080(%rip), %rdi     # 0x329f0
leaq 0x19009(%rip), %rsi     # 0x32980
leaq 0x191ec(%rip), %rcx     # 0x32b6a
movl $0x68, %edx
callq 0x20d0
leaq 0x19070(%rip), %rdi     # 0x329ff
leaq 0x18fea(%rip), %rsi     # 0x32980
leaq 0x191cd(%rip), %rcx     # 0x32b6a
movl $0x69, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/move__test.cpp
// Function: test_set_castle()
void test_set_castle() {
    move mv = to_move(KING,E1,H1);
    set_castle(&mv);
    assert(get_piece(mv)==KING);
    assert(get_from_sq(mv)==E1);
    assert(get_to_sq(mv)==H1);
    assert(!is_epcapture(mv));
    assert(!is_capture(mv));
    assert(is_castle(mv));
    assert(get_promopiece(mv)==NO_PIECE);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x6, %edi
movl $0x3c, %esi
movl $0x3f, %edx
callq 0x76b8
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x77ab
movq (%rbx), %rdi
callq 0x77c1
cmpl $0x6, %eax
jne 0x19a51
movq 0x8(%rsp), %rdi
callq 0x77b0
cmpl $0x3c, %eax
jne 0x19a70
movq 0x8(%rsp), %rdi
callq 0x77b7
cmpl $0x3f, %eax
jne 0x19a8f
movq 0x8(%rsp), %rdi
callq 0x77e9
testb %al, %al
jne 0x19aae
movq 0x8(%rsp), %rdi
callq 0x77df
testb %al, %al
jne 0x19acd
movq 0x8(%rsp), %rdi
callq 0x77f3
testb %al, %al
je 0x19aec
movq 0x8(%rsp), %rdi
callq 0x77cb
testl %eax, %eax
jne 0x19b0b
addq $0x10, %rsp
popq %rbx
retq
leaq 0x19152(%rip), %rdi     # 0x32baa
leaq 0x18f21(%rip), %rsi     # 0x32980
leaq 0x19158(%rip), %rcx     # 0x32bbe
movl $0x6f, %edx
callq 0x20d0
leaq 0x1915e(%rip), %rdi     # 0x32bd5
leaq 0x18f02(%rip), %rsi     # 0x32980
leaq 0x19139(%rip), %rcx     # 0x32bbe
movl $0x70, %edx
callq 0x20d0
leaq 0x19153(%rip), %rdi     # 0x32be9
leaq 0x18ee3(%rip), %rsi     # 0x32980
leaq 0x1911a(%rip), %rcx     # 0x32bbe
movl $0x71, %edx
callq 0x20d0
leaq 0x18f19(%rip), %rdi     # 0x329ce
leaq 0x18ec4(%rip), %rsi     # 0x32980
leaq 0x190fb(%rip), %rcx     # 0x32bbe
movl $0x72, %edx
callq 0x20d0
leaq 0x18f0c(%rip), %rdi     # 0x329e0
leaq 0x18ea5(%rip), %rsi     # 0x32980
leaq 0x190dc(%rip), %rcx     # 0x32bbe
movl $0x73, %edx
callq 0x20d0
leaq 0x18efe(%rip), %rdi     # 0x329f1
leaq 0x18e86(%rip), %rsi     # 0x32980
leaq 0x190bd(%rip), %rcx     # 0x32bbe
movl $0x74, %edx
callq 0x20d0
leaq 0x18eed(%rip), %rdi     # 0x329ff
leaq 0x18e67(%rip), %rsi     # 0x32980
leaq 0x1909e(%rip), %rcx     # 0x32bbe
movl $0x75, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/move__test.cpp
// Function: test_move()
void test_move() {
    test_to_move();
    test_set_promopiece();
    test_set_capture();
    test_set_epcapture();
    test_set_castle();
    test_move_score();
}

// Assembly:
pushq %rax
callq 0x18cac
callq 0x18e0a
callq 0x194a5
callq 0x197ee
callq 0x199a7
popq %rax
jmp 0x19b2a
nop
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_knight_moves()
void test_gen_knight_moves() {
    position pos;
    reset_pos(&pos);

    move moves[10];
    move *mp = gen_knight_moves(moves,&pos,B1,true,true);
    mp = gen_knight_moves(mp,&pos,G1,true,true);

    assert((mp - moves) == 4);
    assert(is_in_move_list(to_move(KNIGHT,B1,A3),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,B1,C3),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,G1,F3),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,G1,H3),moves,mp));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa43
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x39, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x8508
movq %rax, %rdi
movq %rbx, %rsi
movl $0x3e, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x8508
movq %rax, %rbx
subq %r14, %rax
cmpq $0x20, %rax
jne 0x19e97
movl $0x2, %edi
movl $0x39, %esi
movl $0x28, %edx
callq 0x76b8
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x19eb6
movl $0x2, %edi
movl $0x39, %esi
movl $0x2a, %edx
callq 0x76b8
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x19ed5
movl $0x2, %edi
movl $0x3e, %esi
movl $0x2d, %edx
callq 0x76b8
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x19ef4
movl $0x2, %edi
movl $0x3e, %esi
movl $0x2f, %edx
callq 0x76b8
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x19f13
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
leaq 0x18e1e(%rip), %rdi     # 0x32cbc
leaq 0x18e29(%rip), %rsi     # 0x32cce
leaq 0x18e39(%rip), %rcx     # 0x32ce5
movl $0x15, %edx
callq 0x20d0
leaq 0x18e45(%rip), %rdi     # 0x32d02
leaq 0x18e0a(%rip), %rsi     # 0x32cce
leaq 0x18e1a(%rip), %rcx     # 0x32ce5
movl $0x16, %edx
callq 0x20d0
leaq 0x18e56(%rip), %rdi     # 0x32d32
leaq 0x18deb(%rip), %rsi     # 0x32cce
leaq 0x18dfb(%rip), %rcx     # 0x32ce5
movl $0x17, %edx
callq 0x20d0
leaq 0x18e67(%rip), %rdi     # 0x32d62
leaq 0x18dcc(%rip), %rsi     # 0x32cce
leaq 0x18ddc(%rip), %rcx     # 0x32ce5
movl $0x18, %edx
callq 0x20d0
leaq 0x18e78(%rip), %rdi     # 0x32d92
leaq 0x18dad(%rip), %rsi     # 0x32cce
leaq 0x18dbd(%rip), %rcx     # 0x32ce5
movl $0x19, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_knight_captures()
void test_gen_knight_captures() {
    position pos;
    set_pos(&pos,"4k3/8/3P1p2/8/4N3/8/8/4K3 w - - 0 1");

    move moves[10];
    move *mp = gen_knight_moves(moves,&pos,E4,true,false);

    assert((mp-moves)==1);
    assert(is_in_move_list(to_capture(KNIGHT,E4,F6,PAWN),moves,mp));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
leaq 0x18e7f(%rip), %rsi     # 0x32dc2
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x24, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x8508
movq %rax, %rbx
subq %r14, %rax
cmpq $0x8, %rax
jne 0x19fad
movl $0x2, %edi
movl $0x24, %esi
movl $0x15, %edx
movl $0x1, %ecx
callq 0x76d7
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x19fcc
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
leaq 0x18e32(%rip), %rdi     # 0x32de6
leaq 0x18d13(%rip), %rsi     # 0x32cce
leaq 0x18e32(%rip), %rcx     # 0x32df4
movl $0x23, %edx
callq 0x20d0
leaq 0x18e41(%rip), %rdi     # 0x32e14
leaq 0x18cf4(%rip), %rsi     # 0x32cce
leaq 0x18e13(%rip), %rcx     # 0x32df4
movl $0x24, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_knight_noncaptures()
void test_gen_knight_noncaptures() {
    position pos;
    set_pos(&pos,"4k3/8/3P1p2/8/4N3/8/8/4K3 w - - 0 1");

    move moves[10];
    move *mp = gen_knight_moves(moves,&pos,E4,false,true);

    assert((mp-moves)==6);
    assert(is_in_move_list(to_move(KNIGHT,E4,G5),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,E4,G3),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,E4,F2),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,E4,D2),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,E4,C3),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,E4,C5),moves,mp));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
leaq 0x18dc6(%rip), %rsi     # 0x32dc2
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x24, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x8508
movq %rax, %rbx
subq %r14, %rax
cmpq $0x30, %rax
jne 0x1a13b
movl $0x2, %edi
movl $0x24, %esi
movl $0x1e, %edx
callq 0x76b8
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x1a15a
movl $0x2, %edi
movl $0x24, %esi
movl $0x2e, %edx
callq 0x76b8
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x1a179
movl $0x2, %edi
movl $0x24, %esi
movl $0x35, %edx
callq 0x76b8
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x1a198
movl $0x2, %edi
movl $0x24, %esi
movl $0x33, %edx
callq 0x76b8
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x1a1b7
movl $0x2, %edi
movl $0x24, %esi
movl $0x2a, %edx
callq 0x76b8
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x1a1d6
movl $0x2, %edi
movl $0x24, %esi
movl $0x1a, %edx
callq 0x76b8
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x1a1f5
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
leaq 0x18d0a(%rip), %rdi     # 0x32e4c
leaq 0x18b85(%rip), %rsi     # 0x32cce
leaq 0x18d0a(%rip), %rcx     # 0x32e5a
movl $0x2e, %edx
callq 0x20d0
leaq 0x18d1c(%rip), %rdi     # 0x32e7d
leaq 0x18b66(%rip), %rsi     # 0x32cce
leaq 0x18ceb(%rip), %rcx     # 0x32e5a
movl $0x2f, %edx
callq 0x20d0
leaq 0x18d2d(%rip), %rdi     # 0x32ead
leaq 0x18b47(%rip), %rsi     # 0x32cce
leaq 0x18ccc(%rip), %rcx     # 0x32e5a
movl $0x30, %edx
callq 0x20d0
leaq 0x18d3e(%rip), %rdi     # 0x32edd
leaq 0x18b28(%rip), %rsi     # 0x32cce
leaq 0x18cad(%rip), %rcx     # 0x32e5a
movl $0x31, %edx
callq 0x20d0
leaq 0x18d4f(%rip), %rdi     # 0x32f0d
leaq 0x18b09(%rip), %rsi     # 0x32cce
leaq 0x18c8e(%rip), %rcx     # 0x32e5a
movl $0x32, %edx
callq 0x20d0
leaq 0x18d60(%rip), %rdi     # 0x32f3d
leaq 0x18aea(%rip), %rsi     # 0x32cce
leaq 0x18c6f(%rip), %rcx     # 0x32e5a
movl $0x33, %edx
callq 0x20d0
leaq 0x18d71(%rip), %rdi     # 0x32f6d
leaq 0x18acb(%rip), %rsi     # 0x32cce
leaq 0x18c50(%rip), %rcx     # 0x32e5a
movl $0x34, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_bishop_captures()
void test_gen_bishop_captures() {
    position pos;
    set_pos(&pos,"4k3/2p3P1/8/4B3/4B3/3p1P2/8/4K3 w - - 0 1");

    move moves[20];
    move *mp = gen_bishop_moves(moves,&pos,E5,true,false);
    mp = gen_bishop_moves(mp,&pos,E4,true,false);

    assert((mp - moves) == 2);
    assert(is_in_move_list(to_capture(BISHOP,E5,C7,PAWN),moves,mp));
    assert(is_in_move_list(to_capture(BISHOP,E4,D3,PAWN),moves,mp));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
leaq 0x187b9(%rip), %rsi     # 0x32f9d
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1c, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x865d
movq %rax, %rdi
movq %rbx, %rsi
movl $0x24, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x865d
movq %rax, %rbx
subq %r14, %rax
cmpq $0x10, %rax
jne 0x1a894
movl $0x3, %edi
movl $0x1c, %esi
movl $0xa, %edx
movl $0x1, %ecx
callq 0x76d7
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x1a8b3
movl $0x3, %edi
movl $0x24, %esi
movl $0x2b, %edx
movl $0x1, %ecx
callq 0x76d7
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x1a8d2
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r14
retq
leaq 0x18acc(%rip), %rdi     # 0x33367
leaq 0x1842c(%rip), %rsi     # 0x32cce
leaq 0x18ad0(%rip), %rcx     # 0x33379
movl $0x5c, %edx
callq 0x20d0
leaq 0x188ed(%rip), %rdi     # 0x331a7
leaq 0x1840d(%rip), %rsi     # 0x32cce
leaq 0x18ab1(%rip), %rcx     # 0x33379
movl $0x5d, %edx
callq 0x20d0
leaq 0x18996(%rip), %rdi     # 0x3326f
leaq 0x183ee(%rip), %rsi     # 0x32cce
leaq 0x18a92(%rip), %rcx     # 0x33379
movl $0x5e, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_rook_captures()
void test_gen_rook_captures() {
    position pos;
    reset_pos(&pos);

    move moves[20];
    move *mp = gen_rook_moves(moves,&pos,H1,true,false);
    assert((mp - moves) == 0);

    set_pos(&pos,"8/8/3k1p2/8/3K4/8/1R3r2/8 b - - 0 1");

    mp = gen_rook_moves(moves,&pos,F2,true,false);
    assert((mp - moves) == 1);

    assert(is_in_move_list(to_capture(ROOK,F2,B2,ROOK),moves,mp));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
callq 0xaa43
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3f, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x8780
cmpq %rbx, %rax
jne 0x1b264
leaq 0x18202(%rip), %rsi     # 0x333fc
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
callq 0xaa74
movq %rbx, %rdi
movq %r14, %rsi
movl $0x35, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x8780
movq %rax, %r14
subq %rbx, %rax
cmpq $0x8, %rax
jne 0x1b283
movl $0x4, %edi
movl $0x35, %esi
movl $0x31, %edx
movl $0x4, %ecx
callq 0x76d7
movq %rsp, %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0xe727
testb %al, %al
je 0x1b2a2
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r14
retq
leaq 0x18164(%rip), %rdi     # 0x333cf
leaq 0x17a5c(%rip), %rsi     # 0x32cce
leaq 0x1838e(%rip), %rcx     # 0x33607
movl $0x9b, %edx
callq 0x20d0
leaq 0x1839b(%rip), %rdi     # 0x33625
leaq 0x17a3d(%rip), %rsi     # 0x32cce
leaq 0x1836f(%rip), %rcx     # 0x33607
movl $0xa0, %edx
callq 0x20d0
leaq 0x18328(%rip), %rdi     # 0x335d1
leaq 0x17a1e(%rip), %rsi     # 0x32cce
leaq 0x18350(%rip), %rcx     # 0x33607
movl $0xa2, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_queen_captures()
void test_gen_queen_captures() {
    position pos;
    set_pos(&pos,"8/8/3bk3/8/8/2K3Q1/8/8 w - - 0 1");

    move moves[20];
    move *mp = gen_queen_moves(moves,&pos,G3,true,false);

    assert((mp - moves) == 1);
    assert(is_in_move_list(to_capture(QUEEN,G3,D6,BISHOP),moves,mp));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
leaq 0x17a9f(%rip), %rsi     # 0x3366a
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2e, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x88a3
movq %rax, %rbx
subq %r14, %rax
cmpq $0x8, %rax
jne 0x1bc38
movl $0x5, %edi
movl $0x2e, %esi
movl $0x13, %edx
movl $0x3, %ecx
callq 0x76d7
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x1bc57
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r14
retq
leaq 0x179e6(%rip), %rdi     # 0x33625
leaq 0x17088(%rip), %rsi     # 0x32cce
leaq 0x17db2(%rip), %rcx     # 0x339ff
movl $0xe0, %edx
callq 0x20d0
leaq 0x17d68(%rip), %rdi     # 0x339c6
leaq 0x17069(%rip), %rsi     # 0x32cce
leaq 0x17d93(%rip), %rcx     # 0x339ff
movl $0xe1, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_king_captures()
void test_gen_king_captures() {
    position pos;

    set_pos(&pos,"8/8/3k4/2n1P3/8/8/3rP3/R3K2R b KQ - 0 1");
    move moves[20];
    move *mp = gen_king_moves(moves,&pos,true,false);
    assert((mp - moves) == 1);
    assert(is_in_move_list(to_capture(KING,D6,E5,PAWN),moves,mp));

    // flip sides
    set_pos(&pos,"8/8/3k4/2n1P3/8/8/3rP3/RN2K2R w KQ - 0 1");
    mp = gen_king_moves(moves,&pos,true,false);
    assert((mp - moves)==1);
    assert(is_in_move_list(to_capture(KING,E1,D2,ROOK),moves,mp));

    // cannot castle if king will passed through attacked square
    set_pos(&pos,"r3k2r/8/8/8/8/5Q2/8/4K3 b kq - 0 1");
    mp = gen_king_moves(moves,&pos,true,false);
    assert((mp - moves)==0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
leaq 0x16dd9(%rip), %rsi     # 0x33a53
leaq 0xa8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x8018
movq %rax, %r14
subq %r15, %rax
cmpq $0x8, %rax
jne 0x1cd8b
movl $0x6, %edi
movl $0x13, %esi
movl $0x1c, %edx
movl $0x1, %ecx
callq 0x76d7
movq %rsp, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xe727
testb %al, %al
je 0x1cdaa
leaq 0x12107(%rip), %rsi     # 0x2edef
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
callq 0xaa74
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x8018
movq %rax, %r14
subq %rbx, %rax
cmpq $0x8, %rax
jne 0x1cdc9
movl $0x6, %edi
movl $0x3c, %esi
movl $0x33, %edx
movl $0x4, %ecx
callq 0x76d7
movq %rsp, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xe727
testb %al, %al
je 0x1cde8
leaq 0x120fc(%rip), %rsi     # 0x2ee4f
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
callq 0xaa74
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x8018
cmpq %rbx, %rax
jne 0x1ce07
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r14
popq %r15
retq
leaq 0x16893(%rip), %rdi     # 0x33625
leaq 0x15f35(%rip), %rsi     # 0x32cce
leaq 0x171f7(%rip), %rcx     # 0x33f97
movl $0x148, %edx            # imm = 0x148
callq 0x20d0
leaq 0x16d81(%rip), %rdi     # 0x33b32
leaq 0x15f16(%rip), %rsi     # 0x32cce
leaq 0x171d8(%rip), %rcx     # 0x33f97
movl $0x149, %edx            # imm = 0x149
callq 0x20d0
leaq 0x171e5(%rip), %rdi     # 0x33fb5
leaq 0x15ef7(%rip), %rsi     # 0x32cce
leaq 0x171b9(%rip), %rcx     # 0x33f97
movl $0x14e, %edx            # imm = 0x14E
callq 0x20d0
leaq 0x16e9d(%rip), %rdi     # 0x33c8c
leaq 0x15ed8(%rip), %rsi     # 0x32cce
leaq 0x1719a(%rip), %rcx     # 0x33f97
movl $0x14f, %edx            # imm = 0x14F
callq 0x20d0
leaq 0x171b7(%rip), %rdi     # 0x33fc5
leaq 0x15eb9(%rip), %rsi     # 0x32cce
leaq 0x1717b(%rip), %rcx     # 0x33f97
movl $0x154, %edx            # imm = 0x154
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_pawn_noncaps()
void test_gen_pawn_noncaps() {
    position pos;
    set_pos(&pos,"2b1k3/PP6/8/3pP3/4P3/8/6P1/4K3 w - d6 0 1");
    move moves[20],*mp;

    mp = gen_pawn_moves(moves,&pos,false,true);

    assert((mp - moves)==3);
    assert(is_in_move_list(to_move(PAWN,G2,G3),moves,mp));
    assert(is_in_move_list(to_move(PAWN,G2,G4),moves,mp));
    assert(is_in_move_list(to_move(PAWN,E5,E6),moves,mp));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
leaq 0x1622c(%rip), %rsi     # 0x34008
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x792f
movq %rax, %rbx
subq %r14, %rax
cmpq $0x18, %rax
jne 0x1de8a
movl $0x1, %edi
movl $0x36, %esi
movl $0x2e, %edx
callq 0x76b8
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x1dea9
movl $0x1, %edi
movl $0x36, %esi
movl $0x26, %edx
callq 0x76b8
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x1dec8
movl $0x1, %edi
movl $0x1c, %esi
movl $0x14, %edx
callq 0x76b8
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x1dee7
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r14
retq
leaq 0x15e6a(%rip), %rdi     # 0x33cfb
leaq 0x14e36(%rip), %rsi     # 0x32cce
leaq 0x162e5(%rip), %rcx     # 0x34184
movl $0x1e7, %edx            # imm = 0x1E7
callq 0x20d0
leaq 0x161ae(%rip), %rdi     # 0x3405e
leaq 0x14e17(%rip), %rsi     # 0x32cce
leaq 0x162c6(%rip), %rcx     # 0x34184
movl $0x1e8, %edx            # imm = 0x1E8
callq 0x20d0
leaq 0x161bd(%rip), %rdi     # 0x3408c
leaq 0x14df8(%rip), %rsi     # 0x32cce
leaq 0x162a7(%rip), %rcx     # 0x34184
movl $0x1e9, %edx            # imm = 0x1E9
callq 0x20d0
leaq 0x161cc(%rip), %rdi     # 0x340ba
leaq 0x14dd9(%rip), %rsi     # 0x32cce
leaq 0x16288(%rip), %rcx     # 0x34184
movl $0x1ea, %edx            # imm = 0x1EA
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_moves()
void test_gen_moves() {
    position pos;
    reset_pos(&pos);
    move moves[50],*mp;

    mp = gen_moves(moves,&pos,true,true);
    assert((mp-moves)==20);

    set_pos(&pos,"rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1");
    mp = gen_moves(moves,&pos,true,true);
    assert((mp-moves)==20);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x368, %rsp            # imm = 0x368
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaa43
leaq 0x1d0(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78d0
subq %rbx, %rax
cmpq $0xa0, %rax
jne 0x1df84
leaq 0xf527(%rip), %rsi      # 0x2d473
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaa74
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78d0
subq %rbx, %rax
cmpq $0xa0, %rax
jne 0x1dfa3
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %r14
retq
leaq 0x16216(%rip), %rdi     # 0x341a1
leaq 0x14d3c(%rip), %rsi     # 0x32cce
leaq 0x16217(%rip), %rcx     # 0x341b0
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x20d0
leaq 0x161f7(%rip), %rdi     # 0x341a1
leaq 0x14d1d(%rip), %rsi     # 0x32cce
leaq 0x161f8(%rip), %rcx     # 0x341b0
movl $0x1f8, %edx            # imm = 0x1F8
callq 0x20d0