LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_transform_exact_score_mate()
void test_transform_exact_score_mate() {
    clear_hash_table(&htbl);
    position pos;
    set_pos(&pos,"3r2k1/p6p/2Q3p1/4q3/2P1p3/P3Pb2/1P3P1P/2K2BR1 b - - ");

    uint64 key = build_hash_key(&pos);
    move mv = to_move(ROOK,G8,F8);
    store_hash_entry(&htbl,key,build_hash_val(EXACT_SCORE,5,CHECKMATE-7,mv));

    uint64 val = get_hash_entry(&htbl,key);
    assert(val!=0);
    assert(get_hash_entry_type(val)==LOWER_BOUND);
    assert(get_hash_entry_move(val)==mv);
    assert(get_hash_entry_score(val)==CHECKMATE-500);
    assert(get_hash_entry_depth(val)==5);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0xe4cdb(%rip), %rbx     # 0xfaef0
movq %rbx, %rdi
callq 0x5dd9
leaq 0x19e4d(%rip), %rsi     # 0x30071
movq %rsp, %r14
movq %r14, %rdi
callq 0xa1b8
movq %r14, %rdi
callq 0x5a50
movq %rax, %r15
pushq $0x4
popq %rdi
pushq $0x6
popq %rsi
pushq $0x5
popq %rbp
movl %ebp, %edx
callq 0x7284
movq %rax, %r14
pushq $0x3
popq %rdi
movl %ebp, %esi
movl $0xfff8, %edx           # imm = 0xFFF8
movq %rax, %rcx
callq 0x5b8a
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5e8b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5e2e
testq %rax, %rax
je 0x162c8
movq %rax, %rbx
movq %rax, %rdi
callq 0x5d09
cmpl $0x1, %eax
jne 0x162e7
movq %rbx, %rdi
callq 0x5d41
cmpq %r14, %rax
jne 0x16306
movq %rbx, %rdi
callq 0x5d17
cmpl $0xfe0b, %eax           # imm = 0xFE0B
jne 0x16325
movq %rbx, %rdi
callq 0x5d10
cmpl $0x5, %eax
jne 0x16344
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19cb7(%rip), %rdi     # 0x2ff86
leaq 0x1987f(%rip), %rsi     # 0x2fb55
leaq 0x19dc9(%rip), %rcx     # 0x300a6
movl $0x1be, %edx            # imm = 0x1BE
callq 0x20c0
leaq 0x199e9(%rip), %rdi     # 0x2fcd7
leaq 0x19860(%rip), %rsi     # 0x2fb55
leaq 0x19daa(%rip), %rcx     # 0x300a6
movl $0x1bf, %edx            # imm = 0x1BF
callq 0x20c0
leaq 0x19a53(%rip), %rdi     # 0x2fd60
leaq 0x19841(%rip), %rsi     # 0x2fb55
leaq 0x19d8b(%rip), %rcx     # 0x300a6
movl $0x1c0, %edx            # imm = 0x1C0
callq 0x20c0
leaq 0x19c7d(%rip), %rdi     # 0x2ffa9
leaq 0x19822(%rip), %rsi     # 0x2fb55
leaq 0x19d6c(%rip), %rcx     # 0x300a6
movl $0x1c1, %edx            # imm = 0x1C1
callq 0x20c0
leaq 0x19d09(%rip), %rdi     # 0x30054
leaq 0x19803(%rip), %rsi     # 0x2fb55
leaq 0x19d4d(%rip), %rcx     # 0x300a6
movl $0x1c2, %edx            # imm = 0x1C2
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_transform_lower_bound_mated()
void test_transform_lower_bound_mated() {
    clear_hash_table(&htbl);
    position pos;
    set_pos(&pos,"2rq1bk1/p4p1p/1p4p1/3b4/3B1Q2/8/P4PpP/3RR1K1 w - - ");

    uint64 key = build_hash_key(&pos);
    move mv = to_move(ROOK,D1,A1);
    store_hash_entry(&htbl,key,build_hash_val(LOWER_BOUND,8,-CHECKMATE+10,mv));

    uint64 val = get_hash_entry(&htbl,key);
    assert(val!=0);
    assert(get_hash_entry_type(val)==MOVE_ONLY);
    assert(get_hash_entry_move(val)==mv);
    assert(get_hash_entry_depth(val)==8);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0xe4b7a(%rip), %rbx     # 0xfaef0
movq %rbx, %rdi
callq 0x5dd9
leaq 0x19d48(%rip), %rsi     # 0x300cd
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa1b8
movq %r14, %rdi
callq 0x5a50
movq %rax, %r15
pushq $0x4
popq %rdi
pushq $0x3b
popq %rsi
pushq $0x38
popq %rdx
callq 0x7284
movq %rax, %r14
pushq $0x1
popq %rdi
pushq $0x8
popq %rsi
movl $0xffff000b, %edx       # imm = 0xFFFF000B
movq %rax, %rcx
callq 0x5b8a
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5e8b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5e2e
testq %rax, %rax
je 0x16415
movq %rax, %rbx
movq %rax, %rdi
callq 0x5d09
testl %eax, %eax
jne 0x16434
movq %rbx, %rdi
callq 0x5d41
cmpq %r14, %rax
jne 0x16453
movq %rbx, %rdi
callq 0x5d10
cmpl $0x8, %eax
jne 0x16472
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x19b6a(%rip), %rdi     # 0x2ff86
leaq 0x19732(%rip), %rsi     # 0x2fb55
leaq 0x19cd7(%rip), %rcx     # 0x30101
movl $0x1cf, %edx            # imm = 0x1CF
callq 0x20c0
leaq 0x19bf5(%rip), %rdi     # 0x30030
leaq 0x19713(%rip), %rsi     # 0x2fb55
leaq 0x19cb8(%rip), %rcx     # 0x30101
movl $0x1d0, %edx            # imm = 0x1D0
callq 0x20c0
leaq 0x19906(%rip), %rdi     # 0x2fd60
leaq 0x196f4(%rip), %rsi     # 0x2fb55
leaq 0x19c99(%rip), %rcx     # 0x30101
movl $0x1d1, %edx            # imm = 0x1D1
callq 0x20c0
leaq 0x19cb0(%rip), %rdi     # 0x30129
leaq 0x196d5(%rip), %rsi     # 0x2fb55
leaq 0x19c7a(%rip), %rcx     # 0x30101
movl $0x1d2, %edx            # imm = 0x1D2
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_transform_exact_score_mated()
void test_transform_exact_score_mated() {
    clear_hash_table(&htbl);
    position pos;
    set_pos(&pos,"4r1k1/5bpp/2p5/3pr3/8/1B3pPq/PPR2P2/2R2QK1 b - - ");

    uint64 key = build_hash_key(&pos);
    move mv = to_move(PAWN,G7,G6);
    store_hash_entry(&htbl,key,build_hash_val(EXACT_SCORE,10,-CHECKMATE+2,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)==-CHECKMATE+500);
    assert(get_hash_entry_depth(val)==10);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0xe4a4c(%rip), %rbx     # 0xfaef0
movq %rbx, %rdi
callq 0x5dd9
leaq 0x19c93(%rip), %rsi     # 0x30146
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa1b8
movq %r14, %rdi
callq 0x5a50
movq %rax, %r15
pushq $0x1
popq %rdi
pushq $0xe
popq %rsi
pushq $0x16
popq %rdx
callq 0x7284
movq %rax, %r14
pushq $0x3
popq %rdi
pushq $0xa
popq %rsi
movl $0xffff0003, %edx       # imm = 0xFFFF0003
movq %rax, %rcx
callq 0x5b8a
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5e8b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5e2e
testq %rax, %rax
je 0x16557
movq %rax, %rbx
movq %rax, %rdi
callq 0x5d09
cmpl $0x2, %eax
jne 0x16576
movq %rbx, %rdi
callq 0x5d41
cmpq %r14, %rax
jne 0x16595
movq %rbx, %rdi
callq 0x5d17
cmpl $0xffff01f5, %eax       # imm = 0xFFFF01F5
jne 0x165b4
movq %rbx, %rdi
callq 0x5d10
cmpl $0xa, %eax
jne 0x165d3
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x19a28(%rip), %rdi     # 0x2ff86
leaq 0x195f0(%rip), %rsi     # 0x2fb55
leaq 0x19c0c(%rip), %rcx     # 0x30178
movl $0x1df, %edx            # imm = 0x1DF
callq 0x20c0
leaq 0x19800(%rip), %rdi     # 0x2fd7d
leaq 0x195d1(%rip), %rsi     # 0x2fb55
leaq 0x19bed(%rip), %rcx     # 0x30178
movl $0x1e0, %edx            # imm = 0x1E0
callq 0x20c0
leaq 0x197c4(%rip), %rdi     # 0x2fd60
leaq 0x195b2(%rip), %rsi     # 0x2fb55
leaq 0x19bce(%rip), %rcx     # 0x30178
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x20c0
leaq 0x19809(%rip), %rdi     # 0x2fdc4
leaq 0x19593(%rip), %rsi     # 0x2fb55
leaq 0x19baf(%rip), %rcx     # 0x30178
movl $0x1e2, %edx            # imm = 0x1E2
callq 0x20c0
leaq 0x19bc6(%rip), %rdi     # 0x301a0
leaq 0x19574(%rip), %rsi     # 0x2fb55
leaq 0x19b90(%rip), %rcx     # 0x30178
movl $0x1e3, %edx            # imm = 0x1E3
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/hash__test.cpp
// Function: test_transform_upper_bound_mated()
void test_transform_upper_bound_mated() {
    clear_hash_table(&htbl);
    position pos;
    set_pos(&pos,"r1b1k2r/1pp1q2p/p1n3p1/3QPp2/8/1BP3B1/P5PP/3R1RK1 w kq - ");

    uint64 key = build_hash_key(&pos);
    move mv = to_move(KING,G1,H1);
    store_hash_entry(&htbl,key,build_hash_val(UPPER_BOUND,7,-CHECKMATE+8,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)==-CHECKMATE+500);
    assert(get_hash_entry_depth(val)==7);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0xe48eb(%rip), %rbx     # 0xfaef0
movq %rbx, %rdi
callq 0x5dd9
leaq 0x19baa(%rip), %rsi     # 0x301be
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa1b8
movq %r14, %rdi
callq 0x5a50
movq %rax, %r15
pushq $0x6
popq %rdi
pushq $0x3e
popq %rsi
pushq $0x3f
popq %rdx
callq 0x7284
movq %rax, %r14
pushq $0x2
popq %rdi
pushq $0x7
popq %rsi
movl $0xffff0009, %edx       # imm = 0xFFFF0009
movq %rax, %rcx
callq 0x5b8a
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5e8b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5e2e
testq %rax, %rax
je 0x166b8
movq %rax, %rbx
movq %rax, %rdi
callq 0x5d09
cmpl $0x2, %eax
jne 0x166d7
movq %rbx, %rdi
callq 0x5d41
cmpq %r14, %rax
jne 0x166f6
movq %rbx, %rdi
callq 0x5d17
cmpl $0xffff01f5, %eax       # imm = 0xFFFF01F5
jne 0x16715
movq %rbx, %rdi
callq 0x5d10
cmpl $0x7, %eax
jne 0x16734
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x198c7(%rip), %rdi     # 0x2ff86
leaq 0x1948f(%rip), %rsi     # 0x2fb55
leaq 0x19b2b(%rip), %rcx     # 0x301f8
movl $0x1f0, %edx            # imm = 0x1F0
callq 0x20c0
leaq 0x1969f(%rip), %rdi     # 0x2fd7d
leaq 0x19470(%rip), %rsi     # 0x2fb55
leaq 0x19b0c(%rip), %rcx     # 0x301f8
movl $0x1f1, %edx            # imm = 0x1F1
callq 0x20c0
leaq 0x19663(%rip), %rdi     # 0x2fd60
leaq 0x19451(%rip), %rsi     # 0x2fb55
leaq 0x19aed(%rip), %rcx     # 0x301f8
movl $0x1f2, %edx            # imm = 0x1F2
callq 0x20c0
leaq 0x196a8(%rip), %rdi     # 0x2fdc4
leaq 0x19432(%rip), %rsi     # 0x2fb55
leaq 0x19ace(%rip), %rcx     # 0x301f8
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x20c0
leaq 0x19ae5(%rip), %rdi     # 0x30220
leaq 0x19413(%rip), %rsi     # 0x2fb55
leaq 0x19aaf(%rip), %rcx     # 0x301f8
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0xe4789(%rip), %r14     # 0xfaef0
movq %r14, %rdi
callq 0x5dd9
leaq 0x19ac7(%rip), %rsi     # 0x3023d
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rbx, %rdi
callq 0x5a50
movq %rax, %rbx
pushq $0x2
popq %rbp
pushq $0x1d
popq %rsi
pushq $0x23
popq %rdx
movl %ebp, %edi
callq 0x7284
movq %rax, %r15
pushq $0x4
popq %rsi
pushq $-0x5d
popq %rdx
movl %ebp, %edi
movq %rax, %rcx
callq 0x5b8a
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x5e8b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5e2e
testq %rax, %rax
je 0x16845
movq %rax, %r14
movq %rax, %rdi
callq 0x5d09
cmpl $0x2, %eax
jne 0x16864
movq %r14, %rdi
callq 0x5d41
cmpq %r15, %rax
jne 0x16883
movq %r14, %rdi
callq 0x5d17
cmpl $-0x5d, %eax
jne 0x168a2
movq %r14, %rdi
callq 0x5d10
cmpl $0x4, %eax
jne 0x168c1
leaq 0xe46d5(%rip), %r14     # 0xfaef0
movq %r14, %rdi
callq 0x5dd9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5e2e
testq %rax, %rax
jne 0x168e0
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1973a(%rip), %rdi     # 0x2ff86
leaq 0x19302(%rip), %rsi     # 0x2fb55
leaq 0x19a1e(%rip), %rcx     # 0x30278
movl $0x201, %edx            # imm = 0x201
callq 0x20c0
leaq 0x19512(%rip), %rdi     # 0x2fd7d
leaq 0x192e3(%rip), %rsi     # 0x2fb55
leaq 0x199ff(%rip), %rcx     # 0x30278
movl $0x202, %edx            # imm = 0x202
callq 0x20c0
leaq 0x194d6(%rip), %rdi     # 0x2fd60
leaq 0x192c4(%rip), %rsi     # 0x2fb55
leaq 0x199e0(%rip), %rcx     # 0x30278
movl $0x203, %edx            # imm = 0x203
callq 0x20c0
leaq 0x199e1(%rip), %rdi     # 0x3028a
leaq 0x192a5(%rip), %rsi     # 0x2fb55
leaq 0x199c1(%rip), %rcx     # 0x30278
movl $0x204, %edx            # imm = 0x204
callq 0x20c0
leaq 0x199e1(%rip), %rdi     # 0x302a9
leaq 0x19286(%rip), %rsi     # 0x2fb55
leaq 0x199a2(%rip), %rcx     # 0x30278
movl $0x205, %edx            # imm = 0x205
callq 0x20c0
leaq 0x195af(%rip), %rdi     # 0x2fe96
leaq 0x19267(%rip), %rsi     # 0x2fb55
leaq 0x19983(%rip), %rcx     # 0x30278
movl $0x209, %edx            # imm = 0x209
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x141f2
callq 0x14d19
callq 0x153a8
callq 0x157d2
callq 0x158b1
callq 0x1597b
callq 0x15b7f
callq 0x15df7
callq 0x15fcd
callq 0x160d3
callq 0x16201
callq 0x16363
callq 0x16491
callq 0x165f2
callq 0x16753
popq %rax
jmp 0x168ff
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorq %rsi, %rdi
xorl %eax, %eax
testq %rdi, %rdi
je 0x16d31
incl %eax
leaq -0x1(%rdi), %rcx
andq %rcx, %rdi
jmp 0x16d21
cmpl $0x41, %eax
jae 0x16d37
retq
pushq %rax
leaq 0x19691(%rip), %rdi     # 0x303d0
leaq 0x196a2(%rip), %rsi     # 0x303e8
leaq 0x196af(%rip), %rcx     # 0x303fc
pushq $0x18
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/init__test.cpp
// Function: test_hamming_distance()
void test_hamming_distance() {
    assert(hamming_distance(0,0)==0);
    assert(hamming_distance(0,1)==1);
    assert(hamming_distance(0,3)==2);
    assert(hamming_distance(7,1)==2);

    uint64 max32 = 4294967295UL;
    assert(hamming_distance(0,max32)==32);

    uint64 max64 = 18446744073709551615UL;

    assert(hamming_distance(0,max64)==64);
    assert(hamming_distance(max64,0)==64);

    assert(hamming_distance(max32,max64)==32);
}

// Assembly:
pushq %rax
xorl %edi, %edi
xorl %esi, %esi
callq 0x16d1c
testl %eax, %eax
jne 0x16df4
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x16d1c
cmpl $0x1, %eax
jne 0x16e10
pushq $0x3
popq %rsi
xorl %edi, %edi
callq 0x16d1c
cmpl $0x2, %eax
jne 0x16e2c
pushq $0x7
popq %rdi
pushq $0x1
popq %rsi
callq 0x16d1c
cmpl $0x2, %eax
jne 0x16e45
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edi, %edi
callq 0x16d1c
cmpl $0x20, %eax
jne 0x16e5e
pushq $-0x1
popq %rsi
xorl %edi, %edi
callq 0x16d1c
cmpl $0x40, %eax
jne 0x16e77
pushq $-0x1
popq %rdi
xorl %esi, %esi
callq 0x16d1c
cmpl $0x40, %eax
jne 0x16e90
pushq $-0x1
popq %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x16d1c
cmpl $0x20, %eax
jne 0x16ea9
popq %rax
retq
leaq 0x19629(%rip), %rdi     # 0x30424
leaq 0x195e6(%rip), %rsi     # 0x303e8
leaq 0x19634(%rip), %rcx     # 0x3043d
pushq $0x1e
jmp 0x16ec0
leaq 0x19643(%rip), %rdi     # 0x3045a
leaq 0x195ca(%rip), %rsi     # 0x303e8
leaq 0x19618(%rip), %rcx     # 0x3043d
pushq $0x1f
jmp 0x16ec0
leaq 0x19640(%rip), %rdi     # 0x30473
leaq 0x195ae(%rip), %rsi     # 0x303e8
leaq 0x195fc(%rip), %rcx     # 0x3043d
pushq $0x20
jmp 0x16ec0
leaq 0x19640(%rip), %rdi     # 0x3048c
leaq 0x19595(%rip), %rsi     # 0x303e8
leaq 0x195e3(%rip), %rcx     # 0x3043d
pushq $0x21
jmp 0x16ec0
leaq 0x19640(%rip), %rdi     # 0x304a5
leaq 0x1957c(%rip), %rsi     # 0x303e8
leaq 0x195ca(%rip), %rcx     # 0x3043d
pushq $0x24
jmp 0x16ec0
leaq 0x19645(%rip), %rdi     # 0x304c3
leaq 0x19563(%rip), %rsi     # 0x303e8
leaq 0x195b1(%rip), %rcx     # 0x3043d
pushq $0x28
jmp 0x16ec0
leaq 0x1964a(%rip), %rdi     # 0x304e1
leaq 0x1954a(%rip), %rsi     # 0x303e8
leaq 0x19598(%rip), %rcx     # 0x3043d
pushq $0x29
jmp 0x16ec0
leaq 0x1964f(%rip), %rdi     # 0x304ff
leaq 0x19531(%rip), %rsi     # 0x303e8
leaq 0x1957f(%rip), %rcx     # 0x3043d
pushq $0x2b
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe61f2(%rip), %rax     # 0xfd430
leaq 0xe626b(%rip), %rcx     # 0xfd4b0
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 0x172ed
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 0x1730c
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 0x1732b
popq %rax
retq
leaq 0x19302(%rip), %rdi     # 0x305f6
leaq 0x190ed(%rip), %rsi     # 0x303e8
leaq 0x1938f(%rip), %rcx     # 0x30691
movl $0x94, %edx
callq 0x20c0
leaq 0x19393(%rip), %rdi     # 0x306a6
leaq 0x190ce(%rip), %rsi     # 0x303e8
leaq 0x19370(%rip), %rcx     # 0x30691
movl $0x97, %edx
callq 0x20c0
leaq 0x1940f(%rip), %rdi     # 0x30741
leaq 0x190af(%rip), %rsi     # 0x303e8
leaq 0x19351(%rip), %rcx     # 0x30691
movl $0x9a, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe611e(%rip), %rax     # 0xfd470
movq (%rax), %rdx
leaq 0xe6154(%rip), %rcx     # 0xfd4b0
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 0x17405
cmpq $0xff, %rdx
jne 0x17424
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 0x17443
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 0x17462
popq %rax
retq
leaq 0x193d0(%rip), %rdi     # 0x307dc
leaq 0x18fd5(%rip), %rsi     # 0x303e8
leaq 0x1945d(%rip), %rcx     # 0x30877
movl $0xa0, %edx
callq 0x20c0
leaq 0x19461(%rip), %rdi     # 0x3088c
leaq 0x18fb6(%rip), %rsi     # 0x303e8
leaq 0x1943e(%rip), %rcx     # 0x30877
movl $0xa1, %edx
callq 0x20c0
leaq 0x19458(%rip), %rdi     # 0x308a2
leaq 0x18f97(%rip), %rsi     # 0x303e8
leaq 0x1941f(%rip), %rcx     # 0x30877
movl $0xa4, %edx
callq 0x20c0
leaq 0x194d4(%rip), %rdi     # 0x3093d
leaq 0x18f78(%rip), %rsi     # 0x303e8
leaq 0x19400(%rip), %rcx     # 0x30877
movl $0xa7, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16d55
callq 0x16ec6
callq 0x17481
callq 0x17236
popq %rax
jmp 0x1734a
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14926(%rip), %rsi     # 0x2be3d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq 0x1b0(%rbx), %rdx
pushq $0x1c
popq %rsi
movq %rbx, %rdi
callq 0x62e4
testq %rax, %rax
jne 0x1756c
leaq 0x8(%rsp), %rdi
movq 0x1b0(%rdi), %rdx
pushq $0x1b
popq %rsi
callq 0x62e4
leaq 0xe5f5a(%rip), %rcx     # 0xfd4b0
movq 0x68(%rcx), %rdx
orq 0x48(%rcx), %rdx
cmpq %rdx, %rax
jne 0x17585
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x194b0(%rip), %rdi     # 0x30a23
leaq 0x194b9(%rip), %rsi     # 0x30a33
leaq 0x194c7(%rip), %rcx     # 0x30a48
pushq $0x11
jmp 0x1759c
leaq 0x194d5(%rip), %rdi     # 0x30a61
leaq 0x194a0(%rip), %rsi     # 0x30a33
leaq 0x194ae(%rip), %rcx     # 0x30a48
pushq $0x14
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1488c(%rip), %rsi     # 0x2be3d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq 0x1b0(%rbx), %rdx
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x63e8
leaq 0xe5ed9(%rip), %rcx     # 0xfd4b0
cmpq 0x68(%rcx), %rax
jne 0x175e6
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x194a4(%rip), %rdi     # 0x30a91
leaq 0x1943f(%rip), %rsi     # 0x30a33
leaq 0x194b1(%rip), %rcx     # 0x30aac
pushq $0x1c
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x34
popq %rsi
pushq $0x24
popq %rdx
callq 0x7284
movq %rax, %rbx
movq %rax, %rdi
callq 0x737c
cmpl $0x1, %eax
jne 0x1768b
movq %rbx, %rdi
callq 0x736b
cmpl $0x34, %eax
jne 0x176a7
movq %rbx, %rdi
callq 0x7372
cmpl $0x24, %eax
jne 0x176c0
movq %rbx, %rdi
callq 0x73a4
testb %al, %al
jne 0x176d9
movq %rbx, %rdi
callq 0x739a
testb %al, %al
jne 0x176f2
movq %rbx, %rdi
callq 0x73ae
testb %al, %al
jne 0x1770b
movq %rbx, %rdi
callq 0x7386
testl %eax, %eax
jne 0x17724
popq %rbx
retq
leaq 0x187d3(%rip), %rdi     # 0x2fe65
leaq 0x1942a(%rip), %rsi     # 0x30ac3
leaq 0x19437(%rip), %rcx     # 0x30ad7
pushq $0xf
jmp 0x1773b
leaq 0x1943d(%rip), %rdi     # 0x30aeb
leaq 0x1940e(%rip), %rsi     # 0x30ac3
leaq 0x1941b(%rip), %rcx     # 0x30ad7
pushq $0x10
jmp 0x1773b
leaq 0x19438(%rip), %rdi     # 0x30aff
leaq 0x193f5(%rip), %rsi     # 0x30ac3
leaq 0x19402(%rip), %rcx     # 0x30ad7
pushq $0x11
jmp 0x1773b
leaq 0x19431(%rip), %rdi     # 0x30b11
leaq 0x193dc(%rip), %rsi     # 0x30ac3
leaq 0x193e9(%rip), %rcx     # 0x30ad7
pushq $0x12
jmp 0x1773b
leaq 0x1942a(%rip), %rdi     # 0x30b23
leaq 0x193c3(%rip), %rsi     # 0x30ac3
leaq 0x193d0(%rip), %rcx     # 0x30ad7
pushq $0x13
jmp 0x1773b
leaq 0x19421(%rip), %rdi     # 0x30b33
leaq 0x193aa(%rip), %rsi     # 0x30ac3
leaq 0x193b7(%rip), %rcx     # 0x30ad7
pushq $0x14
jmp 0x1773b
leaq 0x19417(%rip), %rdi     # 0x30b42
leaq 0x19391(%rip), %rsi     # 0x30ac3
leaq 0x1939e(%rip), %rcx     # 0x30ad7
pushq $0x15
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x23
popq %rsi
pushq $0x2a
popq %rdx
callq 0x7284
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x7352
movq (%rbx), %rdi
callq 0x737c
cmpl $0x1, %eax
jne 0x18103
movq 0x8(%rsp), %rdi
callq 0x736b
cmpl $0x23, %eax
jne 0x1811f
movq 0x8(%rsp), %rdi
callq 0x7372
cmpl $0x2a, %eax
jne 0x1813b
movq 0x8(%rsp), %rdi
callq 0x73a4
testb %al, %al
je 0x18154
movq 0x8(%rsp), %rdi
callq 0x739a
testb %al, %al
je 0x1816d
movq 0x8(%rsp), %rdi
callq 0x7390
cmpl $0x1, %eax
jne 0x18186
movq 0x8(%rsp), %rdi
callq 0x73ae
testb %al, %al
jne 0x1819f
movq 0x8(%rsp), %rdi
callq 0x7386
testl %eax, %eax
jne 0x181b8
addq $0x10, %rsp
popq %rbx
retq
leaq 0x17d5b(%rip), %rdi     # 0x2fe65
leaq 0x189b2(%rip), %rsi     # 0x30ac3
leaq 0x18b95(%rip), %rcx     # 0x30cad
pushq $0x62
jmp 0x181cf
leaq 0x18ba1(%rip), %rdi     # 0x30cc7
leaq 0x18996(%rip), %rsi     # 0x30ac3
leaq 0x18b79(%rip), %rcx     # 0x30cad
pushq $0x63
jmp 0x181cf
leaq 0x18b99(%rip), %rdi     # 0x30cdb
leaq 0x1897a(%rip), %rsi     # 0x30ac3
leaq 0x18b5d(%rip), %rcx     # 0x30cad
pushq $0x64
jmp 0x181cf
leaq 0x189b7(%rip), %rdi     # 0x30b12
leaq 0x18961(%rip), %rsi     # 0x30ac3
leaq 0x18b44(%rip), %rcx     # 0x30cad
pushq $0x65
jmp 0x181cf
leaq 0x189b0(%rip), %rdi     # 0x30b24
leaq 0x18948(%rip), %rsi     # 0x30ac3
leaq 0x18b2b(%rip), %rcx     # 0x30cad
pushq $0x66
jmp 0x181cf
leaq 0x18b03(%rip), %rdi     # 0x30c90
leaq 0x1892f(%rip), %rsi     # 0x30ac3
leaq 0x18b12(%rip), %rcx     # 0x30cad
pushq $0x67
jmp 0x181cf
leaq 0x1898d(%rip), %rdi     # 0x30b33
leaq 0x18916(%rip), %rsi     # 0x30ac3
leaq 0x18af9(%rip), %rcx     # 0x30cad
pushq $0x68
jmp 0x181cf
leaq 0x18983(%rip), %rdi     # 0x30b42
leaq 0x188fd(%rip), %rsi     # 0x30ac3
leaq 0x18ae0(%rip), %rcx     # 0x30cad
pushq $0x69
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x6
popq %rdi
pushq $0x3c
popq %rsi
pushq $0x3f
popq %rdx
callq 0x7284
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x7366
movq (%rbx), %rdi
callq 0x737c
cmpl $0x6, %eax
jne 0x18275
movq 0x8(%rsp), %rdi
callq 0x736b
cmpl $0x3c, %eax
jne 0x18291
movq 0x8(%rsp), %rdi
callq 0x7372
cmpl $0x3f, %eax
jne 0x182aa
movq 0x8(%rsp), %rdi
callq 0x73a4
testb %al, %al
jne 0x182c3
movq 0x8(%rsp), %rdi
callq 0x739a
testb %al, %al
jne 0x182dc
movq 0x8(%rsp), %rdi
callq 0x73ae
testb %al, %al
je 0x182f5
movq 0x8(%rsp), %rdi
callq 0x7386
testl %eax, %eax
jne 0x1830e
addq $0x10, %rsp
popq %rbx
retq
leaq 0x18a71(%rip), %rdi     # 0x30ced
leaq 0x18840(%rip), %rsi     # 0x30ac3
leaq 0x18a77(%rip), %rcx     # 0x30d01
pushq $0x6f
jmp 0x18325
leaq 0x18a80(%rip), %rdi     # 0x30d18
leaq 0x18824(%rip), %rsi     # 0x30ac3
leaq 0x18a5b(%rip), %rcx     # 0x30d01
pushq $0x70
jmp 0x18325
leaq 0x18a7b(%rip), %rdi     # 0x30d2c
leaq 0x1880b(%rip), %rsi     # 0x30ac3
leaq 0x18a42(%rip), %rcx     # 0x30d01
pushq $0x71
jmp 0x18325
leaq 0x18847(%rip), %rdi     # 0x30b11
leaq 0x187f2(%rip), %rsi     # 0x30ac3
leaq 0x18a29(%rip), %rcx     # 0x30d01
pushq $0x72
jmp 0x18325
leaq 0x18840(%rip), %rdi     # 0x30b23
leaq 0x187d9(%rip), %rsi     # 0x30ac3
leaq 0x18a10(%rip), %rcx     # 0x30d01
pushq $0x73
jmp 0x18325
leaq 0x18838(%rip), %rdi     # 0x30b34
leaq 0x187c0(%rip), %rsi     # 0x30ac3
leaq 0x189f7(%rip), %rcx     # 0x30d01
pushq $0x74
jmp 0x18325
leaq 0x1882d(%rip), %rdi     # 0x30b42
leaq 0x187a7(%rip), %rsi     # 0x30ac3
leaq 0x189de(%rip), %rcx     # 0x30d01
pushq $0x75
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17610
callq 0x17741
callq 0x17d50
callq 0x18048
callq 0x181d5
popq %rax
jmp 0x1832b
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
callq 0xa187
movq %rsp, %r14
pushq $0x39
popq %rdx
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %ecx
movl %ebp, %r8d
callq 0x7f93
pushq $0x3e
popq %rdx
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %ecx
movl %ebp, %r8d
callq 0x7f93
movq %rax, %rbx
subq %r14, %rax
cmpq $0x20, %rax
jne 0x18658
pushq $0x2
popq %rdi
pushq $0x39
popq %rsi
pushq $0x28
popq %rdx
callq 0x7284
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x18671
pushq $0x2
popq %rdi
pushq $0x39
popq %rsi
pushq $0x2a
popq %rdx
callq 0x7284
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x1868a
pushq $0x2
popq %rdi
pushq $0x3e
popq %rsi
pushq $0x2d
popq %rdx
callq 0x7284
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x186a3
pushq $0x2
popq %rdi
pushq $0x3e
popq %rsi
pushq $0x2f
popq %rdx
callq 0x7284
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x186bc
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x187a0(%rip), %rdi     # 0x30dff
leaq 0x187ab(%rip), %rsi     # 0x30e11
leaq 0x187bb(%rip), %rcx     # 0x30e28
pushq $0x15
jmp 0x186d3
leaq 0x187cd(%rip), %rdi     # 0x30e45
leaq 0x18792(%rip), %rsi     # 0x30e11
leaq 0x187a2(%rip), %rcx     # 0x30e28
pushq $0x16
jmp 0x186d3
leaq 0x187e4(%rip), %rdi     # 0x30e75
leaq 0x18779(%rip), %rsi     # 0x30e11
leaq 0x18789(%rip), %rcx     # 0x30e28
pushq $0x17
jmp 0x186d3
leaq 0x187fb(%rip), %rdi     # 0x30ea5
leaq 0x18760(%rip), %rsi     # 0x30e11
leaq 0x18770(%rip), %rcx     # 0x30e28
pushq $0x18
jmp 0x186d3
leaq 0x18812(%rip), %rdi     # 0x30ed5
leaq 0x18747(%rip), %rsi     # 0x30e11
leaq 0x18757(%rip), %rcx     # 0x30e28
pushq $0x19
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1881b(%rip), %rsi     # 0x30f05
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rsp, %r14
pushq $0x24
popq %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x7f93
movq %rax, %rbx
subq %r14, %rax
cmpq $0x8, %rax
jne 0x18748
pushq $0x2
popq %rdi
pushq $0x24
popq %rsi
pushq $0x15
popq %rdx
pushq $0x1
popq %rcx
callq 0x72a3
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x18761
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
leaq 0x187da(%rip), %rdi     # 0x30f29
leaq 0x186bb(%rip), %rsi     # 0x30e11
leaq 0x187da(%rip), %rcx     # 0x30f37
pushq $0x23
jmp 0x18778
leaq 0x187ef(%rip), %rdi     # 0x30f57
leaq 0x186a2(%rip), %rsi     # 0x30e11
leaq 0x187c1(%rip), %rcx     # 0x30f37
pushq $0x24
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18776(%rip), %rsi     # 0x30f05
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rsp, %r14
pushq $0x24
popq %rdx
pushq $0x1
popq %r8
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x7f93
movq %rax, %rbx
subq %r14, %rax
cmpq $0x30, %rax
jne 0x188a6
pushq $0x2
popq %rdi
pushq $0x24
popq %rsi
pushq $0x1e
popq %rdx
callq 0x7284
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x188c2
pushq $0x2
popq %rdi
pushq $0x24
popq %rsi
pushq $0x2e
popq %rdx
callq 0x7284
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x188db
pushq $0x2
popq %rdi
pushq $0x24
popq %rsi
pushq $0x35
popq %rdx
callq 0x7284
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x188f4
pushq $0x2
popq %rdi
pushq $0x24
popq %rsi
pushq $0x33
popq %rdx
callq 0x7284
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x1890d
pushq $0x2
popq %rdi
pushq $0x24
popq %rsi
pushq $0x2a
popq %rdx
callq 0x7284
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x18926
pushq $0x2
popq %rdi
pushq $0x24
popq %rsi
pushq $0x1a
popq %rdx
callq 0x7284
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x1893f
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
leaq 0x186e2(%rip), %rdi     # 0x30f8f
leaq 0x1855d(%rip), %rsi     # 0x30e11
leaq 0x186e2(%rip), %rcx     # 0x30f9d
pushq $0x2e
jmp 0x18956
leaq 0x186f7(%rip), %rdi     # 0x30fc0
leaq 0x18541(%rip), %rsi     # 0x30e11
leaq 0x186c6(%rip), %rcx     # 0x30f9d
pushq $0x2f
jmp 0x18956
leaq 0x1870e(%rip), %rdi     # 0x30ff0
leaq 0x18528(%rip), %rsi     # 0x30e11
leaq 0x186ad(%rip), %rcx     # 0x30f9d
pushq $0x30
jmp 0x18956
leaq 0x18725(%rip), %rdi     # 0x31020
leaq 0x1850f(%rip), %rsi     # 0x30e11
leaq 0x18694(%rip), %rcx     # 0x30f9d
pushq $0x31
jmp 0x18956
leaq 0x1873c(%rip), %rdi     # 0x31050
leaq 0x184f6(%rip), %rsi     # 0x30e11
leaq 0x1867b(%rip), %rcx     # 0x30f9d
pushq $0x32
jmp 0x18956
leaq 0x18753(%rip), %rdi     # 0x31080
leaq 0x184dd(%rip), %rsi     # 0x30e11
leaq 0x18662(%rip), %rcx     # 0x30f9d
pushq $0x33
jmp 0x18956
leaq 0x1876a(%rip), %rdi     # 0x310b0
leaq 0x184c4(%rip), %rsi     # 0x30e11
leaq 0x18649(%rip), %rcx     # 0x30f9d
pushq $0x34
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
leaq 0x18273(%rip), %rsi     # 0x310e0
leaq 0xa8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rsp, %r14
pushq $0x1c
popq %rdx
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x80ac
pushq $0x24
popq %rdx
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x80ac
movq %rax, %rbx
subq %r14, %rax
cmpq $0x10, %rax
jne 0x18f07
pushq $0x3
popq %rdi
pushq $0x1c
popq %rsi
pushq $0xa
popq %rdx
pushq $0x1
popq %rcx
callq 0x72a3
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x18f20
pushq $0x3
popq %rdi
pushq $0x24
popq %rsi
pushq $0x2b
popq %rdx
pushq $0x1
popq %rcx
callq 0x72a3
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x18f39
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1859c(%rip), %rdi     # 0x314aa
leaq 0x17efc(%rip), %rsi     # 0x30e11
leaq 0x185a0(%rip), %rcx     # 0x314bc
pushq $0x5c
jmp 0x18f50
leaq 0x183c3(%rip), %rdi     # 0x312ea
leaq 0x17ee3(%rip), %rsi     # 0x30e11
leaq 0x18587(%rip), %rcx     # 0x314bc
pushq $0x5d
jmp 0x18f50
leaq 0x18472(%rip), %rdi     # 0x313b2
leaq 0x17eca(%rip), %rsi     # 0x30e11
leaq 0x1856e(%rip), %rcx     # 0x314bc
pushq $0x5e
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa187
movq %rsp, %rbx
pushq $0x3f
popq %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x819f
cmpq %rbx, %rax
jne 0x197c7
leaq 0x17dd5(%rip), %rsi     # 0x3153f
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
callq 0xa1b8
pushq $0x35
popq %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x819f
movq %rax, %r14
subq %rbx, %rax
cmpq $0x8, %rax
jne 0x197e6
pushq $0x35
popq %rsi
pushq $0x31
popq %rdx
pushq $0x4
popq %rcx
movl %ecx, %edi
callq 0x72a3
movq %rsp, %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0xdacb
testb %al, %al
je 0x19805
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r14
retq
leaq 0x17d44(%rip), %rdi     # 0x31512
leaq 0x1763c(%rip), %rsi     # 0x30e11
leaq 0x17f6e(%rip), %rcx     # 0x3174a
movl $0x9b, %edx
callq 0x20c0
leaq 0x17f7b(%rip), %rdi     # 0x31768
leaq 0x1761d(%rip), %rsi     # 0x30e11
leaq 0x17f4f(%rip), %rcx     # 0x3174a
movl $0xa0, %edx
callq 0x20c0
leaq 0x17f08(%rip), %rdi     # 0x31714
leaq 0x175fe(%rip), %rsi     # 0x30e11
leaq 0x17f30(%rip), %rcx     # 0x3174a
movl $0xa2, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17732(%rip), %rsi     # 0x317ad
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rsp, %r14
pushq $0x2e
popq %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x8292
movq %rax, %rbx
subq %r14, %rax
cmpq $0x8, %rax
jne 0x1a0dc
pushq $0x5
popq %rdi
pushq $0x2e
popq %rsi
pushq $0x13
popq %rdx
pushq $0x3
popq %rcx
callq 0x72a3
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x1a0fb
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r14
retq
leaq 0x17685(%rip), %rdi     # 0x31768
leaq 0x16d27(%rip), %rsi     # 0x30e11
leaq 0x17a51(%rip), %rcx     # 0x31b42
movl $0xe0, %edx
callq 0x20c0
leaq 0x17a07(%rip), %rdi     # 0x31b09
leaq 0x16d08(%rip), %rsi     # 0x30e11
leaq 0x17a32(%rip), %rcx     # 0x31b42
movl $0xe1, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16ba6(%rip), %rsi     # 0x31b96
leaq 0xa8(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rsp, %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x7b3b
movq %rax, %r14
subq %r15, %rax
cmpq $0x8, %rax
jne 0x1b0eb
pushq $0x6
popq %rdi
pushq $0x13
popq %rsi
pushq $0x1c
popq %rdx
pushq $0x1
popq %rcx
callq 0x72a3
movq %rsp, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xdacb
testb %al, %al
je 0x1b10a
leaq 0x11dcb(%rip), %rsi     # 0x2ce1f
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
callq 0xa1b8
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x7b3b
movq %rax, %r14
subq %rbx, %rax
cmpq $0x8, %rax
jne 0x1b129
pushq $0x6
popq %rdi
pushq $0x3c
popq %rsi
pushq $0x33
popq %rdx
pushq $0x4
popq %rcx
callq 0x72a3
movq %rsp, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xdacb
testb %al, %al
je 0x1b148
leaq 0x11dca(%rip), %rsi     # 0x2ce7f
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
callq 0xa1b8
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x7b3b
cmpq %rbx, %rax
jne 0x1b167
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r14
popq %r15
retq
leaq 0x16676(%rip), %rdi     # 0x31768
leaq 0x15d18(%rip), %rsi     # 0x30e11
leaq 0x16fda(%rip), %rcx     # 0x320da
movl $0x148, %edx            # imm = 0x148
callq 0x20c0
leaq 0x16b64(%rip), %rdi     # 0x31c75
leaq 0x15cf9(%rip), %rsi     # 0x30e11
leaq 0x16fbb(%rip), %rcx     # 0x320da
movl $0x149, %edx            # imm = 0x149
callq 0x20c0
leaq 0x16fc8(%rip), %rdi     # 0x320f8
leaq 0x15cda(%rip), %rsi     # 0x30e11
leaq 0x16f9c(%rip), %rcx     # 0x320da
movl $0x14e, %edx            # imm = 0x14E
callq 0x20c0
leaq 0x16c80(%rip), %rdi     # 0x31dcf
leaq 0x15cbb(%rip), %rsi     # 0x30e11
leaq 0x16f7d(%rip), %rcx     # 0x320da
movl $0x14f, %edx            # imm = 0x14F
callq 0x20c0
leaq 0x16f9a(%rip), %rdi     # 0x32108
leaq 0x15c9c(%rip), %rsi     # 0x30e11
leaq 0x16f5e(%rip), %rcx     # 0x320da
movl $0x154, %edx            # imm = 0x154
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x160ef(%rip), %rsi     # 0x3214b
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0xa1b8
movq %rsp, %r14
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x74e1
movq %rax, %rbx
subq %r14, %rax
cmpq $0x18, %rax
jne 0x1c0f6
pushq $0x1
popq %rdi
pushq $0x36
popq %rsi
pushq $0x2e
popq %rdx
callq 0x7284
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x1c115
pushq $0x1
popq %rdi
pushq $0x36
popq %rsi
pushq $0x26
popq %rdx
callq 0x7284
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x1c134
pushq $0x1
popq %rdi
pushq $0x1c
popq %rsi
pushq $0x14
popq %rdx
callq 0x7284
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x1c153
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r14
retq
leaq 0x15d41(%rip), %rdi     # 0x31e3e
leaq 0x14d0d(%rip), %rsi     # 0x30e11
leaq 0x161bc(%rip), %rcx     # 0x322c7
movl $0x1e7, %edx            # imm = 0x1E7
callq 0x20c0
leaq 0x16085(%rip), %rdi     # 0x321a1
leaq 0x14cee(%rip), %rsi     # 0x30e11
leaq 0x1619d(%rip), %rcx     # 0x322c7
movl $0x1e8, %edx            # imm = 0x1E8
callq 0x20c0
leaq 0x16094(%rip), %rdi     # 0x321cf
leaq 0x14ccf(%rip), %rsi     # 0x30e11
leaq 0x1617e(%rip), %rcx     # 0x322c7
movl $0x1e9, %edx            # imm = 0x1E9
callq 0x20c0
leaq 0x160a3(%rip), %rdi     # 0x321fd
leaq 0x14cb0(%rip), %rsi     # 0x30e11
leaq 0x1615f(%rip), %rcx     # 0x322c7
movl $0x1ea, %edx            # imm = 0x1EA
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa187
leaq 0x1d0(%rsp), %rbx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %ecx, %edx
callq 0x7482
subq %rbx, %rax
cmpq $0xa0, %rax
jne 0x1c1e6
leaq 0xf2f0(%rip), %rsi      # 0x2b4a3
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa1b8
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %ecx, %edx
callq 0x7482
subq %rbx, %rax
cmpq $0xa0, %rax
jne 0x1c205
addq $0x368, %rsp            # imm = 0x368
popq %rbx
popq %r14
retq
leaq 0x160f7(%rip), %rdi     # 0x322e4
leaq 0x14c1d(%rip), %rsi     # 0x30e11
leaq 0x160f8(%rip), %rcx     # 0x322f3
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x20c0
leaq 0x160d8(%rip), %rdi     # 0x322e4
leaq 0x14bfe(%rip), %rsi     # 0x30e11
leaq 0x160d9(%rip), %rcx     # 0x322f3
movl $0x1f8, %edx            # imm = 0x1F8
callq 0x20c0