LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_pawn()
void test_eval_pawn() {
    position pos;
    reset_pos(&pos);
    assert(eval_pawn(&pos,E2,true)==pawn_pst[E2]);
    assert(eval_pawn(&pos,B7,false)==pawn_pst[B2]);
    assert(eval_pawn(&pos,B7,false)==eval_pawn(&pos,B2,true));
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xaa51
movq %rbx, %rdi
movl $0x34, %esi
movl $0x1, %edx
callq 0x5c24
cmpl $-0x3, %eax
jne 0x12149
movq %rsp, %rdi
movl $0x9, %esi
xorl %edx, %edx
callq 0x5c24
testl %eax, %eax
jne 0x12168
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x9, %esi
xorl %edx, %edx
callq 0x5c24
movl %eax, %ebp
movq %rbx, %rdi
movl $0x31, %esi
movl $0x1, %edx
callq 0x5c24
cmpl %eax, %ebp
jne 0x12187
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %rbp
retq
leaq 0x1cfe8(%rip), %rdi     # 0x2f138
leaq 0x1cfb2(%rip), %rsi     # 0x2f109
leaq 0x1d000(%rip), %rcx     # 0x2f15e
movl $0x18, %edx
callq 0x20d0
leaq 0x1d005(%rip), %rdi     # 0x2f174
leaq 0x1cf93(%rip), %rsi     # 0x2f109
leaq 0x1cfe1(%rip), %rcx     # 0x2f15e
movl $0x19, %edx
callq 0x20d0
leaq 0x1d00d(%rip), %rdi     # 0x2f19b
leaq 0x1cf74(%rip), %rsi     # 0x2f109
leaq 0x1cfc2(%rip), %rcx     # 0x2f15e
movl $0x1a, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_knight()
void test_eval_knight() {
    position pos;
    reset_pos(&pos);
    assert(eval_knight(&pos,F3,true)==knight_pst[F3] + knight_tropism * distance(F3,E8));
    assert(eval_knight(&pos,D6,true)==knight_pst[D6] + knight_tropism * distance(D6,E8));
    assert(eval_knight(&pos,H3,false)==knight_pst[H6] + knight_tropism * distance(H6,E8));
    assert(eval_knight(&pos,F7,false)==knight_pst[F2] + knight_tropism * distance(F2,E8));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa51
movq %rbx, %rdi
movl $0x2d, %esi
movl $0x1, %edx
callq 0x50fa
movl %eax, %ebx
movl $0x2d, %edi
movl $0x4, %esi
callq 0xcb96
addl %eax, %eax
movl $0x8, %ecx
subl %eax, %ecx
cmpl %ecx, %ebx
jne 0x12281
leaq 0x8(%rsp), %rdi
movl $0x13, %esi
movl $0x1, %edx
callq 0x50fa
movl %eax, %ebx
movl $0x13, %edi
movl $0x4, %esi
callq 0xcb96
addl %eax, %eax
movl $0x14, %ecx
subl %eax, %ecx
cmpl %ecx, %ebx
jne 0x122a0
leaq 0x8(%rsp), %rdi
movl $0x2f, %esi
xorl %edx, %edx
callq 0x50fa
movl %eax, %ebx
movl $0x17, %edi
movl $0x4, %esi
callq 0xcb96
addl %eax, %eax
movl $0xfffffffb, %ecx       # imm = 0xFFFFFFFB
subl %eax, %ecx
cmpl %ecx, %ebx
jne 0x122bf
leaq 0x8(%rsp), %rdi
movl $0xd, %esi
xorl %edx, %edx
callq 0x50fa
movl %eax, %ebx
movl $0x35, %edi
movl $0x4, %esi
callq 0xcb96
addl %eax, %eax
addl %ebx, %eax
jne 0x122de
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1cf45(%rip), %rdi     # 0x2f1cd
leaq 0x1ce7a(%rip), %rsi     # 0x2f109
leaq 0x1cf84(%rip), %rcx     # 0x2f21a
movl $0x20, %edx
callq 0x20d0
leaq 0x1cf8b(%rip), %rdi     # 0x2f232
leaq 0x1ce5b(%rip), %rsi     # 0x2f109
leaq 0x1cf65(%rip), %rcx     # 0x2f21a
movl $0x21, %edx
callq 0x20d0
leaq 0x1cfb9(%rip), %rdi     # 0x2f27f
leaq 0x1ce3c(%rip), %rsi     # 0x2f109
leaq 0x1cf46(%rip), %rcx     # 0x2f21a
movl $0x22, %edx
callq 0x20d0
leaq 0x1cfe8(%rip), %rdi     # 0x2f2cd
leaq 0x1ce1d(%rip), %rsi     # 0x2f109
leaq 0x1cf27(%rip), %rcx     # 0x2f21a
movl $0x23, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_bishop()
void test_eval_bishop() {
    position pos;

    set_pos(&pos,"6k1/3B4/8/8/8/8/8/K7 w - - 0 1");
    assert(eval(&pos,false)==bishop_val + bishop_pst[D7]);

    set_pos(&pos,"6k1/8/8/3B4/8/8/8/K7 w - - 0 1");
    assert(eval(&pos,false)==bishop_val + bishop_pst[D5]);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1d00f(%rip), %rsi     # 0x2f31b
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl $0x147, %eax            # imm = 0x147
jne 0x12358
leaq 0x1d04f(%rip), %rsi     # 0x2f380
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl $0x154, %eax            # imm = 0x154
jne 0x12377
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1cfdb(%rip), %rdi     # 0x2f33a
leaq 0x1cda3(%rip), %rsi     # 0x2f109
leaq 0x1cffb(%rip), %rcx     # 0x2f368
movl $0x2a, %edx
callq 0x20d0
leaq 0x1d021(%rip), %rdi     # 0x2f39f
leaq 0x1cd84(%rip), %rsi     # 0x2f109
leaq 0x1cfdc(%rip), %rcx     # 0x2f368
movl $0x2d, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_rook_on_7th()
void test_eval_rook_on_7th() {
    position pos;
    set_pos(&pos,"7k/8/8/8/8/8/r7/7K w - - 0 1");
    int32_pair npmat = eval_nonpawn_material(&pos);
    assert(npmat.val1==0);
    assert(npmat.val2==rook_val);

    assert(eval(&pos,false)==-rook_val - rook_on_7th - rook_open_file);

    // move king out
    set_pos(&pos,"7k/8/8/8/8/7K/r7/8 w - - 0 1");
    assert(eval(&pos,false)==-rook_val - rook_open_file);

    // flipped
    set_pos(&pos,"7k/8/8/8/8/7K/r7/8 b - - 0 1");
    assert(eval(&pos,false)==rook_val  + rook_open_file);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1d12e(%rip), %rsi     # 0x2f6a9
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
callq 0x56fe
testl %eax, %eax
jne 0x1261d
movabsq $0x1f400000000, %rcx    # imm = 0x1F400000000
cmpq %rcx, %rax
jne 0x1263c
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x58f7
cmpl $0xfffffdc1, %eax       # imm = 0xFFFFFDC1
jne 0x1265b
leaq 0x1d178(%rip), %rsi     # 0x2f741
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl $0xfffffdf3, %eax       # imm = 0xFFFFFDF3
jne 0x1267a
leaq 0x1d199(%rip), %rsi     # 0x2f78b
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl $0x20d, %eax            # imm = 0x20D
jne 0x12699
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d0a2(%rip), %rdi     # 0x2f6c6
leaq 0x1cade(%rip), %rsi     # 0x2f109
leaq 0x1d0a2(%rip), %rcx     # 0x2f6d4
movl $0x55, %edx
callq 0x20d0
leaq 0x1d0ae(%rip), %rdi     # 0x2f6f1
leaq 0x1cabf(%rip), %rsi     # 0x2f109
leaq 0x1d083(%rip), %rcx     # 0x2f6d4
movl $0x56, %edx
callq 0x20d0
leaq 0x1d0a4(%rip), %rdi     # 0x2f706
leaq 0x1caa0(%rip), %rsi     # 0x2f109
leaq 0x1d064(%rip), %rcx     # 0x2f6d4
movl $0x58, %edx
callq 0x20d0
leaq 0x1d0dd(%rip), %rdi     # 0x2f75e
leaq 0x1ca81(%rip), %rsi     # 0x2f109
leaq 0x1d045(%rip), %rcx     # 0x2f6d4
movl $0x5c, %edx
callq 0x20d0
leaq 0x1d108(%rip), %rdi     # 0x2f7a8
leaq 0x1ca62(%rip), %rsi     # 0x2f109
leaq 0x1d026(%rip), %rcx     # 0x2f6d4
movl $0x60, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_connected_majors_7th()
void test_eval_connected_majors_7th() {
    position pos;
    set_pos(&pos,"7k/R2R4/8/8/8/8/8/7K w - - 0 1");
    assert(eval(&pos,false)==rook_val*2 + rook_on_7th*2 + connected_majors_on_7th
            + rook_open_file*2);

    set_pos(&pos,"7k/R2RQ3/8/8/8/8/8/7K w - - 0 1");
    int32 expected = rook_val*2 + queen_val
            + rook_on_7th*3
            + connected_majors_on_7th*2
            + rook_open_file*2
            - eval_scale(king_safety_pawn_far_away // f file
                       + king_safety_pawn_far_away // g file
                       + (king_safety_pawn_far_away/2), // h file
                       rook_val*2+queen_val);
    assert(eval(&pos,false)==expected);

    // flip it
    set_pos(&pos,"7k/R2QR3/8/8/8/8/8/7K b - - 0 1");
    assert(eval(&pos,false)==-expected);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1d10a(%rip), %rsi     # 0x2f7d4
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl $0x4ce, %eax            # imm = 0x4CE
jne 0x12756
leaq 0x1d184(%rip), %rsi     # 0x2f873
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaa82
movl $0xffffffb5, %edi       # imm = 0xFFFFFFB5
movl $0x76c, %esi            # imm = 0x76C
callq 0x5545
movl %eax, %ebx
movl $0x8d4, %ebp            # imm = 0x8D4
subl %eax, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl %ebp, %eax
jne 0x12775
addl $0xfffff72c, %ebx       # imm = 0xFFFFF72C
leaq 0x1d17f(%rip), %rsi     # 0x2f8ae
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaa82
movq %r14, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl %ebx, %eax
jne 0x12794
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1d096(%rip), %rdi     # 0x2f7f3
leaq 0x1c9a5(%rip), %rsi     # 0x2f109
leaq 0x1d0e2(%rip), %rcx     # 0x2f84d
movl $0x67, %edx
callq 0x20d0
leaq 0x1d117(%rip), %rdi     # 0x2f893
leaq 0x1c986(%rip), %rsi     # 0x2f109
leaq 0x1d0c3(%rip), %rcx     # 0x2f84d
movl $0x72, %edx
callq 0x20d0
leaq 0x1d133(%rip), %rdi     # 0x2f8ce
leaq 0x1c967(%rip), %rsi     # 0x2f109
leaq 0x1d0a4(%rip), %rcx     # 0x2f84d
movl $0x76, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_rook_open_file()
void test_eval_rook_open_file() {
    position pos;

    set_pos(&pos,"3r3k/8/8/8/8/8/8/7K b - - 0 1");
    assert(eval(&pos,false)==rook_val + rook_open_file);

    set_pos(&pos,"3r3k/3r4/8/8/8/8/8/7K b - - 0 1");
    assert(eval(&pos,false)==rook_val*2 + rook_open_file*2);

    set_pos(&pos,"3r3k/8/3p4/8/8/8/8/7K b - - 0 1");
    assert(eval(&pos,false)==rook_val+pawn_val +passed_pawn+isolated_pawn
            + pawn_pst[fliprank[D6]]);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1d128(%rip), %rsi     # 0x2f8ea
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl $0x20d, %eax            # imm = 0x20D
jne 0x12833
leaq 0x1d141(%rip), %rsi     # 0x2f928
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl $0x41a, %eax            # imm = 0x41A
jne 0x12852
leaq 0x1d16c(%rip), %rsi     # 0x2f978
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl $0x25d, %eax            # imm = 0x25D
jne 0x12871
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1cf6e(%rip), %rdi     # 0x2f7a8
leaq 0x1c8c8(%rip), %rsi     # 0x2f109
leaq 0x1d0c0(%rip), %rcx     # 0x2f908
movl $0x7d, %edx
callq 0x20d0
leaq 0x1d0ef(%rip), %rdi     # 0x2f948
leaq 0x1c8a9(%rip), %rsi     # 0x2f109
leaq 0x1d0a1(%rip), %rcx     # 0x2f908
movl $0x80, %edx
callq 0x20d0
leaq 0x1d120(%rip), %rdi     # 0x2f998
leaq 0x1c88a(%rip), %rsi     # 0x2f109
leaq 0x1d082(%rip), %rcx     # 0x2f908
movl $0x84, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_rook_half_open_file()
void test_eval_rook_half_open_file() {
    position pos;

    set_pos(&pos,"8/2P5/8/2R5/K7/8/7k/8 w - - 0 1");
    assert(eval(&pos,false)==rook_val + pawn_val  + passed_pawn + isolated_pawn
            + pawn_pst[C7]);

    set_pos(&pos,"8/2p5/8/2R5/K7/8/7k/8 w - - 0 1");
    assert(eval(&pos,false)==rook_val-pawn_val -passed_pawn-isolated_pawn
            + pawn_pst[fliprank[C7]]
            + rook_half_open_file);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1d151(%rip), %rsi     # 0x2f9f0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl $0x276, %eax            # imm = 0x276
jne 0x128eb
leaq 0x1d1c4(%rip), %rsi     # 0x2fa88
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl $0x19f, %eax            # imm = 0x19F
jne 0x1290a
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d11e(%rip), %rdi     # 0x2fa10
leaq 0x1c810(%rip), %rsi     # 0x2f109
leaq 0x1d163(%rip), %rcx     # 0x2fa63
movl $0x8c, %edx
callq 0x20d0
leaq 0x1d197(%rip), %rdi     # 0x2faa8
leaq 0x1c7f1(%rip), %rsi     # 0x2f109
leaq 0x1d144(%rip), %rcx     # 0x2fa63
movl $0x91, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_queen()
void test_eval_queen() {
    position pos;

    set_pos(&pos,"3kq3/8/8/8/8/8/8/3K4 b - - 0 1");
    assert(eval(&pos,false)==queen_val + queen_pst[fliprank[E8]]);
    int32_pair npmat = eval_nonpawn_material(&pos);
    assert(npmat.val1==0);
    assert(npmat.val2==queen_val);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1d1de(%rip), %rsi     # 0x2fb16
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl $0x383, %eax            # imm = 0x383
jne 0x1297c
leaq 0x8(%rsp), %rdi
callq 0x56fe
testl %eax, %eax
jne 0x1299b
movabsq $0x38400000000, %rcx    # imm = 0x38400000000
cmpq %rcx, %rax
jne 0x129ba
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d1b2(%rip), %rdi     # 0x2fb35
leaq 0x1c77f(%rip), %rsi     # 0x2f109
leaq 0x1d1da(%rip), %rcx     # 0x2fb6b
movl $0x98, %edx
callq 0x20d0
leaq 0x1cd24(%rip), %rdi     # 0x2f6c6
leaq 0x1c760(%rip), %rsi     # 0x2f109
leaq 0x1d1bb(%rip), %rcx     # 0x2fb6b
movl $0x9a, %edx
callq 0x20d0
leaq 0x1d1c1(%rip), %rdi     # 0x2fb82
leaq 0x1c741(%rip), %rsi     # 0x2f109
leaq 0x1d19c(%rip), %rcx     # 0x2fb6b
movl $0x9b, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_king_pst()
void test_king_pst() {
    position pos;

    set_pos(&pos,"rnbqkbnr/pppppppp/8/8/3P4/3BPN2/PPP2PPP/RNBQR1K1 w - - 0 1");
    int32_pair npmat = eval_nonpawn_material(&pos);
    assert(0==npmat.val1-npmat.val2);

    int32_pair pmat = eval_pawn_material(&pos);
    assert(0==pmat.val1-pmat.val2);

    int32 score = eval(&pos,false);

    int32 tropism_delta = knight_tropism * distance(F3,pos.black_king)
        - knight_tropism * distance(G1,pos.black_king);

    assert(score==pawn_pst[D4] -pawn_pst[D2] + pawn_pst[E3] -pawn_pst[E2]
                 + bishop_pst[D3] - bishop_pst[F1]
                 + knight_pst[F3] - knight_pst[G1]
                 + rook_pst[E1] - rook_pst[H1]
                 + king_pst[G1] - king_pst[E1]
                 + tropism_delta);

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1d1ad(%rip), %rsi     # 0x2fb98
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
callq 0x56fe
movq %rax, %rcx
shrq $0x20, %rcx
cmpl %ecx, %eax
jne 0x12a6e
leaq 0x8(%rsp), %rdi
callq 0x5811
movq %rax, %rcx
shrq $0x20, %rcx
cmpl %ecx, %eax
jne 0x12a8d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
movl %eax, %ebp
movl 0x150(%rbx), %esi
movl $0x2d, %edi
callq 0xcb96
movl %eax, %r14d
movl 0x150(%rbx), %esi
movl $0x3e, %edi
callq 0xcb96
subl %r14d, %eax
leal 0x47(,%rax,2), %eax
cmpl %eax, %ebp
jne 0x12aac
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1d15e(%rip), %rdi     # 0x2fbd3
leaq 0x1c68d(%rip), %rsi     # 0x2f109
leaq 0x1d169(%rip), %rcx     # 0x2fbec
movl $0xa3, %edx
callq 0x20d0
leaq 0x1d16d(%rip), %rdi     # 0x2fc01
leaq 0x1c66e(%rip), %rsi     # 0x2f109
leaq 0x1d14a(%rip), %rcx     # 0x2fbec
movl $0xa6, %edx
callq 0x20d0
leaq 0x1d165(%rip), %rdi     # 0x2fc18
leaq 0x1c64f(%rip), %rsi     # 0x2f109
leaq 0x1d12b(%rip), %rcx     # 0x2fbec
movl $0xb2, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_king_endgame_pst()
void test_king_endgame_pst() {
    position pos;

    set_pos(&pos,"8/8/8/4k3/8/8/8/RNB2K2 w - - 0 1");

    int32_pair npmat = eval_nonpawn_material(&pos);
    int32 expected = rook_val + knight_val + bishop_val;
    assert(expected==npmat.val1);
    assert(0==npmat.val2);

    expected += rook_open_file + knight_pst[B1]
            + knight_tropism * distance(B1,pos.black_king)
            + king_endgame_pst[F1] - king_pst[E5]
            - eval_scale(king_safety_middle_open_file,rook_val+knight_val+bishop_val);
    assert(expected==eval(&pos,false));

    // by removing a bishop both sides should be evaluated as in the endgame
    set_pos(&pos,"8/8/8/4k3/8/8/8/RN3K2 b - - 0 1");

    expected = -rook_val - knight_val - rook_open_file
            - knight_pst[B1]
            - knight_tropism * distance(B1,pos.black_king)
            - king_endgame_pst[F1]
            + king_endgame_pst[E5];
    assert(expected==eval(&pos,false));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1d20a(%rip), %rsi     # 0x2fce7
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
callq 0x56fe
cmpl $0x460, %eax            # imm = 0x460
jne 0x12b90
shrq $0x20, %rax
jne 0x12baf
leaq 0x8(%rsp), %rbx
movl 0x150(%rbx), %esi
movl $0x39, %edi
callq 0xcb96
movl %eax, %r14d
movl $0xffffffce, %edi       # imm = 0xFFFFFFCE
movl $0x460, %esi            # imm = 0x460
callq 0x5545
leal (%rax,%r14,2), %eax
movl $0x48d, %ebp            # imm = 0x48D
subl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl %eax, %ebp
jne 0x12bce
leaq 0x1d211(%rip), %rsi     # 0x2fd63
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movl 0x150(%rbx), %esi
movl $0x39, %edi
callq 0xcb96
leal -0x316(,%rax,2), %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl %eax, %ebp
jne 0x12bed
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1d171(%rip), %rdi     # 0x2fd08
leaq 0x1c56b(%rip), %rsi     # 0x2f109
leaq 0x1d178(%rip), %rcx     # 0x2fd1d
movl $0xbd, %edx
callq 0x20d0
leaq 0x1d184(%rip), %rdi     # 0x2fd3a
leaq 0x1c54c(%rip), %rsi     # 0x2f109
leaq 0x1d159(%rip), %rcx     # 0x2fd1d
movl $0xbe, %edx
callq 0x20d0
leaq 0x1d173(%rip), %rdi     # 0x2fd48
leaq 0x1c52d(%rip), %rsi     # 0x2f109
leaq 0x1d13a(%rip), %rcx     # 0x2fd1d
movl $0xc4, %edx
callq 0x20d0
leaq 0x1d154(%rip), %rdi     # 0x2fd48
leaq 0x1c50e(%rip), %rsi     # 0x2f109
leaq 0x1d11b(%rip), %rcx     # 0x2fd1d
movl $0xce, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_king_safety_middle_files()
void test_king_safety_middle_files() {
    position pos;

    // initial position then e3... no penalty
    set_pos(&pos,"rnbqkbnr/pppppppp/8/8/8/4P3/PPPP1PPP/RNBQKBNR w KQkq - 0 1");
    int32 score = eval(&pos,false);
    assert(score==pawn_pst[E3]-pawn_pst[E2]);

    // open file for both, so still no penalty
    set_pos(&pos,"rnbqkbnr/pppp1ppp/8/8/8/8/PPPP1PPP/RNBQKBNR w KQkq - 0 1");
    score = eval(&pos,false);
    assert(score==0);

    // remove both queens.  open e file.  put black king on d8
    set_pos(&pos,"rnbk1bnr/pppp1ppp/8/8/8/8/PPPP1PPP/RNB1KBNR b KQ - 0 1");
    score = eval(&pos,false);
    assert(score== -eval_scale(king_safety_middle_open_file,
            rook_val*2 + knight_val*2 + bishop_val*2) + king_pst[fliprank[D8]]);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1d168(%rip), %rsi     # 0x2fd83
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl $0x8, %eax
jne 0x12c9c
leaq 0x1d1c6(%rip), %rsi     # 0x2fe04
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
testl %eax, %eax
jne 0x12cbb
leaq 0x1d1dd(%rip), %rsi     # 0x2fe3d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
movl %eax, %ebx
movl $0xffffffce, %edi       # imm = 0xFFFFFFCE
movl $0x8c0, %esi            # imm = 0x8C0
callq 0x5545
movl $0xffffffe7, %ecx       # imm = 0xFFFFFFE7
subl %eax, %ecx
cmpl %ecx, %ebx
jne 0x12cda
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d11b(%rip), %rdi     # 0x2fdbe
leaq 0x1c45f(%rip), %rsi     # 0x2f109
leaq 0x1d12e(%rip), %rcx     # 0x2fddf
movl $0xd7, %edx
callq 0x20d0
leaq 0x1c43e(%rip), %rdi     # 0x2f100
leaq 0x1c440(%rip), %rsi     # 0x2f109
leaq 0x1d10f(%rip), %rcx     # 0x2fddf
movl $0xdc, %edx
callq 0x20d0
leaq 0x1d193(%rip), %rdi     # 0x2fe74
leaq 0x1c421(%rip), %rsi     # 0x2f109
leaq 0x1d0f0(%rip), %rcx     # 0x2fddf
movl $0xe2, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_king_safety_kingside()
void test_king_safety_kingside() {
    position pos;

    // no pawns advanced
    set_pos(&pos,"rnbq1rk1/pppppppp/8/8/8/8/PPPPPPPP/RNBQ1RK1 w kq - 0 1");
    assert(eval(&pos,false)==0);

    // white pawn on f4
    set_pos(&pos,"rnbq1rk1/pppppppp/8/8/8/5P2/PPPPP1PP/RNBQ1RK1 w kq - 0 1");
    assert(eval(&pos,false)==pawn_pst[F3]-pawn_pst[F2]
        + eval_scale(king_safety_pawn_one_away,rook_val*2+knight_val+bishop_val+queen_val));

    // white pawn on g4
    set_pos(&pos,"rnbq1rk1/pppppppp/8/8/6P1/8/PPPPPP1P/RNBQ1RK1 w kq - 0 1");
    assert(eval(&pos,false)==pawn_pst[G4]-pawn_pst[G2]+eval_scale(king_safety_pawn_two_away,rook_val*2+knight_val+bishop_val+queen_val));

    // black pawn on h4
    set_pos(&pos,"rnbq1rk1/ppppppp1/8/8/7p/8/PPPPPPPP/RNBQ1RK1 b KQkq - 0 1");
    assert(eval(&pos,false)==pawn_pst[fliprank[H4]]-pawn_pst[fliprank[H7]]
         +eval_scale(king_safety_pawn_far_away/2,rook_val*2+knight_val+bishop_val+queen_val));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1d1e1(%rip), %rsi     # 0x2fee9
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
testl %eax, %eax
jne 0x12dd6
leaq 0x1d227(%rip), %rsi     # 0x2ff55
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
movl %eax, %ebx
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
movl $0x9d8, %esi            # imm = 0x9D8
callq 0x5545
addl $0x3, %eax
cmpl %eax, %ebx
jne 0x12df5
leaq 0x1d2a5(%rip), %rsi     # 0x3000d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
movl %eax, %ebx
movl $0xffffffec, %edi       # imm = 0xFFFFFFEC
movl $0x9d8, %esi            # imm = 0x9D8
callq 0x5545
addl $0x5, %eax
cmpl %eax, %ebx
jne 0x12e14
leaq 0x1d325(%rip), %rsi     # 0x300c3
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
movl %eax, %ebx
movl $0xfffffff1, %edi       # imm = 0xFFFFFFF1
movl $0x9d8, %esi            # imm = 0x9D8
callq 0x5545
addl $0x7, %eax
cmpl %eax, %ebx
jne 0x12e33
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d143(%rip), %rdi     # 0x2ff20
leaq 0x1c325(%rip), %rsi     # 0x2f109
leaq 0x1d149(%rip), %rcx     # 0x2ff34
movl $0xea, %edx
callq 0x20d0
leaq 0x1d192(%rip), %rdi     # 0x2ff8e
leaq 0x1c306(%rip), %rsi     # 0x2f109
leaq 0x1d12a(%rip), %rcx     # 0x2ff34
movl $0xef, %edx
callq 0x20d0
leaq 0x1d22b(%rip), %rdi     # 0x30046
leaq 0x1c2e7(%rip), %rsi     # 0x2f109
leaq 0x1d10b(%rip), %rcx     # 0x2ff34
movl $0xf3, %edx
callq 0x20d0
leaq 0x1d2c3(%rip), %rdi     # 0x300fd
leaq 0x1c2c8(%rip), %rsi     # 0x2f109
leaq 0x1d0ec(%rip), %rcx     # 0x2ff34
movl $0xf8, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_king_safety_queenside()
void test_king_safety_queenside() {
    position pos;

    // white pawn on c3
    set_pos(&pos,"1krq1bnr/pppppppp/8/8/8/2P5/PP1PPPPP/1KRQ1BNR w kq - 0 1");
    assert(eval(&pos,false)==pawn_pst[C3]-pawn_pst[C2]+eval_scale(king_safety_pawn_one_away,rook_val*2+queen_val+bishop_val+knight_val));

    // white pawn on b4
    set_pos(&pos,"1krq1bnr/pppppppp/8/8/1P6/8/P1PPPPPP/1KRQ1BNR w kq - 0 1");
    assert(eval(&pos,false)==pawn_pst[B4]-pawn_pst[B2]+eval_scale(king_safety_pawn_two_away,rook_val*2+queen_val+bishop_val+knight_val));

    // black pawn on a4
    set_pos(&pos,"1krq1bnr/1ppppppp/8/8/p7/8/PPPPPPPP/1KRQ1BNR b kq - 0 1");
    assert(eval(&pos,false)==pawn_pst[fliprank[A4]]-pawn_pst[fliprank[A7]]
       +eval_scale(king_safety_pawn_far_away/2,rook_val*2+queen_val+bishop_val+knight_val));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1d330(%rip), %rsi     # 0x30191
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
movl %eax, %ebx
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
movl $0x9d8, %esi            # imm = 0x9D8
callq 0x5545
addl $0x3, %eax
cmpl %eax, %ebx
jne 0x12f05
leaq 0x1d3d2(%rip), %rsi     # 0x30269
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
movl %eax, %ebx
movl $0xffffffec, %edi       # imm = 0xFFFFFFEC
movl $0x9d8, %esi            # imm = 0x9D8
callq 0x5545
addl $0x5, %eax
cmpl %eax, %ebx
jne 0x12f24
leaq 0x1d452(%rip), %rsi     # 0x3031f
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
movl %eax, %ebx
movl $0xfffffff1, %edi       # imm = 0xFFFFFFF1
movl $0x9d8, %esi            # imm = 0x9D8
callq 0x5545
addl $0x7, %eax
cmpl %eax, %ebx
jne 0x12f43
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d2be(%rip), %rdi     # 0x301ca
leaq 0x1c1f6(%rip), %rsi     # 0x2f109
leaq 0x1d32d(%rip), %rcx     # 0x30247
movl $0x100, %edx            # imm = 0x100
callq 0x20d0
leaq 0x1d377(%rip), %rdi     # 0x302a2
leaq 0x1c1d7(%rip), %rsi     # 0x2f109
leaq 0x1d30e(%rip), %rcx     # 0x30247
movl $0x104, %edx            # imm = 0x104
callq 0x20d0
leaq 0x1d40d(%rip), %rdi     # 0x30357
leaq 0x1c1b8(%rip), %rsi     # 0x2f109
leaq 0x1d2ef(%rip), %rcx     # 0x30247
movl $0x109, %edx            # imm = 0x109
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_double_and_isolated_pawns()
void test_double_and_isolated_pawns() {
    position pos;

    set_pos(&pos,"k7/p1p3p1/3p3p/1P5P/1PP1P3/8/8/K7 b - - 0 1");
    int32_pair npmat = eval_nonpawn_material(&pos);
    assert(0==npmat.val1);
    assert(0==npmat.val2);

    int32_pair pmat = eval_pawn_material(&pos);
    assert(pawn_val*5==pmat.val1);
    assert(pawn_val*5==pmat.val2);

    int32 expected = king_endgame_pst[fliprank[A8]]
           + pawn_pst[fliprank[A7]] + pawn_pst[fliprank[C7]] + pawn_pst[fliprank[D6]]
           + pawn_pst[fliprank[G7]] + pawn_pst[fliprank[H6]]
           + isolated_pawn // black pawn on a7
           - king_endgame_pst[A1]
           - pawn_pst[B5] - pawn_pst[B4] - pawn_pst[C4] - pawn_pst[E4] - pawn_pst[H5]
           - isolated_pawn*2 // white pawns on e4 and h1
           - doubled_pawn*2;  // white pawns on b4 and b5
    assert(eval(&pos,false)==expected);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1d47a(%rip), %rsi     # 0x303eb
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
callq 0x56fe
testl %eax, %eax
jne 0x12fc9
testq %rax, %rax
jne 0x12fe8
leaq 0x8(%rsp), %rdi
callq 0x5811
cmpl $0x1f4, %eax            # imm = 0x1F4
jne 0x13007
shrq $0x20, %rax
cmpl $0x1f4, %eax            # imm = 0x1F4
jne 0x13026
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x58f7
cmpl $0x11, %eax
jne 0x13045
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d447(%rip), %rdi     # 0x30417
leaq 0x1c132(%rip), %rsi     # 0x2f109
leaq 0x1d447(%rip), %rcx     # 0x30425
movl $0x111, %edx            # imm = 0x111
callq 0x20d0
leaq 0x1cd4b(%rip), %rdi     # 0x2fd3a
leaq 0x1c113(%rip), %rsi     # 0x2f109
leaq 0x1d428(%rip), %rcx     # 0x30425
movl $0x112, %edx            # imm = 0x112
callq 0x20d0
leaq 0x1d43d(%rip), %rdi     # 0x3044b
leaq 0x1c0f4(%rip), %rsi     # 0x2f109
leaq 0x1d409(%rip), %rcx     # 0x30425
movl $0x115, %edx            # imm = 0x115
callq 0x20d0
leaq 0x1d434(%rip), %rdi     # 0x30461
leaq 0x1c0d5(%rip), %rsi     # 0x2f109
leaq 0x1d3ea(%rip), %rcx     # 0x30425
movl $0x116, %edx            # imm = 0x116
callq 0x20d0
leaq 0x1c847(%rip), %rdi     # 0x2f893
leaq 0x1c0b6(%rip), %rsi     # 0x2f109
leaq 0x1d3cb(%rip), %rcx     # 0x30425
movl $0x120, %edx            # imm = 0x120
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_symmetry(int, position*)
bool test_eval_symmetry(int32 score,position *pos) {
    position flip_pos;

    memcpy(&flip_pos,pos,sizeof(position));
    flip_board(&flip_pos);

    int32 score2=eval(&flip_pos,false);
    assert(score==score2);

    flip_board(&flip_pos);
    assert(equal_pos(pos,&flip_pos,true));

    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movl $0x1c8, %edx            # imm = 0x1C8
movq %r14, %rdi
callq 0x2100
movq %r14, %rdi
callq 0xaf6f
movq %r14, %rdi
xorl %esi, %esi
callq 0x58f7
cmpl %ebp, %eax
jne 0x1318f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaf6f
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xa0b8
testb %al, %al
je 0x131ae
movb $0x1, %al
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1d3cd(%rip), %rdi     # 0x30563
leaq 0x1bf6c(%rip), %rsi     # 0x2f109
leaq 0x1d3cd(%rip), %rcx     # 0x30571
movl $0x13e, %edx            # imm = 0x13E
callq 0x20d0
leaq 0x1d3e7(%rip), %rdi     # 0x3059c
leaq 0x1bf4d(%rip), %rsi     # 0x2f109
leaq 0x1d3ae(%rip), %rcx     # 0x30571
movl $0x141, %edx            # imm = 0x141
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval_material()
void test_eval_material() {
    position pos;

    set_pos(&pos,"8/k7/prb5/K7/QN6/8/8/8 b - - 0 1");
    int32_pair np = eval_nonpawn_material(&pos);
    assert(np.val1==queen_val+knight_val);
    assert(np.val2==rook_val+bishop_val);

    int32_pair p = eval_pawn_material(&pos);
    assert(p.val1==0);
    assert(p.val2==pawn_val);

    assert(eval(&pos,true)==pawn_val+rook_val+bishop_val-queen_val-knight_val);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1d82f(%rip), %rsi     # 0x30c10
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
callq 0x56fe
cmpl $0x4b0, %eax            # imm = 0x4B0
jne 0x1344c
shrq $0x20, %rax
cmpl $0x334, %eax            # imm = 0x334
jne 0x1346b
leaq 0x8(%rsp), %rdi
callq 0x5811
testl %eax, %eax
jne 0x1348a
movabsq $0x6400000000, %rcx     # imm = 0x6400000000
cmpq %rcx, %rax
jne 0x134a9
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x58f7
cmpl $0xfffffee8, %eax       # imm = 0xFFFFFEE8
jne 0x134c8
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d7de(%rip), %rdi     # 0x30c31
leaq 0x1bcaf(%rip), %rsi     # 0x2f109
leaq 0x1d7ee(%rip), %rcx     # 0x30c4f
movl $0x170, %edx            # imm = 0x170
callq 0x20d0
leaq 0x1d7f7(%rip), %rdi     # 0x30c69
leaq 0x1bc90(%rip), %rsi     # 0x2f109
leaq 0x1d7cf(%rip), %rcx     # 0x30c4f
movl $0x171, %edx            # imm = 0x171
callq 0x20d0
leaq 0x1d7f5(%rip), %rdi     # 0x30c86
leaq 0x1bc71(%rip), %rsi     # 0x2f109
leaq 0x1d7b0(%rip), %rcx     # 0x30c4f
movl $0x174, %edx            # imm = 0x174
callq 0x20d0
leaq 0x1d7e0(%rip), %rdi     # 0x30c90
leaq 0x1bc52(%rip), %rsi     # 0x2f109
leaq 0x1d791(%rip), %rcx     # 0x30c4f
movl $0x175, %edx            # imm = 0x175
callq 0x20d0
leaq 0x1d7d2(%rip), %rdi     # 0x30ca1
leaq 0x1bc33(%rip), %rsi     # 0x2f109
leaq 0x1d772(%rip), %rcx     # 0x30c4f
movl $0x177, %edx            # imm = 0x177
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_evalfunc()
void test_evalfunc() {
    position pos;

    reset_pos(&pos);
    assert(eval(&pos,false)==0);

    // ensure the score is from the player POV
    set_pos(&pos,"rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1");
    int32 score=eval(&pos,false);
    pos.player=WHITE;
    int32 score2=eval(&pos,false);
    assert(score==-score2);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xaa51
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
testl %eax, %eax
jne 0x135b2
leaq 0x19f7a(%rip), %rsi     # 0x2d4f3
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
movl %eax, %ebp
movl $0x1, 0x138(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58f7
addl %ebp, %eax
jne 0x135d1
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %rbp
retq
leaq 0x1c967(%rip), %rdi     # 0x2ff20
leaq 0x1bb49(%rip), %rsi     # 0x2f109
leaq 0x1d76f(%rip), %rcx     # 0x30d36
movl $0x185, %edx            # imm = 0x185
callq 0x20d0
leaq 0x1d773(%rip), %rdi     # 0x30d4b
leaq 0x1bb2a(%rip), %rsi     # 0x2f109
leaq 0x1d750(%rip), %rcx     # 0x30d36
movl $0x18c, %edx            # imm = 0x18C
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/eval__test.cpp
// Function: test_eval()
void test_eval() {
    test_start_pos_is_0();
    test_eval_pawn();
    test_eval_knight();
    test_eval_bishop();
    test_eval_rook();
    test_eval_rook_on_7th();
    test_eval_connected_majors_7th();
    test_eval_rook_open_file();
    test_eval_rook_half_open_file();
    test_eval_queen();
    test_king_pst();
    test_king_endgame_pst();
    test_king_safety_middle_files();
    test_king_safety_kingside();
    test_king_safety_queenside();
    test_double_and_isolated_pawns();
    test_score1();
    test_score2();
    test_vertical_symmetry();
    test_eval_material();
    test_eval_scale();
    test_evalfunc();
}

// Assembly:
pushq %rax
callq 0x1208c
callq 0x120d7
callq 0x121a6
callq 0x122fd
callq 0x12396
callq 0x1256c
callq 0x126b8
callq 0x127b3
callq 0x12890
callq 0x12929
callq 0x129d9
callq 0x12acb
callq 0x12c0c
callq 0x12cf9
callq 0x12e52
callq 0x12f62
callq 0x13064
callq 0x130b7
callq 0x131cd
callq 0x133d2
callq 0x134e7
popq %rax
jmp 0x13550
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/evalp__test.cpp
// Function: test_passed_pawn_initial_pos()
void test_passed_pawn_initial_pos() {
    position pos;
    reset_pos(&pos);

    for (int i=0;i<64;i++) {
        if (pos.piece[i]==PAWN || pos.piece[i]==-PAWN) {
            assert(!is_passed(&pos,(square_t)i,pos.piece[i]==PAWN));
            assert(!is_doubled(&pos,(square_t)i,pos.piece[i]==PAWN));
            assert(!is_isolated(&pos,(square_t)i,pos.piece[i]==PAWN));
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xaa51
xorl %r14d, %r14d
movl (%rsp,%r14,4), %eax
cmpl $0x1, %eax
je 0x13686
cmpl $-0x1, %eax
jne 0x136cf
xorl %edx, %edx
cmpl $0x1, %eax
sete %dl
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5c9e
testb %al, %al
jne 0x13702
xorl %edx, %edx
cmpl $0x1, (%rsp,%r14,4)
sete %dl
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5cf8
testb %al, %al
jne 0x13721
xorl %edx, %edx
cmpl $0x1, (%rsp,%r14,4)
sete %dl
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5d76
testb %al, %al
jne 0x136e3
incq %r14
cmpq $0x40, %r14
jne 0x13678
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x1d70a(%rip), %rdi     # 0x30df4
leaq 0x1d699(%rip), %rsi     # 0x30d8a
leaq 0x1d6a7(%rip), %rcx     # 0x30d9f
movl $0x15, %edx
callq 0x20d0
leaq 0x1d651(%rip), %rdi     # 0x30d5a
leaq 0x1d67a(%rip), %rsi     # 0x30d8a
leaq 0x1d688(%rip), %rcx     # 0x30d9f
movl $0x13, %edx
callq 0x20d0
leaq 0x1d69b(%rip), %rdi     # 0x30dc3
leaq 0x1d65b(%rip), %rsi     # 0x30d8a
leaq 0x1d669(%rip), %rcx     # 0x30d9f
movl $0x14, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d6d7(%rip), %rsi     # 0x30e26
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
movl $0x19, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
je 0x13856
leaq 0x8(%rsp), %rdi
movl $0x22, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
je 0x13875
leaq 0x8(%rsp), %rdi
movl $0x23, %esi
xorl %edx, %edx
callq 0x5c9e
testb %al, %al
je 0x13894
leaq 0x8(%rsp), %rdi
movl $0x1c, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
je 0x138b3
leaq 0x8(%rsp), %rdi
movl $0x1d, %esi
xorl %edx, %edx
callq 0x5c9e
testb %al, %al
jne 0x138d2
leaq 0x8(%rsp), %rdi
movl $0x25, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
jne 0x138f1
leaq 0x8(%rsp), %rdi
movl $0x26, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
jne 0x13910
leaq 0x8(%rsp), %rdi
movl $0x1f, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
jne 0x1392f
leaq 0x8(%rsp), %rdi
movl $0x17, %esi
xorl %edx, %edx
callq 0x5c9e
testb %al, %al
jne 0x1394e
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1dca6(%rip), %rdi     # 0x31503
leaq 0x1d526(%rip), %rsi     # 0x30d8a
leaq 0x1d5e0(%rip), %rcx     # 0x30e4b
movl $0x1e, %edx
callq 0x20d0
leaq 0x1d5f0(%rip), %rdi     # 0x30e6c
leaq 0x1d507(%rip), %rsi     # 0x30d8a
leaq 0x1d5c1(%rip), %rcx     # 0x30e4b
movl $0x1f, %edx
callq 0x20d0
leaq 0x1d5e9(%rip), %rdi     # 0x30e84
leaq 0x1d4e8(%rip), %rsi     # 0x30d8a
leaq 0x1d5a2(%rip), %rcx     # 0x30e4b
movl $0x20, %edx
callq 0x20d0
leaq 0x1d5e3(%rip), %rdi     # 0x30e9d
leaq 0x1d4c9(%rip), %rsi     # 0x30d8a
leaq 0x1d583(%rip), %rcx     # 0x30e4b
movl $0x21, %edx
callq 0x20d0
leaq 0x1d5dc(%rip), %rdi     # 0x30eb5
leaq 0x1d4aa(%rip), %rsi     # 0x30d8a
leaq 0x1d564(%rip), %rcx     # 0x30e4b
movl $0x23, %edx
callq 0x20d0
leaq 0x1d5d7(%rip), %rdi     # 0x30ecf
leaq 0x1d48b(%rip), %rsi     # 0x30d8a
leaq 0x1d545(%rip), %rcx     # 0x30e4b
movl $0x24, %edx
callq 0x20d0
leaq 0x1d5d1(%rip), %rdi     # 0x30ee8
leaq 0x1d46c(%rip), %rsi     # 0x30d8a
leaq 0x1d526(%rip), %rcx     # 0x30e4b
movl $0x25, %edx
callq 0x20d0
leaq 0x1d5cb(%rip), %rdi     # 0x30f01
leaq 0x1d44d(%rip), %rsi     # 0x30d8a
leaq 0x1d507(%rip), %rcx     # 0x30e4b
movl $0x26, %edx
callq 0x20d0
leaq 0x1d5c5(%rip), %rdi     # 0x30f1a
leaq 0x1d42e(%rip), %rsi     # 0x30d8a
leaq 0x1d4e8(%rip), %rcx     # 0x30e4b
movl $0x27, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d5b8(%rip), %rsi     # 0x30f34
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
movl $0xd, %esi
xorl %edx, %edx
callq 0x5c9e
testb %al, %al
jne 0x13a2f
leaq 0x8(%rsp), %rdi
movl $0xe, %esi
xorl %edx, %edx
callq 0x5c9e
testb %al, %al
jne 0x13a4e
leaq 0x8(%rsp), %rdi
movl $0xf, %esi
xorl %edx, %edx
callq 0x5c9e
testb %al, %al
jne 0x13a6d
leaq 0x8(%rsp), %rdi
movl $0x1d, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
jne 0x13a8c
leaq 0x8(%rsp), %rdi
movl $0x1e, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
jne 0x13aab
leaq 0x8(%rsp), %rdi
movl $0x1f, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
jne 0x13aca
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d51e(%rip), %rdi     # 0x30f54
leaq 0x1d34d(%rip), %rsi     # 0x30d8a
leaq 0x1d52a(%rip), %rcx     # 0x30f6e
movl $0x2e, %edx
callq 0x20d0
leaq 0x1d53b(%rip), %rdi     # 0x30f90
leaq 0x1d32e(%rip), %rsi     # 0x30d8a
leaq 0x1d50b(%rip), %rcx     # 0x30f6e
movl $0x2f, %edx
callq 0x20d0
leaq 0x1d536(%rip), %rdi     # 0x30faa
leaq 0x1d30f(%rip), %rsi     # 0x30d8a
leaq 0x1d4ec(%rip), %rcx     # 0x30f6e
movl $0x30, %edx
callq 0x20d0
leaq 0x1d531(%rip), %rdi     # 0x30fc4
leaq 0x1d2f0(%rip), %rsi     # 0x30d8a
leaq 0x1d4cd(%rip), %rcx     # 0x30f6e
movl $0x31, %edx
callq 0x20d0
leaq 0x1d52b(%rip), %rdi     # 0x30fdd
leaq 0x1d2d1(%rip), %rsi     # 0x30d8a
leaq 0x1d4ae(%rip), %rcx     # 0x30f6e
movl $0x32, %edx
callq 0x20d0
leaq 0x1d430(%rip), %rdi     # 0x30f01
leaq 0x1d2b2(%rip), %rsi     # 0x30d8a
leaq 0x1d48f(%rip), %rcx     # 0x30f6e
movl $0x33, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d4fe(%rip), %rsi     # 0x30ff6
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
movl $0x11, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
je 0x13bae
leaq 0x8(%rsp), %rdi
movl $0x12, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
je 0x13bcd
leaq 0x8(%rsp), %rdi
movl $0x15, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
je 0x13bec
leaq 0x8(%rsp), %rdi
movl $0x17, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
je 0x13c0b
leaq 0x8(%rsp), %rdi
movl $0x30, %esi
xorl %edx, %edx
callq 0x5c9e
testb %al, %al
je 0x13c2a
leaq 0x8(%rsp), %rdi
movl $0x2f, %esi
xorl %edx, %edx
callq 0x5c9e
testb %al, %al
je 0x13c49
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d468(%rip), %rdi     # 0x3101d
leaq 0x1d1ce(%rip), %rsi     # 0x30d8a
leaq 0x1d472(%rip), %rcx     # 0x31035
movl $0x3a, %edx
callq 0x20d0
leaq 0x1d483(%rip), %rdi     # 0x31057
leaq 0x1d1af(%rip), %rsi     # 0x30d8a
leaq 0x1d453(%rip), %rcx     # 0x31035
movl $0x3b, %edx
callq 0x20d0
leaq 0x1d47c(%rip), %rdi     # 0x3106f
leaq 0x1d190(%rip), %rsi     # 0x30d8a
leaq 0x1d434(%rip), %rcx     # 0x31035
movl $0x3c, %edx
callq 0x20d0
leaq 0x1d475(%rip), %rdi     # 0x31087
leaq 0x1d171(%rip), %rsi     # 0x30d8a
leaq 0x1d415(%rip), %rcx     # 0x31035
movl $0x3d, %edx
callq 0x20d0
leaq 0x1d46e(%rip), %rdi     # 0x3109f
leaq 0x1d152(%rip), %rsi     # 0x30d8a
leaq 0x1d3f6(%rip), %rcx     # 0x31035
movl $0x3e, %edx
callq 0x20d0
leaq 0x1d468(%rip), %rdi     # 0x310b8
leaq 0x1d133(%rip), %rsi     # 0x30d8a
leaq 0x1d3d7(%rip), %rcx     # 0x31035
movl $0x3f, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d45a(%rip), %rsi     # 0x310d1
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
movl $0x11, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
je 0x13cbb
leaq 0x8(%rsp), %rdi
movl $0xa, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
je 0x13cda
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d35b(%rip), %rdi     # 0x3101d
leaq 0x1d0c1(%rip), %rsi     # 0x30d8a
leaq 0x1d421(%rip), %rcx     # 0x310f1
movl $0x46, %edx
callq 0x20d0
leaq 0x1d432(%rip), %rdi     # 0x31113
leaq 0x1d0a2(%rip), %rsi     # 0x30d8a
leaq 0x1d402(%rip), %rcx     # 0x310f1
movl $0x47, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d423(%rip), %rsi     # 0x3112b
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
movl $0x10, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
je 0x13dd7
leaq 0x8(%rsp), %rdi
movl $0x16, %esi
xorl %edx, %edx
callq 0x5c9e
testb %al, %al
jne 0x13df6
leaq 0x8(%rsp), %rdi
movl $0x1d, %esi
xorl %edx, %edx
callq 0x5c9e
testb %al, %al
jne 0x13e15
leaq 0x8(%rsp), %rdi
movl $0x1f, %esi
xorl %edx, %edx
callq 0x5c9e
testb %al, %al
jne 0x13e34
leaq 0x8(%rsp), %rdi
movl $0x25, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
jne 0x13e53
leaq 0x8(%rsp), %rdi
movl $0x27, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
jne 0x13e72
leaq 0x8(%rsp), %rdi
movl $0x2e, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
jne 0x13e91
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1d374(%rip), %rdi     # 0x31152
leaq 0x1cfa5(%rip), %rsi     # 0x30d8a
leaq 0x1d37e(%rip), %rcx     # 0x3116a
movl $0x4e, %edx
callq 0x20d0
leaq 0x1d38d(%rip), %rdi     # 0x3118a
leaq 0x1cf86(%rip), %rsi     # 0x30d8a
leaq 0x1d35f(%rip), %rcx     # 0x3116a
movl $0x4f, %edx
callq 0x20d0
leaq 0x1d099(%rip), %rdi     # 0x30eb5
leaq 0x1cf67(%rip), %rsi     # 0x30d8a
leaq 0x1d340(%rip), %rcx     # 0x3116a
movl $0x50, %edx
callq 0x20d0
leaq 0x1d369(%rip), %rdi     # 0x311a4
leaq 0x1cf48(%rip), %rsi     # 0x30d8a
leaq 0x1d321(%rip), %rcx     # 0x3116a
movl $0x51, %edx
callq 0x20d0
leaq 0x1d075(%rip), %rdi     # 0x30ecf
leaq 0x1cf29(%rip), %rsi     # 0x30d8a
leaq 0x1d302(%rip), %rcx     # 0x3116a
movl $0x52, %edx
callq 0x20d0
leaq 0x1d345(%rip), %rdi     # 0x311be
leaq 0x1cf0a(%rip), %rsi     # 0x30d8a
leaq 0x1d2e3(%rip), %rcx     # 0x3116a
movl $0x53, %edx
callq 0x20d0
leaq 0x1d33f(%rip), %rdi     # 0x311d7
leaq 0x1ceeb(%rip), %rsi     # 0x30d8a
leaq 0x1d2c4(%rip), %rcx     # 0x3116a
movl $0x54, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d331(%rip), %rsi     # 0x311f0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
movl $0xd, %esi
xorl %edx, %edx
callq 0x5c9e
testb %al, %al
jne 0x13f72
leaq 0x8(%rsp), %rdi
movl $0x16, %esi
xorl %edx, %edx
callq 0x5c9e
testb %al, %al
jne 0x13f91
leaq 0x8(%rsp), %rdi
movl $0x1f, %esi
xorl %edx, %edx
callq 0x5c9e
testb %al, %al
jne 0x13fb0
leaq 0x8(%rsp), %rdi
movl $0x20, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
je 0x13fcf
leaq 0x8(%rsp), %rdi
movl $0x2e, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
jne 0x13fee
leaq 0x8(%rsp), %rdi
movl $0x37, %esi
movl $0x1, %edx
callq 0x5c9e
testb %al, %al
jne 0x1400d
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x1cfdb(%rip), %rdi     # 0x30f54
leaq 0x1ce0a(%rip), %rsi     # 0x30d8a
leaq 0x1d28b(%rip), %rcx     # 0x31212
movl $0x5b, %edx
callq 0x20d0
leaq 0x1d1f2(%rip), %rdi     # 0x3118a
leaq 0x1cdeb(%rip), %rsi     # 0x30d8a
leaq 0x1d26c(%rip), %rcx     # 0x31212
movl $0x5c, %edx
callq 0x20d0
leaq 0x1d1ed(%rip), %rdi     # 0x311a4
leaq 0x1cdcc(%rip), %rsi     # 0x30d8a
leaq 0x1d24d(%rip), %rcx     # 0x31212
movl $0x5d, %edx
callq 0x20d0
leaq 0x1d259(%rip), %rdi     # 0x3122f
leaq 0x1cdad(%rip), %rsi     # 0x30d8a
leaq 0x1d22e(%rip), %rcx     # 0x31212
movl $0x5e, %edx
callq 0x20d0
leaq 0x1d1e2(%rip), %rdi     # 0x311d7
leaq 0x1cd8e(%rip), %rsi     # 0x30d8a
leaq 0x1d20f(%rip), %rcx     # 0x31212
movl $0x5f, %edx
callq 0x20d0
leaq 0x1d233(%rip), %rdi     # 0x31247
leaq 0x1cd6f(%rip), %rsi     # 0x30d8a
leaq 0x1d1f0(%rip), %rcx     # 0x31212
movl $0x60, %edx
callq 0x20d0