LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_clear()
void test_clear() {
    clear_hash_table(&htbl);
    position pos;
    set_pos(&pos,"3qrrk1/1pp2pp1/1p2bn1p/5N2/2P5/P1P3B1/1P4PP/2Q1RRK1 w - - ");

    uint64 key = build_hash_key(&pos);
    move mv = to_move(KNIGHT,F5,D4);
    store_hash_entry(&htbl,key,build_hash_val(UPPER_BOUND,4,-93,mv));

    uint64 val = get_hash_entry(&htbl,key);
    assert(val!=0);
    assert(get_hash_entry_type(val)==UPPER_BOUND);
    assert(get_hash_entry_move(val)==mv);
    assert(get_hash_entry_score(val)==-93);
    assert(get_hash_entry_depth(val)==4);

    clear_hash_table(&htbl);
    val = get_hash_entry(&htbl,key);
    assert(val==0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0xe00f0(%rip), %r15     # 0xf7ef0
movq %r15, %rdi
callq 0x62b6
leaq 0x1a47e(%rip), %rsi     # 0x3228d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rbx, %rdi
callq 0x5ee8
movq %rax, %rbx
movl $0x2, %edi
movl $0x1d, %esi
movl $0x23, %edx
callq 0x775c
movq %rax, %r14
movl $0x2, %edi
movl $0x4, %esi
movl $0xffffffa3, %edx       # imm = 0xFFFFFFA3
movq %rax, %rcx
callq 0x604f
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x636f
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6312
testq %rax, %rax
je 0x17eea
movq %rax, %r15
movq %rax, %rdi
callq 0x61e4
cmpl $0x2, %eax
jne 0x17f09
movq %r15, %rdi
callq 0x621c
cmpq %r14, %rax
jne 0x17f28
movq %r15, %rdi
callq 0x61f2
cmpl $-0x5d, %eax
jne 0x17f47
movq %r15, %rdi
callq 0x61eb
cmpl $0x4, %eax
jne 0x17f66
leaq 0xe002f(%rip), %r14     # 0xf7ef0
movq %r14, %rdi
callq 0x62b6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6312
testq %rax, %rax
jne 0x17f85
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a0e5(%rip), %rdi     # 0x31fd6
leaq 0x19cad(%rip), %rsi     # 0x31ba5
leaq 0x1a3c9(%rip), %rcx     # 0x322c8
movl $0x201, %edx            # imm = 0x201
callq 0x20d0
leaq 0x19ebd(%rip), %rdi     # 0x31dcd
leaq 0x19c8e(%rip), %rsi     # 0x31ba5
leaq 0x1a3aa(%rip), %rcx     # 0x322c8
movl $0x202, %edx            # imm = 0x202
callq 0x20d0
leaq 0x19e81(%rip), %rdi     # 0x31db0
leaq 0x19c6f(%rip), %rsi     # 0x31ba5
leaq 0x1a38b(%rip), %rcx     # 0x322c8
movl $0x203, %edx            # imm = 0x203
callq 0x20d0
leaq 0x1a38c(%rip), %rdi     # 0x322da
leaq 0x19c50(%rip), %rsi     # 0x31ba5
leaq 0x1a36c(%rip), %rcx     # 0x322c8
movl $0x204, %edx            # imm = 0x204
callq 0x20d0
leaq 0x1a38c(%rip), %rdi     # 0x322f9
leaq 0x19c31(%rip), %rsi     # 0x31ba5
leaq 0x1a34d(%rip), %rcx     # 0x322c8
movl $0x205, %edx            # imm = 0x205
callq 0x20d0
leaq 0x19f5a(%rip), %rdi     # 0x31ee6
leaq 0x19c12(%rip), %rsi     # 0x31ba5
leaq 0x1a32e(%rip), %rcx     # 0x322c8
movl $0x209, %edx            # imm = 0x209
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_hash()
void test_hash() {
    test_hash_keys1();
    test_hash_keys2();
    test_hash_keys3();
    test_hash_val_lower_bound();
    test_hash_val_upper_bound();
    test_hash_val_exact_score();
    test_store_and_probe();
    test_pawn_store_and_probe();
    test_with_mate_score();
    test_transform_upper_bound_mate();
    test_transform_exact_score_mate();
    test_transform_lower_bound_mated();
    test_transform_exact_score_mated();
    test_transform_upper_bound_mated();
    test_clear();
    test_overwrite();
}

// Assembly:
pushq %rax
callq 0x15583
callq 0x1626d
callq 0x1698a
callq 0x16e0c
callq 0x16ef9
callq 0x16fc7
callq 0x171d4
callq 0x1744f
callq 0x1762d
callq 0x1773c
callq 0x17874
callq 0x179df
callq 0x17b17
callq 0x17c82
callq 0x17ded
popq %rax
jmp 0x17fa4
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/init__test.cpp
// Function: hamming_distance(unsigned long long, unsigned long long)
uint32 hamming_distance(uint64 x,uint64 y) {
    uint32 dist = 0;
    uint64 val = x ^ y;

    while (val != 0L) {
        dist++;
        val &= val - 1;
    }

    assert(dist >= 0 && dist <= 64);

    return dist;
}

// Assembly:
xorl %eax, %eax
cmpq %rdi, %rsi
je 0x183e8
xorq %rdi, %rsi
xorl %eax, %eax
incl %eax
leaq -0x1(%rsi), %rcx
andq %rcx, %rsi
jne 0x183d8
cmpl $0x41, %eax
jae 0x183e9
retq
pushq %rax
leaq 0x1a02f(%rip), %rdi     # 0x32420
leaq 0x1a040(%rip), %rsi     # 0x32438
leaq 0x1a04d(%rip), %rcx     # 0x3244c
movl $0x18, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/init__test.cpp
// Function: test_bb_files()
void test_bb_files() {
    assert(bb_files[FILE_A]==
            (bb_squares[A1] | bb_squares[A2] | bb_squares[A3] | bb_squares[A4]
           | bb_squares[A5] | bb_squares[A6] | bb_squares[A7] | bb_squares[A8]));
    assert(bb_files[FILE_E]==
            (bb_squares[E1] | bb_squares[E2] | bb_squares[E3] | bb_squares[E4]
           | bb_squares[E5] | bb_squares[E6] | bb_squares[E7] | bb_squares[E8]));
    assert(bb_files[FILE_H]==
            (bb_squares[H1] | bb_squares[H2] | bb_squares[H3] | bb_squares[H4]
           | bb_squares[H5] | bb_squares[H6] | bb_squares[H7] | bb_squares[H8]));
}

// Assembly:
pushq %rax
leaq 0xe1cbf(%rip), %rax     # 0xfa430
leaq 0xe1d38(%rip), %rcx     # 0xfa4b0
movq 0x180(%rcx), %rdx
orq 0x1c0(%rcx), %rdx
orq 0x140(%rcx), %rdx
orq 0x100(%rcx), %rdx
orq 0xc0(%rcx), %rdx
orq 0x80(%rcx), %rdx
orq 0x40(%rcx), %rdx
orq (%rcx), %rdx
cmpq %rdx, (%rax)
jne 0x18820
movq 0x1a0(%rcx), %rdx
orq 0x1e0(%rcx), %rdx
orq 0x160(%rcx), %rdx
orq 0x120(%rcx), %rdx
orq 0xe0(%rcx), %rdx
orq 0xa0(%rcx), %rdx
orq 0x60(%rcx), %rdx
orq 0x20(%rcx), %rdx
cmpq %rdx, 0x20(%rax)
jne 0x1883f
movq 0x1b8(%rcx), %rdx
orq 0x1f8(%rcx), %rdx
orq 0x178(%rcx), %rdx
orq 0x138(%rcx), %rdx
orq 0xf8(%rcx), %rdx
orq 0xb8(%rcx), %rdx
orq 0x78(%rcx), %rdx
orq 0x38(%rcx), %rdx
cmpq %rdx, 0x38(%rax)
jne 0x1885e
popq %rax
retq
leaq 0x19d0c(%rip), %rdi     # 0x32533
leaq 0x19c0a(%rip), %rsi     # 0x32438
leaq 0x19d99(%rip), %rcx     # 0x325ce
movl $0x94, %edx
callq 0x20d0
leaq 0x19d9d(%rip), %rdi     # 0x325e3
leaq 0x19beb(%rip), %rsi     # 0x32438
leaq 0x19d7a(%rip), %rcx     # 0x325ce
movl $0x97, %edx
callq 0x20d0
leaq 0x19e19(%rip), %rdi     # 0x3267e
leaq 0x19bcc(%rip), %rsi     # 0x32438
leaq 0x19d5b(%rip), %rcx     # 0x325ce
movl $0x9a, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/init__test.cpp
// Function: test_bb_ranks()
void test_bb_ranks() {
    assert(bb_ranks[RANK_8]==
            (bb_squares[A8] | bb_squares[B8] | bb_squares[C8] | bb_squares[D8]
           | bb_squares[E8] | bb_squares[F8] | bb_squares[G8] | bb_squares[H8]));
    assert(bb_ranks[RANK_8]==255);
    assert(bb_ranks[RANK_4]==
            (bb_squares[A4] | bb_squares[B4] | bb_squares[C4] | bb_squares[D4]
           | bb_squares[E4] | bb_squares[F4] | bb_squares[G4] | bb_squares[H4]));
    assert(bb_ranks[RANK_1]==
            (bb_squares[A1] | bb_squares[B1] | bb_squares[C1] | bb_squares[D1]
           | bb_squares[E1] | bb_squares[F1] | bb_squares[G1] | bb_squares[H1]));
}

// Assembly:
pushq %rax
leaq 0xe1beb(%rip), %rax     # 0xfa470
movq (%rax), %rdx
leaq 0xe1c21(%rip), %rcx     # 0xfa4b0
movdqa 0x10(%rcx), %xmm0
por 0x30(%rcx), %xmm0
movdqa (%rcx), %xmm1
por 0x20(%rcx), %xmm1
por %xmm0, %xmm1
pshufd $0xee, %xmm1, %xmm0     # xmm0 = xmm1[2,3,2,3]
por %xmm1, %xmm0
movq %xmm0, %rsi
cmpq %rsi, %rdx
jne 0x18938
cmpq $0xff, %rdx
jne 0x18957
movdqa 0x100(%rcx), %xmm0
movdqa 0x110(%rcx), %xmm1
por 0x130(%rcx), %xmm1
por 0x120(%rcx), %xmm0
por %xmm1, %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
por %xmm0, %xmm1
movq %xmm1, %rdx
cmpq %rdx, 0x20(%rax)
jne 0x18976
movdqa 0x1c0(%rcx), %xmm0
movdqa 0x1d0(%rcx), %xmm1
por 0x1f0(%rcx), %xmm1
por 0x1e0(%rcx), %xmm0
por %xmm1, %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
por %xmm0, %xmm1
movq %xmm1, %rcx
cmpq %rcx, 0x38(%rax)
jne 0x18995
popq %rax
retq
leaq 0x19dda(%rip), %rdi     # 0x32719
leaq 0x19af2(%rip), %rsi     # 0x32438
leaq 0x19e67(%rip), %rcx     # 0x327b4
movl $0xa0, %edx
callq 0x20d0
leaq 0x19e6b(%rip), %rdi     # 0x327c9
leaq 0x19ad3(%rip), %rsi     # 0x32438
leaq 0x19e48(%rip), %rcx     # 0x327b4
movl $0xa1, %edx
callq 0x20d0
leaq 0x19e62(%rip), %rdi     # 0x327df
leaq 0x19ab4(%rip), %rsi     # 0x32438
leaq 0x19e29(%rip), %rcx     # 0x327b4
movl $0xa4, %edx
callq 0x20d0
leaq 0x19ede(%rip), %rdi     # 0x3287a
leaq 0x19a95(%rip), %rsi     # 0x32438
leaq 0x19e0a(%rip), %rcx     # 0x327b4
movl $0xa7, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/init__test.cpp
// Function: test_init()
void test_init() {
    test_hamming_distance();
    test_zkeys();
    test_bb_squares();
    test_bb_files();
    test_bb_ranks();
}

// Assembly:
pushq %rax
callq 0x1840a
callq 0x189b4
callq 0x18769
popq %rax
jmp 0x1887d
nop
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/magic__test.cpp
// Function: test_bishop_moves()
void test_bishop_moves() {
    position pos;
    set_pos(&pos,"8/1r3k2/8/3bB3/8/8/8/3K4 b - - 0 1");

    uint64 bishop_moves = get_bishop_moves(&pos,E5,pos.black_pieces);
    assert(bishop_moves==0);

    bishop_moves = get_bishop_moves(&pos,D5,pos.black_pieces);
    assert(bishop_moves==(bb_squares[B7] | bb_squares[F7]));
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x1544a(%rip), %rsi     # 0x2de8d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq 0x1b0(%rbx), %rdx
movq %rbx, %rdi
movl $0x1c, %esi
callq 0x6708
testq %rax, %rax
jne 0x18a9c
leaq 0x8(%rsp), %rdi
movq 0x1b0(%rdi), %rdx
movl $0x1b, %esi
callq 0x6708
leaq 0xe1a2a(%rip), %rcx     # 0xfa4b0
movq 0x68(%rcx), %rdx
orq 0x48(%rcx), %rdx
cmpq %rdx, %rax
jne 0x18abb
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x19ebd(%rip), %rdi     # 0x32960
leaq 0x19ec6(%rip), %rsi     # 0x32970
leaq 0x19ed4(%rip), %rcx     # 0x32985
movl $0x11, %edx
callq 0x20d0
leaq 0x19edc(%rip), %rdi     # 0x3299e
leaq 0x19ea7(%rip), %rsi     # 0x32970
leaq 0x19eb5(%rip), %rcx     # 0x32985
movl $0x14, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/magic__test.cpp
// Function: test_rook_moves()
void test_rook_moves() {
    position pos;
    set_pos(&pos,"8/1r3k2/8/3bB3/8/8/8/3K4 b - - 0 1");

    uint64 rook_moves = get_rook_moves(&pos,B7,pos.black_pieces);
    assert(rook_moves==bb_squares[F7]);
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x153a4(%rip), %rsi     # 0x2de8d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq 0x1b0(%rbx), %rdx
movq %rbx, %rdi
movl $0x9, %esi
callq 0x6828
leaq 0xe199f(%rip), %rcx     # 0xfa4b0
cmpq 0x68(%rcx), %rax
jne 0x18b20
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x19ea7(%rip), %rdi     # 0x329ce
leaq 0x19e42(%rip), %rsi     # 0x32970
leaq 0x19eb4(%rip), %rcx     # 0x329e9
movl $0x1c, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/move__test.cpp
// Function: test_to_move()
void test_to_move() {
    move mv = to_move(PAWN,E2,E4);
    assert(get_piece(mv)==PAWN);
    assert(get_from_sq(mv)==E2);
    assert(get_to_sq(mv)==E4);
    assert(!is_epcapture(mv));
    assert(!is_capture(mv));
    assert(!is_castle(mv));
    assert(get_promopiece(mv)==NO_PIECE);
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x34, %esi
movl $0x24, %edx
callq 0x775c
movq %rax, %rbx
movq %rax, %rdi
callq 0x7865
cmpl $0x1, %eax
jne 0x18bd1
movq %rbx, %rdi
callq 0x7854
cmpl $0x34, %eax
jne 0x18bf0
movq %rbx, %rdi
callq 0x785b
cmpl $0x24, %eax
jne 0x18c0f
movq %rbx, %rdi
callq 0x788d
testb %al, %al
jne 0x18c2e
movq %rbx, %rdi
callq 0x7883
testb %al, %al
jne 0x18c4d
movq %rbx, %rdi
callq 0x7897
testb %al, %al
jne 0x18c6c
movq %rbx, %rdi
callq 0x786f
testl %eax, %eax
jne 0x18c8b
popq %rbx
retq
leaq 0x192dd(%rip), %rdi     # 0x31eb5
leaq 0x19e21(%rip), %rsi     # 0x32a00
leaq 0x19e2e(%rip), %rcx     # 0x32a14
movl $0xf, %edx
callq 0x20d0
leaq 0x19e31(%rip), %rdi     # 0x32a28
leaq 0x19e02(%rip), %rsi     # 0x32a00
leaq 0x19e0f(%rip), %rcx     # 0x32a14
movl $0x10, %edx
callq 0x20d0
leaq 0x19e26(%rip), %rdi     # 0x32a3c
leaq 0x19de3(%rip), %rsi     # 0x32a00
leaq 0x19df0(%rip), %rcx     # 0x32a14
movl $0x11, %edx
callq 0x20d0
leaq 0x19e19(%rip), %rdi     # 0x32a4e
leaq 0x19dc4(%rip), %rsi     # 0x32a00
leaq 0x19dd1(%rip), %rcx     # 0x32a14
movl $0x12, %edx
callq 0x20d0
leaq 0x19e0c(%rip), %rdi     # 0x32a60
leaq 0x19da5(%rip), %rsi     # 0x32a00
leaq 0x19db2(%rip), %rcx     # 0x32a14
movl $0x13, %edx
callq 0x20d0
leaq 0x19dfd(%rip), %rdi     # 0x32a70
leaq 0x19d86(%rip), %rsi     # 0x32a00
leaq 0x19d93(%rip), %rcx     # 0x32a14
movl $0x14, %edx
callq 0x20d0
leaq 0x19ded(%rip), %rdi     # 0x32a7f
leaq 0x19d67(%rip), %rsi     # 0x32a00
leaq 0x19d74(%rip), %rcx     # 0x32a14
movl $0x15, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/move__test.cpp
// Function: test_set_epcapture()
void test_set_epcapture() {
    move mv = to_move(PAWN,D4,C3);
    set_epcapture(&mv);
    assert(get_piece(mv)==PAWN);
    assert(get_from_sq(mv)==D4);
    assert(get_to_sq(mv)==C3);
    assert(is_epcapture(mv));
    assert(is_capture(mv));
    assert(get_captured_piece(mv)==PAWN);
    assert(!is_castle(mv));
    assert(get_promopiece(mv)==NO_PIECE);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x1, %edi
movl $0x23, %esi
movl $0x2a, %edx
callq 0x775c
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x783b
movq (%rbx), %rdi
callq 0x7865
cmpl $0x1, %eax
jne 0x1973b
movq 0x8(%rsp), %rdi
callq 0x7854
cmpl $0x23, %eax
jne 0x1975a
movq 0x8(%rsp), %rdi
callq 0x785b
cmpl $0x2a, %eax
jne 0x19779
movq 0x8(%rsp), %rdi
callq 0x788d
testb %al, %al
je 0x19798
movq 0x8(%rsp), %rdi
callq 0x7883
testb %al, %al
je 0x197b7
movq 0x8(%rsp), %rdi
callq 0x7879
cmpl $0x1, %eax
jne 0x197d6
movq 0x8(%rsp), %rdi
callq 0x7897
testb %al, %al
jne 0x197f5
movq 0x8(%rsp), %rdi
callq 0x786f
testl %eax, %eax
jne 0x19814
addq $0x10, %rsp
popq %rbx
retq
leaq 0x18773(%rip), %rdi     # 0x31eb5
leaq 0x192b7(%rip), %rsi     # 0x32a00
leaq 0x1949a(%rip), %rcx     # 0x32bea
movl $0x62, %edx
callq 0x20d0
leaq 0x194a3(%rip), %rdi     # 0x32c04
leaq 0x19298(%rip), %rsi     # 0x32a00
leaq 0x1947b(%rip), %rcx     # 0x32bea
movl $0x63, %edx
callq 0x20d0
leaq 0x19498(%rip), %rdi     # 0x32c18
leaq 0x19279(%rip), %rsi     # 0x32a00
leaq 0x1945c(%rip), %rcx     # 0x32bea
movl $0x64, %edx
callq 0x20d0
leaq 0x192b0(%rip), %rdi     # 0x32a4f
leaq 0x1925a(%rip), %rsi     # 0x32a00
leaq 0x1943d(%rip), %rcx     # 0x32bea
movl $0x65, %edx
callq 0x20d0
leaq 0x192a3(%rip), %rdi     # 0x32a61
leaq 0x1923b(%rip), %rsi     # 0x32a00
leaq 0x1941e(%rip), %rcx     # 0x32bea
movl $0x66, %edx
callq 0x20d0
leaq 0x193f0(%rip), %rdi     # 0x32bcd
leaq 0x1921c(%rip), %rsi     # 0x32a00
leaq 0x193ff(%rip), %rcx     # 0x32bea
movl $0x67, %edx
callq 0x20d0
leaq 0x19274(%rip), %rdi     # 0x32a70
leaq 0x191fd(%rip), %rsi     # 0x32a00
leaq 0x193e0(%rip), %rcx     # 0x32bea
movl $0x68, %edx
callq 0x20d0
leaq 0x19264(%rip), %rdi     # 0x32a7f
leaq 0x191de(%rip), %rsi     # 0x32a00
leaq 0x193c1(%rip), %rcx     # 0x32bea
movl $0x69, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/move__test.cpp
// Function: test_set_castle()
void test_set_castle() {
    move mv = to_move(KING,E1,H1);
    set_castle(&mv);
    assert(get_piece(mv)==KING);
    assert(get_from_sq(mv)==E1);
    assert(get_to_sq(mv)==H1);
    assert(!is_epcapture(mv));
    assert(!is_capture(mv));
    assert(is_castle(mv));
    assert(get_promopiece(mv)==NO_PIECE);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x6, %edi
movl $0x3c, %esi
movl $0x3f, %edx
callq 0x775c
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x784f
movq (%rbx), %rdi
callq 0x7865
cmpl $0x6, %eax
jne 0x198dd
movq 0x8(%rsp), %rdi
callq 0x7854
cmpl $0x3c, %eax
jne 0x198fc
movq 0x8(%rsp), %rdi
callq 0x785b
cmpl $0x3f, %eax
jne 0x1991b
movq 0x8(%rsp), %rdi
callq 0x788d
testb %al, %al
jne 0x1993a
movq 0x8(%rsp), %rdi
callq 0x7883
testb %al, %al
jne 0x19959
movq 0x8(%rsp), %rdi
callq 0x7897
testb %al, %al
je 0x19978
movq 0x8(%rsp), %rdi
callq 0x786f
testl %eax, %eax
jne 0x19997
addq $0x10, %rsp
popq %rbx
retq
leaq 0x19346(%rip), %rdi     # 0x32c2a
leaq 0x19115(%rip), %rsi     # 0x32a00
leaq 0x1934c(%rip), %rcx     # 0x32c3e
movl $0x6f, %edx
callq 0x20d0
leaq 0x19352(%rip), %rdi     # 0x32c55
leaq 0x190f6(%rip), %rsi     # 0x32a00
leaq 0x1932d(%rip), %rcx     # 0x32c3e
movl $0x70, %edx
callq 0x20d0
leaq 0x19347(%rip), %rdi     # 0x32c69
leaq 0x190d7(%rip), %rsi     # 0x32a00
leaq 0x1930e(%rip), %rcx     # 0x32c3e
movl $0x71, %edx
callq 0x20d0
leaq 0x1910d(%rip), %rdi     # 0x32a4e
leaq 0x190b8(%rip), %rsi     # 0x32a00
leaq 0x192ef(%rip), %rcx     # 0x32c3e
movl $0x72, %edx
callq 0x20d0
leaq 0x19100(%rip), %rdi     # 0x32a60
leaq 0x19099(%rip), %rsi     # 0x32a00
leaq 0x192d0(%rip), %rcx     # 0x32c3e
movl $0x73, %edx
callq 0x20d0
leaq 0x190f2(%rip), %rdi     # 0x32a71
leaq 0x1907a(%rip), %rsi     # 0x32a00
leaq 0x192b1(%rip), %rcx     # 0x32c3e
movl $0x74, %edx
callq 0x20d0
leaq 0x190e1(%rip), %rdi     # 0x32a7f
leaq 0x1905b(%rip), %rsi     # 0x32a00
leaq 0x19292(%rip), %rcx     # 0x32c3e
movl $0x75, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/move__test.cpp
// Function: test_move()
void test_move() {
    test_to_move();
    test_set_promopiece();
    test_set_capture();
    test_set_epcapture();
    test_set_castle();
    test_move_score();
}

// Assembly:
pushq %rax
callq 0x18b4c
callq 0x18caa
callq 0x1933c
callq 0x1967a
callq 0x19833
popq %rax
jmp 0x199b6
nop
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_knight_moves()
void test_gen_knight_moves() {
    position pos;
    reset_pos(&pos);

    move moves[10];
    move *mp = gen_knight_moves(moves,&pos,B1,true,true);
    mp = gen_knight_moves(mp,&pos,G1,true,true);

    assert((mp - moves) == 4);
    assert(is_in_move_list(to_move(KNIGHT,B1,A3),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,B1,C3),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,G1,F3),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,G1,H3),moves,mp));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa51
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x39, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x859c
movq %rax, %rdi
movq %rbx, %rsi
movl $0x3e, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x859c
movq %rax, %rbx
subq %r14, %rax
cmpq $0x20, %rax
jne 0x19d23
movl $0x2, %edi
movl $0x39, %esi
movl $0x28, %edx
callq 0x775c
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x19d42
movl $0x2, %edi
movl $0x39, %esi
movl $0x2a, %edx
callq 0x775c
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x19d61
movl $0x2, %edi
movl $0x3e, %esi
movl $0x2d, %edx
callq 0x775c
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x19d80
movl $0x2, %edi
movl $0x3e, %esi
movl $0x2f, %edx
callq 0x775c
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x19d9f
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
leaq 0x19012(%rip), %rdi     # 0x32d3c
leaq 0x1901d(%rip), %rsi     # 0x32d4e
leaq 0x1902d(%rip), %rcx     # 0x32d65
movl $0x15, %edx
callq 0x20d0
leaq 0x19039(%rip), %rdi     # 0x32d82
leaq 0x18ffe(%rip), %rsi     # 0x32d4e
leaq 0x1900e(%rip), %rcx     # 0x32d65
movl $0x16, %edx
callq 0x20d0
leaq 0x1904a(%rip), %rdi     # 0x32db2
leaq 0x18fdf(%rip), %rsi     # 0x32d4e
leaq 0x18fef(%rip), %rcx     # 0x32d65
movl $0x17, %edx
callq 0x20d0
leaq 0x1905b(%rip), %rdi     # 0x32de2
leaq 0x18fc0(%rip), %rsi     # 0x32d4e
leaq 0x18fd0(%rip), %rcx     # 0x32d65
movl $0x18, %edx
callq 0x20d0
leaq 0x1906c(%rip), %rdi     # 0x32e12
leaq 0x18fa1(%rip), %rsi     # 0x32d4e
leaq 0x18fb1(%rip), %rcx     # 0x32d65
movl $0x19, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_knight_captures()
void test_gen_knight_captures() {
    position pos;
    set_pos(&pos,"4k3/8/3P1p2/8/4N3/8/8/4K3 w - - 0 1");

    move moves[10];
    move *mp = gen_knight_moves(moves,&pos,E4,true,false);

    assert((mp-moves)==1);
    assert(is_in_move_list(to_capture(KNIGHT,E4,F6,PAWN),moves,mp));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
leaq 0x19073(%rip), %rsi     # 0x32e42
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x24, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x859c
movq %rax, %rbx
subq %r14, %rax
cmpq $0x8, %rax
jne 0x19e39
movl $0x2, %edi
movl $0x24, %esi
movl $0x15, %edx
movl $0x1, %ecx
callq 0x777b
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x19e58
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
leaq 0x19026(%rip), %rdi     # 0x32e66
leaq 0x18f07(%rip), %rsi     # 0x32d4e
leaq 0x19026(%rip), %rcx     # 0x32e74
movl $0x23, %edx
callq 0x20d0
leaq 0x19035(%rip), %rdi     # 0x32e94
leaq 0x18ee8(%rip), %rsi     # 0x32d4e
leaq 0x19007(%rip), %rcx     # 0x32e74
movl $0x24, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_knight_noncaptures()
void test_gen_knight_noncaptures() {
    position pos;
    set_pos(&pos,"4k3/8/3P1p2/8/4N3/8/8/4K3 w - - 0 1");

    move moves[10];
    move *mp = gen_knight_moves(moves,&pos,E4,false,true);

    assert((mp-moves)==6);
    assert(is_in_move_list(to_move(KNIGHT,E4,G5),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,E4,G3),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,E4,F2),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,E4,D2),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,E4,C3),moves,mp));
    assert(is_in_move_list(to_move(KNIGHT,E4,C5),moves,mp));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
leaq 0x18fba(%rip), %rsi     # 0x32e42
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x24, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x859c
movq %rax, %rbx
subq %r14, %rax
cmpq $0x30, %rax
jne 0x19fc7
movl $0x2, %edi
movl $0x24, %esi
movl $0x1e, %edx
callq 0x775c
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x19fe6
movl $0x2, %edi
movl $0x24, %esi
movl $0x2e, %edx
callq 0x775c
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x1a005
movl $0x2, %edi
movl $0x24, %esi
movl $0x35, %edx
callq 0x775c
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x1a024
movl $0x2, %edi
movl $0x24, %esi
movl $0x33, %edx
callq 0x775c
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x1a043
movl $0x2, %edi
movl $0x24, %esi
movl $0x2a, %edx
callq 0x775c
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x1a062
movl $0x2, %edi
movl $0x24, %esi
movl $0x1a, %edx
callq 0x775c
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x1a081
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
leaq 0x18efe(%rip), %rdi     # 0x32ecc
leaq 0x18d79(%rip), %rsi     # 0x32d4e
leaq 0x18efe(%rip), %rcx     # 0x32eda
movl $0x2e, %edx
callq 0x20d0
leaq 0x18f10(%rip), %rdi     # 0x32efd
leaq 0x18d5a(%rip), %rsi     # 0x32d4e
leaq 0x18edf(%rip), %rcx     # 0x32eda
movl $0x2f, %edx
callq 0x20d0
leaq 0x18f21(%rip), %rdi     # 0x32f2d
leaq 0x18d3b(%rip), %rsi     # 0x32d4e
leaq 0x18ec0(%rip), %rcx     # 0x32eda
movl $0x30, %edx
callq 0x20d0
leaq 0x18f32(%rip), %rdi     # 0x32f5d
leaq 0x18d1c(%rip), %rsi     # 0x32d4e
leaq 0x18ea1(%rip), %rcx     # 0x32eda
movl $0x31, %edx
callq 0x20d0
leaq 0x18f43(%rip), %rdi     # 0x32f8d
leaq 0x18cfd(%rip), %rsi     # 0x32d4e
leaq 0x18e82(%rip), %rcx     # 0x32eda
movl $0x32, %edx
callq 0x20d0
leaq 0x18f54(%rip), %rdi     # 0x32fbd
leaq 0x18cde(%rip), %rsi     # 0x32d4e
leaq 0x18e63(%rip), %rcx     # 0x32eda
movl $0x33, %edx
callq 0x20d0
leaq 0x18f65(%rip), %rdi     # 0x32fed
leaq 0x18cbf(%rip), %rsi     # 0x32d4e
leaq 0x18e44(%rip), %rcx     # 0x32eda
movl $0x34, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_bishop_captures()
void test_gen_bishop_captures() {
    position pos;
    set_pos(&pos,"4k3/2p3P1/8/4B3/4B3/3p1P2/8/4K3 w - - 0 1");

    move moves[20];
    move *mp = gen_bishop_moves(moves,&pos,E5,true,false);
    mp = gen_bishop_moves(mp,&pos,E4,true,false);

    assert((mp - moves) == 2);
    assert(is_in_move_list(to_capture(BISHOP,E5,C7,PAWN),moves,mp));
    assert(is_in_move_list(to_capture(BISHOP,E4,D3,PAWN),moves,mp));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
leaq 0x189ad(%rip), %rsi     # 0x3301d
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1c, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x86f1
movq %rax, %rdi
movq %rbx, %rsi
movl $0x24, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x86f1
movq %rax, %rbx
subq %r14, %rax
cmpq $0x10, %rax
jne 0x1a720
movl $0x3, %edi
movl $0x1c, %esi
movl $0xa, %edx
movl $0x1, %ecx
callq 0x777b
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x1a73f
movl $0x3, %edi
movl $0x24, %esi
movl $0x2b, %edx
movl $0x1, %ecx
callq 0x777b
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x1a75e
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r14
retq
leaq 0x18cc0(%rip), %rdi     # 0x333e7
leaq 0x18620(%rip), %rsi     # 0x32d4e
leaq 0x18cc4(%rip), %rcx     # 0x333f9
movl $0x5c, %edx
callq 0x20d0
leaq 0x18ae1(%rip), %rdi     # 0x33227
leaq 0x18601(%rip), %rsi     # 0x32d4e
leaq 0x18ca5(%rip), %rcx     # 0x333f9
movl $0x5d, %edx
callq 0x20d0
leaq 0x18b8a(%rip), %rdi     # 0x332ef
leaq 0x185e2(%rip), %rsi     # 0x32d4e
leaq 0x18c86(%rip), %rcx     # 0x333f9
movl $0x5e, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_rook_captures()
void test_gen_rook_captures() {
    position pos;
    reset_pos(&pos);

    move moves[20];
    move *mp = gen_rook_moves(moves,&pos,H1,true,false);
    assert((mp - moves) == 0);

    set_pos(&pos,"8/8/3k1p2/8/3K4/8/1R3r2/8 b - - 0 1");

    mp = gen_rook_moves(moves,&pos,F2,true,false);
    assert((mp - moves) == 1);

    assert(is_in_move_list(to_capture(ROOK,F2,B2,ROOK),moves,mp));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
callq 0xaa51
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3f, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x8814
cmpq %rbx, %rax
jne 0x1b0f0
leaq 0x183f6(%rip), %rsi     # 0x3347c
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
callq 0xaa82
movq %rbx, %rdi
movq %r14, %rsi
movl $0x35, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x8814
movq %rax, %r14
subq %rbx, %rax
cmpq $0x8, %rax
jne 0x1b10f
movl $0x4, %edi
movl $0x35, %esi
movl $0x31, %edx
movl $0x4, %ecx
callq 0x777b
movq %rsp, %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0xe682
testb %al, %al
je 0x1b12e
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r14
retq
leaq 0x18358(%rip), %rdi     # 0x3344f
leaq 0x17c50(%rip), %rsi     # 0x32d4e
leaq 0x18582(%rip), %rcx     # 0x33687
movl $0x9b, %edx
callq 0x20d0
leaq 0x1858f(%rip), %rdi     # 0x336a5
leaq 0x17c31(%rip), %rsi     # 0x32d4e
leaq 0x18563(%rip), %rcx     # 0x33687
movl $0xa0, %edx
callq 0x20d0
leaq 0x1851c(%rip), %rdi     # 0x33651
leaq 0x17c12(%rip), %rsi     # 0x32d4e
leaq 0x18544(%rip), %rcx     # 0x33687
movl $0xa2, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_queen_captures()
void test_gen_queen_captures() {
    position pos;
    set_pos(&pos,"8/8/3bk3/8/8/2K3Q1/8/8 w - - 0 1");

    move moves[20];
    move *mp = gen_queen_moves(moves,&pos,G3,true,false);

    assert((mp - moves) == 1);
    assert(is_in_move_list(to_capture(QUEEN,G3,D6,BISHOP),moves,mp));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
leaq 0x17c93(%rip), %rsi     # 0x336ea
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2e, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x8937
movq %rax, %rbx
subq %r14, %rax
cmpq $0x8, %rax
jne 0x1bac4
movl $0x5, %edi
movl $0x2e, %esi
movl $0x13, %edx
movl $0x3, %ecx
callq 0x777b
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x1bae3
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r14
retq
leaq 0x17bda(%rip), %rdi     # 0x336a5
leaq 0x1727c(%rip), %rsi     # 0x32d4e
leaq 0x17fa6(%rip), %rcx     # 0x33a7f
movl $0xe0, %edx
callq 0x20d0
leaq 0x17f5c(%rip), %rdi     # 0x33a46
leaq 0x1725d(%rip), %rsi     # 0x32d4e
leaq 0x17f87(%rip), %rcx     # 0x33a7f
movl $0xe1, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_king_captures()
void test_gen_king_captures() {
    position pos;

    set_pos(&pos,"8/8/3k4/2n1P3/8/8/3rP3/R3K2R b KQ - 0 1");
    move moves[20];
    move *mp = gen_king_moves(moves,&pos,true,false);
    assert((mp - moves) == 1);
    assert(is_in_move_list(to_capture(KING,D6,E5,PAWN),moves,mp));

    // flip sides
    set_pos(&pos,"8/8/3k4/2n1P3/8/8/3rP3/RN2K2R w KQ - 0 1");
    mp = gen_king_moves(moves,&pos,true,false);
    assert((mp - moves)==1);
    assert(is_in_move_list(to_capture(KING,E1,D2,ROOK),moves,mp));

    // cannot castle if king will passed through attacked square
    set_pos(&pos,"r3k2r/8/8/8/8/5Q2/8/4K3 b kq - 0 1");
    mp = gen_king_moves(moves,&pos,true,false);
    assert((mp - moves)==0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
leaq 0x16fcd(%rip), %rsi     # 0x33ad3
leaq 0xa8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x80aa
movq %rax, %r14
subq %r15, %rax
cmpq $0x8, %rax
jne 0x1cc17
movl $0x6, %edi
movl $0x13, %esi
movl $0x1c, %edx
movl $0x1, %ecx
callq 0x777b
movq %rsp, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xe682
testb %al, %al
je 0x1cc36
leaq 0x122fb(%rip), %rsi     # 0x2ee6f
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
callq 0xaa82
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x80aa
movq %rax, %r14
subq %rbx, %rax
cmpq $0x8, %rax
jne 0x1cc55
movl $0x6, %edi
movl $0x3c, %esi
movl $0x33, %edx
movl $0x4, %ecx
callq 0x777b
movq %rsp, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xe682
testb %al, %al
je 0x1cc74
leaq 0x122f0(%rip), %rsi     # 0x2eecf
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
callq 0xaa82
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x80aa
cmpq %rbx, %rax
jne 0x1cc93
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r14
popq %r15
retq
leaq 0x16a87(%rip), %rdi     # 0x336a5
leaq 0x16129(%rip), %rsi     # 0x32d4e
leaq 0x173eb(%rip), %rcx     # 0x34017
movl $0x148, %edx            # imm = 0x148
callq 0x20d0
leaq 0x16f75(%rip), %rdi     # 0x33bb2
leaq 0x1610a(%rip), %rsi     # 0x32d4e
leaq 0x173cc(%rip), %rcx     # 0x34017
movl $0x149, %edx            # imm = 0x149
callq 0x20d0
leaq 0x173d9(%rip), %rdi     # 0x34035
leaq 0x160eb(%rip), %rsi     # 0x32d4e
leaq 0x173ad(%rip), %rcx     # 0x34017
movl $0x14e, %edx            # imm = 0x14E
callq 0x20d0
leaq 0x17091(%rip), %rdi     # 0x33d0c
leaq 0x160cc(%rip), %rsi     # 0x32d4e
leaq 0x1738e(%rip), %rcx     # 0x34017
movl $0x14f, %edx            # imm = 0x14F
callq 0x20d0
leaq 0x173ab(%rip), %rdi     # 0x34045
leaq 0x160ad(%rip), %rsi     # 0x32d4e
leaq 0x1736f(%rip), %rcx     # 0x34017
movl $0x154, %edx            # imm = 0x154
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_pawn_noncaps()
void test_gen_pawn_noncaps() {
    position pos;
    set_pos(&pos,"2b1k3/PP6/8/3pP3/4P3/8/6P1/4K3 w - d6 0 1");
    move moves[20],*mp;

    mp = gen_pawn_moves(moves,&pos,false,true);

    assert((mp - moves)==3);
    assert(is_in_move_list(to_move(PAWN,G2,G3),moves,mp));
    assert(is_in_move_list(to_move(PAWN,G2,G4),moves,mp));
    assert(is_in_move_list(to_move(PAWN,E5,E6),moves,mp));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
leaq 0x16420(%rip), %rsi     # 0x34088
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x79cf
movq %rax, %rbx
subq %r14, %rax
cmpq $0x18, %rax
jne 0x1dd16
movl $0x1, %edi
movl $0x36, %esi
movl $0x2e, %edx
callq 0x775c
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x1dd35
movl $0x1, %edi
movl $0x36, %esi
movl $0x26, %edx
callq 0x775c
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x1dd54
movl $0x1, %edi
movl $0x1c, %esi
movl $0x14, %edx
callq 0x775c
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x1dd73
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r14
retq
leaq 0x1605e(%rip), %rdi     # 0x33d7b
leaq 0x1502a(%rip), %rsi     # 0x32d4e
leaq 0x164d9(%rip), %rcx     # 0x34204
movl $0x1e7, %edx            # imm = 0x1E7
callq 0x20d0
leaq 0x163a2(%rip), %rdi     # 0x340de
leaq 0x1500b(%rip), %rsi     # 0x32d4e
leaq 0x164ba(%rip), %rcx     # 0x34204
movl $0x1e8, %edx            # imm = 0x1E8
callq 0x20d0
leaq 0x163b1(%rip), %rdi     # 0x3410c
leaq 0x14fec(%rip), %rsi     # 0x32d4e
leaq 0x1649b(%rip), %rcx     # 0x34204
movl $0x1e9, %edx            # imm = 0x1E9
callq 0x20d0
leaq 0x163c0(%rip), %rdi     # 0x3413a
leaq 0x14fcd(%rip), %rsi     # 0x32d4e
leaq 0x1647c(%rip), %rcx     # 0x34204
movl $0x1ea, %edx            # imm = 0x1EA
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_moves()
void test_gen_moves() {
    position pos;
    reset_pos(&pos);
    move moves[50],*mp;

    mp = gen_moves(moves,&pos,true,true);
    assert((mp-moves)==20);

    set_pos(&pos,"rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1");
    mp = gen_moves(moves,&pos,true,true);
    assert((mp-moves)==20);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x368, %rsp            # imm = 0x368
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaa51
leaq 0x1d0(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7970
subq %rbx, %rax
cmpq $0xa0, %rax
jne 0x1de10
leaq 0xf71b(%rip), %rsi      # 0x2d4f3
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xaa82
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x7970
subq %rbx, %rax
cmpq $0xa0, %rax
jne 0x1de2f
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %r14
retq
leaq 0x1640a(%rip), %rdi     # 0x34221
leaq 0x14f30(%rip), %rsi     # 0x32d4e
leaq 0x1640b(%rip), %rcx     # 0x34230
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x20d0
leaq 0x163eb(%rip), %rdi     # 0x34221
leaq 0x14f11(%rip), %rsi     # 0x32d4e
leaq 0x163ec(%rip), %rcx     # 0x34230
movl $0x1f8, %edx            # imm = 0x1F8
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_gen_legal_moves()
void test_gen_legal_moves() {
    position pos;
    set_pos(&pos,"7k/4Bp1p/8/8/8/8/8/1K4R1 b - - 0 1");
    move moves[50],*mp;
    mp = gen_legal_moves(moves,&pos,true,true);
    assert(num_moves(moves,mp,true,true)==4);

    set_pos(&pos,"rnb1k2r/ppq1n3/2pppp2/6pp/2PP3N/P2BP3/2PB1PPP/R2Q1RK1 w kq - -");
    assert(is_legal_move(to_move(KNIGHT,H4,G6),&pos));

    set_pos(&pos,"r2r2k1/1p2p1b1/1pp1b1pp/4P2n/PP3p1p/2P2N2/5PP1/R3KBNR b KQ b3 -");
    assert(is_legal_move(to_move(BISHOP,E6,B3),&pos));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x368, %rsp            # imm = 0x368
leaq 0x163e7(%rip), %rsi     # 0x34246
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
leaq 0x1d0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %r14, %rdi
movq %rax, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0xe70f
cmpl $0x4, %eax
jne 0x1df1c
leaq 0x163fc(%rip), %rsi     # 0x342a6
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movl $0x2, %edi
movl $0x27, %esi
movl $0x16, %edx
callq 0x775c
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe559
testb %al, %al
je 0x1df3b
leaq 0x1642e(%rip), %rsi     # 0x3430f
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
movl $0x3, %edi
movl $0x14, %esi
movl $0x29, %edx
callq 0x775c
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe559
testb %al, %al
je 0x1df5a
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %r14
retq
leaq 0x16346(%rip), %rdi     # 0x34269
leaq 0x14e24(%rip), %rsi     # 0x32d4e
leaq 0x16359(%rip), %rcx     # 0x3428a
movl $0x200, %edx            # imm = 0x200
callq 0x20d0
leaq 0x163a3(%rip), %rdi     # 0x342e5
leaq 0x14e05(%rip), %rsi     # 0x32d4e
leaq 0x1633a(%rip), %rcx     # 0x3428a
movl $0x203, %edx            # imm = 0x203
callq 0x20d0
leaq 0x163ee(%rip), %rdi     # 0x3434f
leaq 0x14de6(%rip), %rsi     # 0x32d4e
leaq 0x1631b(%rip), %rcx     # 0x3428a
movl $0x206, %edx            # imm = 0x206
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/movegen__test.cpp
// Function: test_movegen()
void test_movegen() {
    test_gen_knight_moves();
    test_gen_knight_captures();
    test_gen_knight_noncaptures();
    test_gen_bishop_moves();
    test_gen_bishop_captures();
    test_gen_bishop_noncaptures();
    test_gen_rook_moves();
    test_gen_rook_captures();
    test_gen_rook_noncaptures();
    test_gen_queen_moves();
    test_gen_queen_captures();
    test_gen_queen_noncaptures();
    test_gen_king_moves();
    test_gen_king_captures();
    test_gen_king_noncaptures();
    test_gen_pawn_moves();
    test_gen_pawn_captures();
    test_gen_pawn_noncaps();
    test_gen_moves();
    test_gen_legal_moves();
}

// Assembly:
pushq %rax
callq 0x19c10
callq 0x19dbe
callq 0x19e77
callq 0x1a0a0
callq 0x1a65f
callq 0x1a77d
callq 0x1ac9a
callq 0x1b045
callq 0x1b14d
callq 0x1b4a4
callq 0x1ba46
callq 0x1bb02
callq 0x1c053
callq 0x1caf3
callq 0x1ccb2
callq 0x1d07d
callq 0x1d72e
callq 0x1dc57
callq 0x1dd92
popq %rax
jmp 0x1de4e
nop
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/mvvlva__test.cpp
// Function: get_highest_scoring(position*, unsigned long long*, unsigned long long*)
move get_highest_scoring(position *pos,move *startp,move *endp) {
    move* bestp = 0;
    int32 bestscore = 0;

    for (move *mp=startp;mp<endp;mp++) {
        if (*mp != 0) {
            int32 score = mvvlva(pos,*mp);
            if (bestp==0 || score > bestscore) {
                bestp = mp;
                bestscore = score;
            }
        }
    }

    move bestmv = *bestp;
    *bestp = 0;
    return bestmv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1e022
movq %r15, %rdi
callq 0x8b29
testq %r12, %r12
sete %cl
cmpl %ebp, %eax
setg %dl
orb %cl, %dl
movq %r14, %rcx
jne 0x1e01d
movl %ebp, %eax
movq %r12, %rcx
movl %eax, %ebp
movq %rcx, %r12
addq $0x8, %r14
cmpq %rbx, %r14
jb 0x1dff6
movq (%r12), %rax
movq $0x0, (%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/mvvlva__test.cpp
// Function: test_mvvlva1()
void test_mvvlva1() {
    position pos;
    set_pos(&pos,"3r1rk1/p3qp1p/2bb2p1/2p5/3P4/1P6/PBQN1PPP/2R2RK1 b - - ");
    move moves[50],*endp;
    endp = gen_legal_moves(moves,&pos,true,true); // 46 moves

    move c5d4 = to_capture(PAWN,C5,D4,PAWN);
    move c6g2 = to_capture(BISHOP,C6,G2,PAWN);
    move d6h2 = to_capture(BISHOP,D6,H2,PAWN);

    move bestmv = get_highest_scoring(&pos,moves,endp);
    move bestmv2 = get_highest_scoring(&pos,moves,endp);
    move bestmv3 = get_highest_scoring(&pos,moves,endp);

    assert(bestmv==c5d4);
    assert(bestmv2 != bestmv3);
    assert(bestmv2==c6g2 || bestmv2==d6h2);
    assert(bestmv3==c6g2 || bestmv3==d6h2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x368, %rsp            # imm = 0x368
leaq 0x16321(%rip), %rsi     # 0x34379
leaq 0x1a0(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rax, %r12
movl $0x1, %edi
movl $0x1a, %esi
movl $0x23, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, 0x8(%rsp)
movl $0x3, %edi
movl $0x12, %esi
movl $0x36, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %r15
movl $0x3, %edi
movl $0x13, %esi
movl $0x37, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %r13
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x1dfe0
movq %rax, %r14
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x1dfe0
movq %rax, %rbp
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
movq %r12, %rdx
callq 0x1dfe0
cmpq 0x8(%rsp), %r14
jne 0x1e14b
cmpq %rax, %rbp
je 0x1e16a
cmpq %r15, %rbp
sete %cl
cmpq %r13, %rbp
sete %dl
orb %cl, %dl
je 0x1e189
cmpq %r15, %rax
sete %cl
cmpq %r13, %rax
sete %al
orb %cl, %al
je 0x1e1a8
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1625f(%rip), %rdi     # 0x343b1
leaq 0x16265(%rip), %rsi     # 0x343be
leaq 0x16274(%rip), %rcx     # 0x343d4
movl $0x2e, %edx
callq 0x20d0
leaq 0x16277(%rip), %rdi     # 0x343e8
leaq 0x16246(%rip), %rsi     # 0x343be
leaq 0x16255(%rip), %rcx     # 0x343d4
movl $0x2f, %edx
callq 0x20d0
leaq 0x1626b(%rip), %rdi     # 0x343fb
leaq 0x16227(%rip), %rsi     # 0x343be
leaq 0x16236(%rip), %rcx     # 0x343d4
movl $0x30, %edx
callq 0x20d0
leaq 0x1626b(%rip), %rdi     # 0x3441a
leaq 0x16208(%rip), %rsi     # 0x343be
leaq 0x16217(%rip), %rcx     # 0x343d4
movl $0x31, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/mvvlva__test.cpp
// Function: test_mvvlva4()
void test_mvvlva4() {
    position pos;
    set_pos(&pos,"6R1/kp6/8/1KpP4/8/8/8/6B1 w - c6");

    move moves[50],*endp;
    endp = gen_legal_moves(moves,&pos,true,true); // 28 moves

    move d5c6 = to_capture(PAWN,D5,C6,PAWN);
    set_epcapture(&d5c6);

    move b5c5 = to_capture(KING,B5,C5,PAWN);
    move g1c5 = to_capture(BISHOP,G1,C5,PAWN);

    assert(is_in_move_list(d5c6,moves,endp));
    assert(is_in_move_list(b5c5,moves,endp));
    assert(is_in_move_list(g1c5,moves,endp));

    assert(get_highest_scoring(&pos,moves,endp)==d5c6);
    assert(get_highest_scoring(&pos,moves,endp)==g1c5);
    assert(get_highest_scoring(&pos,moves,endp)==b5c5);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x370, %rsp            # imm = 0x370
leaq 0x15e00(%rip), %rsi     # 0x34880
leaq 0x1a8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa82
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rax, %rbx
movl $0x1, %edi
movl $0x1b, %esi
movl $0x12, %edx
movl $0x1, %ecx
callq 0x777b
leaq 0x8(%rsp), %r13
movq %rax, (%r13)
movq %r13, %rdi
callq 0x783b
movl $0x6, %edi
movl $0x19, %esi
movl $0x1a, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %r14
movl $0x3, %edi
movl $0x3e, %esi
movl $0x1a, %edx
movl $0x1, %ecx
callq 0x777b
movq %rax, %r15
movq (%r13), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x1ebc3
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x1ebe2
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xe682
testb %al, %al
je 0x1ec01
leaq 0x1a8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x1dfe0
cmpq 0x8(%rsp), %rax
jne 0x1ec20
leaq 0x1a8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x1dfe0
cmpq %r15, %rax
jne 0x1ec3f
leaq 0x1a8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x1dfe0
cmpq %r14, %rax
jne 0x1ec5e
addq $0x370, %rsp            # imm = 0x370
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x15cd7(%rip), %rdi     # 0x348a1
leaq 0x157ed(%rip), %rsi     # 0x343be
leaq 0x15cea(%rip), %rcx     # 0x348c2
movl $0x95, %edx
callq 0x20d0
leaq 0x15ced(%rip), %rdi     # 0x348d6
leaq 0x157ce(%rip), %rsi     # 0x343be
leaq 0x15ccb(%rip), %rcx     # 0x348c2
movl $0x96, %edx
callq 0x20d0
leaq 0x15cef(%rip), %rdi     # 0x348f7
leaq 0x157af(%rip), %rsi     # 0x343be
leaq 0x15cac(%rip), %rcx     # 0x348c2
movl $0x97, %edx
callq 0x20d0
leaq 0x15cf1(%rip), %rdi     # 0x34918
leaq 0x15790(%rip), %rsi     # 0x343be
leaq 0x15c8d(%rip), %rcx     # 0x348c2
movl $0x99, %edx
callq 0x20d0
leaq 0x15cfd(%rip), %rdi     # 0x34943
leaq 0x15771(%rip), %rsi     # 0x343be
leaq 0x15c6e(%rip), %rcx     # 0x348c2
movl $0x9a, %edx
callq 0x20d0
leaq 0x15d09(%rip), %rdi     # 0x3496e
leaq 0x15752(%rip), %rsi     # 0x343be
leaq 0x15c4f(%rip), %rcx     # 0x348c2
movl $0x9b, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/mvvlva__test.cpp
// Function: test_mvvlva()
void test_mvvlva() {
    test_mvvlva1();
    test_mvvlva2();
    test_mvvlva3();
    test_mvvlva4();
}

// Assembly:
pushq %rax
callq 0x1e040
callq 0x1e1c7
callq 0x1e51d
popq %rax
jmp 0x1ea69
nop
// File: /workspace/github_cpp_makefile_star2_O3/jswaff[P]prophet3/test/next__test.cpp
// Function: test_best_at_top()
void test_best_at_top() {
    position pos;
    reset_pos(&pos);

    move moves[20];
    move *endp = gen_legal_moves(moves,&pos,true,true);
    assert(endp-moves==20);

    set_move_score(moves+4,1000);
    set_move_score(moves+11,900);
    set_move_score(moves+7,-1500);
    move mv1 = moves[4];
    move mv2 = moves[11];
    move mv3 = moves[7];

    int i=0;
    for (move *mp=moves;mp<endp;mp++) {
        if (*mp != mv1 && *mp != mv2 && *mp != mv3) {
            assert(get_move_score(mp)==0);
        }
        best_at_top(mp,endp);

        if (i==0) {
            assert(*mp==mv1);
        } else if (i==1) {
            assert(*mp==mv2);
        } else if (i==19) {
            assert(*mp==mv3);
        }
        i++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
callq 0xaa51
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x78e0
movq %rax, %r14
subq %rbx, %rax
cmpq $0xa0, %rax
jne 0x1ee0e
leaq 0x20(%rsp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x78bc
leaq 0x58(%rsp), %rdi
movl $0x384, %esi            # imm = 0x384
callq 0x78bc
leaq 0x38(%rsp), %rdi
movl $0xfffffa24, %esi       # imm = 0xFFFFFA24
callq 0x78bc
cmpq %r14, %rbx
jae 0x1ed80
movq 0x20(%rsp), %r15
movq 0x38(%rsp), %r12
movq 0x58(%rsp), %r13
xorl %ebp, %ebp
movq (%rbx), %rax
cmpq %r15, %rax
sete %cl
cmpq %r13, %rax
sete %dl
orb %cl, %dl
cmpq %r12, %rax
sete %al
orb %dl, %al
jne 0x1ed49
movq %rbx, %rdi
callq 0x78a1
testl %eax, %eax
jne 0x1ed92
movq %rbx, %rdi
movq %r14, %rsi
callq 0x954b
cmpl $0x13, %ebp
je 0x1ed70
cmpl $0x1, %ebp
je 0x1ed69
testl %ebp, %ebp
jne 0x1ed75
cmpq %r15, (%rbx)
je 0x1ed75
jmp 0x1edb1
cmpq %r13, (%rbx)
je 0x1ed75
jmp 0x1edd0
cmpq %r12, (%rbx)
jne 0x1edef
incl %ebp
addq $0x8, %rbx
cmpq %r14, %rbx
jb 0x1ed22
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd3b9(%rip), %rdi      # 0x2c152
leaq 0x15c08(%rip), %rsi     # 0x349a8
leaq 0x15c15(%rip), %rcx     # 0x349bc
movl $0x1e, %edx
callq 0x20d0
leaq 0x15c1c(%rip), %rdi     # 0x349d4
leaq 0x15be9(%rip), %rsi     # 0x349a8
leaq 0x15bf6(%rip), %rcx     # 0x349bc
movl $0x23, %edx
callq 0x20d0
leaq 0x15c06(%rip), %rdi     # 0x349dd
leaq 0x15bca(%rip), %rsi     # 0x349a8
leaq 0x15bd7(%rip), %rcx     # 0x349bc
movl $0x25, %edx
callq 0x20d0
leaq 0x15bf0(%rip), %rdi     # 0x349e6
leaq 0x15bab(%rip), %rsi     # 0x349a8
leaq 0x15bb8(%rip), %rcx     # 0x349bc
movl $0x27, %edx
callq 0x20d0
leaq 0x15b84(%rip), %rdi     # 0x34999
leaq 0x15b8c(%rip), %rsi     # 0x349a8
leaq 0x15b99(%rip), %rcx     # 0x349bc
movl $0x12, %edx
callq 0x20d0