LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/evalp__test.cpp
// Function: test_doubled()
void test_doubled() {
    position pos;
    set_pos(&pos,"k7/p1p3p1/3p3p/1P5P/1PP1P1P1/8/8/K7 w - - 0 1");

    assert(!is_passed(&pos,B5,true));
    assert(is_doubled(&pos,B5,true));
    assert(!is_isolated(&pos,B5,true));

    assert(!is_passed(&pos,B4,true));
    assert(is_doubled(&pos,B4,true));
    assert(!is_isolated(&pos,B4,true));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1cf65(%rip), %rsi     # 0x314d4
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
movl $0x19, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
jne 0x1462b
leaq 0x8(%rsp), %rdi
movl $0x19, %esi
movl $0x1, %edx
callq 0x5cf8
testb %al, %al
je 0x1464a
leaq 0x8(%rsp), %rdi
movl $0x19, %esi
movl $0x1, %edx
callq 0x5d76
testb %al, %al
jne 0x14669
leaq 0x8(%rsp), %rdi
movl $0x21, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
jne 0x14688
leaq 0x8(%rsp), %rdi
movl $0x21, %esi
movl $0x1, %edx
callq 0x5cf8
testb %al, %al
je 0x146a7
leaq 0x8(%rsp), %rdi
movl $0x21, %esi
movl $0x1, %edx
callq 0x5d76
testb %al, %al
jne 0x146c6
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1ced0(%rip), %rdi     # 0x31502
leaq 0x1c751(%rip), %rsi     # 0x30d8a
leaq 0x1cedb(%rip), %rcx     # 0x3151b
movl $0x8d, %edx
callq 0x20d0
leaq 0x1cede(%rip), %rdi     # 0x3152f
leaq 0x1c732(%rip), %rsi     # 0x30d8a
leaq 0x1cebc(%rip), %rcx     # 0x3151b
movl $0x8e, %edx
callq 0x20d0
leaq 0x1ced8(%rip), %rdi     # 0x31548
leaq 0x1c713(%rip), %rsi     # 0x30d8a
leaq 0x1ce9d(%rip), %rcx     # 0x3151b
movl $0x8f, %edx
callq 0x20d0
leaq 0x1ced4(%rip), %rdi     # 0x31563
leaq 0x1c6f4(%rip), %rsi     # 0x30d8a
leaq 0x1ce7e(%rip), %rcx     # 0x3151b
movl $0x91, %edx
callq 0x20d0
leaq 0x1cece(%rip), %rdi     # 0x3157c
leaq 0x1c6d5(%rip), %rsi     # 0x30d8a
leaq 0x1ce5f(%rip), %rcx     # 0x3151b
movl $0x92, %edx
callq 0x20d0
leaq 0x1cec8(%rip), %rdi     # 0x31595
leaq 0x1c6b6(%rip), %rsi     # 0x30d8a
leaq 0x1ce40(%rip), %rcx     # 0x3151b
movl $0x93, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/evalp__test.cpp
// Function: test_evalp()
void test_evalp() {
    test_passed_pawn_initial_pos();
    test_passed_pawn_wiki_pos();
    test_passed_pawn_wiki_pos2();
    test_passed_pawn_wiki_pos3();
    test_passed_pawn_wiki_pos4();
    test_levinfish_smyslov57();
    test_fischer_larsen71();
    test_botvinnik_capablanca38();
    test_isolated_pawn();
    test_doubled();
}

// Assembly:
pushq %rax
callq 0x13660
callq 0x13740
callq 0x1396d
callq 0x13ae9
callq 0x13c68
callq 0x13cf9
callq 0x13eb0
callq 0x1402c
callq 0x1428b
popq %rax
jmp 0x14560
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_no_extension()
void test_no_extension() {
    position pos;
    reset_pos(&pos);

    move e2e4 = to_move(PAWN,E2,E4);
    apply_move(&pos,e2e4,gundos);

    assert(0==extend(&pos,e2e4,false));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xaa51
movl $0x1, %edi
movl $0x34, %esi
movl $0x24, %edx
callq 0x775c
movq %rax, %r14
leaq 0xb43a1(%rip), %rdx     # 0xc8af0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x30e1
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5e8c
testl %eax, %eax
jne 0x14776
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x1ce33(%rip), %rdi     # 0x315b0
leaq 0x1ce47(%rip), %rsi     # 0x315cb
leaq 0x1ce56(%rip), %rcx     # 0x315e1
movl $0x15, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_extend_promotion()
void test_extend_promotion() {
    position pos;
    set_pos(&pos,"k7/b1P5/KP6/6q1/8/8/8/4n3 w - -");

    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

    move c7c8q = to_move(PAWN,C7,C8);
    set_promopiece(&c7c8q,QUEEN);

    assert(is_in_move_list(c7c8q,moves,endp));

    apply_move(&pos,c7c8q,gundos);

    assert(1==extend(&pos,c7c8q,true));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1ce52(%rip), %rsi     # 0x315fa
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rax, %rbx
movl $0x1, %edi
movl $0xa, %esi
movl $0x2, %edx
callq 0x775c
movq %rsp, %r15
movq %rax, (%r15)
movq %r15, %rdi
movl $0x5, %esi
callq 0x7824
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x14849
movq (%rsp), %rsi
leaq 0xb42d7(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x30e1
movq (%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x5e8c
cmpl $0x1, %eax
jne 0x14868
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cdca(%rip), %rdi     # 0x3161a
leaq 0x1cd74(%rip), %rsi     # 0x315cb
leaq 0x1cdde(%rip), %rcx     # 0x3163c
movl $0x22, %edx
callq 0x20d0
leaq 0x1cdea(%rip), %rdi     # 0x31659
leaq 0x1cd55(%rip), %rsi     # 0x315cb
leaq 0x1cdbf(%rip), %rcx     # 0x3163c
movl $0x26, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_white_push_to_7th()
void test_white_push_to_7th() {
    position pos;
    set_pos(&pos,"k7/b1P5/KP6/6q1/8/8/8/4n3 w - -");

    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

    move b6b7 = to_move(PAWN,B6,B7);

    assert(is_in_move_list(b6b7,moves,endp));

    apply_move(&pos,b6b7,gundos);
    assert(1==extend(&pos,b6b7,true));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1cd60(%rip), %rsi     # 0x315fa
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rax, %r15
movl $0x1, %edi
movl $0x11, %esi
movl $0x9, %edx
callq 0x775c
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe682
testb %al, %al
je 0x14929
leaq 0xb41f9(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x5e8c
cmpl $0x1, %eax
jne 0x14948
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cd44(%rip), %rdi     # 0x31674
leaq 0x1cc94(%rip), %rsi     # 0x315cb
leaq 0x1cd57(%rip), %rcx     # 0x31695
movl $0x32, %edx
callq 0x20d0
leaq 0x1cd64(%rip), %rdi     # 0x316b3
leaq 0x1cc75(%rip), %rsi     # 0x315cb
leaq 0x1cd38(%rip), %rcx     # 0x31695
movl $0x35, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_passed_pawn()
void test_passed_pawn() {
    position pos;
    set_pos(&pos,"8/5ppp/8/5PPP/8/6k1/8/6K1 b - -");

    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

    move g7g6 = to_move(PAWN,G7,G6);

    assert(is_in_move_list(g7g6,moves,endp));

    apply_move(&pos,g7g6,gundos);
    assert(0==extend(&pos,g7g6,false));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1cd53(%rip), %rsi     # 0x316cd
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rax, %r15
movl $0x1, %edi
movl $0xe, %esi
movl $0x16, %edx
callq 0x775c
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe682
testb %al, %al
je 0x14a05
leaq 0xb4119(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5e8c
testl %eax, %eax
jne 0x14a24
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cce1(%rip), %rdi     # 0x316ed
leaq 0x1cbb8(%rip), %rsi     # 0x315cb
leaq 0x1ccf4(%rip), %rcx     # 0x3170e
movl $0x41, %edx
callq 0x20d0
leaq 0x1ccfb(%rip), %rdi     # 0x31726
leaq 0x1cb99(%rip), %rsi     # 0x315cb
leaq 0x1ccd5(%rip), %rcx     # 0x3170e
movl $0x44, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_passed_pawn2()
void test_passed_pawn2() {
    position pos;
    set_pos(&pos,"8/8/1PP2PbP/3r4/8/1Q5p/p5N1/k3K3 b - -");

    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

    move d5d4 = to_move(ROOK,D5,D4);

    assert(is_in_move_list(d5d4,moves,endp));
    apply_move(&pos,d5d4,gundos);
    assert(0==extend(&pos,d5d4,false));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1c5a0(%rip), %rsi     # 0x30ff6
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rax, %r15
movl $0x4, %edi
movl $0x1b, %esi
movl $0x23, %edx
callq 0x775c
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe682
testb %al, %al
je 0x14ae1
leaq 0xb403d(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5e8c
testl %eax, %eax
jne 0x14b00
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cc59(%rip), %rdi     # 0x31741
leaq 0x1cadc(%rip), %rsi     # 0x315cb
leaq 0x1cc6c(%rip), %rcx     # 0x31762
movl $0x50, %edx
callq 0x20d0
leaq 0x1cc74(%rip), %rdi     # 0x3177b
leaq 0x1cabd(%rip), %rsi     # 0x315cb
leaq 0x1cc4d(%rip), %rcx     # 0x31762
movl $0x52, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_black_push_to_2nd()
void test_black_push_to_2nd() {
    position pos;
    set_pos(&pos,"8/8/1PP2PbP/3r4/8/1Q5p/p5N1/k3K3 b - -");

    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

    move h3h2 = to_move(PAWN,H3,H2);

    assert(is_in_move_list(h3h2,moves,endp));
    apply_move(&pos,h3h2,gundos);
    assert(1==extend(&pos,h3h2,false));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1c4c4(%rip), %rsi     # 0x30ff6
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rax, %r15
movl $0x1, %edi
movl $0x2f, %esi
movl $0x37, %edx
callq 0x775c
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe682
testb %al, %al
je 0x14bbe
leaq 0xb3f61(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5e8c
cmpl $0x1, %eax
jne 0x14bdd
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cbd1(%rip), %rdi     # 0x31796
leaq 0x1c9ff(%rip), %rsi     # 0x315cb
leaq 0x1cbe4(%rip), %rcx     # 0x317b7
movl $0x5e, %edx
callq 0x20d0
leaq 0x1cbf1(%rip), %rdi     # 0x317d5
leaq 0x1c9e0(%rip), %rsi     # 0x315cb
leaq 0x1cbc5(%rip), %rcx     # 0x317b7
movl $0x60, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_passed_pawn3()
void test_passed_pawn3() {
    // Fischer-Larsen 71
    position pos;
    set_pos(&pos,"8/4kp2/6p1/7p/P7/2K3P1/7P/8 w - -");

    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

    move a4a5 = to_move(PAWN,A4,A5);

    assert(is_in_move_list(a4a5,moves,endp));
    apply_move(&pos,a4a5,gundos);
    assert(0==extend(&pos,a4a5,false));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1cbe1(%rip), %rsi     # 0x317f0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rax, %r15
movl $0x1, %edi
movl $0x20, %esi
movl $0x18, %edx
callq 0x775c
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe682
testb %al, %al
je 0x14c9a
leaq 0xb3e84(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5e8c
testl %eax, %eax
jne 0x14cb9
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cb71(%rip), %rdi     # 0x31812
leaq 0x1c923(%rip), %rsi     # 0x315cb
leaq 0x1cb84(%rip), %rcx     # 0x31833
movl $0x6d, %edx
callq 0x20d0
leaq 0x1cb8c(%rip), %rdi     # 0x3184c
leaq 0x1c904(%rip), %rsi     # 0x315cb
leaq 0x1cb65(%rip), %rcx     # 0x31833
movl $0x6f, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_passed_pawn4()
void test_passed_pawn4() {
    position pos;
    set_pos(&pos,"8/4kp2/6p1/7p/P7/2K3P1/7P/8 b - -");

    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

    move f7f6 = to_move(PAWN,F7,F6);

    assert(is_in_move_list(f7f6,moves,endp));
    apply_move(&pos,f7f6,gundos);
    assert(0==extend(&pos,f7f6,false));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1c505(%rip), %rsi     # 0x311f0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rax, %r15
movl $0x1, %edi
movl $0xd, %esi
movl $0x15, %edx
callq 0x775c
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe682
testb %al, %al
je 0x14d76
leaq 0xb3da8(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5e8c
testl %eax, %eax
jne 0x14d95
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1caea(%rip), %rdi     # 0x31867
leaq 0x1c847(%rip), %rsi     # 0x315cb
leaq 0x1cafd(%rip), %rcx     # 0x31888
movl $0x7b, %edx
callq 0x20d0
leaq 0x1cb05(%rip), %rdi     # 0x318a1
leaq 0x1c828(%rip), %rsi     # 0x315cb
leaq 0x1cade(%rip), %rcx     # 0x31888
movl $0x7d, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_passed_pawn5()
void test_passed_pawn5() {
    position pos;
    set_pos(&pos,"8/p3q1kp/1p2Pnp1/3pQ3/2pP4/1nP3N1/1B4PP/6K1 b - -");
    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

    move a7a6 = to_move(PAWN,A7,A6);

    assert(is_in_move_list(a7a6,moves,endp));
    apply_move(&pos,a7a6,gundos);
    assert(0==extend(&pos,a7a6,false));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1caf5(%rip), %rsi     # 0x318bc
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rax, %r15
movl $0x1, %edi
movl $0x8, %esi
movl $0x10, %edx
callq 0x775c
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe682
testb %al, %al
je 0x14e52
leaq 0xb3ccc(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5e8c
testl %eax, %eax
jne 0x14e71
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1ca95(%rip), %rdi     # 0x318ee
leaq 0x1c76b(%rip), %rsi     # 0x315cb
leaq 0x1caa8(%rip), %rcx     # 0x3190f
movl $0x89, %edx
callq 0x20d0
leaq 0x1cab0(%rip), %rdi     # 0x31928
leaq 0x1c74c(%rip), %rsi     # 0x315cb
leaq 0x1ca89(%rip), %rcx     # 0x3190f
movl $0x8b, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_passed_pawn6()
void test_passed_pawn6() {
    position pos;
    set_pos(&pos,"8/p3q1kp/1p2Pnp1/3pQ3/2pP4/1nP3N1/1B4PP/6K1 b - -");
    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

    move b6b5 = to_move(PAWN,B6,B5);

    assert(is_in_move_list(b6b5,moves,endp));
    apply_move(&pos,b6b5,gundos);
    assert(0==extend(&pos,b6b5,false));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1ca19(%rip), %rsi     # 0x318bc
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rax, %r15
movl $0x1, %edi
movl $0x11, %esi
movl $0x19, %edx
callq 0x775c
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe682
testb %al, %al
je 0x14f2e
leaq 0xb3bf0(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5e8c
testl %eax, %eax
jne 0x14f4d
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1ca0e(%rip), %rdi     # 0x31943
leaq 0x1c68f(%rip), %rsi     # 0x315cb
leaq 0x1ca21(%rip), %rcx     # 0x31964
movl $0x96, %edx
callq 0x20d0
leaq 0x1ca29(%rip), %rdi     # 0x3197d
leaq 0x1c670(%rip), %rsi     # 0x315cb
leaq 0x1ca02(%rip), %rcx     # 0x31964
movl $0x98, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_newly_created_passed_pawn()
void test_newly_created_passed_pawn() {
    position pos;
    set_pos(&pos,"7k/8/6p1/4p3/5P2/8/8/7K w - -");

    move f4e5 = to_capture(PAWN,F4,E5,PAWN);

    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

    assert(is_in_move_list(f4e5,moves,endp));
    apply_move(&pos,f4e5,gundos);

    assert(0==extend(&pos,f4e5,false));
    undo_last_move(&pos,gundos);

    move f4f5 = to_move(PAWN,F4,F5);
    assert(is_in_move_list(f4f5,moves,endp));
    apply_move(&pos,f4f5,gundos);

    assert(0==extend(&pos,f4f5,false));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1ca19(%rip), %rsi     # 0x31998
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movl $0x1, %edi
movl $0x25, %esi
movl $0x1c, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %r14
leaq 0x1d0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe682
testb %al, %al
je 0x1507e
leaq 0xb3b0b(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x30e1
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5e8c
testl %eax, %eax
jne 0x1509d
leaq 0xb3adf(%rip), %rsi     # 0xc8af0
leaq 0x8(%rsp), %rdi
callq 0x334b
movl $0x1, %edi
movl $0x25, %esi
movl $0x1d, %edx
callq 0x775c
movq %rax, %r14
leaq 0x1d0(%rsp), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x150bc
leaq 0xb3aa0(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30e1
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5e8c
testl %eax, %eax
jne 0x150db
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1c931(%rip), %rdi     # 0x319b6
leaq 0x1c53f(%rip), %rsi     # 0x315cb
leaq 0x1c944(%rip), %rcx     # 0x319d7
movl $0xa4, %edx
callq 0x20d0
leaq 0x1c959(%rip), %rdi     # 0x319fd
leaq 0x1c520(%rip), %rsi     # 0x315cb
leaq 0x1c925(%rip), %rcx     # 0x319d7
movl $0xa7, %edx
callq 0x20d0
leaq 0x1c955(%rip), %rdi     # 0x31a18
leaq 0x1c501(%rip), %rsi     # 0x315cb
leaq 0x1c906(%rip), %rcx     # 0x319d7
movl $0xab, %edx
callq 0x20d0
leaq 0x1c957(%rip), %rdi     # 0x31a39
leaq 0x1c4e2(%rip), %rsi     # 0x315cb
leaq 0x1c8e7(%rip), %rcx     # 0x319d7
movl $0xae, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_recapture()
void test_recapture() {
    position pos;
    set_pos(&pos,"7k/8/8/3r4/3R4/3r4/8/6K1 w - -");

    move d4d5 = to_capture(ROOK,D4,D5,ROOK);

    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

    assert(is_in_move_list(d4d5,moves,endp));
    apply_move(&pos,d4d5,gundos);

    move d3d5 = to_capture(ROOK,D3,D5,ROOK);

    move moves2[MAX_MOVES_PER_PLY];
    move *endp2 = gen_legal_moves(moves2,&pos,true,true);
    assert(is_in_move_list(d3d5,moves2,endp2));

    assert(1==extend(&pos,d4d5,false));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1498, %rsp           # imm = 0x1498
leaq 0x1c945(%rip), %rsi     # 0x31a54
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaa82
movl $0x4, %edi
movl $0x23, %esi
movl $0x1b, %edx
movl $0x4, %ecx
callq 0x777b
movq %rax, %rbx
leaq 0xb30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe682
testb %al, %al
je 0x151f0
leaq 0xb397e(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movl $0x4, %edi
movl $0x2b, %esi
movl $0x1b, %edx
movl $0x4, %ecx
callq 0x777b
movq %rax, %r15
leaq 0x1d0(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xe682
testb %al, %al
je 0x1520f
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5e8c
cmpl $0x1, %eax
jne 0x1522e
addq $0x1498, %rsp           # imm = 0x1498
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1c87c(%rip), %rdi     # 0x31a73
leaq 0x1c3cd(%rip), %rsi     # 0x315cb
leaq 0x1c88f(%rip), %rcx     # 0x31a94
movl $0xba, %edx
callq 0x20d0
leaq 0x1c894(%rip), %rdi     # 0x31aaa
leaq 0x1c3ae(%rip), %rsi     # 0x315cb
leaq 0x1c870(%rip), %rcx     # 0x31a94
movl $0xc1, %edx
callq 0x20d0
leaq 0x1c898(%rip), %rdi     # 0x31acd
leaq 0x1c38f(%rip), %rsi     # 0x315cb
leaq 0x1c851(%rip), %rcx     # 0x31a94
movl $0xc3, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_recapture2()
void test_recapture2() {
    position pos;
    set_pos(&pos,"7k/8/8/3r4/3R4/3q4/8/6K1 w - -");

    move d4d5 = to_capture(ROOK,D4,D5,ROOK);

    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

    assert(is_in_move_list(d4d5,moves,endp));
    apply_move(&pos,d4d5,gundos);

    move d3d5 = to_capture(QUEEN,D3,D5,ROOK);

    move moves2[MAX_MOVES_PER_PLY];
    move *endp2 = gen_legal_moves(moves2,&pos,true,true);
    assert(is_in_move_list(d3d5,moves2,endp2));

    assert(1==extend(&pos,d3d5,false));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1490, %rsp           # imm = 0x1490
leaq 0x1c888(%rip), %rsi     # 0x31ae8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaa82
movl $0x4, %edi
movl $0x23, %esi
movl $0x1b, %edx
movl $0x4, %ecx
callq 0x777b
movq %rax, %rbx
leaq 0xb30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe682
testb %al, %al
je 0x1533f
leaq 0xb382d(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movl $0x5, %edi
movl $0x2b, %esi
movl $0x1b, %edx
movl $0x4, %ecx
callq 0x777b
movq %rax, %rbx
leaq 0x1d0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe682
testb %al, %al
je 0x1535e
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5e8c
cmpl $0x1, %eax
jne 0x1537d
addq $0x1490, %rsp           # imm = 0x1490
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1c72d(%rip), %rdi     # 0x31a73
leaq 0x1c27e(%rip), %rsi     # 0x315cb
leaq 0x1c7b3(%rip), %rcx     # 0x31b07
movl $0xcf, %edx
callq 0x20d0
leaq 0x1c745(%rip), %rdi     # 0x31aaa
leaq 0x1c25f(%rip), %rsi     # 0x315cb
leaq 0x1c794(%rip), %rcx     # 0x31b07
movl $0xd6, %edx
callq 0x20d0
leaq 0x1c79a(%rip), %rdi     # 0x31b1e
leaq 0x1c240(%rip), %rsi     # 0x315cb
leaq 0x1c775(%rip), %rcx     # 0x31b07
movl $0xd8, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_recapture3()
void test_recapture3() {
    position pos;
    set_pos(&pos,"7k/8/8/3b4/3R4/3q4/8/6K1 w - -");

    move d4d5 = to_capture(ROOK,D4,D5,BISHOP);

    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

    assert(is_in_move_list(d4d5,moves,endp));
    apply_move(&pos,d4d5,gundos);

    move d3d5 = to_capture(QUEEN,D3,D5,ROOK);

    move moves2[MAX_MOVES_PER_PLY];
    move *endp2 = gen_legal_moves(moves2,&pos,true,true);
    assert(is_in_move_list(d3d5,moves2,endp2));

    assert(0==extend(&pos,d3d5,false));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1490, %rsp           # imm = 0x1490
leaq 0x1c78a(%rip), %rsi     # 0x31b39
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaa82
movl $0x4, %edi
movl $0x23, %esi
movl $0x1b, %edx
movl $0x3, %ecx
callq 0x777b
movq %rax, %rbx
leaq 0xb30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe682
testb %al, %al
je 0x1548d
leaq 0xb36de(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movl $0x5, %edi
movl $0x2b, %esi
movl $0x1b, %edx
movl $0x4, %ecx
callq 0x777b
movq %rax, %rbx
leaq 0x1d0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe682
testb %al, %al
je 0x154ac
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5e8c
testl %eax, %eax
jne 0x154cb
addq $0x1490, %rsp           # imm = 0x1490
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1c5df(%rip), %rdi     # 0x31a73
leaq 0x1c130(%rip), %rsi     # 0x315cb
leaq 0x1c6b6(%rip), %rcx     # 0x31b58
movl $0xe4, %edx
callq 0x20d0
leaq 0x1c5f7(%rip), %rdi     # 0x31aaa
leaq 0x1c111(%rip), %rsi     # 0x315cb
leaq 0x1c697(%rip), %rcx     # 0x31b58
movl $0xeb, %edx
callq 0x20d0
leaq 0x1c69d(%rip), %rdi     # 0x31b6f
leaq 0x1c0f2(%rip), %rsi     # 0x315cb
leaq 0x1c678(%rip), %rcx     # 0x31b58
movl $0xed, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/hash__test.cpp
// Function: contains_key(unsigned long long, unsigned long long*, int, int)
bool contains_key(uint64 needle,uint64 haystack[],int n,int start) {
    for (int i=start;i<n;i++) {
        if (needle==haystack[i]) {
            return true;
        }
    }
    return false;
}

// Assembly:
cmpl %edx, %ecx
jge 0x15552
movslq %ecx, %r8
movb $0x1, %al
cmpq %rdi, (%rsi,%r8,8)
je 0x15551
movslq %edx, %rax
incq %r8
notl %ecx
addl %edx, %ecx
movq %r8, %rdx
subl $0x1, %ecx
jb 0x1554b
leaq 0x1(%rdx), %r8
cmpq %rdi, (%rsi,%rdx,8)
jne 0x15539
cmpq %rax, %rdx
setl %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_hash_val_lower_bound()
void test_hash_val_lower_bound() {
    int32 depth = 14;
    int32 score = -109;
    move mv = to_move(PAWN,E2,E4);
    uint64 val = build_hash_val(LOWER_BOUND,depth,score,mv);

    assert(get_hash_entry_type(val)==LOWER_BOUND);
    assert(get_hash_entry_depth(val)==depth);
    assert(get_hash_entry_score(val)==score);
    assert(get_hash_entry_move(val)==mv);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x1, %edi
movl $0x34, %esi
movl $0x24, %edx
callq 0x775c
movq %rax, %rbx
movl $0x1, %edi
movl $0xe, %esi
movl $0xffffff93, %edx       # imm = 0xFFFFFF93
movq %rax, %rcx
callq 0x604f
movq %rax, %r14
movq %rax, %rdi
callq 0x61e4
cmpl $0x1, %eax
jne 0x16e7d
movq %r14, %rdi
callq 0x61eb
cmpl $0xe, %eax
jne 0x16e9c
movq %r14, %rdi
callq 0x61f2
cmpl $-0x6d, %eax
jne 0x16ebb
movq %r14, %rdi
callq 0x621c
cmpq %rbx, %rax
jne 0x16eda
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1aea3(%rip), %rdi     # 0x31d27
leaq 0x1ad1a(%rip), %rsi     # 0x31ba5
leaq 0x1aebb(%rip), %rcx     # 0x31d4d
movl $0x12e, %edx            # imm = 0x12E
callq 0x20d0
leaq 0x1aecb(%rip), %rdi     # 0x31d6e
leaq 0x1acfb(%rip), %rsi     # 0x31ba5
leaq 0x1ae9c(%rip), %rcx     # 0x31d4d
movl $0x12f, %edx            # imm = 0x12F
callq 0x20d0
leaq 0x1aecd(%rip), %rdi     # 0x31d8f
leaq 0x1acdc(%rip), %rsi     # 0x31ba5
leaq 0x1ae7d(%rip), %rcx     # 0x31d4d
movl $0x130, %edx            # imm = 0x130
callq 0x20d0
leaq 0x1aecf(%rip), %rdi     # 0x31db0
leaq 0x1acbd(%rip), %rsi     # 0x31ba5
leaq 0x1ae5e(%rip), %rcx     # 0x31d4d
movl $0x131, %edx            # imm = 0x131
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_hash_val_upper_bound()
void test_hash_val_upper_bound() {
    int32 depth = 45;
    move mv = 0;
    uint64 val = build_hash_val(UPPER_BOUND,depth,-CHECKMATE,mv);

    assert(get_hash_entry_type(val)==UPPER_BOUND);
    assert(get_hash_entry_depth(val)==depth);
    assert(get_hash_entry_score(val)==-CHECKMATE+500);
    assert(get_hash_entry_move(val)==mv);
}

// Assembly:
pushq %rbx
movl $0x2, %edi
movl $0x2d, %esi
movl $0xffff0001, %edx       # imm = 0xFFFF0001
xorl %ecx, %ecx
callq 0x604f
movq %rax, %rbx
movq %rax, %rdi
callq 0x61e4
cmpl $0x2, %eax
jne 0x16f4b
movq %rbx, %rdi
callq 0x61eb
cmpl $0x2d, %eax
jne 0x16f6a
movq %rbx, %rdi
callq 0x61f2
cmpl $0xffff01f5, %eax       # imm = 0xFFFF01F5
jne 0x16f89
movq %rbx, %rdi
callq 0x621c
testq %rax, %rax
jne 0x16fa8
popq %rbx
retq
leaq 0x1ae7b(%rip), %rdi     # 0x31dcd
leaq 0x1ac4c(%rip), %rsi     # 0x31ba5
leaq 0x1ae93(%rip), %rcx     # 0x31df3
movl $0x139, %edx            # imm = 0x139
callq 0x20d0
leaq 0x1adfd(%rip), %rdi     # 0x31d6e
leaq 0x1ac2d(%rip), %rsi     # 0x31ba5
leaq 0x1ae74(%rip), %rcx     # 0x31df3
movl $0x13a, %edx            # imm = 0x13A
callq 0x20d0
leaq 0x1ae84(%rip), %rdi     # 0x31e14
leaq 0x1ac0e(%rip), %rsi     # 0x31ba5
leaq 0x1ae55(%rip), %rcx     # 0x31df3
movl $0x13b, %edx            # imm = 0x13B
callq 0x20d0
leaq 0x1ae01(%rip), %rdi     # 0x31db0
leaq 0x1abef(%rip), %rsi     # 0x31ba5
leaq 0x1ae36(%rip), %rcx     # 0x31df3
movl $0x13c, %edx            # imm = 0x13C
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_hash_val_exact_score()
void test_hash_val_exact_score() {
    int32 depth = 1;
    int32 score = -54;
    move mv = to_capture(PAWN,E7,F8,BISHOP);
    set_promopiece(&mv,QUEEN);
    uint64 val = build_hash_val(EXACT_SCORE,depth,score,mv);

    assert(get_hash_entry_type(val)==EXACT_SCORE);
    assert(get_hash_entry_depth(val)==depth);
    assert(get_hash_entry_score(val)==score);
    move found = get_hash_entry_move(val);
    assert(found==mv);
    assert(get_from_sq(mv)==E7);
    assert(get_to_sq(mv)==F8);
    assert(get_piece(mv)==PAWN);
    assert(is_capture(mv));
    assert(get_promopiece(found)==QUEEN);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x1, %edi
movl $0xc, %esi
movl $0x5, %edx
movl $0x3, %ecx
callq 0x777b
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x7824
movq (%rbx), %rcx
movl $0x3, %edi
movl $0x1, %esi
movl $0xffffffca, %edx       # imm = 0xFFFFFFCA
callq 0x604f
movq %rax, %rbx
movq %rax, %rdi
callq 0x61e4
cmpl $0x3, %eax
jne 0x170bd
movq %rbx, %rdi
callq 0x61eb
cmpl $0x1, %eax
jne 0x170dc
movq %rbx, %rdi
callq 0x61f2
cmpl $-0x36, %eax
jne 0x170fb
movq %rbx, %rdi
callq 0x621c
cmpq 0x8(%rsp), %rax
jne 0x1711a
movq %rax, %rbx
movq %rax, %rdi
callq 0x7854
cmpl $0xc, %eax
jne 0x17139
movq 0x8(%rsp), %rdi
callq 0x785b
cmpl $0x5, %eax
jne 0x17158
movq 0x8(%rsp), %rdi
callq 0x7865
cmpl $0x1, %eax
jne 0x17177
movq 0x8(%rsp), %rdi
callq 0x7883
testb %al, %al
je 0x17196
movq %rbx, %rdi
callq 0x786f
cmpl $0x5, %eax
jne 0x171b5
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1ad7a(%rip), %rdi     # 0x31e3e
leaq 0x1aada(%rip), %rsi     # 0x31ba5
leaq 0x1ad92(%rip), %rcx     # 0x31e64
movl $0x146, %edx            # imm = 0x146
callq 0x20d0
leaq 0x1ac8b(%rip), %rdi     # 0x31d6e
leaq 0x1aabb(%rip), %rsi     # 0x31ba5
leaq 0x1ad73(%rip), %rcx     # 0x31e64
movl $0x147, %edx            # imm = 0x147
callq 0x20d0
leaq 0x1ac8d(%rip), %rdi     # 0x31d8f
leaq 0x1aa9c(%rip), %rsi     # 0x31ba5
leaq 0x1ad54(%rip), %rcx     # 0x31e64
movl $0x148, %edx            # imm = 0x148
callq 0x20d0
leaq 0x1ad64(%rip), %rdi     # 0x31e85
leaq 0x1aa7d(%rip), %rsi     # 0x31ba5
leaq 0x1ad35(%rip), %rcx     # 0x31e64
movl $0x14a, %edx            # imm = 0x14A
callq 0x20d0
leaq 0x1ad4f(%rip), %rdi     # 0x31e8f
leaq 0x1aa5e(%rip), %rsi     # 0x31ba5
leaq 0x1ad16(%rip), %rcx     # 0x31e64
movl $0x14b, %edx            # imm = 0x14B
callq 0x20d0
leaq 0x1ad44(%rip), %rdi     # 0x31ea3
leaq 0x1aa3f(%rip), %rsi     # 0x31ba5
leaq 0x1acf7(%rip), %rcx     # 0x31e64
movl $0x14c, %edx            # imm = 0x14C
callq 0x20d0
leaq 0x1ad37(%rip), %rdi     # 0x31eb5
leaq 0x1aa20(%rip), %rsi     # 0x31ba5
leaq 0x1acd8(%rip), %rcx     # 0x31e64
movl $0x14d, %edx            # imm = 0x14D
callq 0x20d0
leaq 0x1b8c4(%rip), %rdi     # 0x32a61
leaq 0x1aa01(%rip), %rsi     # 0x31ba5
leaq 0x1acb9(%rip), %rcx     # 0x31e64
movl $0x14e, %edx            # imm = 0x14E
callq 0x20d0
leaq 0x1ad0d(%rip), %rdi     # 0x31ec9
leaq 0x1a9e2(%rip), %rsi     # 0x31ba5
leaq 0x1ac9a(%rip), %rcx     # 0x31e64
movl $0x14f, %edx            # imm = 0x14F
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_with_mate_score()
void test_with_mate_score() {
    clear_hash_table(&htbl);
    position pos;
    set_pos(&pos,"5k2/6pp/p1qN4/1p1p4/3P4/2PKP2Q/PP3r2/3R4 b - -");

    uint64 key = build_hash_key(&pos);
    move mv = to_move(PAWN,C6,C4);
    store_hash_entry(&htbl,key,build_hash_val(LOWER_BOUND,5,CHECKMATE-3,mv));

    uint64 val = get_hash_entry(&htbl,key);
    assert(val!=0);
    assert(get_hash_entry_move(val)==mv);

    // the idea here is to not deal with mate score adjustments!  Just say "it's at least a mate"
    assert(get_hash_entry_score(val)==CHECKMATE-500);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0xe08b0(%rip), %rbx     # 0xf7ef0
movq %rbx, %rdi
callq 0x62b6
leaq 0x1a958(%rip), %rsi     # 0x31fa7
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaa82
movq %r14, %rdi
callq 0x5ee8
movq %rax, %r15
movl $0x1, %edi
movl $0x12, %esi
movl $0x22, %edx
callq 0x775c
movq %rax, %r14
movl $0x1, %edi
movl $0x5, %esi
movl $0xfffc, %edx           # imm = 0xFFFC
movq %rax, %rcx
callq 0x604f
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x636f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6312
testq %rax, %rax
je 0x176df
movq %rax, %rbx
movq %rax, %rdi
callq 0x621c
cmpq %r14, %rax
jne 0x176fe
movq %rbx, %rdi
callq 0x61f2
cmpl $0xfe0b, %eax           # imm = 0xFE0B
jne 0x1771d
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a8f0(%rip), %rdi     # 0x31fd6
leaq 0x1a4b8(%rip), %rsi     # 0x31ba5
leaq 0x1a8e9(%rip), %rcx     # 0x31fdd
movl $0x19d, %edx            # imm = 0x19D
callq 0x20d0
leaq 0x1a6ab(%rip), %rdi     # 0x31db0
leaq 0x1a499(%rip), %rsi     # 0x31ba5
leaq 0x1a8ca(%rip), %rcx     # 0x31fdd
movl $0x19e, %edx            # imm = 0x19E
callq 0x20d0
leaq 0x1a8d5(%rip), %rdi     # 0x31ff9
leaq 0x1a47a(%rip), %rsi     # 0x31ba5
leaq 0x1a8ab(%rip), %rcx     # 0x31fdd
movl $0x1a1, %edx            # imm = 0x1A1
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe07a1(%rip), %r14     # 0xf7ef0
movq %r14, %rdi
callq 0x62b6
leaq 0x1a8c4(%rip), %rsi     # 0x32022
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
callq 0x5ee8
movq %rax, %r15
movl $0x4, %edi
movl $0x3d, %esi
movl $0x3c, %edx
callq 0x775c
movq %rax, %rbx
movl $0x2, %edi
movl $0x5, %esi
movl $0xfffc, %edx           # imm = 0xFFFC
movq %rax, %rcx
callq 0x604f
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x636f
movq %r14, %rdi
movq %r15, %rsi
callq 0x6312
testq %rax, %rax
je 0x177f8
movq %rax, %r14
movq %rax, %rdi
callq 0x61e4
testl %eax, %eax
jne 0x17817
movq %r14, %rdi
callq 0x621c
cmpq %rbx, %rax
jne 0x17836
movq %r14, %rdi
callq 0x61eb
cmpl $0x5, %eax
jne 0x17855
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a7d7(%rip), %rdi     # 0x31fd6
leaq 0x1a39f(%rip), %rsi     # 0x31ba5
leaq 0x1a84c(%rip), %rcx     # 0x32059
movl $0x1ae, %edx            # imm = 0x1AE
callq 0x20d0
leaq 0x1a862(%rip), %rdi     # 0x32080
leaq 0x1a380(%rip), %rsi     # 0x31ba5
leaq 0x1a82d(%rip), %rcx     # 0x32059
movl $0x1af, %edx            # imm = 0x1AF
callq 0x20d0
leaq 0x1a573(%rip), %rdi     # 0x31db0
leaq 0x1a361(%rip), %rsi     # 0x31ba5
leaq 0x1a80e(%rip), %rcx     # 0x32059
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x20d0
leaq 0x1a848(%rip), %rdi     # 0x320a4
leaq 0x1a342(%rip), %rsi     # 0x31ba5
leaq 0x1a7ef(%rip), %rcx     # 0x32059
movl $0x1b1, %edx            # imm = 0x1B1
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe0669(%rip), %r14     # 0xf7ef0
movq %r14, %rdi
callq 0x62b6
leaq 0x1a82b(%rip), %rsi     # 0x320c1
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
callq 0x5ee8
movq %rax, %r15
movl $0x4, %edi
movl $0x6, %esi
movl $0x5, %edx
callq 0x775c
movq %rax, %rbx
movl $0x3, %edi
movl $0x5, %esi
movl $0xfff8, %edx           # imm = 0xFFF8
movq %rax, %rcx
callq 0x604f
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x636f
movq %r14, %rdi
movq %r15, %rsi
callq 0x6312
testq %rax, %rax
je 0x17944
movq %rax, %r14
movq %rax, %rdi
callq 0x61e4
cmpl $0x1, %eax
jne 0x17963
movq %r14, %rdi
callq 0x621c
cmpq %rbx, %rax
jne 0x17982
movq %r14, %rdi
callq 0x61f2
cmpl $0xfe0b, %eax           # imm = 0xFE0B
jne 0x179a1
movq %r14, %rdi
callq 0x61eb
cmpl $0x5, %eax
jne 0x179c0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a68b(%rip), %rdi     # 0x31fd6
leaq 0x1a253(%rip), %rsi     # 0x31ba5
leaq 0x1a79d(%rip), %rcx     # 0x320f6
movl $0x1be, %edx            # imm = 0x1BE
callq 0x20d0
leaq 0x1a3bd(%rip), %rdi     # 0x31d27
leaq 0x1a234(%rip), %rsi     # 0x31ba5
leaq 0x1a77e(%rip), %rcx     # 0x320f6
movl $0x1bf, %edx            # imm = 0x1BF
callq 0x20d0
leaq 0x1a427(%rip), %rdi     # 0x31db0
leaq 0x1a215(%rip), %rsi     # 0x31ba5
leaq 0x1a75f(%rip), %rcx     # 0x320f6
movl $0x1c0, %edx            # imm = 0x1C0
callq 0x20d0
leaq 0x1a651(%rip), %rdi     # 0x31ff9
leaq 0x1a1f6(%rip), %rsi     # 0x31ba5
leaq 0x1a740(%rip), %rcx     # 0x320f6
movl $0x1c1, %edx            # imm = 0x1C1
callq 0x20d0
leaq 0x1a6dd(%rip), %rdi     # 0x320a4
leaq 0x1a1d7(%rip), %rsi     # 0x31ba5
leaq 0x1a721(%rip), %rcx     # 0x320f6
movl $0x1c2, %edx            # imm = 0x1C2
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe04fe(%rip), %r14     # 0xf7ef0
movq %r14, %rdi
callq 0x62b6
leaq 0x1a71c(%rip), %rsi     # 0x3211d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
callq 0x5ee8
movq %rax, %r15
movl $0x4, %edi
movl $0x3b, %esi
movl $0x38, %edx
callq 0x775c
movq %rax, %rbx
movl $0x1, %edi
movl $0x8, %esi
movl $0xffff000b, %edx       # imm = 0xFFFF000B
movq %rax, %rcx
callq 0x604f
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x636f
movq %r14, %rdi
movq %r15, %rsi
callq 0x6312
testq %rax, %rax
je 0x17a9b
movq %rax, %r14
movq %rax, %rdi
callq 0x61e4
testl %eax, %eax
jne 0x17aba
movq %r14, %rdi
callq 0x621c
cmpq %rbx, %rax
jne 0x17ad9
movq %r14, %rdi
callq 0x61eb
cmpl $0x8, %eax
jne 0x17af8
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a534(%rip), %rdi     # 0x31fd6
leaq 0x1a0fc(%rip), %rsi     # 0x31ba5
leaq 0x1a6a1(%rip), %rcx     # 0x32151
movl $0x1cf, %edx            # imm = 0x1CF
callq 0x20d0
leaq 0x1a5bf(%rip), %rdi     # 0x32080
leaq 0x1a0dd(%rip), %rsi     # 0x31ba5
leaq 0x1a682(%rip), %rcx     # 0x32151
movl $0x1d0, %edx            # imm = 0x1D0
callq 0x20d0
leaq 0x1a2d0(%rip), %rdi     # 0x31db0
leaq 0x1a0be(%rip), %rsi     # 0x31ba5
leaq 0x1a663(%rip), %rcx     # 0x32151
movl $0x1d1, %edx            # imm = 0x1D1
callq 0x20d0
leaq 0x1a67a(%rip), %rdi     # 0x32179
leaq 0x1a09f(%rip), %rsi     # 0x31ba5
leaq 0x1a644(%rip), %rcx     # 0x32151
movl $0x1d2, %edx            # imm = 0x1D2
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe03c6(%rip), %r14     # 0xf7ef0
movq %r14, %rdi
callq 0x62b6
leaq 0x1a65d(%rip), %rsi     # 0x32196
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
callq 0x5ee8
movq %rax, %r15
movl $0x1, %edi
movl $0xe, %esi
movl $0x16, %edx
callq 0x775c
movq %rax, %rbx
movl $0x3, %edi
movl $0xa, %esi
movl $0xffff0003, %edx       # imm = 0xFFFF0003
movq %rax, %rcx
callq 0x604f
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x636f
movq %r14, %rdi
movq %r15, %rsi
callq 0x6312
testq %rax, %rax
je 0x17be7
movq %rax, %r14
movq %rax, %rdi
callq 0x61e4
cmpl $0x2, %eax
jne 0x17c06
movq %r14, %rdi
callq 0x621c
cmpq %rbx, %rax
jne 0x17c25
movq %r14, %rdi
callq 0x61f2
cmpl $0xffff01f5, %eax       # imm = 0xFFFF01F5
jne 0x17c44
movq %r14, %rdi
callq 0x61eb
cmpl $0xa, %eax
jne 0x17c63
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a3e8(%rip), %rdi     # 0x31fd6
leaq 0x19fb0(%rip), %rsi     # 0x31ba5
leaq 0x1a5cc(%rip), %rcx     # 0x321c8
movl $0x1df, %edx            # imm = 0x1DF
callq 0x20d0
leaq 0x1a1c0(%rip), %rdi     # 0x31dcd
leaq 0x19f91(%rip), %rsi     # 0x31ba5
leaq 0x1a5ad(%rip), %rcx     # 0x321c8
movl $0x1e0, %edx            # imm = 0x1E0
callq 0x20d0
leaq 0x1a184(%rip), %rdi     # 0x31db0
leaq 0x19f72(%rip), %rsi     # 0x31ba5
leaq 0x1a58e(%rip), %rcx     # 0x321c8
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x20d0
leaq 0x1a1c9(%rip), %rdi     # 0x31e14
leaq 0x19f53(%rip), %rsi     # 0x31ba5
leaq 0x1a56f(%rip), %rcx     # 0x321c8
movl $0x1e2, %edx            # imm = 0x1E2
callq 0x20d0
leaq 0x1a586(%rip), %rdi     # 0x321f0
leaq 0x19f34(%rip), %rsi     # 0x31ba5
leaq 0x1a550(%rip), %rcx     # 0x321c8
movl $0x1e3, %edx            # imm = 0x1E3
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe025b(%rip), %r14     # 0xf7ef0
movq %r14, %rdi
callq 0x62b6
leaq 0x1a56a(%rip), %rsi     # 0x3220e
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
callq 0x5ee8
movq %rax, %r15
movl $0x6, %edi
movl $0x3e, %esi
movl $0x3f, %edx
callq 0x775c
movq %rax, %rbx
movl $0x2, %edi
movl $0x7, %esi
movl $0xffff0009, %edx       # imm = 0xFFFF0009
movq %rax, %rcx
callq 0x604f
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x636f
movq %r14, %rdi
movq %r15, %rsi
callq 0x6312
testq %rax, %rax
je 0x17d52
movq %rax, %r14
movq %rax, %rdi
callq 0x61e4
cmpl $0x2, %eax
jne 0x17d71
movq %r14, %rdi
callq 0x621c
cmpq %rbx, %rax
jne 0x17d90
movq %r14, %rdi
callq 0x61f2
cmpl $0xffff01f5, %eax       # imm = 0xFFFF01F5
jne 0x17daf
movq %r14, %rdi
callq 0x61eb
cmpl $0x7, %eax
jne 0x17dce
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a27d(%rip), %rdi     # 0x31fd6
leaq 0x19e45(%rip), %rsi     # 0x31ba5
leaq 0x1a4e1(%rip), %rcx     # 0x32248
movl $0x1f0, %edx            # imm = 0x1F0
callq 0x20d0
leaq 0x1a055(%rip), %rdi     # 0x31dcd
leaq 0x19e26(%rip), %rsi     # 0x31ba5
leaq 0x1a4c2(%rip), %rcx     # 0x32248
movl $0x1f1, %edx            # imm = 0x1F1
callq 0x20d0
leaq 0x1a019(%rip), %rdi     # 0x31db0
leaq 0x19e07(%rip), %rsi     # 0x31ba5
leaq 0x1a4a3(%rip), %rcx     # 0x32248
movl $0x1f2, %edx            # imm = 0x1F2
callq 0x20d0
leaq 0x1a05e(%rip), %rdi     # 0x31e14
leaq 0x19de8(%rip), %rsi     # 0x31ba5
leaq 0x1a484(%rip), %rcx     # 0x32248
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x20d0
leaq 0x1a49b(%rip), %rdi     # 0x32270
leaq 0x19dc9(%rip), %rsi     # 0x31ba5
leaq 0x1a465(%rip), %rcx     # 0x32248
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x20d0