LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
xorl %edi, %edi
callq 0xce02
testb %al, %al
je 0x27045
movl $0x1, %edi
callq 0xce02
testb %al, %al
jne 0x27064
movl $0x2, %edi
callq 0xce02
testb %al, %al
je 0x27083
movl $0x8, %edi
callq 0xce02
testb %al, %al
jne 0x270a2
movl $0x9, %edi
callq 0xce02
testb %al, %al
je 0x270c1
movl $0xa, %edi
callq 0xce02
testb %al, %al
jne 0x270e0
movl $0x10, %edi
callq 0xce02
testb %al, %al
je 0x270ff
movl $0x11, %edi
callq 0xce02
testb %al, %al
jne 0x2711e
movl $0x12, %edi
callq 0xce02
testb %al, %al
je 0x2713d
popq %rax
retq
leaq 0x10c96(%rip), %rdi     # 0x37ce2
leaq 0x1056a(%rip), %rsi     # 0x375bd
leaq 0x10c98(%rip), %rcx     # 0x37cf2
movl $0x7d, %edx
callq 0x20d0
leaq 0x10c9f(%rip), %rdi     # 0x37d0a
leaq 0x1054b(%rip), %rsi     # 0x375bd
leaq 0x10c79(%rip), %rcx     # 0x37cf2
movl $0x7e, %edx
callq 0x20d0
leaq 0x10c91(%rip), %rdi     # 0x37d1b
leaq 0x1052c(%rip), %rsi     # 0x375bd
leaq 0x10c5a(%rip), %rcx     # 0x37cf2
movl $0x7f, %edx
callq 0x20d0
leaq 0x10c82(%rip), %rdi     # 0x37d2b
leaq 0x1050d(%rip), %rsi     # 0x375bd
leaq 0x10c3b(%rip), %rcx     # 0x37cf2
movl $0x80, %edx
callq 0x20d0
leaq 0x10c74(%rip), %rdi     # 0x37d3c
leaq 0x104ee(%rip), %rsi     # 0x375bd
leaq 0x10c1c(%rip), %rcx     # 0x37cf2
movl $0x81, %edx
callq 0x20d0
leaq 0x10c65(%rip), %rdi     # 0x37d4c
leaq 0x104cf(%rip), %rsi     # 0x375bd
leaq 0x10bfd(%rip), %rcx     # 0x37cf2
movl $0x82, %edx
callq 0x20d0
leaq 0x10c57(%rip), %rdi     # 0x37d5d
leaq 0x104b0(%rip), %rsi     # 0x375bd
leaq 0x10bde(%rip), %rcx     # 0x37cf2
movl $0x83, %edx
callq 0x20d0
leaq 0x10c48(%rip), %rdi     # 0x37d6d
leaq 0x10491(%rip), %rsi     # 0x375bd
leaq 0x10bbf(%rip), %rcx     # 0x37cf2
movl $0x84, %edx
callq 0x20d0
leaq 0x10c3a(%rip), %rdi     # 0x37d7e
leaq 0x10472(%rip), %rsi     # 0x375bd
leaq 0x10ba0(%rip), %rcx     # 0x37cf2
movl $0x85, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movl $0x7, %edi
callq 0xce34
testb %al, %al
je 0x27201
movl $0x6, %edi
callq 0xce34
testb %al, %al
jne 0x27220
movl $0x5, %edi
callq 0xce34
testb %al, %al
je 0x2723f
movl $0xf, %edi
callq 0xce34
testb %al, %al
jne 0x2725e
movl $0xe, %edi
callq 0xce34
testb %al, %al
je 0x2727d
movl $0xd, %edi
callq 0xce34
testb %al, %al
jne 0x2729c
movl $0x17, %edi
callq 0xce34
testb %al, %al
je 0x272bb
movl $0x16, %edi
callq 0xce34
testb %al, %al
jne 0x272da
movl $0x15, %edi
callq 0xce34
testb %al, %al
je 0x272f9
popq %rax
retq
leaq 0x10b86(%rip), %rdi     # 0x37d8e
leaq 0x103ae(%rip), %rsi     # 0x375bd
leaq 0x10b87(%rip), %rcx     # 0x37d9d
movl $0x89, %edx
callq 0x20d0
leaq 0x10b8d(%rip), %rdi     # 0x37db4
leaq 0x1038f(%rip), %rsi     # 0x375bd
leaq 0x10b68(%rip), %rcx     # 0x37d9d
movl $0x8a, %edx
callq 0x20d0
leaq 0x10b7e(%rip), %rdi     # 0x37dc4
leaq 0x10370(%rip), %rsi     # 0x375bd
leaq 0x10b49(%rip), %rcx     # 0x37d9d
movl $0x8b, %edx
callq 0x20d0
leaq 0x10b6e(%rip), %rdi     # 0x37dd3
leaq 0x10351(%rip), %rsi     # 0x375bd
leaq 0x10b2a(%rip), %rcx     # 0x37d9d
movl $0x8c, %edx
callq 0x20d0
leaq 0x10b5f(%rip), %rdi     # 0x37de3
leaq 0x10332(%rip), %rsi     # 0x375bd
leaq 0x10b0b(%rip), %rcx     # 0x37d9d
movl $0x8d, %edx
callq 0x20d0
leaq 0x10b4f(%rip), %rdi     # 0x37df2
leaq 0x10313(%rip), %rsi     # 0x375bd
leaq 0x10aec(%rip), %rcx     # 0x37d9d
movl $0x8e, %edx
callq 0x20d0
leaq 0x10b40(%rip), %rdi     # 0x37e02
leaq 0x102f4(%rip), %rsi     # 0x375bd
leaq 0x10acd(%rip), %rcx     # 0x37d9d
movl $0x8f, %edx
callq 0x20d0
leaq 0x10b30(%rip), %rdi     # 0x37e11
leaq 0x102d5(%rip), %rsi     # 0x375bd
leaq 0x10aae(%rip), %rcx     # 0x37d9d
movl $0x90, %edx
callq 0x20d0
leaq 0x10b21(%rip), %rdi     # 0x37e21
leaq 0x102b6(%rip), %rsi     # 0x375bd
leaq 0x10a8f(%rip), %rcx     # 0x37d9d
movl $0x91, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movl $0x38, %edi
movl $0x31, %esi
callq 0xce63
testb %al, %al
je 0x2739a
movl $0x38, %edi
movl $0x30, %esi
callq 0xce63
testb %al, %al
jne 0x273b9
movl $0x23, %edi
movl $0xe, %esi
callq 0xce63
testb %al, %al
je 0x273d8
movl $0xe, %edi
movl $0x31, %esi
callq 0xce63
testb %al, %al
je 0x273f7
movl $0x32, %edi
movl $0x34, %esi
callq 0xce63
testb %al, %al
jne 0x27416
xorl %edi, %edi
movl $0x3f, %esi
callq 0xce63
testb %al, %al
je 0x27435
popq %rax
retq
leaq 0x10a8f(%rip), %rdi     # 0x37e30
leaq 0x10215(%rip), %rsi     # 0x375bd
leaq 0x10a94(%rip), %rcx     # 0x37e43
movl $0x95, %edx
callq 0x20d0
leaq 0x10a9b(%rip), %rdi     # 0x37e5b
leaq 0x101f6(%rip), %rsi     # 0x375bd
leaq 0x10a75(%rip), %rcx     # 0x37e43
movl $0x96, %edx
callq 0x20d0
leaq 0x10a90(%rip), %rdi     # 0x37e6f
leaq 0x101d7(%rip), %rsi     # 0x375bd
leaq 0x10a56(%rip), %rcx     # 0x37e43
movl $0x97, %edx
callq 0x20d0
leaq 0x10a84(%rip), %rdi     # 0x37e82
leaq 0x101b8(%rip), %rsi     # 0x375bd
leaq 0x10a37(%rip), %rcx     # 0x37e43
movl $0x98, %edx
callq 0x20d0
leaq 0x10a78(%rip), %rdi     # 0x37e95
leaq 0x10199(%rip), %rsi     # 0x375bd
leaq 0x10a18(%rip), %rcx     # 0x37e43
movl $0x99, %edx
callq 0x20d0
leaq 0x10a6d(%rip), %rdi     # 0x37ea9
leaq 0x1017a(%rip), %rsi     # 0x375bd
leaq 0x109f9(%rip), %rcx     # 0x37e43
movl $0x9a, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
callq 0x26482
callq 0x265d5
callq 0x268ea
callq 0x26767
callq 0x269b8
callq 0x262c4
callq 0x26a83
callq 0x26b10
callq 0x26b9d
callq 0x26c2a
callq 0x26cb7
callq 0x26d72
callq 0x26e2d
callq 0x26ee8
callq 0x26fa3
callq 0x2715c
popq %rax
jmp 0x27318
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movl $0x64, %edi
xorl %esi, %esi
callq 0xdf9f
testl %eax, %eax
jne 0x2752b
movl $0x63, %edi
xorl %esi, %esi
callq 0xdf9f
testl %eax, %eax
jne 0x2754a
movl $0x19, %edi
xorl %esi, %esi
callq 0xdf9f
testl %eax, %eax
jne 0x27569
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x3, %esi
callq 0xdf9f
testl %eax, %eax
jne 0x27588
movl $0xffffffe7, %edi       # imm = 0xFFFFFFE7
movl $0x2, %esi
callq 0xdf9f
testl %eax, %eax
jne 0x275a7
movl $0x17c, %edi            # imm = 0x17C
movl $0x12b, %esi            # imm = 0x12B
callq 0xdf9f
cmpl $0xd6, %eax
jne 0x275c6
popq %rax
retq
leaq 0x1098a(%rip), %rdi     # 0x37ebc
leaq 0x1099d(%rip), %rsi     # 0x37ed6
leaq 0x109aa(%rip), %rcx     # 0x37eea
movl $0x7, %edx
callq 0x20d0
leaq 0x109b5(%rip), %rdi     # 0x37f06
leaq 0x1097e(%rip), %rsi     # 0x37ed6
leaq 0x1098b(%rip), %rcx     # 0x37eea
movl $0x8, %edx
callq 0x20d0
leaq 0x109af(%rip), %rdi     # 0x37f1f
leaq 0x1095f(%rip), %rsi     # 0x37ed6
leaq 0x1096c(%rip), %rcx     # 0x37eea
movl $0x9, %edx
callq 0x20d0
leaq 0x109a9(%rip), %rdi     # 0x37f38
leaq 0x10940(%rip), %rsi     # 0x37ed6
leaq 0x1094d(%rip), %rcx     # 0x37eea
movl $0xa, %edx
callq 0x20d0
leaq 0x109a3(%rip), %rdi     # 0x37f51
leaq 0x10921(%rip), %rsi     # 0x37ed6
leaq 0x1092e(%rip), %rcx     # 0x37eea
movl $0xb, %edx
callq 0x20d0
leaq 0x1099e(%rip), %rdi     # 0x37f6b
leaq 0x10902(%rip), %rsi     # 0x37ed6
leaq 0x1090f(%rip), %rcx     # 0x37eea
movl $0xd, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
leaq 0x918b(%rip), %rdi      # 0x307da
callq 0xdfcd
cmpl $0x40, %eax
jne 0x2768d
leaq 0x10b38(%rip), %rdi     # 0x38198
callq 0xdfcd
cmpl $0x2c, %eax
jne 0x276ac
leaq 0x109c9(%rip), %rdi     # 0x3803a
callq 0xdfcd
testl %eax, %eax
jne 0x276cb
leaq 0x109e1(%rip), %rdi     # 0x38062
callq 0xdfcd
cmpl $0x1a, %eax
jne 0x276ea
popq %rax
retq
leaq 0x10962(%rip), %rdi     # 0x37ff6
leaq 0x1090c(%rip), %rsi     # 0x37fa7
leaq 0x1096e(%rip), %rcx     # 0x38010
movl $0x14, %edx
callq 0x20d0
leaq 0x10973(%rip), %rdi     # 0x38026
leaq 0x108ed(%rip), %rsi     # 0x37fa7
leaq 0x1094f(%rip), %rcx     # 0x38010
movl $0x15, %edx
callq 0x20d0
leaq 0x1096b(%rip), %rdi     # 0x3803d
leaq 0x108ce(%rip), %rsi     # 0x37fa7
leaq 0x10930(%rip), %rcx     # 0x38010
movl $0x16, %edx
callq 0x20d0
leaq 0x10960(%rip), %rdi     # 0x38051
leaq 0x108af(%rip), %rsi     # 0x37fa7
leaq 0x10911(%rip), %rcx     # 0x38010
movl $0x17, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
leaq 0xd(%rsp), %rbx
movl $0x2c, %edi
movq %rbx, %rsi
callq 0xe01b
movzwl (%rbx), %eax
xorl $0x3365, %eax           # imm = 0x3365
movzbl 0x2(%rbx), %ecx
orw %ax, %cx
jne 0x2777d
leaq 0xd(%rsp), %rbx
movl $0x7, %edi
movq %rbx, %rsi
callq 0xe01b
movzwl (%rbx), %eax
xorl $0x3868, %eax           # imm = 0x3868
movzbl 0x2(%rbx), %ecx
orw %ax, %cx
jne 0x2779c
leaq 0xd(%rsp), %rbx
movl $0x12, %edi
movq %rbx, %rsi
callq 0xe01b
movzwl (%rbx), %eax
xorl $0x3663, %eax           # imm = 0x3663
movzbl 0x2(%rbx), %ecx
orw %ax, %cx
jne 0x277bb
addq $0x10, %rsp
popq %rbx
retq
leaq 0x108e1(%rip), %rdi     # 0x38065
leaq 0x1081c(%rip), %rsi     # 0x37fa7
leaq 0x108e5(%rip), %rcx     # 0x38077
movl $0x1d, %edx
callq 0x20d0
leaq 0x108ed(%rip), %rdi     # 0x38090
leaq 0x107fd(%rip), %rsi     # 0x37fa7
leaq 0x108c6(%rip), %rcx     # 0x38077
movl $0x20, %edx
callq 0x20d0
leaq 0x108e0(%rip), %rdi     # 0x380a2
leaq 0x107de(%rip), %rsi     # 0x37fa7
leaq 0x108a7(%rip), %rcx     # 0x38077
movl $0x23, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movl $0x1, %edi
movl $0xa, %esi
movl $0x1a, %edx
callq 0x76b8
movq %rax, 0x8(%rsp)
leaq 0x2(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe0f5
movl $0x35633763, %eax       # imm = 0x35633763
xorl (%rbx), %eax
movzbl 0x4(%rbx), %ecx
orl %eax, %ecx
jne 0x278a4
movl $0x2, %edi
movl $0x1, %esi
movl $0x12, %edx
callq 0x76b8
movq %rax, 0x8(%rsp)
leaq 0x2(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe0f5
movl $0x36633862, %eax       # imm = 0x36633862
xorl (%rbx), %eax
movzbl 0x4(%rbx), %ecx
orl %eax, %ecx
jne 0x278c3
movl $0x1, %edi
movl $0xa, %esi
movl $0x2, %edx
callq 0x76b8
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x7780
movq (%rbx), %rdi
leaq 0x2(%rsp), %rbx
movq %rbx, %rsi
callq 0xe0f5
movl $0x38633763, %eax       # imm = 0x38633763
xorl (%rbx), %eax
movzwl 0x4(%rbx), %ecx
xorl $0x71, %ecx
orl %eax, %ecx
jne 0x278e2
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1080e(%rip), %rdi     # 0x380b9
leaq 0x106f5(%rip), %rsi     # 0x37fa7
leaq 0x10817(%rip), %rcx     # 0x380d0
movl $0x2a, %edx
callq 0x20d0
leaq 0x10823(%rip), %rdi     # 0x380ed
leaq 0x106d6(%rip), %rsi     # 0x37fa7
leaq 0x107f8(%rip), %rcx     # 0x380d0
movl $0x2e, %edx
callq 0x20d0
leaq 0x10821(%rip), %rdi     # 0x3810a
leaq 0x106b7(%rip), %rsi     # 0x37fa7
leaq 0x107d9(%rip), %rcx     # 0x380d0
movl $0x33, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x30, %rsp
movl $0x1, %edi
movl $0x34, %esi
movl $0x24, %edx
callq 0x76b8
leaq 0x20(%rsp), %rbx
movq %rax, -0x20(%rbx)
movl $0x1, %edi
movl $0x34, %esi
movl $0x2c, %edx
callq 0x76b8
movq %rax, -0x18(%rbx)
movl $0x2, %edi
movl $0x3e, %esi
movl $0x2d, %edx
callq 0x76b8
movq %rax, -0x10(%rbx)
movl $0x3, %edi
movl $0x39, %esi
movl $0x2b, %edx
callq 0x76b8
movq %rax, -0x8(%rbx)
movl $0x1, %edi
movl $0x23, %esi
movl $0x1c, %edx
callq 0x76b8
movq %rax, (%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x771c
movl $0x1, %edi
movl $0x34, %esi
movl $0x24, %edx
callq 0x76b8
leaq 0x28(%rsp), %rbx
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
je 0x27e75
movl $0x1, %edi
movl $0x33, %esi
movl $0x2b, %edx
callq 0x76b8
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xe727
testb %al, %al
jne 0x27e94
addq $0x30, %rsp
popq %rbx
retq
leaq 0x1033e(%rip), %rdi     # 0x381ba
leaq 0x10124(%rip), %rsi     # 0x37fa7
leaq 0x10369(%rip), %rcx     # 0x381f3
movl $0x81, %edx
callq 0x20d0
leaq 0x10374(%rip), %rdi     # 0x3820f
leaq 0x10105(%rip), %rsi     # 0x37fa7
leaq 0x1034a(%rip), %rcx     # 0x381f3
movl $0x82, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xaa43
movl $0x1, %edi
movl $0x34, %esi
movl $0x24, %edx
callq 0x76b8
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe5c8
testb %al, %al
je 0x27f19
movl $0x1, %edi
movl $0x34, %esi
movl $0x1c, %edx
callq 0x76b8
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xe5c8
testb %al, %al
jne 0x27f38
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x10329(%rip), %rdi     # 0x38249
leaq 0x10080(%rip), %rsi     # 0x37fa7
leaq 0x10335(%rip), %rcx     # 0x38263
movl $0x8a, %edx
callq 0x20d0
leaq 0x1033e(%rip), %rdi     # 0x3827d
leaq 0x10061(%rip), %rsi     # 0x37fa7
leaq 0x10316(%rip), %rcx     # 0x38263
movl $0x8d, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/utils__test.cpp
// Function: test_gs_draw50()
void test_gs_draw50() {
    reset_pos(&gpos);

    gpos.fifty_counter=gpos.move_counter=49;
    assert(get_game_status()==INPROGRESS);

    gpos.fifty_counter=gpos.move_counter=50;
    assert(get_game_status()==INPROGRESS);

    gpos.fifty_counter=gpos.move_counter=51;
    assert(get_game_status()==INPROGRESS);

    gpos.fifty_counter=gpos.move_counter=100;
    assert(get_game_status()==DRAW_BY_50);
}

// Assembly:
pushq %rbx
leaq 0xa05b5(%rip), %rbx     # 0xc8920
movq %rbx, %rdi
callq 0xaa43
movabsq $0x3100000031, %rax     # imm = 0x3100000031
movq %rax, 0x144(%rbx)
callq 0xe83b
testl %eax, %eax
jne 0x283de
movabsq $0x3200000032, %rax     # imm = 0x3200000032
movq %rax, 0x144(%rbx)
callq 0xe83b
testl %eax, %eax
jne 0x283fd
movabsq $0x3300000033, %rax     # imm = 0x3300000033
movq %rax, 0x144(%rbx)
callq 0xe83b
testl %eax, %eax
jne 0x2841c
movabsq $0x6400000064, %rax     # imm = 0x6400000064
movq %rax, 0x144(%rbx)
callq 0xe83b
cmpl $0x4, %eax
jne 0x2843b
popq %rbx
retq
leaq 0x1005e(%rip), %rdi     # 0x38443
leaq 0xfbbb(%rip), %rsi      # 0x37fa7
leaq 0x101a7(%rip), %rcx     # 0x3859a
movl $0xd5, %edx
callq 0x20d0
leaq 0x1003f(%rip), %rdi     # 0x38443
leaq 0xfb9c(%rip), %rsi      # 0x37fa7
leaq 0x10188(%rip), %rcx     # 0x3859a
movl $0xd8, %edx
callq 0x20d0
leaq 0x10020(%rip), %rdi     # 0x38443
leaq 0xfb7d(%rip), %rsi      # 0x37fa7
leaq 0x10169(%rip), %rcx     # 0x3859a
movl $0xdb, %edx
callq 0x20d0
leaq 0x1016e(%rip), %rdi     # 0x385b0
leaq 0xfb5e(%rip), %rsi      # 0x37fa7
leaq 0x1014a(%rip), %rcx     # 0x3859a
movl $0xde, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/jswaff[P]prophet3/test/utils__test.cpp
// Function: test_utils()
void test_utils() {
    test_opposite_player();
    test_str_to_sq();
    test_sq_to_str();
    test_move_to_str();
    test_str_to_move();
    test_is_in_move_list();
    test_is_legal_move();
    test_is_white_piece();
    test_is_black_piece();
    test_is_not_white_piece();
    test_is_not_black_piece();

    test_gs_initial_pos();
    test_gs_checkmate_foolsmate();
    test_gs_checkmate_byrnefischer();
    test_gs_checkmate_simplemate();
    test_gs_stalemate();
    test_gs_stalemate_burnpilsbury();
    test_gs_stalemate_2();
    test_gs_stalemate_3();
    test_gs_draw50();
    test_gs_no_material();
    test_gs_no_material_one_pawn();
    test_gs_no_material_one_knight();
    test_gs_no_material_one_bishop();
    test_gs_no_material_one_rook();
    test_gs_no_material_one_queen();
    test_gs_no_material_just_kings();
    test_gs_no_material_two_white_knights();
    test_gs_no_material_two_opposing_knights();
    test_gs_no_material_two_bishops_different_colors();
    test_gs_no_material_two_bishops_same_color();
    test_gs_no_material_bishop_vs_knight();
    test_gs_draw_by_rep();
}

// Assembly:
pushq %rax
callq 0x275ec
callq 0x27647
callq 0x27709
callq 0x277da
callq 0x27901
callq 0x27d90
callq 0x27eb3
callq 0x27f57
callq 0x27fde
callq 0x28065
callq 0x280ec
callq 0x28173
callq 0x281aa
callq 0x281e9
callq 0x28228
callq 0x28267
callq 0x282a6
callq 0x282e5
callq 0x28324
callq 0x28363
callq 0x2845a
callq 0x28499
callq 0x284d8
callq 0x28517
callq 0x28556
callq 0x28595
callq 0x285d4
callq 0x28613
callq 0x28652
callq 0x28691
callq 0x286d0
callq 0x2870f
popq %rax
jmp 0x2874e
// File: /workspace/github_cpp_makefile_star2_O1/tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parse()
void ObjParser<Stream>::parse()
{
    nextToken();
    while(true)
    {
        if(accept(TokenType::COMMENT));
        else if(parseVertex());
        else if(parseNormal());
        else if(parseTexCo());
        else if(parseFace());
        else if(parseUseMtl());
        else if(parseMtlLib());
        else if(parseObject());
        else if(parseGroup());
        else if(parseShade());
        if(!accept(TokenType::END_OF_LINE))
        {
            expect(TokenType::END_OF_FILE);
            break;
        }
    }
    done = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5a38
cmpl $0x0, 0xe0(%rbx)
je 0x4853
movq %rbx, %rdi
callq 0x5fca
testb %al, %al
jne 0x485b
movq %rbx, %rdi
callq 0x6130
testb %al, %al
jne 0x485b
movq %rbx, %rdi
callq 0x620e
testb %al, %al
jne 0x485b
movq %rbx, %rdi
callq 0x6366
testb %al, %al
jne 0x485b
movq %rbx, %rdi
callq 0x69c6
testb %al, %al
jne 0x485b
movq %rbx, %rdi
callq 0x6a48
testb %al, %al
jne 0x485b
movq %rbx, %rdi
callq 0x6aca
testb %al, %al
jne 0x485b
movq %rbx, %rdi
callq 0x6b4c
testb %al, %al
jne 0x485b
movq %rbx, %rdi
callq 0x6bce
jmp 0x485b
movq %rbx, %rdi
callq 0x5a38
cmpl $0xf, 0xe0(%rbx)
jne 0x486c
movq %rbx, %rdi
jmp 0x47db
movq %rbx, %rdi
movl $0xc, %esi
callq 0x6c94
movb $0x1, 0x99(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseVertex()
bool parseVertex()
    {
        if(accept(TokenType::VERTEX))
        {
            tmat::Vector4f vertex;
            int index = 0;

            while(expect(TokenType::NUMBER))
            {
                vertex[index] = stof(token);
                index ++;
                if(index >= 3)
                    break;
            }

            if(accept(TokenType::NUMBER))
            {
                vertex[index] = stof(token);
                index ++;
            }

            /* Add the vertex to the list of vertices. */
            vertices.push_back(vertex);
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, 0xe0(%rdi)
jne 0x60db
movq %rdi, %rbx
callq 0x5a38
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
xorl %r13d, %r13d
movq %rbx, %rdi
movl $0xb, %esi
callq 0x6c94
testb %al, %al
je 0x6063
movq 0xa0(%rbx), %r12
callq 0x3040
movq %rax, %r15
movl (%rax), %r14d
movl $0x0, (%rax)
movq %r12, %rdi
leaq -0x38(%rbp), %rsi
callq 0x3300
cmpq %r12, -0x38(%rbp)
je 0x60ec
movl (%r15), %eax
testl %eax, %eax
je 0x604a
cmpl $0x22, %eax
jne 0x604d
jmp 0x60f8
movl %r14d, (%r15)
movss %xmm0, -0x50(%rbp,%r13,4)
incq %r13
cmpq $0x3, %r13
jne 0x5ffa
movl $0x3, %r13d
cmpl $0xb, 0xe0(%rbx)
jne 0x60cb
movq %rbx, %rdi
callq 0x5a38
movq 0xa0(%rbx), %r15
callq 0x3040
movq %rax, %r14
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, (%r14)
leaq -0x38(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3300
cmpq %r15, (%r12)
je 0x6104
movl (%r14), %eax
testl %eax, %eax
je 0x60bc
cmpl $0x22, %eax
jne 0x60c2
leaq 0x248a(%rip), %rdi      # 0x8541
callq 0x3330
movl -0x2c(%rbp), %eax
movl %eax, (%r14)
movl %r13d, %eax
movss %xmm0, -0x50(%rbp,%rax,4)
addq $0x8, %rbx
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x6d6e
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x244e(%rip), %rdi      # 0x8541
callq 0x3160
leaq 0x2442(%rip), %rdi      # 0x8541
callq 0x3330
leaq 0x2436(%rip), %rdi      # 0x8541
callq 0x3160
cmpl $0x0, (%r14)
jne 0x6127
movl -0x2c(%rbp), %ecx
movl %ecx, (%r14)
jmp 0x6127
cmpl $0x0, (%r15)
jne 0x6127
movl %r14d, (%r15)
movq %rax, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseNormal()
bool parseNormal()
    {
        if(accept(TokenType::NORMAL))
        {
            tmat::Vector3f vertex;
            int index = 0;

            while(expect(TokenType::NUMBER))
            {
                vertex[index] = stof(token);
                index ++;
                if(index >= 3)
                    break;
            }
            
            /* Add the normal to the list of normals. */
            normals.push_back(vertex);
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x2, 0xe0(%rdi)
jne 0x61d4
movq %rdi, %rbx
callq 0x5a38
movl $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
xorl %r13d, %r13d
movq %rbx, %rdi
movl $0xb, %esi
callq 0x6c94
testb %al, %al
je 0x61c4
movq 0xa0(%rbx), %r12
callq 0x3040
movq %rax, %r15
movl (%rax), %r14d
movl $0x0, (%rax)
movq %r12, %rdi
leaq -0x40(%rbp), %rsi
callq 0x3300
cmpq %r12, -0x40(%rbp)
je 0x61e5
movl (%r15), %eax
testl %eax, %eax
je 0x61b1
cmpl $0x22, %eax
jne 0x61b4
jmp 0x61f1
movl %r14d, (%r15)
movss %xmm0, -0x38(%rbp,%r13,4)
incq %r13
cmpq $0x3, %r13
jne 0x6168
addq $0x20, %rbx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x6f1c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2355(%rip), %rdi      # 0x8541
callq 0x3160
leaq 0x2349(%rip), %rdi      # 0x8541
callq 0x3330
cmpl $0x0, (%r15)
jne 0x6206
movl %r14d, (%r15)
movq %rax, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseTexCo()
bool parseTexCo()
    {
        if(accept(TokenType::TEXCO))
        {
            tmat::Vector2f vertex;
            int index = 0;

            while(expect(TokenType::NUMBER))
            {
                vertex[index] = stof(token);
                index ++;
                if(index >= 1)
                    break;
            }

            if(accept(TokenType::NUMBER))
            {
                vertex[index] = stof(token);
                index ++;
            }

            /* Add the texco to the list of texcos. */
            texCos.push_back(vertex);
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x3, 0xe0(%rdi)
jne 0x631e
movq %rdi, %rbx
callq 0x5a38
movq $0x0, -0x38(%rbp)
movq %rbx, %rdi
movl $0xb, %esi
callq 0x6c94
testb %al, %al
je 0x6296
movq 0xa0(%rbx), %r15
callq 0x3040
movq %rax, %r14
movl (%rax), %r13d
movl $0x0, (%rax)
leaq -0x40(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3300
cmpq %r15, (%r12)
je 0x632f
movl (%r14), %eax
testl %eax, %eax
je 0x629c
cmpl $0x22, %eax
jne 0x629f
leaq 0x22b0(%rip), %rdi      # 0x8541
callq 0x3330
leaq -0x38(%rbp), %r13
jmp 0x62a9
movl %r13d, (%r14)
leaq -0x34(%rbp), %r13
movss %xmm0, -0x4(%r13)
cmpl $0xb, 0xe0(%rbx)
jne 0x630e
movq %rbx, %rdi
callq 0x5a38
movq 0xa0(%rbx), %r15
callq 0x3040
movq %rax, %r14
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, (%r14)
leaq -0x40(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3300
cmpq %r15, (%r12)
je 0x633b
movl (%r14), %eax
testl %eax, %eax
je 0x6302
cmpl $0x22, %eax
jne 0x6308
leaq 0x2244(%rip), %rdi      # 0x8541
callq 0x3330
movl -0x2c(%rbp), %eax
movl %eax, (%r14)
movss %xmm0, (%r13)
addq $0x38, %rbx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x70fc
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x220b(%rip), %rdi      # 0x8541
callq 0x3160
leaq 0x21ff(%rip), %rdi      # 0x8541
callq 0x3160
cmpl $0x0, (%r14)
jne 0x635e
movl -0x2c(%rbp), %ecx
movl %ecx, (%r14)
jmp 0x635e
cmpl $0x0, (%r14)
jne 0x635e
movl %r13d, (%r14)
movq %rax, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseUseMtl()
bool parseUseMtl()
    {
        if(accept(TokenType::USEMTL))
        {
            parseString();
            expect(TokenType::STRING);
            std::string name = token;

            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0xe0(%rdi), %r14d
cmpl $0x5, %r14d
jne 0x6a36
movq %rdi, %rbx
callq 0x5a38
movq %rbx, %rdi
callq 0x73e6
movq %rbx, %rdi
movl $0xe, %esi
callq 0x6c94
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0xa0(%rbx), %rsi
movq 0xa8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x74e0
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6a36
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3250
cmpl $0x5, %r14d
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseMtlLib()
bool parseMtlLib()
    {
        if(accept(TokenType::MTLLIB))
        {
            parseString();
            expect(TokenType::STRING);
            std::string path = token;
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0xe0(%rdi), %r14d
cmpl $0x6, %r14d
jne 0x6ab8
movq %rdi, %rbx
callq 0x5a38
movq %rbx, %rdi
callq 0x73e6
movq %rbx, %rdi
movl $0xe, %esi
callq 0x6c94
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0xa0(%rbx), %rsi
movq 0xa8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x74e0
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6ab8
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3250
cmpl $0x6, %r14d
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseObject()
bool parseObject()
    {
        if(accept(TokenType::OBJECT))
        {
            parseString();
            expect(TokenType::STRING);
            std::string name = token;

            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0xe0(%rdi), %r14d
cmpl $0x7, %r14d
jne 0x6b3a
movq %rdi, %rbx
callq 0x5a38
movq %rbx, %rdi
callq 0x73e6
movq %rbx, %rdi
movl $0xe, %esi
callq 0x6c94
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0xa0(%rbx), %rsi
movq 0xa8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x74e0
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6b3a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3250
cmpl $0x7, %r14d
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseShade()
bool parseShade()
    {
        if(accept(TokenType::SHADE))
        {
            if(accept(TokenType::NUMBER))
            {
                if(token == "1")
                    smooth = true;
                else
                {
                    error() << "unknown shade type '" << token << "'.";
                }
            }
            else
            {
                expect(TokenType::OFF);
                smooth = false;
            }
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0xe0(%rdi), %r15d
cmpl $0x9, %r15d
jne 0x6c81
movq %rdi, %rbx
callq 0x5a38
cmpl $0xb, 0xe0(%rbx)
jne 0x6c64
movq %rbx, %rdi
callq 0x5a38
leaq 0xa0(%rbx), %rdi
leaq 0x1a66(%rip), %rsi      # 0x8676
callq 0x3090
testl %eax, %eax
je 0x6c7a
movq %rbx, %rdi
callq 0x757a
movq %rax, %r14
leaq 0x1a4d(%rip), %rsi      # 0x8678
movl $0x14, %edx
movq %rax, %rdi
callq 0x32a0
movq 0xa0(%rbx), %rsi
movq 0xa8(%rbx), %rdx
movq %r14, %rdi
callq 0x32a0
leaq 0x1a38(%rip), %rsi      # 0x868d
movl $0x2, %edx
movq %rax, %rdi
callq 0x32a0
jmp 0x6c81
movq %rbx, %rdi
movl $0x11, %esi
callq 0x6c94
movb $0x0, 0x98(%rbx)
jmp 0x6c81
movb $0x1, 0x98(%rbx)
cmpl $0x9, %r15d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::expect(ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::TokenType)
bool expect(TokenType type)
    {
        if(accept(type))
            return true;
        else
        {
            error() << "expected '" <<
                tokenStrings[type] << "' got '" << tokenStrings[token_type] <<
                "'." << std::endl;
        }
        assert(false);
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl %esi, 0xe0(%rdi)
jne 0x6cb5
movq %rbx, %rdi
callq 0x5a38
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
movl %esi, %r14d
movq %rbx, %rdi
callq 0x757a
leaq 0x19e0(%rip), %rsi      # 0x86a7
movq %rax, %rdi
callq 0x3230
movl %r14d, %esi
shlq $0x5, %rsi
leaq 0x4583(%rip), %r14      # 0xb260
addq %r14, %rsi
movq %rax, %rdi
callq 0x3210
leaq 0x19c3(%rip), %rsi      # 0x86b2
movq %rax, %rdi
callq 0x3230
movl 0xe0(%rbx), %esi
shlq $0x5, %rsi
addq %r14, %rsi
movq %rax, %rdi
callq 0x3210
leaq 0x197a(%rip), %rsi      # 0x868d
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x3120
leaq 0x1990(%rip), %rdi      # 0x86ba
leaq 0x1852(%rip), %rsi      # 0x8583
leaq 0x1988(%rip), %rcx      # 0x86c0
movl $0xe8, %edx
callq 0x3170
// File: /workspace/github_cpp_makefile_star2_O1/tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseString()
void parseString()
    {
        int c;
        std::stringstream s;
        while((c = stream.get()) != '\n' && c != '\r')
        {
            s << (char) c;
        }
        stream.unget();

        token = s.str();
        token_type = TokenType::STRING;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
leaq -0x1c0(%rbp), %rdi
callq 0x31a0
leaq -0x1b0(%rbp), %r14
leaq -0x38(%rbp), %r15
movq (%rbx), %rdi
callq 0x32c0
cmpl $0xa, %eax
je 0x7437
cmpl $0xd, %eax
je 0x7437
movb %al, -0x38(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x32a0
jmp 0x7410
movq (%rbx), %rdi
callq 0x30b0
leaq -0x1a8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3380
leaq 0xa0(%rbx), %rdi
leaq -0x38(%rbp), %r14
movq %r14, %rsi
callq 0x32d0
movq (%r14), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x747a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3250
movl $0xe, 0xe0(%rbx)
movq 0x3b25(%rip), %rsi      # 0xafb0
leaq -0x1c0(%rbp), %rdi
callq 0x31c0
leaq -0x140(%rbp), %rdi
callq 0x30c0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x74b5
jmp 0x74b5
movq %rax, %rbx
movq 0x3af1(%rip), %rsi      # 0xafb0
leaq -0x1c0(%rbp), %rdi
callq 0x31c0
leaq -0x140(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/string_size.cc
// Function: main
int main()
{
    string st("The expense of spirit\n");
    cout << "The size of " << st << "is " << st.size()
         << " characters, including the newline" << endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xd3e(%rip), %rsi       # 0x2004
leaq 0xd4d(%rip), %rdx       # 0x201a
leaq -0x30(%rbp), %rdi
callq 0x143e
movq 0x2cfb(%rip), %rdi      # 0x3fd8
leaq 0xd37(%rip), %rsi       # 0x201b
movl $0xc, %edx
callq 0x10b0
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq 0x2cdb(%rip), %rdi      # 0x3fd8
callq 0x10b0
movq %rax, %rbx
leaq 0xd1c(%rip), %rsi       # 0x2028
movl $0x3, %edx
movq %rax, %rdi
callq 0x10b0
movq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x1040
movq %rax, %rbx
leaq 0xcfd(%rip), %rsi       # 0x202c
movl $0x22, %edx
movq %rax, %rdi
callq 0x10b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1378
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x10a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x139b
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x10a0
movq %rbx, %rdi
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/camargodev[P]n-tile-puzzle/Main.cpp
// Function: processAlgorithm(int, unsigned long)
Result processAlgorithm(int algorithmId, PackedState initialState) {
    switch (algorithmId) {
        case InputReader::BFS_ID:
            return BFS().execute(initialState);
        case InputReader::GREEDY_ID:
            return GreedyBestFirstSearch().execute(initialState);
        case InputReader::ASTAR_ID:
            return AStar().execute(initialState);
        case InputReader::IDFS_ID:
            return IDFS().execute(initialState);
        case InputReader::IDASTAR_ID:
            return IDAStar().execute(initialState);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movl %esi, %eax
leaq 0x68a0(%rip), %rcx      # 0x9004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6860
jmp 0x27ef
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x864a
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x889e
leaq 0x8(%rsp), %rdi
callq 0x866e
jmp 0x27ef
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7ca8
jmp 0x27ef
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x8438
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8566
leaq 0x8(%rsp), %rdi
callq 0x845c
jmp 0x27ef
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7374
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x845c
jmp 0x2818
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x866e
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/camargodev[P]n-tile-puzzle/Main.cpp
// Function: currentTime[abi:cxx11]()
string currentTime(){
    time_t     now = time(0);
    struct tm  tstruct;
    char       buf[80];
    tstruct = *localtime(&now);
    strftime(buf, sizeof(buf), "%d-%m-%Y-%H", &tstruct);
    string str(buf);
    for(int i = 0; i < str.length(); i++){
        if(str.at(i) == ':')
            str.at(i) = '_';
    }
    return str;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x21f0
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x2160
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq 0x60(%rsp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm1, 0x10(%rcx)
movaps %xmm2, 0x20(%rcx)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rcx)
leaq 0x67ad(%rip), %rdx      # 0x9018
leaq 0x10(%rsp), %r14
movl $0x50, %esi
movq %r14, %rdi
callq 0x2190
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x20d0
leaq (%rsp,%rax), %rdx
addq $0x10, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d2c
cmpq $0x0, 0x8(%rbx)
je 0x28be
xorl %eax, %eax
movq (%rbx), %rcx
cmpb $0x3a, (%rcx,%rax)
jne 0x28b5
movb $0x5f, (%rcx,%rax)
incq %rax
cmpq %rax, 0x8(%rbx)
ja 0x28a8
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/camargodev[P]n-tile-puzzle/src/ManhattanDistance.cpp
// Function: ManhattanDistance::calculate(unsigned long)
int ManhattanDistance :: calculate(PackedState state) {
    int distance = 0;
    uint64_t mask = 15;
    for (int i = 0; i < numberOfTiles*numberOfTiles; i++) {
        uint64_t currentNumber = state & mask;
        currentNumber = currentNumber >> 4*i;
        int intNumber = currentNumber;
        if (intNumber > 0) {
            int expectedPosition = getExpectedPositionForNumber(intNumber);
            int currentDistance = calculateDistanceBeetwenPositions(expectedPosition, i);
            distance += currentDistance;
        }
        mask = mask << 4;
    }
    return distance;
}

// Assembly:
movl (%rdi), %r10d
testl %r10d, %r10d
je 0x2faf
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r10d, %r11d
imull %r10d, %r11d
cmpl $0x1, %r11d
movl %r11d, %ebx
adcl $0x0, %ebx
shlq $0x2, %rbx
movl $0xf, %r14d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %edi, %edi
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r15
andq %rsi, %r15
shrq %cl, %r15
testl %r15d, %r15d
jle 0x2f94
movl %r15d, %eax
notl %eax
addl %r11d, %eax
cltd
idivl %r10d
movl %eax, %r9d
movl %edi, %eax
cltd
idivl %r10d
movl %r9d, %edx
subl %eax, %edx
movl %edx, %r12d
negl %r12d
cmovsl %edx, %r12d
addl %r10d, %eax
subl %r9d, %eax
imull %r10d, %eax
subl %r15d, %eax
addl %ebp, %eax
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
addl %r8d, %r12d
addl %edx, %r12d
movl %r12d, %r8d
shlq $0x4, %r14
decl %ebp
addq $0x4, %rcx
incl %edi
cmpq %rcx, %rbx
jne 0x2f43
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2fb2
xorl %r8d, %r8d
movl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/camargodev[P]n-tile-puzzle/src/ManhattanDistance.cpp
// Function: ManhattanDistance::calculateDistanceBeetwenPositions(int, int)
int ManhattanDistance :: calculateDistanceBeetwenPositions(int pos1, int pos2) {
    int pos1x = (int) floor(pos1/numberOfTiles);
    int pos1y = pos1 - numberOfTiles*pos1x;

    int pos2x = (int) floor(pos2/numberOfTiles);
    int pos2y = pos2 - numberOfTiles*pos2x;

    int horizontalDistance = abs(pos1x - pos2x);
    int verticalDistance = abs(pos1y - pos2y);

    return horizontalDistance + verticalDistance;
}

// Assembly:
movl %edx, %ecx
movl (%rdi), %r8d
movl %esi, %eax
cltd
idivl %r8d
movl %eax, %edi
movl %ecx, %eax
cltd
idivl %r8d
movl %edi, %edx
subl %eax, %edx
movl %edx, %r9d
negl %r9d
cmovsl %edx, %r9d
subl %edi, %eax
imull %r8d, %eax
subl %ecx, %esi
addl %esi, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
addl %r9d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::isGoalState(unsigned long)
bool StateManager :: is3TileState(PackedState state) {
    uint64_t mask = INITIAL_MASK;
    uint64_t maskAtPos14 = mask << 4*14;
    uint64_t maskAtPos13 = mask << 4*13;
    uint64_t valAtPos13 = state & maskAtPos13;
    uint64_t valAtPos14 = state & maskAtPos14;
    return valAtPos13 == 0 && valAtPos14 == 0;
}

// Assembly:
movq 0x8(%rdi), %rax
movq %rax, %rcx
shlq $0x38, %rcx
shlq $0x34, %rax
orq %rcx, %rax
testq %rsi, %rax
movl $0x12345678, %eax       # imm = 0x12345678
movabsq $0x123456789abcdef, %rcx # imm = 0x123456789ABCDEF
cmoveq %rax, %rcx
cmpq %rsi, %rcx
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::unpack(unsigned long)
UnpackedState StateManager :: unpack(PackedState state) {
    PackedState mask = INITIAL_MASK;
    UnpackedState unpackedState;
    short numberOfTiles = getNumberOfTiles(state);
    for (int i = 0; i < numberOfTiles; i++) {
        Line line;
        for (int j = 0; j < numberOfTiles; j++) {
            uint64_t value = state & mask;
            value = value >> 4*(numberOfTiles*i+j);
            line.insert(line.begin(), value);
            mask = mask << 4;
        }   
        unpackedState.insert(unpackedState.begin(), line);
    }
    return unpackedState;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq 0x8(%rsi), %rbp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x10(%rsp)
movq $0x0, 0x10(%rdi)
movq %rbp, %rax
shlq $0x38, %rax
movq %rbp, %rcx
shlq $0x34, %rcx
orq %rax, %rcx
andq %rdx, %rcx
cmpq $0x1, %rcx
movl $0x4, %ecx
sbbl $0x0, %ecx
movl %ecx, %eax
shll $0x2, %eax
movq %rax, 0x40(%rsp)
xorl %r13d, %r13d
leaq 0x20(%rsp), %r15
leaq 0xe(%rsp), %r12
xorl %ebx, %ebx
movq %rcx, 0x18(%rsp)
movq %rbx, 0x48(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq %rcx, %rbx
movq %r13, 0x50(%rsp)
movq %rbp, %rax
andq %r14, %rax
movl %r13d, %ecx
shrq %cl, %rax
movq 0x20(%rsp), %rsi
movw %ax, 0xe(%rsp)
movq %r15, %rdi
movq %r12, %rdx
callq 0x3c3e
shlq $0x4, %rbp
addq $0x4, %r13
decq %rbx
jne 0x3242
movq 0x10(%rsp), %rdi
movq (%rdi), %rsi
movq %r15, %rdx
callq 0x3a38
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
movq 0x18(%rsp), %rcx
movq 0x50(%rsp), %r13
movq 0x48(%rsp), %rbx
je 0x32a3
callq 0x2200
movq 0x18(%rsp), %rcx
incq %rbx
addq 0x40(%rsp), %r13
cmpq %rcx, %rbx
jne 0x3224
movq 0x10(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x32ca
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x32dc
callq 0x2200
movq 0x10(%rsp), %rdi
callq 0x2c16
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::produceNextStates(State)
vector<State> StateManager :: produceNextStates(State state) {
    vector<State> neighbors;
    int blankPosition = getBlankTilePosition(state.value);
    short numberOfTiles = getNumberOfTiles(state.value);
    for (auto neighboorPosition : getNeighborsPositionsAndHeuristics(state)) {
        State newState;
        newState.value = swapValuesByPositions(state.value, blankPosition, neighboorPosition.first);
        newState.heuristic = neighboorPosition.second;
        newState.parentBlankPos = blankPosition;
        neighbors.insert(neighbors.begin(), newState);
    }
    return neighbors;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x33f0
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x345c
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %r12
cmpq %r12, %r13
je 0x33a3
movl (%r13), %esi
movq 0x8(%r15), %rax
leal (,%rsi,4), %ecx
shlq %cl, %rax
movq %rax, %rdx
andq %r14, %rdx
movl %esi, %ecx
subl %ebp, %ecx
jge 0x336f
movl %ebp, %ecx
subl %esi, %ecx
shll $0x2, %ecx
shlq %cl, %rdx
jmp 0x3375
shll $0x2, %ecx
shrq %cl, %rdx
movl 0x4(%r13), %ecx
notq %rax
andq %r14, %rax
orq %rdx, %rax
movq %rax, (%rsp)
movb %cl, 0x8(%rsp)
movb %bpl, 0x9(%rsp)
movq (%rbx), %rsi
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x3ade
addq $0x8, %r13
jmp 0x3340
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x33b2
callq 0x2200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x33db
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x33db
callq 0x2200
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x33e8
callq 0x2200
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::getBlankTilePosition(unsigned long)
int StateManager :: getBlankTilePosition(PackedState state) {
    PackedState mask = INITIAL_MASK;
    short numberOfTiles = getNumberOfTiles(state);
    for (int i = 0; i < numberOfTiles*numberOfTiles; i++) {
        uint64_t value = state & mask;
        short shortValue = value >> 4*i;
        if (shortValue == BLANK)
            return i;
        mask = mask << 4;
    }
}

// Assembly:
movq 0x8(%rdi), %rdx
movq %rdx, %rax
shlq $0x38, %rax
movq %rdx, %rcx
shlq $0x34, %rcx
orq %rax, %rcx
testq %rsi, %rcx
movl $0x9, %eax
movl $0x10, %r8d
cmovel %eax, %r8d
movswl (%rdi), %edi
movl %edx, %eax
andl %esi, %eax
movswl %ax, %ecx
xorl %eax, %eax
cmpl %edi, %ecx
je 0x345b
xorl %eax, %eax
movl $0x1, %r9d
movl $0x4, %ecx
cmpq %r9, %r8
je 0x345b
shlq $0x4, %rdx
movq %rdx, %r10
andq %rsi, %r10
shrq %cl, %r10
movswl %r10w, %r10d
addq $0x4, %rcx
cmpl %edi, %r10d
cmovel %r9d, %eax
leaq 0x1(%r9), %r9
jne 0x3434
retq