LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/search__test.cpp
// Function: test_qsearch_does_expand_promotions()
void test_qsearch_does_expand_promotions() {
    position pos;
    set_pos(&pos,"8/P6k/8/8/8/8/7K/8 w - -");

    clear_hash_table(&htbl);

    search_stats stats; stats.nodes=0; stats.qnodes=0; stats.last_pv.n=0;
    start_timer(10000);
    move moves[50];

    set_abort_search(false);
    qsearch(&pos,-INF,INF,0,0,false,&stats,moves,gundos);

    assert(stats.nodes==0);
    assert(stats.qnodes==4);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x9d8, %rsp            # imm = 0x9D8
leaq 0x119f8(%rip), %rsi     # 0x36d7f
leaq 0x190(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
leaq 0xd2b52(%rip), %rdi     # 0xf7ef0
callq 0x62b6
xorps %xmm0, %xmm0
leaq 0x358(%rsp), %r14
movups %xmm0, 0x18(%r14)
movl $0x0, 0x28(%r14)
movl $0x2710, %edi           # imm = 0x2710
callq 0x244a4
xorl %edi, %edi
callq 0xb2ba
subq $0x8, %rsp
leaq 0xa3719(%rip), %rax     # 0xc8af0
leaq 0x8(%rsp), %r10
movq %rbx, %rdi
movl $0xfffcf2c0, %esi       # imm = 0xFFFCF2C0
movl $0x30d40, %edx          # imm = 0x30D40
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq %r14
callq 0xc1b8
addq $0x20, %rsp
cmpq $0x0, 0x18(%r14)
jne 0x2541c
cmpq $0x4, 0x378(%rsp)
jne 0x2543b
addq $0x9d8, %rsp            # imm = 0x9D8
popq %rbx
popq %r14
retq
leaq 0x11836(%rip), %rdi     # 0x36c59
leaq 0x11527(%rip), %rsi     # 0x36951
leaq 0x11967(%rip), %rcx     # 0x36d98
movl $0x132, %edx            # imm = 0x132
callq 0x20d0
leaq 0x11981(%rip), %rdi     # 0x36dc3
leaq 0x11508(%rip), %rsi     # 0x36951
leaq 0x11948(%rip), %rcx     # 0x36d98
movl $0x133, %edx            # imm = 0x133
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/search__test.cpp
// Function: test_qsearch_beta_cutoff()
void test_qsearch_beta_cutoff() {
    position pos;

    // this position would be very good for white if searched
    set_pos(&pos,"8/P6k/8/8/8/8/7K/8 w - -");
    search_stats stats; stats.nodes=0; stats.qnodes=0; stats.last_pv.n=0;
    start_timer(10000);
    move moves[50];

    int32 score = eval(&pos,false);
    assert(abs(score) < queen_val);

    set_abort_search(false);
    qsearch(&pos,-INF,-queen_val,0,0,false,&stats,moves,gundos);

    assert(stats.nodes==0);
    assert(stats.qnodes==0);
}

// Assembly:
pushq %rbx
subq $0x9e0, %rsp            # imm = 0x9E0
leaq 0x11916(%rip), %rsi     # 0x36d7f
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
xorps %xmm0, %xmm0
movups %xmm0, 0x378(%rsp)
movl $0x0, 0x388(%rsp)
movl $0x2710, %edi           # imm = 0x2710
callq 0x244a4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl $0x384, %ecx            # imm = 0x384
jae 0x25510
xorl %edi, %edi
callq 0xb2ba
subq $0x8, %rsp
leaq 0xa362f(%rip), %rax     # 0xc8af0
leaq 0x1d8(%rsp), %r10
leaq 0x368(%rsp), %rbx
leaq 0x10(%rsp), %rdi
movl $0xfffcf2c0, %esi       # imm = 0xFFFCF2C0
movl $0xfffffc7c, %edx       # imm = 0xFFFFFC7C
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq %rbx
callq 0xc1b8
addq $0x20, %rsp
cmpq $0x0, 0x18(%rbx)
jne 0x2552f
cmpq $0x0, 0x380(%rsp)
jne 0x2554e
addq $0x9e0, %rsp            # imm = 0x9E0
popq %rbx
retq
leaq 0x118bc(%rip), %rdi     # 0x36dd3
leaq 0x11433(%rip), %rsi     # 0x36951
leaq 0x118c5(%rip), %rcx     # 0x36dea
movl $0x140, %edx            # imm = 0x140
callq 0x20d0
leaq 0x11723(%rip), %rdi     # 0x36c59
leaq 0x11414(%rip), %rsi     # 0x36951
leaq 0x118a6(%rip), %rcx     # 0x36dea
movl $0x145, %edx            # imm = 0x145
callq 0x20d0
leaq 0x11748(%rip), %rdi     # 0x36c9d
leaq 0x113f5(%rip), %rsi     # 0x36951
leaq 0x11887(%rip), %rcx     # 0x36dea
movl $0x146, %edx            # imm = 0x146
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/see__test.cpp
// Function: test_queen_takes_undefended_pawn()
void test_queen_takes_undefended_pawn() {
    position pos;
    set_pos(&pos,"7k/8/1p6/8/8/1Q6/8/7K w - -");

    move mv = to_capture(QUEEN,B3,B6,PAWN);
    assert(is_legal_move(mv,&pos));
    apply_move(&pos,mv,gundos);

    int32 score = see(&pos,mv);
    assert(score==pawn_val);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x1183d(%rip), %rsi     # 0x36e0a
movq %rsp, %r14
movq %r14, %rdi
callq 0xaa82
movl $0x5, %edi
movl $0x29, %esi
movl $0x11, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe559
testb %al, %al
je 0x25633
leaq 0xa34e6(%rip), %rdx     # 0xc8af0
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc966
cmpl $0x64, %eax
jne 0x25652
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x117ec(%rip), %rdi     # 0x36e26
leaq 0x117fc(%rip), %rsi     # 0x36e3d
leaq 0x11808(%rip), %rcx     # 0x36e50
movl $0x15, %edx
callq 0x20d0
leaq 0x1181f(%rip), %rdi     # 0x36e78
leaq 0x117dd(%rip), %rsi     # 0x36e3d
leaq 0x117e9(%rip), %rcx     # 0x36e50
movl $0x19, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/see__test.cpp
// Function: test_queen_takes_defended_pawn()
void test_queen_takes_defended_pawn() {
    position pos;
    set_pos(&pos,"7k/p7/1p6/8/8/1Q6/8/7K w - -");

    move mv = to_capture(QUEEN,B3,B6,PAWN);
    assert(is_legal_move(mv,&pos));
    apply_move(&pos,mv,gundos);

    int32 score = see(&pos,mv);
    assert(score==pawn_val-queen_val);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x11806(%rip), %rsi     # 0x36e88
movq %rsp, %r14
movq %r14, %rdi
callq 0xaa82
movl $0x5, %edi
movl $0x29, %esi
movl $0x11, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe559
testb %al, %al
je 0x256ea
leaq 0xa3431(%rip), %rdx     # 0xc8af0
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc966
cmpl $0xfffffce0, %eax       # imm = 0xFFFFFCE0
jne 0x25709
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x11735(%rip), %rdi     # 0x36e26
leaq 0x11745(%rip), %rsi     # 0x36e3d
leaq 0x117a6(%rip), %rcx     # 0x36ea5
movl $0x21, %edx
callq 0x20d0
leaq 0x117bb(%rip), %rdi     # 0x36ecb
leaq 0x11726(%rip), %rsi     # 0x36e3d
leaq 0x11787(%rip), %rcx     # 0x36ea5
movl $0x25, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/see__test.cpp
// Function: test_rook_takes_undefended_pawn()
void test_rook_takes_undefended_pawn() {
    position pos;
    set_pos(&pos,"1k1r4/1pp4p/p7/4p3/8/P5P1/1PP4P/2K1R3 w - -");

    move mv = to_capture(ROOK,E1,E5,PAWN);
    assert(is_legal_move(mv,&pos));
    apply_move(&pos,mv,gundos);

    int32 score = see(&pos,mv);
    assert(score==pawn_val);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x117ac(%rip), %rsi     # 0x36ee5
movq %rsp, %r14
movq %r14, %rdi
callq 0xaa82
movl $0x4, %edi
movl $0x3c, %esi
movl $0x1c, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe559
testb %al, %al
je 0x2579f
leaq 0xa337a(%rip), %rdx     # 0xc8af0
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc966
cmpl $0x64, %eax
jne 0x257be
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x11680(%rip), %rdi     # 0x36e26
leaq 0x11690(%rip), %rsi     # 0x36e3d
leaq 0x1175d(%rip), %rcx     # 0x36f11
movl $0x2d, %edx
callq 0x20d0
leaq 0x116b3(%rip), %rdi     # 0x36e78
leaq 0x11671(%rip), %rsi     # 0x36e3d
leaq 0x1173e(%rip), %rcx     # 0x36f11
movl $0x31, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/see__test.cpp
// Function: test_with_xrays()
void test_with_xrays() {
    position pos;
    set_pos(&pos,"1k1r3q/1ppn3p/p4b2/4p3/8/P2N2P1/1PP1R1BP/2K1Q3 w - -");

    move mv = to_capture(KNIGHT,D3,E5,PAWN);
    assert(is_legal_move(mv,&pos));
    apply_move(&pos,mv,gundos);

    int32 score = see(&pos,mv);
    assert(score==pawn_val-knight_val);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x8bf5(%rip), %rsi      # 0x2e3e3
movq %rsp, %r14
movq %r14, %rdi
callq 0xaa82
movl $0x2, %edi
movl $0x2b, %esi
movl $0x1c, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe559
testb %al, %al
je 0x25856
leaq 0xa32c5(%rip), %rdx     # 0xc8af0
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc966
cmpl $0xffffff38, %eax       # imm = 0xFFFFFF38
jne 0x25875
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x115c9(%rip), %rdi     # 0x36e26
leaq 0x115d9(%rip), %rsi     # 0x36e3d
leaq 0x116cd(%rip), %rcx     # 0x36f38
movl $0x39, %edx
callq 0x20d0
leaq 0x116d3(%rip), %rdi     # 0x36f4f
leaq 0x115ba(%rip), %rsi     # 0x36e3d
leaq 0x116ae(%rip), %rcx     # 0x36f38
movl $0x3d, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/see__test.cpp
// Function: test_rook_xrays()
void test_rook_xrays() {
    position pos;
    set_pos(&pos,"3kr3/8/4p3/8/8/4R3/4R3/4K3 w - -");

    move mv = to_capture(ROOK,E3,E6,PAWN);
    assert(is_legal_move(mv,&pos));
    apply_move(&pos,mv,gundos);

    int32 score = see(&pos,mv);
    assert(score==pawn_val);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x116c5(%rip), %rsi     # 0x36f6a
movq %rsp, %r14
movq %r14, %rdi
callq 0xaa82
movl $0x4, %edi
movl $0x2c, %esi
movl $0x14, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe559
testb %al, %al
je 0x2590b
leaq 0xa320e(%rip), %rdx     # 0xc8af0
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc966
cmpl $0x64, %eax
jne 0x2592a
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x11514(%rip), %rdi     # 0x36e26
leaq 0x11524(%rip), %rsi     # 0x36e3d
leaq 0x1166b(%rip), %rcx     # 0x36f8b
movl $0x45, %edx
callq 0x20d0
leaq 0x11547(%rip), %rdi     # 0x36e78
leaq 0x11505(%rip), %rsi     # 0x36e3d
leaq 0x1164c(%rip), %rcx     # 0x36f8b
movl $0x49, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/see__test.cpp
// Function: test_knight_takes_defended_pawn_as_white()
void test_knight_takes_defended_pawn_as_white() {
    position pos;
    set_pos(&pos,"k7/8/5n2/3p4/8/2N2B2/8/K7 w - -");

    move mv = to_capture(KNIGHT,C3,D5,PAWN);
    assert(is_legal_move(mv,&pos));
    apply_move(&pos,mv,gundos);

    int32 score = see(&pos,mv);
    assert(score==pawn_val);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x11648(%rip), %rsi     # 0x36fa2
movq %rsp, %r14
movq %r14, %rdi
callq 0xaa82
movl $0x2, %edi
movl $0x2a, %esi
movl $0x1b, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe559
testb %al, %al
je 0x259c0
leaq 0xa3159(%rip), %rdx     # 0xc8af0
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc966
cmpl $0x64, %eax
jne 0x259df
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x1145f(%rip), %rdi     # 0x36e26
leaq 0x1146f(%rip), %rsi     # 0x36e3d
leaq 0x115ed(%rip), %rcx     # 0x36fc2
movl $0x51, %edx
callq 0x20d0
leaq 0x11492(%rip), %rdi     # 0x36e78
leaq 0x11450(%rip), %rsi     # 0x36e3d
leaq 0x115ce(%rip), %rcx     # 0x36fc2
movl $0x55, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/see__test.cpp
// Function: test_knight_takes_defended_pawn_as_black()
void test_knight_takes_defended_pawn_as_black() {
    position pos;
    set_pos(&pos,"K7/8/5N2/3P4/8/2n2b2/8/k7 b - -");

    move mv = to_capture(KNIGHT,C3,D5,PAWN);
    assert(is_legal_move(mv,&pos));
    apply_move(&pos,mv,gundos);

    int32 score = see(&pos,mv);
    assert(score==pawn_val);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x115e3(%rip), %rsi     # 0x36ff2
movq %rsp, %r14
movq %r14, %rdi
callq 0xaa82
movl $0x2, %edi
movl $0x2a, %esi
movl $0x1b, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe559
testb %al, %al
je 0x25a75
leaq 0xa30a4(%rip), %rdx     # 0xc8af0
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc966
cmpl $0x64, %eax
jne 0x25a94
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x113aa(%rip), %rdi     # 0x36e26
leaq 0x113ba(%rip), %rsi     # 0x36e3d
leaq 0x11588(%rip), %rcx     # 0x37012
movl $0x5d, %edx
callq 0x20d0
leaq 0x113dd(%rip), %rdi     # 0x36e78
leaq 0x1139b(%rip), %rsi     # 0x36e3d
leaq 0x11569(%rip), %rcx     # 0x37012
movl $0x61, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/see__test.cpp
// Function: test_crazy_rooks()
void test_crazy_rooks() {
    position pos;
    set_pos(&pos,"2K5/8/8/3pRrRr/8/8/8/2k5 w - -");

    move mv = to_capture(ROOK,E5,D5,PAWN);
    assert(is_legal_move(mv,&pos));
    apply_move(&pos,mv,gundos);

    int32 score = see(&pos,mv);
    assert(score==pawn_val-rook_val);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x1157e(%rip), %rsi     # 0x37042
movq %rsp, %r14
movq %r14, %rdi
callq 0xaa82
movl $0x4, %edi
movl $0x1c, %esi
movl $0x1b, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe559
testb %al, %al
je 0x25b2c
leaq 0xa2fef(%rip), %rdx     # 0xc8af0
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc966
cmpl $0xfffffe70, %eax       # imm = 0xFFFFFE70
jne 0x25b4b
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x112f3(%rip), %rdi     # 0x36e26
leaq 0x11303(%rip), %rsi     # 0x36e3d
leaq 0x11520(%rip), %rcx     # 0x37061
movl $0x69, %edx
callq 0x20d0
leaq 0x11527(%rip), %rdi     # 0x37079
leaq 0x112e4(%rip), %rsi     # 0x36e3d
leaq 0x11501(%rip), %rcx     # 0x37061
movl $0x6d, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/see__test.cpp
// Function: test_crazy_rooks2()
void test_crazy_rooks2() {
    position pos;
    set_pos(&pos,"2K5/8/8/3pRrR1/8/8/8/2k5 w - -");
    move mv = to_capture(ROOK,E5,D5,PAWN);
    assert(is_legal_move(mv,&pos));
    apply_move(&pos,mv,gundos);

    int32 score = see(&pos,mv);
    assert(score==pawn_val);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x11517(%rip), %rsi     # 0x37092
movq %rsp, %r14
movq %r14, %rdi
callq 0xaa82
movl $0x4, %edi
movl $0x1c, %esi
movl $0x1b, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe559
testb %al, %al
je 0x25be1
leaq 0xa2f38(%rip), %rdx     # 0xc8af0
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc966
cmpl $0x64, %eax
jne 0x25c00
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x1123e(%rip), %rdi     # 0x36e26
leaq 0x1124e(%rip), %rsi     # 0x36e3d
leaq 0x114bb(%rip), %rcx     # 0x370b1
movl $0x74, %edx
callq 0x20d0
leaq 0x11271(%rip), %rdi     # 0x36e78
leaq 0x1122f(%rip), %rsi     # 0x36e3d
leaq 0x1149c(%rip), %rcx     # 0x370b1
movl $0x78, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/see__test.cpp
// Function: test_knight_takes_defended_pawn()
void test_knight_takes_defended_pawn() {
    position pos;
    set_pos(&pos,"1K1k4/8/5n2/3p4/8/1BN5/8/8 w - -");

    move mv = to_capture(KNIGHT,C3,D5,PAWN);
    assert(is_legal_move(mv,&pos));
    apply_move(&pos,mv,gundos);

    int32 score = see(&pos,mv);
    assert(score==pawn_val);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x1149a(%rip), %rsi     # 0x370ca
movq %rsp, %r14
movq %r14, %rdi
callq 0xaa82
movl $0x2, %edi
movl $0x2a, %esi
movl $0x1b, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe559
testb %al, %al
je 0x25c96
leaq 0xa2e83(%rip), %rdx     # 0xc8af0
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc966
cmpl $0x64, %eax
jne 0x25cb5
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x11189(%rip), %rdi     # 0x36e26
leaq 0x11199(%rip), %rsi     # 0x36e3d
leaq 0x11440(%rip), %rcx     # 0x370eb
movl $0x80, %edx
callq 0x20d0
leaq 0x111bc(%rip), %rdi     # 0x36e78
leaq 0x1117a(%rip), %rsi     # 0x36e3d
leaq 0x11421(%rip), %rcx     # 0x370eb
movl $0x84, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/see__test.cpp
// Function: test_bishop_takes_defended_pawn()
void test_bishop_takes_defended_pawn() {
    position pos;
    set_pos(&pos,"1K1k4/8/5n2/3p4/8/1BN5/8/8 w - -");

    move mv = to_capture(BISHOP,B3,D5,PAWN);
    assert(is_legal_move(mv,&pos));
    apply_move(&pos,mv,gundos);

    int32 score = see(&pos,mv);
    assert(score==pawn_val-bishop_val+knight_val);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x113e5(%rip), %rsi     # 0x370ca
movq %rsp, %r14
movq %r14, %rdi
callq 0xaa82
movl $0x3, %edi
movl $0x29, %esi
movl $0x1b, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe559
testb %al, %al
je 0x25d4b
leaq 0xa2dce(%rip), %rdx     # 0xc8af0
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc966
cmpl $0x50, %eax
jne 0x25d6a
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x110d4(%rip), %rdi     # 0x36e26
leaq 0x110e4(%rip), %rsi     # 0x36e3d
leaq 0x113b2(%rip), %rcx     # 0x37112
movl $0x8c, %edx
callq 0x20d0
leaq 0x113c8(%rip), %rdi     # 0x37139
leaq 0x110c5(%rip), %rsi     # 0x36e3d
leaq 0x11393(%rip), %rcx     # 0x37112
movl $0x90, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/see__test.cpp
// Function: test_knight_takes_defended_pawn_with_crazy_bishops()
void test_knight_takes_defended_pawn_with_crazy_bishops() {
    position pos;
    set_pos(&pos,"1K1k4/8/5n2/3p4/8/2N2B2/6b1/7b w - -");

    move mv = to_capture(KNIGHT,C3,D5,PAWN);
    assert(is_legal_move(mv,&pos));
    apply_move(&pos,mv,gundos);

    int32 score = see(&pos,mv);
    assert(score==pawn_val-knight_val);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x113c5(%rip), %rsi     # 0x3715f
movq %rsp, %r14
movq %r14, %rdi
callq 0xaa82
movl $0x2, %edi
movl $0x2a, %esi
movl $0x1b, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xe559
testb %al, %al
je 0x25e02
leaq 0xa2d19(%rip), %rdx     # 0xc8af0
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc966
cmpl $0xffffff38, %eax       # imm = 0xFFFFFF38
jne 0x25e21
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x1101d(%rip), %rdi     # 0x36e26
leaq 0x1102d(%rip), %rsi     # 0x36e3d
leaq 0x1136d(%rip), %rcx     # 0x37184
movl $0x98, %edx
callq 0x20d0
leaq 0x11127(%rip), %rdi     # 0x36f4f
leaq 0x1100e(%rip), %rsi     # 0x36e3d
leaq 0x1134e(%rip), %rcx     # 0x37184
movl $0x9c, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/see__test.cpp
// Function: test_case_see(char const*, char const*, int)
void test_case_see(const char* fen,const char* str_mv,int32 score) {
    position pos;
    set_pos(&pos,fen);

    move mv = str_to_move(str_mv,&pos);
    assert(is_legal_move(mv,&pos));
    int32 captured_piece = is_epcapture(mv) ? PAWN : (piece_t)pos.piece[get_to_sq(mv)];
    if (captured_piece < NO_PIECE) captured_piece = -captured_piece;
    assert(captured_piece==get_captured_piece(mv));
    apply_move(&pos,mv,gundos);
    int32 my_score = see(&pos,mv);
    assert(my_score==score);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0xaa82
movq %r14, %rdi
movq %r15, %rsi
callq 0xe13f
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xe559
testb %al, %al
je 0x25ee0
movq %r14, %rdi
callq 0x788d
movl $0x1, %ebp
testb %al, %al
jne 0x25ea2
movq %r14, %rdi
callq 0x785b
movl %eax, %eax
movl (%rsp,%rax,4), %eax
movl %eax, %ebp
negl %ebp
cmovsl %eax, %ebp
movq %r14, %rdi
callq 0x7879
cmpl %eax, %ebp
jne 0x25eff
leaq 0xa2c3b(%rip), %rdx     # 0xc8af0
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x30e1
movq %r15, %rdi
movq %r14, %rsi
callq 0xc966
cmpl %ebx, %eax
jne 0x25f1e
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10f3f(%rip), %rdi     # 0x36e26
leaq 0x10f4f(%rip), %rsi     # 0x36e3d
leaq 0x112c9(%rip), %rcx     # 0x371be
movl $0xa4, %edx
callq 0x20d0
leaq 0x112ee(%rip), %rdi     # 0x371f4
leaq 0x10f30(%rip), %rsi     # 0x36e3d
leaq 0x112aa(%rip), %rcx     # 0x371be
movl $0xa7, %edx
callq 0x20d0
leaq 0x112f6(%rip), %rdi     # 0x3721b
leaq 0x10f11(%rip), %rsi     # 0x36e3d
leaq 0x1128b(%rip), %rcx     # 0x371be
movl $0xaa, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/square__test.cpp
// Function: test_get_dir()
void test_get_dir() {
    assert(direction_tbl[E4][E6]==NORTH);
    assert(direction_tbl[D6][D1]==SOUTH);
    assert(direction_tbl[H1][A1]==WEST);
    assert(direction_tbl[A7][G7]==EAST);

    assert(direction_tbl[B3][E6]==NORTHEAST);
    assert(direction_tbl[A5][E1]==SOUTHEAST);
    assert(direction_tbl[H3][G2]==SOUTHWEST);
    assert(direction_tbl[G5][E7]==NORTHWEST);

    assert(direction_tbl[C3][D5]==NODIR);
    assert(direction_tbl[E4][E4]==NODIR);
}

// Assembly:
pushq %rax
leaq 0x9e800(%rip), %rax     # 0xc4920
cmpl $0x0, 0x2450(%rax)
jne 0x261a0
cmpl $0x4, 0x13ec(%rax)
jne 0x261bf
cmpl $0x6, 0x3fe0(%rax)
jne 0x261de
cmpl $0x2, 0x838(%rax)
jne 0x261fd
cmpl $0x1, 0x2950(%rax)
jne 0x2621c
cmpl $0x3, 0x18f0(%rax)
jne 0x2623b
cmpl $0x5, 0x2fd8(%rax)
jne 0x2625a
cmpl $0x7, 0x1e30(%rax)
jne 0x26279
cmpl $0x8, 0x2a6c(%rax)
jne 0x26298
cmpl $0x8, 0x2490(%rax)
jne 0x262b7
popq %rax
retq
leaq 0x11479(%rip), %rdi     # 0x37620
leaq 0x1148f(%rip), %rsi     # 0x3763d
leaq 0x1149e(%rip), %rcx     # 0x37653
movl $0xd, %edx
callq 0x20d0
leaq 0x114a1(%rip), %rdi     # 0x37667
leaq 0x11470(%rip), %rsi     # 0x3763d
leaq 0x1147f(%rip), %rcx     # 0x37653
movl $0xe, %edx
callq 0x20d0
leaq 0x1149f(%rip), %rdi     # 0x37684
leaq 0x11451(%rip), %rsi     # 0x3763d
leaq 0x11460(%rip), %rcx     # 0x37653
movl $0xf, %edx
callq 0x20d0
leaq 0x1149c(%rip), %rdi     # 0x376a0
leaq 0x11432(%rip), %rsi     # 0x3763d
leaq 0x11441(%rip), %rcx     # 0x37653
movl $0x10, %edx
callq 0x20d0
leaq 0x11499(%rip), %rdi     # 0x376bc
leaq 0x11413(%rip), %rsi     # 0x3763d
leaq 0x11422(%rip), %rcx     # 0x37653
movl $0x12, %edx
callq 0x20d0
leaq 0x1149b(%rip), %rdi     # 0x376dd
leaq 0x113f4(%rip), %rsi     # 0x3763d
leaq 0x11403(%rip), %rcx     # 0x37653
movl $0x13, %edx
callq 0x20d0
leaq 0x1149d(%rip), %rdi     # 0x376fe
leaq 0x113d5(%rip), %rsi     # 0x3763d
leaq 0x113e4(%rip), %rcx     # 0x37653
movl $0x14, %edx
callq 0x20d0
leaq 0x1149f(%rip), %rdi     # 0x3771f
leaq 0x113b6(%rip), %rsi     # 0x3763d
leaq 0x113c5(%rip), %rcx     # 0x37653
movl $0x15, %edx
callq 0x20d0
leaq 0x114a1(%rip), %rdi     # 0x37740
leaq 0x11397(%rip), %rsi     # 0x3763d
leaq 0x113a6(%rip), %rcx     # 0x37653
movl $0x17, %edx
callq 0x20d0
leaq 0x1149f(%rip), %rdi     # 0x3775d
leaq 0x11378(%rip), %rsi     # 0x3763d
leaq 0x11387(%rip), %rcx     # 0x37653
movl $0x18, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/square__test.cpp
// Function: test_rank()
void test_rank() {
    assert(get_rank(A8)==RANK_8);
    assert(get_rank(B8)==RANK_8);
    assert(get_rank(H8)==RANK_8);
    assert(get_rank(C7)==RANK_7);
    assert(get_rank(E5)==RANK_5);
    assert(get_rank(A2)==RANK_2);
    assert(get_rank(H1)==RANK_1);
}

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0xca69
testl %eax, %eax
jne 0x26350
movl $0x1, %edi
callq 0xca69
testl %eax, %eax
jne 0x2636f
movl $0x7, %edi
callq 0xca69
testl %eax, %eax
jne 0x2638e
movl $0xa, %edi
callq 0xca69
cmpl $0x1, %eax
jne 0x263ad
movl $0x1c, %edi
callq 0xca69
cmpl $0x3, %eax
jne 0x263cc
movl $0x30, %edi
callq 0xca69
cmpl $0x6, %eax
jne 0x263eb
movl $0x3f, %edi
callq 0xca69
cmpl $0x7, %eax
jne 0x2640a
popq %rax
retq
leaq 0x11423(%rip), %rdi     # 0x3777a
leaq 0x112df(%rip), %rsi     # 0x3763d
leaq 0x1142a(%rip), %rcx     # 0x3778f
movl $0x1c, %edx
callq 0x20d0
leaq 0x1142a(%rip), %rdi     # 0x377a0
leaq 0x112c0(%rip), %rsi     # 0x3763d
leaq 0x1140b(%rip), %rcx     # 0x3778f
movl $0x1d, %edx
callq 0x20d0
leaq 0x11420(%rip), %rdi     # 0x377b5
leaq 0x112a1(%rip), %rsi     # 0x3763d
leaq 0x113ec(%rip), %rcx     # 0x3778f
movl $0x1e, %edx
callq 0x20d0
leaq 0x11416(%rip), %rdi     # 0x377ca
leaq 0x11282(%rip), %rsi     # 0x3763d
leaq 0x113cd(%rip), %rcx     # 0x3778f
movl $0x1f, %edx
callq 0x20d0
leaq 0x1140c(%rip), %rdi     # 0x377df
leaq 0x11263(%rip), %rsi     # 0x3763d
leaq 0x113ae(%rip), %rcx     # 0x3778f
movl $0x20, %edx
callq 0x20d0
leaq 0x11402(%rip), %rdi     # 0x377f4
leaq 0x11244(%rip), %rsi     # 0x3763d
leaq 0x1138f(%rip), %rcx     # 0x3778f
movl $0x21, %edx
callq 0x20d0
leaq 0x113f8(%rip), %rdi     # 0x37809
leaq 0x11225(%rip), %rsi     # 0x3763d
leaq 0x11370(%rip), %rcx     # 0x3778f
movl $0x22, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/square__test.cpp
// Function: test_file()
void test_file() {
    assert(get_file(A1)==FILE_A);
    assert(get_file(B3)==FILE_B);
    assert(get_file(C8)==FILE_C);
    assert(get_file(D4)==FILE_D);
    assert(get_file(E2)==FILE_E);
    assert(get_file(F7)==FILE_F);
    assert(get_file(G5)==FILE_G);
    assert(get_file(H6)==FILE_H);
}

// Assembly:
pushq %rax
movl $0x38, %edi
callq 0xca3e
testl %eax, %eax
jne 0x264c3
movl $0x29, %edi
callq 0xca3e
cmpl $0x1, %eax
jne 0x264e2
movl $0x2, %edi
callq 0xca3e
cmpl $0x2, %eax
jne 0x26501
movl $0x23, %edi
callq 0xca3e
cmpl $0x3, %eax
jne 0x26520
movl $0x34, %edi
callq 0xca3e
cmpl $0x4, %eax
jne 0x2653f
movl $0xd, %edi
callq 0xca3e
cmpl $0x5, %eax
jne 0x2655e
movl $0x1e, %edi
callq 0xca3e
cmpl $0x6, %eax
jne 0x2657d
movl $0x17, %edi
callq 0xca3e
cmpl $0x7, %eax
jne 0x2659c
popq %rax
retq
leaq 0x11354(%rip), %rdi     # 0x3781e
leaq 0x1116c(%rip), %rsi     # 0x3763d
leaq 0x1135b(%rip), %rcx     # 0x37833
movl $0x26, %edx
callq 0x20d0
leaq 0x1135b(%rip), %rdi     # 0x37844
leaq 0x1114d(%rip), %rsi     # 0x3763d
leaq 0x1133c(%rip), %rcx     # 0x37833
movl $0x27, %edx
callq 0x20d0
leaq 0x11351(%rip), %rdi     # 0x37859
leaq 0x1112e(%rip), %rsi     # 0x3763d
leaq 0x1131d(%rip), %rcx     # 0x37833
movl $0x28, %edx
callq 0x20d0
leaq 0x11347(%rip), %rdi     # 0x3786e
leaq 0x1110f(%rip), %rsi     # 0x3763d
leaq 0x112fe(%rip), %rcx     # 0x37833
movl $0x29, %edx
callq 0x20d0
leaq 0x1133d(%rip), %rdi     # 0x37883
leaq 0x110f0(%rip), %rsi     # 0x3763d
leaq 0x112df(%rip), %rcx     # 0x37833
movl $0x2a, %edx
callq 0x20d0
leaq 0x11333(%rip), %rdi     # 0x37898
leaq 0x110d1(%rip), %rsi     # 0x3763d
leaq 0x112c0(%rip), %rcx     # 0x37833
movl $0x2b, %edx
callq 0x20d0
leaq 0x11329(%rip), %rdi     # 0x378ad
leaq 0x110b2(%rip), %rsi     # 0x3763d
leaq 0x112a1(%rip), %rcx     # 0x37833
movl $0x2c, %edx
callq 0x20d0
leaq 0x1131f(%rip), %rdi     # 0x378c2
leaq 0x11093(%rip), %rsi     # 0x3763d
leaq 0x11282(%rip), %rcx     # 0x37833
movl $0x2d, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/square__test.cpp
// Function: test_file_distance()
void test_file_distance() {
    assert(file_distance(A1,B1)==1);
    assert(file_distance(A1,H8)==7);
    assert(file_distance(A1,H4)==7);
    assert(file_distance(B3,C7)==1);
    assert(file_distance(H2,A3)==7);
    assert(file_distance(F3,B8)==4);
    assert(file_distance(E1,E2)==0);
}

// Assembly:
pushq %rax
movl $0x38, %edi
movl $0x39, %esi
callq 0xcb3c
cmpl $0x1, %eax
jne 0x26665
movl $0x38, %edi
movl $0x7, %esi
callq 0xcb3c
cmpl $0x7, %eax
jne 0x26684
movl $0x38, %edi
movl $0x27, %esi
callq 0xcb3c
cmpl $0x7, %eax
jne 0x266a3
movl $0x29, %edi
movl $0xa, %esi
callq 0xcb3c
cmpl $0x1, %eax
jne 0x266c2
movl $0x37, %edi
movl $0x28, %esi
callq 0xcb3c
cmpl $0x7, %eax
jne 0x266e1
movl $0x2d, %edi
movl $0x1, %esi
callq 0xcb3c
cmpl $0x4, %eax
jne 0x26700
movl $0x3c, %edi
movl $0x34, %esi
callq 0xcb3c
testl %eax, %eax
jne 0x2671f
popq %rax
retq
leaq 0x1126b(%rip), %rdi     # 0x378d7
leaq 0x10fca(%rip), %rsi     # 0x3763d
leaq 0x11275(%rip), %rcx     # 0x378ef
movl $0x31, %edx
callq 0x20d0
leaq 0x1127e(%rip), %rdi     # 0x37909
leaq 0x10fab(%rip), %rsi     # 0x3763d
leaq 0x11256(%rip), %rcx     # 0x378ef
movl $0x32, %edx
callq 0x20d0
leaq 0x11277(%rip), %rdi     # 0x37921
leaq 0x10f8c(%rip), %rsi     # 0x3763d
leaq 0x11237(%rip), %rcx     # 0x378ef
movl $0x33, %edx
callq 0x20d0
leaq 0x11270(%rip), %rdi     # 0x37939
leaq 0x10f6d(%rip), %rsi     # 0x3763d
leaq 0x11218(%rip), %rcx     # 0x378ef
movl $0x34, %edx
callq 0x20d0
leaq 0x11269(%rip), %rdi     # 0x37951
leaq 0x10f4e(%rip), %rsi     # 0x3763d
leaq 0x111f9(%rip), %rcx     # 0x378ef
movl $0x35, %edx
callq 0x20d0
leaq 0x11262(%rip), %rdi     # 0x37969
leaq 0x10f2f(%rip), %rsi     # 0x3763d
leaq 0x111da(%rip), %rcx     # 0x378ef
movl $0x36, %edx
callq 0x20d0
leaq 0x1125b(%rip), %rdi     # 0x37981
leaq 0x10f10(%rip), %rsi     # 0x3763d
leaq 0x111bb(%rip), %rcx     # 0x378ef
movl $0x37, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/square__test.cpp
// Function: test_rank_distance()
void test_rank_distance() {
    assert(rank_distance(A1,B1)==0);
    assert(rank_distance(A1,C4)==3);
    assert(rank_distance(H8,A7)==1);
    assert(rank_distance(G8,B1)==7);
}

// Assembly:
pushq %rax
movl $0x38, %edi
movl $0x39, %esi
callq 0xcae2
testl %eax, %eax
jne 0x26790
movl $0x38, %edi
movl $0x22, %esi
callq 0xcae2
cmpl $0x3, %eax
jne 0x267af
movl $0x7, %edi
movl $0x8, %esi
callq 0xcae2
cmpl $0x1, %eax
jne 0x267ce
movl $0x6, %edi
movl $0x39, %esi
callq 0xcae2
cmpl $0x7, %eax
jne 0x267ed
popq %rax
retq
leaq 0x11202(%rip), %rdi     # 0x37999
leaq 0x10e9f(%rip), %rsi     # 0x3763d
leaq 0x1120c(%rip), %rcx     # 0x379b1
movl $0x3b, %edx
callq 0x20d0
leaq 0x11215(%rip), %rdi     # 0x379cb
leaq 0x10e80(%rip), %rsi     # 0x3763d
leaq 0x111ed(%rip), %rcx     # 0x379b1
movl $0x3c, %edx
callq 0x20d0
leaq 0x1120e(%rip), %rdi     # 0x379e3
leaq 0x10e61(%rip), %rsi     # 0x3763d
leaq 0x111ce(%rip), %rcx     # 0x379b1
movl $0x3d, %edx
callq 0x20d0
leaq 0x11207(%rip), %rdi     # 0x379fb
leaq 0x10e42(%rip), %rsi     # 0x3763d
leaq 0x111af(%rip), %rcx     # 0x379b1
movl $0x3e, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/square__test.cpp
// Function: test_distance()
void test_distance() {
    assert(distance(E4,E4)==0);
    assert(distance(A1,A8)==7);
    assert(distance(H1,E4)==3);
    assert(distance(H8,E4)==4);
}

// Assembly:
pushq %rax
movl $0x24, %edi
movl $0x24, %esi
callq 0xcb96
testl %eax, %eax
jne 0x2685b
movl $0x38, %edi
xorl %esi, %esi
callq 0xcb96
cmpl $0x7, %eax
jne 0x2687a
movl $0x3f, %edi
movl $0x24, %esi
callq 0xcb96
cmpl $0x3, %eax
jne 0x26899
movl $0x7, %edi
movl $0x24, %esi
callq 0xcb96
cmpl $0x4, %eax
jne 0x268b8
popq %rax
retq
leaq 0x111b1(%rip), %rdi     # 0x37a13
leaq 0x10dd4(%rip), %rsi     # 0x3763d
leaq 0x111b6(%rip), %rcx     # 0x37a26
movl $0x42, %edx
callq 0x20d0
leaq 0x111ba(%rip), %rdi     # 0x37a3b
leaq 0x10db5(%rip), %rsi     # 0x3763d
leaq 0x11197(%rip), %rcx     # 0x37a26
movl $0x43, %edx
callq 0x20d0
leaq 0x111ae(%rip), %rdi     # 0x37a4e
leaq 0x10d96(%rip), %rsi     # 0x3763d
leaq 0x11178(%rip), %rcx     # 0x37a26
movl $0x44, %edx
callq 0x20d0
leaq 0x111a2(%rip), %rdi     # 0x37a61
leaq 0x10d77(%rip), %rsi     # 0x3763d
leaq 0x11159(%rip), %rcx     # 0x37a26
movl $0x45, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/square__test.cpp
// Function: test_northeast()
void test_northeast() {
    assert(northeast(NO_SQUARE)==NO_SQUARE);
    assert(northeast(B4)==C5);
    assert(northeast(G8)==NO_SQUARE);
    assert(northeast(H7)==NO_SQUARE);
}

// Assembly:
pushq %rax
movl $0x40, %edi
callq 0xccf0
cmpl $0x40, %eax
jne 0x26b4a
movl $0x21, %edi
callq 0xccf0
cmpl $0x1a, %eax
jne 0x26b69
movl $0x6, %edi
callq 0xccf0
cmpl $0x40, %eax
jne 0x26b88
movl $0xf, %edi
callq 0xccf0
cmpl $0x40, %eax
jne 0x26ba7
popq %rax
retq
leaq 0x11029(%rip), %rdi     # 0x37b7a
leaq 0x10ae5(%rip), %rsi     # 0x3763d
leaq 0x1103b(%rip), %rcx     # 0x37b9a
movl $0x61, %edx
callq 0x20d0
leaq 0x11040(%rip), %rdi     # 0x37bb0
leaq 0x10ac6(%rip), %rsi     # 0x3763d
leaq 0x1101c(%rip), %rcx     # 0x37b9a
movl $0x62, %edx
callq 0x20d0
leaq 0x11033(%rip), %rdi     # 0x37bc2
leaq 0x10aa7(%rip), %rsi     # 0x3763d
leaq 0x10ffd(%rip), %rcx     # 0x37b9a
movl $0x63, %edx
callq 0x20d0
leaq 0x1102d(%rip), %rdi     # 0x37bdb
leaq 0x10a88(%rip), %rsi     # 0x3763d
leaq 0x10fde(%rip), %rcx     # 0x37b9a
movl $0x64, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/square__test.cpp
// Function: test_southeast()
void test_southeast() {
    assert(southeast(NO_SQUARE)==NO_SQUARE);
    assert(southeast(B4)==C3);
    assert(southeast(G1)==NO_SQUARE);
    assert(southeast(H2)==NO_SQUARE);
}

// Assembly:
pushq %rax
movl $0x40, %edi
callq 0xcd33
cmpl $0x40, %eax
jne 0x26c05
movl $0x21, %edi
callq 0xcd33
cmpl $0x2a, %eax
jne 0x26c24
movl $0x3e, %edi
callq 0xcd33
cmpl $0x40, %eax
jne 0x26c43
movl $0x37, %edi
callq 0xcd33
cmpl $0x40, %eax
jne 0x26c62
popq %rax
retq
leaq 0x10fe8(%rip), %rdi     # 0x37bf4
leaq 0x10a2a(%rip), %rsi     # 0x3763d
leaq 0x10ffa(%rip), %rcx     # 0x37c14
movl $0x68, %edx
callq 0x20d0
leaq 0x10fff(%rip), %rdi     # 0x37c2a
leaq 0x10a0b(%rip), %rsi     # 0x3763d
leaq 0x10fdb(%rip), %rcx     # 0x37c14
movl $0x69, %edx
callq 0x20d0
leaq 0x10ff2(%rip), %rdi     # 0x37c3c
leaq 0x109ec(%rip), %rsi     # 0x3763d
leaq 0x10fbc(%rip), %rcx     # 0x37c14
movl $0x6a, %edx
callq 0x20d0
leaq 0x10fec(%rip), %rdi     # 0x37c55
leaq 0x109cd(%rip), %rsi     # 0x3763d
leaq 0x10f9d(%rip), %rcx     # 0x37c14
movl $0x6b, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/square__test.cpp
// Function: test_southwest()
void test_southwest() {
    assert(southwest(NO_SQUARE)==NO_SQUARE);
    assert(southwest(B4)==A3);
    assert(southwest(B1)==NO_SQUARE);
    assert(southwest(A2)==NO_SQUARE);
}

// Assembly:
pushq %rax
movl $0x40, %edi
callq 0xcd7a
cmpl $0x40, %eax
jne 0x26cc0
movl $0x21, %edi
callq 0xcd7a
cmpl $0x28, %eax
jne 0x26cdf
movl $0x39, %edi
callq 0xcd7a
cmpl $0x40, %eax
jne 0x26cfe
movl $0x30, %edi
callq 0xcd7a
cmpl $0x40, %eax
jne 0x26d1d
popq %rax
retq
leaq 0x10fa7(%rip), %rdi     # 0x37c6e
leaq 0x1096f(%rip), %rsi     # 0x3763d
leaq 0x10fb9(%rip), %rcx     # 0x37c8e
movl $0x6f, %edx
callq 0x20d0
leaq 0x10fbe(%rip), %rdi     # 0x37ca4
leaq 0x10950(%rip), %rsi     # 0x3763d
leaq 0x10f9a(%rip), %rcx     # 0x37c8e
movl $0x70, %edx
callq 0x20d0
leaq 0x10fb1(%rip), %rdi     # 0x37cb6
leaq 0x10931(%rip), %rsi     # 0x3763d
leaq 0x10f7b(%rip), %rcx     # 0x37c8e
movl $0x71, %edx
callq 0x20d0
leaq 0x10fab(%rip), %rdi     # 0x37ccf
leaq 0x10912(%rip), %rsi     # 0x3763d
leaq 0x10f5c(%rip), %rcx     # 0x37c8e
movl $0x72, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/square__test.cpp
// Function: test_northwest()
void test_northwest() {
    assert(northwest(NO_SQUARE)==NO_SQUARE);
    assert(northwest(B4)==A5);
    assert(northwest(A7)==NO_SQUARE);
    assert(northwest(B8)==NO_SQUARE);
}

// Assembly:
pushq %rax
movl $0x40, %edi
callq 0xcdba
cmpl $0x40, %eax
jne 0x26d7b
movl $0x21, %edi
callq 0xcdba
cmpl $0x18, %eax
jne 0x26d9a
movl $0x8, %edi
callq 0xcdba
cmpl $0x40, %eax
jne 0x26db9
movl $0x1, %edi
callq 0xcdba
cmpl $0x40, %eax
jne 0x26dd8
popq %rax
retq
leaq 0x10f66(%rip), %rdi     # 0x37ce8
leaq 0x108b4(%rip), %rsi     # 0x3763d
leaq 0x10f78(%rip), %rcx     # 0x37d08
movl $0x76, %edx
callq 0x20d0
leaq 0x10f7d(%rip), %rdi     # 0x37d1e
leaq 0x10895(%rip), %rsi     # 0x3763d
leaq 0x10f59(%rip), %rcx     # 0x37d08
movl $0x77, %edx
callq 0x20d0
leaq 0x10f70(%rip), %rdi     # 0x37d30
leaq 0x10876(%rip), %rsi     # 0x3763d
leaq 0x10f3a(%rip), %rcx     # 0x37d08
movl $0x78, %edx
callq 0x20d0
leaq 0x10f6a(%rip), %rdi     # 0x37d49
leaq 0x10857(%rip), %rsi     # 0x3763d
leaq 0x10f1b(%rip), %rcx     # 0x37d08
movl $0x79, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/square__test.cpp
// Function: test_is_light_sq()
void test_is_light_sq() {
    assert(is_light_sq(A8));
    assert(!is_light_sq(B8));
    assert(is_light_sq(C8));
    assert(!is_light_sq(A7));
    assert(is_light_sq(B7));
    assert(!is_light_sq(C7));
    assert(is_light_sq(A6));
    assert(!is_light_sq(B6));
    assert(is_light_sq(C6));
}

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0xcdf5
testb %al, %al
je 0x26e99
movl $0x1, %edi
callq 0xcdf5
testb %al, %al
jne 0x26eb8
movl $0x2, %edi
callq 0xcdf5
testb %al, %al
je 0x26ed7
movl $0x8, %edi
callq 0xcdf5
testb %al, %al
jne 0x26ef6
movl $0x9, %edi
callq 0xcdf5
testb %al, %al
je 0x26f15
movl $0xa, %edi
callq 0xcdf5
testb %al, %al
jne 0x26f34
movl $0x10, %edi
callq 0xcdf5
testb %al, %al
je 0x26f53
movl $0x11, %edi
callq 0xcdf5
testb %al, %al
jne 0x26f72
movl $0x12, %edi
callq 0xcdf5
testb %al, %al
je 0x26f91
popq %rax
retq
leaq 0x10ec2(%rip), %rdi     # 0x37d62
leaq 0x10796(%rip), %rsi     # 0x3763d
leaq 0x10ec4(%rip), %rcx     # 0x37d72
movl $0x7d, %edx
callq 0x20d0
leaq 0x10ecb(%rip), %rdi     # 0x37d8a
leaq 0x10777(%rip), %rsi     # 0x3763d
leaq 0x10ea5(%rip), %rcx     # 0x37d72
movl $0x7e, %edx
callq 0x20d0
leaq 0x10ebd(%rip), %rdi     # 0x37d9b
leaq 0x10758(%rip), %rsi     # 0x3763d
leaq 0x10e86(%rip), %rcx     # 0x37d72
movl $0x7f, %edx
callq 0x20d0
leaq 0x10eae(%rip), %rdi     # 0x37dab
leaq 0x10739(%rip), %rsi     # 0x3763d
leaq 0x10e67(%rip), %rcx     # 0x37d72
movl $0x80, %edx
callq 0x20d0
leaq 0x10ea0(%rip), %rdi     # 0x37dbc
leaq 0x1071a(%rip), %rsi     # 0x3763d
leaq 0x10e48(%rip), %rcx     # 0x37d72
movl $0x81, %edx
callq 0x20d0
leaq 0x10e91(%rip), %rdi     # 0x37dcc
leaq 0x106fb(%rip), %rsi     # 0x3763d
leaq 0x10e29(%rip), %rcx     # 0x37d72
movl $0x82, %edx
callq 0x20d0
leaq 0x10e83(%rip), %rdi     # 0x37ddd
leaq 0x106dc(%rip), %rsi     # 0x3763d
leaq 0x10e0a(%rip), %rcx     # 0x37d72
movl $0x83, %edx
callq 0x20d0
leaq 0x10e74(%rip), %rdi     # 0x37ded
leaq 0x106bd(%rip), %rsi     # 0x3763d
leaq 0x10deb(%rip), %rcx     # 0x37d72
movl $0x84, %edx
callq 0x20d0
leaq 0x10e66(%rip), %rdi     # 0x37dfe
leaq 0x1069e(%rip), %rsi     # 0x3763d
leaq 0x10dcc(%rip), %rcx     # 0x37d72
movl $0x85, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/square__test.cpp
// Function: test_is_dark_sq()
void test_is_dark_sq() {
    assert(is_dark_sq(H8));
    assert(!is_dark_sq(G8));
    assert(is_dark_sq(F8));
    assert(!is_dark_sq(H7));
    assert(is_dark_sq(G7));
    assert(!is_dark_sq(F7));
    assert(is_dark_sq(H6));
    assert(!is_dark_sq(G6));
    assert(is_dark_sq(F6));
}

// Assembly:
pushq %rax
movl $0x7, %edi
callq 0xce27
testb %al, %al
je 0x27055
movl $0x6, %edi
callq 0xce27
testb %al, %al
jne 0x27074
movl $0x5, %edi
callq 0xce27
testb %al, %al
je 0x27093
movl $0xf, %edi
callq 0xce27
testb %al, %al
jne 0x270b2
movl $0xe, %edi
callq 0xce27
testb %al, %al
je 0x270d1
movl $0xd, %edi
callq 0xce27
testb %al, %al
jne 0x270f0
movl $0x17, %edi
callq 0xce27
testb %al, %al
je 0x2710f
movl $0x16, %edi
callq 0xce27
testb %al, %al
jne 0x2712e
movl $0x15, %edi
callq 0xce27
testb %al, %al
je 0x2714d
popq %rax
retq
leaq 0x10db2(%rip), %rdi     # 0x37e0e
leaq 0x105da(%rip), %rsi     # 0x3763d
leaq 0x10db3(%rip), %rcx     # 0x37e1d
movl $0x89, %edx
callq 0x20d0
leaq 0x10db9(%rip), %rdi     # 0x37e34
leaq 0x105bb(%rip), %rsi     # 0x3763d
leaq 0x10d94(%rip), %rcx     # 0x37e1d
movl $0x8a, %edx
callq 0x20d0
leaq 0x10daa(%rip), %rdi     # 0x37e44
leaq 0x1059c(%rip), %rsi     # 0x3763d
leaq 0x10d75(%rip), %rcx     # 0x37e1d
movl $0x8b, %edx
callq 0x20d0
leaq 0x10d9a(%rip), %rdi     # 0x37e53
leaq 0x1057d(%rip), %rsi     # 0x3763d
leaq 0x10d56(%rip), %rcx     # 0x37e1d
movl $0x8c, %edx
callq 0x20d0
leaq 0x10d8b(%rip), %rdi     # 0x37e63
leaq 0x1055e(%rip), %rsi     # 0x3763d
leaq 0x10d37(%rip), %rcx     # 0x37e1d
movl $0x8d, %edx
callq 0x20d0
leaq 0x10d7b(%rip), %rdi     # 0x37e72
leaq 0x1053f(%rip), %rsi     # 0x3763d
leaq 0x10d18(%rip), %rcx     # 0x37e1d
movl $0x8e, %edx
callq 0x20d0
leaq 0x10d6c(%rip), %rdi     # 0x37e82
leaq 0x10520(%rip), %rsi     # 0x3763d
leaq 0x10cf9(%rip), %rcx     # 0x37e1d
movl $0x8f, %edx
callq 0x20d0
leaq 0x10d5c(%rip), %rdi     # 0x37e91
leaq 0x10501(%rip), %rsi     # 0x3763d
leaq 0x10cda(%rip), %rcx     # 0x37e1d
movl $0x90, %edx
callq 0x20d0
leaq 0x10d4d(%rip), %rdi     # 0x37ea1
leaq 0x104e2(%rip), %rsi     # 0x3763d
leaq 0x10cbb(%rip), %rcx     # 0x37e1d
movl $0x91, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/square__test.cpp
// Function: test_is_diagonal()
void test_is_diagonal() {
    assert(is_diagonal(A1,B2));
    assert(!is_diagonal(A1,A2));
    assert(is_diagonal(D4,G7));
    assert(is_diagonal(G7,B2));
    assert(!is_diagonal(C2,E2));
    assert(is_diagonal(A8,H1));
}

// Assembly:
pushq %rax
movl $0x38, %edi
movl $0x31, %esi
callq 0xce56
testb %al, %al
je 0x271ee
movl $0x38, %edi
movl $0x30, %esi
callq 0xce56
testb %al, %al
jne 0x2720d
movl $0x23, %edi
movl $0xe, %esi
callq 0xce56
testb %al, %al
je 0x2722c
movl $0xe, %edi
movl $0x31, %esi
callq 0xce56
testb %al, %al
je 0x2724b
movl $0x32, %edi
movl $0x34, %esi
callq 0xce56
testb %al, %al
jne 0x2726a
xorl %edi, %edi
movl $0x3f, %esi
callq 0xce56
testb %al, %al
je 0x27289
popq %rax
retq
leaq 0x10cbb(%rip), %rdi     # 0x37eb0
leaq 0x10441(%rip), %rsi     # 0x3763d
leaq 0x10cc0(%rip), %rcx     # 0x37ec3
movl $0x95, %edx
callq 0x20d0
leaq 0x10cc7(%rip), %rdi     # 0x37edb
leaq 0x10422(%rip), %rsi     # 0x3763d
leaq 0x10ca1(%rip), %rcx     # 0x37ec3
movl $0x96, %edx
callq 0x20d0
leaq 0x10cbc(%rip), %rdi     # 0x37eef
leaq 0x10403(%rip), %rsi     # 0x3763d
leaq 0x10c82(%rip), %rcx     # 0x37ec3
movl $0x97, %edx
callq 0x20d0
leaq 0x10cb0(%rip), %rdi     # 0x37f02
leaq 0x103e4(%rip), %rsi     # 0x3763d
leaq 0x10c63(%rip), %rcx     # 0x37ec3
movl $0x98, %edx
callq 0x20d0
leaq 0x10ca4(%rip), %rdi     # 0x37f15
leaq 0x103c5(%rip), %rsi     # 0x3763d
leaq 0x10c44(%rip), %rcx     # 0x37ec3
movl $0x99, %edx
callq 0x20d0
leaq 0x10c99(%rip), %rdi     # 0x37f29
leaq 0x103a6(%rip), %rsi     # 0x3763d
leaq 0x10c25(%rip), %rcx     # 0x37ec3
movl $0x9a, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/square__test.cpp
// Function: test_square()
void test_square() {
    test_rank();
    test_file();
    test_rank_distance();
    test_file_distance();
    test_distance();
    test_get_dir();
    test_north();
    test_east();
    test_south();
    test_west();
    test_northeast();
    test_southeast();
    test_southwest();
    test_northwest();
    test_is_light_sq();
    test_is_dark_sq();
    test_is_diagonal();
}

// Assembly:
pushq %rax
callq 0x262d6
callq 0x26429
callq 0x2673e
callq 0x265bb
callq 0x2680c
callq 0x26118
callq 0x268d7
callq 0x26964
callq 0x269f1
callq 0x26a7e
callq 0x26b0b
callq 0x26bc6
callq 0x26c81
callq 0x26d3c
callq 0x26df7
callq 0x26fb0
popq %rax
jmp 0x2716c
nop
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/time__test.cpp
// Function: test_get_search_time()
void test_get_search_time() {
    // should leave 1/10th second on the clock if possible
    assert(get_search_time(100,0)==0);
    assert(get_search_time(99,0)==0);
    assert(get_search_time(25,0)==0);
    assert(get_search_time(-1,3)==0);
    assert(get_search_time(-25,2)==0);

    assert(get_search_time(380,299)==214);
}

// Assembly:
pushq %rax
movl $0x64, %edi
xorl %esi, %esi
callq 0xdf4f
testl %eax, %eax
jne 0x2737f
movl $0x63, %edi
xorl %esi, %esi
callq 0xdf4f
testl %eax, %eax
jne 0x2739e
movl $0x19, %edi
xorl %esi, %esi
callq 0xdf4f
testl %eax, %eax
jne 0x273bd
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x3, %esi
callq 0xdf4f
testl %eax, %eax
jne 0x273dc
movl $0xffffffe7, %edi       # imm = 0xFFFFFFE7
movl $0x2, %esi
callq 0xdf4f
testl %eax, %eax
jne 0x273fb
movl $0x17c, %edi            # imm = 0x17C
movl $0x12b, %esi            # imm = 0x12B
callq 0xdf4f
cmpl $0xd6, %eax
jne 0x2741a
popq %rax
retq
leaq 0x10bb6(%rip), %rdi     # 0x37f3c
leaq 0x10bc9(%rip), %rsi     # 0x37f56
leaq 0x10bd6(%rip), %rcx     # 0x37f6a
movl $0x7, %edx
callq 0x20d0
leaq 0x10be1(%rip), %rdi     # 0x37f86
leaq 0x10baa(%rip), %rsi     # 0x37f56
leaq 0x10bb7(%rip), %rcx     # 0x37f6a
movl $0x8, %edx
callq 0x20d0
leaq 0x10bdb(%rip), %rdi     # 0x37f9f
leaq 0x10b8b(%rip), %rsi     # 0x37f56
leaq 0x10b98(%rip), %rcx     # 0x37f6a
movl $0x9, %edx
callq 0x20d0
leaq 0x10bd5(%rip), %rdi     # 0x37fb8
leaq 0x10b6c(%rip), %rsi     # 0x37f56
leaq 0x10b79(%rip), %rcx     # 0x37f6a
movl $0xa, %edx
callq 0x20d0
leaq 0x10bcf(%rip), %rdi     # 0x37fd1
leaq 0x10b4d(%rip), %rsi     # 0x37f56
leaq 0x10b5a(%rip), %rcx     # 0x37f6a
movl $0xb, %edx
callq 0x20d0
leaq 0x10bca(%rip), %rdi     # 0x37feb
leaq 0x10b2e(%rip), %rsi     # 0x37f56
leaq 0x10b3b(%rip), %rcx     # 0x37f6a
movl $0xd, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/utils__test.cpp
// Function: test_str_to_sq()
void test_str_to_sq() {
    assert(str_to_sq("-")==NO_SQUARE);
    assert(str_to_sq("e3")==E3);
    assert(str_to_sq("a8")==A8);
    assert(str_to_sq("C5")==C5);
}

// Assembly:
pushq %rax
leaq 0x93b7(%rip), %rdi      # 0x3085a
callq 0xdf7d
cmpl $0x40, %eax
jne 0x274e1
leaq 0x10d64(%rip), %rdi     # 0x38218
callq 0xdf7d
cmpl $0x2c, %eax
jne 0x27500
leaq 0x10bf5(%rip), %rdi     # 0x380ba
callq 0xdf7d
testl %eax, %eax
jne 0x2751f
leaq 0x10c0d(%rip), %rdi     # 0x380e2
callq 0xdf7d
cmpl $0x1a, %eax
jne 0x2753e
popq %rax
retq
leaq 0x10b8e(%rip), %rdi     # 0x38076
leaq 0x10b38(%rip), %rsi     # 0x38027
leaq 0x10b9a(%rip), %rcx     # 0x38090
movl $0x14, %edx
callq 0x20d0
leaq 0x10b9f(%rip), %rdi     # 0x380a6
leaq 0x10b19(%rip), %rsi     # 0x38027
leaq 0x10b7b(%rip), %rcx     # 0x38090
movl $0x15, %edx
callq 0x20d0
leaq 0x10b97(%rip), %rdi     # 0x380bd
leaq 0x10afa(%rip), %rsi     # 0x38027
leaq 0x10b5c(%rip), %rcx     # 0x38090
movl $0x16, %edx
callq 0x20d0
leaq 0x10b8c(%rip), %rdi     # 0x380d1
leaq 0x10adb(%rip), %rsi     # 0x38027
leaq 0x10b3d(%rip), %rcx     # 0x38090
movl $0x17, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/utils__test.cpp
// Function: test_sq_to_str()
void test_sq_to_str() {
    char str[3];
    sq_to_str(E3,str);
    assert(!strcmp("e3",str));

    sq_to_str(H8,str);
    assert(!strcmp("h8",str));

    sq_to_str(C6,str);
    assert(!strcmp("c6",str));
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xd(%rsp), %rbx
movl $0x2c, %edi
movq %rbx, %rsi
callq 0xdfc5
movzwl (%rbx), %eax
xorl $0x3365, %eax           # imm = 0x3365
movzbl 0x2(%rbx), %ecx
orw %ax, %cx
jne 0x275d1
leaq 0xd(%rsp), %rbx
movl $0x7, %edi
movq %rbx, %rsi
callq 0xdfc5
movzwl (%rbx), %eax
xorl $0x3868, %eax           # imm = 0x3868
movzbl 0x2(%rbx), %ecx
orw %ax, %cx
jne 0x275f0
leaq 0xd(%rsp), %rbx
movl $0x12, %edi
movq %rbx, %rsi
callq 0xdfc5
movzwl (%rbx), %eax
xorl $0x3663, %eax           # imm = 0x3663
movzbl 0x2(%rbx), %ecx
orw %ax, %cx
jne 0x2760f
addq $0x10, %rsp
popq %rbx
retq
leaq 0x10b0d(%rip), %rdi     # 0x380e5
leaq 0x10a48(%rip), %rsi     # 0x38027
leaq 0x10b11(%rip), %rcx     # 0x380f7
movl $0x1d, %edx
callq 0x20d0
leaq 0x10b19(%rip), %rdi     # 0x38110
leaq 0x10a29(%rip), %rsi     # 0x38027
leaq 0x10af2(%rip), %rcx     # 0x380f7
movl $0x20, %edx
callq 0x20d0
leaq 0x10b0c(%rip), %rdi     # 0x38122
leaq 0x10a0a(%rip), %rsi     # 0x38027
leaq 0x10ad3(%rip), %rcx     # 0x380f7
movl $0x23, %edx
callq 0x20d0