LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: handle_bk()
void handle_bk() {
    if (book_db==0) {
        print("\tbook not enabled\n");
    } else {
        move_freq_pair mfp[300];
        int32 num_book_moves = get_book_moves(mfp,&gpos);

        if (num_book_moves > 0) {
            char move_buffer[8];
            for (int i=0;i<num_book_moves;i++) {
                if (mfp[i].freq > 0) {
                    move_to_str(mfp[i].mv,move_buffer);
                    print("\t%s, freq: %d\n",move_buffer,mfp[i].freq);
                }
            }
        } else {
            print("\tno book moves found\n");
        }
    }
    print("\n"); // blank line required by protocol
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x12d0, %rsp           # imm = 0x12D0
leaq 0xba9c6(%rip), %rax     # 0xcfad8
cmpq $0x0, (%rax)
jne 0x1512b
leaq 0x23bf9(%rip), %rdi     # 0x38d18
movb $0x0, %al
callq 0x8c60
jmp 0x15201
leaq -0x12c0(%rbp), %rdi
leaq 0xbe9a7(%rip), %rsi     # 0xd3ae0
callq 0x5ed0
movl %eax, -0x12c4(%rbp)
cmpl $0x0, -0x12c4(%rbp)
jle 0x151f1
movl $0x0, -0x12d0(%rbp)
movl -0x12d0(%rbp), %eax
cmpl -0x12c4(%rbp), %eax
jge 0x151ef
movslq -0x12d0(%rbp), %rcx
leaq -0x12c0(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jle 0x151d9
movslq -0x12d0(%rbp), %rcx
leaq -0x12c0(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
leaq -0x12cc(%rbp), %rsi
callq 0x14350
leaq -0x12cc(%rbp), %rsi
movslq -0x12d0(%rbp), %rcx
leaq -0x12c0(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edx
leaq 0x23b59(%rip), %rdi     # 0x38d2b
movb $0x0, %al
callq 0x8c60
jmp 0x151db
movl -0x12d0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x12d0(%rbp)
jmp 0x1515b
jmp 0x151ff
leaq 0x23b42(%rip), %rdi     # 0x38d3a
movb $0x0, %al
callq 0x8c60
jmp 0x15201
leaq 0x2167d(%rip), %rdi     # 0x36885
movb $0x0, %al
callq 0x8c60
addq $0x12d0, %rsp           # imm = 0x12D0
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: print_thinking_output(move_line*, int, int, int, unsigned long long)
void print_thinking_output(move_line* line,int32 depth,int32 score,int32 start_time,uint64 nodes) {
    assert(line);
    assert(line->n > 0);

    char buffer[1024];
    line_to_str(line,buffer);
    int32 time_centis = (milli_timer() - start_time) / 10;
    print("%2d %5d %5d %7llu %s\n",depth,score,time_centis,nodes,buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x152e5
jmp 0x15304
leaq 0x239b8(%rip), %rdi     # 0x38ca4
leaq 0x23a67(%rip), %rsi     # 0x38d5a
movl $0x42, %edx
leaq 0x23a6a(%rip), %rcx     # 0x38d69
callq 0x20c0
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x1530f
jmp 0x1532e
leaq 0x23a98(%rip), %rdi     # 0x38dae
leaq 0x23a3d(%rip), %rsi     # 0x38d5a
movl $0x43, %edx
leaq 0x23a40(%rip), %rcx     # 0x38d69
callq 0x20c0
movq -0x8(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x14270
callq 0x14080
subl -0x14(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x424(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x424(%rbp), %ecx
movq -0x20(%rbp), %r8
leaq -0x420(%rbp), %r9
leaq 0x23a48(%rip), %rdi     # 0x38dba
movb $0x0, %al
callq 0x8c60
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: print_result(game_status)
void print_result(game_status gs) {
    if (gs==CHECKMATED) {
        if (gpos.player==WHITE) {
            print("RESULT 0-1 {Black mates}\n");
        } else {
            print("RESULT 1-0 {White mates}\n");
        }
    } else if (gs==STALEMATED) {
        print("RESULT 1/2-1/2 {Stalemate}\n");
    } else if (gs==DRAW_MATERIAL) {
        print("RESULT 1/2-1/2 {Draw by lack of mating material}\n");
    } else if (gs==DRAW_BY_50) {
        print("RESULT 1/2-1/2 {Draw by 50 move rule}\n");
    } else if (gs==DRAW_REP) {
        print("RESULT 1/2-1/2 {Draw by repetition}\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0x153d1
leaq 0xbe738(%rip), %rax     # 0xd3ae0
cmpl $0x1, 0x138(%rax)
jne 0x153c1
leaq 0x23a18(%rip), %rdi     # 0x38dd0
movb $0x0, %al
callq 0x8c60
jmp 0x153cf
leaq 0x23a22(%rip), %rdi     # 0x38dea
movb $0x0, %al
callq 0x8c60
jmp 0x1542f
cmpl $0x2, -0x4(%rbp)
jne 0x153e7
leaq 0x23a26(%rip), %rdi     # 0x38e04
movb $0x0, %al
callq 0x8c60
jmp 0x1542d
cmpl $0x3, -0x4(%rbp)
jne 0x153fd
leaq 0x23a2c(%rip), %rdi     # 0x38e20
movb $0x0, %al
callq 0x8c60
jmp 0x1542b
cmpl $0x4, -0x4(%rbp)
jne 0x15413
leaq 0x23a48(%rip), %rdi     # 0x38e52
movb $0x0, %al
callq 0x8c60
jmp 0x15429
cmpl $0x5, -0x4(%rbp)
jne 0x15427
leaq 0x23a59(%rip), %rdi     # 0x38e79
movb $0x0, %al
callq 0x8c60
jmp 0x15429
jmp 0x1542b
jmp 0x1542d
jmp 0x1542f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: think_and_make_move()
void think_and_make_move() {
    // check if game is over before we even get started.
    game_status gs = get_game_status();
    if (gs != INPROGRESS) {
        print_result(gs);
        return;
    }

    think();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x14e20
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x15460
movl -0x4(%rbp), %edi
callq 0x15390
jmp 0x15465
callq 0x13160
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: handle_level()
void handle_level() {
    char mps[10],base[10];
    if (scanf("%s",mps)==EOF) return;
    if (scanf("%s",base)==EOF) return;
    float f_inc = 0.0;
    if (scanf("%f",&f_inc)==EOF) return;
    int32 my_increment = (int32)(f_inc * 1000); // convert to ms
    printd("# increment: %d\n",my_increment);
    set_increment(my_increment);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0xa(%rbp), %rsi
leaq 0x23144(%rip), %rdi     # 0x38607
movb $0x0, %al
callq 0x2190
cmpl $-0x1, %eax
jne 0x154d1
jmp 0x15538
leaq -0x14(%rbp), %rsi
leaq 0x2312b(%rip), %rdi     # 0x38607
movb $0x0, %al
callq 0x2190
cmpl $-0x1, %eax
jne 0x154ea
jmp 0x15538
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
leaq 0x239a5(%rip), %rdi     # 0x38e9e
leaq -0x18(%rbp), %rsi
movb $0x0, %al
callq 0x2190
cmpl $-0x1, %eax
jne 0x1550b
jmp 0x15538
movss 0x23801(%rip), %xmm0    # 0x38d14
mulss -0x18(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
leaq 0x23978(%rip), %rdi     # 0x38ea1
movb $0x0, %al
callq 0x8db0
movl -0x1c(%rbp), %edi
callq 0x12ff0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: handle_memory()
void handle_memory() {
    int32 mem_in_mb;
    if (scanf("%d",&mem_in_mb)==EOF) return;

    printd("# received memory command, N=%d\n",mem_in_mb);
    if (mem_in_mb != last_mem_in_mb) {
        free(htbl.tblptr);
        free(phtbl.tblptr);

        uint32 total_hash_size = mem_in_mb * 1024 * 1024; // convert to bytes

        init_hash_table(&htbl,total_hash_size / 2);
        init_hash_table(&phtbl,total_hash_size / 2);

        last_mem_in_mb = mem_in_mb;
    } else {
        printd("# memory usage hasn't changed, skipping free/malloc\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x23963(%rip), %rdi     # 0x38eb2
leaq -0x4(%rbp), %rsi
movb $0x0, %al
callq 0x2190
cmpl $-0x1, %eax
jne 0x15564
jmp 0x155e5
movl -0x4(%rbp), %esi
leaq 0x23947(%rip), %rdi     # 0x38eb5
movb $0x0, %al
callq 0x8db0
movl -0x4(%rbp), %eax
cmpl 0x8ab9d6(%rip), %eax    # 0x8c0f54
je 0x155d7
leaq 0xedb29(%rip), %rax     # 0x1030b0
movq (%rax), %rdi
callq 0x21e0
leaq 0xedb4a(%rip), %rax     # 0x1030e0
movq (%rax), %rdi
callq 0x21e0
movl -0x4(%rbp), %eax
shll $0xa, %eax
shll $0xa, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %esi
shrl %esi
leaq 0xedafa(%rip), %rdi     # 0x1030b0
callq 0x87f0
movl -0x8(%rbp), %esi
shrl %esi
leaq 0xedb19(%rip), %rdi     # 0x1030e0
callq 0x87f0
movl -0x4(%rbp), %eax
movl %eax, 0x8ab97f(%rip)    # 0x8c0f54
jmp 0x155e5
leaq 0x238f8(%rip), %rdi     # 0x38ed6
movb $0x0, %al
callq 0x8db0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: handle_new()
void handle_new() {
    stop_search_thread();
    force_mode = false;
    reset_pos(&gpos);
    set_max_depth(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x15290
movb $0x0, 0x37d50(%rip)     # 0x4d370
leaq 0xbe4b9(%rip), %rdi     # 0xd3ae0
callq 0xf390
xorl %edi, %edi
callq 0x13010
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: handle_perft()
void handle_perft() {
    draw_board(&gpos);
    int max_depth;
    if (scanf("%d",&max_depth) != EOF) {
        int32 start = milli_timer();
        uint64 nodes=perft_iterate(max_depth);
        int32 end = milli_timer();
        if (end==start) end = start+1;
        print("\n# nodes: %lu\n",nodes);
        print("# elapsed time: %d ms\n",end-start);
        print("# rate: %.2f n/s\n\n",nodes*1000.0/(end-start));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xbe451(%rip), %rdi     # 0xd3ae0
callq 0x64e0
leaq 0x23817(%rip), %rdi     # 0x38eb2
leaq -0x4(%rbp), %rsi
movb $0x0, %al
callq 0x2190
cmpl $-0x1, %eax
je 0x15757
callq 0x14080
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0xd9a0
movq %rax, -0x10(%rbp)
callq 0x14080
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x156dc
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x23824(%rip), %rdi     # 0x38f0b
xorl %eax, %eax
movb %al, -0x15(%rbp)
callq 0x8c60
movb -0x15(%rbp), %al
movl -0x14(%rbp), %esi
movl -0x8(%rbp), %ecx
subl %ecx, %esi
leaq 0x23817(%rip), %rdi     # 0x38f1a
callq 0x8c60
movaps 0x23051(%rip), %xmm1    # 0x38760
movq -0x10(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x23050(%rip), %xmm1    # 0x38770
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x23019(%rip), %xmm1    # 0x38750
mulsd %xmm1, %xmm0
movl -0x14(%rbp), %eax
subl -0x8(%rbp), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
leaq 0x237e1(%rip), %rdi     # 0x38f31
movb $0x1, %al
callq 0x8c60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: handle_ping()
void handle_ping() {
    if (!is_pondering()) {
        stop_search_thread();
    }
    int n;
    if (scanf("%d",&n) != EOF) {
        print("pong %d\n",n);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x13090
testb $0x1, %al
jne 0x157c6
callq 0x15290
leaq 0x236e5(%rip), %rdi     # 0x38eb2
leaq -0x4(%rbp), %rsi
movb $0x0, %al
callq 0x2190
cmpl $-0x1, %eax
je 0x157ee
movl -0x4(%rbp), %esi
leaq 0x2375d(%rip), %rdi     # 0x38f44
movb $0x0, %al
callq 0x8c60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: handle_probe_book()
void handle_probe_book() {
    move mv = probe_book(&gpos);
    if (mv==0) {
        print("no move found.\n");
    } else {
        print_move(mv);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xbe2c1(%rip), %rdi     # 0xd3ae0
callq 0x5c50
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1583f
leaq 0x23717(%rip), %rdi     # 0x38f4d
movb $0x0, %al
callq 0x8c60
jmp 0x15848
movq -0x8(%rbp), %rdi
callq 0x14ed0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: handle_protover()
void handle_protover() {
    int version;
    if (scanf("%d",&version) != EOF) {
        if (version < 2) {
            error("protover >= 2 expected.\n");
            exit(0);
        }

        print("feature analyze=0 black=0 colors=0 cores=0 ping=1 draw=0 debug=1 edit=0 ics=1\n");
        print("feature level=0 name=1 nps=0 memory=1 playother=1 pause=0 resume=0 reuse=1 san=0\n");
        print("feature setboard=1 sigint=0 sigterm=0 smp=0 st=0 time=1 usermove=1\n");
        print("feature white=0 variants=\"normal\"\n");
        print("feature done=1\n"); // must be last
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x23653(%rip), %rdi     # 0x38eb2
leaq -0x4(%rbp), %rsi
movb $0x0, %al
callq 0x2190
cmpl $-0x1, %eax
je 0x158d0
cmpl $0x2, -0x4(%rbp)
jge 0x1588a
leaq 0x236e1(%rip), %rdi     # 0x38f5d
movb $0x0, %al
callq 0x8f00
xorl %edi, %edi
callq 0x21f0
leaq 0x236e5(%rip), %rdi     # 0x38f76
movb $0x0, %al
callq 0x8c60
leaq 0x23726(%rip), %rdi     # 0x38fc5
movb $0x0, %al
callq 0x8c60
leaq 0x2376a(%rip), %rdi     # 0x39017
movb $0x0, %al
callq 0x8c60
leaq 0x237a0(%rip), %rdi     # 0x3905b
movb $0x0, %al
callq 0x8c60
leaq 0x237b5(%rip), %rdi     # 0x3907e
movb $0x0, %al
callq 0x8c60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: handle_quit()
void handle_quit() {
    stop_search_thread();
    if (book_db != 0) {
        sqlite3_close(book_db);
    }
    free(htbl.tblptr);
    free(phtbl.tblptr);

    print("bye...\n");
    exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x15290
leaq 0xba1e8(%rip), %rax     # 0xcfad8
cmpq $0x0, (%rax)
je 0x15905
leaq 0xba1db(%rip), %rax     # 0xcfad8
movq (%rax), %rdi
callq 0x20a0
leaq 0xed7a4(%rip), %rax     # 0x1030b0
movq (%rax), %rdi
callq 0x21e0
leaq 0xed7c5(%rip), %rax     # 0x1030e0
movq (%rax), %rdi
callq 0x21e0
leaq 0x23764(%rip), %rdi     # 0x3908e
movb $0x0, %al
callq 0x8c60
xorl %edi, %edi
callq 0x21f0
nopl (%rax,%rax)
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: handle_result()
void handle_result() {
    stop_search_thread();
    char result[10],text[100],comment[100];
    if (scanf("%s",result)==EOF) return;
    comment[0]='\0';
    do {
        if (scanf("%s",text)==EOF) return; // the reason the game is over {bla bla}
        if (strlen(comment)>0) strcat(comment," ");
        strcat(comment,text);
    } while (!strchr(text,'}') && strlen(comment) < 50);
    print("# RESULT: %s\n",result);
    print("# COMMENT: %s\n",comment);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
callq 0x15290
leaq -0xa(%rbp), %rsi
leaq 0x22c2c(%rip), %rdi     # 0x38607
movb $0x0, %al
callq 0x2190
cmpl $-0x1, %eax
jne 0x159ec
jmp 0x15ab1
movb $0x0, -0xe0(%rbp)
leaq -0x70(%rbp), %rsi
leaq 0x22c09(%rip), %rdi     # 0x38607
movb $0x0, %al
callq 0x2190
cmpl $-0x1, %eax
jne 0x15a0f
jmp 0x15ab1
leaq -0xe0(%rbp), %rdi
callq 0x2080
cmpq $0x0, %rax
jbe 0x15a34
leaq -0xe0(%rbp), %rdi
leaq 0x22cd6(%rip), %rsi     # 0x38705
callq 0x22f0
leaq -0xe0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x22f0
leaq -0x70(%rbp), %rdi
movl $0x7d, %esi
callq 0x2070
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0xe1(%rbp)
jne 0x15a7c
leaq -0xe0(%rbp), %rdi
callq 0x2080
cmpq $0x32, %rax
setb %al
movb %al, -0xe1(%rbp)
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0x159f3
leaq -0xa(%rbp), %rsi
leaq 0x23601(%rip), %rdi     # 0x39096
movb $0x0, %al
callq 0x8c60
leaq -0xe0(%rbp), %rsi
leaq 0x235fa(%rip), %rdi     # 0x390a4
movb $0x0, %al
callq 0x8c60
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: handle_sd()
void handle_sd() {
    int32 my_max_depth;
    if (scanf("%d",&my_max_depth)==EOF) return;
    printd("# MAX DEPTH: %d\n",my_max_depth);
    set_max_depth(my_max_depth);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x233e3(%rip), %rdi     # 0x38eb2
leaq -0x4(%rbp), %rsi
movb $0x0, %al
callq 0x2190
cmpl $-0x1, %eax
jne 0x15ae1
jmp 0x15afa
movl -0x4(%rbp), %esi
leaq 0x235c8(%rip), %rdi     # 0x390b3
movb $0x0, %al
callq 0x8db0
movl -0x4(%rbp), %edi
callq 0x13010
addq $0x10, %rsp
popq %rbp
retq
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: handle_setboard()
void handle_setboard() {
    char fen[255];
    if (!fgets(fen, 255, stdin)) {
        return;
    }
    printd("# SETBOARD FEN: %s\n",fen);
    if (!set_pos(&gpos,fen)) {
        print("tellusererror illegal position\n");
    }
    draw_board(&gpos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
leaq -0x100(%rbp), %rdi
movq 0x374b7(%rip), %rax     # 0x4cfd0
movq (%rax), %rdx
movl $0xff, %esi
callq 0x22d0
cmpq $0x0, %rax
jne 0x15b2e
jmp 0x15b74
leaq -0x100(%rbp), %rsi
leaq 0x23588(%rip), %rdi     # 0x390c4
movb $0x0, %al
callq 0x8db0
leaq -0x100(%rbp), %rsi
leaq 0xbdf8f(%rip), %rdi     # 0xd3ae0
callq 0xf3e0
testb $0x1, %al
jne 0x15b68
leaq 0x23577(%rip), %rdi     # 0x390d8
movb $0x0, %al
callq 0x8c60
leaq 0xbdf71(%rip), %rdi     # 0xd3ae0
callq 0x64e0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: handle_time()
void handle_time() {
    int32 my_time_remaining;
    if (scanf("%d",&my_time_remaining)==EOF) return;
    my_time_remaining *= 10; // centiseconds to milliseconds
    printd("# TIME REMAINING: %d\n",my_time_remaining);
    set_time_remaining(my_time_remaining);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x23323(%rip), %rdi     # 0x38eb2
leaq -0x4(%rbp), %rsi
movb $0x0, %al
callq 0x2190
cmpl $-0x1, %eax
jne 0x15ba1
jmp 0x15bc1
imull $0xa, -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %esi
leaq 0x23546(%rip), %rdi     # 0x390f8
movb $0x0, %al
callq 0x8db0
movl -0x4(%rbp), %edi
callq 0x12fd0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jswaff[P]prophet3/src/xboard.cpp
// Function: parse_command(char const*)
void parse_command(const char *cmd) {

    last_input_time = milli_timer();
    printd("# RECEIVED: %s\n",cmd);

    int len=sizeof(function_table)/sizeof(function_table_entry);

    for (int i=0;i<len;i++) {
        function_table_entry fte = function_table[i];
        if (strcmp(cmd,fte.name)==0) {
            fte.func();
            return;
        }
    }

    print("Error (unknown command): %s\n",cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x14080
movl %eax, 0x8ab179(%rip)    # 0x8c0f50
movq -0x8(%rbp), %rsi
leaq 0x234dc(%rip), %rdi     # 0x392be
movb $0x0, %al
callq 0x8db0
movl $0x2c, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x15e44
movslq -0x10(%rbp), %rcx
leaq 0x37576(%rip), %rax     # 0x4d380
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2260
cmpl $0x0, %eax
jne 0x15e37
callq *-0x18(%rbp)
jmp 0x15e56
jmp 0x15e39
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x15df7
movq -0x8(%rbp), %rsi
leaq 0x2347f(%rip), %rdi     # 0x392ce
movb $0x0, %al
callq 0x8c60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jswaff[P]prophet3/test/apply__test.cpp
// Function: test_undo_double_pawn_push()
void test_undo_double_pawn_push() {
    position pos;
    reset_pos(&pos);

    position save_pos;
    memcpy(&save_pos,&pos,sizeof(position));

    move mv = to_move(PAWN,E2,E4);
    apply_move(&pos,mv,gundos);

    undo_last_move(&pos,gundos);
    assert(equal_pos(&pos,&save_pos,true));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3a0, %rsp            # imm = 0x3A0
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq -0x390(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1c8, %edx            # imm = 0x1C8
callq 0x20f0
movl $0x1, %edi
movl $0x34, %esi
movl $0x24, %edx
callq 0xa830
movq %rax, -0x398(%rbp)
movq -0x398(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xbd4d1(%rip), %rdx     # 0xd3cb0
callq 0x3620
leaq -0x1c8(%rbp), %rdi
leaq 0xbd4be(%rip), %rsi     # 0xd3cb0
callq 0x39a0
leaq -0x1c8(%rbp), %rdi
leaq -0x390(%rbp), %rsi
movl $0x1, %edx
callq 0xe490
testb $0x1, %al
jne 0x16815
jmp 0x16817
jmp 0x16836
leaq 0x22ef2(%rip), %rdi     # 0x39710
leaq 0x22b02(%rip), %rsi     # 0x39327
movl $0x85, %edx
leaq 0x22efe(%rip), %rcx     # 0x3972f
callq 0x20c0
addq $0x3a0, %rsp            # imm = 0x3A0
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/apply__test.cpp
// Function: test_undo_capturing_promotion()
void test_undo_capturing_promotion() {
    position pos;
    set_pos(&pos,"r7/1PK5/8/8/k7/8/8/8 w - -");

    position save_pos;
    memcpy(&save_pos,&pos,sizeof(position));

    move mv = to_capture(PAWN,B7,A8,ROOK);
    set_promopiece(&mv,QUEEN);
    apply_move(&pos,mv,gundos);

    undo_last_move(&pos,gundos);
    assert(equal_pos(&pos,&save_pos,true));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3a0, %rsp            # imm = 0x3A0
leaq -0x1c8(%rbp), %rdi
leaq 0x22ef8(%rip), %rsi     # 0x39751
callq 0xf3e0
leaq -0x390(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1c8, %edx            # imm = 0x1C8
callq 0x20f0
movl $0x1, %edi
movl $0x9, %esi
xorl %edx, %edx
movl $0x4, %ecx
callq 0xa890
movq %rax, -0x398(%rbp)
leaq -0x398(%rbp), %rdi
movl $0x5, %esi
callq 0xa9e0
movq -0x398(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xbd3f7(%rip), %rdx     # 0xd3cb0
callq 0x3620
leaq -0x1c8(%rbp), %rdi
leaq 0xbd3e4(%rip), %rsi     # 0xd3cb0
callq 0x39a0
leaq -0x1c8(%rbp), %rdi
leaq -0x390(%rbp), %rsi
movl $0x1, %edx
callq 0xe490
testb $0x1, %al
jne 0x168ef
jmp 0x168f1
jmp 0x16910
leaq 0x22e18(%rip), %rdi     # 0x39710
leaq 0x22a28(%rip), %rsi     # 0x39327
movl $0x94, %edx
leaq 0x22e61(%rip), %rcx     # 0x3976c
callq 0x20c0
addq $0x3a0, %rsp            # imm = 0x3A0
popq %rbp
retq
nopl (%rax)
// File: jswaff[P]prophet3/test/apply__test.cpp
// Function: test_undo_epcapture()
void test_undo_epcapture() {
    position pos;
    set_pos(&pos,"k7/8/8/8/pP6/8/K7/8 b - b3");

    position save_pos;
    memcpy(&save_pos,&pos,sizeof(position));

    move mv = to_capture(PAWN,A4,B3,PAWN);
    set_epcapture(&mv);
    apply_move(&pos,mv,gundos);

    undo_last_move(&pos,gundos);
    assert(equal_pos(&pos,&save_pos,true));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3a0, %rsp            # imm = 0x3A0
leaq -0x1c8(%rbp), %rdi
leaq 0x22e58(%rip), %rsi     # 0x39791
callq 0xf3e0
leaq -0x390(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1c8, %edx            # imm = 0x1C8
callq 0x20f0
movl $0x1, %ecx
movl $0x20, %esi
movl $0x29, %edx
movl %ecx, %edi
callq 0xa890
movq %rax, -0x398(%rbp)
leaq -0x398(%rbp), %rdi
callq 0xaa20
movq -0x398(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xbd31c(%rip), %rdx     # 0xd3cb0
callq 0x3620
leaq -0x1c8(%rbp), %rdi
leaq 0xbd309(%rip), %rsi     # 0xd3cb0
callq 0x39a0
leaq -0x1c8(%rbp), %rdi
leaq -0x390(%rbp), %rsi
movl $0x1, %edx
callq 0xe490
testb $0x1, %al
jne 0x169ca
jmp 0x169cc
jmp 0x169eb
leaq 0x22d3d(%rip), %rdi     # 0x39710
leaq 0x2294d(%rip), %rsi     # 0x39327
movl $0xa3, %edx
leaq 0x22dc6(%rip), %rcx     # 0x397ac
callq 0x20c0
addq $0x3a0, %rsp            # imm = 0x3A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/apply__test.cpp
// Function: test_undo_castle()
void test_undo_castle() {
    position pos;
    set_pos(&pos,"k7/8/8/8/8/8/8/4K2R w K -");

    position save_pos;
    memcpy(&save_pos,&pos,sizeof(position));

    move mv = to_move(KING,E1,G1);
    set_castle(&mv);
    apply_move(&pos,mv,gundos);

    undo_last_move(&pos,gundos);
    assert(equal_pos(&pos,&save_pos,true));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3a0, %rsp            # imm = 0x3A0
leaq -0x1c8(%rbp), %rdi
leaq 0x22dae(%rip), %rsi     # 0x397c7
callq 0xf3e0
leaq -0x390(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
movl $0x1c8, %edx            # imm = 0x1C8
callq 0x20f0
movl $0x6, %edi
movl $0x3c, %esi
movl $0x3e, %edx
callq 0xa830
movq %rax, -0x398(%rbp)
leaq -0x398(%rbp), %rdi
callq 0xaa60
movq -0x398(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
leaq 0xbd23e(%rip), %rdx     # 0xd3cb0
callq 0x3620
leaq -0x1c8(%rbp), %rdi
leaq 0xbd22b(%rip), %rsi     # 0xd3cb0
callq 0x39a0
leaq -0x1c8(%rbp), %rdi
leaq -0x390(%rbp), %rsi
movl $0x1, %edx
callq 0xe490
testb $0x1, %al
jne 0x16aa8
jmp 0x16aaa
jmp 0x16ac9
leaq 0x22c5f(%rip), %rdi     # 0x39710
leaq 0x2286f(%rip), %rsi     # 0x39327
movl $0xb2, %edx
leaq 0x22d1d(%rip), %rcx     # 0x397e1
callq 0x20c0
addq $0x3a0, %rsp            # imm = 0x3A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/apply__test.cpp
// Function: test_apply()
void test_apply() {
    test_apply_move();
    test_undo_double_pawn_push();
    test_undo_capturing_promotion();
    test_undo_epcapture();
    test_undo_castle();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x15e60
callq 0x16780
callq 0x16840
callq 0x16920
callq 0x16a00
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/attack__test.cpp
// Function: test_attacked_by_king()
void test_attacked_by_king() {
    position pos;
    set_pos(&pos,"3k4/8/8/3n4/3K4/8/8/8 w - - 0 1");

    uint64 white_map=0,black_map=0;
    for (int32 sq=A8;sq<=H1;sq++) {
        if (attacked_by_king(&pos,(square_t)sq,WHITE)) {
            white_map |= bb_squares[sq];
        }

        if (attacked_by_king(&pos,(square_t)sq,BLACK)) {
            black_map |= bb_squares[sq];
        }
    }
    assert(white_map==(bb_squares[C5] | bb_squares[D5] | bb_squares[E5]
                     | bb_squares[C4] | bb_squares[E4] | bb_squares[C3]
                     | bb_squares[D3] | bb_squares[E3]));


    assert(black_map==(bb_squares[C8] | bb_squares[E8] | bb_squares[C7]
                     | bb_squares[D7] | bb_squares[E7]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x22c3d(%rip), %rsi     # 0x39976
callq 0xf3e0
movq $0x0, -0x1d0(%rbp)
movq $0x0, -0x1d8(%rbp)
movl $0x0, -0x1dc(%rbp)
cmpl $0x3f, -0x1dc(%rbp)
jg 0x16df8
movl -0x1dc(%rbp), %esi
leaq -0x1c8(%rbp), %rdi
movl $0x1, %edx
callq 0x3ff0
testb $0x1, %al
jne 0x16d88
jmp 0x16da8
movslq -0x1dc(%rbp), %rcx
leaq 0xee8da(%rip), %rax     # 0x105670
movq (%rax,%rcx,8), %rax
orq -0x1d0(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movl -0x1dc(%rbp), %esi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x3ff0
testb $0x1, %al
jne 0x16dc2
jmp 0x16de2
movslq -0x1dc(%rbp), %rcx
leaq 0xee8a0(%rip), %rax     # 0x105670
movq (%rax,%rcx,8), %rax
orq -0x1d8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
jmp 0x16de4
movl -0x1dc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1dc(%rbp)
jmp 0x16d5e
movq -0x1d0(%rbp), %rax
leaq 0xee86a(%rip), %rcx     # 0x105670
movq 0xd0(%rcx), %rcx
leaq 0xee85c(%rip), %rdx     # 0x105670
orq 0xd8(%rdx), %rcx
leaq 0xee84e(%rip), %rdx     # 0x105670
orq 0xe0(%rdx), %rcx
leaq 0xee840(%rip), %rdx     # 0x105670
orq 0x110(%rdx), %rcx
leaq 0xee832(%rip), %rdx     # 0x105670
orq 0x120(%rdx), %rcx
leaq 0xee824(%rip), %rdx     # 0x105670
orq 0x150(%rdx), %rcx
leaq 0xee816(%rip), %rdx     # 0x105670
orq 0x158(%rdx), %rcx
leaq 0xee808(%rip), %rdx     # 0x105670
orq 0x160(%rdx), %rcx
cmpq %rcx, %rax
jne 0x16e76
jmp 0x16e95
leaq 0x22b19(%rip), %rdi     # 0x39996
leaq 0x22a2a(%rip), %rsi     # 0x398ae
movl $0x37, %edx
leaq 0x22b99(%rip), %rcx     # 0x39a29
callq 0x20c0
movq -0x1d8(%rbp), %rax
leaq 0xee7cd(%rip), %rcx     # 0x105670
movq 0x10(%rcx), %rcx
leaq 0xee7c2(%rip), %rdx     # 0x105670
orq 0x20(%rdx), %rcx
leaq 0xee7b7(%rip), %rdx     # 0x105670
orq 0x50(%rdx), %rcx
leaq 0xee7ac(%rip), %rdx     # 0x105670
orq 0x58(%rdx), %rcx
leaq 0xee7a1(%rip), %rdx     # 0x105670
orq 0x60(%rdx), %rcx
cmpq %rcx, %rax
jne 0x16eda
jmp 0x16ef9
leaq 0x22b65(%rip), %rdi     # 0x39a46
leaq 0x229c6(%rip), %rsi     # 0x398ae
movl $0x3b, %edx
leaq 0x22b35(%rip), %rcx     # 0x39a29
callq 0x20c0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/attack__test.cpp
// Function: test_attacked_by_pawn()
void test_attacked_by_pawn() {
    position pos;
    set_pos(&pos,"3k4/8/8/3p4/3P3P/8/8/3K4 w - - 0 1");

    for (int32 sq=A8;sq<=H1;sq++) {
        assert(attacked_by_pawn(&pos,(square_t)sq,WHITE)==
                (sq==C5 || sq==E5 || sq==G5));

        assert(attacked_by_pawn(&pos,(square_t)sq,BLACK)==
                (sq==C4 || sq==E4));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x22b7d(%rip), %rsi     # 0x39aa6
callq 0xf3e0
movl $0x0, -0x1cc(%rbp)
cmpl $0x3f, -0x1cc(%rbp)
jg 0x1705d
movl -0x1cc(%rbp), %esi
leaq -0x1c8(%rbp), %rdi
movl $0x1, %edx
callq 0x4260
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1d4(%rbp)
movb $0x1, %al
cmpl $0x1a, -0x1cc(%rbp)
movb %al, -0x1cd(%rbp)
je 0x16f99
movb $0x1, %al
cmpl $0x1c, -0x1cc(%rbp)
movb %al, -0x1cd(%rbp)
je 0x16f99
cmpl $0x1e, -0x1cc(%rbp)
sete %al
movb %al, -0x1cd(%rbp)
movl -0x1d4(%rbp), %eax
movb -0x1cd(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x16fb1
jmp 0x16fd0
leaq 0x22b11(%rip), %rdi     # 0x39ac9
leaq 0x228ef(%rip), %rsi     # 0x398ae
movl $0x44, %edx
leaq 0x22b47(%rip), %rcx     # 0x39b12
callq 0x20c0
movl -0x1cc(%rbp), %esi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x4260
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1dc(%rbp)
movb $0x1, %al
cmpl $0x22, -0x1cc(%rbp)
movb %al, -0x1d5(%rbp)
je 0x17010
cmpl $0x24, -0x1cc(%rbp)
sete %al
movb %al, -0x1d5(%rbp)
movl -0x1dc(%rbp), %eax
movb -0x1d5(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x17028
jmp 0x17047
leaq 0x22b00(%rip), %rdi     # 0x39b2f
leaq 0x22878(%rip), %rsi     # 0x398ae
movl $0x47, %edx
leaq 0x22ad0(%rip), %rcx     # 0x39b12
callq 0x20c0
jmp 0x17049
movl -0x1cc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1cc(%rbp)
jmp 0x16f38
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/attack__test.cpp
// Function: test_attacked_by_rook()
void test_attacked_by_rook() {
    position pos;
    set_pos(&pos,"8/1r3k2/8/3p4/3P3P/8/1P6/3K4 b - - 0 1");

    uint64 white_map=0,black_map=0;
    for (int32 sq=A8;sq<=H1;sq++) {
        if (attacked_by_rook(&pos,(square_t)sq,WHITE)) {
            white_map |= bb_squares[sq];
        }

        if (attacked_by_rook(&pos,(square_t)sq,BLACK)) {
            black_map |= bb_squares[sq];
        }
    }

    assert(white_map==0);
    assert(black_map==(bb_squares[B8] | bb_squares[A7] | bb_squares[C7]
            | bb_squares[D7] | bb_squares[E7] | bb_squares[F7]
            | bb_squares[B6] | bb_squares[B5] | bb_squares[B4]
            | bb_squares[B3] | bb_squares[B2]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x1c8(%rbp), %rdi
leaq 0x22ae5(%rip), %rsi     # 0x39b6e
callq 0xf3e0
movq $0x0, -0x1d0(%rbp)
movq $0x0, -0x1d8(%rbp)
movl $0x0, -0x1dc(%rbp)
cmpl $0x3f, -0x1dc(%rbp)
jg 0x17148
movl -0x1dc(%rbp), %esi
leaq -0x1c8(%rbp), %rdi
movl $0x1, %edx
callq 0x4110
testb $0x1, %al
jne 0x170d8
jmp 0x170f8
movslq -0x1dc(%rbp), %rcx
leaq 0xee58a(%rip), %rax     # 0x105670
movq (%rax,%rcx,8), %rax
orq -0x1d0(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movl -0x1dc(%rbp), %esi
leaq -0x1c8(%rbp), %rdi
xorl %edx, %edx
callq 0x4110
testb $0x1, %al
jne 0x17112
jmp 0x17132
movslq -0x1dc(%rbp), %rcx
leaq 0xee550(%rip), %rax     # 0x105670
movq (%rax,%rcx,8), %rax
orq -0x1d8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
jmp 0x17134
movl -0x1dc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1dc(%rbp)
jmp 0x170ae
cmpq $0x0, -0x1d0(%rbp)
jne 0x17154
jmp 0x17173
leaq 0x22a3a(%rip), %rdi     # 0x39b95
leaq 0x2274c(%rip), %rsi     # 0x398ae
movl $0x5a, %edx
leaq 0x22a34(%rip), %rcx     # 0x39ba2
callq 0x20c0
movq -0x1d8(%rbp), %rax
leaq 0xee4ef(%rip), %rcx     # 0x105670
movq 0x8(%rcx), %rcx
leaq 0xee4e4(%rip), %rdx     # 0x105670
orq 0x40(%rdx), %rcx
leaq 0xee4d9(%rip), %rdx     # 0x105670
orq 0x50(%rdx), %rcx
leaq 0xee4ce(%rip), %rdx     # 0x105670
orq 0x58(%rdx), %rcx
leaq 0xee4c3(%rip), %rdx     # 0x105670
orq 0x60(%rdx), %rcx
leaq 0xee4b8(%rip), %rdx     # 0x105670
orq 0x68(%rdx), %rcx
leaq 0xee4ad(%rip), %rdx     # 0x105670
orq 0x88(%rdx), %rcx
leaq 0xee49f(%rip), %rdx     # 0x105670
orq 0xc8(%rdx), %rcx
leaq 0xee491(%rip), %rdx     # 0x105670
orq 0x108(%rdx), %rcx
leaq 0xee483(%rip), %rdx     # 0x105670
orq 0x148(%rdx), %rcx
leaq 0xee475(%rip), %rdx     # 0x105670
orq 0x188(%rdx), %rcx
cmpq %rcx, %rax
jne 0x17209
jmp 0x17228
leaq 0x229af(%rip), %rdi     # 0x39bbf
leaq 0x22697(%rip), %rsi     # 0x398ae
movl $0x5e, %edx
leaq 0x2297f(%rip), %rcx     # 0x39ba2
callq 0x20c0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/attack__test.cpp
// Function: test_get_attackers()
void test_get_attackers() {
    position pos;
    set_pos(&pos,"1k1r3q/1ppn3p/p4b2/4p3/8/P2N2P1/1PP1R1BP/2K1Q3 w - -");

    uint64 attackers = get_attackers(&pos,E5,WHITE);

    assert(attackers & bb_squares[D3]);
    assert(attackers & bb_squares[E2]);
    assert(get_num_bits(attackers)==2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x1c8(%rbp), %rdi
leaq 0x22952(%rip), %rsi     # 0x3a1db
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
movl $0x1c, %esi
movl $0x1, %edx
callq 0x4500
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rax
leaq 0xeddb7(%rip), %rcx     # 0x105670
andq 0x158(%rcx), %rax
cmpq $0x0, %rax
je 0x178c8
jmp 0x178e7
leaq 0x22941(%rip), %rdi     # 0x3a210
leaq 0x21fd8(%rip), %rsi     # 0x398ae
movl $0xa1, %edx
leaq 0x22949(%rip), %rcx     # 0x3a22b
callq 0x20c0
movq -0x1d0(%rbp), %rax
leaq 0xedd7b(%rip), %rcx     # 0x105670
andq 0x1a0(%rcx), %rax
cmpq $0x0, %rax
je 0x17904
jmp 0x17923
leaq 0x2293a(%rip), %rdi     # 0x3a245
leaq 0x21f9c(%rip), %rsi     # 0x398ae
movl $0xa2, %edx
leaq 0x2290d(%rip), %rcx     # 0x3a22b
callq 0x20c0
movq -0x1d0(%rbp), %rdi
callq 0x47b0
cmpl $0x2, %eax
jne 0x17936
jmp 0x17955
leaq 0x22923(%rip), %rdi     # 0x3a260
leaq 0x21f6a(%rip), %rsi     # 0x398ae
movl $0xa3, %edx
leaq 0x228db(%rip), %rcx     # 0x3a22b
callq 0x20c0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/attack__test.cpp
// Function: test_get_attackers2()
void test_get_attackers2() {
    position pos;
    set_pos(&pos,"1k1r3q/1ppn3p/p4b2/4p3/8/P2N2P1/1PP1R1BP/2K1Q3 w - -");

    uint64 attackers = get_attackers(&pos,E5,BLACK);

    assert(attackers & bb_squares[D7]);
    assert(attackers & bb_squares[F6]);
    assert(get_num_bits(attackers)==2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x1c8(%rbp), %rdi
leaq 0x22862(%rip), %rsi     # 0x3a1db
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
movl $0x1c, %esi
xorl %edx, %edx
callq 0x4500
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rax
leaq 0xedcca(%rip), %rcx     # 0x105670
andq 0x58(%rcx), %rax
cmpq $0x0, %rax
je 0x179b2
jmp 0x179d1
leaq 0x228c2(%rip), %rdi     # 0x3a27b
leaq 0x21eee(%rip), %rsi     # 0x398ae
movl $0xac, %edx
leaq 0x228ca(%rip), %rcx     # 0x3a296
callq 0x20c0
movq -0x1d0(%rbp), %rax
leaq 0xedc91(%rip), %rcx     # 0x105670
andq 0xa8(%rcx), %rax
cmpq $0x0, %rax
je 0x179ee
jmp 0x17a0d
leaq 0x228bc(%rip), %rdi     # 0x3a2b1
leaq 0x21eb2(%rip), %rsi     # 0x398ae
movl $0xad, %edx
leaq 0x2288e(%rip), %rcx     # 0x3a296
callq 0x20c0
movq -0x1d0(%rbp), %rdi
callq 0x47b0
cmpl $0x2, %eax
jne 0x17a20
jmp 0x17a3f
leaq 0x22839(%rip), %rdi     # 0x3a260
leaq 0x21e80(%rip), %rsi     # 0x398ae
movl $0xae, %edx
leaq 0x2285c(%rip), %rcx     # 0x3a296
callq 0x20c0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/test/attack__test.cpp
// Function: test_get_attackers3()
void test_get_attackers3() {
    position pos;
    set_pos(&pos,"8/p1k5/1p6/8/3b4/1Q6/8/7K w - -");

    uint64 attackers = get_attackers(&pos,B6,WHITE);

    assert(attackers & bb_squares[B3]);
    assert(get_num_bits(attackers)==1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x1c8(%rbp), %rdi
leaq 0x22863(%rip), %rsi     # 0x3a2cc
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
movl $0x11, %esi
movl $0x1, %edx
callq 0x4500
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rax
leaq 0xedbd7(%rip), %rcx     # 0x105670
andq 0x148(%rcx), %rax
cmpq $0x0, %rax
je 0x17aa8
jmp 0x17ac7
leaq 0x2283d(%rip), %rdi     # 0x3a2ec
leaq 0x21df8(%rip), %rsi     # 0x398ae
movl $0xb7, %edx
leaq 0x22845(%rip), %rcx     # 0x3a307
callq 0x20c0
movq -0x1d0(%rbp), %rdi
callq 0x47b0
cmpl $0x1, %eax
jne 0x17ada
jmp 0x17af9
leaq 0x22841(%rip), %rdi     # 0x3a322
leaq 0x21dc6(%rip), %rsi     # 0x398ae
movl $0xb8, %edx
leaq 0x22813(%rip), %rcx     # 0x3a307
callq 0x20c0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/attack__test.cpp
// Function: test_get_attackers4()
void test_get_attackers4() {
    position pos;
    set_pos(&pos,"8/p1k5/1p6/8/3b4/1Q6/8/7K w - -");

    uint64 attackers = get_attackers(&pos,B6,BLACK);

    assert(attackers & bb_squares[C7]);
    assert(attackers & bb_squares[A7]);
    assert(attackers & bb_squares[D4]);
    assert(get_num_bits(attackers)==3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x1c8(%rbp), %rdi
leaq 0x227a3(%rip), %rsi     # 0x3a2cc
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
movl $0x11, %esi
xorl %edx, %edx
callq 0x4500
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rax
leaq 0xedb1a(%rip), %rcx     # 0x105670
andq 0x50(%rcx), %rax
cmpq $0x0, %rax
je 0x17b62
jmp 0x17b81
leaq 0x227d4(%rip), %rdi     # 0x3a33d
leaq 0x21d3e(%rip), %rsi     # 0x398ae
movl $0xc1, %edx
leaq 0x227dc(%rip), %rcx     # 0x3a358
callq 0x20c0
movq -0x1d0(%rbp), %rax
leaq 0xedae1(%rip), %rcx     # 0x105670
andq 0x40(%rcx), %rax
cmpq $0x0, %rax
je 0x17b9b
jmp 0x17bba
leaq 0x227d1(%rip), %rdi     # 0x3a373
leaq 0x21d05(%rip), %rsi     # 0x398ae
movl $0xc2, %edx
leaq 0x227a3(%rip), %rcx     # 0x3a358
callq 0x20c0
movq -0x1d0(%rbp), %rax
leaq 0xedaa8(%rip), %rcx     # 0x105670
andq 0x118(%rcx), %rax
cmpq $0x0, %rax
je 0x17bd7
jmp 0x17bf6
leaq 0x227b0(%rip), %rdi     # 0x3a38e
leaq 0x21cc9(%rip), %rsi     # 0x398ae
movl $0xc3, %edx
leaq 0x22767(%rip), %rcx     # 0x3a358
callq 0x20c0
movq -0x1d0(%rbp), %rdi
callq 0x47b0
cmpl $0x3, %eax
jne 0x17c09
jmp 0x17c28
leaq 0x22799(%rip), %rdi     # 0x3a3a9
leaq 0x21c97(%rip), %rsi     # 0x398ae
movl $0xc4, %edx
leaq 0x22735(%rip), %rcx     # 0x3a358
callq 0x20c0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/attack__test.cpp
// Function: test_attack()
void test_attack() {
    test_attacked_by_knight();
    test_attacked_by_king();
    test_attacked_by_pawn();
    test_attacked_by_rook();
    test_attacked_by_bishop();
    test_attacked_by_queen();
    test_get_attackers();
    test_get_attackers2();
    test_get_attackers3();
    test_get_attackers4();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x16b00
callq 0x16d20
callq 0x16f10
callq 0x17070
callq 0x17240
callq 0x174c0
callq 0x17870
callq 0x17960
callq 0x17a50
callq 0x17b10
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/test/bitboards__test.cpp
// Function: test_isolate_lsb_bit()
void test_isolate_lsb_bit() {
    uint64 mask = bb_squares[A8] | bb_squares[E4] | bb_squares[F4] | bb_squares[D1];

    assert(isolate_lsb_bit(mask,0)==bb_squares[A8]);
    assert(isolate_lsb_bit(mask,1)==bb_squares[E4]);
    assert(isolate_lsb_bit(mask,2)==bb_squares[F4]);
    assert(isolate_lsb_bit(mask,3)==bb_squares[D1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xed861(%rip), %rax     # 0x105670
movq (%rax), %rax
leaq 0xed857(%rip), %rcx     # 0x105670
orq 0x120(%rcx), %rax
leaq 0xed849(%rip), %rcx     # 0x105670
orq 0x128(%rcx), %rax
leaq 0xed83b(%rip), %rcx     # 0x105670
orq 0x1d8(%rcx), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4b00
leaq 0xed81e(%rip), %rcx     # 0x105670
cmpq (%rcx), %rax
jne 0x17e59
jmp 0x17e78
leaq 0x22674(%rip), %rdi     # 0x3a4d4
leaq 0x2257d(%rip), %rsi     # 0x3a3e4
movl $0x1e, %edx
leaq 0x22689(%rip), %rcx     # 0x3a4fc
callq 0x20c0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x4b00
leaq 0xed7e3(%rip), %rcx     # 0x105670
cmpq 0x120(%rcx), %rax
jne 0x17e98
jmp 0x17eb7
leaq 0x22679(%rip), %rdi     # 0x3a518
leaq 0x2253e(%rip), %rsi     # 0x3a3e4
movl $0x1f, %edx
leaq 0x2264a(%rip), %rcx     # 0x3a4fc
callq 0x20c0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x4b00
leaq 0xed7a4(%rip), %rcx     # 0x105670
cmpq 0x128(%rcx), %rax
jne 0x17ed7
jmp 0x17ef6
leaq 0x22662(%rip), %rdi     # 0x3a540
leaq 0x224ff(%rip), %rsi     # 0x3a3e4
movl $0x20, %edx
leaq 0x2260b(%rip), %rcx     # 0x3a4fc
callq 0x20c0
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x4b00
leaq 0xed765(%rip), %rcx     # 0x105670
cmpq 0x1d8(%rcx), %rax
jne 0x17f16
jmp 0x17f35
leaq 0x2264b(%rip), %rdi     # 0x3a568
leaq 0x224c0(%rip), %rsi     # 0x3a3e4
movl $0x21, %edx
leaq 0x225cc(%rip), %rcx     # 0x3a4fc
callq 0x20c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jswaff[P]prophet3/test/bitboards__test.cpp
// Function: test_pawn_attacks()
void test_pawn_attacks() {
    assert(bb_pawn_attacks[E4][WHITE]==(bb_squares[D5] | bb_squares[F5]));
    assert(bb_pawn_attacks[E4][BLACK]==(bb_squares[D3] | bb_squares[F3]));

    assert(bb_pawn_attacks[A2][WHITE]==bb_squares[B3]);
    assert(bb_pawn_attacks[A2][BLACK]==bb_squares[B1]);

    assert(bb_pawn_attacks[H7][WHITE]==bb_squares[G8]);
    assert(bb_pawn_attacks[H7][BLACK]==bb_squares[G6]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xed5a5(%rip), %rax     # 0x105c70
movq 0x248(%rax), %rax
leaq 0xecf97(%rip), %rcx     # 0x105670
movq 0xd8(%rcx), %rcx
leaq 0xecf89(%rip), %rdx     # 0x105670
orq 0xe8(%rdx), %rcx
cmpq %rcx, %rax
jne 0x186f5
jmp 0x18714
leaq 0x22102(%rip), %rdi     # 0x3a7fe
leaq 0x21ce1(%rip), %rsi     # 0x3a3e4
movl $0x7b, %edx
leaq 0x2212d(%rip), %rcx     # 0x3a83c
callq 0x20c0
leaq 0xed555(%rip), %rax     # 0x105c70
movq 0x240(%rax), %rax
leaq 0xecf47(%rip), %rcx     # 0x105670
movq 0x158(%rcx), %rcx
leaq 0xecf39(%rip), %rdx     # 0x105670
orq 0x168(%rdx), %rcx
cmpq %rcx, %rax
jne 0x18745
jmp 0x18764
leaq 0x22109(%rip), %rdi     # 0x3a855
leaq 0x21c91(%rip), %rsi     # 0x3a3e4
movl $0x7c, %edx
leaq 0x220dd(%rip), %rcx     # 0x3a83c
callq 0x20c0
leaq 0xed505(%rip), %rax     # 0x105c70
movq 0x308(%rax), %rax
leaq 0xecef7(%rip), %rcx     # 0x105670
cmpq 0x148(%rcx), %rax
jne 0x18784
jmp 0x187a3
leaq 0x22108(%rip), %rdi     # 0x3a893
leaq 0x21c52(%rip), %rsi     # 0x3a3e4
movl $0x7e, %edx
leaq 0x2209e(%rip), %rcx     # 0x3a83c
callq 0x20c0
leaq 0xed4c6(%rip), %rax     # 0x105c70
movq 0x300(%rax), %rax
leaq 0xeceb8(%rip), %rcx     # 0x105670
cmpq 0x1c8(%rcx), %rax
jne 0x187c3
jmp 0x187e2
leaq 0x220f4(%rip), %rdi     # 0x3a8be
leaq 0x21c13(%rip), %rsi     # 0x3a3e4
movl $0x7f, %edx
leaq 0x2205f(%rip), %rcx     # 0x3a83c
callq 0x20c0
leaq 0xed487(%rip), %rax     # 0x105c70
movq 0xf8(%rax), %rax
leaq 0xece79(%rip), %rcx     # 0x105670
cmpq 0x30(%rcx), %rax
jne 0x187ff
jmp 0x1881e
leaq 0x220e3(%rip), %rdi     # 0x3a8e9
leaq 0x21bd7(%rip), %rsi     # 0x3a3e4
movl $0x81, %edx
leaq 0x22023(%rip), %rcx     # 0x3a83c
callq 0x20c0
leaq 0xed44b(%rip), %rax     # 0x105c70
movq 0xf0(%rax), %rax
leaq 0xece3d(%rip), %rcx     # 0x105670
cmpq 0xb0(%rcx), %rax
jne 0x1883e
jmp 0x1885d
leaq 0x220cf(%rip), %rdi     # 0x3a914
leaq 0x21b98(%rip), %rsi     # 0x3a3e4
movl $0x82, %edx
leaq 0x21fe4(%rip), %rcx     # 0x3a83c
callq 0x20c0
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/bitboards__test.cpp
// Function: test_bitboards()
void test_bitboards() {
    test_get_num_bits();
    test_get_lsb();
    test_get_msb();
    test_isolate_lsb_bit();
    test_knight_moves();
    test_king_moves();
    test_pawn_attacks();
    test_rays();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x17c80
callq 0x17d00
callq 0x17d80
callq 0x17e00
callq 0x17f40
callq 0x182e0
callq 0x186c0
callq 0x18860
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/book__test.cpp
// Function: test_build_book_key()
void test_build_book_key() {
    position pos;
    reset_pos(&pos);

    int64 bkey = build_book_key(&pos);
    assert(bkey==8683256505108505948L);

    set_pos(&pos,"8/4Pk1p/6p1/1r6/8/5N2/2B2PPP/b5K1 w - - ");
    bkey = build_book_key(&pos);
    assert(bkey==5404474865777589476L);

    set_pos(&pos,"8/8/3k4/2n1P3/8/8/3rP3/RN2K2R w KQ - 0 1");
    bkey = build_book_key(&pos);
    assert(bkey==-6221215072275532145L);

    set_pos(&pos,"rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1");
    bkey = build_book_key(&pos);
    assert(bkey==8410219886346271288L);

    set_pos(&pos,"r3k2r/8/8/8/8/5Q2/8/4K3 b kq - 0 1");
    bkey = build_book_key(&pos);
    assert(bkey==-7818203441519759474);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq -0x1c8(%rbp), %rdi
callq 0x5ae0
movq %rax, -0x1d0(%rbp)
movabsq $0x78811fc91897a55c, %rax # imm = 0x78811FC91897A55C
cmpq %rax, -0x1d0(%rbp)
jne 0x18bdf
jmp 0x18bfe
leaq 0x21ff3(%rip), %rdi     # 0x3abd9
leaq 0x22007(%rip), %rsi     # 0x3abf4
movl $0x12, %edx
leaq 0x2200f(%rip), %rcx     # 0x3ac08
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x22017(%rip), %rsi     # 0x3ac23
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0x5ae0
movq %rax, -0x1d0(%rbp)
movabsq $0x4b008d419c333ce4, %rax # imm = 0x4B008D419C333CE4
cmpq %rax, -0x1d0(%rbp)
jne 0x18c39
jmp 0x18c58
leaq 0x2200c(%rip), %rdi     # 0x3ac4c
leaq 0x21fad(%rip), %rsi     # 0x3abf4
movl $0x16, %edx
leaq 0x21fb5(%rip), %rcx     # 0x3ac08
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x22001(%rip), %rsi     # 0x3ac67
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0x5ae0
movq %rax, -0x1d0(%rbp)
movabsq $-0x56563225964a0971, %rax # imm = 0xA9A9CDDA69B5F68F
cmpq %rax, -0x1d0(%rbp)
jne 0x18c93
jmp 0x18cb2
leaq 0x21ff6(%rip), %rdi     # 0x3ac90
leaq 0x21f53(%rip), %rsi     # 0x3abf4
movl $0x1a, %edx
leaq 0x21f5b(%rip), %rcx     # 0x3ac08
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x2062b(%rip), %rsi     # 0x392eb
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0x5ae0
movq %rax, -0x1d0(%rbp)
movabsq $0x74b71a6d68987a38, %rax # imm = 0x74B71A6D68987A38
cmpq %rax, -0x1d0(%rbp)
jne 0x18ced
jmp 0x18d0c
leaq 0x21fb8(%rip), %rdi     # 0x3acac
leaq 0x21ef9(%rip), %rsi     # 0x3abf4
movl $0x1e, %edx
leaq 0x21f01(%rip), %rcx     # 0x3ac08
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
leaq 0x21fad(%rip), %rsi     # 0x3acc7
callq 0xf3e0
leaq -0x1c8(%rbp), %rdi
callq 0x5ae0
movq %rax, -0x1d0(%rbp)
movabsq $-0x6c7fd69b81859072, %rax # imm = 0x938029647E7A6F8E
cmpq %rax, -0x1d0(%rbp)
jne 0x18d47
jmp 0x18d66
leaq 0x21f9c(%rip), %rdi     # 0x3acea
leaq 0x21e9f(%rip), %rsi     # 0x3abf4
movl $0x22, %edx
leaq 0x21ea7(%rip), %rcx     # 0x3ac08
callq 0x20c0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nop
// File: jswaff[P]prophet3/test/draw__test.cpp
// Function: test_is_draw_by_50()
void test_is_draw_by_50() {
    position pos;
    reset_pos(&pos);
    assert(!is_draw_by_50(&pos));

    pos.fifty_counter=pos.move_counter=49;
    assert(!is_draw_by_50(&pos));

    pos.fifty_counter=pos.move_counter=50;
    assert(!is_draw_by_50(&pos));

    pos.fifty_counter=pos.move_counter=51;
    assert(!is_draw_by_50(&pos));

    pos.fifty_counter=pos.move_counter=99;
    assert(!is_draw_by_50(&pos));

    pos.fifty_counter=pos.move_counter=100;
    assert(is_draw_by_50(&pos));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x1c8(%rbp), %rdi
callq 0xf390
leaq -0x1c8(%rbp), %rdi
callq 0x6490
xorb $-0x1, %al
testb $0x1, %al
jne 0x18e5b
jmp 0x18e5d
jmp 0x18e7c
leaq 0x21ff0(%rip), %rdi     # 0x3ae54
leaq 0x21ffe(%rip), %rsi     # 0x3ae69
movl $0xf, %edx
leaq 0x22006(%rip), %rcx     # 0x3ae7d
callq 0x20c0
movl $0x31, -0x84(%rbp)
movl $0x31, -0x80(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x6490
xorb $-0x1, %al
testb $0x1, %al
jne 0x18ea1
jmp 0x18ea3
jmp 0x18ec2
leaq 0x21faa(%rip), %rdi     # 0x3ae54
leaq 0x21fb8(%rip), %rsi     # 0x3ae69
movl $0x12, %edx
leaq 0x21fc0(%rip), %rcx     # 0x3ae7d
callq 0x20c0
movl $0x32, -0x84(%rbp)
movl $0x32, -0x80(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x6490
xorb $-0x1, %al
testb $0x1, %al
jne 0x18ee7
jmp 0x18ee9
jmp 0x18f08
leaq 0x21f64(%rip), %rdi     # 0x3ae54
leaq 0x21f72(%rip), %rsi     # 0x3ae69
movl $0x15, %edx
leaq 0x21f7a(%rip), %rcx     # 0x3ae7d
callq 0x20c0
movl $0x33, -0x84(%rbp)
movl $0x33, -0x80(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x6490
xorb $-0x1, %al
testb $0x1, %al
jne 0x18f2d
jmp 0x18f2f
jmp 0x18f4e
leaq 0x21f1e(%rip), %rdi     # 0x3ae54
leaq 0x21f2c(%rip), %rsi     # 0x3ae69
movl $0x18, %edx
leaq 0x21f34(%rip), %rcx     # 0x3ae7d
callq 0x20c0
movl $0x63, -0x84(%rbp)
movl $0x63, -0x80(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x6490
xorb $-0x1, %al
testb $0x1, %al
jne 0x18f73
jmp 0x18f75
jmp 0x18f94
leaq 0x21ed8(%rip), %rdi     # 0x3ae54
leaq 0x21ee6(%rip), %rsi     # 0x3ae69
movl $0x1b, %edx
leaq 0x21eee(%rip), %rcx     # 0x3ae7d
callq 0x20c0
movl $0x64, -0x84(%rbp)
movl $0x64, -0x80(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x6490
testb $0x1, %al
jne 0x18fb7
jmp 0x18fb9
jmp 0x18fd8
leaq 0x21e95(%rip), %rdi     # 0x3ae55
leaq 0x21ea2(%rip), %rsi     # 0x3ae69
movl $0x1e, %edx
leaq 0x21eaa(%rip), %rcx     # 0x3ae7d
callq 0x20c0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopw %cs:(%rax,%rax)