LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/evalp__test.cpp
// Function: test_passed_pawn_wiki_pos()
void test_passed_pawn_wiki_pos() {
    position pos;
    set_pos(&pos,"7k/8/7p/1P2Pp1P/2Pp1PP1/8/8/7K w - -");

    assert(is_passed(&pos,B5,true));
    assert(is_passed(&pos,C4,true));
    assert(is_passed(&pos,D4,false));
    assert(is_passed(&pos,E5,true));

    assert(!is_passed(&pos,F5,false));
    assert(!is_passed(&pos,F4,true));
    assert(!is_passed(&pos,G4,true));
    assert(!is_passed(&pos,H5,true));
    assert(!is_passed(&pos,H6,false));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c703(%rip), %rsi     # 0x2edd6
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
pushq $0x19
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x580e
testb %al, %al
je 0x127bc
leaq 0x8(%rsp), %rdi
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
je 0x127d8
leaq 0x8(%rsp), %rdi
pushq $0x23
popq %rsi
xorl %edx, %edx
callq 0x580e
testb %al, %al
je 0x127f4
leaq 0x8(%rsp), %rdi
pushq $0x1c
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
je 0x12810
leaq 0x8(%rsp), %rdi
pushq $0x1d
popq %rsi
xorl %edx, %edx
callq 0x580e
testb %al, %al
jne 0x12829
leaq 0x8(%rsp), %rdi
pushq $0x25
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
jne 0x12842
leaq 0x8(%rsp), %rdi
pushq $0x26
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
jne 0x1285b
leaq 0x8(%rsp), %rdi
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
jne 0x12874
leaq 0x8(%rsp), %rdi
pushq $0x17
popq %rsi
xorl %edx, %edx
callq 0x580e
testb %al, %al
jne 0x1288d
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1ccf0(%rip), %rdi     # 0x2f4b3
leaq 0x1c570(%rip), %rsi     # 0x2ed3a
leaq 0x1c62a(%rip), %rcx     # 0x2edfb
pushq $0x1e
jmp 0x128a4
leaq 0x1c63d(%rip), %rdi     # 0x2ee1c
leaq 0x1c554(%rip), %rsi     # 0x2ed3a
leaq 0x1c60e(%rip), %rcx     # 0x2edfb
pushq $0x1f
jmp 0x128a4
leaq 0x1c639(%rip), %rdi     # 0x2ee34
leaq 0x1c538(%rip), %rsi     # 0x2ed3a
leaq 0x1c5f2(%rip), %rcx     # 0x2edfb
pushq $0x20
jmp 0x128a4
leaq 0x1c636(%rip), %rdi     # 0x2ee4d
leaq 0x1c51c(%rip), %rsi     # 0x2ed3a
leaq 0x1c5d6(%rip), %rcx     # 0x2edfb
pushq $0x21
jmp 0x128a4
leaq 0x1c635(%rip), %rdi     # 0x2ee65
leaq 0x1c503(%rip), %rsi     # 0x2ed3a
leaq 0x1c5bd(%rip), %rcx     # 0x2edfb
pushq $0x23
jmp 0x128a4
leaq 0x1c636(%rip), %rdi     # 0x2ee7f
leaq 0x1c4ea(%rip), %rsi     # 0x2ed3a
leaq 0x1c5a4(%rip), %rcx     # 0x2edfb
pushq $0x24
jmp 0x128a4
leaq 0x1c636(%rip), %rdi     # 0x2ee98
leaq 0x1c4d1(%rip), %rsi     # 0x2ed3a
leaq 0x1c58b(%rip), %rcx     # 0x2edfb
pushq $0x25
jmp 0x128a4
leaq 0x1c636(%rip), %rdi     # 0x2eeb1
leaq 0x1c4b8(%rip), %rsi     # 0x2ed3a
leaq 0x1c572(%rip), %rcx     # 0x2edfb
pushq $0x26
jmp 0x128a4
leaq 0x1c636(%rip), %rdi     # 0x2eeca
leaq 0x1c49f(%rip), %rsi     # 0x2ed3a
leaq 0x1c559(%rip), %rcx     # 0x2edfb
pushq $0x27
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/evalp__test.cpp
// Function: test_passed_pawn_wiki_pos2()
void test_passed_pawn_wiki_pos2() {
    position pos;
    set_pos(&pos,"8/5ppp/8/5PPP/8/6k1/8/6K1 w - -");

    assert(!is_passed(&pos,F7,false));
    assert(!is_passed(&pos,G7,false));
    assert(!is_passed(&pos,H7,false));
    assert(!is_passed(&pos,F5,true));
    assert(!is_passed(&pos,G5,true));
    assert(!is_passed(&pos,H5,true));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c62b(%rip), %rsi     # 0x2eee4
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
pushq $0xd
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x580e
testb %al, %al
jne 0x12956
leaq 0x8(%rsp), %rdi
pushq $0xe
popq %rsi
xorl %edx, %edx
callq 0x580e
testb %al, %al
jne 0x1296f
leaq 0x8(%rsp), %rdi
pushq $0xf
popq %rsi
xorl %edx, %edx
callq 0x580e
testb %al, %al
jne 0x12988
leaq 0x8(%rsp), %rdi
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
jne 0x129a1
leaq 0x8(%rsp), %rdi
pushq $0x1e
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
jne 0x129ba
leaq 0x8(%rsp), %rdi
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
jne 0x129d3
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c5a7(%rip), %rdi     # 0x2ef04
leaq 0x1c3d6(%rip), %rsi     # 0x2ed3a
leaq 0x1c5b3(%rip), %rcx     # 0x2ef1e
pushq $0x2e
jmp 0x129ea
leaq 0x1c5ca(%rip), %rdi     # 0x2ef40
leaq 0x1c3bd(%rip), %rsi     # 0x2ed3a
leaq 0x1c59a(%rip), %rcx     # 0x2ef1e
pushq $0x2f
jmp 0x129ea
leaq 0x1c5cb(%rip), %rdi     # 0x2ef5a
leaq 0x1c3a4(%rip), %rsi     # 0x2ed3a
leaq 0x1c581(%rip), %rcx     # 0x2ef1e
pushq $0x30
jmp 0x129ea
leaq 0x1c5cc(%rip), %rdi     # 0x2ef74
leaq 0x1c38b(%rip), %rsi     # 0x2ed3a
leaq 0x1c568(%rip), %rcx     # 0x2ef1e
pushq $0x31
jmp 0x129ea
leaq 0x1c5cc(%rip), %rdi     # 0x2ef8d
leaq 0x1c372(%rip), %rsi     # 0x2ed3a
leaq 0x1c54f(%rip), %rcx     # 0x2ef1e
pushq $0x32
jmp 0x129ea
leaq 0x1c4d7(%rip), %rdi     # 0x2eeb1
leaq 0x1c359(%rip), %rsi     # 0x2ed3a
leaq 0x1c536(%rip), %rcx     # 0x2ef1e
pushq $0x33
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/evalp__test.cpp
// Function: test_passed_pawn_wiki_pos3()
void test_passed_pawn_wiki_pos3() {
    position pos;
    set_pos(&pos,"8/8/1PP2PbP/3r4/8/1Q5p/p5N1/k3K3 b - -");

    assert(is_passed(&pos,B6,true));
    assert(is_passed(&pos,C6,true));
    assert(is_passed(&pos,F6,true));
    assert(is_passed(&pos,H6,true));
    assert(is_passed(&pos,A2,false));
    assert(is_passed(&pos,H3,false));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c5a7(%rip), %rsi     # 0x2efa6
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
pushq $0x11
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x580e
testb %al, %al
je 0x12a9d
leaq 0x8(%rsp), %rdi
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
je 0x12ab6
leaq 0x8(%rsp), %rdi
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
je 0x12acf
leaq 0x8(%rsp), %rdi
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
je 0x12ae8
leaq 0x8(%rsp), %rdi
pushq $0x30
popq %rsi
xorl %edx, %edx
callq 0x580e
testb %al, %al
je 0x12b01
leaq 0x8(%rsp), %rdi
pushq $0x2f
popq %rsi
xorl %edx, %edx
callq 0x580e
testb %al, %al
je 0x12b1a
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c529(%rip), %rdi     # 0x2efcd
leaq 0x1c28f(%rip), %rsi     # 0x2ed3a
leaq 0x1c533(%rip), %rcx     # 0x2efe5
pushq $0x3a
jmp 0x12b31
leaq 0x1c54a(%rip), %rdi     # 0x2f007
leaq 0x1c276(%rip), %rsi     # 0x2ed3a
leaq 0x1c51a(%rip), %rcx     # 0x2efe5
pushq $0x3b
jmp 0x12b31
leaq 0x1c549(%rip), %rdi     # 0x2f01f
leaq 0x1c25d(%rip), %rsi     # 0x2ed3a
leaq 0x1c501(%rip), %rcx     # 0x2efe5
pushq $0x3c
jmp 0x12b31
leaq 0x1c548(%rip), %rdi     # 0x2f037
leaq 0x1c244(%rip), %rsi     # 0x2ed3a
leaq 0x1c4e8(%rip), %rcx     # 0x2efe5
pushq $0x3d
jmp 0x12b31
leaq 0x1c547(%rip), %rdi     # 0x2f04f
leaq 0x1c22b(%rip), %rsi     # 0x2ed3a
leaq 0x1c4cf(%rip), %rcx     # 0x2efe5
pushq $0x3e
jmp 0x12b31
leaq 0x1c547(%rip), %rdi     # 0x2f068
leaq 0x1c212(%rip), %rsi     # 0x2ed3a
leaq 0x1c4b6(%rip), %rcx     # 0x2efe5
pushq $0x3f
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/evalp__test.cpp
// Function: test_passed_pawn_wiki_pos4()
void test_passed_pawn_wiki_pos4() {
    position pos;
    set_pos(&pos,"k7/b1P5/KP6/6q1/8/8/8/4n3 b - -");

    assert(is_passed(&pos,B6,true));
    assert(is_passed(&pos,C7,true));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c53b(%rip), %rsi     # 0x2f081
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
pushq $0x11
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x580e
testb %al, %al
je 0x12b82
leaq 0x8(%rsp), %rdi
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
je 0x12b9b
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c444(%rip), %rdi     # 0x2efcd
leaq 0x1c1aa(%rip), %rsi     # 0x2ed3a
leaq 0x1c50a(%rip), %rcx     # 0x2f0a1
pushq $0x46
jmp 0x12bb2
leaq 0x1c521(%rip), %rdi     # 0x2f0c3
leaq 0x1c191(%rip), %rsi     # 0x2ed3a
leaq 0x1c4f1(%rip), %rcx     # 0x2f0a1
pushq $0x47
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/evalp__test.cpp
// Function: test_levinfish_smyslov57()
void test_levinfish_smyslov57() {
    position pos;
    set_pos(&pos,"R7/6k1/P5p1/5p1p/5P1P/r5P1/5K2/8 w - -");

    assert(is_passed(&pos,A6,true));
    assert(!is_passed(&pos,G6,false));
    assert(!is_passed(&pos,F5,false));
    assert(!is_passed(&pos,H5,false));
    assert(!is_passed(&pos,F4,true));
    assert(!is_passed(&pos,H4,true));
    assert(!is_passed(&pos,G3,true));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c514(%rip), %rsi     # 0x2f0db
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x580e
testb %al, %al
je 0x12c80
leaq 0x8(%rsp), %rdi
pushq $0x16
popq %rsi
xorl %edx, %edx
callq 0x580e
testb %al, %al
jne 0x12c9c
leaq 0x8(%rsp), %rdi
pushq $0x1d
popq %rsi
xorl %edx, %edx
callq 0x580e
testb %al, %al
jne 0x12cb5
leaq 0x8(%rsp), %rdi
pushq $0x1f
popq %rsi
xorl %edx, %edx
callq 0x580e
testb %al, %al
jne 0x12cce
leaq 0x8(%rsp), %rdi
pushq $0x25
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
jne 0x12ce7
leaq 0x8(%rsp), %rdi
pushq $0x27
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
jne 0x12d00
leaq 0x8(%rsp), %rdi
pushq $0x2e
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
jne 0x12d19
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c47b(%rip), %rdi     # 0x2f102
leaq 0x1c0ac(%rip), %rsi     # 0x2ed3a
leaq 0x1c485(%rip), %rcx     # 0x2f11a
pushq $0x4e
jmp 0x12d30
leaq 0x1c497(%rip), %rdi     # 0x2f13a
leaq 0x1c090(%rip), %rsi     # 0x2ed3a
leaq 0x1c469(%rip), %rcx     # 0x2f11a
pushq $0x4f
jmp 0x12d30
leaq 0x1c1a9(%rip), %rdi     # 0x2ee65
leaq 0x1c077(%rip), %rsi     # 0x2ed3a
leaq 0x1c450(%rip), %rcx     # 0x2f11a
pushq $0x50
jmp 0x12d30
leaq 0x1c47f(%rip), %rdi     # 0x2f154
leaq 0x1c05e(%rip), %rsi     # 0x2ed3a
leaq 0x1c437(%rip), %rcx     # 0x2f11a
pushq $0x51
jmp 0x12d30
leaq 0x1c191(%rip), %rdi     # 0x2ee7f
leaq 0x1c045(%rip), %rsi     # 0x2ed3a
leaq 0x1c41e(%rip), %rcx     # 0x2f11a
pushq $0x52
jmp 0x12d30
leaq 0x1c467(%rip), %rdi     # 0x2f16e
leaq 0x1c02c(%rip), %rsi     # 0x2ed3a
leaq 0x1c405(%rip), %rcx     # 0x2f11a
pushq $0x53
jmp 0x12d30
leaq 0x1c467(%rip), %rdi     # 0x2f187
leaq 0x1c013(%rip), %rsi     # 0x2ed3a
leaq 0x1c3ec(%rip), %rcx     # 0x2f11a
pushq $0x54
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/evalp__test.cpp
// Function: test_fischer_larsen71()
void test_fischer_larsen71() {
    position pos;
    set_pos(&pos,"8/4kp2/6p1/7p/P7/2K3P1/7P/8 b - -");

    assert(!is_passed(&pos,F7,false));
    assert(!is_passed(&pos,G6,false));
    assert(!is_passed(&pos,H5,false));
    assert(is_passed(&pos,A4,true));
    assert(!is_passed(&pos,G3,true));
    assert(!is_passed(&pos,H2,true));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1c45b(%rip), %rsi     # 0x2f1a0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
pushq $0xd
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x580e
testb %al, %al
jne 0x12de2
leaq 0x8(%rsp), %rdi
pushq $0x16
popq %rsi
xorl %edx, %edx
callq 0x580e
testb %al, %al
jne 0x12dfb
leaq 0x8(%rsp), %rdi
pushq $0x1f
popq %rsi
xorl %edx, %edx
callq 0x580e
testb %al, %al
jne 0x12e14
leaq 0x8(%rsp), %rdi
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
je 0x12e2d
leaq 0x8(%rsp), %rdi
pushq $0x2e
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
jne 0x12e46
leaq 0x8(%rsp), %rdi
pushq $0x37
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
jne 0x12e5f
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c11b(%rip), %rdi     # 0x2ef04
leaq 0x1bf4a(%rip), %rsi     # 0x2ed3a
leaq 0x1c3cb(%rip), %rcx     # 0x2f1c2
pushq $0x5b
jmp 0x12e76
leaq 0x1c338(%rip), %rdi     # 0x2f13a
leaq 0x1bf31(%rip), %rsi     # 0x2ed3a
leaq 0x1c3b2(%rip), %rcx     # 0x2f1c2
pushq $0x5c
jmp 0x12e76
leaq 0x1c339(%rip), %rdi     # 0x2f154
leaq 0x1bf18(%rip), %rsi     # 0x2ed3a
leaq 0x1c399(%rip), %rcx     # 0x2f1c2
pushq $0x5d
jmp 0x12e76
leaq 0x1c3ab(%rip), %rdi     # 0x2f1df
leaq 0x1beff(%rip), %rsi     # 0x2ed3a
leaq 0x1c380(%rip), %rcx     # 0x2f1c2
pushq $0x5e
jmp 0x12e76
leaq 0x1c33a(%rip), %rdi     # 0x2f187
leaq 0x1bee6(%rip), %rsi     # 0x2ed3a
leaq 0x1c367(%rip), %rcx     # 0x2f1c2
pushq $0x5f
jmp 0x12e76
leaq 0x1c391(%rip), %rdi     # 0x2f1f7
leaq 0x1becd(%rip), %rsi     # 0x2ed3a
leaq 0x1c34e(%rip), %rcx     # 0x2f1c2
pushq $0x60
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1c151(%rip), %rsi     # 0x2f484
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
pushq $0x19
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x580e
testb %al, %al
jne 0x133d7
leaq 0x8(%rsp), %rdi
pushq $0x19
popq %rsi
pushq $0x1
popq %rdx
callq 0x5866
testb %al, %al
je 0x133f6
leaq 0x8(%rsp), %rdi
pushq $0x19
popq %rsi
pushq $0x1
popq %rdx
callq 0x58e2
testb %al, %al
jne 0x13415
leaq 0x8(%rsp), %rdi
pushq $0x21
popq %rsi
pushq $0x1
popq %rdx
callq 0x580e
testb %al, %al
jne 0x13434
leaq 0x8(%rsp), %rdi
pushq $0x21
popq %rsi
pushq $0x1
popq %rdx
callq 0x5866
testb %al, %al
je 0x13453
leaq 0x8(%rsp), %rdi
pushq $0x21
popq %rsi
pushq $0x1
popq %rdx
callq 0x58e2
testb %al, %al
jne 0x13472
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1c0d4(%rip), %rdi     # 0x2f4b2
leaq 0x1b955(%rip), %rsi     # 0x2ed3a
leaq 0x1c0df(%rip), %rcx     # 0x2f4cb
movl $0x8d, %edx
callq 0x20c0
leaq 0x1c0e2(%rip), %rdi     # 0x2f4df
leaq 0x1b936(%rip), %rsi     # 0x2ed3a
leaq 0x1c0c0(%rip), %rcx     # 0x2f4cb
movl $0x8e, %edx
callq 0x20c0
leaq 0x1c0dc(%rip), %rdi     # 0x2f4f8
leaq 0x1b917(%rip), %rsi     # 0x2ed3a
leaq 0x1c0a1(%rip), %rcx     # 0x2f4cb
movl $0x8f, %edx
callq 0x20c0
leaq 0x1c0d8(%rip), %rdi     # 0x2f513
leaq 0x1b8f8(%rip), %rsi     # 0x2ed3a
leaq 0x1c082(%rip), %rcx     # 0x2f4cb
movl $0x91, %edx
callq 0x20c0
leaq 0x1c0d2(%rip), %rdi     # 0x2f52c
leaq 0x1b8d9(%rip), %rsi     # 0x2ed3a
leaq 0x1c063(%rip), %rcx     # 0x2f4cb
movl $0x92, %edx
callq 0x20c0
leaq 0x1c0cc(%rip), %rdi     # 0x2f545
leaq 0x1b8ba(%rip), %rsi     # 0x2ed3a
leaq 0x1c044(%rip), %rcx     # 0x2f4cb
movl $0x93, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x125f0
callq 0x126c4
callq 0x128aa
callq 0x129f0
callq 0x12b37
callq 0x12bb8
callq 0x12d36
callq 0x12e7c
callq 0x13093
popq %rax
jmp 0x13324
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa187
pushq $0x1
popq %rdi
pushq $0x34
popq %rsi
pushq $0x24
popq %rdx
callq 0x7284
movq %rax, %r14
leaq 0xb85fb(%rip), %rdx     # 0xcbaf0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2fa5
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x59f8
testl %eax, %eax
jne 0x1351c
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x1c03d(%rip), %rdi     # 0x2f560
leaq 0x1c051(%rip), %rsi     # 0x2f57b
leaq 0x1c060(%rip), %rcx     # 0x2f591
pushq $0x15
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb38, %rsp            # imm = 0xB38
leaq 0x1c05d(%rip), %rsi     # 0x2f5aa
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
leaq 0x1d0(%rsp), %r14
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x73f8
movq %rax, %rbx
pushq $0xa
popq %rsi
pushq $0x2
popq %rdx
movl %ebp, %edi
callq 0x7284
movq %rsp, %r15
movq %rax, (%r15)
pushq $0x5
popq %rsi
movq %r15, %rdi
callq 0x733b
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x135e1
movq (%rsp), %rsi
leaq 0xb853e(%rip), %rdx     # 0xcbaf0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2fa5
movq (%rsp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x59f8
cmpl $0x1, %eax
jne 0x135fa
addq $0xb38, %rsp            # imm = 0xB38
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bfe2(%rip), %rdi     # 0x2f5ca
leaq 0x1bf8c(%rip), %rsi     # 0x2f57b
leaq 0x1bff6(%rip), %rcx     # 0x2f5ec
pushq $0x22
jmp 0x13611
leaq 0x1c008(%rip), %rdi     # 0x2f609
leaq 0x1bf73(%rip), %rsi     # 0x2f57b
leaq 0x1bfdd(%rip), %rcx     # 0x2f5ec
pushq $0x26
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xb38, %rsp            # imm = 0xB38
leaq 0x1bf7f(%rip), %rsi     # 0x2f5aa
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
leaq 0x1d0(%rsp), %r14
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x73f8
movq %rax, %r15
pushq $0x11
popq %rsi
pushq $0x9
popq %rdx
movl %ebp, %edi
callq 0x7284
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xdacb
testb %al, %al
je 0x136af
leaq 0xb8472(%rip), %rdx     # 0xcbaf0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fa5
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x59f8
cmpl $0x1, %eax
jne 0x136c8
addq $0xb38, %rsp            # imm = 0xB38
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bf6e(%rip), %rdi     # 0x2f624
leaq 0x1bebe(%rip), %rsi     # 0x2f57b
leaq 0x1bf81(%rip), %rcx     # 0x2f645
pushq $0x32
jmp 0x136df
leaq 0x1bf94(%rip), %rdi     # 0x2f663
leaq 0x1bea5(%rip), %rsi     # 0x2f57b
leaq 0x1bf68(%rip), %rcx     # 0x2f645
pushq $0x35
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xb38, %rsp            # imm = 0xB38
leaq 0x1bf84(%rip), %rsi     # 0x2f67d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
leaq 0x1d0(%rsp), %r14
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x73f8
movq %rax, %r15
pushq $0xe
popq %rsi
pushq $0x16
popq %rdx
movl %ebp, %edi
callq 0x7284
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xdacb
testb %al, %al
je 0x1377b
leaq 0xb83a4(%rip), %rdx     # 0xcbaf0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fa5
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x59f8
testl %eax, %eax
jne 0x13794
addq $0xb38, %rsp            # imm = 0xB38
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bf1b(%rip), %rdi     # 0x2f69d
leaq 0x1bdf2(%rip), %rsi     # 0x2f57b
leaq 0x1bf2e(%rip), %rcx     # 0x2f6be
pushq $0x41
jmp 0x137ab
leaq 0x1bf3b(%rip), %rdi     # 0x2f6d6
leaq 0x1bdd9(%rip), %rsi     # 0x2f57b
leaq 0x1bf15(%rip), %rcx     # 0x2f6be
pushq $0x44
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b7e2(%rip), %rsi     # 0x2efa6
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
leaq 0x1d0(%rsp), %r14
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
movl %ecx, %edx
callq 0x73f8
movq %rax, %r15
pushq $0x4
popq %rdi
pushq $0x1b
popq %rsi
pushq $0x23
popq %rdx
callq 0x7284
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xdacb
testb %al, %al
je 0x13844
leaq 0xb82da(%rip), %rdx     # 0xcbaf0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fa5
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x59f8
testl %eax, %eax
jne 0x1385d
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1bea6(%rip), %rdi     # 0x2f6f1
leaq 0x1bd29(%rip), %rsi     # 0x2f57b
leaq 0x1beb9(%rip), %rcx     # 0x2f712
pushq $0x50
jmp 0x13874
leaq 0x1bec7(%rip), %rdi     # 0x2f72b
leaq 0x1bd10(%rip), %rsi     # 0x2f57b
leaq 0x1bea0(%rip), %rcx     # 0x2f712
pushq $0x52
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xb38, %rsp            # imm = 0xB38
leaq 0x1b718(%rip), %rsi     # 0x2efa6
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
leaq 0x1d0(%rsp), %r14
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x73f8
movq %rax, %r15
pushq $0x2f
popq %rsi
pushq $0x37
popq %rdx
movl %ebp, %edi
callq 0x7284
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xdacb
testb %al, %al
je 0x13911
leaq 0xb820f(%rip), %rdx     # 0xcbaf0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fa5
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x59f8
cmpl $0x1, %eax
jne 0x1392a
addq $0xb38, %rsp            # imm = 0xB38
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1be2e(%rip), %rdi     # 0x2f746
leaq 0x1bc5c(%rip), %rsi     # 0x2f57b
leaq 0x1be41(%rip), %rcx     # 0x2f767
pushq $0x5e
jmp 0x13941
leaq 0x1be54(%rip), %rdi     # 0x2f785
leaq 0x1bc43(%rip), %rsi     # 0x2f57b
leaq 0x1be28(%rip), %rcx     # 0x2f767
pushq $0x60
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xb38, %rsp            # imm = 0xB38
leaq 0x1be45(%rip), %rsi     # 0x2f7a0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
leaq 0x1d0(%rsp), %r14
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x73f8
movq %rax, %r15
pushq $0x20
popq %rsi
pushq $0x18
popq %rdx
movl %ebp, %edi
callq 0x7284
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xdacb
testb %al, %al
je 0x139dd
leaq 0xb8142(%rip), %rdx     # 0xcbaf0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fa5
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x59f8
testl %eax, %eax
jne 0x139f6
addq $0xb38, %rsp            # imm = 0xB38
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bdde(%rip), %rdi     # 0x2f7c2
leaq 0x1bb90(%rip), %rsi     # 0x2f57b
leaq 0x1bdf1(%rip), %rcx     # 0x2f7e3
pushq $0x6d
jmp 0x13a0d
leaq 0x1bdff(%rip), %rdi     # 0x2f7fc
leaq 0x1bb77(%rip), %rsi     # 0x2f57b
leaq 0x1bdd8(%rip), %rcx     # 0x2f7e3
pushq $0x6f
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xb38, %rsp            # imm = 0xB38
leaq 0x1b779(%rip), %rsi     # 0x2f1a0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
leaq 0x1d0(%rsp), %r14
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x73f8
movq %rax, %r15
pushq $0xd
popq %rsi
pushq $0x15
popq %rdx
movl %ebp, %edi
callq 0x7284
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xdacb
testb %al, %al
je 0x13aa9
leaq 0xb8076(%rip), %rdx     # 0xcbaf0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fa5
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x59f8
testl %eax, %eax
jne 0x13ac2
addq $0xb38, %rsp            # imm = 0xB38
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bd67(%rip), %rdi     # 0x2f817
leaq 0x1bac4(%rip), %rsi     # 0x2f57b
leaq 0x1bd7a(%rip), %rcx     # 0x2f838
pushq $0x7b
jmp 0x13ad9
leaq 0x1bd88(%rip), %rdi     # 0x2f851
leaq 0x1baab(%rip), %rsi     # 0x2f57b
leaq 0x1bd61(%rip), %rcx     # 0x2f838
pushq $0x7d
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xb38, %rsp            # imm = 0xB38
leaq 0x1bd79(%rip), %rsi     # 0x2f86c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
leaq 0x1d0(%rsp), %r14
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x73f8
movq %rax, %r15
pushq $0x8
popq %rsi
pushq $0x10
popq %rdx
movl %ebp, %edi
callq 0x7284
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xdacb
testb %al, %al
je 0x13b75
leaq 0xb7faa(%rip), %rdx     # 0xcbaf0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fa5
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x59f8
testl %eax, %eax
jne 0x13b94
addq $0xb38, %rsp            # imm = 0xB38
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bd22(%rip), %rdi     # 0x2f89e
leaq 0x1b9f8(%rip), %rsi     # 0x2f57b
leaq 0x1bd35(%rip), %rcx     # 0x2f8bf
movl $0x89, %edx
callq 0x20c0
leaq 0x1bd3d(%rip), %rdi     # 0x2f8d8
leaq 0x1b9d9(%rip), %rsi     # 0x2f57b
leaq 0x1bd16(%rip), %rcx     # 0x2f8bf
movl $0x8b, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xb38, %rsp            # imm = 0xB38
leaq 0x1bca5(%rip), %rsi     # 0x2f86c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
leaq 0x1d0(%rsp), %r14
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x73f8
movq %rax, %r15
pushq $0x11
popq %rsi
pushq $0x19
popq %rdx
movl %ebp, %edi
callq 0x7284
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xdacb
testb %al, %al
je 0x13c49
leaq 0xb7ed6(%rip), %rdx     # 0xcbaf0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fa5
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x59f8
testl %eax, %eax
jne 0x13c68
addq $0xb38, %rsp            # imm = 0xB38
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bca3(%rip), %rdi     # 0x2f8f3
leaq 0x1b924(%rip), %rsi     # 0x2f57b
leaq 0x1bcb6(%rip), %rcx     # 0x2f914
movl $0x96, %edx
callq 0x20c0
leaq 0x1bcbe(%rip), %rdi     # 0x2f92d
leaq 0x1b905(%rip), %rsi     # 0x2f57b
leaq 0x1bc97(%rip), %rcx     # 0x2f914
movl $0x98, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xb38, %rsp            # imm = 0xB38
leaq 0x1bcad(%rip), %rsi     # 0x2f948
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
pushq $0x25
popq %rsi
pushq $0x1c
popq %rdx
pushq $0x1
popq %rbp
movl %ebp, %edi
movl %ebp, %ecx
callq 0x72a3
movq %rax, %r14
leaq 0x1d0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x73f8
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xdacb
testb %al, %al
je 0x13d88
leaq 0xb7dfc(%rip), %rdx     # 0xcbaf0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2fa5
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x59f8
testl %eax, %eax
jne 0x13da7
leaq 0xb7dd0(%rip), %rsi     # 0xcbaf0
leaq 0x8(%rsp), %rdi
callq 0x31f8
pushq $0x1
popq %rdi
pushq $0x25
popq %rsi
pushq $0x1d
popq %rdx
callq 0x7284
movq %rax, %r14
leaq 0x1d0(%rsp), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x13dc6
leaq 0xb7d97(%rip), %rdx     # 0xcbaf0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2fa5
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x59f8
testl %eax, %eax
jne 0x13de5
addq $0xb38, %rsp            # imm = 0xB38
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bbd7(%rip), %rdi     # 0x2f966
leaq 0x1b7e5(%rip), %rsi     # 0x2f57b
leaq 0x1bbea(%rip), %rcx     # 0x2f987
movl $0xa4, %edx
callq 0x20c0
leaq 0x1bbff(%rip), %rdi     # 0x2f9ad
leaq 0x1b7c6(%rip), %rsi     # 0x2f57b
leaq 0x1bbcb(%rip), %rcx     # 0x2f987
movl $0xa7, %edx
callq 0x20c0
leaq 0x1bbfb(%rip), %rdi     # 0x2f9c8
leaq 0x1b7a7(%rip), %rsi     # 0x2f57b
leaq 0x1bbac(%rip), %rcx     # 0x2f987
movl $0xab, %edx
callq 0x20c0
leaq 0x1bbfd(%rip), %rdi     # 0x2f9e9
leaq 0x1b788(%rip), %rsi     # 0x2f57b
leaq 0x1bb8d(%rip), %rcx     # 0x2f987
movl $0xae, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1bbeb(%rip), %rsi     # 0x2fa04
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa1b8
pushq $0x23
popq %rsi
pushq $0x1b
popq %rdx
pushq $0x4
popq %rcx
movl %ecx, %edi
callq 0x72a3
movq %rax, %rbx
leaq 0xb30(%rsp), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movl %ecx, %edx
callq 0x73f8
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xdacb
testb %al, %al
je 0x13eda
leaq 0xb7c86(%rip), %rdx     # 0xcbaf0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fa5
pushq $0x2b
popq %rsi
pushq $0x1b
popq %rdx
pushq $0x4
popq %rcx
movl %ecx, %edi
callq 0x72a3
movq %rax, %r15
leaq 0x1d0(%rsp), %r12
pushq $0x1
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
movl %ecx, %edx
callq 0x73f8
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xdacb
testb %al, %al
je 0x13ef9
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x59f8
cmpl $0x1, %eax
jne 0x13f18
addq $0x1498, %rsp           # imm = 0x1498
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1bb42(%rip), %rdi     # 0x2fa23
leaq 0x1b693(%rip), %rsi     # 0x2f57b
leaq 0x1bb55(%rip), %rcx     # 0x2fa44
movl $0xba, %edx
callq 0x20c0
leaq 0x1bb5a(%rip), %rdi     # 0x2fa5a
leaq 0x1b674(%rip), %rsi     # 0x2f57b
leaq 0x1bb36(%rip), %rcx     # 0x2fa44
movl $0xc1, %edx
callq 0x20c0
leaq 0x1bb5e(%rip), %rdi     # 0x2fa7d
leaq 0x1b655(%rip), %rsi     # 0x2f57b
leaq 0x1bb17(%rip), %rcx     # 0x2fa44
movl $0xc3, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1bb4e(%rip), %rsi     # 0x2fa98
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa1b8
pushq $0x23
popq %rsi
pushq $0x1b
popq %rdx
pushq $0x4
popq %rcx
movl %ecx, %edi
callq 0x72a3
movq %rax, %rbx
leaq 0xb30(%rsp), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movl %ecx, %edx
callq 0x73f8
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xdacb
testb %al, %al
je 0x1400a
leaq 0xb7b55(%rip), %rdx     # 0xcbaf0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fa5
pushq $0x5
popq %rdi
pushq $0x2b
popq %rsi
pushq $0x1b
popq %rdx
pushq $0x4
popq %rcx
callq 0x72a3
movq %rax, %rbx
leaq 0x1d0(%rsp), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movl %ecx, %edx
callq 0x73f8
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xdacb
testb %al, %al
je 0x14029
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x59f8
cmpl $0x1, %eax
jne 0x14048
addq $0x1490, %rsp           # imm = 0x1490
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1ba12(%rip), %rdi     # 0x2fa23
leaq 0x1b563(%rip), %rsi     # 0x2f57b
leaq 0x1ba98(%rip), %rcx     # 0x2fab7
movl $0xcf, %edx
callq 0x20c0
leaq 0x1ba2a(%rip), %rdi     # 0x2fa5a
leaq 0x1b544(%rip), %rsi     # 0x2f57b
leaq 0x1ba79(%rip), %rcx     # 0x2fab7
movl $0xd6, %edx
callq 0x20c0
leaq 0x1ba7f(%rip), %rdi     # 0x2face
leaq 0x1b525(%rip), %rsi     # 0x2f57b
leaq 0x1ba5a(%rip), %rcx     # 0x2fab7
movl $0xd8, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ba6f(%rip), %rsi     # 0x2fae9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa1b8
pushq $0x4
popq %rdi
pushq $0x23
popq %rsi
pushq $0x1b
popq %rdx
pushq $0x3
popq %rcx
callq 0x72a3
movq %rax, %rbx
leaq 0xb30(%rsp), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movl %ecx, %edx
callq 0x73f8
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xdacb
testb %al, %al
je 0x1413a
leaq 0xb7a24(%rip), %rdx     # 0xcbaf0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fa5
pushq $0x5
popq %rdi
pushq $0x2b
popq %rsi
pushq $0x1b
popq %rdx
pushq $0x4
popq %rcx
callq 0x72a3
movq %rax, %rbx
leaq 0x1d0(%rsp), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movl %ecx, %edx
callq 0x73f8
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xdacb
testb %al, %al
je 0x14159
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x59f8
testl %eax, %eax
jne 0x14178
addq $0x1490, %rsp           # imm = 0x1490
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1b8e2(%rip), %rdi     # 0x2fa23
leaq 0x1b433(%rip), %rsi     # 0x2f57b
leaq 0x1b9b9(%rip), %rcx     # 0x2fb08
movl $0xe4, %edx
callq 0x20c0
leaq 0x1b8fa(%rip), %rdi     # 0x2fa5a
leaq 0x1b414(%rip), %rsi     # 0x2f57b
leaq 0x1b99a(%rip), %rcx     # 0x2fb08
movl $0xeb, %edx
callq 0x20c0
leaq 0x1b9a0(%rip), %rdi     # 0x2fb1f
leaq 0x1b3f5(%rip), %rsi     # 0x2f57b
leaq 0x1b97b(%rip), %rcx     # 0x2fb08
movl $0xed, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
pushq $0x1
popq %rbp
pushq $0x34
popq %rsi
pushq $0x24
popq %rdx
movl %ebp, %edi
callq 0x7284
movq %rax, %rbx
pushq $0xe
popq %rsi
pushq $-0x6d
popq %rdx
movl %ebp, %edi
movq %rax, %rcx
callq 0x5b8a
movq %rax, %r14
movq %rax, %rdi
callq 0x5d09
cmpl $0x1, %eax
jne 0x15835
movq %r14, %rdi
callq 0x5d10
cmpl $0xe, %eax
jne 0x15854
movq %r14, %rdi
callq 0x5d17
cmpl $-0x6d, %eax
jne 0x15873
movq %r14, %rdi
callq 0x5d41
cmpq %rbx, %rax
jne 0x15892
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1a49b(%rip), %rdi     # 0x2fcd7
leaq 0x1a312(%rip), %rsi     # 0x2fb55
leaq 0x1a4b3(%rip), %rcx     # 0x2fcfd
movl $0x12e, %edx            # imm = 0x12E
callq 0x20c0
leaq 0x1a4c3(%rip), %rdi     # 0x2fd1e
leaq 0x1a2f3(%rip), %rsi     # 0x2fb55
leaq 0x1a494(%rip), %rcx     # 0x2fcfd
movl $0x12f, %edx            # imm = 0x12F
callq 0x20c0
leaq 0x1a4c5(%rip), %rdi     # 0x2fd3f
leaq 0x1a2d4(%rip), %rsi     # 0x2fb55
leaq 0x1a475(%rip), %rcx     # 0x2fcfd
movl $0x130, %edx            # imm = 0x130
callq 0x20c0
leaq 0x1a4c7(%rip), %rdi     # 0x2fd60
leaq 0x1a2b5(%rip), %rsi     # 0x2fb55
leaq 0x1a456(%rip), %rcx     # 0x2fcfd
movl $0x131, %edx            # imm = 0x131
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x2
popq %rdi
pushq $0x2d
popq %rsi
movl $0xffff0001, %edx       # imm = 0xFFFF0001
xorl %ecx, %ecx
callq 0x5b8a
movq %rax, %rbx
movq %rax, %rdi
callq 0x5d09
cmpl $0x2, %eax
jne 0x158ff
movq %rbx, %rdi
callq 0x5d10
cmpl $0x2d, %eax
jne 0x1591e
movq %rbx, %rdi
callq 0x5d17
cmpl $0xffff01f5, %eax       # imm = 0xFFFF01F5
jne 0x1593d
movq %rbx, %rdi
callq 0x5d41
testq %rax, %rax
jne 0x1595c
popq %rbx
retq
leaq 0x1a477(%rip), %rdi     # 0x2fd7d
leaq 0x1a248(%rip), %rsi     # 0x2fb55
leaq 0x1a48f(%rip), %rcx     # 0x2fda3
movl $0x139, %edx            # imm = 0x139
callq 0x20c0
leaq 0x1a3f9(%rip), %rdi     # 0x2fd1e
leaq 0x1a229(%rip), %rsi     # 0x2fb55
leaq 0x1a470(%rip), %rcx     # 0x2fda3
movl $0x13a, %edx            # imm = 0x13A
callq 0x20c0
leaq 0x1a480(%rip), %rdi     # 0x2fdc4
leaq 0x1a20a(%rip), %rsi     # 0x2fb55
leaq 0x1a451(%rip), %rcx     # 0x2fda3
movl $0x13b, %edx            # imm = 0x13B
callq 0x20c0
leaq 0x1a3fd(%rip), %rdi     # 0x2fd60
leaq 0x1a1eb(%rip), %rsi     # 0x2fb55
leaq 0x1a432(%rip), %rcx     # 0x2fda3
movl $0x13c, %edx            # imm = 0x13C
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0xe4f0f(%rip), %rbx     # 0xfaef0
movq %rbx, %rdi
callq 0x5dd9
leaq 0x19f67(%rip), %rsi     # 0x2ff57
movq %rsp, %r14
movq %r14, %rdi
callq 0xa1b8
movq %r14, %rdi
callq 0x5a50
movq %rax, %r15
pushq $0x1
popq %rbp
pushq $0x12
popq %rsi
pushq $0x22
popq %rdx
movl %ebp, %edi
callq 0x7284
movq %rax, %r14
pushq $0x5
popq %rsi
movl %ebp, %edi
movl $0xfffc, %edx           # imm = 0xFFFC
movq %rax, %rcx
callq 0x5b8a
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5e8b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5e2e
testq %rax, %rax
je 0x16076
movq %rax, %rbx
movq %rax, %rdi
callq 0x5d41
cmpq %r14, %rax
jne 0x16095
movq %rbx, %rdi
callq 0x5d17
cmpl $0xfe0b, %eax           # imm = 0xFE0B
jne 0x160b4
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19f09(%rip), %rdi     # 0x2ff86
leaq 0x19ad1(%rip), %rsi     # 0x2fb55
leaq 0x19f02(%rip), %rcx     # 0x2ff8d
movl $0x19d, %edx            # imm = 0x19D
callq 0x20c0
leaq 0x19cc4(%rip), %rdi     # 0x2fd60
leaq 0x19ab2(%rip), %rsi     # 0x2fb55
leaq 0x19ee3(%rip), %rcx     # 0x2ff8d
movl $0x19e, %edx            # imm = 0x19E
callq 0x20c0
leaq 0x19eee(%rip), %rdi     # 0x2ffa9
leaq 0x19a93(%rip), %rsi     # 0x2fb55
leaq 0x19ec4(%rip), %rcx     # 0x2ff8d
movl $0x1a1, %edx            # imm = 0x1A1
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe4e0a(%rip), %rbx     # 0xfaef0
movq %rbx, %rdi
callq 0x5dd9
leaq 0x19edd(%rip), %rsi     # 0x2ffd2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa1b8
movq %r14, %rdi
callq 0x5a50
movq %rax, %r15
pushq $0x4
popq %rdi
pushq $0x3d
popq %rsi
pushq $0x3c
popq %rdx
callq 0x7284
movq %rax, %r14
pushq $0x2
popq %rdi
pushq $0x5
popq %rsi
movl $0xfffc, %edx           # imm = 0xFFFC
movq %rax, %rcx
callq 0x5b8a
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5e8b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5e2e
testq %rax, %rax
je 0x16185
movq %rax, %rbx
movq %rax, %rdi
callq 0x5d09
testl %eax, %eax
jne 0x161a4
movq %rbx, %rdi
callq 0x5d41
cmpq %r14, %rax
jne 0x161c3
movq %rbx, %rdi
callq 0x5d10
cmpl $0x5, %eax
jne 0x161e2
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x19dfa(%rip), %rdi     # 0x2ff86
leaq 0x199c2(%rip), %rsi     # 0x2fb55
leaq 0x19e6f(%rip), %rcx     # 0x30009
movl $0x1ae, %edx            # imm = 0x1AE
callq 0x20c0
leaq 0x19e85(%rip), %rdi     # 0x30030
leaq 0x199a3(%rip), %rsi     # 0x2fb55
leaq 0x19e50(%rip), %rcx     # 0x30009
movl $0x1af, %edx            # imm = 0x1AF
callq 0x20c0
leaq 0x19b96(%rip), %rdi     # 0x2fd60
leaq 0x19984(%rip), %rsi     # 0x2fb55
leaq 0x19e31(%rip), %rcx     # 0x30009
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x20c0
leaq 0x19e6b(%rip), %rdi     # 0x30054
leaq 0x19965(%rip), %rsi     # 0x2fb55
leaq 0x19e12(%rip), %rcx     # 0x30009
movl $0x1b1, %edx            # imm = 0x1B1
callq 0x20c0