LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d5a3(%rip), %rsi     # 0x30da6
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rbx, %rdi
movl $0x19, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
je 0x1390a
leaq 0x8(%rsp), %rdi
movl $0x22, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
je 0x13929
leaq 0x8(%rsp), %rdi
movl $0x23, %esi
xorl %edx, %edx
callq 0x5bee
testb %al, %al
je 0x13948
leaq 0x8(%rsp), %rdi
movl $0x1c, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
je 0x13967
leaq 0x8(%rsp), %rdi
movl $0x1d, %esi
xorl %edx, %edx
callq 0x5bee
testb %al, %al
jne 0x13986
leaq 0x8(%rsp), %rdi
movl $0x25, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
jne 0x139a5
leaq 0x8(%rsp), %rdi
movl $0x26, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
jne 0x139c4
leaq 0x8(%rsp), %rdi
movl $0x1f, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
jne 0x139e3
leaq 0x8(%rsp), %rdi
movl $0x17, %esi
xorl %edx, %edx
callq 0x5bee
testb %al, %al
jne 0x13a02
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1db72(%rip), %rdi     # 0x31483
leaq 0x1d3f2(%rip), %rsi     # 0x30d0a
leaq 0x1d4ac(%rip), %rcx     # 0x30dcb
movl $0x1e, %edx
callq 0x20d0
leaq 0x1d4bc(%rip), %rdi     # 0x30dec
leaq 0x1d3d3(%rip), %rsi     # 0x30d0a
leaq 0x1d48d(%rip), %rcx     # 0x30dcb
movl $0x1f, %edx
callq 0x20d0
leaq 0x1d4b5(%rip), %rdi     # 0x30e04
leaq 0x1d3b4(%rip), %rsi     # 0x30d0a
leaq 0x1d46e(%rip), %rcx     # 0x30dcb
movl $0x20, %edx
callq 0x20d0
leaq 0x1d4af(%rip), %rdi     # 0x30e1d
leaq 0x1d395(%rip), %rsi     # 0x30d0a
leaq 0x1d44f(%rip), %rcx     # 0x30dcb
movl $0x21, %edx
callq 0x20d0
leaq 0x1d4a8(%rip), %rdi     # 0x30e35
leaq 0x1d376(%rip), %rsi     # 0x30d0a
leaq 0x1d430(%rip), %rcx     # 0x30dcb
movl $0x23, %edx
callq 0x20d0
leaq 0x1d4a3(%rip), %rdi     # 0x30e4f
leaq 0x1d357(%rip), %rsi     # 0x30d0a
leaq 0x1d411(%rip), %rcx     # 0x30dcb
movl $0x24, %edx
callq 0x20d0
leaq 0x1d49d(%rip), %rdi     # 0x30e68
leaq 0x1d338(%rip), %rsi     # 0x30d0a
leaq 0x1d3f2(%rip), %rcx     # 0x30dcb
movl $0x25, %edx
callq 0x20d0
leaq 0x1d497(%rip), %rdi     # 0x30e81
leaq 0x1d319(%rip), %rsi     # 0x30d0a
leaq 0x1d3d3(%rip), %rcx     # 0x30dcb
movl $0x26, %edx
callq 0x20d0
leaq 0x1d491(%rip), %rdi     # 0x30e9a
leaq 0x1d2fa(%rip), %rsi     # 0x30d0a
leaq 0x1d3b4(%rip), %rcx     # 0x30dcb
movl $0x27, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d484(%rip), %rsi     # 0x30eb4
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rbx, %rdi
movl $0xd, %esi
xorl %edx, %edx
callq 0x5bee
testb %al, %al
jne 0x13ae3
leaq 0x8(%rsp), %rdi
movl $0xe, %esi
xorl %edx, %edx
callq 0x5bee
testb %al, %al
jne 0x13b02
leaq 0x8(%rsp), %rdi
movl $0xf, %esi
xorl %edx, %edx
callq 0x5bee
testb %al, %al
jne 0x13b21
leaq 0x8(%rsp), %rdi
movl $0x1d, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
jne 0x13b40
leaq 0x8(%rsp), %rdi
movl $0x1e, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
jne 0x13b5f
leaq 0x8(%rsp), %rdi
movl $0x1f, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
jne 0x13b7e
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d3ea(%rip), %rdi     # 0x30ed4
leaq 0x1d219(%rip), %rsi     # 0x30d0a
leaq 0x1d3f6(%rip), %rcx     # 0x30eee
movl $0x2e, %edx
callq 0x20d0
leaq 0x1d407(%rip), %rdi     # 0x30f10
leaq 0x1d1fa(%rip), %rsi     # 0x30d0a
leaq 0x1d3d7(%rip), %rcx     # 0x30eee
movl $0x2f, %edx
callq 0x20d0
leaq 0x1d402(%rip), %rdi     # 0x30f2a
leaq 0x1d1db(%rip), %rsi     # 0x30d0a
leaq 0x1d3b8(%rip), %rcx     # 0x30eee
movl $0x30, %edx
callq 0x20d0
leaq 0x1d3fd(%rip), %rdi     # 0x30f44
leaq 0x1d1bc(%rip), %rsi     # 0x30d0a
leaq 0x1d399(%rip), %rcx     # 0x30eee
movl $0x31, %edx
callq 0x20d0
leaq 0x1d3f7(%rip), %rdi     # 0x30f5d
leaq 0x1d19d(%rip), %rsi     # 0x30d0a
leaq 0x1d37a(%rip), %rcx     # 0x30eee
movl $0x32, %edx
callq 0x20d0
leaq 0x1d2fc(%rip), %rdi     # 0x30e81
leaq 0x1d17e(%rip), %rsi     # 0x30d0a
leaq 0x1d35b(%rip), %rcx     # 0x30eee
movl $0x33, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d3ca(%rip), %rsi     # 0x30f76
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rbx, %rdi
movl $0x11, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
je 0x13c62
leaq 0x8(%rsp), %rdi
movl $0x12, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
je 0x13c81
leaq 0x8(%rsp), %rdi
movl $0x15, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
je 0x13ca0
leaq 0x8(%rsp), %rdi
movl $0x17, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
je 0x13cbf
leaq 0x8(%rsp), %rdi
movl $0x30, %esi
xorl %edx, %edx
callq 0x5bee
testb %al, %al
je 0x13cde
leaq 0x8(%rsp), %rdi
movl $0x2f, %esi
xorl %edx, %edx
callq 0x5bee
testb %al, %al
je 0x13cfd
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d334(%rip), %rdi     # 0x30f9d
leaq 0x1d09a(%rip), %rsi     # 0x30d0a
leaq 0x1d33e(%rip), %rcx     # 0x30fb5
movl $0x3a, %edx
callq 0x20d0
leaq 0x1d34f(%rip), %rdi     # 0x30fd7
leaq 0x1d07b(%rip), %rsi     # 0x30d0a
leaq 0x1d31f(%rip), %rcx     # 0x30fb5
movl $0x3b, %edx
callq 0x20d0
leaq 0x1d348(%rip), %rdi     # 0x30fef
leaq 0x1d05c(%rip), %rsi     # 0x30d0a
leaq 0x1d300(%rip), %rcx     # 0x30fb5
movl $0x3c, %edx
callq 0x20d0
leaq 0x1d341(%rip), %rdi     # 0x31007
leaq 0x1d03d(%rip), %rsi     # 0x30d0a
leaq 0x1d2e1(%rip), %rcx     # 0x30fb5
movl $0x3d, %edx
callq 0x20d0
leaq 0x1d33a(%rip), %rdi     # 0x3101f
leaq 0x1d01e(%rip), %rsi     # 0x30d0a
leaq 0x1d2c2(%rip), %rcx     # 0x30fb5
movl $0x3e, %edx
callq 0x20d0
leaq 0x1d334(%rip), %rdi     # 0x31038
leaq 0x1cfff(%rip), %rsi     # 0x30d0a
leaq 0x1d2a3(%rip), %rcx     # 0x30fb5
movl $0x3f, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d326(%rip), %rsi     # 0x31051
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rbx, %rdi
movl $0x11, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
je 0x13d6f
leaq 0x8(%rsp), %rdi
movl $0xa, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
je 0x13d8e
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d227(%rip), %rdi     # 0x30f9d
leaq 0x1cf8d(%rip), %rsi     # 0x30d0a
leaq 0x1d2ed(%rip), %rcx     # 0x31071
movl $0x46, %edx
callq 0x20d0
leaq 0x1d2fe(%rip), %rdi     # 0x31093
leaq 0x1cf6e(%rip), %rsi     # 0x30d0a
leaq 0x1d2ce(%rip), %rcx     # 0x31071
movl $0x47, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d2ef(%rip), %rsi     # 0x310ab
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rbx, %rdi
movl $0x10, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
je 0x13e8b
leaq 0x8(%rsp), %rdi
movl $0x16, %esi
xorl %edx, %edx
callq 0x5bee
testb %al, %al
jne 0x13eaa
leaq 0x8(%rsp), %rdi
movl $0x1d, %esi
xorl %edx, %edx
callq 0x5bee
testb %al, %al
jne 0x13ec9
leaq 0x8(%rsp), %rdi
movl $0x1f, %esi
xorl %edx, %edx
callq 0x5bee
testb %al, %al
jne 0x13ee8
leaq 0x8(%rsp), %rdi
movl $0x25, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
jne 0x13f07
leaq 0x8(%rsp), %rdi
movl $0x27, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
jne 0x13f26
leaq 0x8(%rsp), %rdi
movl $0x2e, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
jne 0x13f45
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d240(%rip), %rdi     # 0x310d2
leaq 0x1ce71(%rip), %rsi     # 0x30d0a
leaq 0x1d24a(%rip), %rcx     # 0x310ea
movl $0x4e, %edx
callq 0x20d0
leaq 0x1d259(%rip), %rdi     # 0x3110a
leaq 0x1ce52(%rip), %rsi     # 0x30d0a
leaq 0x1d22b(%rip), %rcx     # 0x310ea
movl $0x4f, %edx
callq 0x20d0
leaq 0x1cf65(%rip), %rdi     # 0x30e35
leaq 0x1ce33(%rip), %rsi     # 0x30d0a
leaq 0x1d20c(%rip), %rcx     # 0x310ea
movl $0x50, %edx
callq 0x20d0
leaq 0x1d235(%rip), %rdi     # 0x31124
leaq 0x1ce14(%rip), %rsi     # 0x30d0a
leaq 0x1d1ed(%rip), %rcx     # 0x310ea
movl $0x51, %edx
callq 0x20d0
leaq 0x1cf41(%rip), %rdi     # 0x30e4f
leaq 0x1cdf5(%rip), %rsi     # 0x30d0a
leaq 0x1d1ce(%rip), %rcx     # 0x310ea
movl $0x52, %edx
callq 0x20d0
leaq 0x1d211(%rip), %rdi     # 0x3113e
leaq 0x1cdd6(%rip), %rsi     # 0x30d0a
leaq 0x1d1af(%rip), %rcx     # 0x310ea
movl $0x53, %edx
callq 0x20d0
leaq 0x1d20b(%rip), %rdi     # 0x31157
leaq 0x1cdb7(%rip), %rsi     # 0x30d0a
leaq 0x1d190(%rip), %rcx     # 0x310ea
movl $0x54, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d1fd(%rip), %rsi     # 0x31170
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rbx, %rdi
movl $0xd, %esi
xorl %edx, %edx
callq 0x5bee
testb %al, %al
jne 0x14026
leaq 0x8(%rsp), %rdi
movl $0x16, %esi
xorl %edx, %edx
callq 0x5bee
testb %al, %al
jne 0x14045
leaq 0x8(%rsp), %rdi
movl $0x1f, %esi
xorl %edx, %edx
callq 0x5bee
testb %al, %al
jne 0x14064
leaq 0x8(%rsp), %rdi
movl $0x20, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
je 0x14083
leaq 0x8(%rsp), %rdi
movl $0x2e, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
jne 0x140a2
leaq 0x8(%rsp), %rdi
movl $0x37, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
jne 0x140c1
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1cea7(%rip), %rdi     # 0x30ed4
leaq 0x1ccd6(%rip), %rsi     # 0x30d0a
leaq 0x1d157(%rip), %rcx     # 0x31192
movl $0x5b, %edx
callq 0x20d0
leaq 0x1d0be(%rip), %rdi     # 0x3110a
leaq 0x1ccb7(%rip), %rsi     # 0x30d0a
leaq 0x1d138(%rip), %rcx     # 0x31192
movl $0x5c, %edx
callq 0x20d0
leaq 0x1d0b9(%rip), %rdi     # 0x31124
leaq 0x1cc98(%rip), %rsi     # 0x30d0a
leaq 0x1d119(%rip), %rcx     # 0x31192
movl $0x5d, %edx
callq 0x20d0
leaq 0x1d125(%rip), %rdi     # 0x311af
leaq 0x1cc79(%rip), %rsi     # 0x30d0a
leaq 0x1d0fa(%rip), %rcx     # 0x31192
movl $0x5e, %edx
callq 0x20d0
leaq 0x1d0ae(%rip), %rdi     # 0x31157
leaq 0x1cc5a(%rip), %rsi     # 0x30d0a
leaq 0x1d0db(%rip), %rcx     # 0x31192
movl $0x5f, %edx
callq 0x20d0
leaq 0x1d0ff(%rip), %rdi     # 0x311c7
leaq 0x1cc3b(%rip), %rsi     # 0x30d0a
leaq 0x1d0bc(%rip), %rcx     # 0x31192
movl $0x60, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ce31(%rip), %rsi     # 0x31454
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movq %rbx, %rdi
movl $0x19, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
jne 0x146df
leaq 0x8(%rsp), %rdi
movl $0x19, %esi
movl $0x1, %edx
callq 0x5c48
testb %al, %al
je 0x146fe
leaq 0x8(%rsp), %rdi
movl $0x19, %esi
movl $0x1, %edx
callq 0x5ccb
testb %al, %al
jne 0x1471d
leaq 0x8(%rsp), %rdi
movl $0x21, %esi
movl $0x1, %edx
callq 0x5bee
testb %al, %al
jne 0x1473c
leaq 0x8(%rsp), %rdi
movl $0x21, %esi
movl $0x1, %edx
callq 0x5c48
testb %al, %al
je 0x1475b
leaq 0x8(%rsp), %rdi
movl $0x21, %esi
movl $0x1, %edx
callq 0x5ccb
testb %al, %al
jne 0x1477a
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1cd9c(%rip), %rdi     # 0x31482
leaq 0x1c61d(%rip), %rsi     # 0x30d0a
leaq 0x1cda7(%rip), %rcx     # 0x3149b
movl $0x8d, %edx
callq 0x20d0
leaq 0x1cdaa(%rip), %rdi     # 0x314af
leaq 0x1c5fe(%rip), %rsi     # 0x30d0a
leaq 0x1cd88(%rip), %rcx     # 0x3149b
movl $0x8e, %edx
callq 0x20d0
leaq 0x1cda4(%rip), %rdi     # 0x314c8
leaq 0x1c5df(%rip), %rsi     # 0x30d0a
leaq 0x1cd69(%rip), %rcx     # 0x3149b
movl $0x8f, %edx
callq 0x20d0
leaq 0x1cda0(%rip), %rdi     # 0x314e3
leaq 0x1c5c0(%rip), %rsi     # 0x30d0a
leaq 0x1cd4a(%rip), %rcx     # 0x3149b
movl $0x91, %edx
callq 0x20d0
leaq 0x1cd9a(%rip), %rdi     # 0x314fc
leaq 0x1c5a1(%rip), %rsi     # 0x30d0a
leaq 0x1cd2b(%rip), %rcx     # 0x3149b
movl $0x92, %edx
callq 0x20d0
leaq 0x1cd94(%rip), %rdi     # 0x31515
leaq 0x1c582(%rip), %rsi     # 0x30d0a
leaq 0x1cd0c(%rip), %rcx     # 0x3149b
movl $0x93, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13714
callq 0x137f4
callq 0x13a21
callq 0x13b9d
callq 0x13d1c
callq 0x13dad
callq 0x13f64
callq 0x140e0
callq 0x1433f
popq %rax
jmp 0x14614
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0xaa43
movl $0x1, %edi
movl $0x34, %esi
movl $0x24, %edx
callq 0x76b8
movq %rax, %r14
leaq 0xb42ed(%rip), %rdx     # 0xc8af0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x30e3
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5de4
testl %eax, %eax
jne 0x1482a
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x1ccff(%rip), %rdi     # 0x31530
leaq 0x1cd13(%rip), %rsi     # 0x3154b
leaq 0x1cd22(%rip), %rcx     # 0x31561
movl $0x15, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_extend_promotion()
void test_extend_promotion() {
    position pos;
    set_pos(&pos,"k7/b1P5/KP6/6q1/8/8/8/4n3 w - -");

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

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

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

    apply_move(&pos,c7c8q,gundos);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1cd1e(%rip), %rsi     # 0x3157a
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rax, %rbx
movl $0x1, %edi
movl $0xa, %esi
movl $0x2, %edx
callq 0x76b8
movq %rsp, %r15
movq %rax, (%r15)
movq %r15, %rdi
movl $0x5, %esi
callq 0x7780
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x148fd
movq (%rsp), %rsi
leaq 0xb4223(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x30e3
movq (%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x5de4
cmpl $0x1, %eax
jne 0x1491c
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cc96(%rip), %rdi     # 0x3159a
leaq 0x1cc40(%rip), %rsi     # 0x3154b
leaq 0x1ccaa(%rip), %rcx     # 0x315bc
movl $0x22, %edx
callq 0x20d0
leaq 0x1ccb6(%rip), %rdi     # 0x315d9
leaq 0x1cc21(%rip), %rsi     # 0x3154b
leaq 0x1cc8b(%rip), %rcx     # 0x315bc
movl $0x26, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_white_push_to_7th()
void test_white_push_to_7th() {
    position pos;
    set_pos(&pos,"k7/b1P5/KP6/6q1/8/8/8/4n3 w - -");

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1cc2c(%rip), %rsi     # 0x3157a
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rax, %r15
movl $0x1, %edi
movl $0x11, %esi
movl $0x9, %edx
callq 0x76b8
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe727
testb %al, %al
je 0x149dd
leaq 0xb4145(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e3
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x5de4
cmpl $0x1, %eax
jne 0x149fc
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cc10(%rip), %rdi     # 0x315f4
leaq 0x1cb60(%rip), %rsi     # 0x3154b
leaq 0x1cc23(%rip), %rcx     # 0x31615
movl $0x32, %edx
callq 0x20d0
leaq 0x1cc30(%rip), %rdi     # 0x31633
leaq 0x1cb41(%rip), %rsi     # 0x3154b
leaq 0x1cc04(%rip), %rcx     # 0x31615
movl $0x35, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_passed_pawn()
void test_passed_pawn() {
    position pos;
    set_pos(&pos,"8/5ppp/8/5PPP/8/6k1/8/6K1 b - -");

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1cc1f(%rip), %rsi     # 0x3164d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rax, %r15
movl $0x1, %edi
movl $0xe, %esi
movl $0x16, %edx
callq 0x76b8
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe727
testb %al, %al
je 0x14ab9
leaq 0xb4065(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e3
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5de4
testl %eax, %eax
jne 0x14ad8
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cbad(%rip), %rdi     # 0x3166d
leaq 0x1ca84(%rip), %rsi     # 0x3154b
leaq 0x1cbc0(%rip), %rcx     # 0x3168e
movl $0x41, %edx
callq 0x20d0
leaq 0x1cbc7(%rip), %rdi     # 0x316a6
leaq 0x1ca65(%rip), %rsi     # 0x3154b
leaq 0x1cba1(%rip), %rcx     # 0x3168e
movl $0x44, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1c46c(%rip), %rsi     # 0x30f76
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rax, %r15
movl $0x4, %edi
movl $0x1b, %esi
movl $0x23, %edx
callq 0x76b8
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe727
testb %al, %al
je 0x14b95
leaq 0xb3f89(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e3
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5de4
testl %eax, %eax
jne 0x14bb4
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cb25(%rip), %rdi     # 0x316c1
leaq 0x1c9a8(%rip), %rsi     # 0x3154b
leaq 0x1cb38(%rip), %rcx     # 0x316e2
movl $0x50, %edx
callq 0x20d0
leaq 0x1cb40(%rip), %rdi     # 0x316fb
leaq 0x1c989(%rip), %rsi     # 0x3154b
leaq 0x1cb19(%rip), %rcx     # 0x316e2
movl $0x52, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_black_push_to_2nd()
void test_black_push_to_2nd() {
    position pos;
    set_pos(&pos,"8/8/1PP2PbP/3r4/8/1Q5p/p5N1/k3K3 b - -");

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1c390(%rip), %rsi     # 0x30f76
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rax, %r15
movl $0x1, %edi
movl $0x2f, %esi
movl $0x37, %edx
callq 0x76b8
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe727
testb %al, %al
je 0x14c72
leaq 0xb3ead(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e3
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5de4
cmpl $0x1, %eax
jne 0x14c91
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1ca9d(%rip), %rdi     # 0x31716
leaq 0x1c8cb(%rip), %rsi     # 0x3154b
leaq 0x1cab0(%rip), %rcx     # 0x31737
movl $0x5e, %edx
callq 0x20d0
leaq 0x1cabd(%rip), %rdi     # 0x31755
leaq 0x1c8ac(%rip), %rsi     # 0x3154b
leaq 0x1ca91(%rip), %rcx     # 0x31737
movl $0x60, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_passed_pawn3()
void test_passed_pawn3() {
    // Fischer-Larsen 71
    position pos;
    set_pos(&pos,"8/4kp2/6p1/7p/P7/2K3P1/7P/8 w - -");

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1caad(%rip), %rsi     # 0x31770
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rax, %r15
movl $0x1, %edi
movl $0x20, %esi
movl $0x18, %edx
callq 0x76b8
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe727
testb %al, %al
je 0x14d4e
leaq 0xb3dd0(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e3
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5de4
testl %eax, %eax
jne 0x14d6d
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1ca3d(%rip), %rdi     # 0x31792
leaq 0x1c7ef(%rip), %rsi     # 0x3154b
leaq 0x1ca50(%rip), %rcx     # 0x317b3
movl $0x6d, %edx
callq 0x20d0
leaq 0x1ca58(%rip), %rdi     # 0x317cc
leaq 0x1c7d0(%rip), %rsi     # 0x3154b
leaq 0x1ca31(%rip), %rcx     # 0x317b3
movl $0x6f, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_passed_pawn4()
void test_passed_pawn4() {
    position pos;
    set_pos(&pos,"8/4kp2/6p1/7p/P7/2K3P1/7P/8 b - -");

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1c3d1(%rip), %rsi     # 0x31170
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rax, %r15
movl $0x1, %edi
movl $0xd, %esi
movl $0x15, %edx
callq 0x76b8
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe727
testb %al, %al
je 0x14e2a
leaq 0xb3cf4(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e3
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5de4
testl %eax, %eax
jne 0x14e49
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1c9b6(%rip), %rdi     # 0x317e7
leaq 0x1c713(%rip), %rsi     # 0x3154b
leaq 0x1c9c9(%rip), %rcx     # 0x31808
movl $0x7b, %edx
callq 0x20d0
leaq 0x1c9d1(%rip), %rdi     # 0x31821
leaq 0x1c6f4(%rip), %rsi     # 0x3154b
leaq 0x1c9aa(%rip), %rcx     # 0x31808
movl $0x7d, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_passed_pawn5()
void test_passed_pawn5() {
    position pos;
    set_pos(&pos,"8/p3q1kp/1p2Pnp1/3pQ3/2pP4/1nP3N1/1B4PP/6K1 b - -");
    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1c9c1(%rip), %rsi     # 0x3183c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rax, %r15
movl $0x1, %edi
movl $0x8, %esi
movl $0x10, %edx
callq 0x76b8
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe727
testb %al, %al
je 0x14f06
leaq 0xb3c18(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e3
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5de4
testl %eax, %eax
jne 0x14f25
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1c961(%rip), %rdi     # 0x3186e
leaq 0x1c637(%rip), %rsi     # 0x3154b
leaq 0x1c974(%rip), %rcx     # 0x3188f
movl $0x89, %edx
callq 0x20d0
leaq 0x1c97c(%rip), %rdi     # 0x318a8
leaq 0x1c618(%rip), %rsi     # 0x3154b
leaq 0x1c955(%rip), %rcx     # 0x3188f
movl $0x8b, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_passed_pawn6()
void test_passed_pawn6() {
    position pos;
    set_pos(&pos,"8/p3q1kp/1p2Pnp1/3pQ3/2pP4/1nP3N1/1B4PP/6K1 b - -");
    move moves[MAX_MOVES_PER_PLY];
    move *endp = gen_legal_moves(moves,&pos,true,true);

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1c8e5(%rip), %rsi     # 0x3183c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rax, %r15
movl $0x1, %edi
movl $0x11, %esi
movl $0x19, %edx
callq 0x76b8
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe727
testb %al, %al
je 0x14fe2
leaq 0xb3b3c(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e3
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5de4
testl %eax, %eax
jne 0x15001
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1c8da(%rip), %rdi     # 0x318c3
leaq 0x1c55b(%rip), %rsi     # 0x3154b
leaq 0x1c8ed(%rip), %rcx     # 0x318e4
movl $0x96, %edx
callq 0x20d0
leaq 0x1c8f5(%rip), %rdi     # 0x318fd
leaq 0x1c53c(%rip), %rsi     # 0x3154b
leaq 0x1c8ce(%rip), %rcx     # 0x318e4
movl $0x98, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/extend__test.cpp
// Function: test_newly_created_passed_pawn()
void test_newly_created_passed_pawn() {
    position pos;
    set_pos(&pos,"7k/8/6p1/4p3/5P2/8/8/7K w - -");

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

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb30, %rsp            # imm = 0xB30
leaq 0x1c8e5(%rip), %rsi     # 0x31918
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa74
movl $0x1, %edi
movl $0x25, %esi
movl $0x1c, %edx
movl $0x1, %ecx
callq 0x76d7
movq %rax, %r14
leaq 0x1d0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe727
testb %al, %al
je 0x15132
leaq 0xb3a57(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x30e3
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5de4
testl %eax, %eax
jne 0x15151
leaq 0xb3a2b(%rip), %rsi     # 0xc8af0
leaq 0x8(%rsp), %rdi
callq 0x3341
movl $0x1, %edi
movl $0x25, %esi
movl $0x1d, %edx
callq 0x76b8
movq %rax, %r14
leaq 0x1d0(%rsp), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x15170
leaq 0xb39ec(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30e3
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5de4
testl %eax, %eax
jne 0x1518f
addq $0xb30, %rsp            # imm = 0xB30
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1c7fd(%rip), %rdi     # 0x31936
leaq 0x1c40b(%rip), %rsi     # 0x3154b
leaq 0x1c810(%rip), %rcx     # 0x31957
movl $0xa4, %edx
callq 0x20d0
leaq 0x1c825(%rip), %rdi     # 0x3197d
leaq 0x1c3ec(%rip), %rsi     # 0x3154b
leaq 0x1c7f1(%rip), %rcx     # 0x31957
movl $0xa7, %edx
callq 0x20d0
leaq 0x1c821(%rip), %rdi     # 0x31998
leaq 0x1c3cd(%rip), %rsi     # 0x3154b
leaq 0x1c7d2(%rip), %rcx     # 0x31957
movl $0xab, %edx
callq 0x20d0
leaq 0x1c823(%rip), %rdi     # 0x319b9
leaq 0x1c3ae(%rip), %rsi     # 0x3154b
leaq 0x1c7b3(%rip), %rcx     # 0x31957
movl $0xae, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1c811(%rip), %rsi     # 0x319d4
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaa74
movl $0x4, %edi
movl $0x23, %esi
movl $0x1b, %edx
movl $0x4, %ecx
callq 0x76d7
movq %rax, %rbx
leaq 0xb30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe727
testb %al, %al
je 0x152a4
leaq 0xb38ca(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e3
movl $0x4, %edi
movl $0x2b, %esi
movl $0x1b, %edx
movl $0x4, %ecx
callq 0x76d7
movq %rax, %r15
leaq 0x1d0(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xe727
testb %al, %al
je 0x152c3
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5de4
cmpl $0x1, %eax
jne 0x152e2
addq $0x1498, %rsp           # imm = 0x1498
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1c748(%rip), %rdi     # 0x319f3
leaq 0x1c299(%rip), %rsi     # 0x3154b
leaq 0x1c75b(%rip), %rcx     # 0x31a14
movl $0xba, %edx
callq 0x20d0
leaq 0x1c760(%rip), %rdi     # 0x31a2a
leaq 0x1c27a(%rip), %rsi     # 0x3154b
leaq 0x1c73c(%rip), %rcx     # 0x31a14
movl $0xc1, %edx
callq 0x20d0
leaq 0x1c764(%rip), %rdi     # 0x31a4d
leaq 0x1c25b(%rip), %rsi     # 0x3154b
leaq 0x1c71d(%rip), %rcx     # 0x31a14
movl $0xc3, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1c754(%rip), %rsi     # 0x31a68
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaa74
movl $0x4, %edi
movl $0x23, %esi
movl $0x1b, %edx
movl $0x4, %ecx
callq 0x76d7
movq %rax, %rbx
leaq 0xb30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe727
testb %al, %al
je 0x153f3
leaq 0xb3779(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e3
movl $0x5, %edi
movl $0x2b, %esi
movl $0x1b, %edx
movl $0x4, %ecx
callq 0x76d7
movq %rax, %rbx
leaq 0x1d0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe727
testb %al, %al
je 0x15412
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5de4
cmpl $0x1, %eax
jne 0x15431
addq $0x1490, %rsp           # imm = 0x1490
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1c5f9(%rip), %rdi     # 0x319f3
leaq 0x1c14a(%rip), %rsi     # 0x3154b
leaq 0x1c67f(%rip), %rcx     # 0x31a87
movl $0xcf, %edx
callq 0x20d0
leaq 0x1c611(%rip), %rdi     # 0x31a2a
leaq 0x1c12b(%rip), %rsi     # 0x3154b
leaq 0x1c660(%rip), %rcx     # 0x31a87
movl $0xd6, %edx
callq 0x20d0
leaq 0x1c666(%rip), %rdi     # 0x31a9e
leaq 0x1c10c(%rip), %rsi     # 0x3154b
leaq 0x1c641(%rip), %rcx     # 0x31a87
movl $0xd8, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1c656(%rip), %rsi     # 0x31ab9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaa74
movl $0x4, %edi
movl $0x23, %esi
movl $0x1b, %edx
movl $0x3, %ecx
callq 0x76d7
movq %rax, %rbx
leaq 0xb30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe727
testb %al, %al
je 0x15541
leaq 0xb362a(%rip), %rdx     # 0xc8af0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e3
movl $0x5, %edi
movl $0x2b, %esi
movl $0x1b, %edx
movl $0x4, %ecx
callq 0x76d7
movq %rax, %rbx
leaq 0x1d0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7840
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe727
testb %al, %al
je 0x15560
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5de4
testl %eax, %eax
jne 0x1557f
addq $0x1490, %rsp           # imm = 0x1490
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1c4ab(%rip), %rdi     # 0x319f3
leaq 0x1bffc(%rip), %rsi     # 0x3154b
leaq 0x1c582(%rip), %rcx     # 0x31ad8
movl $0xe4, %edx
callq 0x20d0
leaq 0x1c4c3(%rip), %rdi     # 0x31a2a
leaq 0x1bfdd(%rip), %rsi     # 0x3154b
leaq 0x1c563(%rip), %rcx     # 0x31ad8
movl $0xeb, %edx
callq 0x20d0
leaq 0x1c569(%rip), %rdi     # 0x31aef
leaq 0x1bfbe(%rip), %rsi     # 0x3154b
leaq 0x1c544(%rip), %rcx     # 0x31ad8
movl $0xed, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/hash__test.cpp
// Function: contains_key(unsigned long long, unsigned long long*, int, int)
bool contains_key(uint64 needle,uint64 haystack[],int n,int start) {
    for (int i=start;i<n;i++) {
        if (needle==haystack[i]) {
            return true;
        }
    }
    return false;
}

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x1, %edi
movl $0x34, %esi
movl $0x24, %edx
callq 0x76b8
movq %rax, %rbx
movl $0x1, %edi
movl $0xe, %esi
movl $0xffffff93, %edx       # imm = 0xFFFFFF93
movq %rax, %rcx
callq 0x5fa7
movq %rax, %r14
movq %rax, %rdi
callq 0x6135
cmpl $0x1, %eax
jne 0x16fcc
movq %r14, %rdi
callq 0x613c
cmpl $0xe, %eax
jne 0x16feb
movq %r14, %rdi
callq 0x6143
cmpl $-0x6d, %eax
jne 0x1700a
movq %r14, %rdi
callq 0x616d
cmpq %rbx, %rax
jne 0x17029
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1acd4(%rip), %rdi     # 0x31ca7
leaq 0x1ab4b(%rip), %rsi     # 0x31b25
leaq 0x1acec(%rip), %rcx     # 0x31ccd
movl $0x12e, %edx            # imm = 0x12E
callq 0x20d0
leaq 0x1acfc(%rip), %rdi     # 0x31cee
leaq 0x1ab2c(%rip), %rsi     # 0x31b25
leaq 0x1accd(%rip), %rcx     # 0x31ccd
movl $0x12f, %edx            # imm = 0x12F
callq 0x20d0
leaq 0x1acfe(%rip), %rdi     # 0x31d0f
leaq 0x1ab0d(%rip), %rsi     # 0x31b25
leaq 0x1acae(%rip), %rcx     # 0x31ccd
movl $0x130, %edx            # imm = 0x130
callq 0x20d0
leaq 0x1ad00(%rip), %rdi     # 0x31d30
leaq 0x1aaee(%rip), %rsi     # 0x31b25
leaq 0x1ac8f(%rip), %rcx     # 0x31ccd
movl $0x131, %edx            # imm = 0x131
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_hash_val_upper_bound()
void test_hash_val_upper_bound() {
    int32 depth = 45;
    move mv = 0;
    uint64 val = build_hash_val(UPPER_BOUND,depth,-CHECKMATE,mv);

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

// Assembly:
pushq %rbx
movl $0x2, %edi
movl $0x2d, %esi
movl $0xffff0001, %edx       # imm = 0xFFFF0001
xorl %ecx, %ecx
callq 0x5fa7
movq %rax, %rbx
movq %rax, %rdi
callq 0x6135
cmpl $0x2, %eax
jne 0x1709a
movq %rbx, %rdi
callq 0x613c
cmpl $0x2d, %eax
jne 0x170b9
movq %rbx, %rdi
callq 0x6143
cmpl $0xffff01f5, %eax       # imm = 0xFFFF01F5
jne 0x170d8
movq %rbx, %rdi
callq 0x616d
testq %rax, %rax
jne 0x170f7
popq %rbx
retq
leaq 0x1acac(%rip), %rdi     # 0x31d4d
leaq 0x1aa7d(%rip), %rsi     # 0x31b25
leaq 0x1acc4(%rip), %rcx     # 0x31d73
movl $0x139, %edx            # imm = 0x139
callq 0x20d0
leaq 0x1ac2e(%rip), %rdi     # 0x31cee
leaq 0x1aa5e(%rip), %rsi     # 0x31b25
leaq 0x1aca5(%rip), %rcx     # 0x31d73
movl $0x13a, %edx            # imm = 0x13A
callq 0x20d0
leaq 0x1acb5(%rip), %rdi     # 0x31d94
leaq 0x1aa3f(%rip), %rsi     # 0x31b25
leaq 0x1ac86(%rip), %rcx     # 0x31d73
movl $0x13b, %edx            # imm = 0x13B
callq 0x20d0
leaq 0x1ac32(%rip), %rdi     # 0x31d30
leaq 0x1aa20(%rip), %rsi     # 0x31b25
leaq 0x1ac67(%rip), %rcx     # 0x31d73
movl $0x13c, %edx            # imm = 0x13C
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_hash_val_exact_score()
void test_hash_val_exact_score() {
    int32 depth = 1;
    int32 score = -54;
    move mv = to_capture(PAWN,E7,F8,BISHOP);
    set_promopiece(&mv,QUEEN);
    uint64 val = build_hash_val(EXACT_SCORE,depth,score,mv);

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

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x1, %edi
movl $0xc, %esi
movl $0x5, %edx
movl $0x3, %ecx
callq 0x76d7
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x7780
movq (%rbx), %rcx
movl $0x3, %edi
movl $0x1, %esi
movl $0xffffffca, %edx       # imm = 0xFFFFFFCA
callq 0x5fa7
movq %rax, %rbx
movq %rax, %rdi
callq 0x6135
cmpl $0x3, %eax
jne 0x1720c
movq %rbx, %rdi
callq 0x613c
cmpl $0x1, %eax
jne 0x1722b
movq %rbx, %rdi
callq 0x6143
cmpl $-0x36, %eax
jne 0x1724a
movq %rbx, %rdi
callq 0x616d
movq 0x8(%rsp), %rdi
cmpq %rdi, %rax
jne 0x17269
movq %rax, %rbx
callq 0x77b0
cmpl $0xc, %eax
jne 0x17288
movq 0x8(%rsp), %rdi
callq 0x77b7
cmpl $0x5, %eax
jne 0x172a7
movq 0x8(%rsp), %rdi
callq 0x77c1
cmpl $0x1, %eax
jne 0x172c6
movq 0x8(%rsp), %rdi
callq 0x77df
testb %al, %al
je 0x172e5
movq %rbx, %rdi
callq 0x77cb
cmpl $0x5, %eax
jne 0x17304
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1abab(%rip), %rdi     # 0x31dbe
leaq 0x1a90b(%rip), %rsi     # 0x31b25
leaq 0x1abc3(%rip), %rcx     # 0x31de4
movl $0x146, %edx            # imm = 0x146
callq 0x20d0
leaq 0x1aabc(%rip), %rdi     # 0x31cee
leaq 0x1a8ec(%rip), %rsi     # 0x31b25
leaq 0x1aba4(%rip), %rcx     # 0x31de4
movl $0x147, %edx            # imm = 0x147
callq 0x20d0
leaq 0x1aabe(%rip), %rdi     # 0x31d0f
leaq 0x1a8cd(%rip), %rsi     # 0x31b25
leaq 0x1ab85(%rip), %rcx     # 0x31de4
movl $0x148, %edx            # imm = 0x148
callq 0x20d0
leaq 0x1ab95(%rip), %rdi     # 0x31e05
leaq 0x1a8ae(%rip), %rsi     # 0x31b25
leaq 0x1ab66(%rip), %rcx     # 0x31de4
movl $0x14a, %edx            # imm = 0x14A
callq 0x20d0
leaq 0x1ab80(%rip), %rdi     # 0x31e0f
leaq 0x1a88f(%rip), %rsi     # 0x31b25
leaq 0x1ab47(%rip), %rcx     # 0x31de4
movl $0x14b, %edx            # imm = 0x14B
callq 0x20d0
leaq 0x1ab75(%rip), %rdi     # 0x31e23
leaq 0x1a870(%rip), %rsi     # 0x31b25
leaq 0x1ab28(%rip), %rcx     # 0x31de4
movl $0x14c, %edx            # imm = 0x14C
callq 0x20d0
leaq 0x1ab68(%rip), %rdi     # 0x31e35
leaq 0x1a851(%rip), %rsi     # 0x31b25
leaq 0x1ab09(%rip), %rcx     # 0x31de4
movl $0x14d, %edx            # imm = 0x14D
callq 0x20d0
leaq 0x1b6f5(%rip), %rdi     # 0x329e1
leaq 0x1a832(%rip), %rsi     # 0x31b25
leaq 0x1aaea(%rip), %rcx     # 0x31de4
movl $0x14e, %edx            # imm = 0x14E
callq 0x20d0
leaq 0x1ab3e(%rip), %rdi     # 0x31e49
leaq 0x1a813(%rip), %rsi     # 0x31b25
leaq 0x1aacb(%rip), %rcx     # 0x31de4
movl $0x14f, %edx            # imm = 0x14F
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_with_mate_score()
void test_with_mate_score() {
    clear_hash_table(&htbl);
    position pos;
    set_pos(&pos,"5k2/6pp/p1qN4/1p1p4/3P4/2PKP2Q/PP3r2/3R4 b - -");

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0xe0761(%rip), %rbx     # 0xf7ef0
movq %rbx, %rdi
callq 0x6207
leaq 0x1a789(%rip), %rsi     # 0x31f27
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaa74
movq %r14, %rdi
callq 0x5e40
movq %rax, %r15
movl $0x1, %edi
movl $0x12, %esi
movl $0x22, %edx
callq 0x76b8
movq %rax, %r14
movl $0x1, %edi
movl $0x5, %esi
movl $0xfffc, %edx           # imm = 0xFFFC
movq %rax, %rcx
callq 0x5fa7
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x62c0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6263
testq %rax, %rax
je 0x1782e
movq %rax, %rbx
movq %rax, %rdi
callq 0x616d
cmpq %r14, %rax
jne 0x1784d
movq %rbx, %rdi
callq 0x6143
cmpl $0xfe0b, %eax           # imm = 0xFE0B
jne 0x1786c
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a721(%rip), %rdi     # 0x31f56
leaq 0x1a2e9(%rip), %rsi     # 0x31b25
leaq 0x1a71a(%rip), %rcx     # 0x31f5d
movl $0x19d, %edx            # imm = 0x19D
callq 0x20d0
leaq 0x1a4dc(%rip), %rdi     # 0x31d30
leaq 0x1a2ca(%rip), %rsi     # 0x31b25
leaq 0x1a6fb(%rip), %rcx     # 0x31f5d
movl $0x19e, %edx            # imm = 0x19E
callq 0x20d0
leaq 0x1a706(%rip), %rdi     # 0x31f79
leaq 0x1a2ab(%rip), %rsi     # 0x31b25
leaq 0x1a6dc(%rip), %rcx     # 0x31f5d
movl $0x1a1, %edx            # imm = 0x1A1
callq 0x20d0