LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jswaff[P]prophet3/test/see__test.cpp
// Function: test_with_xrays()
void test_with_xrays() {
    position pos;
    set_pos(&pos,"1k1r3q/1ppn3p/p4b2/4p3/8/P2N2P1/1PP1R1BP/2K1Q3 w - -");

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x9232(%rip), %rsi      # 0x3a1db
callq 0xf3e0
movl $0x2, %edi
movl $0x2b, %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 0x30fe7
jmp 0x30fe9
jmp 0x31008
leaq 0x1268b(%rip), %rdi     # 0x4367b
leaq 0x1269b(%rip), %rsi     # 0x43692
movl $0x39, %edx
leaq 0x1278a(%rip), %rcx     # 0x4378d
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xa2c93(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x11f10
movl %eax, -0x1d4(%rbp)
cmpl $0xffffff38, -0x1d4(%rbp) # imm = 0xFFFFFF38
jne 0x31049
jmp 0x31068
leaq 0x12754(%rip), %rdi     # 0x437a4
leaq 0x1263b(%rip), %rsi     # 0x43692
movl $0x3d, %edx
leaq 0x1272a(%rip), %rcx     # 0x4378d
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_xrays()
void test_rook_xrays() {
    position pos;
    set_pos(&pos,"3kr3/8/4p3/8/8/4R3/4R3/4K3 w - -");

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x12726(%rip), %rsi     # 0x437bf
callq 0xf3e0
movl $0x4, %edi
movl $0x2c, %esi
movl $0x14, %edx
movl $0x1, %ecx
callq 0xa890
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x14a90
testb $0x1, %al
jne 0x310d7
jmp 0x310d9
jmp 0x310f8
leaq 0x1259b(%rip), %rdi     # 0x4367b
leaq 0x125ab(%rip), %rsi     # 0x43692
movl $0x45, %edx
leaq 0x126ed(%rip), %rcx     # 0x437e0
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xa2ba3(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x11f10
movl %eax, -0x1d4(%rbp)
cmpl $0x64, -0x1d4(%rbp)
jne 0x31136
jmp 0x31155
leaq 0x12590(%rip), %rdi     # 0x436cd
leaq 0x1254e(%rip), %rsi     # 0x43692
movl $0x49, %edx
leaq 0x12690(%rip), %rcx     # 0x437e0
callq 0x20c0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/see__test.cpp
// Function: test_knight_takes_defended_pawn_as_white()
void test_knight_takes_defended_pawn_as_white() {
    position pos;
    set_pos(&pos,"k7/8/5n2/3p4/8/2N2B2/8/K7 w - -");

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x1267e(%rip), %rsi     # 0x437f7
callq 0xf3e0
movl $0x2, %edi
movl $0x2a, %esi
movl $0x1b, %edx
movl $0x1, %ecx
callq 0xa890
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x14a90
testb $0x1, %al
jne 0x311b7
jmp 0x311b9
jmp 0x311d8
leaq 0x124bb(%rip), %rdi     # 0x4367b
leaq 0x124cb(%rip), %rsi     # 0x43692
movl $0x51, %edx
leaq 0x12644(%rip), %rcx     # 0x43817
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xa2ac3(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x11f10
movl %eax, -0x1d4(%rbp)
cmpl $0x64, -0x1d4(%rbp)
jne 0x31216
jmp 0x31235
leaq 0x124b0(%rip), %rdi     # 0x436cd
leaq 0x1246e(%rip), %rsi     # 0x43692
movl $0x55, %edx
leaq 0x125e7(%rip), %rcx     # 0x43817
callq 0x20c0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/see__test.cpp
// Function: test_knight_takes_defended_pawn_as_black()
void test_knight_takes_defended_pawn_as_black() {
    position pos;
    set_pos(&pos,"K7/8/5N2/3P4/8/2n2b2/8/k7 b - -");

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x125ee(%rip), %rsi     # 0x43847
callq 0xf3e0
movl $0x2, %edi
movl $0x2a, %esi
movl $0x1b, %edx
movl $0x1, %ecx
callq 0xa890
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x14a90
testb $0x1, %al
jne 0x31297
jmp 0x31299
jmp 0x312b8
leaq 0x123db(%rip), %rdi     # 0x4367b
leaq 0x123eb(%rip), %rsi     # 0x43692
movl $0x5d, %edx
leaq 0x125b4(%rip), %rcx     # 0x43867
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xa29e3(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x11f10
movl %eax, -0x1d4(%rbp)
cmpl $0x64, -0x1d4(%rbp)
jne 0x312f6
jmp 0x31315
leaq 0x123d0(%rip), %rdi     # 0x436cd
leaq 0x1238e(%rip), %rsi     # 0x43692
movl $0x61, %edx
leaq 0x12557(%rip), %rcx     # 0x43867
callq 0x20c0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/see__test.cpp
// Function: test_crazy_rooks()
void test_crazy_rooks() {
    position pos;
    set_pos(&pos,"2K5/8/8/3pRrRr/8/8/8/2k5 w - -");

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x1255e(%rip), %rsi     # 0x43897
callq 0xf3e0
movl $0x4, %edi
movl $0x1c, %esi
movl $0x1b, %edx
movl $0x1, %ecx
callq 0xa890
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x14a90
testb $0x1, %al
jne 0x31377
jmp 0x31379
jmp 0x31398
leaq 0x122fb(%rip), %rdi     # 0x4367b
leaq 0x1230b(%rip), %rsi     # 0x43692
movl $0x69, %edx
leaq 0x12523(%rip), %rcx     # 0x438b6
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xa2903(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x11f10
movl %eax, -0x1d4(%rbp)
cmpl $0xfffffe70, -0x1d4(%rbp) # imm = 0xFFFFFE70
jne 0x313d9
jmp 0x313f8
leaq 0x124ee(%rip), %rdi     # 0x438ce
leaq 0x122ab(%rip), %rsi     # 0x43692
movl $0x6d, %edx
leaq 0x124c3(%rip), %rcx     # 0x438b6
callq 0x20c0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/see__test.cpp
// Function: test_crazy_rooks2()
void test_crazy_rooks2() {
    position pos;
    set_pos(&pos,"2K5/8/8/3pRrR1/8/8/8/2k5 w - -");
    move mv = to_capture(ROOK,E5,D5,PAWN);
    assert(is_legal_move(mv,&pos));
    apply_move(&pos,mv,gundos);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x124be(%rip), %rsi     # 0x438e7
callq 0xf3e0
movl $0x4, %edi
movl $0x1c, %esi
movl $0x1b, %edx
movl $0x1, %ecx
callq 0xa890
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x14a90
testb $0x1, %al
jne 0x31467
jmp 0x31469
jmp 0x31488
leaq 0x1220b(%rip), %rdi     # 0x4367b
leaq 0x1221b(%rip), %rsi     # 0x43692
movl $0x74, %edx
leaq 0x12483(%rip), %rcx     # 0x43906
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xa2813(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x11f10
movl %eax, -0x1d4(%rbp)
cmpl $0x64, -0x1d4(%rbp)
jne 0x314c6
jmp 0x314e5
leaq 0x12200(%rip), %rdi     # 0x436cd
leaq 0x121be(%rip), %rsi     # 0x43692
movl $0x78, %edx
leaq 0x12426(%rip), %rcx     # 0x43906
callq 0x20c0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/see__test.cpp
// Function: test_knight_takes_defended_pawn()
void test_knight_takes_defended_pawn() {
    position pos;
    set_pos(&pos,"1K1k4/8/5n2/3p4/8/1BN5/8/8 w - -");

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x12416(%rip), %rsi     # 0x4391f
callq 0xf3e0
movl $0x2, %edi
movl $0x2a, %esi
movl $0x1b, %edx
movl $0x1, %ecx
callq 0xa890
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x14a90
testb $0x1, %al
jne 0x31547
jmp 0x31549
jmp 0x31568
leaq 0x1212b(%rip), %rdi     # 0x4367b
leaq 0x1213b(%rip), %rsi     # 0x43692
movl $0x80, %edx
leaq 0x123dd(%rip), %rcx     # 0x43940
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xa2733(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x11f10
movl %eax, -0x1d4(%rbp)
cmpl $0x64, -0x1d4(%rbp)
jne 0x315a6
jmp 0x315c5
leaq 0x12120(%rip), %rdi     # 0x436cd
leaq 0x120de(%rip), %rsi     # 0x43692
movl $0x84, %edx
leaq 0x12380(%rip), %rcx     # 0x43940
callq 0x20c0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/see__test.cpp
// Function: test_bishop_takes_defended_pawn()
void test_bishop_takes_defended_pawn() {
    position pos;
    set_pos(&pos,"1K1k4/8/5n2/3p4/8/1BN5/8/8 w - -");

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x12336(%rip), %rsi     # 0x4391f
callq 0xf3e0
movl $0x3, %edi
movl $0x29, %esi
movl $0x1b, %edx
movl $0x1, %ecx
callq 0xa890
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x14a90
testb $0x1, %al
jne 0x31627
jmp 0x31629
jmp 0x31648
leaq 0x1204b(%rip), %rdi     # 0x4367b
leaq 0x1205b(%rip), %rsi     # 0x43692
movl $0x8c, %edx
leaq 0x12324(%rip), %rcx     # 0x43967
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xa2653(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x11f10
movl %eax, -0x1d4(%rbp)
cmpl $0x50, -0x1d4(%rbp)
jne 0x31686
jmp 0x316a5
leaq 0x12301(%rip), %rdi     # 0x4398e
leaq 0x11ffe(%rip), %rsi     # 0x43692
movl $0x90, %edx
leaq 0x122c7(%rip), %rcx     # 0x43967
callq 0x20c0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/see__test.cpp
// Function: test_knight_takes_defended_pawn_with_crazy_bishops()
void test_knight_takes_defended_pawn_with_crazy_bishops() {
    position pos;
    set_pos(&pos,"1K1k4/8/5n2/3p4/8/2N2B2/6b1/7b w - -");

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x122eb(%rip), %rsi     # 0x439b4
callq 0xf3e0
movl $0x2, %edi
movl $0x2a, %esi
movl $0x1b, %edx
movl $0x1, %ecx
callq 0xa890
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x14a90
testb $0x1, %al
jne 0x31707
jmp 0x31709
jmp 0x31728
leaq 0x11f6b(%rip), %rdi     # 0x4367b
leaq 0x11f7b(%rip), %rsi     # 0x43692
movl $0x98, %edx
leaq 0x122b6(%rip), %rcx     # 0x439d9
callq 0x20c0
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xa2573(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x11f10
movl %eax, -0x1d4(%rbp)
cmpl $0xffffff38, -0x1d4(%rbp) # imm = 0xFFFFFF38
jne 0x31769
jmp 0x31788
leaq 0x12034(%rip), %rdi     # 0x437a4
leaq 0x11f1b(%rip), %rsi     # 0x43692
movl $0x9c, %edx
leaq 0x12256(%rip), %rcx     # 0x439d9
callq 0x20c0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/see__test.cpp
// Function: test_case_see(char const*, char const*, int)
void test_case_see(const char* fen,const char* str_mv,int32 score) {
    position pos;
    set_pos(&pos,fen);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x1e0(%rbp), %rdi
callq 0xf3e0
movq -0x10(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x14400
movq %rax, -0x1e8(%rbp)
movq -0x1e8(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x14a90
testb $0x1, %al
jne 0x317f6
jmp 0x317f8
jmp 0x31817
leaq 0x11e7c(%rip), %rdi     # 0x4367b
leaq 0x11e8c(%rip), %rsi     # 0x43692
movl $0xa4, %edx
leaq 0x12201(%rip), %rcx     # 0x43a13
callq 0x20c0
movq -0x1e8(%rbp), %rdi
callq 0xab50
testb $0x1, %al
jne 0x31829
jmp 0x31836
movl $0x1, %eax
movl %eax, -0x1f4(%rbp)
jmp 0x31851
movq -0x1e8(%rbp), %rdi
callq 0xaaa0
movl %eax, %eax
movl -0x1e0(%rbp,%rax,4), %eax
movl %eax, -0x1f4(%rbp)
movl -0x1f4(%rbp), %eax
movl %eax, -0x1ec(%rbp)
cmpl $0x0, -0x1ec(%rbp)
jge 0x31874
xorl %eax, %eax
subl -0x1ec(%rbp), %eax
movl %eax, -0x1ec(%rbp)
movl -0x1ec(%rbp), %eax
movl %eax, -0x1f8(%rbp)
movq -0x1e8(%rbp), %rdi
callq 0xab00
movl %eax, %ecx
movl -0x1f8(%rbp), %eax
cmpl %ecx, %eax
jne 0x3189a
jmp 0x318b9
leaq 0x121a8(%rip), %rdi     # 0x43a49
leaq 0x11dea(%rip), %rsi     # 0x43692
movl $0xa7, %edx
leaq 0x1215f(%rip), %rcx     # 0x43a13
callq 0x20c0
movq -0x1e8(%rbp), %rsi
leaq -0x1e0(%rbp), %rdi
leaq 0xa23e2(%rip), %rdx     # 0xd3cb0
callq 0x3620
movq -0x1e8(%rbp), %rsi
leaq -0x1e0(%rbp), %rdi
callq 0x11f10
movl %eax, -0x1f0(%rbp)
movl -0x1f0(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x318f9
jmp 0x31918
leaq 0x12170(%rip), %rdi     # 0x43a70
leaq 0x11d8b(%rip), %rsi     # 0x43692
movl $0xaa, %edx
leaq 0x12100(%rip), %rcx     # 0x43a13
callq 0x20c0
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/square__test.cpp
// Function: test_get_dir()
void test_get_dir() {
    assert(direction_tbl[E4][E6]==NORTH);
    assert(direction_tbl[D6][D1]==SOUTH);
    assert(direction_tbl[H1][A1]==WEST);
    assert(direction_tbl[A7][G7]==EAST);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9dfc5(%rip), %rax     # 0xcfae0
cmpl $0x0, 0x2450(%rax)
jne 0x31b26
jmp 0x31b45
leaq 0x12348(%rip), %rdi     # 0x43e75
leaq 0x1235e(%rip), %rsi     # 0x43e92
movl $0xd, %edx
leaq 0x12368(%rip), %rcx     # 0x43ea8
callq 0x20c0
leaq 0x9df94(%rip), %rax     # 0xcfae0
cmpl $0x4, 0x13ec(%rax)
jne 0x31b57
jmp 0x31b76
leaq 0x1235e(%rip), %rdi     # 0x43ebc
leaq 0x1232d(%rip), %rsi     # 0x43e92
movl $0xe, %edx
leaq 0x12337(%rip), %rcx     # 0x43ea8
callq 0x20c0
leaq 0x9df63(%rip), %rax     # 0xcfae0
cmpl $0x6, 0x3fe0(%rax)
jne 0x31b88
jmp 0x31ba7
leaq 0x1234a(%rip), %rdi     # 0x43ed9
leaq 0x122fc(%rip), %rsi     # 0x43e92
movl $0xf, %edx
leaq 0x12306(%rip), %rcx     # 0x43ea8
callq 0x20c0
leaq 0x9df32(%rip), %rax     # 0xcfae0
cmpl $0x2, 0x838(%rax)
jne 0x31bb9
jmp 0x31bd8
leaq 0x12335(%rip), %rdi     # 0x43ef5
leaq 0x122cb(%rip), %rsi     # 0x43e92
movl $0x10, %edx
leaq 0x122d5(%rip), %rcx     # 0x43ea8
callq 0x20c0
leaq 0x9df01(%rip), %rax     # 0xcfae0
cmpl $0x1, 0x2950(%rax)
jne 0x31bea
jmp 0x31c09
leaq 0x12320(%rip), %rdi     # 0x43f11
leaq 0x1229a(%rip), %rsi     # 0x43e92
movl $0x12, %edx
leaq 0x122a4(%rip), %rcx     # 0x43ea8
callq 0x20c0
leaq 0x9ded0(%rip), %rax     # 0xcfae0
cmpl $0x3, 0x18f0(%rax)
jne 0x31c1b
jmp 0x31c3a
leaq 0x12310(%rip), %rdi     # 0x43f32
leaq 0x12269(%rip), %rsi     # 0x43e92
movl $0x13, %edx
leaq 0x12273(%rip), %rcx     # 0x43ea8
callq 0x20c0
leaq 0x9de9f(%rip), %rax     # 0xcfae0
cmpl $0x5, 0x2fd8(%rax)
jne 0x31c4c
jmp 0x31c6b
leaq 0x12300(%rip), %rdi     # 0x43f53
leaq 0x12238(%rip), %rsi     # 0x43e92
movl $0x14, %edx
leaq 0x12242(%rip), %rcx     # 0x43ea8
callq 0x20c0
leaq 0x9de6e(%rip), %rax     # 0xcfae0
cmpl $0x7, 0x1e30(%rax)
jne 0x31c7d
jmp 0x31c9c
leaq 0x122f0(%rip), %rdi     # 0x43f74
leaq 0x12207(%rip), %rsi     # 0x43e92
movl $0x15, %edx
leaq 0x12211(%rip), %rcx     # 0x43ea8
callq 0x20c0
leaq 0x9de3d(%rip), %rax     # 0xcfae0
cmpl $0x8, 0x2a6c(%rax)
jne 0x31cae
jmp 0x31ccd
leaq 0x122e0(%rip), %rdi     # 0x43f95
leaq 0x121d6(%rip), %rsi     # 0x43e92
movl $0x17, %edx
leaq 0x121e0(%rip), %rcx     # 0x43ea8
callq 0x20c0
leaq 0x9de0c(%rip), %rax     # 0xcfae0
cmpl $0x8, 0x2490(%rax)
jne 0x31cdf
jmp 0x31cfe
leaq 0x122cc(%rip), %rdi     # 0x43fb2
leaq 0x121a5(%rip), %rsi     # 0x43e92
movl $0x18, %edx
leaq 0x121af(%rip), %rcx     # 0x43ea8
callq 0x20c0
popq %rbp
retq
// File: jswaff[P]prophet3/test/square__test.cpp
// Function: test_rank()
void test_rank() {
    assert(get_rank(A8)==RANK_8);
    assert(get_rank(B8)==RANK_8);
    assert(get_rank(H8)==RANK_8);
    assert(get_rank(C7)==RANK_7);
    assert(get_rank(E5)==RANK_5);
    assert(get_rank(A2)==RANK_2);
    assert(get_rank(H1)==RANK_1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x120d0
cmpl $0x0, %eax
jne 0x31d12
jmp 0x31d31
leaq 0x122b6(%rip), %rdi     # 0x43fcf
leaq 0x12172(%rip), %rsi     # 0x43e92
movl $0x1c, %edx
leaq 0x122b8(%rip), %rcx     # 0x43fe4
callq 0x20c0
movl $0x1, %edi
callq 0x120d0
cmpl $0x0, %eax
jne 0x31d42
jmp 0x31d61
leaq 0x122ac(%rip), %rdi     # 0x43ff5
leaq 0x12142(%rip), %rsi     # 0x43e92
movl $0x1d, %edx
leaq 0x12288(%rip), %rcx     # 0x43fe4
callq 0x20c0
movl $0x7, %edi
callq 0x120d0
cmpl $0x0, %eax
jne 0x31d72
jmp 0x31d91
leaq 0x12291(%rip), %rdi     # 0x4400a
leaq 0x12112(%rip), %rsi     # 0x43e92
movl $0x1e, %edx
leaq 0x12258(%rip), %rcx     # 0x43fe4
callq 0x20c0
movl $0xa, %edi
callq 0x120d0
cmpl $0x1, %eax
jne 0x31da2
jmp 0x31dc1
leaq 0x12276(%rip), %rdi     # 0x4401f
leaq 0x120e2(%rip), %rsi     # 0x43e92
movl $0x1f, %edx
leaq 0x12228(%rip), %rcx     # 0x43fe4
callq 0x20c0
movl $0x1c, %edi
callq 0x120d0
cmpl $0x3, %eax
jne 0x31dd2
jmp 0x31df1
leaq 0x1225b(%rip), %rdi     # 0x44034
leaq 0x120b2(%rip), %rsi     # 0x43e92
movl $0x20, %edx
leaq 0x121f8(%rip), %rcx     # 0x43fe4
callq 0x20c0
movl $0x30, %edi
callq 0x120d0
cmpl $0x6, %eax
jne 0x31e02
jmp 0x31e21
leaq 0x12240(%rip), %rdi     # 0x44049
leaq 0x12082(%rip), %rsi     # 0x43e92
movl $0x21, %edx
leaq 0x121c8(%rip), %rcx     # 0x43fe4
callq 0x20c0
movl $0x3f, %edi
callq 0x120d0
cmpl $0x7, %eax
jne 0x31e32
jmp 0x31e51
leaq 0x12225(%rip), %rdi     # 0x4405e
leaq 0x12052(%rip), %rsi     # 0x43e92
movl $0x22, %edx
leaq 0x12198(%rip), %rcx     # 0x43fe4
callq 0x20c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/square__test.cpp
// Function: test_file()
void test_file() {
    assert(get_file(A1)==FILE_A);
    assert(get_file(B3)==FILE_B);
    assert(get_file(C8)==FILE_C);
    assert(get_file(D4)==FILE_D);
    assert(get_file(E2)==FILE_E);
    assert(get_file(F7)==FILE_F);
    assert(get_file(G5)==FILE_G);
    assert(get_file(H6)==FILE_H);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x38, %edi
callq 0x12070
cmpl $0x0, %eax
jne 0x31e75
jmp 0x31e94
leaq 0x121f7(%rip), %rdi     # 0x44073
leaq 0x1200f(%rip), %rsi     # 0x43e92
movl $0x26, %edx
leaq 0x121f9(%rip), %rcx     # 0x44088
callq 0x20c0
movl $0x29, %edi
callq 0x12070
cmpl $0x1, %eax
jne 0x31ea5
jmp 0x31ec4
leaq 0x121ed(%rip), %rdi     # 0x44099
leaq 0x11fdf(%rip), %rsi     # 0x43e92
movl $0x27, %edx
leaq 0x121c9(%rip), %rcx     # 0x44088
callq 0x20c0
movl $0x2, %edi
callq 0x12070
cmpl $0x2, %eax
jne 0x31ed5
jmp 0x31ef4
leaq 0x121d2(%rip), %rdi     # 0x440ae
leaq 0x11faf(%rip), %rsi     # 0x43e92
movl $0x28, %edx
leaq 0x12199(%rip), %rcx     # 0x44088
callq 0x20c0
movl $0x23, %edi
callq 0x12070
cmpl $0x3, %eax
jne 0x31f05
jmp 0x31f24
leaq 0x121b7(%rip), %rdi     # 0x440c3
leaq 0x11f7f(%rip), %rsi     # 0x43e92
movl $0x29, %edx
leaq 0x12169(%rip), %rcx     # 0x44088
callq 0x20c0
movl $0x34, %edi
callq 0x12070
cmpl $0x4, %eax
jne 0x31f35
jmp 0x31f54
leaq 0x1219c(%rip), %rdi     # 0x440d8
leaq 0x11f4f(%rip), %rsi     # 0x43e92
movl $0x2a, %edx
leaq 0x12139(%rip), %rcx     # 0x44088
callq 0x20c0
movl $0xd, %edi
callq 0x12070
cmpl $0x5, %eax
jne 0x31f65
jmp 0x31f84
leaq 0x12181(%rip), %rdi     # 0x440ed
leaq 0x11f1f(%rip), %rsi     # 0x43e92
movl $0x2b, %edx
leaq 0x12109(%rip), %rcx     # 0x44088
callq 0x20c0
movl $0x1e, %edi
callq 0x12070
cmpl $0x6, %eax
jne 0x31f95
jmp 0x31fb4
leaq 0x12166(%rip), %rdi     # 0x44102
leaq 0x11eef(%rip), %rsi     # 0x43e92
movl $0x2c, %edx
leaq 0x120d9(%rip), %rcx     # 0x44088
callq 0x20c0
movl $0x17, %edi
callq 0x12070
cmpl $0x7, %eax
jne 0x31fc5
jmp 0x31fe4
leaq 0x1214b(%rip), %rdi     # 0x44117
leaq 0x11ebf(%rip), %rsi     # 0x43e92
movl $0x2d, %edx
leaq 0x120a9(%rip), %rcx     # 0x44088
callq 0x20c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/square__test.cpp
// Function: test_file_distance()
void test_file_distance() {
    assert(file_distance(A1,B1)==1);
    assert(file_distance(A1,H8)==7);
    assert(file_distance(A1,H4)==7);
    assert(file_distance(B3,C7)==1);
    assert(file_distance(H2,A3)==7);
    assert(file_distance(F3,B8)==4);
    assert(file_distance(E1,E2)==0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x38, %edi
movl $0x39, %esi
callq 0x12290
cmpl $0x1, %eax
jne 0x3200a
jmp 0x32029
leaq 0x1211b(%rip), %rdi     # 0x4412c
leaq 0x11e7a(%rip), %rsi     # 0x43e92
movl $0x31, %edx
leaq 0x12120(%rip), %rcx     # 0x44144
callq 0x20c0
movl $0x38, %edi
movl $0x7, %esi
callq 0x12290
cmpl $0x7, %eax
jne 0x3203f
jmp 0x3205e
leaq 0x12118(%rip), %rdi     # 0x4415e
leaq 0x11e45(%rip), %rsi     # 0x43e92
movl $0x32, %edx
leaq 0x120eb(%rip), %rcx     # 0x44144
callq 0x20c0
movl $0x38, %edi
movl $0x27, %esi
callq 0x12290
cmpl $0x7, %eax
jne 0x32074
jmp 0x32093
leaq 0x120fb(%rip), %rdi     # 0x44176
leaq 0x11e10(%rip), %rsi     # 0x43e92
movl $0x33, %edx
leaq 0x120b6(%rip), %rcx     # 0x44144
callq 0x20c0
movl $0x29, %edi
movl $0xa, %esi
callq 0x12290
cmpl $0x1, %eax
jne 0x320a9
jmp 0x320c8
leaq 0x120de(%rip), %rdi     # 0x4418e
leaq 0x11ddb(%rip), %rsi     # 0x43e92
movl $0x34, %edx
leaq 0x12081(%rip), %rcx     # 0x44144
callq 0x20c0
movl $0x37, %edi
movl $0x28, %esi
callq 0x12290
cmpl $0x7, %eax
jne 0x320de
jmp 0x320fd
leaq 0x120c1(%rip), %rdi     # 0x441a6
leaq 0x11da6(%rip), %rsi     # 0x43e92
movl $0x35, %edx
leaq 0x1204c(%rip), %rcx     # 0x44144
callq 0x20c0
movl $0x2d, %edi
movl $0x1, %esi
callq 0x12290
cmpl $0x4, %eax
jne 0x32113
jmp 0x32132
leaq 0x120a4(%rip), %rdi     # 0x441be
leaq 0x11d71(%rip), %rsi     # 0x43e92
movl $0x36, %edx
leaq 0x12017(%rip), %rcx     # 0x44144
callq 0x20c0
movl $0x3c, %edi
movl $0x34, %esi
callq 0x12290
cmpl $0x0, %eax
jne 0x32148
jmp 0x32167
leaq 0x12087(%rip), %rdi     # 0x441d6
leaq 0x11d3c(%rip), %rsi     # 0x43e92
movl $0x37, %edx
leaq 0x11fe2(%rip), %rcx     # 0x44144
callq 0x20c0
popq %rbp
retq
nopl (%rax)
// File: jswaff[P]prophet3/test/square__test.cpp
// Function: test_rank_distance()
void test_rank_distance() {
    assert(rank_distance(A1,B1)==0);
    assert(rank_distance(A1,C4)==3);
    assert(rank_distance(H8,A7)==1);
    assert(rank_distance(G8,B1)==7);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x38, %edi
movl $0x39, %esi
callq 0x121d0
cmpl $0x0, %eax
jne 0x3218a
jmp 0x321a9
leaq 0x1205d(%rip), %rdi     # 0x441ee
leaq 0x11cfa(%rip), %rsi     # 0x43e92
movl $0x3b, %edx
leaq 0x12062(%rip), %rcx     # 0x44206
callq 0x20c0
movl $0x38, %edi
movl $0x22, %esi
callq 0x121d0
cmpl $0x3, %eax
jne 0x321bf
jmp 0x321de
leaq 0x1205a(%rip), %rdi     # 0x44220
leaq 0x11cc5(%rip), %rsi     # 0x43e92
movl $0x3c, %edx
leaq 0x1202d(%rip), %rcx     # 0x44206
callq 0x20c0
movl $0x7, %edi
movl $0x8, %esi
callq 0x121d0
cmpl $0x1, %eax
jne 0x321f4
jmp 0x32213
leaq 0x1203d(%rip), %rdi     # 0x44238
leaq 0x11c90(%rip), %rsi     # 0x43e92
movl $0x3d, %edx
leaq 0x11ff8(%rip), %rcx     # 0x44206
callq 0x20c0
movl $0x6, %edi
movl $0x39, %esi
callq 0x121d0
cmpl $0x7, %eax
jne 0x32229
jmp 0x32248
leaq 0x12020(%rip), %rdi     # 0x44250
leaq 0x11c5b(%rip), %rsi     # 0x43e92
movl $0x3e, %edx
leaq 0x11fc3(%rip), %rcx     # 0x44206
callq 0x20c0
popq %rbp
retq
nopw (%rax,%rax)
// File: jswaff[P]prophet3/test/square__test.cpp
// Function: test_distance()
void test_distance() {
    assert(distance(E4,E4)==0);
    assert(distance(A1,A8)==7);
    assert(distance(H1,E4)==3);
    assert(distance(H8,E4)==4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x24, %esi
movl %esi, %edi
callq 0x12350
cmpl $0x0, %eax
jne 0x32267
jmp 0x32286
leaq 0x11ffa(%rip), %rdi     # 0x44268
leaq 0x11c1d(%rip), %rsi     # 0x43e92
movl $0x42, %edx
leaq 0x11ffa(%rip), %rcx     # 0x4427b
callq 0x20c0
movl $0x38, %edi
xorl %esi, %esi
callq 0x12350
cmpl $0x7, %eax
jne 0x32299
jmp 0x322b8
leaq 0x11ff0(%rip), %rdi     # 0x44290
leaq 0x11beb(%rip), %rsi     # 0x43e92
movl $0x43, %edx
leaq 0x11fc8(%rip), %rcx     # 0x4427b
callq 0x20c0
movl $0x3f, %edi
movl $0x24, %esi
callq 0x12350
cmpl $0x3, %eax
jne 0x322ce
jmp 0x322ed
leaq 0x11fce(%rip), %rdi     # 0x442a3
leaq 0x11bb6(%rip), %rsi     # 0x43e92
movl $0x44, %edx
leaq 0x11f93(%rip), %rcx     # 0x4427b
callq 0x20c0
movl $0x7, %edi
movl $0x24, %esi
callq 0x12350
cmpl $0x4, %eax
jne 0x32303
jmp 0x32322
leaq 0x11fac(%rip), %rdi     # 0x442b6
leaq 0x11b81(%rip), %rsi     # 0x43e92
movl $0x45, %edx
leaq 0x11f5e(%rip), %rcx     # 0x4427b
callq 0x20c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/square__test.cpp
// Function: test_northeast()
void test_northeast() {
    assert(northeast(NO_SQUARE)==NO_SQUARE);
    assert(northeast(B4)==C5);
    assert(northeast(G8)==NO_SQUARE);
    assert(northeast(H7)==NO_SQUARE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x40, %edi
callq 0x12610
cmpl $0x40, %eax
jne 0x325c5
jmp 0x325e4
leaq 0x11e03(%rip), %rdi     # 0x443cf
leaq 0x118bf(%rip), %rsi     # 0x43e92
movl $0x61, %edx
leaq 0x11e10(%rip), %rcx     # 0x443ef
callq 0x20c0
movl $0x21, %edi
callq 0x12610
cmpl $0x1a, %eax
jne 0x325f5
jmp 0x32614
leaq 0x11e09(%rip), %rdi     # 0x44405
leaq 0x1188f(%rip), %rsi     # 0x43e92
movl $0x62, %edx
leaq 0x11de0(%rip), %rcx     # 0x443ef
callq 0x20c0
movl $0x6, %edi
callq 0x12610
cmpl $0x40, %eax
jne 0x32625
jmp 0x32644
leaq 0x11deb(%rip), %rdi     # 0x44417
leaq 0x1185f(%rip), %rsi     # 0x43e92
movl $0x63, %edx
leaq 0x11db0(%rip), %rcx     # 0x443ef
callq 0x20c0
movl $0xf, %edi
callq 0x12610
cmpl $0x40, %eax
jne 0x32655
jmp 0x32674
leaq 0x11dd4(%rip), %rdi     # 0x44430
leaq 0x1182f(%rip), %rsi     # 0x43e92
movl $0x64, %edx
leaq 0x11d80(%rip), %rcx     # 0x443ef
callq 0x20c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/square__test.cpp
// Function: test_southeast()
void test_southeast() {
    assert(southeast(NO_SQUARE)==NO_SQUARE);
    assert(southeast(B4)==C3);
    assert(southeast(G1)==NO_SQUARE);
    assert(southeast(H2)==NO_SQUARE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x40, %edi
callq 0x126a0
cmpl $0x40, %eax
jne 0x32695
jmp 0x326b4
leaq 0x11dad(%rip), %rdi     # 0x44449
leaq 0x117ef(%rip), %rsi     # 0x43e92
movl $0x68, %edx
leaq 0x11dba(%rip), %rcx     # 0x44469
callq 0x20c0
movl $0x21, %edi
callq 0x126a0
cmpl $0x2a, %eax
jne 0x326c5
jmp 0x326e4
leaq 0x11db3(%rip), %rdi     # 0x4447f
leaq 0x117bf(%rip), %rsi     # 0x43e92
movl $0x69, %edx
leaq 0x11d8a(%rip), %rcx     # 0x44469
callq 0x20c0
movl $0x3e, %edi
callq 0x126a0
cmpl $0x40, %eax
jne 0x326f5
jmp 0x32714
leaq 0x11d95(%rip), %rdi     # 0x44491
leaq 0x1178f(%rip), %rsi     # 0x43e92
movl $0x6a, %edx
leaq 0x11d5a(%rip), %rcx     # 0x44469
callq 0x20c0
movl $0x37, %edi
callq 0x126a0
cmpl $0x40, %eax
jne 0x32725
jmp 0x32744
leaq 0x11d7e(%rip), %rdi     # 0x444aa
leaq 0x1175f(%rip), %rsi     # 0x43e92
movl $0x6b, %edx
leaq 0x11d2a(%rip), %rcx     # 0x44469
callq 0x20c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/square__test.cpp
// Function: test_southwest()
void test_southwest() {
    assert(southwest(NO_SQUARE)==NO_SQUARE);
    assert(southwest(B4)==A3);
    assert(southwest(B1)==NO_SQUARE);
    assert(southwest(A2)==NO_SQUARE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x40, %edi
callq 0x12730
cmpl $0x40, %eax
jne 0x32765
jmp 0x32784
leaq 0x11d57(%rip), %rdi     # 0x444c3
leaq 0x1171f(%rip), %rsi     # 0x43e92
movl $0x6f, %edx
leaq 0x11d64(%rip), %rcx     # 0x444e3
callq 0x20c0
movl $0x21, %edi
callq 0x12730
cmpl $0x28, %eax
jne 0x32795
jmp 0x327b4
leaq 0x11d5d(%rip), %rdi     # 0x444f9
leaq 0x116ef(%rip), %rsi     # 0x43e92
movl $0x70, %edx
leaq 0x11d34(%rip), %rcx     # 0x444e3
callq 0x20c0
movl $0x39, %edi
callq 0x12730
cmpl $0x40, %eax
jne 0x327c5
jmp 0x327e4
leaq 0x11d3f(%rip), %rdi     # 0x4450b
leaq 0x116bf(%rip), %rsi     # 0x43e92
movl $0x71, %edx
leaq 0x11d04(%rip), %rcx     # 0x444e3
callq 0x20c0
movl $0x30, %edi
callq 0x12730
cmpl $0x40, %eax
jne 0x327f5
jmp 0x32814
leaq 0x11d28(%rip), %rdi     # 0x44524
leaq 0x1168f(%rip), %rsi     # 0x43e92
movl $0x72, %edx
leaq 0x11cd4(%rip), %rcx     # 0x444e3
callq 0x20c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/square__test.cpp
// Function: test_northwest()
void test_northwest() {
    assert(northwest(NO_SQUARE)==NO_SQUARE);
    assert(northwest(B4)==A5);
    assert(northwest(A7)==NO_SQUARE);
    assert(northwest(B8)==NO_SQUARE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x40, %edi
callq 0x127c0
cmpl $0x40, %eax
jne 0x32835
jmp 0x32854
leaq 0x11d01(%rip), %rdi     # 0x4453d
leaq 0x1164f(%rip), %rsi     # 0x43e92
movl $0x76, %edx
leaq 0x11d0e(%rip), %rcx     # 0x4455d
callq 0x20c0
movl $0x21, %edi
callq 0x127c0
cmpl $0x18, %eax
jne 0x32865
jmp 0x32884
leaq 0x11d07(%rip), %rdi     # 0x44573
leaq 0x1161f(%rip), %rsi     # 0x43e92
movl $0x77, %edx
leaq 0x11cde(%rip), %rcx     # 0x4455d
callq 0x20c0
movl $0x8, %edi
callq 0x127c0
cmpl $0x40, %eax
jne 0x32895
jmp 0x328b4
leaq 0x11ce9(%rip), %rdi     # 0x44585
leaq 0x115ef(%rip), %rsi     # 0x43e92
movl $0x78, %edx
leaq 0x11cae(%rip), %rcx     # 0x4455d
callq 0x20c0
movl $0x1, %edi
callq 0x127c0
cmpl $0x40, %eax
jne 0x328c5
jmp 0x328e4
leaq 0x11cd2(%rip), %rdi     # 0x4459e
leaq 0x115bf(%rip), %rsi     # 0x43e92
movl $0x79, %edx
leaq 0x11c7e(%rip), %rcx     # 0x4455d
callq 0x20c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/square__test.cpp
// Function: test_is_light_sq()
void test_is_light_sq() {
    assert(is_light_sq(A8));
    assert(!is_light_sq(B8));
    assert(is_light_sq(C8));
    assert(!is_light_sq(A7));
    assert(is_light_sq(B7));
    assert(!is_light_sq(C7));
    assert(is_light_sq(A6));
    assert(!is_light_sq(B6));
    assert(is_light_sq(C6));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x12850
testb $0x1, %al
jne 0x32901
jmp 0x32903
jmp 0x32922
leaq 0x11cad(%rip), %rdi     # 0x445b7
leaq 0x11581(%rip), %rsi     # 0x43e92
movl $0x7d, %edx
leaq 0x11caa(%rip), %rcx     # 0x445c7
callq 0x20c0
movl $0x1, %edi
callq 0x12850
xorb $-0x1, %al
testb $0x1, %al
jne 0x32934
jmp 0x32936
jmp 0x32955
leaq 0x11ca2(%rip), %rdi     # 0x445df
leaq 0x1154e(%rip), %rsi     # 0x43e92
movl $0x7e, %edx
leaq 0x11c77(%rip), %rcx     # 0x445c7
callq 0x20c0
movl $0x2, %edi
callq 0x12850
testb $0x1, %al
jne 0x32965
jmp 0x32967
jmp 0x32986
leaq 0x11c82(%rip), %rdi     # 0x445f0
leaq 0x1151d(%rip), %rsi     # 0x43e92
movl $0x7f, %edx
leaq 0x11c46(%rip), %rcx     # 0x445c7
callq 0x20c0
movl $0x8, %edi
callq 0x12850
xorb $-0x1, %al
testb $0x1, %al
jne 0x32998
jmp 0x3299a
jmp 0x329b9
leaq 0x11c5f(%rip), %rdi     # 0x44600
leaq 0x114ea(%rip), %rsi     # 0x43e92
movl $0x80, %edx
leaq 0x11c13(%rip), %rcx     # 0x445c7
callq 0x20c0
movl $0x9, %edi
callq 0x12850
testb $0x1, %al
jne 0x329c9
jmp 0x329cb
jmp 0x329ea
leaq 0x11c3f(%rip), %rdi     # 0x44611
leaq 0x114b9(%rip), %rsi     # 0x43e92
movl $0x81, %edx
leaq 0x11be2(%rip), %rcx     # 0x445c7
callq 0x20c0
movl $0xa, %edi
callq 0x12850
xorb $-0x1, %al
testb $0x1, %al
jne 0x329fc
jmp 0x329fe
jmp 0x32a1d
leaq 0x11c1c(%rip), %rdi     # 0x44621
leaq 0x11486(%rip), %rsi     # 0x43e92
movl $0x82, %edx
leaq 0x11baf(%rip), %rcx     # 0x445c7
callq 0x20c0
movl $0x10, %edi
callq 0x12850
testb $0x1, %al
jne 0x32a2d
jmp 0x32a2f
jmp 0x32a4e
leaq 0x11bfc(%rip), %rdi     # 0x44632
leaq 0x11455(%rip), %rsi     # 0x43e92
movl $0x83, %edx
leaq 0x11b7e(%rip), %rcx     # 0x445c7
callq 0x20c0
movl $0x11, %edi
callq 0x12850
xorb $-0x1, %al
testb $0x1, %al
jne 0x32a60
jmp 0x32a62
jmp 0x32a81
leaq 0x11bd9(%rip), %rdi     # 0x44642
leaq 0x11422(%rip), %rsi     # 0x43e92
movl $0x84, %edx
leaq 0x11b4b(%rip), %rcx     # 0x445c7
callq 0x20c0
movl $0x12, %edi
callq 0x12850
testb $0x1, %al
jne 0x32a91
jmp 0x32a93
jmp 0x32ab2
leaq 0x11bb9(%rip), %rdi     # 0x44653
leaq 0x113f1(%rip), %rsi     # 0x43e92
movl $0x85, %edx
leaq 0x11b1a(%rip), %rcx     # 0x445c7
callq 0x20c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/square__test.cpp
// Function: test_is_dark_sq()
void test_is_dark_sq() {
    assert(is_dark_sq(H8));
    assert(!is_dark_sq(G8));
    assert(is_dark_sq(F8));
    assert(!is_dark_sq(H7));
    assert(is_dark_sq(G7));
    assert(!is_dark_sq(F7));
    assert(is_dark_sq(H6));
    assert(!is_dark_sq(G6));
    assert(is_dark_sq(F6));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x7, %edi
callq 0x128e0
testb $0x1, %al
jne 0x32ad4
jmp 0x32ad6
jmp 0x32af5
leaq 0x11b86(%rip), %rdi     # 0x44663
leaq 0x113ae(%rip), %rsi     # 0x43e92
movl $0x89, %edx
leaq 0x11b82(%rip), %rcx     # 0x44672
callq 0x20c0
movl $0x6, %edi
callq 0x128e0
xorb $-0x1, %al
testb $0x1, %al
jne 0x32b07
jmp 0x32b09
jmp 0x32b28
leaq 0x11b79(%rip), %rdi     # 0x44689
leaq 0x1137b(%rip), %rsi     # 0x43e92
movl $0x8a, %edx
leaq 0x11b4f(%rip), %rcx     # 0x44672
callq 0x20c0
movl $0x5, %edi
callq 0x128e0
testb $0x1, %al
jne 0x32b38
jmp 0x32b3a
jmp 0x32b59
leaq 0x11b58(%rip), %rdi     # 0x44699
leaq 0x1134a(%rip), %rsi     # 0x43e92
movl $0x8b, %edx
leaq 0x11b1e(%rip), %rcx     # 0x44672
callq 0x20c0
movl $0xf, %edi
callq 0x128e0
xorb $-0x1, %al
testb $0x1, %al
jne 0x32b6b
jmp 0x32b6d
jmp 0x32b8c
leaq 0x11b34(%rip), %rdi     # 0x446a8
leaq 0x11317(%rip), %rsi     # 0x43e92
movl $0x8c, %edx
leaq 0x11aeb(%rip), %rcx     # 0x44672
callq 0x20c0
movl $0xe, %edi
callq 0x128e0
testb $0x1, %al
jne 0x32b9c
jmp 0x32b9e
jmp 0x32bbd
leaq 0x11b13(%rip), %rdi     # 0x446b8
leaq 0x112e6(%rip), %rsi     # 0x43e92
movl $0x8d, %edx
leaq 0x11aba(%rip), %rcx     # 0x44672
callq 0x20c0
movl $0xd, %edi
callq 0x128e0
xorb $-0x1, %al
testb $0x1, %al
jne 0x32bcf
jmp 0x32bd1
jmp 0x32bf0
leaq 0x11aef(%rip), %rdi     # 0x446c7
leaq 0x112b3(%rip), %rsi     # 0x43e92
movl $0x8e, %edx
leaq 0x11a87(%rip), %rcx     # 0x44672
callq 0x20c0
movl $0x17, %edi
callq 0x128e0
testb $0x1, %al
jne 0x32c00
jmp 0x32c02
jmp 0x32c21
leaq 0x11ace(%rip), %rdi     # 0x446d7
leaq 0x11282(%rip), %rsi     # 0x43e92
movl $0x8f, %edx
leaq 0x11a56(%rip), %rcx     # 0x44672
callq 0x20c0
movl $0x16, %edi
callq 0x128e0
xorb $-0x1, %al
testb $0x1, %al
jne 0x32c33
jmp 0x32c35
jmp 0x32c54
leaq 0x11aaa(%rip), %rdi     # 0x446e6
leaq 0x1124f(%rip), %rsi     # 0x43e92
movl $0x90, %edx
leaq 0x11a23(%rip), %rcx     # 0x44672
callq 0x20c0
movl $0x15, %edi
callq 0x128e0
testb $0x1, %al
jne 0x32c64
jmp 0x32c66
jmp 0x32c85
leaq 0x11a89(%rip), %rdi     # 0x446f6
leaq 0x1121e(%rip), %rsi     # 0x43e92
movl $0x91, %edx
leaq 0x119f2(%rip), %rcx     # 0x44672
callq 0x20c0
popq %rbp
retq
nopw (%rax,%rax)
// File: jswaff[P]prophet3/test/square__test.cpp
// Function: test_is_diagonal()
void test_is_diagonal() {
    assert(is_diagonal(A1,B2));
    assert(!is_diagonal(A1,A2));
    assert(is_diagonal(D4,G7));
    assert(is_diagonal(G7,B2));
    assert(!is_diagonal(C2,E2));
    assert(is_diagonal(A8,H1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x38, %edi
movl $0x31, %esi
callq 0x12940
testb $0x1, %al
jne 0x32ca9
jmp 0x32cab
jmp 0x32cca
leaq 0x11a53(%rip), %rdi     # 0x44705
leaq 0x111d9(%rip), %rsi     # 0x43e92
movl $0x95, %edx
leaq 0x11a53(%rip), %rcx     # 0x44718
callq 0x20c0
movl $0x38, %edi
movl $0x30, %esi
callq 0x12940
xorb $-0x1, %al
testb $0x1, %al
jne 0x32ce1
jmp 0x32ce3
jmp 0x32d02
leaq 0x11a46(%rip), %rdi     # 0x44730
leaq 0x111a1(%rip), %rsi     # 0x43e92
movl $0x96, %edx
leaq 0x11a1b(%rip), %rcx     # 0x44718
callq 0x20c0
movl $0x23, %edi
movl $0xe, %esi
callq 0x12940
testb $0x1, %al
jne 0x32d17
jmp 0x32d19
jmp 0x32d38
leaq 0x11a24(%rip), %rdi     # 0x44744
leaq 0x1116b(%rip), %rsi     # 0x43e92
movl $0x97, %edx
leaq 0x119e5(%rip), %rcx     # 0x44718
callq 0x20c0
movl $0xe, %edi
movl $0x31, %esi
callq 0x12940
testb $0x1, %al
jne 0x32d4d
jmp 0x32d4f
jmp 0x32d6e
leaq 0x11a01(%rip), %rdi     # 0x44757
leaq 0x11135(%rip), %rsi     # 0x43e92
movl $0x98, %edx
leaq 0x119af(%rip), %rcx     # 0x44718
callq 0x20c0
movl $0x32, %edi
movl $0x34, %esi
callq 0x12940
xorb $-0x1, %al
testb $0x1, %al
jne 0x32d85
jmp 0x32d87
jmp 0x32da6
leaq 0x119dc(%rip), %rdi     # 0x4476a
leaq 0x110fd(%rip), %rsi     # 0x43e92
movl $0x99, %edx
leaq 0x11977(%rip), %rcx     # 0x44718
callq 0x20c0
xorl %edi, %edi
movl $0x3f, %esi
callq 0x12940
testb $0x1, %al
jne 0x32db8
jmp 0x32dba
jmp 0x32dd9
leaq 0x119bd(%rip), %rdi     # 0x4477e
leaq 0x110ca(%rip), %rsi     # 0x43e92
movl $0x9a, %edx
leaq 0x11944(%rip), %rcx     # 0x44718
callq 0x20c0
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/test/square__test.cpp
// Function: test_square()
void test_square() {
    test_rank();
    test_file();
    test_rank_distance();
    test_file_distance();
    test_distance();
    test_get_dir();
    test_north();
    test_east();
    test_south();
    test_west();
    test_northeast();
    test_southeast();
    test_southwest();
    test_northwest();
    test_is_light_sq();
    test_is_dark_sq();
    test_is_diagonal();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x31d00
callq 0x31e60
callq 0x32170
callq 0x31ff0
callq 0x32250
callq 0x31b10
callq 0x32330
callq 0x323d0
callq 0x32470
callq 0x32510
callq 0x325b0
callq 0x32680
callq 0x32750
callq 0x32820
callq 0x328f0
callq 0x32ac0
callq 0x32c90
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/test/time__test.cpp
// Function: test_get_search_time()
void test_get_search_time() {
    // should leave 1/10th second on the clock if possible
    assert(get_search_time(100,0)==0);
    assert(get_search_time(99,0)==0);
    assert(get_search_time(25,0)==0);
    assert(get_search_time(-1,3)==0);
    assert(get_search_time(-25,2)==0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x64, %edi
xorl %esi, %esi
callq 0x140e0
cmpl $0x0, %eax
jne 0x32e57
jmp 0x32e76
leaq 0x11933(%rip), %rdi     # 0x44791
leaq 0x11946(%rip), %rsi     # 0x447ab
movl $0x7, %edx
leaq 0x1194e(%rip), %rcx     # 0x447bf
callq 0x20c0
movl $0x63, %edi
xorl %esi, %esi
callq 0x140e0
cmpl $0x0, %eax
jne 0x32e89
jmp 0x32ea8
leaq 0x1194b(%rip), %rdi     # 0x447db
leaq 0x11914(%rip), %rsi     # 0x447ab
movl $0x8, %edx
leaq 0x1191c(%rip), %rcx     # 0x447bf
callq 0x20c0
movl $0x19, %edi
xorl %esi, %esi
callq 0x140e0
cmpl $0x0, %eax
jne 0x32ebb
jmp 0x32eda
leaq 0x11932(%rip), %rdi     # 0x447f4
leaq 0x118e2(%rip), %rsi     # 0x447ab
movl $0x9, %edx
leaq 0x118ea(%rip), %rcx     # 0x447bf
callq 0x20c0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x3, %esi
callq 0x140e0
cmpl $0x0, %eax
jne 0x32ef0
jmp 0x32f0f
leaq 0x11916(%rip), %rdi     # 0x4480d
leaq 0x118ad(%rip), %rsi     # 0x447ab
movl $0xa, %edx
leaq 0x118b5(%rip), %rcx     # 0x447bf
callq 0x20c0
movl $0xffffffe7, %edi       # imm = 0xFFFFFFE7
movl $0x2, %esi
callq 0x140e0
cmpl $0x0, %eax
jne 0x32f25
jmp 0x32f44
leaq 0x118fa(%rip), %rdi     # 0x44826
leaq 0x11878(%rip), %rsi     # 0x447ab
movl $0xb, %edx
leaq 0x11880(%rip), %rcx     # 0x447bf
callq 0x20c0
movl $0x17c, %edi            # imm = 0x17C
movl $0x12b, %esi            # imm = 0x12B
callq 0x140e0
cmpl $0xd6, %eax
jne 0x32f5c
jmp 0x32f7b
leaq 0x118dd(%rip), %rdi     # 0x44840
leaq 0x11841(%rip), %rsi     # 0x447ab
movl $0xd, %edx
leaq 0x11849(%rip), %rcx     # 0x447bf
callq 0x20c0
popq %rbp
retq
nopl (%rax)
// File: jswaff[P]prophet3/test/utils__test.cpp
// Function: test_str_to_sq()
void test_str_to_sq() {
    assert(str_to_sq("-")==NO_SQUARE);
    assert(str_to_sq("e3")==E3);
    assert(str_to_sq("a8")==A8);
    assert(str_to_sq("C5")==C5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9796(%rip), %rdi      # 0x3c7a1
callq 0x14150
cmpl $0x40, %eax
jne 0x33017
jmp 0x33036
leaq 0x118ad(%rip), %rdi     # 0x448cb
leaq 0x11857(%rip), %rsi     # 0x4487c
movl $0x14, %edx
leaq 0x118b4(%rip), %rcx     # 0x448e5
callq 0x20c0
leaq 0x11a30(%rip), %rdi     # 0x44a6d
callq 0x14150
cmpl $0x2c, %eax
jne 0x33049
jmp 0x33068
leaq 0x118ab(%rip), %rdi     # 0x448fb
leaq 0x11825(%rip), %rsi     # 0x4487c
movl $0x15, %edx
leaq 0x11882(%rip), %rcx     # 0x448e5
callq 0x20c0
leaq 0x118a0(%rip), %rdi     # 0x4490f
callq 0x14150
cmpl $0x0, %eax
jne 0x3307b
jmp 0x3309a
leaq 0x11890(%rip), %rdi     # 0x44912
leaq 0x117f3(%rip), %rsi     # 0x4487c
movl $0x16, %edx
leaq 0x11850(%rip), %rcx     # 0x448e5
callq 0x20c0
leaq 0x11896(%rip), %rdi     # 0x44937
callq 0x14150
cmpl $0x1a, %eax
jne 0x330ad
jmp 0x330cc
leaq 0x11872(%rip), %rdi     # 0x44926
leaq 0x117c1(%rip), %rsi     # 0x4487c
movl $0x17, %edx
leaq 0x1181e(%rip), %rcx     # 0x448e5
callq 0x20c0
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/utils__test.cpp
// Function: test_sq_to_str()
void test_sq_to_str() {
    char str[3];
    sq_to_str(E3,str);
    assert(!strcmp("e3",str));

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x3(%rbp), %rsi
movl $0x2c, %edi
callq 0x14220
leaq -0x3(%rbp), %rsi
leaq 0x1197c(%rip), %rdi     # 0x44a6d
callq 0x2260
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x33104
jmp 0x33106
jmp 0x33125
leaq 0x1182d(%rip), %rdi     # 0x4493a
leaq 0x11768(%rip), %rsi     # 0x4487c
movl $0x1d, %edx
leaq 0x1182c(%rip), %rcx     # 0x4494c
callq 0x20c0
leaq -0x3(%rbp), %rsi
movl $0x7, %edi
callq 0x14220
leaq -0x3(%rbp), %rsi
leaq 0x11824(%rip), %rdi     # 0x44962
callq 0x2260
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x33151
jmp 0x33153
jmp 0x33172
leaq 0x1180b(%rip), %rdi     # 0x44965
leaq 0x1171b(%rip), %rsi     # 0x4487c
movl $0x20, %edx
leaq 0x117df(%rip), %rcx     # 0x4494c
callq 0x20c0
leaq -0x3(%rbp), %rsi
movl $0x12, %edi
callq 0x14220
leaq -0x3(%rbp), %rsi
leaq 0xdfb5(%rip), %rdi      # 0x41140
callq 0x2260
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3319e
jmp 0x331a0
jmp 0x331bf
leaq 0x117d0(%rip), %rdi     # 0x44977
leaq 0x116ce(%rip), %rsi     # 0x4487c
movl $0x23, %edx
leaq 0x11792(%rip), %rcx     # 0x4494c
callq 0x20c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/utils__test.cpp
// Function: test_move_to_str()
void test_move_to_str() {
    move mv = to_move(PAWN,C7,C5);
    char buffer[6];
    move_to_str(mv,buffer);
    assert(!strcmp("c7c5",buffer));

    mv = to_move(KNIGHT,B8,C6);
    move_to_str(mv,buffer);
    assert(!strcmp("b8c6",buffer));

    mv = to_move(PAWN,C7,C8);
    set_promopiece(&mv,QUEEN);
    move_to_str(mv,buffer);
    assert(!strcmp("c7c8q",buffer));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0xa, %esi
movl $0x1a, %edx
callq 0xa830
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xe(%rbp), %rsi
callq 0x14350
leaq -0xe(%rbp), %rsi
leaq 0x11781(%rip), %rdi     # 0x44989
callq 0x2260
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3321b
jmp 0x3321d
jmp 0x3323c
leaq 0x1176a(%rip), %rdi     # 0x4498e
leaq 0x11651(%rip), %rsi     # 0x4487c
movl $0x2a, %edx
leaq 0x1176e(%rip), %rcx     # 0x449a5
callq 0x20c0
movl $0x2, %edi
movl $0x1, %esi
movl $0x12, %edx
callq 0xa830
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xe(%rbp), %rsi
callq 0x14350
leaq -0xe(%rbp), %rsi
leaq 0x11751(%rip), %rdi     # 0x449bd
callq 0x2260
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3327f
jmp 0x33281
jmp 0x332a0
leaq 0x1173a(%rip), %rdi     # 0x449c2
leaq 0x115ed(%rip), %rsi     # 0x4487c
movl $0x2e, %edx
leaq 0x1170a(%rip), %rcx     # 0x449a5
callq 0x20c0
movl $0x1, %edi
movl $0xa, %esi
movl $0x2, %edx
callq 0xa830
movq %rax, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0xa9e0
movq -0x8(%rbp), %rdi
leaq -0xe(%rbp), %rsi
callq 0x14350
leaq -0xe(%rbp), %rsi
leaq 0x116fb(%rip), %rdi     # 0x449d9
callq 0x2260
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x332f1
jmp 0x332f3
jmp 0x33312
leaq 0x116e5(%rip), %rdi     # 0x449df
leaq 0x1157b(%rip), %rsi     # 0x4487c
movl $0x33, %edx
leaq 0x11698(%rip), %rcx     # 0x449a5
callq 0x20c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/test/utils__test.cpp
// Function: test_is_in_move_list()
void test_is_in_move_list() {
    move mv_list[5];
    mv_list[0] = to_move(PAWN,E2,E4);
    mv_list[1] = to_move(PAWN,E2,E3);
    mv_list[2] = to_move(KNIGHT,G1,F3);
    mv_list[3] = to_move(BISHOP,B1,D3);
    mv_list[4] = to_move(PAWN,D4,E5);
    set_capture(&mv_list[4],PAWN);

    assert(is_in_move_list(to_move(PAWN,E2,E4),mv_list,&mv_list[5]));
    assert(!is_in_move_list(to_move(PAWN,D2,D3),mv_list,&mv_list[5]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x1, %edi
movl $0x34, %esi
movl $0x24, %edx
callq 0xa830
movq %rax, -0x30(%rbp)
movl $0x1, %edi
movl $0x34, %esi
movl $0x2c, %edx
callq 0xa830
movq %rax, -0x28(%rbp)
movl $0x2, %edi
movl $0x3e, %esi
movl $0x2d, %edx
callq 0xa830
movq %rax, -0x20(%rbp)
movl $0x3, %edi
movl $0x39, %esi
movl $0x2b, %edx
callq 0xa830
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0x23, %esi
movl $0x1c, %edx
callq 0xa830
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
addq $0x20, %rdi
movl $0x1, %esi
callq 0xa920
movl $0x1, %edi
movl $0x34, %esi
movl $0x24, %edx
callq 0xa830
movq %rax, %rdi
leaq -0x30(%rbp), %rsi
leaq -0x30(%rbp), %rdx
addq $0x28, %rdx
callq 0x14c10
testb $0x1, %al
jne 0x33940
jmp 0x33942
jmp 0x33961
leaq 0x11146(%rip), %rdi     # 0x44a8f
leaq 0x10f2c(%rip), %rsi     # 0x4487c
movl $0x81, %edx
leaq 0x1116c(%rip), %rcx     # 0x44ac8
callq 0x20c0
movl $0x1, %edi
movl $0x33, %esi
movl $0x2b, %edx
callq 0xa830
movq %rax, %rdi
leaq -0x30(%rbp), %rsi
leaq -0x30(%rbp), %rdx
addq $0x28, %rdx
callq 0x14c10
xorb $-0x1, %al
testb $0x1, %al
jne 0x33991
jmp 0x33993
jmp 0x339b2
leaq 0x1114a(%rip), %rdi     # 0x44ae4
leaq 0x10edb(%rip), %rsi     # 0x4487c
movl $0x82, %edx
leaq 0x1111b(%rip), %rcx     # 0x44ac8
callq 0x20c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/test/utils__test.cpp
// Function: test_is_legal_move()
void test_is_legal_move() {
    position pos;
    reset_pos(&pos);

    move legal = to_move(PAWN,E2,E4);
    assert(is_legal_move(legal,&pos));

    move illegal = to_move(PAWN,E2,E5);
    assert(!is_legal_move(illegal,&pos));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
callq 0xf390
movl $0x1, %edi
movl $0x34, %esi
movl $0x24, %edx
callq 0xa830
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x14a90
testb $0x1, %al
jne 0x33a0b
jmp 0x33a0d
jmp 0x33a2c
leaq 0x1110a(%rip), %rdi     # 0x44b1e
leaq 0x10e61(%rip), %rsi     # 0x4487c
movl $0x8a, %edx
leaq 0x11111(%rip), %rcx     # 0x44b38
callq 0x20c0
movl $0x1, %edi
movl $0x34, %esi
movl $0x1c, %edx
callq 0xa830
movq %rax, -0x1d8(%rbp)
movq -0x1d8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x14a90
xorb $-0x1, %al
testb $0x1, %al
jne 0x33a62
jmp 0x33a64
jmp 0x33a83
leaq 0x110e7(%rip), %rdi     # 0x44b52
leaq 0x10e0a(%rip), %rsi     # 0x4487c
movl $0x8d, %edx
leaq 0x110ba(%rip), %rcx     # 0x44b38
callq 0x20c0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nopl (%rax)