LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb40, %rsp            # imm = 0xB40
leaq -0x1c8(%rbp), %rdi
leaq 0x212f7(%rip), %rsi     # 0x3dd50
callq 0xf3e0
leaq -0xb30(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0xb38(%rbp)
movl $0x1, %edi
movl $0x11, %esi
movl $0x9, %edx
callq 0xa830
movq %rax, -0xb40(%rbp)
movq -0xb40(%rbp), %rdi
leaq -0xb30(%rbp), %rsi
movq -0xb38(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1caba
jmp 0x1cabc
jmp 0x1cadb
leaq 0x21307(%rip), %rdi     # 0x3ddca
leaq 0x21257(%rip), %rsi     # 0x3dd21
movl $0x32, %edx
leaq 0x21315(%rip), %rcx     # 0x3ddeb
callq 0x20c0
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xb71c0(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
movl $0x1, %edx
callq 0x8150
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x1cb1a
jmp 0x1cb39
leaq 0x212e8(%rip), %rdi     # 0x3de09
leaq 0x211f9(%rip), %rsi     # 0x3dd21
movl $0x35, %edx
leaq 0x212b7(%rip), %rcx     # 0x3ddeb
callq 0x20c0
addq $0xb40, %rsp            # imm = 0xB40
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb40, %rsp            # imm = 0xB40
leaq -0x1c8(%rbp), %rdi
leaq 0x212ba(%rip), %rsi     # 0x3de23
callq 0xf3e0
leaq -0xb30(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0xb38(%rbp)
movl $0x1, %edi
movl $0xe, %esi
movl $0x16, %edx
callq 0xa830
movq %rax, -0xb40(%rbp)
movq -0xb40(%rbp), %rdi
leaq -0xb30(%rbp), %rsi
movq -0xb38(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1cbca
jmp 0x1cbcc
jmp 0x1cbeb
leaq 0x21270(%rip), %rdi     # 0x3de43
leaq 0x21147(%rip), %rsi     # 0x3dd21
movl $0x41, %edx
leaq 0x2127e(%rip), %rcx     # 0x3de64
callq 0x20c0
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xb70b0(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x8150
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1cc24
jmp 0x1cc43
leaq 0x21251(%rip), %rdi     # 0x3de7c
leaq 0x210ef(%rip), %rsi     # 0x3dd21
movl $0x44, %edx
leaq 0x21226(%rip), %rcx     # 0x3de64
callq 0x20c0
addq $0xb40, %rsp            # imm = 0xB40
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb40, %rsp            # imm = 0xB40
leaq -0x1c8(%rbp), %rdi
leaq 0x20ae3(%rip), %rsi     # 0x3d74c
callq 0xf3e0
leaq -0xb30(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0xb38(%rbp)
movl $0x4, %edi
movl $0x1b, %esi
movl $0x23, %edx
callq 0xa830
movq %rax, -0xb40(%rbp)
movq -0xb40(%rbp), %rdi
leaq -0xb30(%rbp), %rsi
movq -0xb38(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1ccca
jmp 0x1cccc
jmp 0x1cceb
leaq 0x211c4(%rip), %rdi     # 0x3de97
leaq 0x21047(%rip), %rsi     # 0x3dd21
movl $0x50, %edx
leaq 0x211d2(%rip), %rcx     # 0x3deb8
callq 0x20c0
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xb6fb0(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x8150
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1cd24
jmp 0x1cd43
leaq 0x211a6(%rip), %rdi     # 0x3ded1
leaq 0x20fef(%rip), %rsi     # 0x3dd21
movl $0x52, %edx
leaq 0x2117a(%rip), %rcx     # 0x3deb8
callq 0x20c0
addq $0xb40, %rsp            # imm = 0xB40
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb40, %rsp            # imm = 0xB40
leaq -0x1c8(%rbp), %rdi
leaq 0x209e3(%rip), %rsi     # 0x3d74c
callq 0xf3e0
leaq -0xb30(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0xb38(%rbp)
movl $0x1, %edi
movl $0x2f, %esi
movl $0x37, %edx
callq 0xa830
movq %rax, -0xb40(%rbp)
movq -0xb40(%rbp), %rdi
leaq -0xb30(%rbp), %rsi
movq -0xb38(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1cdca
jmp 0x1cdcc
jmp 0x1cdeb
leaq 0x21119(%rip), %rdi     # 0x3deec
leaq 0x20f47(%rip), %rsi     # 0x3dd21
movl $0x5e, %edx
leaq 0x21127(%rip), %rcx     # 0x3df0d
callq 0x20c0
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xb6eb0(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x8150
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x1ce27
jmp 0x1ce46
leaq 0x210fd(%rip), %rdi     # 0x3df2b
leaq 0x20eec(%rip), %rsi     # 0x3dd21
movl $0x60, %edx
leaq 0x210cc(%rip), %rcx     # 0x3df0d
callq 0x20c0
addq $0xb40, %rsp            # imm = 0xB40
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb40, %rsp            # imm = 0xB40
leaq -0x1c8(%rbp), %rdi
leaq 0x210dd(%rip), %rsi     # 0x3df46
callq 0xf3e0
leaq -0xb30(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0xb38(%rbp)
movl $0x1, %edi
movl $0x20, %esi
movl $0x18, %edx
callq 0xa830
movq %rax, -0xb40(%rbp)
movq -0xb40(%rbp), %rdi
leaq -0xb30(%rbp), %rsi
movq -0xb38(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1ceca
jmp 0x1cecc
jmp 0x1ceeb
leaq 0x21095(%rip), %rdi     # 0x3df68
leaq 0x20e47(%rip), %rsi     # 0x3dd21
movl $0x6d, %edx
leaq 0x210a3(%rip), %rcx     # 0x3df89
callq 0x20c0
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xb6db0(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x8150
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1cf24
jmp 0x1cf43
leaq 0x21077(%rip), %rdi     # 0x3dfa2
leaq 0x20def(%rip), %rsi     # 0x3dd21
movl $0x6f, %edx
leaq 0x2104b(%rip), %rcx     # 0x3df89
callq 0x20c0
addq $0xb40, %rsp            # imm = 0xB40
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb40, %rsp            # imm = 0xB40
leaq -0x1c8(%rbp), %rdi
leaq 0x209dd(%rip), %rsi     # 0x3d946
callq 0xf3e0
leaq -0xb30(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0xb38(%rbp)
movl $0x1, %edi
movl $0xd, %esi
movl $0x15, %edx
callq 0xa830
movq %rax, -0xb40(%rbp)
movq -0xb40(%rbp), %rdi
leaq -0xb30(%rbp), %rsi
movq -0xb38(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1cfca
jmp 0x1cfcc
jmp 0x1cfeb
leaq 0x20fea(%rip), %rdi     # 0x3dfbd
leaq 0x20d47(%rip), %rsi     # 0x3dd21
movl $0x7b, %edx
leaq 0x20ff8(%rip), %rcx     # 0x3dfde
callq 0x20c0
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xb6cb0(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x8150
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1d024
jmp 0x1d043
leaq 0x20fcc(%rip), %rdi     # 0x3dff7
leaq 0x20cef(%rip), %rsi     # 0x3dd21
movl $0x7d, %edx
leaq 0x20fa0(%rip), %rcx     # 0x3dfde
callq 0x20c0
addq $0xb40, %rsp            # imm = 0xB40
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb40, %rsp            # imm = 0xB40
leaq -0x1c8(%rbp), %rdi
leaq 0x20fa9(%rip), %rsi     # 0x3e012
callq 0xf3e0
leaq -0xb30(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0xb38(%rbp)
movl $0x1, %edi
movl $0x8, %esi
movl $0x10, %edx
callq 0xa830
movq %rax, -0xb40(%rbp)
movq -0xb40(%rbp), %rdi
leaq -0xb30(%rbp), %rsi
movq -0xb38(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1d0ca
jmp 0x1d0cc
jmp 0x1d0eb
leaq 0x20f71(%rip), %rdi     # 0x3e044
leaq 0x20c47(%rip), %rsi     # 0x3dd21
movl $0x89, %edx
leaq 0x20f7f(%rip), %rcx     # 0x3e065
callq 0x20c0
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xb6bb0(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x8150
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1d124
jmp 0x1d143
leaq 0x20f53(%rip), %rdi     # 0x3e07e
leaq 0x20bef(%rip), %rsi     # 0x3dd21
movl $0x8b, %edx
leaq 0x20f27(%rip), %rcx     # 0x3e065
callq 0x20c0
addq $0xb40, %rsp            # imm = 0xB40
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb40, %rsp            # imm = 0xB40
leaq -0x1c8(%rbp), %rdi
leaq 0x20ea9(%rip), %rsi     # 0x3e012
callq 0xf3e0
leaq -0xb30(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0xb38(%rbp)
movl $0x1, %edi
movl $0x11, %esi
movl $0x19, %edx
callq 0xa830
movq %rax, -0xb40(%rbp)
movq -0xb40(%rbp), %rdi
leaq -0xb30(%rbp), %rsi
movq -0xb38(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1d1ca
jmp 0x1d1cc
jmp 0x1d1eb
leaq 0x20ec6(%rip), %rdi     # 0x3e099
leaq 0x20b47(%rip), %rsi     # 0x3dd21
movl $0x96, %edx
leaq 0x20ed4(%rip), %rcx     # 0x3e0ba
callq 0x20c0
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xb6ab0(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x8150
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1d224
jmp 0x1d243
leaq 0x20ea8(%rip), %rdi     # 0x3e0d3
leaq 0x20aef(%rip), %rsi     # 0x3dd21
movl $0x98, %edx
leaq 0x20e7c(%rip), %rcx     # 0x3e0ba
callq 0x20c0
addq $0xb40, %rsp            # imm = 0xB40
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb40, %rsp            # imm = 0xB40
leaq -0x1c8(%rbp), %rdi
leaq 0x20e85(%rip), %rsi     # 0x3e0ee
callq 0xf3e0
movl $0x1, %ecx
movl $0x25, %esi
movl $0x1c, %edx
movl %ecx, %edi
callq 0xa890
movq %rax, -0x1d0(%rbp)
leaq -0xb30(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0xb38(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0xb30(%rbp), %rsi
movq -0xb38(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1d2cc
jmp 0x1d2ce
jmp 0x1d2ed
leaq 0x20e37(%rip), %rdi     # 0x3e10c
leaq 0x20a45(%rip), %rsi     # 0x3dd21
movl $0xa4, %edx
leaq 0x20e45(%rip), %rcx     # 0x3e12d
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xb69ae(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x8150
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1d326
jmp 0x1d345
leaq 0x20e26(%rip), %rdi     # 0x3e153
leaq 0x209ed(%rip), %rsi     # 0x3dd21
movl $0xa7, %edx
leaq 0x20ded(%rip), %rcx     # 0x3e12d
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0xb695d(%rip), %rsi     # 0xd3cb0
callq 0x39a0
movl $0x1, %edi
movl $0x25, %esi
movl $0x1d, %edx
callq 0xa830
movq %rax, -0xb40(%rbp)
movq -0xb40(%rbp), %rdi
leaq -0xb30(%rbp), %rsi
movq -0xb38(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1d393
jmp 0x1d395
jmp 0x1d3b4
leaq 0x20dd2(%rip), %rdi     # 0x3e16e
leaq 0x2097e(%rip), %rsi     # 0x3dd21
movl $0xab, %edx
leaq 0x20d7e(%rip), %rcx     # 0x3e12d
callq 0x20c0
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xb68e7(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x8150
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1d3ed
jmp 0x1d40c
leaq 0x20d9b(%rip), %rdi     # 0x3e18f
leaq 0x20926(%rip), %rsi     # 0x3dd21
movl $0xae, %edx
leaq 0x20d26(%rip), %rcx     # 0x3e12d
callq 0x20c0
addq $0xb40, %rsp            # imm = 0xB40
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x14b0, %rsp           # imm = 0x14B0
leaq -0x1c8(%rbp), %rdi
leaq 0x20d71(%rip), %rsi     # 0x3e1aa
callq 0xf3e0
movl $0x4, %ecx
movl $0x23, %esi
movl $0x1b, %edx
movl %ecx, %edi
callq 0xa890
movq %rax, -0x1d0(%rbp)
leaq -0xb30(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0xb38(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0xb30(%rbp), %rsi
movq -0xb38(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1d49c
jmp 0x1d49e
jmp 0x1d4bd
leaq 0x20d24(%rip), %rdi     # 0x3e1c9
leaq 0x20875(%rip), %rsi     # 0x3dd21
movl $0xba, %edx
leaq 0x20d32(%rip), %rcx     # 0x3e1ea
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xb67de(%rip), %rdx     # 0xd3cb0
callq 0x3620
movl $0x4, %ecx
movl $0x2b, %esi
movl $0x1b, %edx
movl %ecx, %edi
callq 0xa890
movq %rax, -0xb40(%rbp)
leaq -0x14a0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0x14a8(%rbp)
movq -0xb40(%rbp), %rdi
leaq -0x14a0(%rbp), %rsi
movq -0x14a8(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1d535
jmp 0x1d537
jmp 0x1d556
leaq 0x20cc2(%rip), %rdi     # 0x3e200
leaq 0x207dc(%rip), %rsi     # 0x3dd21
movl $0xc1, %edx
leaq 0x20c99(%rip), %rcx     # 0x3e1ea
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x8150
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x1d578
jmp 0x1d597
leaq 0x20ca4(%rip), %rdi     # 0x3e223
leaq 0x2079b(%rip), %rsi     # 0x3dd21
movl $0xc3, %edx
leaq 0x20c58(%rip), %rcx     # 0x3e1ea
callq 0x20c0
addq $0x14b0, %rsp           # imm = 0x14B0
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x14b0, %rsp           # imm = 0x14B0
leaq -0x1c8(%rbp), %rdi
leaq 0x20c85(%rip), %rsi     # 0x3e23e
callq 0xf3e0
movl $0x4, %ecx
movl $0x23, %esi
movl $0x1b, %edx
movl %ecx, %edi
callq 0xa890
movq %rax, -0x1d0(%rbp)
leaq -0xb30(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0xb38(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0xb30(%rbp), %rsi
movq -0xb38(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1d61c
jmp 0x1d61e
jmp 0x1d63d
leaq 0x20ba4(%rip), %rdi     # 0x3e1c9
leaq 0x206f5(%rip), %rsi     # 0x3dd21
movl $0xcf, %edx
leaq 0x20c25(%rip), %rcx     # 0x3e25d
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xb665e(%rip), %rdx     # 0xd3cb0
callq 0x3620
movl $0x5, %edi
movl $0x2b, %esi
movl $0x1b, %edx
movl $0x4, %ecx
callq 0xa890
movq %rax, -0xb40(%rbp)
leaq -0x14a0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0x14a8(%rbp)
movq -0xb40(%rbp), %rdi
leaq -0x14a0(%rbp), %rsi
movq -0x14a8(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1d6b8
jmp 0x1d6ba
jmp 0x1d6d9
leaq 0x20b3f(%rip), %rdi     # 0x3e200
leaq 0x20659(%rip), %rsi     # 0x3dd21
movl $0xd6, %edx
leaq 0x20b89(%rip), %rcx     # 0x3e25d
callq 0x20c0
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x8150
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x1d6fb
jmp 0x1d71a
leaq 0x20b72(%rip), %rdi     # 0x3e274
leaq 0x20618(%rip), %rsi     # 0x3dd21
movl $0xd8, %edx
leaq 0x20b48(%rip), %rcx     # 0x3e25d
callq 0x20c0
addq $0x14b0, %rsp           # imm = 0x14B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x14b0, %rsp           # imm = 0x14B0
leaq -0x1c8(%rbp), %rdi
leaq 0x20b46(%rip), %rsi     # 0x3e28f
callq 0xf3e0
movl $0x4, %edi
movl $0x23, %esi
movl $0x1b, %edx
movl $0x3, %ecx
callq 0xa890
movq %rax, -0x1d0(%rbp)
leaq -0xb30(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0xb38(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0xb30(%rbp), %rsi
movq -0xb38(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1d7af
jmp 0x1d7b1
jmp 0x1d7d0
leaq 0x20a11(%rip), %rdi     # 0x3e1c9
leaq 0x20562(%rip), %rsi     # 0x3dd21
movl $0xe4, %edx
leaq 0x20ae3(%rip), %rcx     # 0x3e2ae
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xb64cb(%rip), %rdx     # 0xd3cb0
callq 0x3620
movl $0x5, %edi
movl $0x2b, %esi
movl $0x1b, %edx
movl $0x4, %ecx
callq 0xa890
movq %rax, -0xb40(%rbp)
leaq -0x14a0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0x14a8(%rbp)
movq -0xb40(%rbp), %rdi
leaq -0x14a0(%rbp), %rsi
movq -0x14a8(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x1d84b
jmp 0x1d84d
jmp 0x1d86c
leaq 0x209ac(%rip), %rdi     # 0x3e200
leaq 0x204c6(%rip), %rsi     # 0x3dd21
movl $0xeb, %edx
leaq 0x20a47(%rip), %rcx     # 0x3e2ae
callq 0x20c0
movq -0xb40(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x8150
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x1d88b
jmp 0x1d8aa
leaq 0x20a33(%rip), %rdi     # 0x3e2c5
leaq 0x20488(%rip), %rsi     # 0x3dd21
movl $0xed, %edx
leaq 0x20a09(%rip), %rcx     # 0x3e2ae
callq 0x20c0
addq $0x14b0, %rsp           # imm = 0x14B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/extend__test.cpp
// Function: test_extend()
void test_extend() {
    test_no_extension();
    test_extend_promotion();
    test_white_push_to_7th();
    test_passed_pawn();
    test_passed_pawn2();
    //test_black_push_to_2nd();
    test_passed_pawn3();
    test_passed_pawn4();
    test_passed_pawn5();
    test_passed_pawn6();
    test_newly_created_passed_pawn();
    //test_recapture();
    //test_recapture2();
    //test_recapture3();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x1c880
callq 0x1c920
callq 0x1ca40
callq 0x1cb50
callq 0x1cc50
callq 0x1ce50
callq 0x1cf50
callq 0x1d050
callq 0x1d150
callq 0x1d250
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1d945
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x1d938
movb $0x1, -0x1(%rbp)
jmp 0x1d949
jmp 0x1d93a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1d918
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0xe, -0x4(%rbp)
movl $0xffffff93, -0x8(%rbp) # imm = 0xFFFFFF93
movl $0x1, %edi
movl $0x34, %esi
movl $0x24, %edx
callq 0xa830
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movq -0x10(%rbp), %rcx
movl $0x1, %edi
callq 0x8470
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8710
cmpl $0x1, %eax
jne 0x1faa6
jmp 0x1fac5
leaq 0x1e9d0(%rip), %rdi     # 0x3e47d
leaq 0x1e847(%rip), %rsi     # 0x3e2fb
movl $0x12e, %edx            # imm = 0x12E
leaq 0x1e9e3(%rip), %rcx     # 0x3e4a3
callq 0x20c0
movq -0x18(%rbp), %rdi
callq 0x8730
cmpl -0x4(%rbp), %eax
jne 0x1fad5
jmp 0x1faf4
leaq 0x1e9e8(%rip), %rdi     # 0x3e4c4
leaq 0x1e818(%rip), %rsi     # 0x3e2fb
movl $0x12f, %edx            # imm = 0x12F
leaq 0x1e9b4(%rip), %rcx     # 0x3e4a3
callq 0x20c0
movq -0x18(%rbp), %rdi
callq 0x8750
cmpl -0x8(%rbp), %eax
jne 0x1fb04
jmp 0x1fb23
leaq 0x1e9da(%rip), %rdi     # 0x3e4e5
leaq 0x1e7e9(%rip), %rsi     # 0x3e2fb
movl $0x130, %edx            # imm = 0x130
leaq 0x1e985(%rip), %rcx     # 0x3e4a3
callq 0x20c0
movq -0x18(%rbp), %rdi
callq 0x87d0
cmpq -0x10(%rbp), %rax
jne 0x1fb34
jmp 0x1fb53
leaq 0x1e9cb(%rip), %rdi     # 0x3e506
leaq 0x1e7b9(%rip), %rsi     # 0x3e2fb
movl $0x131, %edx            # imm = 0x131
leaq 0x1e955(%rip), %rcx     # 0x3e4a3
callq 0x20c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x2d, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rcx
movl $0x2, %edi
movl $0xffff0001, %edx       # imm = 0xFFFF0001
callq 0x8470
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8710
cmpl $0x2, %eax
jne 0x1fba1
jmp 0x1fbc0
leaq 0x1e97b(%rip), %rdi     # 0x3e523
leaq 0x1e74c(%rip), %rsi     # 0x3e2fb
movl $0x139, %edx            # imm = 0x139
leaq 0x1e98e(%rip), %rcx     # 0x3e549
callq 0x20c0
movq -0x18(%rbp), %rdi
callq 0x8730
cmpl -0x4(%rbp), %eax
jne 0x1fbd0
jmp 0x1fbef
leaq 0x1e8ed(%rip), %rdi     # 0x3e4c4
leaq 0x1e71d(%rip), %rsi     # 0x3e2fb
movl $0x13a, %edx            # imm = 0x13A
leaq 0x1e95f(%rip), %rcx     # 0x3e549
callq 0x20c0
movq -0x18(%rbp), %rdi
callq 0x8750
cmpl $0xffff01f5, %eax       # imm = 0xFFFF01F5
jne 0x1fc01
jmp 0x1fc20
leaq 0x1e962(%rip), %rdi     # 0x3e56a
leaq 0x1e6ec(%rip), %rsi     # 0x3e2fb
movl $0x13b, %edx            # imm = 0x13B
leaq 0x1e92e(%rip), %rcx     # 0x3e549
callq 0x20c0
movq -0x18(%rbp), %rdi
callq 0x87d0
cmpq -0x10(%rbp), %rax
jne 0x1fc31
jmp 0x1fc50
leaq 0x1e8ce(%rip), %rdi     # 0x3e506
leaq 0x1e6bc(%rip), %rsi     # 0x3e2fb
movl $0x13c, %edx            # imm = 0x13C
leaq 0x1e8fe(%rip), %rcx     # 0x3e549
callq 0x20c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
leaq 0xe2cbe(%rip), %rdi     # 0x1030b0
callq 0x88c0
leaq -0x1c8(%rbp), %rdi
leaq 0x1e2f8(%rip), %rsi     # 0x3e6fd
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0x81f0
movq %rax, -0x1d0(%rbp)
movl $0x1, %edi
movl $0x12, %esi
movl $0x22, %edx
callq 0xa830
movq %rax, -0x1d8(%rbp)
movq -0x1d0(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movq -0x1d8(%rbp), %rcx
movl $0x1, %edi
movl $0x5, %esi
movl $0xfffc, %edx           # imm = 0xFFFC
callq 0x8470
movq -0x1e8(%rbp), %rsi
movq %rax, %rdx
leaq 0xe2c3e(%rip), %rdi     # 0x1030b0
callq 0x8a50
movq -0x1d0(%rbp), %rsi
leaq 0xe2c2b(%rip), %rdi     # 0x1030b0
callq 0x8980
movq %rax, -0x1e0(%rbp)
cmpq $0x0, -0x1e0(%rbp)
je 0x2049d
jmp 0x204bc
leaq 0x1e288(%rip), %rdi     # 0x3e72c
leaq 0x1de50(%rip), %rsi     # 0x3e2fb
movl $0x19d, %edx            # imm = 0x19D
leaq 0x1e27c(%rip), %rcx     # 0x3e733
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x87d0
cmpq -0x1d8(%rbp), %rax
jne 0x204d3
jmp 0x204f2
leaq 0x1e02c(%rip), %rdi     # 0x3e506
leaq 0x1de1a(%rip), %rsi     # 0x3e2fb
movl $0x19e, %edx            # imm = 0x19E
leaq 0x1e246(%rip), %rcx     # 0x3e733
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8750
cmpl $0xfe0b, %eax           # imm = 0xFE0B
jne 0x20507
jmp 0x20526
leaq 0x1e241(%rip), %rdi     # 0x3e74f
leaq 0x1dde6(%rip), %rsi     # 0x3e2fb
movl $0x1a1, %edx            # imm = 0x1A1
leaq 0x1e212(%rip), %rcx     # 0x3e733
callq 0x20c0
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
leaq 0xe2b6e(%rip), %rdi     # 0x1030b0
callq 0x88c0
leaq -0x1c8(%rbp), %rdi
leaq 0x1e223(%rip), %rsi     # 0x3e778
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0x81f0
movq %rax, -0x1d0(%rbp)
movl $0x4, %edi
movl $0x3d, %esi
movl $0x3c, %edx
callq 0xa830
movq %rax, -0x1d8(%rbp)
movq -0x1d0(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movq -0x1d8(%rbp), %rcx
movl $0x2, %edi
movl $0x5, %esi
movl $0xfffc, %edx           # imm = 0xFFFC
callq 0x8470
movq -0x1e8(%rbp), %rsi
movq %rax, %rdx
leaq 0xe2aee(%rip), %rdi     # 0x1030b0
callq 0x8a50
movq -0x1d0(%rbp), %rsi
leaq 0xe2adb(%rip), %rdi     # 0x1030b0
callq 0x8980
movq %rax, -0x1e0(%rbp)
cmpq $0x0, -0x1e0(%rbp)
je 0x205ed
jmp 0x2060c
leaq 0x1e138(%rip), %rdi     # 0x3e72c
leaq 0x1dd00(%rip), %rsi     # 0x3e2fb
movl $0x1ae, %edx            # imm = 0x1AE
leaq 0x1e1a8(%rip), %rcx     # 0x3e7af
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8710
cmpl $0x0, %eax
jne 0x2061f
jmp 0x2063e
leaq 0x1e1b0(%rip), %rdi     # 0x3e7d6
leaq 0x1dcce(%rip), %rsi     # 0x3e2fb
movl $0x1af, %edx            # imm = 0x1AF
leaq 0x1e176(%rip), %rcx     # 0x3e7af
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x87d0
cmpq -0x1d8(%rbp), %rax
jne 0x20655
jmp 0x20674
leaq 0x1deaa(%rip), %rdi     # 0x3e506
leaq 0x1dc98(%rip), %rsi     # 0x3e2fb
movl $0x1b0, %edx            # imm = 0x1B0
leaq 0x1e140(%rip), %rcx     # 0x3e7af
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8730
cmpl $0x5, %eax
jne 0x20687
jmp 0x206a6
leaq 0x1e16c(%rip), %rdi     # 0x3e7fa
leaq 0x1dc66(%rip), %rsi     # 0x3e2fb
movl $0x1b1, %edx            # imm = 0x1B1
leaq 0x1e10e(%rip), %rcx     # 0x3e7af
callq 0x20c0
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
leaq 0xe29ee(%rip), %rdi     # 0x1030b0
callq 0x88c0
leaq -0x1c8(%rbp), %rdi
leaq 0x1e142(%rip), %rsi     # 0x3e817
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0x81f0
movq %rax, -0x1d0(%rbp)
movl $0x4, %edi
movl $0x6, %esi
movl $0x5, %edx
callq 0xa830
movq %rax, -0x1d8(%rbp)
movq -0x1d0(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movq -0x1d8(%rbp), %rcx
movl $0x3, %edi
movl $0x5, %esi
movl $0xfff8, %edx           # imm = 0xFFF8
callq 0x8470
movq -0x1e8(%rbp), %rsi
movq %rax, %rdx
leaq 0xe296e(%rip), %rdi     # 0x1030b0
callq 0x8a50
movq -0x1d0(%rbp), %rsi
leaq 0xe295b(%rip), %rdi     # 0x1030b0
callq 0x8980
movq %rax, -0x1e0(%rbp)
cmpq $0x0, -0x1e0(%rbp)
je 0x2076d
jmp 0x2078c
leaq 0x1dfb8(%rip), %rdi     # 0x3e72c
leaq 0x1db80(%rip), %rsi     # 0x3e2fb
movl $0x1be, %edx            # imm = 0x1BE
leaq 0x1e0c5(%rip), %rcx     # 0x3e84c
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8710
cmpl $0x1, %eax
jne 0x2079f
jmp 0x207be
leaq 0x1dcd7(%rip), %rdi     # 0x3e47d
leaq 0x1db4e(%rip), %rsi     # 0x3e2fb
movl $0x1bf, %edx            # imm = 0x1BF
leaq 0x1e093(%rip), %rcx     # 0x3e84c
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x87d0
cmpq -0x1d8(%rbp), %rax
jne 0x207d5
jmp 0x207f4
leaq 0x1dd2a(%rip), %rdi     # 0x3e506
leaq 0x1db18(%rip), %rsi     # 0x3e2fb
movl $0x1c0, %edx            # imm = 0x1C0
leaq 0x1e05d(%rip), %rcx     # 0x3e84c
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8750
cmpl $0xfe0b, %eax           # imm = 0xFE0B
jne 0x20809
jmp 0x20828
leaq 0x1df3f(%rip), %rdi     # 0x3e74f
leaq 0x1dae4(%rip), %rsi     # 0x3e2fb
movl $0x1c1, %edx            # imm = 0x1C1
leaq 0x1e029(%rip), %rcx     # 0x3e84c
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8730
cmpl $0x5, %eax
jne 0x2083b
jmp 0x2085a
leaq 0x1dfb8(%rip), %rdi     # 0x3e7fa
leaq 0x1dab2(%rip), %rsi     # 0x3e2fb
movl $0x1c2, %edx            # imm = 0x1C2
leaq 0x1dff7(%rip), %rcx     # 0x3e84c
callq 0x20c0
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
leaq 0xe282e(%rip), %rdi     # 0x1030b0
callq 0x88c0
leaq -0x1c8(%rbp), %rdi
leaq 0x1dfde(%rip), %rsi     # 0x3e873
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0x81f0
movq %rax, -0x1d0(%rbp)
movl $0x4, %edi
movl $0x3b, %esi
movl $0x38, %edx
callq 0xa830
movq %rax, -0x1d8(%rbp)
movq -0x1d0(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movq -0x1d8(%rbp), %rcx
movl $0x1, %edi
movl $0x8, %esi
movl $0xffff000b, %edx       # imm = 0xFFFF000B
callq 0x8470
movq -0x1e8(%rbp), %rsi
movq %rax, %rdx
leaq 0xe27ae(%rip), %rdi     # 0x1030b0
callq 0x8a50
movq -0x1d0(%rbp), %rsi
leaq 0xe279b(%rip), %rdi     # 0x1030b0
callq 0x8980
movq %rax, -0x1e0(%rbp)
cmpq $0x0, -0x1e0(%rbp)
je 0x2092d
jmp 0x2094c
leaq 0x1ddf8(%rip), %rdi     # 0x3e72c
leaq 0x1d9c0(%rip), %rsi     # 0x3e2fb
movl $0x1cf, %edx            # imm = 0x1CF
leaq 0x1df60(%rip), %rcx     # 0x3e8a7
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8710
cmpl $0x0, %eax
jne 0x2095f
jmp 0x2097e
leaq 0x1de70(%rip), %rdi     # 0x3e7d6
leaq 0x1d98e(%rip), %rsi     # 0x3e2fb
movl $0x1d0, %edx            # imm = 0x1D0
leaq 0x1df2e(%rip), %rcx     # 0x3e8a7
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x87d0
cmpq -0x1d8(%rbp), %rax
jne 0x20995
jmp 0x209b4
leaq 0x1db6a(%rip), %rdi     # 0x3e506
leaq 0x1d958(%rip), %rsi     # 0x3e2fb
movl $0x1d1, %edx            # imm = 0x1D1
leaq 0x1def8(%rip), %rcx     # 0x3e8a7
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8730
cmpl $0x8, %eax
jne 0x209c7
jmp 0x209e6
leaq 0x1df01(%rip), %rdi     # 0x3e8cf
leaq 0x1d926(%rip), %rsi     # 0x3e2fb
movl $0x1d2, %edx            # imm = 0x1D2
leaq 0x1dec6(%rip), %rcx     # 0x3e8a7
callq 0x20c0
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
leaq 0xe26ae(%rip), %rdi     # 0x1030b0
callq 0x88c0
leaq -0x1c8(%rbp), %rdi
leaq 0x1ded7(%rip), %rsi     # 0x3e8ec
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0x81f0
movq %rax, -0x1d0(%rbp)
movl $0x1, %edi
movl $0xe, %esi
movl $0x16, %edx
callq 0xa830
movq %rax, -0x1d8(%rbp)
movq -0x1d0(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movq -0x1d8(%rbp), %rcx
movl $0x3, %edi
movl $0xa, %esi
movl $0xffff0003, %edx       # imm = 0xFFFF0003
callq 0x8470
movq -0x1e8(%rbp), %rsi
movq %rax, %rdx
leaq 0xe262e(%rip), %rdi     # 0x1030b0
callq 0x8a50
movq -0x1d0(%rbp), %rsi
leaq 0xe261b(%rip), %rdi     # 0x1030b0
callq 0x8980
movq %rax, -0x1e0(%rbp)
cmpq $0x0, -0x1e0(%rbp)
je 0x20aad
jmp 0x20acc
leaq 0x1dc78(%rip), %rdi     # 0x3e72c
leaq 0x1d840(%rip), %rsi     # 0x3e2fb
movl $0x1df, %edx            # imm = 0x1DF
leaq 0x1de57(%rip), %rcx     # 0x3e91e
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8710
cmpl $0x2, %eax
jne 0x20adf
jmp 0x20afe
leaq 0x1da3d(%rip), %rdi     # 0x3e523
leaq 0x1d80e(%rip), %rsi     # 0x3e2fb
movl $0x1e0, %edx            # imm = 0x1E0
leaq 0x1de25(%rip), %rcx     # 0x3e91e
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x87d0
cmpq -0x1d8(%rbp), %rax
jne 0x20b15
jmp 0x20b34
leaq 0x1d9ea(%rip), %rdi     # 0x3e506
leaq 0x1d7d8(%rip), %rsi     # 0x3e2fb
movl $0x1e1, %edx            # imm = 0x1E1
leaq 0x1ddef(%rip), %rcx     # 0x3e91e
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8750
cmpl $0xffff01f5, %eax       # imm = 0xFFFF01F5
jne 0x20b49
jmp 0x20b68
leaq 0x1da1a(%rip), %rdi     # 0x3e56a
leaq 0x1d7a4(%rip), %rsi     # 0x3e2fb
movl $0x1e2, %edx            # imm = 0x1E2
leaq 0x1ddbb(%rip), %rcx     # 0x3e91e
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8730
cmpl $0xa, %eax
jne 0x20b7b
jmp 0x20b9a
leaq 0x1ddc4(%rip), %rdi     # 0x3e946
leaq 0x1d772(%rip), %rsi     # 0x3e2fb
movl $0x1e3, %edx            # imm = 0x1E3
leaq 0x1dd89(%rip), %rcx     # 0x3e91e
callq 0x20c0
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
leaq 0xe24ee(%rip), %rdi     # 0x1030b0
callq 0x88c0
leaq -0x1c8(%rbp), %rdi
leaq 0x1dd8f(%rip), %rsi     # 0x3e964
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0x81f0
movq %rax, -0x1d0(%rbp)
movl $0x6, %edi
movl $0x3e, %esi
movl $0x3f, %edx
callq 0xa830
movq %rax, -0x1d8(%rbp)
movq -0x1d0(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movq -0x1d8(%rbp), %rcx
movl $0x2, %edi
movl $0x7, %esi
movl $0xffff0009, %edx       # imm = 0xFFFF0009
callq 0x8470
movq -0x1e8(%rbp), %rsi
movq %rax, %rdx
leaq 0xe246e(%rip), %rdi     # 0x1030b0
callq 0x8a50
movq -0x1d0(%rbp), %rsi
leaq 0xe245b(%rip), %rdi     # 0x1030b0
callq 0x8980
movq %rax, -0x1e0(%rbp)
cmpq $0x0, -0x1e0(%rbp)
je 0x20c6d
jmp 0x20c8c
leaq 0x1dab8(%rip), %rdi     # 0x3e72c
leaq 0x1d680(%rip), %rsi     # 0x3e2fb
movl $0x1f0, %edx            # imm = 0x1F0
leaq 0x1dd17(%rip), %rcx     # 0x3e99e
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8710
cmpl $0x2, %eax
jne 0x20c9f
jmp 0x20cbe
leaq 0x1d87d(%rip), %rdi     # 0x3e523
leaq 0x1d64e(%rip), %rsi     # 0x3e2fb
movl $0x1f1, %edx            # imm = 0x1F1
leaq 0x1dce5(%rip), %rcx     # 0x3e99e
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x87d0
cmpq -0x1d8(%rbp), %rax
jne 0x20cd5
jmp 0x20cf4
leaq 0x1d82a(%rip), %rdi     # 0x3e506
leaq 0x1d618(%rip), %rsi     # 0x3e2fb
movl $0x1f2, %edx            # imm = 0x1F2
leaq 0x1dcaf(%rip), %rcx     # 0x3e99e
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8750
cmpl $0xffff01f5, %eax       # imm = 0xFFFF01F5
jne 0x20d09
jmp 0x20d28
leaq 0x1d85a(%rip), %rdi     # 0x3e56a
leaq 0x1d5e4(%rip), %rsi     # 0x3e2fb
movl $0x1f3, %edx            # imm = 0x1F3
leaq 0x1dc7b(%rip), %rcx     # 0x3e99e
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8730
cmpl $0x7, %eax
jne 0x20d3b
jmp 0x20d5a
leaq 0x1dc84(%rip), %rdi     # 0x3e9c6
leaq 0x1d5b2(%rip), %rsi     # 0x3e2fb
movl $0x1f4, %edx            # imm = 0x1F4
leaq 0x1dc49(%rip), %rcx     # 0x3e99e
callq 0x20c0
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
leaq 0xe232e(%rip), %rdi     # 0x1030b0
callq 0x88c0
leaq -0x1c8(%rbp), %rdi
leaq 0x1dc4e(%rip), %rsi     # 0x3e9e3
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0x81f0
movq %rax, -0x1d0(%rbp)
movl $0x2, %edi
movl $0x1d, %esi
movl $0x23, %edx
callq 0xa830
movq %rax, -0x1d8(%rbp)
movq -0x1d0(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movq -0x1d8(%rbp), %rcx
movl $0x2, %edi
movl $0x4, %esi
movl $0xffffffa3, %edx       # imm = 0xFFFFFFA3
callq 0x8470
movq -0x1e8(%rbp), %rsi
movq %rax, %rdx
leaq 0xe22ae(%rip), %rdi     # 0x1030b0
callq 0x8a50
movq -0x1d0(%rbp), %rsi
leaq 0xe229b(%rip), %rdi     # 0x1030b0
callq 0x8980
movq %rax, -0x1e0(%rbp)
cmpq $0x0, -0x1e0(%rbp)
je 0x20e2d
jmp 0x20e4c
leaq 0x1d8f8(%rip), %rdi     # 0x3e72c
leaq 0x1d4c0(%rip), %rsi     # 0x3e2fb
movl $0x201, %edx            # imm = 0x201
leaq 0x1dbd7(%rip), %rcx     # 0x3ea1e
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8710
cmpl $0x2, %eax
jne 0x20e5f
jmp 0x20e7e
leaq 0x1d6bd(%rip), %rdi     # 0x3e523
leaq 0x1d48e(%rip), %rsi     # 0x3e2fb
movl $0x202, %edx            # imm = 0x202
leaq 0x1dba5(%rip), %rcx     # 0x3ea1e
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x87d0
cmpq -0x1d8(%rbp), %rax
jne 0x20e95
jmp 0x20eb4
leaq 0x1d66a(%rip), %rdi     # 0x3e506
leaq 0x1d458(%rip), %rsi     # 0x3e2fb
movl $0x203, %edx            # imm = 0x203
leaq 0x1db6f(%rip), %rcx     # 0x3ea1e
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8750
cmpl $-0x5d, %eax
jne 0x20ec7
jmp 0x20ee6
leaq 0x1db62(%rip), %rdi     # 0x3ea30
leaq 0x1d426(%rip), %rsi     # 0x3e2fb
movl $0x204, %edx            # imm = 0x204
leaq 0x1db3d(%rip), %rcx     # 0x3ea1e
callq 0x20c0
movq -0x1e0(%rbp), %rdi
callq 0x8730
cmpl $0x4, %eax
jne 0x20ef9
jmp 0x20f18
leaq 0x1db4f(%rip), %rdi     # 0x3ea4f
leaq 0x1d3f4(%rip), %rsi     # 0x3e2fb
movl $0x205, %edx            # imm = 0x205
leaq 0x1db0b(%rip), %rcx     # 0x3ea1e
callq 0x20c0
leaq 0xe2191(%rip), %rdi     # 0x1030b0
callq 0x88c0
movq -0x1d0(%rbp), %rsi
leaq 0xe217e(%rip), %rdi     # 0x1030b0
callq 0x8980
movq %rax, -0x1e0(%rbp)
cmpq $0x0, -0x1e0(%rbp)
jne 0x20f4a
jmp 0x20f69
leaq 0x1d6eb(%rip), %rdi     # 0x3e63c
leaq 0x1d3a3(%rip), %rsi     # 0x3e2fb
movl $0x209, %edx            # imm = 0x209
leaq 0x1daba(%rip), %rcx     # 0x3ea1e
callq 0x20c0
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
callq 0x1d980
callq 0x1e980
callq 0x1f3e0
callq 0x1fa50
callq 0x1fb60
callq 0x1fc60
callq 0x1fe70
callq 0x20180
callq 0x203e0
callq 0x20530
callq 0x206b0
callq 0x20870
callq 0x209f0
callq 0x20bb0
callq 0x20d70
callq 0x20f80
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
xorq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x214e5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
andq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x214c3
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x21(%rbp)
jb 0x214fa
cmpl $0x40, -0x14(%rbp)
setbe %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x21503
jmp 0x21505
jmp 0x21524
leaq 0x1d66c(%rip), %rdi     # 0x3eb78
leaq 0x1d67d(%rip), %rsi     # 0x3eb90
movl $0x18, %edx
leaq 0x1d685(%rip), %rcx     # 0x3eba4
callq 0x20c0
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)