LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jswaff[P]prophet3/test/next__test.cpp
// Function: test_pv_and_hash_same_move()
void test_pv_and_hash_same_move() {
    position pos;
    reset_pos(&pos);

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

    // make move 4 the PV move and move 2 the hash move
    move_order_dto mo_dto;
    mo_dto.startp = mo_dto.currentp = mo_dto.endp = moves;
    mo_dto.pv_move = moves[7];
    mo_dto.hash_move = mo_dto.pv_move;
    mo_dto.killer1 = 0;
    mo_dto.killer2 = 0;
    mo_dto.caps_only = false;
    mo_dto.next_stage = PVMOVE;

    move *nextp;
    assert(next(&pos,&nextp,&mo_dto));
    assert(*nextp==mo_dto.pv_move);

    for (int i=1;i<20;i++) {
        assert(next(&pos,&nextp,&mo_dto));
        assert(*nextp!=mo_dto.pv_move);
    }

    // 21st call should return false
    assert(!next(&pos,&nextp,&mo_dto));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb80, %rsp            # imm = 0xB80
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq -0xb30(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
leaq -0xb30(%rbp), %rax
movq %rax, -0xb40(%rbp)
movq %rax, -0xb38(%rbp)
movq %rax, -0xb48(%rbp)
movq -0xaf8(%rbp), %rax
movq %rax, -0xb68(%rbp)
movq -0xb68(%rbp), %rax
movq %rax, -0xb60(%rbp)
movq $0x0, -0xb58(%rbp)
movq $0x0, -0xb50(%rbp)
movb $0x0, -0xb6c(%rbp)
movl $0x0, -0xb70(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0xb78(%rbp), %rsi
leaq -0xb70(%rbp), %rdx
callq 0xc670
testb $0x1, %al
jne 0x29b40
jmp 0x29b42
jmp 0x29b61
leaq 0x1798f(%rip), %rdi     # 0x414d8
leaq 0x176fa(%rip), %rsi     # 0x4124a
movl $0x93, %edx
leaq 0x17942(%rip), %rcx     # 0x4149e
callq 0x20c0
movq -0xb78(%rbp), %rax
movq (%rax), %rax
cmpq -0xb68(%rbp), %rax
jne 0x29b76
jmp 0x29b95
leaq 0x1785c(%rip), %rdi     # 0x413d9
leaq 0x176c6(%rip), %rsi     # 0x4124a
movl $0x94, %edx
leaq 0x1790e(%rip), %rcx     # 0x4149e
callq 0x20c0
movl $0x1, -0xb7c(%rbp)
cmpl $0x14, -0xb7c(%rbp)
jge 0x29c37
leaq -0x1c8(%rbp), %rdi
leaq -0xb78(%rbp), %rsi
leaq -0xb70(%rbp), %rdx
callq 0xc670
testb $0x1, %al
jne 0x29bcc
jmp 0x29bce
jmp 0x29bed
leaq 0x17903(%rip), %rdi     # 0x414d8
leaq 0x1766e(%rip), %rsi     # 0x4124a
movl $0x97, %edx
leaq 0x178b6(%rip), %rcx     # 0x4149e
callq 0x20c0
movq -0xb78(%rbp), %rax
movq (%rax), %rax
cmpq -0xb68(%rbp), %rax
je 0x29c02
jmp 0x29c21
leaq 0x178b7(%rip), %rdi     # 0x414c0
leaq 0x1763a(%rip), %rsi     # 0x4124a
movl $0x98, %edx
leaq 0x17882(%rip), %rcx     # 0x4149e
callq 0x20c0
jmp 0x29c23
movl -0xb7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb7c(%rbp)
jmp 0x29b9f
leaq -0x1c8(%rbp), %rdi
leaq -0xb78(%rbp), %rsi
leaq -0xb70(%rbp), %rdx
callq 0xc670
xorb $-0x1, %al
testb $0x1, %al
jne 0x29c59
jmp 0x29c5b
jmp 0x29c7a
leaq 0x17875(%rip), %rdi     # 0x414d7
leaq 0x175e1(%rip), %rsi     # 0x4124a
movl $0x9c, %edx
leaq 0x17829(%rip), %rcx     # 0x4149e
callq 0x20c0
addq $0xb80, %rsp            # imm = 0xB80
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/next__test.cpp
// Function: test_ep_ordered_as_capture()
void test_ep_ordered_as_capture() {
    position pos;
    set_pos(&pos,"8/3p4/8/4P3/8/8/K6k/8 b - -");

    apply_move(&pos,to_move(PAWN,D7,D5),gundos);

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

    move epcap = to_capture(PAWN,E5,D6,PAWN);
    set_epcapture(&epcap);
    assert(is_in_move_list(epcap,moves,endp));

    move_order_dto mo_dto;
    mo_dto.startp = mo_dto.currentp = mo_dto.endp = moves;
    mo_dto.pv_move = 0;
    mo_dto.hash_move = 0;
    mo_dto.killer1 = 0;
    mo_dto.killer2 = 0;
    mo_dto.next_stage = PVMOVE;

    move *m;
    next(&pos,&m,&mo_dto);
    assert(clear_score(*m) == epcap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3c0, %rsp            # imm = 0x3C0
leaq -0x1c8(%rbp), %rdi
leaq 0x1624e(%rip), %rsi     # 0x41b27
callq 0xf3e0
movl $0x1, %edi
movl $0xb, %esi
movl $0x1b, %edx
callq 0xa830
movq %rax, %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xa83ad(%rip), %rdx     # 0xd3cb0
callq 0x3620
leaq -0x360(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0xac70
movq %rax, -0x368(%rbp)
movl $0x1, %ecx
movl $0x1c, %esi
movl $0x13, %edx
movl %ecx, %edi
callq 0xa890
movq %rax, -0x370(%rbp)
leaq -0x370(%rbp), %rdi
callq 0xaa20
movq -0x370(%rbp), %rdi
leaq -0x360(%rbp), %rsi
movq -0x368(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x2b972
jmp 0x2b974
jmp 0x2b993
leaq 0x161c8(%rip), %rdi     # 0x41b43
leaq 0x158c8(%rip), %rsi     # 0x4124a
movl $0x1c9, %edx            # imm = 0x1C9
leaq 0x161d7(%rip), %rcx     # 0x41b65
callq 0x20c0
leaq -0x360(%rbp), %rax
movq %rax, -0x380(%rbp)
movq %rax, -0x378(%rbp)
movq %rax, -0x388(%rbp)
movq $0x0, -0x3a8(%rbp)
movq $0x0, -0x3a0(%rbp)
movq $0x0, -0x398(%rbp)
movq $0x0, -0x390(%rbp)
movl $0x0, -0x3b0(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x3b8(%rbp), %rsi
leaq -0x3b0(%rbp), %rdx
callq 0xc670
movq -0x3b8(%rbp), %rax
movq (%rax), %rdi
callq 0xac50
cmpq -0x370(%rbp), %rax
jne 0x2ba19
jmp 0x2ba38
leaq 0x16167(%rip), %rdi     # 0x41b87
leaq 0x15823(%rip), %rsi     # 0x4124a
movl $0x1d5, %edx            # imm = 0x1D5
leaq 0x16132(%rip), %rcx     # 0x41b65
callq 0x20c0
addq $0x3c0, %rsp            # imm = 0x3C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/next__test.cpp
// Function: test_killers()
void test_killers() {
    position pos;
    reset_pos(&pos);

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

    move h2h3 = to_move(PAWN,H2,H3);
    assert(is_in_move_list(h2h3,moves,endp));

    move g2g4 = to_move(PAWN,G2,G4);
    assert(is_in_move_list(g2g4,moves,endp));

    move_order_dto mo_dto;
    mo_dto.startp = mo_dto.currentp = mo_dto.endp = moves;
    mo_dto.pv_move = 0;
    mo_dto.hash_move = 0;
    mo_dto.killer1 = h2h3;
    mo_dto.killer2 = g2g4;
    mo_dto.next_stage = PVMOVE;

    move *m;
    next(&pos,&m,&mo_dto);
    assert(clear_score(*m) == h2h3);
    next(&pos,&m,&mo_dto);
    assert(clear_score(*m) == g2g4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3c0, %rsp            # imm = 0x3C0
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq -0x360(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0x368(%rbp)
movl $0x1, %edi
movl $0x37, %esi
movl $0x2f, %edx
callq 0xa830
movq %rax, -0x370(%rbp)
movq -0x370(%rbp), %rdi
leaq -0x360(%rbp), %rsi
movq -0x368(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x2bac3
jmp 0x2bac5
jmp 0x2bae4
leaq 0x160d4(%rip), %rdi     # 0x41ba0
leaq 0x15777(%rip), %rsi     # 0x4124a
movl $0x1e0, %edx            # imm = 0x1E0
leaq 0x160e2(%rip), %rcx     # 0x41bc1
callq 0x20c0
movl $0x1, %edi
movl $0x36, %esi
movl $0x26, %edx
callq 0xa830
movq %rax, -0x378(%rbp)
movq -0x378(%rbp), %rdi
leaq -0x360(%rbp), %rsi
movq -0x368(%rbp), %rdx
callq 0x14c10
testb $0x1, %al
jne 0x2bb1f
jmp 0x2bb21
jmp 0x2bb40
leaq 0x160ad(%rip), %rdi     # 0x41bd5
leaq 0x1571b(%rip), %rsi     # 0x4124a
movl $0x1e3, %edx            # imm = 0x1E3
leaq 0x16086(%rip), %rcx     # 0x41bc1
callq 0x20c0
leaq -0x360(%rbp), %rax
movq %rax, -0x388(%rbp)
movq %rax, -0x380(%rbp)
movq %rax, -0x390(%rbp)
movq $0x0, -0x3b0(%rbp)
movq $0x0, -0x3a8(%rbp)
movq -0x370(%rbp), %rax
movq %rax, -0x3a0(%rbp)
movq -0x378(%rbp), %rax
movq %rax, -0x398(%rbp)
movl $0x0, -0x3b8(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x3c0(%rbp), %rsi
leaq -0x3b8(%rbp), %rdx
callq 0xc670
movq -0x3c0(%rbp), %rax
movq (%rax), %rdi
callq 0xac50
cmpq -0x370(%rbp), %rax
jne 0x2bbcc
jmp 0x2bbeb
leaq 0x16023(%rip), %rdi     # 0x41bf6
leaq 0x15670(%rip), %rsi     # 0x4124a
movl $0x1ef, %edx            # imm = 0x1EF
leaq 0x15fdb(%rip), %rcx     # 0x41bc1
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq -0x3c0(%rbp), %rsi
leaq -0x3b8(%rbp), %rdx
callq 0xc670
movq -0x3c0(%rbp), %rax
movq (%rax), %rdi
callq 0xac50
cmpq -0x378(%rbp), %rax
jne 0x2bc1f
jmp 0x2bc3e
leaq 0x15fe8(%rip), %rdi     # 0x41c0e
leaq 0x1561d(%rip), %rsi     # 0x4124a
movl $0x1f1, %edx            # imm = 0x1F1
leaq 0x15f88(%rip), %rcx     # 0x41bc1
callq 0x20c0
addq $0x3c0, %rsp            # imm = 0x3C0
popq %rbp
retq
nopw (%rax,%rax)
// File: jswaff[P]prophet3/test/next__test.cpp
// Function: assert_all_moves_good(position*)
void assert_all_moves_good(position *pos) {
    move moves[200];
    move *endp = gen_legal_moves(&moves[0],pos,true,true);
    for (move* mp=moves;mp<endp;mp++) {
        assert(good_move(pos,*mp)==(*mp != BADMOVE));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x660, %rsp            # imm = 0x660
movq %rdi, -0x8(%rbp)
leaq -0x650(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xac70
movq %rax, -0x658(%rbp)
leaq -0x650(%rbp), %rax
movq %rax, -0x660(%rbp)
movq -0x660(%rbp), %rax
cmpq -0x658(%rbp), %rax
jae 0x2bd02
movq -0x8(%rbp), %rdi
movq -0x660(%rbp), %rax
movq (%rax), %rsi
callq 0xcef0
andb $0x1, %al
movzbl %al, %eax
movq -0x660(%rbp), %rcx
cmpq $0x0, (%rcx)
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x2bccd
jmp 0x2bcec
leaq 0x15f52(%rip), %rdi     # 0x41c26
leaq 0x1556f(%rip), %rsi     # 0x4124a
movl $0x1f8, %edx            # imm = 0x1F8
leaq 0x15f64(%rip), %rcx     # 0x41c4b
callq 0x20c0
jmp 0x2bcee
movq -0x660(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x660(%rbp)
jmp 0x2bc8b
addq $0x660, %rsp            # imm = 0x660
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/test/next__test.cpp
// Function: test_next()
void test_next() {
    test_best_at_top();
    test_place_move_on_top();
    test_pv();
    test_hash_next();
    test_pv_then_hash();
    test_pv_and_hash_same_move();
    test_promotions();
    test_pv_then_hash_then_captures();
    test_winning_caps_before_noncaps();
    test_caps_in_order_white();
    test_caps_in_order_black();
    test_ep_ordered_as_capture();
    test_killers();
    test_good_move();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x29210
callq 0x29490
callq 0x296e0
callq 0x297f0
callq 0x29900
callq 0x29a90
callq 0x29c90
callq 0x2a1b0
callq 0x2a630
callq 0x2b1e0
callq 0x2b550
callq 0x2b8c0
callq 0x2ba50
callq 0x2bd10
popq %rbp
retq
nopl (%rax)
// File: jswaff[P]prophet3/test/pos__test.cpp
// Function: test_add_piece()
void test_add_piece() {
    position pos;
    reset_pos(&pos);

    add_piece(&pos,PAWN,E4);
    assert(pos.piece[E4]==PAWN);

    add_piece(&pos,-PAWN,E5);
    assert(pos.piece[E5]==-PAWN);

    add_piece(&pos,KNIGHT,F3);
    assert(pos.piece[F3]==KNIGHT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq -0x1c8(%rbp), %rdi
movl $0x1, %esi
movl $0x24, %edx
callq 0xeb20
cmpl $0x1, -0x138(%rbp)
jne 0x2c898
jmp 0x2c8b7
leaq 0x158c0(%rip), %rdi     # 0x4215f
leaq 0x156b7(%rip), %rsi     # 0x41f5d
movl $0x47, %edx
leaq 0x158c1(%rip), %rcx     # 0x42173
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1c, %edx
callq 0xeb20
cmpl $-0x1, -0x158(%rbp)
jne 0x2c8d8
jmp 0x2c8f7
leaq 0x158aa(%rip), %rdi     # 0x42189
leaq 0x15677(%rip), %rsi     # 0x41f5d
movl $0x4a, %edx
leaq 0x15881(%rip), %rcx     # 0x42173
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
movl $0x2, %esi
movl $0x2d, %edx
callq 0xeb20
cmpl $0x2, -0x114(%rbp)
jne 0x2c918
jmp 0x2c937
leaq 0x1587f(%rip), %rdi     # 0x4219e
leaq 0x15637(%rip), %rsi     # 0x41f5d
movl $0x4d, %edx
leaq 0x15841(%rip), %rcx     # 0x42173
callq 0x20c0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
// File: jswaff[P]prophet3/test/pos__test.cpp
// Function: test_remove_piece()
void test_remove_piece() {
    position pos;
    reset_pos(&pos);

    remove_piece(&pos,E2);
    assert(pos.piece[E2]==NO_PIECE);

    remove_piece(&pos,H1);
    assert(pos.piece[H1]==NO_PIECE);

    remove_piece(&pos,E8);
    assert(pos.piece[E8]==NO_PIECE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq -0x1c8(%rbp), %rdi
movl $0x34, %esi
callq 0xee40
cmpl $0x0, -0xf8(%rbp)
jne 0x2c973
jmp 0x2c992
leaq 0x1583a(%rip), %rdi     # 0x421b4
leaq 0x155dc(%rip), %rsi     # 0x41f5d
movl $0x55, %edx
leaq 0x1583f(%rip), %rcx     # 0x421cc
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
movl $0x3f, %esi
callq 0xee40
cmpl $0x0, -0xcc(%rbp)
jne 0x2c9ae
jmp 0x2c9cd
leaq 0x15830(%rip), %rdi     # 0x421e5
leaq 0x155a1(%rip), %rsi     # 0x41f5d
movl $0x58, %edx
leaq 0x15804(%rip), %rcx     # 0x421cc
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
movl $0x4, %esi
callq 0xee40
cmpl $0x0, -0x1b8(%rbp)
jne 0x2c9e9
jmp 0x2ca08
leaq 0x1580d(%rip), %rdi     # 0x421fd
leaq 0x15566(%rip), %rsi     # 0x41f5d
movl $0x5b, %edx
leaq 0x157c9(%rip), %rcx     # 0x421cc
callq 0x20c0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/pos__test.cpp
// Function: test_is_empty_sq()
void test_is_empty_sq() {
    position pos;
    reset_pos(&pos);
    assert(is_empty_sq(&pos,D4));
    assert(!is_empty_sq(&pos,D8));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq -0x1c8(%rbp), %rdi
movl $0x23, %esi
callq 0xf9c0
testb $0x1, %al
jne 0x2ef1e
jmp 0x2ef20
jmp 0x2ef3f
leaq 0x13f12(%rip), %rdi     # 0x42e39
leaq 0x1302f(%rip), %rsi     # 0x41f5d
movl $0x1b5, %edx            # imm = 0x1B5
leaq 0x13f14(%rip), %rcx     # 0x42e4e
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
movl $0x3, %esi
callq 0xf9c0
xorb $-0x1, %al
testb $0x1, %al
jne 0x2ef58
jmp 0x2ef5a
jmp 0x2ef79
leaq 0x13f05(%rip), %rdi     # 0x42e66
leaq 0x12ff5(%rip), %rsi     # 0x41f5d
movl $0x1b6, %edx            # imm = 0x1B6
leaq 0x13eda(%rip), %rcx     # 0x42e4e
callq 0x20c0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/pos__test.cpp
// Function: test_flip_vertical()
void test_flip_vertical() {
    position pos;
    position save_pos;

    reset_pos(&pos);
    memcpy(&save_pos,&pos,sizeof(position));
    flip_board(&pos);
    flip_board(&pos);
    assert(equal_pos(&pos,&save_pos,true));

    ///
    set_pos(&pos,"7r/R6p/2K4P/5k1P/2p4n/5p2/8/8 w - - 0 1");
    memcpy(&save_pos,&pos,sizeof(position));
    flip_board(&pos);
    flip_board(&pos);
    assert(equal_pos(&pos,&save_pos,true));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x390, %rsp            # imm = 0x390
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq -0x390(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1c8, %edx            # imm = 0x1C8
callq 0x20f0
leaq -0x1c8(%rbp), %rdi
callq 0xfc80
leaq -0x1c8(%rbp), %rdi
callq 0xfc80
leaq -0x1c8(%rbp), %rdi
leaq -0x390(%rbp), %rsi
movl $0x1, %edx
callq 0xe490
testb $0x1, %al
jne 0x2f2f5
jmp 0x2f2f7
jmp 0x2f316
leaq 0xa412(%rip), %rdi      # 0x39710
leaq 0x12c58(%rip), %rsi     # 0x41f5d
movl $0x1de, %edx            # imm = 0x1DE
leaq 0x13c4c(%rip), %rcx     # 0x42f5d
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0xd1dd(%rip), %rsi      # 0x3c501
callq 0xf3e0
leaq -0x390(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1c8, %edx            # imm = 0x1C8
callq 0x20f0
leaq -0x1c8(%rbp), %rdi
callq 0xfc80
leaq -0x1c8(%rbp), %rdi
callq 0xfc80
leaq -0x1c8(%rbp), %rdi
leaq -0x390(%rbp), %rsi
movl $0x1, %edx
callq 0xe490
testb $0x1, %al
jne 0x2f377
jmp 0x2f379
jmp 0x2f398
leaq 0xa390(%rip), %rdi      # 0x39710
leaq 0x12bd6(%rip), %rsi     # 0x41f5d
movl $0x1e5, %edx            # imm = 0x1E5
leaq 0x13bca(%rip), %rcx     # 0x42f5d
callq 0x20c0
addq $0x390, %rsp            # imm = 0x390
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/pos__test.cpp
// Function: test_is_checkmate()
void test_is_checkmate() {
    position pos;

    // Fool's mate!
    set_pos(&pos,"rnb1kbnr/pppp1ppp/8/4p3/6Pq/5P2/PPPPP2P/RNBQKBNR w KQkq -");
    assert(is_checkmate(&pos));

    // Byrne vs Fischer
    set_pos(&pos,"1Q6/5pk1/2p3p1/1p2N2p/1b5P/1bn5/2r3P1/2K5 w - -");
    assert(is_checkmate(&pos));

    // Simple mate with rook
    set_pos(&pos,"3k2R1/8/3K4/8/8/8/8/8 b - -");
    assert(is_checkmate(&pos));

    // Starting position
    reset_pos(&pos);
    assert(!is_checkmate(&pos));

    set_pos(&pos,"8/8/8/6K1/8/1Q6/p7/k7 b - -");
    assert(!is_checkmate(&pos));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x1c8(%rbp), %rdi
leaq 0x13bae(%rip), %rsi     # 0x42f77
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0xfef0
testb $0x1, %al
jne 0x2f3e0
jmp 0x2f3e2
jmp 0x2f401
leaq 0x13c2e(%rip), %rdi     # 0x43017
leaq 0x12b6d(%rip), %rsi     # 0x41f5d
movl $0x1ed, %edx            # imm = 0x1ED
leaq 0x13bb5(%rip), %rcx     # 0x42fb1
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x13bbb(%rip), %rsi     # 0x42fca
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0xfef0
testb $0x1, %al
jne 0x2f426
jmp 0x2f428
jmp 0x2f447
leaq 0x13be8(%rip), %rdi     # 0x43017
leaq 0x12b27(%rip), %rsi     # 0x41f5d
movl $0x1f1, %edx            # imm = 0x1F1
leaq 0x13b6f(%rip), %rcx     # 0x42fb1
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x13ba5(%rip), %rsi     # 0x42ffa
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0xfef0
testb $0x1, %al
jne 0x2f46c
jmp 0x2f46e
jmp 0x2f48d
leaq 0x13ba2(%rip), %rdi     # 0x43017
leaq 0x12ae1(%rip), %rsi     # 0x41f5d
movl $0x1f5, %edx            # imm = 0x1F5
leaq 0x13b29(%rip), %rcx     # 0x42fb1
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq -0x1c8(%rbp), %rdi
callq 0xfef0
xorb $-0x1, %al
testb $0x1, %al
jne 0x2f4ad
jmp 0x2f4af
jmp 0x2f4ce
leaq 0x13b60(%rip), %rdi     # 0x43016
leaq 0x12aa0(%rip), %rsi     # 0x41f5d
movl $0x1f9, %edx            # imm = 0x1F9
leaq 0x13ae8(%rip), %rcx     # 0x42fb1
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x13b4e(%rip), %rsi     # 0x4302a
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0xfef0
xorb $-0x1, %al
testb $0x1, %al
jne 0x2f4f5
jmp 0x2f4f7
jmp 0x2f516
leaq 0x13b18(%rip), %rdi     # 0x43016
leaq 0x12a58(%rip), %rsi     # 0x41f5d
movl $0x1fc, %edx            # imm = 0x1FC
leaq 0x13aa0(%rip), %rcx     # 0x42fb1
callq 0x20c0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/pos__test.cpp
// Function: test_is_stalemate()
void test_is_stalemate() {
    position pos;

    // Burn vs Pilsbury, 1898
    set_pos(&pos,"5k2/5P2/5K2/8/8/8/8/8 b - -");
    assert(is_stalemate(&pos));

    set_pos(&pos,"kb6/8/1K6/8/8/8/8/8 b - - ");
    assert(!is_stalemate(&pos));
    set_pos(&pos,"kb5R/8/1K6/8/8/8/8/8 b - - ");
    assert(is_stalemate(&pos));

    set_pos(&pos,"8/8/8/8/8/2K5/1R6/k7 b - -");
    assert(is_stalemate(&pos));

    set_pos(&pos,"8/8/8/6K1/8/1Q6/p7/k7 b - -");
    assert(is_stalemate(&pos));

    set_pos(&pos,"rnb1kbnr/pppp1ppp/8/4p3/6Pq/5P2/PPPPP2P/RNBQKBNR w KQkq -");
    assert(!is_stalemate(&pos));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x1c8(%rbp), %rdi
leaq 0x13b0d(%rip), %rsi     # 0x43046
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0xff70
testb $0x1, %al
jne 0x2f550
jmp 0x2f552
jmp 0x2f571
leaq 0x13b3e(%rip), %rdi     # 0x43097
leaq 0x129fd(%rip), %rsi     # 0x41f5d
movl $0x204, %edx            # imm = 0x204
leaq 0x13af6(%rip), %rcx     # 0x43062
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x13afc(%rip), %rsi     # 0x4307b
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0xff70
xorb $-0x1, %al
testb $0x1, %al
jne 0x2f598
jmp 0x2f59a
jmp 0x2f5b9
leaq 0x13af5(%rip), %rdi     # 0x43096
leaq 0x129b5(%rip), %rsi     # 0x41f5d
movl $0x207, %edx            # imm = 0x207
leaq 0x13aae(%rip), %rcx     # 0x43062
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x13ae3(%rip), %rsi     # 0x430aa
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0xff70
testb $0x1, %al
jne 0x2f5de
jmp 0x2f5e0
jmp 0x2f5ff
leaq 0x13ab0(%rip), %rdi     # 0x43097
leaq 0x1296f(%rip), %rsi     # 0x41f5d
movl $0x209, %edx            # imm = 0x209
leaq 0x13a68(%rip), %rcx     # 0x43062
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x13ab9(%rip), %rsi     # 0x430c6
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0xff70
testb $0x1, %al
jne 0x2f624
jmp 0x2f626
jmp 0x2f645
leaq 0x13a6a(%rip), %rdi     # 0x43097
leaq 0x12929(%rip), %rsi     # 0x41f5d
movl $0x20c, %edx            # imm = 0x20C
leaq 0x13a22(%rip), %rcx     # 0x43062
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x139d7(%rip), %rsi     # 0x4302a
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0xff70
testb $0x1, %al
jne 0x2f66a
jmp 0x2f66c
jmp 0x2f68b
leaq 0x13a24(%rip), %rdi     # 0x43097
leaq 0x128e3(%rip), %rsi     # 0x41f5d
movl $0x20f, %edx            # imm = 0x20F
leaq 0x139dc(%rip), %rcx     # 0x43062
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x138de(%rip), %rsi     # 0x42f77
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0xff70
xorb $-0x1, %al
testb $0x1, %al
jne 0x2f6b2
jmp 0x2f6b4
jmp 0x2f6d3
leaq 0x139db(%rip), %rdi     # 0x43096
leaq 0x1289b(%rip), %rsi     # 0x41f5d
movl $0x212, %edx            # imm = 0x212
leaq 0x13994(%rip), %rcx     # 0x43062
callq 0x20c0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopl (%rax)
// File: jswaff[P]prophet3/test/pos__test.cpp
// Function: test_is_zugzwang()
void test_is_zugzwang() {
    position pos;
    reset_pos(&pos);
    assert(!is_zugzwang(&pos));

    // just kings
    set_pos(&pos,"7k/8/8/8/8/8/8/7K w - - ");
    assert(is_zugzwang(&pos));

    // single white bishop
    set_pos(&pos,"7k/8/8/B7/8/8/8/7K b - - ");
    assert(is_zugzwang(&pos));

    // white pawn black knight
    set_pos(&pos,"7k/8/8/n7/P7/8/8/7K b - - ");
    assert(is_zugzwang(&pos));

    // white rook black knight
    set_pos(&pos,"7k/8/8/n7/R7/8/8/7K b - - ");
    assert(!is_zugzwang(&pos));

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq -0x1c8(%rbp), %rdi
callq 0xfff0
xorb $-0x1, %al
testb $0x1, %al
jne 0x2f70b
jmp 0x2f70d
jmp 0x2f72c
leaq 0x139cd(%rip), %rdi     # 0x430e1
leaq 0x12842(%rip), %rsi     # 0x41f5d
movl $0x218, %edx            # imm = 0x218
leaq 0x139cd(%rip), %rcx     # 0x430f4
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x139d2(%rip), %rsi     # 0x4310c
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0xfff0
testb $0x1, %al
jne 0x2f751
jmp 0x2f753
jmp 0x2f772
leaq 0x13988(%rip), %rdi     # 0x430e2
leaq 0x127fc(%rip), %rsi     # 0x41f5d
movl $0x21c, %edx            # imm = 0x21C
leaq 0x13987(%rip), %rcx     # 0x430f4
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x139a5(%rip), %rsi     # 0x43125
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0xfff0
testb $0x1, %al
jne 0x2f797
jmp 0x2f799
jmp 0x2f7b8
leaq 0x13942(%rip), %rdi     # 0x430e2
leaq 0x127b6(%rip), %rsi     # 0x41f5d
movl $0x220, %edx            # imm = 0x220
leaq 0x13941(%rip), %rcx     # 0x430f4
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x13979(%rip), %rsi     # 0x4313f
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0xfff0
testb $0x1, %al
jne 0x2f7dd
jmp 0x2f7df
jmp 0x2f7fe
leaq 0x138fc(%rip), %rdi     # 0x430e2
leaq 0x12770(%rip), %rsi     # 0x41f5d
movl $0x224, %edx            # imm = 0x224
leaq 0x138fb(%rip), %rcx     # 0x430f4
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x1394e(%rip), %rsi     # 0x4315a
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0xfff0
xorb $-0x1, %al
testb $0x1, %al
jne 0x2f825
jmp 0x2f827
jmp 0x2f846
leaq 0x138b3(%rip), %rdi     # 0x430e1
leaq 0x12728(%rip), %rsi     # 0x41f5d
movl $0x228, %edx            # imm = 0x228
leaq 0x138b3(%rip), %rcx     # 0x430f4
callq 0x20c0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/pos__test.cpp
// Function: test_pos()
void test_pos() {
    test_pos_consistency();
    test_equal_pos();
    test_reset_pos();
    test_add_piece();
    test_remove_piece();
    test_set_pos();
    test_remove_rook_castling_availability();
    test_remove_castling_availability();
    test_is_empty_sq();
    test_is_enemy_and_friendly_occupied();
    test_flip_vertical();
    test_is_checkmate();
    test_is_stalemate();
    test_is_zugzwang();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2e090
callq 0x2ca20
callq 0x2c290
callq 0x2c860
callq 0x2c940
callq 0x2cec0
callq 0x2dbe0
callq 0x2d890
callq 0x2eef0
callq 0x2ef90
callq 0x2f290
callq 0x2f3b0
callq 0x2f520
callq 0x2f6e0
popq %rbp
retq
nopl (%rax)
// File: jswaff[P]prophet3/test/search__test.cpp
// Function: test_matein1()
void test_matein1() {
    position pos;
    set_pos(&pos,"4k3/8/3Q4/2B5/8/8/1K6/8 w - -");
    clear_hash_table(&htbl);

    move_line pv; pv.n=0;
    search_stats stats; stats.nodes=0; stats.last_pv.n=0;
    start_timer(10000);
    int32 score=search(&pos,&pv,-INF,INF,2,&stats,move_stack,gundos,false);
    assert(score==CHECKMATE-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb90, %rsp            # imm = 0xB90
leaq -0x1c8(%rbp), %rdi
leaq 0x1387c(%rip), %rsi     # 0x43175
callq 0xf3e0
leaq 0xd37ab(%rip), %rdi     # 0x1030b0
callq 0x88c0
movl $0x0, -0x4f0(%rbp)
movq $0x0, -0xb58(%rbp)
movl $0x0, -0xb48(%rbp)
movl $0x2710, %edi           # imm = 0x2710
callq 0x2f8b0
leaq -0x1c8(%rbp), %rdi
leaq -0x4f0(%rbp), %rsi
movl $0xfffcf2c0, %edx       # imm = 0xFFFCF2C0
movl $0x30d40, %ecx          # imm = 0x30D40
movl $0x2, %r8d
leaq -0xb70(%rbp), %r9
leaq 0x891621(%rip), %r10    # 0x8c0f80
leaq 0xa434a(%rip), %rax     # 0xd3cb0
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x10350
movl %eax, -0xb74(%rbp)
cmpl $0xfffe, -0xb74(%rbp)   # imm = 0xFFFE
jne 0x2f993
jmp 0x2f9b2
leaq 0x137f9(%rip), %rdi     # 0x43193
leaq 0x13805(%rip), %rsi     # 0x431a6
movl $0x1f, %edx
leaq 0x1380f(%rip), %rcx     # 0x431bc
callq 0x20c0
addq $0xb90, %rsp            # imm = 0xB90
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/test/search__test.cpp
// Function: test_matein1b()
void test_matein1b() {
    position pos;
    set_pos(&pos,"4K3/8/8/3n2q1/8/8/3k4/8 b - -");
    clear_hash_table(&htbl);

    move_line pv; pv.n=0;
    search_stats stats; stats.nodes=0; stats.last_pv.n=0;
    start_timer(10000);
    int32 score=search(&pos,&pv,-INF,INF,2,&stats,move_stack,gundos,false);
    assert(score==CHECKMATE-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb90, %rsp            # imm = 0xB90
leaq -0x1c8(%rbp), %rdi
leaq 0x137f7(%rip), %rsi     # 0x431d0
callq 0xf3e0
leaq 0xd36cb(%rip), %rdi     # 0x1030b0
callq 0x88c0
movl $0x0, -0x4f0(%rbp)
movq $0x0, -0xb58(%rbp)
movl $0x0, -0xb48(%rbp)
movl $0x2710, %edi           # imm = 0x2710
callq 0x2f8b0
leaq -0x1c8(%rbp), %rdi
leaq -0x4f0(%rbp), %rsi
movl $0xfffcf2c0, %edx       # imm = 0xFFFCF2C0
movl $0x30d40, %ecx          # imm = 0x30D40
movl $0x2, %r8d
leaq -0xb70(%rbp), %r9
leaq 0x891541(%rip), %r10    # 0x8c0f80
leaq 0xa426a(%rip), %rax     # 0xd3cb0
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x10350
movl %eax, -0xb74(%rbp)
cmpl $0xfffe, -0xb74(%rbp)   # imm = 0xFFFE
jne 0x2fa73
jmp 0x2fa92
leaq 0x13719(%rip), %rdi     # 0x43193
leaq 0x13725(%rip), %rsi     # 0x431a6
movl $0x2b, %edx
leaq 0x13761(%rip), %rcx     # 0x431ee
callq 0x20c0
addq $0xb90, %rsp            # imm = 0xB90
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/test/search__test.cpp
// Function: test_matein2()
void test_matein2() {
    position pos;
    set_pos(&pos,"r1bq2r1/b4pk1/p1pp1p2/1p2pP2/1P2P1PB/3P4/1PPQ2P1/R3K2R w - -");
    clear_hash_table(&htbl);

    move_line pv; pv.n=0;
    search_stats stats; stats.nodes=0; stats.last_pv.n=0;
    start_timer(10000);
    int32 score=search(&pos,&pv,-INF,INF,4,&stats,move_stack,gundos,false);
    assert(score==CHECKMATE-3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb90, %rsp            # imm = 0xB90
leaq -0x1c8(%rbp), %rdi
leaq 0x1374a(%rip), %rsi     # 0x43203
callq 0xf3e0
leaq 0xd35eb(%rip), %rdi     # 0x1030b0
callq 0x88c0
movl $0x0, -0x4f0(%rbp)
movq $0x0, -0xb58(%rbp)
movl $0x0, -0xb48(%rbp)
movl $0x2710, %edi           # imm = 0x2710
callq 0x2f8b0
leaq -0x1c8(%rbp), %rdi
leaq -0x4f0(%rbp), %rsi
movl $0xfffcf2c0, %edx       # imm = 0xFFFCF2C0
movl $0x30d40, %ecx          # imm = 0x30D40
movl $0x4, %r8d
leaq -0xb70(%rbp), %r9
leaq 0x891461(%rip), %r10    # 0x8c0f80
leaq 0xa418a(%rip), %rax     # 0xd3cb0
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x10350
movl %eax, -0xb74(%rbp)
cmpl $0xfffc, -0xb74(%rbp)   # imm = 0xFFFC
jne 0x2fb53
jmp 0x2fb72
leaq 0x136e6(%rip), %rdi     # 0x43240
leaq 0x13645(%rip), %rsi     # 0x431a6
movl $0x37, %edx
leaq 0x136e6(%rip), %rcx     # 0x43253
callq 0x20c0
addq $0xb90, %rsp            # imm = 0xB90
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/test/search__test.cpp
// Function: test_matein3()
void test_matein3() {
    position pos;
    set_pos(&pos,"r5rk/5p1p/5R2/4B3/8/8/7P/7K w - -");
    clear_hash_table(&htbl);

    move_line pv; pv.n=0;
    search_stats stats; stats.nodes=0; stats.last_pv.n=0;
    start_timer(10000);
    int32 score=search(&pos,&pv,-INF,INF,6,&stats,move_stack,gundos,false);
    assert(score==CHECKMATE-5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb90, %rsp            # imm = 0xB90
leaq -0x1c8(%rbp), %rdi
leaq 0x136ce(%rip), %rsi     # 0x43267
callq 0xf3e0
leaq 0xd350b(%rip), %rdi     # 0x1030b0
callq 0x88c0
movl $0x0, -0x4f0(%rbp)
movq $0x0, -0xb58(%rbp)
movl $0x0, -0xb48(%rbp)
movl $0x2710, %edi           # imm = 0x2710
callq 0x2f8b0
leaq -0x1c8(%rbp), %rdi
leaq -0x4f0(%rbp), %rsi
movl $0xfffcf2c0, %edx       # imm = 0xFFFCF2C0
movl $0x30d40, %ecx          # imm = 0x30D40
movl $0x6, %r8d
leaq -0xb70(%rbp), %r9
leaq 0x891381(%rip), %r10    # 0x8c0f80
leaq 0xa40aa(%rip), %rax     # 0xd3cb0
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x10350
movl %eax, -0xb74(%rbp)
cmpl $0xfffa, -0xb74(%rbp)   # imm = 0xFFFA
jne 0x2fc33
jmp 0x2fc52
leaq 0x1364f(%rip), %rdi     # 0x43289
leaq 0x13565(%rip), %rsi     # 0x431a6
movl $0x43, %edx
leaq 0x1364f(%rip), %rcx     # 0x4329c
callq 0x20c0
addq $0xb90, %rsp            # imm = 0xB90
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/test/search__test.cpp
// Function: test_stalemate()
void test_stalemate() {
    position pos;
    set_pos(&pos,"8/6p1/5p2/5k1K/7P/8/8/8 w - -");
    clear_hash_table(&htbl);

    move_line pv; pv.n=0;
    search_stats stats; stats.nodes=0; stats.last_pv.n=0;
    start_timer(10000);
    int32 score=search(&pos,&pv,-INF,INF,1,&stats,move_stack,gundos,false);
    assert(score==DRAWSCORE);
    assert(pv.n==0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb90, %rsp            # imm = 0xB90
leaq -0x1c8(%rbp), %rdi
leaq 0x13637(%rip), %rsi     # 0x432b0
callq 0xf3e0
leaq 0xd342b(%rip), %rdi     # 0x1030b0
callq 0x88c0
movl $0x0, -0x4f0(%rbp)
movq $0x0, -0xb58(%rbp)
movl $0x0, -0xb48(%rbp)
movl $0x2710, %edi           # imm = 0x2710
callq 0x2f8b0
leaq -0x1c8(%rbp), %rdi
leaq -0x4f0(%rbp), %rsi
movl $0xfffcf2c0, %edx       # imm = 0xFFFCF2C0
movl $0x30d40, %ecx          # imm = 0x30D40
movl $0x1, %r8d
leaq -0xb70(%rbp), %r9
leaq 0x8912a1(%rip), %r10    # 0x8c0f80
leaq 0xa3fca(%rip), %rax     # 0xd3cb0
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x10350
movl %eax, -0xb74(%rbp)
cmpl $0x0, -0xb74(%rbp)
jne 0x2fd10
jmp 0x2fd2f
leaq 0x135b7(%rip), %rdi     # 0x432ce
leaq 0x13488(%rip), %rsi     # 0x431a6
movl $0x4f, %edx
leaq 0x135b5(%rip), %rcx     # 0x432df
callq 0x20c0
cmpl $0x0, -0x4f0(%rbp)
jne 0x2fd3a
jmp 0x2fd59
leaq 0x135b4(%rip), %rdi     # 0x432f5
leaq 0x1345e(%rip), %rsi     # 0x431a6
movl $0x50, %edx
leaq 0x1358b(%rip), %rcx     # 0x432df
callq 0x20c0
addq $0xb90, %rsp            # imm = 0xB90
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/search__test.cpp
// Function: test_abort_search()
void test_abort_search() {
    position pos;
    reset_pos(&pos);
    clear_hash_table(&htbl);

    move_line pv; pv.n=0;
    search_stats stats; stats.nodes=0; stats.last_pv.n=0;
    start_timer(10000);

    set_abort_search(true);
    search(&pos,&pv,-INF,INF,1,&stats,move_stack,gundos,false);
    //assert(stats.nodes==21); // 1 + 20


    pv.n=0;
    stats.nodes=0;
    search(&pos,&pv,-INF,INF,3,&stats,move_stack,gundos,false);
    assert(stats.nodes==4); // 1 + 3 (down the left side of the tree)

    set_abort_search(false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb90, %rsp            # imm = 0xB90
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq 0xd3322(%rip), %rdi     # 0x1030b0
callq 0x88c0
movl $0x0, -0x4f0(%rbp)
movq $0x0, -0xb58(%rbp)
movl $0x0, -0xb48(%rbp)
movl $0x2710, %edi           # imm = 0x2710
callq 0x2f8b0
movl $0x1, %edi
callq 0x10200
leaq -0x1c8(%rbp), %rdi
leaq -0x4f0(%rbp), %rsi
movl $0xfffcf2c0, %edx       # imm = 0xFFFCF2C0
movl $0x30d40, %ecx          # imm = 0x30D40
movl $0x1, %r8d
leaq -0xb70(%rbp), %r9
leaq 0x89118e(%rip), %r10    # 0x8c0f80
leaq 0xa3eb7(%rip), %rax     # 0xd3cb0
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x10350
movl $0x0, -0x4f0(%rbp)
movq $0x0, -0xb58(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x4f0(%rbp), %rsi
movl $0xfffcf2c0, %edx       # imm = 0xFFFCF2C0
movl $0x30d40, %ecx          # imm = 0x30D40
movl $0x3, %r8d
leaq -0xb70(%rbp), %r9
leaq 0x89112d(%rip), %r10    # 0x8c0f80
leaq 0xa3e56(%rip), %rax     # 0xd3cb0
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x10350
cmpq $0x4, -0xb58(%rbp)
jne 0x2fe7f
jmp 0x2fe9e
leaq 0x13477(%rip), %rdi     # 0x432fd
leaq 0x13319(%rip), %rsi     # 0x431a6
movl $0x6c, %edx
leaq 0x13473(%rip), %rcx     # 0x4330c
callq 0x20c0
xorl %edi, %edi
callq 0x10200
addq $0xb90, %rsp            # imm = 0xB90
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/search__test.cpp
// Function: test_qsearch_does_not_expand_initial_position()
void test_qsearch_does_not_expand_initial_position() {
    position pos;
    reset_pos(&pos);

    clear_hash_table(&htbl);

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa00, %rsp            # imm = 0xA00
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq 0xd2a22(%rip), %rdi     # 0x1030b0
callq 0x88c0
movq $0x0, -0x830(%rbp)
movq $0x0, -0x828(%rbp)
movl $0x0, -0x820(%rbp)
movl $0x2710, %edi           # imm = 0x2710
callq 0x2f8b0
xorl %edi, %edi
callq 0x10200
leaq -0x9e0(%rbp), %r10
leaq -0x1c8(%rbp), %rdi
movl $0xfffcf2c0, %esi       # imm = 0xFFFCF2C0
movl $0x30d40, %edx          # imm = 0x30D40
xorl %r9d, %r9d
leaq -0x848(%rbp), %r11
leaq 0xa35c3(%rip), %rax     # 0xd3cb0
movl %r9d, %ecx
movl %r9d, %r8d
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x114e0
cmpq $0x0, -0x830(%rbp)
jne 0x30712
jmp 0x30731
leaq 0x12d95(%rip), %rdi     # 0x434ae
leaq 0x12a86(%rip), %rsi     # 0x431a6
movl $0xf0, %edx
leaq 0x12d91(%rip), %rcx     # 0x434bd
callq 0x20c0
cmpq $0x0, -0x828(%rbp)
jne 0x3073d
jmp 0x3075c
leaq 0x12dae(%rip), %rdi     # 0x434f2
leaq 0x12a5b(%rip), %rsi     # 0x431a6
movl $0xf1, %edx
leaq 0x12d66(%rip), %rcx     # 0x434bd
callq 0x20c0
addq $0xa00, %rsp            # imm = 0xA00
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/search__test.cpp
// Function: test_qsearch_standpat_raises_alpha()
void test_qsearch_standpat_raises_alpha() {
    position pos;
    reset_pos(&pos);

    clear_hash_table(&htbl);
    search_stats stats; stats.nodes=0; stats.qnodes=0; stats.last_pv.n=0;
    start_timer(10000);

    int32 score = eval(&pos,false);

    move moves[50];

    set_abort_search(false);
    int32 qscore = qsearch(&pos,-INF,INF,0,0,false,&stats,moves,gundos);
    assert(score==qscore);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa00, %rsp            # imm = 0xA00
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq 0xd2922(%rip), %rdi     # 0x1030b0
callq 0x88c0
movq $0x0, -0x830(%rbp)
movq $0x0, -0x828(%rbp)
movl $0x0, -0x820(%rbp)
movl $0x2710, %edi           # imm = 0x2710
callq 0x2f8b0
leaq -0x1c8(%rbp), %rdi
xorl %esi, %esi
callq 0x7630
movl %eax, -0x84c(%rbp)
xorl %edi, %edi
callq 0x10200
leaq -0x9e0(%rbp), %r10
leaq -0x1c8(%rbp), %rdi
movl $0xfffcf2c0, %esi       # imm = 0xFFFCF2C0
movl $0x30d40, %edx          # imm = 0x30D40
xorl %r9d, %r9d
leaq -0x848(%rbp), %r11
leaq 0xa34af(%rip), %rax     # 0xd3cb0
movl %r9d, %ecx
movl %r9d, %r8d
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x114e0
movl %eax, -0x9e4(%rbp)
movl -0x84c(%rbp), %eax
cmpl -0x9e4(%rbp), %eax
jne 0x30830
jmp 0x3084f
leaq 0x12ccb(%rip), %rdi     # 0x43502
leaq 0x12968(%rip), %rsi     # 0x431a6
movl $0x102, %edx            # imm = 0x102
leaq 0x12cc6(%rip), %rcx     # 0x43510
callq 0x20c0
addq $0xa00, %rsp            # imm = 0xA00
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/test/search__test.cpp
// Function: test_qsearch_standpat_does_not_raise_alpha()
void test_qsearch_standpat_does_not_raise_alpha() {
    position pos;
    reset_pos(&pos);

    clear_hash_table(&htbl);

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

    set_abort_search(false);
    int32 qscore = qsearch(&pos,queen_val,INF,0,0,false,&stats,moves,gundos);
    assert(queen_val==qscore);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa00, %rsp            # imm = 0xA00
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq 0xd2832(%rip), %rdi     # 0x1030b0
callq 0x88c0
movq $0x0, -0x830(%rbp)
movq $0x0, -0x828(%rbp)
movl $0x0, -0x820(%rbp)
movl $0x2710, %edi           # imm = 0x2710
callq 0x2f8b0
xorl %edi, %edi
callq 0x10200
leaq -0x9e0(%rbp), %r10
leaq -0x1c8(%rbp), %rdi
movl $0x384, %esi            # imm = 0x384
movl $0x30d40, %edx          # imm = 0x30D40
xorl %r9d, %r9d
leaq -0x848(%rbp), %r11
leaq 0xa33d3(%rip), %rax     # 0xd3cb0
movl %r9d, %ecx
movl %r9d, %r8d
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x114e0
movl %eax, -0x9e4(%rbp)
movl $0x384, %eax            # imm = 0x384
cmpl -0x9e4(%rbp), %eax
jne 0x3090b
jmp 0x3092a
leaq 0x12c28(%rip), %rdi     # 0x4353a
leaq 0x1288d(%rip), %rsi     # 0x431a6
movl $0x111, %edx            # imm = 0x111
leaq 0x12c27(%rip), %rcx     # 0x4354c
callq 0x20c0
addq $0xa00, %rsp            # imm = 0xA00
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/search__test.cpp
// Function: test_qsearch_expands_just_captures()
void test_qsearch_expands_just_captures() {
    position pos;
    set_pos(&pos,"7k/8/8/3b4/8/8/6P1/K7 b - -");

    clear_hash_table(&htbl);

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa00, %rsp            # imm = 0xA00
leaq -0x1c8(%rbp), %rdi
leaq 0x12c25(%rip), %rsi     # 0x4357e
callq 0xf3e0
leaq 0xd274b(%rip), %rdi     # 0x1030b0
callq 0x88c0
movq $0x0, -0x830(%rbp)
movq $0x0, -0x828(%rbp)
movl $0x0, -0x820(%rbp)
movl $0x2710, %edi           # imm = 0x2710
callq 0x2f8b0
xorl %edi, %edi
callq 0x10200
leaq -0x9e0(%rbp), %r10
leaq -0x1c8(%rbp), %rdi
movl $0xfffcf2c0, %esi       # imm = 0xFFFCF2C0
movl $0x30d40, %edx          # imm = 0x30D40
xorl %r9d, %r9d
leaq -0x848(%rbp), %r11
leaq 0xa32ec(%rip), %rax     # 0xd3cb0
movl %r9d, %ecx
movl %r9d, %r8d
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x114e0
cmpq $0x0, -0x830(%rbp)
jne 0x309e9
jmp 0x30a08
leaq 0x12abe(%rip), %rdi     # 0x434ae
leaq 0x127af(%rip), %rsi     # 0x431a6
movl $0x121, %edx            # imm = 0x121
leaq 0x12b97(%rip), %rcx     # 0x4359a
callq 0x20c0
cmpq $0x1, -0x828(%rbp)
jne 0x30a14
jmp 0x30a33
leaq 0x12ba9(%rip), %rdi     # 0x435c4
leaq 0x12784(%rip), %rsi     # 0x431a6
movl $0x122, %edx            # imm = 0x122
leaq 0x12b6c(%rip), %rcx     # 0x4359a
callq 0x20c0
addq $0xa00, %rsp            # imm = 0xA00
popq %rbp
retq
nopl (%rax)
// File: jswaff[P]prophet3/test/search__test.cpp
// Function: test_qsearch_does_expand_promotions()
void test_qsearch_does_expand_promotions() {
    position pos;
    set_pos(&pos,"8/P6k/8/8/8/8/7K/8 w - -");

    clear_hash_table(&htbl);

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa00, %rsp            # imm = 0xA00
leaq -0x1c8(%rbp), %rdi
leaq 0x12b7b(%rip), %rsi     # 0x435d4
callq 0xf3e0
leaq 0xd264b(%rip), %rdi     # 0x1030b0
callq 0x88c0
movq $0x0, -0x830(%rbp)
movq $0x0, -0x828(%rbp)
movl $0x0, -0x820(%rbp)
movl $0x2710, %edi           # imm = 0x2710
callq 0x2f8b0
xorl %edi, %edi
callq 0x10200
leaq -0x9e0(%rbp), %r10
leaq -0x1c8(%rbp), %rdi
movl $0xfffcf2c0, %esi       # imm = 0xFFFCF2C0
movl $0x30d40, %edx          # imm = 0x30D40
xorl %r9d, %r9d
leaq -0x848(%rbp), %r11
leaq 0xa31ec(%rip), %rax     # 0xd3cb0
movl %r9d, %ecx
movl %r9d, %r8d
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x114e0
cmpq $0x0, -0x830(%rbp)
jne 0x30ae9
jmp 0x30b08
leaq 0x129be(%rip), %rdi     # 0x434ae
leaq 0x126af(%rip), %rsi     # 0x431a6
movl $0x132, %edx            # imm = 0x132
leaq 0x12aea(%rip), %rcx     # 0x435ed
callq 0x20c0
cmpq $0x4, -0x828(%rbp)
jne 0x30b14
jmp 0x30b33
leaq 0x12afd(%rip), %rdi     # 0x43618
leaq 0x12684(%rip), %rsi     # 0x431a6
movl $0x133, %edx            # imm = 0x133
leaq 0x12abf(%rip), %rcx     # 0x435ed
callq 0x20c0
addq $0xa00, %rsp            # imm = 0xA00
popq %rbp
retq
nopl (%rax)
// File: jswaff[P]prophet3/test/search__test.cpp
// Function: test_qsearch_beta_cutoff()
void test_qsearch_beta_cutoff() {
    position pos;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa00, %rsp            # imm = 0xA00
leaq -0x1c8(%rbp), %rdi
leaq 0x12a7b(%rip), %rsi     # 0x435d4
callq 0xf3e0
movq $0x0, -0x830(%rbp)
movq $0x0, -0x828(%rbp)
movl $0x0, -0x820(%rbp)
movl $0x2710, %edi           # imm = 0x2710
callq 0x2f8b0
leaq -0x1c8(%rbp), %rdi
xorl %esi, %esi
callq 0x7630
movl %eax, -0x9e4(%rbp)
movl -0x9e4(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl $0x384, %eax            # imm = 0x384
jge 0x30bb2
jmp 0x30bd1
leaq 0x12a6f(%rip), %rdi     # 0x43628
leaq 0x125e6(%rip), %rsi     # 0x431a6
movl $0x140, %edx            # imm = 0x140
leaq 0x12a73(%rip), %rcx     # 0x4363f
callq 0x20c0
xorl %edi, %edi
callq 0x10200
leaq -0x9e0(%rbp), %r10
leaq -0x1c8(%rbp), %rdi
movl $0xfffcf2c0, %esi       # imm = 0xFFFCF2C0
movl $0xfffffc7c, %edx       # imm = 0xFFFFFC7C
xorl %r9d, %r9d
leaq -0x848(%rbp), %r11
leaq 0xa30af(%rip), %rax     # 0xd3cb0
movl %r9d, %ecx
movl %r9d, %r8d
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x114e0
cmpq $0x0, -0x830(%rbp)
jne 0x30c26
jmp 0x30c45
leaq 0x12881(%rip), %rdi     # 0x434ae
leaq 0x12572(%rip), %rsi     # 0x431a6
movl $0x145, %edx            # imm = 0x145
leaq 0x129ff(%rip), %rcx     # 0x4363f
callq 0x20c0
cmpq $0x0, -0x828(%rbp)
jne 0x30c51
jmp 0x30c70
leaq 0x1289a(%rip), %rdi     # 0x434f2
leaq 0x12547(%rip), %rsi     # 0x431a6
movl $0x146, %edx            # imm = 0x146
leaq 0x129d4(%rip), %rcx     # 0x4363f
callq 0x20c0
addq $0xa00, %rsp            # imm = 0xA00
popq %rbp
retq
nopl (%rax)
// File: jswaff[P]prophet3/test/see__test.cpp
// Function: test_queen_takes_undefended_pawn()
void test_queen_takes_undefended_pawn() {
    position pos;
    set_pos(&pos,"7k/8/1p6/8/8/1Q6/8/7K w - -");

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x12966(%rip), %rsi     # 0x4365f
callq 0xf3e0
movl $0x5, %edi
movl $0x29, %esi
movl $0x11, %edx
movl $0x1, %ecx
callq 0xa890
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x14a90
testb $0x1, %al
jne 0x30d37
jmp 0x30d39
jmp 0x30d58
leaq 0x1293b(%rip), %rdi     # 0x4367b
leaq 0x1294b(%rip), %rsi     # 0x43692
movl $0x15, %edx
leaq 0x12952(%rip), %rcx     # 0x436a5
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xa2f43(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x11f10
movl %eax, -0x1d4(%rbp)
cmpl $0x64, -0x1d4(%rbp)
jne 0x30d96
jmp 0x30db5
leaq 0x12930(%rip), %rdi     # 0x436cd
leaq 0x128ee(%rip), %rsi     # 0x43692
movl $0x19, %edx
leaq 0x128f5(%rip), %rcx     # 0x436a5
callq 0x20c0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/see__test.cpp
// Function: test_queen_takes_defended_pawn()
void test_queen_takes_defended_pawn() {
    position pos;
    set_pos(&pos,"7k/p7/1p6/8/8/1Q6/8/7K w - -");

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x12904(%rip), %rsi     # 0x436dd
callq 0xf3e0
movl $0x5, %edi
movl $0x29, %esi
movl $0x11, %edx
movl $0x1, %ecx
callq 0xa890
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x14a90
testb $0x1, %al
jne 0x30e17
jmp 0x30e19
jmp 0x30e38
leaq 0x1285b(%rip), %rdi     # 0x4367b
leaq 0x1286b(%rip), %rsi     # 0x43692
movl $0x21, %edx
leaq 0x128c7(%rip), %rcx     # 0x436fa
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xa2e63(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x11f10
movl %eax, -0x1d4(%rbp)
cmpl $0xfffffce0, -0x1d4(%rbp) # imm = 0xFFFFFCE0
jne 0x30e79
jmp 0x30e98
leaq 0x128a0(%rip), %rdi     # 0x43720
leaq 0x1280b(%rip), %rsi     # 0x43692
movl $0x25, %edx
leaq 0x12867(%rip), %rcx     # 0x436fa
callq 0x20c0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/see__test.cpp
// Function: test_rook_takes_undefended_pawn()
void test_rook_takes_undefended_pawn() {
    position pos;
    set_pos(&pos,"1k1r4/1pp4p/p7/4p3/8/P5P1/1PP4P/2K1R3 w - -");

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x12871(%rip), %rsi     # 0x4373a
callq 0xf3e0
movl $0x4, %edi
movl $0x3c, %esi
movl $0x1c, %edx
movl $0x1, %ecx
callq 0xa890
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x14a90
testb $0x1, %al
jne 0x30f07
jmp 0x30f09
jmp 0x30f28
leaq 0x1276b(%rip), %rdi     # 0x4367b
leaq 0x1277b(%rip), %rsi     # 0x43692
movl $0x2d, %edx
leaq 0x12843(%rip), %rcx     # 0x43766
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xa2d73(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x11f10
movl %eax, -0x1d4(%rbp)
cmpl $0x64, -0x1d4(%rbp)
jne 0x30f66
jmp 0x30f85
leaq 0x12760(%rip), %rdi     # 0x436cd
leaq 0x1271e(%rip), %rsi     # 0x43692
movl $0x31, %edx
leaq 0x127e6(%rip), %rcx     # 0x43766
callq 0x20c0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nop