LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/square__test.cpp
// Function: test_northwest()
void test_northwest() {
    assert(northwest(NO_SQUARE)==NO_SQUARE);
    assert(northwest(B4)==A5);
    assert(northwest(A7)==NO_SQUARE);
    assert(northwest(B8)==NO_SQUARE);
}

// Assembly:
pushq %rax
pushq $0x40
popq %rdi
callq 0xc3ac
cmpl $0x40, %eax
jne 0x249e0
pushq $0x21
popq %rdi
callq 0xc3ac
cmpl $0x18, %eax
jne 0x249f9
pushq $0x8
popq %rdi
callq 0xc3ac
cmpl $0x40, %eax
jne 0x24a12
pushq $0x1
popq %rdi
callq 0xc3ac
cmpl $0x40, %eax
jne 0x24a2b
popq %rax
retq
leaq 0x113c5(%rip), %rdi     # 0x35dac
leaq 0x10d13(%rip), %rsi     # 0x35701
leaq 0x113d7(%rip), %rcx     # 0x35dcc
pushq $0x76
jmp 0x24a42
leaq 0x113e2(%rip), %rdi     # 0x35de2
leaq 0x10cfa(%rip), %rsi     # 0x35701
leaq 0x113be(%rip), %rcx     # 0x35dcc
pushq $0x77
jmp 0x24a42
leaq 0x113db(%rip), %rdi     # 0x35df4
leaq 0x10ce1(%rip), %rsi     # 0x35701
leaq 0x113a5(%rip), %rcx     # 0x35dcc
pushq $0x78
jmp 0x24a42
leaq 0x113db(%rip), %rdi     # 0x35e0d
leaq 0x10cc8(%rip), %rsi     # 0x35701
leaq 0x1138c(%rip), %rcx     # 0x35dcc
pushq $0x79
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc401
testb %al, %al
je 0x24ada
pushq $0x1
popq %rdi
callq 0xc401
testb %al, %al
jne 0x24af3
pushq $0x2
popq %rdi
callq 0xc401
testb %al, %al
je 0x24b0c
pushq $0x8
popq %rdi
callq 0xc401
testb %al, %al
jne 0x24b29
pushq $0x9
popq %rdi
callq 0xc401
testb %al, %al
je 0x24b48
pushq $0xa
popq %rdi
callq 0xc401
testb %al, %al
jne 0x24b67
pushq $0x10
popq %rdi
callq 0xc401
testb %al, %al
je 0x24b86
pushq $0x11
popq %rdi
callq 0xc401
testb %al, %al
jne 0x24ba5
pushq $0x12
popq %rdi
callq 0xc401
testb %al, %al
je 0x24bc4
popq %rax
retq
leaq 0x11345(%rip), %rdi     # 0x35e26
leaq 0x10c19(%rip), %rsi     # 0x35701
leaq 0x11347(%rip), %rcx     # 0x35e36
pushq $0x7d
jmp 0x24b23
leaq 0x11354(%rip), %rdi     # 0x35e4e
leaq 0x10c00(%rip), %rsi     # 0x35701
leaq 0x1132e(%rip), %rcx     # 0x35e36
pushq $0x7e
jmp 0x24b23
leaq 0x1134c(%rip), %rdi     # 0x35e5f
leaq 0x10be7(%rip), %rsi     # 0x35701
leaq 0x11315(%rip), %rcx     # 0x35e36
pushq $0x7f
popq %rdx
callq 0x20c0
leaq 0x1133f(%rip), %rdi     # 0x35e6f
leaq 0x10bca(%rip), %rsi     # 0x35701
leaq 0x112f8(%rip), %rcx     # 0x35e36
movl $0x80, %edx
callq 0x20c0
leaq 0x11331(%rip), %rdi     # 0x35e80
leaq 0x10bab(%rip), %rsi     # 0x35701
leaq 0x112d9(%rip), %rcx     # 0x35e36
movl $0x81, %edx
callq 0x20c0
leaq 0x11322(%rip), %rdi     # 0x35e90
leaq 0x10b8c(%rip), %rsi     # 0x35701
leaq 0x112ba(%rip), %rcx     # 0x35e36
movl $0x82, %edx
callq 0x20c0
leaq 0x11314(%rip), %rdi     # 0x35ea1
leaq 0x10b6d(%rip), %rsi     # 0x35701
leaq 0x1129b(%rip), %rcx     # 0x35e36
movl $0x83, %edx
callq 0x20c0
leaq 0x11305(%rip), %rdi     # 0x35eb1
leaq 0x10b4e(%rip), %rsi     # 0x35701
leaq 0x1127c(%rip), %rcx     # 0x35e36
movl $0x84, %edx
callq 0x20c0
leaq 0x112f7(%rip), %rdi     # 0x35ec2
leaq 0x10b2f(%rip), %rsi     # 0x35701
leaq 0x1125d(%rip), %rcx     # 0x35e36
movl $0x85, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x7
popq %rdi
callq 0xc444
testb %al, %al
je 0x24c76
pushq $0x6
popq %rdi
callq 0xc444
testb %al, %al
jne 0x24c95
pushq $0x5
popq %rdi
callq 0xc444
testb %al, %al
je 0x24cb4
pushq $0xf
popq %rdi
callq 0xc444
testb %al, %al
jne 0x24cd3
pushq $0xe
popq %rdi
callq 0xc444
testb %al, %al
je 0x24cf2
pushq $0xd
popq %rdi
callq 0xc444
testb %al, %al
jne 0x24d11
pushq $0x17
popq %rdi
callq 0xc444
testb %al, %al
je 0x24d30
pushq $0x16
popq %rdi
callq 0xc444
testb %al, %al
jne 0x24d4f
pushq $0x15
popq %rdi
callq 0xc444
testb %al, %al
je 0x24d6e
popq %rax
retq
leaq 0x11255(%rip), %rdi     # 0x35ed2
leaq 0x10a7d(%rip), %rsi     # 0x35701
leaq 0x11256(%rip), %rcx     # 0x35ee1
movl $0x89, %edx
callq 0x20c0
leaq 0x1125c(%rip), %rdi     # 0x35ef8
leaq 0x10a5e(%rip), %rsi     # 0x35701
leaq 0x11237(%rip), %rcx     # 0x35ee1
movl $0x8a, %edx
callq 0x20c0
leaq 0x1124d(%rip), %rdi     # 0x35f08
leaq 0x10a3f(%rip), %rsi     # 0x35701
leaq 0x11218(%rip), %rcx     # 0x35ee1
movl $0x8b, %edx
callq 0x20c0
leaq 0x1123d(%rip), %rdi     # 0x35f17
leaq 0x10a20(%rip), %rsi     # 0x35701
leaq 0x111f9(%rip), %rcx     # 0x35ee1
movl $0x8c, %edx
callq 0x20c0
leaq 0x1122e(%rip), %rdi     # 0x35f27
leaq 0x10a01(%rip), %rsi     # 0x35701
leaq 0x111da(%rip), %rcx     # 0x35ee1
movl $0x8d, %edx
callq 0x20c0
leaq 0x1121e(%rip), %rdi     # 0x35f36
leaq 0x109e2(%rip), %rsi     # 0x35701
leaq 0x111bb(%rip), %rcx     # 0x35ee1
movl $0x8e, %edx
callq 0x20c0
leaq 0x1120f(%rip), %rdi     # 0x35f46
leaq 0x109c3(%rip), %rsi     # 0x35701
leaq 0x1119c(%rip), %rcx     # 0x35ee1
movl $0x8f, %edx
callq 0x20c0
leaq 0x111ff(%rip), %rdi     # 0x35f55
leaq 0x109a4(%rip), %rsi     # 0x35701
leaq 0x1117d(%rip), %rcx     # 0x35ee1
movl $0x90, %edx
callq 0x20c0
leaq 0x111f0(%rip), %rdi     # 0x35f65
leaq 0x10985(%rip), %rsi     # 0x35701
leaq 0x1115e(%rip), %rcx     # 0x35ee1
movl $0x91, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x38
popq %rdi
pushq $0x31
popq %rsi
callq 0xc472
testb %al, %al
je 0x24df5
pushq $0x38
popq %rdi
pushq $0x30
popq %rsi
callq 0xc472
testb %al, %al
jne 0x24e14
pushq $0x23
popq %rdi
pushq $0xe
popq %rsi
callq 0xc472
testb %al, %al
je 0x24e33
pushq $0xe
popq %rdi
pushq $0x31
popq %rsi
callq 0xc472
testb %al, %al
je 0x24e52
pushq $0x32
popq %rdi
pushq $0x34
popq %rsi
callq 0xc472
testb %al, %al
jne 0x24e71
pushq $0x3f
popq %rsi
xorl %edi, %edi
callq 0xc472
testb %al, %al
je 0x24e90
popq %rax
retq
leaq 0x11178(%rip), %rdi     # 0x35f74
leaq 0x108fe(%rip), %rsi     # 0x35701
leaq 0x1117d(%rip), %rcx     # 0x35f87
movl $0x95, %edx
callq 0x20c0
leaq 0x11184(%rip), %rdi     # 0x35f9f
leaq 0x108df(%rip), %rsi     # 0x35701
leaq 0x1115e(%rip), %rcx     # 0x35f87
movl $0x96, %edx
callq 0x20c0
leaq 0x11179(%rip), %rdi     # 0x35fb3
leaq 0x108c0(%rip), %rsi     # 0x35701
leaq 0x1113f(%rip), %rcx     # 0x35f87
movl $0x97, %edx
callq 0x20c0
leaq 0x1116d(%rip), %rdi     # 0x35fc6
leaq 0x108a1(%rip), %rsi     # 0x35701
leaq 0x11120(%rip), %rcx     # 0x35f87
movl $0x98, %edx
callq 0x20c0
leaq 0x11161(%rip), %rdi     # 0x35fd9
leaq 0x10882(%rip), %rsi     # 0x35701
leaq 0x11101(%rip), %rcx     # 0x35f87
movl $0x99, %edx
callq 0x20c0
leaq 0x11156(%rip), %rdi     # 0x35fed
leaq 0x10863(%rip), %rsi     # 0x35701
leaq 0x110e2(%rip), %rcx     # 0x35f87
movl $0x9a, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x240de
callq 0x241fe
callq 0x24496
callq 0x24356
callq 0x24540
callq 0x23f4c
callq 0x245e8
callq 0x24661
callq 0x246da
callq 0x24753
callq 0x247cc
callq 0x2486b
callq 0x2490a
callq 0x249a9
callq 0x24a48
callq 0x24be3
popq %rax
jmp 0x24d8d
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x64
popq %rdi
xorl %esi, %esi
callq 0xd4b7
testl %eax, %eax
jne 0x24f69
pushq $0x63
popq %rdi
xorl %esi, %esi
callq 0xd4b7
testl %eax, %eax
jne 0x24f82
pushq $0x19
popq %rdi
xorl %esi, %esi
callq 0xd4b7
testl %eax, %eax
jne 0x24f9b
pushq $-0x1
popq %rdi
pushq $0x3
popq %rsi
callq 0xd4b7
testl %eax, %eax
jne 0x24fb4
pushq $-0x19
popq %rdi
pushq $0x2
popq %rsi
callq 0xd4b7
testl %eax, %eax
jne 0x24fcd
movl $0x17c, %edi            # imm = 0x17C
movl $0x12b, %esi            # imm = 0x12B
callq 0xd4b7
cmpl $0xd6, %eax
jne 0x24fe6
popq %rax
retq
leaq 0x11090(%rip), %rdi     # 0x36000
leaq 0x110a3(%rip), %rsi     # 0x3601a
leaq 0x110b0(%rip), %rcx     # 0x3602e
pushq $0x7
jmp 0x24ffd
leaq 0x110c1(%rip), %rdi     # 0x3604a
leaq 0x1108a(%rip), %rsi     # 0x3601a
leaq 0x11097(%rip), %rcx     # 0x3602e
pushq $0x8
jmp 0x24ffd
leaq 0x110c1(%rip), %rdi     # 0x36063
leaq 0x11071(%rip), %rsi     # 0x3601a
leaq 0x1107e(%rip), %rcx     # 0x3602e
pushq $0x9
jmp 0x24ffd
leaq 0x110c1(%rip), %rdi     # 0x3607c
leaq 0x11058(%rip), %rsi     # 0x3601a
leaq 0x11065(%rip), %rcx     # 0x3602e
pushq $0xa
jmp 0x24ffd
leaq 0x110c1(%rip), %rdi     # 0x36095
leaq 0x1103f(%rip), %rsi     # 0x3601a
leaq 0x1104c(%rip), %rcx     # 0x3602e
pushq $0xb
jmp 0x24ffd
leaq 0x110c2(%rip), %rdi     # 0x360af
leaq 0x11026(%rip), %rsi     # 0x3601a
leaq 0x11033(%rip), %rcx     # 0x3602e
pushq $0xd
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x97a9(%rip), %rdi      # 0x2e80a
callq 0xd4e1
cmpl $0x40, %eax
jne 0x2509f
leaq 0x1126a(%rip), %rdi     # 0x362dc
callq 0xd4e1
cmpl $0x2c, %eax
jne 0x250b8
leaq 0x110fb(%rip), %rdi     # 0x3617e
callq 0xd4e1
testl %eax, %eax
jne 0x250d1
leaq 0x11113(%rip), %rdi     # 0x361a6
callq 0xd4e1
cmpl $0x1a, %eax
jne 0x250ea
popq %rax
retq
leaq 0x11094(%rip), %rdi     # 0x3613a
leaq 0x1103e(%rip), %rsi     # 0x360eb
leaq 0x110a0(%rip), %rcx     # 0x36154
pushq $0x14
jmp 0x25101
leaq 0x110ab(%rip), %rdi     # 0x3616a
leaq 0x11025(%rip), %rsi     # 0x360eb
leaq 0x11087(%rip), %rcx     # 0x36154
pushq $0x15
jmp 0x25101
leaq 0x110a9(%rip), %rdi     # 0x36181
leaq 0x1100c(%rip), %rsi     # 0x360eb
leaq 0x1106e(%rip), %rcx     # 0x36154
pushq $0x16
jmp 0x25101
leaq 0x110a4(%rip), %rdi     # 0x36195
leaq 0x10ff3(%rip), %rsi     # 0x360eb
leaq 0x11055(%rip), %rcx     # 0x36154
pushq $0x17
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x2c
popq %rdi
leaq 0xd(%rsp), %rbx
movq %rbx, %rsi
callq 0xd527
leaq 0x111b9(%rip), %rdi     # 0x362dc
pushq $0x3
popq %rdx
movq %rbx, %rsi
callq 0x2180
testl %eax, %eax
jne 0x25184
pushq $0x7
popq %rdi
leaq 0xd(%rsp), %rbx
movq %rbx, %rsi
callq 0xd527
leaq 0x11088(%rip), %rdi     # 0x361d1
pushq $0x3
popq %rdx
movq %rbx, %rsi
callq 0x2180
testl %eax, %eax
jne 0x2519d
pushq $0x12
popq %rdi
leaq 0xd(%rsp), %rbx
movq %rbx, %rsi
callq 0xd527
leaq 0xd7f2(%rip), %rdi      # 0x32961
pushq $0x3
popq %rdx
movq %rbx, %rsi
callq 0x2180
testl %eax, %eax
jne 0x251b6
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1101e(%rip), %rdi     # 0x361a9
leaq 0x10f59(%rip), %rsi     # 0x360eb
leaq 0x11022(%rip), %rcx     # 0x361bb
pushq $0x1d
jmp 0x251cd
leaq 0x11030(%rip), %rdi     # 0x361d4
leaq 0x10f40(%rip), %rsi     # 0x360eb
leaq 0x11009(%rip), %rcx     # 0x361bb
pushq $0x20
jmp 0x251cd
leaq 0x11029(%rip), %rdi     # 0x361e6
leaq 0x10f27(%rip), %rsi     # 0x360eb
leaq 0x10ff0(%rip), %rcx     # 0x361bb
pushq $0x23
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0xa
popq %rsi
pushq $0x1a
popq %rdx
callq 0x7284
leaq 0x2(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd5f6
leaq 0x10ffb(%rip), %rdi     # 0x361f8
pushq $0x5
popq %rdx
movq %rbx, %rsi
callq 0x2180
testl %eax, %eax
jne 0x25291
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
pushq $0x12
popq %rdx
callq 0x7284
leaq 0x2(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd5f6
leaq 0x10ff7(%rip), %rdi     # 0x3622c
pushq $0x5
popq %rdx
movq %rbx, %rsi
callq 0x2180
testl %eax, %eax
jne 0x252aa
pushq $0x1
popq %rdi
pushq $0xa
popq %rsi
pushq $0x2
popq %rdx
callq 0x7284
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x733b
movq (%rbx), %rdi
leaq 0x2(%rsp), %rbx
movq %rbx, %rsi
callq 0xd5f6
leaq 0x10fcc(%rip), %rdi     # 0x36248
pushq $0x6
popq %rdx
movq %rbx, %rsi
callq 0x2180
testl %eax, %eax
jne 0x252c3
addq $0x10, %rsp
popq %rbx
retq
leaq 0x10f65(%rip), %rdi     # 0x361fd
leaq 0x10e4c(%rip), %rsi     # 0x360eb
leaq 0x10f6e(%rip), %rcx     # 0x36214
pushq $0x2a
jmp 0x252da
leaq 0x10f80(%rip), %rdi     # 0x36231
leaq 0x10e33(%rip), %rsi     # 0x360eb
leaq 0x10f55(%rip), %rcx     # 0x36214
pushq $0x2e
jmp 0x252da
leaq 0x10f84(%rip), %rdi     # 0x3624e
leaq 0x10e1a(%rip), %rsi     # 0x360eb
leaq 0x10f3c(%rip), %rcx     # 0x36214
pushq $0x33
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/jswaff[P]prophet3/test/utils__test.cpp
// Function: test_is_in_move_list()
void test_is_in_move_list() {
    move mv_list[5];
    mv_list[0] = to_move(PAWN,E2,E4);
    mv_list[1] = to_move(PAWN,E2,E3);
    mv_list[2] = to_move(KNIGHT,G1,F3);
    mv_list[3] = to_move(BISHOP,B1,D3);
    mv_list[4] = to_move(PAWN,D4,E5);
    set_capture(&mv_list[4],PAWN);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
pushq $0x1
popq %rbx
pushq $0x34
popq %rbp
pushq $0x24
popq %r14
movl %ebx, %edi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7284
leaq 0x20(%rsp), %r15
movq %rax, -0x20(%r15)
pushq $0x2c
popq %rdx
movl %ebx, %edi
movl %ebp, %esi
callq 0x7284
movq %rax, -0x18(%r15)
pushq $0x2
popq %rdi
pushq $0x3e
popq %rsi
pushq $0x2d
popq %rdx
callq 0x7284
movq %rax, -0x10(%r15)
pushq $0x3
popq %rdi
pushq $0x39
popq %rsi
pushq $0x2b
popq %rdx
callq 0x7284
movq %rax, -0x8(%r15)
pushq $0x23
popq %rsi
pushq $0x1c
popq %rdx
movl %ebx, %edi
callq 0x7284
movq %rax, (%r15)
movq %r15, %rdi
movl %ebx, %esi
callq 0x72df
movl %ebx, %edi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7284
leaq 0x28(%rsp), %rbx
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
je 0x257ab
pushq $0x1
popq %rdi
pushq $0x33
popq %rsi
pushq $0x2b
popq %rdx
callq 0x7284
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdacb
testb %al, %al
jne 0x257ca
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10b4c(%rip), %rdi     # 0x362fe
leaq 0x10932(%rip), %rsi     # 0x360eb
leaq 0x10b77(%rip), %rcx     # 0x36337
movl $0x81, %edx
callq 0x20c0
leaq 0x10b82(%rip), %rdi     # 0x36353
leaq 0x10913(%rip), %rsi     # 0x360eb
leaq 0x10b58(%rip), %rcx     # 0x36337
movl $0x82, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa187
pushq $0x1
popq %rdi
pushq $0x34
popq %rsi
pushq $0x24
popq %rdx
callq 0x7284
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd9e8
testb %al, %al
je 0x25843
pushq $0x1
popq %rdi
pushq $0x34
popq %rsi
pushq $0x1c
popq %rdx
callq 0x7284
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xd9e8
testb %al, %al
jne 0x25862
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
leaq 0x10b43(%rip), %rdi     # 0x3638d
leaq 0x1089a(%rip), %rsi     # 0x360eb
leaq 0x10b4f(%rip), %rcx     # 0x363a7
movl $0x8a, %edx
callq 0x20c0
leaq 0x10b58(%rip), %rdi     # 0x363c1
leaq 0x1087b(%rip), %rsi     # 0x360eb
leaq 0x10b30(%rip), %rcx     # 0x363a7
movl $0x8d, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa5c9b(%rip), %rbx     # 0xcb920
movq %rbx, %rdi
callq 0xa187
movabsq $0x3100000031, %rax     # imm = 0x3100000031
movq %rax, 0x144(%rbx)
callq 0xdbb8
testl %eax, %eax
jne 0x25cf8
movabsq $0x3200000032, %rax     # imm = 0x3200000032
movq %rax, 0x144(%rbx)
callq 0xdbb8
testl %eax, %eax
jne 0x25d17
movabsq $0x3300000033, %rax     # imm = 0x3300000033
movq %rax, 0x144(%rbx)
callq 0xdbb8
testl %eax, %eax
jne 0x25d36
movabsq $0x6400000064, %rax     # imm = 0x6400000064
movq %rax, 0x144(%rbx)
callq 0xdbb8
cmpl $0x4, %eax
jne 0x25d55
popq %rbx
retq
leaq 0x10888(%rip), %rdi     # 0x36587
leaq 0x103e5(%rip), %rsi     # 0x360eb
leaq 0x109d1(%rip), %rcx     # 0x366de
movl $0xd5, %edx
callq 0x20c0
leaq 0x10869(%rip), %rdi     # 0x36587
leaq 0x103c6(%rip), %rsi     # 0x360eb
leaq 0x109b2(%rip), %rcx     # 0x366de
movl $0xd8, %edx
callq 0x20c0
leaq 0x1084a(%rip), %rdi     # 0x36587
leaq 0x103a7(%rip), %rsi     # 0x360eb
leaq 0x10993(%rip), %rcx     # 0x366de
movl $0xdb, %edx
callq 0x20c0
leaq 0x10998(%rip), %rdi     # 0x366f4
leaq 0x10388(%rip), %rsi     # 0x360eb
leaq 0x10974(%rip), %rcx     # 0x366de
movl $0xde, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25008
callq 0x25059
callq 0x25107
callq 0x251d3
callq 0x252e0
callq 0x256e6
callq 0x257e9
callq 0x25881
callq 0x25904
callq 0x25987
callq 0x25a0a
callq 0x25a8d
callq 0x25ac4
callq 0x25b03
callq 0x25b42
callq 0x25b81
callq 0x25bc0
callq 0x25bff
callq 0x25c3e
callq 0x25c7d
callq 0x25d74
callq 0x25db3
callq 0x25df2
callq 0x25e31
callq 0x25e70
callq 0x25eaf
callq 0x25eee
callq 0x25f2d
callq 0x25f6c
callq 0x25fab
callq 0x25fea
callq 0x26029
popq %rax
jmp 0x26068
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3ac8
pushq $0xf
popq %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3f3e
testb %al, %al
jne 0x2fcf
movq %rbx, %rdi
callq 0x3f64
testb %al, %al
jne 0x2fcf
movq %rbx, %rdi
callq 0x400e
testb %al, %al
jne 0x2fcf
movq %rbx, %rdi
callq 0x408c
testb %al, %al
jne 0x2fcf
movq %rbx, %rdi
callq 0x4116
testb %al, %al
jne 0x2fcf
movq %rbx, %rdi
callq 0x4488
testb %al, %al
jne 0x2fcf
movq %rbx, %rdi
callq 0x44e4
testb %al, %al
jne 0x2fcf
movq %rbx, %rdi
callq 0x4540
testb %al, %al
jne 0x2fcf
movq %rbx, %rdi
callq 0x459c
testb %al, %al
jne 0x2fcf
movq %rbx, %rdi
callq 0x45f8
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3f3e
testb %al, %al
jne 0x2f59
pushq $0xc
popq %rsi
movq %rbx, %rdi
callq 0x469a
movb $0x1, 0x99(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x3f3e
testb %al, %al
je 0x3ffd
leaq -0x38(%rbp), %rdi
callq 0x4782
leaq 0xa0(%rbx), %r14
xorl %r12d, %r12d
pushq $0xb
popq %r15
pushq $0x3
popq %r13
movq %rbx, %rdi
movl %r15d, %esi
callq 0x469a
testb %al, %al
je 0x3fcb
movq %r14, %rdi
xorl %esi, %esi
callq 0x4799
movss %xmm0, -0x38(%rbp,%r12,4)
incq %r12
cmpq $0x3, %r12
jne 0x3f9f
movq %r13, %r12
pushq $0xb
popq %rsi
movq %rbx, %rdi
callq 0x3f3e
testb %al, %al
je 0x3fed
movq %r14, %rdi
xorl %esi, %esi
callq 0x4799
movl %r12d, %eax
movss %xmm0, -0x38(%rbp,%rax,4)
addq $0x8, %rbx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x47b8
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x3f3e
testb %al, %al
je 0x407c
leaq -0x2c(%rbp), %rdi
callq 0x4a94
leaq 0xa0(%rbx), %r14
xorl %r12d, %r12d
pushq $0xb
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x469a
testb %al, %al
je 0x406c
movq %r14, %rdi
xorl %esi, %esi
callq 0x4799
movss %xmm0, -0x2c(%rbp,%r12,4)
incq %r12
cmpq $0x3, %r12
jne 0x4043
addq $0x20, %rbx
leaq -0x2c(%rbp), %rsi
movq %rbx, %rdi
callq 0x4aac
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x3
popq %rsi
callq 0x3f3e
testb %al, %al
je 0x410a
andq $0x0, -0x18(%rbp)
pushq $0xb
popq %rsi
movq %rbx, %rdi
callq 0x469a
testb %al, %al
je 0x40d4
leaq -0x14(%rbp), %r14
leaq 0xa0(%rbx), %rdi
xorl %esi, %esi
callq 0x4799
movss %xmm0, -0x4(%r14)
jmp 0x40d8
leaq -0x18(%rbp), %r14
pushq $0xb
popq %rsi
movq %rbx, %rdi
callq 0x3f3e
testb %al, %al
je 0x40fa
leaq 0xa0(%rbx), %rdi
xorl %esi, %esi
callq 0x4799
movss %xmm0, (%r14)
addq $0x38, %rbx
leaq -0x18(%rbp), %rsi
movq %rbx, %rdi
callq 0x4cdc
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %r14
pushq $0x5
popq %rsi
callq 0x3f3e
movl %eax, %ebx
testb %al, %al
je 0x44d7
movq %r14, %rdi
callq 0x5162
pushq $0xe
popq %rsi
movq %r14, %rdi
callq 0x469a
addq $0xa0, %r14
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x22c0
movq %r15, %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %r14
pushq $0x6
popq %rsi
callq 0x3f3e
movl %eax, %ebx
testb %al, %al
je 0x4533
movq %r14, %rdi
callq 0x5162
pushq $0xe
popq %rsi
movq %r14, %rdi
callq 0x469a
addq $0xa0, %r14
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x22c0
movq %r15, %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %r14
pushq $0x7
popq %rsi
callq 0x3f3e
movl %eax, %ebx
testb %al, %al
je 0x458f
movq %r14, %rdi
callq 0x5162
pushq $0xe
popq %rsi
movq %r14, %rdi
callq 0x469a
addq $0xa0, %r14
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x22c0
movq %r15, %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %r14
pushq $0x9
popq %rsi
callq 0x3f3e
movl %eax, %ebx
testb %al, %al
je 0x468c
pushq $0xb
popq %rsi
movq %r14, %rdi
callq 0x3f3e
testb %al, %al
je 0x4646
leaq 0xa0(%r14), %r15
leaq 0x2046(%rip), %rsi      # 0x6676
movq %r15, %rdi
callq 0x5215
testb %al, %al
je 0x465b
movb $0x1, 0x98(%r14)
jmp 0x468c
pushq $0x11
popq %rsi
movq %r14, %rdi
callq 0x469a
movb $0x0, 0x98(%r14)
jmp 0x468c
movq %r14, %rdi
callq 0x5226
leaq 0x200e(%rip), %rsi      # 0x6678
movq %rax, %rdi
callq 0x2200
movq %rax, %rdi
movq %r15, %rsi
callq 0x21f0
leaq 0x2009(%rip), %rsi      # 0x668d
movq %rax, %rdi
callq 0x2200
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %r14d
movq %rdi, %rbx
callq 0x3f3e
testb %al, %al
je 0x46b7
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x5226
leaq 0x1fe1(%rip), %rsi      # 0x66a7
movq %rax, %rdi
callq 0x2200
movl %r14d, %esi
shlq $0x5, %rsi
leaq 0x5b64(%rip), %r14      # 0xa240
addq %r14, %rsi
movq %rax, %rdi
callq 0x21f0
leaq 0x1fc4(%rip), %rsi      # 0x66b2
movq %rax, %rdi
callq 0x2200
movl 0xe0(%rbx), %esi
shlq $0x5, %rsi
addq %r14, %rsi
movq %rax, %rdi
callq 0x21f0
leaq 0x1f7b(%rip), %rsi      # 0x668d
movq %rax, %rdi
callq 0x2200
movq %rax, %rdi
callq 0x2110
leaq 0x1f91(%rip), %rdi      # 0x66ba
leaq 0x1e53(%rip), %rsi      # 0x6583
leaq 0x1f89(%rip), %rcx      # 0x66c0
movl $0xe8, %edx
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x2180
leaq -0x1a8(%rbp), %r14
movq (%rbx), %rdi
callq 0x2270
cmpl $0xa, %eax
je 0x51a5
cmpl $0xd, %eax
je 0x51a5
movsbl %al, %esi
movq %r14, %rdi
callq 0x2260
jmp 0x5186
movq (%rbx), %rdi
callq 0x2090
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2310
leaq 0xa0(%rbx), %rdi
leaq -0x30(%rbp), %r14
movq %r14, %rsi
callq 0x2280
movq %r14, %rdi
callq 0x20f0
movl $0xe, 0xe0(%rbx)
leaq -0x1b8(%rbp), %rdi
callq 0x21b0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x51fe
jmp 0x51fe
movq %rax, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
leaq 0xd98(%rip), %rsi       # 0x2004
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x1030
movq 0x2d58(%rip), %rdi      # 0x3fd8
leaq 0xd94(%rip), %rsi       # 0x201b
callq 0x1080
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x1070
leaq 0xd89(%rip), %rsi       # 0x2028
movq %rax, %rdi
callq 0x1080
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x1050
leaq 0xd72(%rip), %rsi       # 0x202c
movq %rax, %rdi
callq 0x1080
movq %rax, %rdi
callq 0x1040
leaq -0x30(%rbp), %rdi
callq 0x10c8
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x10c8
movq %rbx, %rdi
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x59d0(%rip), %rcx      # 0x8004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5c0c
jmp 0x26bf
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x7566
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x778e
leaq 0x8(%rsp), %rdi
callq 0x7584
jmp 0x26bf
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6e66
jmp 0x26bf
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x7370
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x7488
leaq 0x8(%rsp), %rdi
callq 0x738e
jmp 0x26bf
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x676e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x738e
jmp 0x26e8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7584
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x21d0
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x2150
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm1, 0x10(%rcx)
movaps %xmm2, 0x20(%rcx)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rcx)
leaq 0x58d8(%rip), %rdx      # 0x8018
leaq 0x50(%rsp), %r15
pushq $0x50
popq %rsi
movq %r15, %rdi
callq 0x2170
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2080
cmpq %r14, 0x8(%rbx)
jbe 0x2789
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2390
cmpb $0x3a, (%rax)
jne 0x2784
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2390
movb $0x5f, (%rax)
incq %r14
jmp 0x2760
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/camargodev[P]n-tile-puzzle/Main.cpp
// Function: main
int main(int argc, char** argv)
{   
    StateManager manager;
    InputReader reader;
    Input input = reader.parseInput(argc, argv);

    string fileName = currentTime() + argv[1] + ".csv";

    for (auto unpackedState : input.states) {
        PackedState state = manager.pack(unpackedState);
        Result result = processAlgorithm(input.algorithm, state);
        result.printResult(); 
        result.writeResult(fileName);
    }
    return 0;
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
andw $0x0, 0x70(%rsp)
movl %edi, %edx
movq $0xf, 0x78(%rsp)
leaq 0xc(%rsp), %rsi
movl $0x1, (%rsi)
leaq 0x10(%rsp), %rdi
movq %rbx, %rcx
callq 0x4fd6
leaq 0x30(%rsp), %rdi
callq 0x26f0
movq 0x8(%rbx), %rdx
leaq 0xa0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2973
leaq 0x5814(%rip), %rdx      # 0x8024
leaq 0x50(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x2973
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0x20b0
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x20b0
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x88(%rsp), %r12
leaq 0xd8(%rsp), %rbp
cmpq (%rsp), %r15
je 0x28d6
movq %r14, %rdi
movq %r15, %rsi
callq 0x2992
movq %r12, %rdi
movq %r14, %rsi
callq 0x2992
leaq 0x70(%rsp), %rdi
movq %r12, %rsi
callq 0x2e1c
movq %rax, %r13
movq %r12, %rdi
callq 0x29ec
movl 0x28(%rsp), %esi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x261c
movq %rbx, %rdi
callq 0x434e
movq %rbp, %rdi
leaq 0x50(%rsp), %rsi
callq 0x2270
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x451e
movq %rbp, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x29ec
addq $0x18, %r15
jmp 0x285d
leaq 0x50(%rsp), %rdi
callq 0x20b0
leaq 0x10(%rsp), %rdi
callq 0x2a0e
xorl %eax, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x20b0
jmp 0x2913
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x295c
movq %rax, %rbx
jmp 0x2961
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x20b0
jmp 0x294d
movq %rax, %rbx
jmp 0x2957
jmp 0x294a
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x29ec
jmp 0x294d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x29ec
leaq 0x50(%rsp), %rdi
callq 0x20b0
leaq 0x10(%rsp), %rdi
callq 0x2a0e
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, (%rsp)
movl (%rdi), %r13d
imull %r13d, %r13d
xorl %r15d, %r15d
pushq $0xf
popq %r14
xorl %r12d, %r12d
xorl %ebp, %ebp
cmpq %r12, %r13
je 0x2c96
movq %r14, %rsi
andq %rbx, %rsi
movl %r15d, %ecx
shrq %cl, %rsi
testl %esi, %esi
jle 0x2c89
notl %esi
addl %r13d, %esi
movq (%rsp), %rdi
movl %r12d, %edx
callq 0x2cb2
addl %eax, %ebp
shlq $0x4, %r14
incq %r12
addq $0x4, %r15
jmp 0x2c61
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::printUnpackedState(std::vector<std::vector<short, std::allocator<short>>, std::allocator<std::vector<short, std::allocator<short>>>>)
void StateManager :: printUnpackedState(UnpackedState uState) {
    for(int i = 0; i < uState.size(); i++) {
        cout << "\n";
        for(int j = 0; j < uState[i].size(); j++) {
            cout << uState[i][j] << " ";
        }
    }     
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rcx
xorl %r13d, %r13d
movq 0xa25d(%rip), %r14      # 0xcfd0
leaq 0x52d4(%rip), %r12      # 0x804e
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq %r13, %rax
jbe 0x2ddd
movq %r14, %rdi
leaq 0x52b8(%rip), %rsi      # 0x8050
callq 0x21f0
imulq $0x18, %r13, %rbp
xorl %r15d, %r15d
movq (%rbx), %rcx
movq (%rcx,%rbp), %rax
movq 0x8(%rcx,%rbp), %rdx
subq %rax, %rdx
sarq %rdx
cmpq %r15, %rdx
jbe 0x2dd8
movswl (%rax,%r15,2), %esi
movq %r14, %rdi
callq 0x21c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21f0
incq %r15
jmp 0x2da4
incq %r13
jmp 0x2d7a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rdx, %r14
movq 0x8(%rsi), %rbp
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movq %rdi, 0x8(%rsp)
movups %xmm0, (%rdi)
movq %rbp, %rax
shlq $0x38, %rax
movq %rbp, %rcx
shlq $0x34, %rcx
orq %rax, %rcx
andq %rdx, %rcx
cmpq $0x1, %rcx
pushq $0x4
popq %rbx
sbbq $0x0, %rbx
leal (,%rbx,4), %eax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
leaq 0x30(%rsp), %r15
leaq 0x6(%rsp), %r12
xorl %eax, %eax
movq %rbx, 0x18(%rsp)
cmpq %rbx, %rax
je 0x2f4f
movq %rax, 0x20(%rsp)
andq $0x0, 0x40(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq %r13, 0x28(%rsp)
subq $0x1, %rbx
jb 0x2f1e
movq %rbp, %rax
andq %r14, %rax
movl %r13d, %ecx
shrq %cl, %rax
movq 0x30(%rsp), %rsi
movw %ax, 0x6(%rsp)
movq %r15, %rdi
movq %r12, %rdx
callq 0x379c
shlq $0x4, %rbp
addq $0x4, %r13
jmp 0x2eed
movq 0x8(%rsp), %rdi
movq (%rdi), %rsi
movq %r15, %rdx
callq 0x35b0
movq %r15, %rdi
callq 0x2ba8
movq 0x20(%rsp), %rax
incq %rax
movq 0x28(%rsp), %r13
addq 0x10(%rsp), %r13
movq 0x18(%rsp), %rbx
jmp 0x2ed0
movq 0x8(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f65
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x2ba8
movq 0x8(%rsp), %rdi
callq 0x29ec
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x305a
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
movq %r15, 0x8(%rsp)
movq %r15, %rsi
movq %r14, %r15
movq %r14, %rdx
movq %r12, %rcx
callq 0x3086
movq 0x20(%rsp), %r13
movq 0x28(%rsp), %r12
cmpq %r12, %r13
je 0x301c
movl (%r13), %ecx
movb 0x4(%r13), %r14b
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x325e
movq %rax, 0x10(%rsp)
movb %r14b, 0x18(%rsp)
movb %bpl, 0x19(%rsp)
movq (%rbx), %rsi
movq %rbx, %rdi
leaq 0x10(%rsp), %rdx
callq 0x3648
addq $0x8, %r13
jmp 0x2fdb
leaq 0x20(%rsp), %rdi
callq 0x3bda
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x304a
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x3bda
movq %rbx, %rdi
callq 0x3bcc
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/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
movswl (%rdi), %edi
xorl %ecx, %ecx
xorl %eax, %eax
movq %rdx, %r8
andq %rsi, %r8
shrq %cl, %r8
movswl %r8w, %r8d
cmpl %edi, %r8d
je 0x3084
shlq $0x4, %rdx
incq %rax
addq $0x4, %rcx
jmp 0x3065
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::swapValuesByPositions(unsigned long, int, int)
PackedState StateManager :: swapValuesByPositions(PackedState state, int blankPosition, int neighborPosition) {
    
    uint64_t maskToGetNeighborValue = INITIAL_MASK;
    maskToGetNeighborValue = maskToGetNeighborValue << 4*neighborPosition;
    uint64_t neighborValue = state & maskToGetNeighborValue;
    
    // cleans neighbor position
    uint64_t maskToCleanNeighborPosition = ~maskToGetNeighborValue;
    uint64_t stateWithBlankNeighbor = state & maskToCleanNeighborPosition;
    
    // moves neighbor value to blank position
    if (neighborPosition < blankPosition)
        neighborValue = neighborValue << 4*(blankPosition-neighborPosition);
    else
        neighborValue = neighborValue >> 4*(neighborPosition-blankPosition);

    return stateWithBlankNeighbor | neighborValue;
}

// Assembly:
movl %ecx, %r8d
movq 0x8(%rdi), %rax
leal (,%r8,4), %ecx
shlq %cl, %rax
movq %rax, %rdi
andq %rsi, %rdi
movl %r8d, %ecx
subl %edx, %ecx
jge 0x328a
subl %r8d, %edx
shll $0x2, %edx
movl %edx, %ecx
shlq %cl, %rdi
jmp 0x3290
shll $0x2, %ecx
shrq %cl, %rdi
notq %rax
andq %rsi, %rax
orq %rdi, %rax
retq