LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: init_qtable()
qtable_t init_qtable() {
    qtable_t qtable = new uint8_t*[4];
    for (int i = 0; i < 4; i++) {
        qtable[i] = new uint8_t[64];
    }
    return qtable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $0x20
popq %rdi
callq 0x2030
movq %rax, %rbx
xorl %r15d, %r15d
pushq $0x40
popq %r14
cmpq $0x4, %r15
je 0x29af
movq %r14, %rdi
callq 0x2030
movq %rax, (%rbx,%r15,8)
incq %r15
jmp 0x2998
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: print_DQT(unsigned char**)
void print_DQT(qtable_t qtable) {
    cout << "[Quantization Table]" << endl;
    int rows = 8, cols = 8;
    
    for (int i = 0; i < 4; i++) {
        cout << "  qid = " << i << endl;
        
        for (int r = 0; r < rows; r++) {
            cout << "    ";
            
            for (int c = 0; c < cols; c++) {
                printf("%2d ", (int)qtable[i][r * cols + c]);
            }
            cout << endl;
        }
    }
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x65fb(%rip), %r14      # 0x8fd0
leaq 0x3717(%rip), %rsi      # 0x60f3
movq %r14, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20e0
leaq 0x3723(%rip), %r13      # 0x6116
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0x2a88
movq %r14, %rdi
leaq 0x36fe(%rip), %rsi      # 0x6108
callq 0x2190
movq %rax, %rdi
movl %r15d, %esi
callq 0x22c0
movq %rax, %rdi
callq 0x20e0
xorl %r12d, %r12d
xorl %eax, %eax
cmpq $0x8, %rax
je 0x2a80
movq %rax, -0x30(%rbp)
movq %r14, %rdi
leaq 0x36d6(%rip), %rsi      # 0x6111
callq 0x2190
xorl %r14d, %r14d
cmpq $0x8, %r14
je 0x2a64
movq (%rbx,%r15,8), %rax
addq %r12, %rax
movzbl (%r14,%rax), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x2040
incq %r14
jmp 0x2a43
movq 0x6565(%rip), %r14      # 0x8fd0
movq %r14, %rdi
callq 0x20e0
movq -0x30(%rbp), %rax
incq %rax
addq $0x8, %r12
jmp 0x2a27
incq %r15
jmp 0x29f6
movq 0x6541(%rip), %rdi      # 0x8fd0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: process_DQT(std::basic_ifstream<char, std::char_traits<char>>&, unsigned char**)
bool process_DQT(ifstream& jpegfile, qtable_t qtable) {
    unsigned int pointer = 0;
    char c1, c2;

    /* DQT Length */
    jpegfile.read(&c1, 1); pointer++;
    jpegfile.read(&c2, 1); pointer++;

    unsigned int len = to_num(c1, c2);

    if (debug)
        cout << "[DQT] len = " << len << endl;

    /* Fill in Quantization Table */
    while (pointer < len) {
        char c;
        jpegfile.read(&c, 1); pointer += 1;

        c = to_uint(c);
        unsigned int precision = c >> 4;
        unsigned int qid = c & 0x0F;

        for (int i = 0; i < 64; i++) {
            jpegfile.read(&c, 1); pointer += 1;
            qtable[qid][i] = (uint8_t)to_uint(c);
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x2b(%rbp), %r13
pushq $0x1
popq %r12
movq %r13, %rsi
movq %r12, %rdx
callq 0x21f0
leaq -0x2a(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x21f0
movzbl (%r13), %ecx
movzbl (%r15), %eax
shll $0x8, %ecx
orl %eax, %ecx
movl %ecx, -0x30(%rbp)
cmpb $0x1, 0x66e4(%rip)      # 0x91da
jne 0x2b1e
movq 0x64d1(%rip), %rdi      # 0x8fd0
leaq 0x3615(%rip), %rsi      # 0x611b
callq 0x2190
movl -0x30(%rbp), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20e0
pushq $0x2
popq %rax
cmpl -0x30(%rbp), %eax
jae 0x2b71
movl %eax, -0x34(%rbp)
movq %r14, %rdi
leaq -0x29(%rbp), %rsi
movq %r12, %rdx
callq 0x21f0
movzbl -0x29(%rbp), %r13d
andl $0xf, %r13d
xorl %r15d, %r15d
cmpq $0x40, %r15
je 0x2b69
movq %r14, %rdi
leaq -0x29(%rbp), %rsi
movq %r12, %rdx
callq 0x21f0
movb -0x29(%rbp), %al
movq (%rbx,%r13,8), %rcx
movb %al, (%rcx,%r15)
incq %r15
jmp 0x2b44
movl -0x34(%rbp), %eax
addl $0x41, %eax
jmp 0x2b21
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/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: print_SOF(sof&)
void print_SOF(sof_t& sof) {
    cout << "[SOF Information]" << endl;
    cout << "  precision = " << sof.P << endl;
    cout << "  height = " << sof.Y << endl;
    cout << "  width = " << sof.X << endl;
    cout << "  channels = " << sof.N << endl;
    for (unsigned int i = 0; i < sof.N; i++) {
        cout << "    H = " << sof.hvq[i].H << ", V = " << sof.hvq[i].V << ", Q = " << sof.hvq[i].Q << endl;
    }
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x6436(%rip), %r14      # 0x8fd0
leaq 0x3587(%rip), %rsi      # 0x6128
movq %r14, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20e0
leaq 0x3582(%rip), %rsi      # 0x613a
movq %r14, %rdi
callq 0x2190
movl (%rbx), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20e0
leaq 0x3570(%rip), %rsi      # 0x6149
movq %r14, %rdi
callq 0x2190
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20e0
leaq 0x355a(%rip), %rsi      # 0x6155
movq %r14, %rdi
callq 0x2190
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20e0
leaq 0x3543(%rip), %rsi      # 0x6160
movq %r14, %rdi
callq 0x2190
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20e0
xorl %r14d, %r14d
leaq 0x3535(%rip), %r12      # 0x6177
leaq 0x3535(%rip), %r13      # 0x617e
xorl %r15d, %r15d
movl 0xc(%rbx), %eax
movq 0x637a(%rip), %rdi      # 0x8fd0
cmpq %rax, %r15
jae 0x2cc0
leaq 0x350c(%rip), %rsi      # 0x616e
callq 0x2190
movq 0x10(%rbx), %rcx
movl (%rcx,%r14), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
movq %r12, %rsi
callq 0x2190
movq 0x10(%rbx), %rcx
movl 0x4(%rcx,%r14), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
movq %r13, %rsi
callq 0x2190
movq 0x10(%rbx), %rcx
movl 0x8(%rcx,%r14), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20e0
incq %r15
addq $0xc, %r14
jmp 0x2c4c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: print_DHT(std::map<std::pair<unsigned char, unsigned short>, unsigned char, std::less<std::pair<unsigned char, unsigned short>>, std::allocator<std::pair<std::pair<unsigned char, unsigned short> const, unsigned char>>>*)
void print_DHT(htable_t* htable) {
    cout << "[Huffman Table]" << endl;
    
    for (unsigned int i = 0; i < 4; i++) {
        cout << "  hid = " << i << endl;
        htable_t::iterator iter;

        for (htable_t::iterator iter = htable[i].begin(); iter != htable[i].end(); iter++) {
            uint8_t length = iter->first.first;
            uint16_t symbol = iter->first.second;
            uint8_t code = iter->second;
            printf("    length = %2d, symbol = %04X, code = %02X\n", length, symbol, code);
        }
    }
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60c2(%rip), %rdi      # 0x8fd0
leaq 0x327e(%rip), %rsi      # 0x6193
callq 0x2190
movq %rax, %rdi
callq 0x20e0
leaq 0x3283(%rip), %r12      # 0x61ac
xorl %r13d, %r13d
movq 0x609d(%rip), %rdi      # 0x8fd0
cmpq $0x4, %r13
je 0x2f98
leaq 0x3263(%rip), %rsi      # 0x61a3
callq 0x2190
movq %rax, %rdi
movq %r13, %rsi
callq 0x2110
movq %rax, %rdi
callq 0x20e0
imulq $0x30, %r13, %rax
leaq (%rbx,%rax), %r15
addq $0x8, %r15
movq 0x10(%r15), %r14
cmpq %r15, %r14
je 0x2f93
movzbl 0x20(%r14), %esi
movzwl 0x22(%r14), %edx
movzbl 0x24(%r14), %ecx
movq %r12, %rdi
xorl %eax, %eax
callq 0x2040
movq %r14, %rdi
callq 0x2120
movq %rax, %r14
jmp 0x2f68
incq %r13
jmp 0x2f2c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: print_SOS(sos&)
void print_SOS(sos_t& sos) {
    cout << "[SOS Information]" << endl;
    cout << "  channels = " << sos.ns << endl;
    for (unsigned int i = 0; i < sos.ns; i++) {
        cout << "    td = " << sos.cda[i].td << ", ta = " << sos.cda[i].ta << endl;
    }
    cout << "  Ss = " << sos.ss << endl;
    cout << "  Se = " << sos.se << endl;
    cout << "  Ah = " << sos.ah << endl;
    cout << "  Al = " << sos.al << endl;
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x5ea5(%rip), %r14      # 0x8fd0
leaq 0x30b5(%rip), %rsi      # 0x61e7
movq %r14, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20e0
leaq 0x3017(%rip), %rsi      # 0x6160
movq %r14, %rdi
callq 0x2190
movl (%rbx), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20e0
xorl %r13d, %r13d
leaq 0x308c(%rip), %r15      # 0x61f9
leaq 0x308f(%rip), %r12      # 0x6203
movl (%rbx), %eax
cmpq %rax, %r13
jae 0x31bf
movq %r14, %rdi
movq %r15, %rsi
callq 0x2190
movq 0x8(%rbx), %rcx
movl (%rcx,%r13,8), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
movq %r12, %rsi
callq 0x2190
movq 0x8(%rbx), %rcx
movl 0x4(%rcx,%r13,8), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20e0
incq %r13
jmp 0x3174
movq 0x5e0a(%rip), %r14      # 0x8fd0
leaq 0x303e(%rip), %rsi      # 0x620b
movq %r14, %rdi
callq 0x2190
movl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20e0
leaq 0x3024(%rip), %rsi      # 0x6213
movq %r14, %rdi
callq 0x2190
movl 0x14(%rbx), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20e0
leaq 0x300a(%rip), %rsi      # 0x621b
movq %r14, %rdi
callq 0x2190
movl 0x18(%rbx), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20e0
leaq 0x2ff0(%rip), %rsi      # 0x6223
movq %r14, %rdi
callq 0x2190
movl 0x1c(%rbx), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20e0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: init_image(int, int, int)
image_t init_image(int d1, int d2, int d3) {
    image_t image = new int16_t**[d1];

    for (int i = 0; i < d1; i++) {
        image[i] = new int16_t*[d2];

        for (int j = 0; j < d2; j++) {
            image[i][j] = new int16_t[d3];
        }
    }

    return image;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movl %esi, %ebx
movl %edi, %eax
movl %edi, %edi
shlq $0x3, %rdi
xorl %r15d, %r15d
testl %eax, %eax
pushq $-0x1
popq %r12
cmovsq %r12, %rdi
cmovlel %r15d, %eax
movq %rax, -0x40(%rbp)
callq 0x2030
movq %rax, -0x30(%rbp)
movl %ebx, %eax
movl %r14d, %r13d
shlq $0x3, %rax
addq %r13, %r13
testl %r14d, %r14d
cmovsq %r12, %r13
testl %ebx, %ebx
cmovsq %r12, %rax
movq %rax, -0x38(%rbp)
cmovlel %r15d, %ebx
cmpq -0x40(%rbp), %r15
je 0x347d
movq -0x38(%rbp), %rdi
callq 0x2030
movq %rax, %r14
movq -0x30(%rbp), %rax
movq %r14, (%rax,%r15,8)
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x3478
movq %r13, %rdi
callq 0x2030
movq %rax, (%r14,%r12,8)
incq %r12
jmp 0x3462
incq %r15
jmp 0x3445
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: delete_image(short***, int, int, int)
void delete_image(image_t image, int d1, int d2, int d3) {
    for (int i = 0; i < d1; i++) {
        for (int j = 0; j < d2; j++) {
            delete[] image[i][j];
        }
        delete[] image[i];
    }
    delete[] image;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
xorl %r12d, %r12d
testl %edx, %edx
cmovlel %r12d, %ebx
movq %rdi, %r15
testl %esi, %esi
cmovlel %r12d, %r14d
cmpq %r14, %r12
je 0x34e8
xorl %r13d, %r13d
movq (%r15,%r12,8), %rdi
cmpq %r13, %rbx
je 0x34d9
movq (%rdi,%r13,8), %rdi
testq %rdi, %rdi
je 0x34d4
callq 0x2200
incq %r13
jmp 0x34bd
testq %rdi, %rdi
je 0x34e3
callq 0x2200
incq %r12
jmp 0x34b5
testq %r15, %r15
je 0x3503
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2200
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: to_bitmap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, short***, sof&)
void to_bitmap(string filename, image_t rgb, sof_t& sof){
    bitmap_image bmp(sof.X, sof.Y);

    for (unsigned int py = 0; py < sof.Y; py++) {
        for (unsigned int px = 0; px < sof.X; px++) {
            bmp.set_pixel(
                px, py,
                (uint8_t)rgb[R][py][px],
                (uint8_t)rgb[G][py][px],
                (uint8_t)rgb[B][py][px]
            );
        }
    }

    size_t dot_i = filename.find_last_of(".");
    bmp.save_image(filename.substr(0, dot_i) + ".bmp");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x4(%rdx), %edx
movl 0x8(%r14), %esi
leaq -0xa8(%rbp), %rdi
callq 0x4570
xorl %eax, %eax
movl 0x4(%r14), %ecx
cmpq %rcx, %rax
jae 0x35b8
xorl %ecx, %ecx
movl 0x8(%r14), %edx
cmpq %rdx, %rcx
jae 0x35b3
movq (%r15), %rdx
movq 0x8(%r15), %rsi
movq (%rdx,%rax,8), %rdx
movb (%rdx,%rcx,2), %dl
movq (%rsi,%rax,8), %rsi
movb (%rsi,%rcx,2), %sil
movq 0x10(%r15), %rdi
movq (%rdi,%rax,8), %rdi
movb (%rdi,%rcx,2), %dil
movl -0x80(%rbp), %r8d
imull %eax, %r8d
movl -0x7c(%rbp), %r9d
imull %ecx, %r9d
leal (%r9,%r8), %r10d
movq -0x70(%rbp), %r11
movb %dil, (%r11,%r10)
leal (%r9,%r8), %edi
incl %edi
movq -0x70(%rbp), %r10
movb %sil, (%r10,%rdi)
leal (%r9,%r8), %esi
addl $0x2, %esi
movq -0x70(%rbp), %rdi
movb %dl, (%rdi,%rsi)
incq %rcx
jmp 0x354b
incq %rax
jmp 0x3540
leaq 0x2ce2(%rip), %rsi      # 0x62a1
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x2180
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21b0
leaq 0x2c56(%rip), %rdx      # 0x6238
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x478b
leaq -0xa8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x45ee
leaq -0x58(%rbp), %rdi
callq 0x20d0
leaq -0x38(%rbp), %rdi
callq 0x20d0
leaq -0xa8(%rbp), %rdi
callq 0x47b4
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20d0
jmp 0x363c
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20d0
jmp 0x364a
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x47b4
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: process_EOI(bool&)
bool process_EOI(bool &eoi) {
    if (debug)
        cout << "[EOI]" << endl;
    eoi = true;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x5060(%rip)      # 0x91da
jne 0x4197
movq 0x4e4d(%rip), %rdi      # 0x8fd0
leaq 0x214c(%rip), %rsi      # 0x62d6
callq 0x2190
movq %rax, %rdi
callq 0x20e0
movb $0x1, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: process_other(std::basic_ifstream<char, std::char_traits<char>>&, unsigned int)
void process_other(ifstream& jpegfile, unsigned int opt) {
    switch (opt) {
        case 0xE0: case 0xE1: case 0xE2: case 0xE3:
        case 0xE4: case 0xE5: case 0xE6: case 0xE7:
        case 0xE8: case 0xE9: case 0xEA: case 0xEB:
        case 0xEC: case 0xED: case 0xEE: case 0xEF:
            if (debug)
                cout << "[APP" << to_uint(opt) % 16 << "] len = ";
            skip(jpegfile);
            break;
        
        case COM:
            if (debug)
                cout << "[COM] len = ";
            skip(jpegfile);
            break;
        
        case DRI:
            if (debug)
                cout << "[DRI] len = ";
            skip(jpegfile);
            USE_RST = true;
            break;

        default:
            printf("[Error] unknown tag: %04X\n", opt);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leal -0xe0(%r14), %eax
cmpl $0x10, %eax
jae 0x4202
cmpb $0x1, 0x5017(%rip)      # 0x91da
jne 0x41f6
movq 0x4e04(%rip), %rdi      # 0x8fd0
leaq 0x2109(%rip), %rsi      # 0x62dc
callq 0x2190
andl $0xf, %r14d
movq %rax, %rdi
movq %r14, %rsi
callq 0x2110
leaq 0x1f9c(%rip), %rsi      # 0x618a
movq %rax, %rdi
callq 0x2190
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x243c
cmpl $0xdd, %r14d
je 0x422d
cmpl $0xfe, %r14d
jne 0x425d
cmpb $0x1, 0x4fbf(%rip)      # 0x91da
jne 0x41f6
movq 0x4dac(%rip), %rdi      # 0x8fd0
leaq 0x20b6(%rip), %rsi      # 0x62e1
jmp 0x41f1
cmpb $0x1, 0x4fa6(%rip)      # 0x91da
jne 0x4249
movq 0x4d93(%rip), %rdi      # 0x8fd0
leaq 0x20aa(%rip), %rsi      # 0x62ee
callq 0x2190
movq %rbx, %rdi
callq 0x243c
movb $0x1, 0x4f83(%rip)      # 0x91db
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2097(%rip), %rdi      # 0x62fb
movl %r14d, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/src/test-case/trigonometric.cpp
// Function: testSine(std::ostream&)
bool testSine(std::ostream &log) {
  double s, c;

  for (double x : range<double>(0, 3.14, 30, true)) {
    s = sines(x, c);

    log << "sine(" << x << ") = " << s << ":" << c << "\n";
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
xorl %r15d, %r15d
leaq 0xd864(%rip), %r12      # 0x12140
leaq 0xd862(%rip), %r13      # 0x12145
leaq 0xd8cc(%rip), %rbp      # 0x121b6
cmpq $0x1e, %r15
je 0x49b1
cvtsi2sd %r15, %xmm1
mulsd 0xd707(%rip), %xmm1     # 0x12008
addsd 0xd707(%rip), %xmm1     # 0x12010
movsd %xmm1, 0x8(%rsp)
movq $0xa, 0x20(%rsp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movsd %xmm1, 0x50(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x11454
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movq %rbx, %rdi
leaq 0xd7e1(%rip), %rsi      # 0x1213a
callq 0x4260
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x43a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x4260
movq %rax, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x43a0
movq %rax, %rdi
movq %r13, %rsi
callq 0x4260
movq %rax, %rdi
movsd 0x18(%rsp), %xmm0
callq 0x43a0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x4260
incq %r15
jmp 0x48ea
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jenniferdr[P]proyectoIAI/a_estrella.cc
// Function: compactar_full(char*)
long long int compactar_full(int8 estado[16]) {
  long long int res = 0;
  for (int i = 0; i < 16; i++) {
    res = (estado[i] | res) << 4;
  }
  res = res >> 4;
  return res;
}

// Assembly:
xorl %ecx, %ecx
xorl %eax, %eax
cmpq $0x10, %rcx
je 0x24b7
movsbq (%rdi,%rcx), %rdx
orq %rdx, %rax
shlq $0x4, %rax
incq %rcx
jmp 0x24a0
sarq $0x4, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/jenniferdr[P]proyectoIAI/algoritmos.cc
// Function: make_root(char*)
Nodo* make_root(int8 estado[16]){
  Nodo* n= new Nodo();

  for(int i=0; i<16;i++){
    n->estado[i]= estado[i];
  }
  n->distancia= 0;
  n->predecesor= NULL;

  return n;  
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x2180
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
xorl %ecx, %ecx
cmpq $0x10, %rcx
je 0x36aa
movb (%rbx,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x3699
movb $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jenniferdr[P]proyectoIAI/algoritmos.cc
// Function: make_node(Nodo*, char*)
Nodo* make_node(Nodo* padre,int8 estado[16]){
  Nodo* n= new Nodo();
  
  for(int i=0; i<16;i++){
    n->estado[i]= estado[i];
  }
  n->distancia= padre->distancia +1;
  n->predecesor= padre;

  return n;  
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x2180
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
xorl %ecx, %ecx
cmpq $0x10, %rcx
je 0x36ea
movb (%r14,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x36d8
movb 0x10(%rbx), %cl
incb %cl
movb %cl, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/jenniferdr[P]proyectoIAI/algoritmos.cc
// Function: extract_solution[abi:cxx11](Nodo*)
std::list<Nodo*> extract_solution(Nodo* n){
  std::list<Nodo*> camino;
  while(n!= NULL){
    camino.push_front(n);
    n= n->predecesor;
  }
  return camino;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
testq %rsi, %rsi
je 0x3735
movq %rbx, %rdi
movq %r14, %rsi
callq 0x388a
movq (%rsp), %rax
movq 0x18(%rax), %rsi
movq %rsi, (%rsp)
jmp 0x3717
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3896
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/jenniferdr[P]proyectoIAI/algoritmos.cc
// Function: is_goal(Nodo*)
bool is_goal(Nodo* n){
  bool r = true;
  for (int i = 0; i<16 && r; i++) {
    r = r && matrizR[i]==n->estado[i];
  }
  return r;
}

// Assembly:
movb $0x1, %al
xorl %ecx, %ecx
leaq 0x5a12(%rip), %rdx      # 0x9280
cmpq $0xf, %rcx
ja 0x3886
testb $0x1, %al
je 0x3886
movb (%rcx,%rdx), %al
cmpb (%rdi,%rcx), %al
sete %al
incq %rcx
jmp 0x386e
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jenniferdr[P]proyectoIAI/basepatrones.cc
// Function: compactar(char*, bool*)
int compactar(char estado[16], bool set[16]) {

  int res = 0;
  int p[6];
  int indice = 0;

  for (int i = 0; i < 16; i++) {
    if (i != 0 and !set[i]) continue;

    for (int j = 0; j <16; j++) {
      if (estado[j] == i) {
	p[indice] = j;
	indice++;
      }
    }
  }

  for (int i = 0; i< 6; i++) {
    res = (p[i] | res) << 4;
  }
  res = res >> 4;

  return res;
}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
movq %rax, %rdx
testq %rax, %rax
je 0x39b1
cmpq $0x10, %rax
je 0x39bc
cmpb $0x1, (%rsi,%rax)
jne 0x39b7
xorl %edx, %edx
jmp 0x39b1
movsbq (%rdi,%rdx), %r8
movl %r8d, %r8d
cmpq %r8, %rax
jne 0x39ae
movslq %ecx, %rcx
movl %edx, -0x18(%rsp,%rcx,4)
incl %ecx
incq %rdx
cmpq $0x10, %rdx
jne 0x3998
incq %rax
jmp 0x3980
xorl %ecx, %ecx
xorl %eax, %eax
cmpq $0x6, %rcx
je 0x39d2
orl -0x18(%rsp,%rcx,4), %eax
shll $0x4, %eax
incq %rcx
jmp 0x39c0
sarl $0x4, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/jenniferdr[P]proyectoIAI/basepatrones.cc
// Function: puedeMoverse(int, int)
bool puedeMoverse(int dist, int posicion_cero) {
  if (posicion_cero + dist > 15 or posicion_cero + dist < 0) return false;

  switch (posicion_cero) {
  case 4:
  case 8:
  case 12:
    return dist != -1;
    break;
  case 3:
  case 7:
  case 11:
    return dist != 1;
  }

  return true;
}

// Assembly:
leal (%rsi,%rdi), %eax
cmpl $0xf, %eax
jbe 0x39e1
xorl %eax, %eax
retq
movb $0x1, %al
cmpl $0xc, %esi
ja 0x39e0
movl $0x888, %ecx            # imm = 0x888
btl %esi, %ecx
jb 0x3a01
movl $0x1110, %ecx           # imm = 0x1110
btl %esi, %ecx
jae 0x39e0
cmpl $-0x1, %edi
jmp 0x3a04
cmpl $0x1, %edi
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/jenniferdr[P]proyectoIAI/basepatrones.cc
// Function: h_static55_M(char*)
int h_static55_M(int8 estado[16]) {
  // Busca el estado actual en dos bases de datos
  int res = bd1[compactar(estado, set1)] + bd2[compactar(estado, set2)];
  // A eso le suma la distancia manhattan del resto de las fichas
  for (int i = 0; i < 16; i++) {
    if (!set3[i]) continue;
    for (int j = 0; j < 16; j++) {
      if (estado[j] == i) {
	res += matrizH[i][j];
      }
    }
  }
  return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x547c(%rip), %rsi      # 0x9290
callq 0x397c
cltq
leaq 0x54ee(%rip), %rcx      # 0x9310
movzbl (%rax,%rcx), %ebp
leaq 0x5473(%rip), %rsi      # 0x92a0
movq %rbx, %rdi
callq 0x397c
cltq
leaq 0x10054d2(%rip), %rcx   # 0x1009310
movzbl (%rax,%rcx), %eax
addl %ebp, %eax
leaq 0x5335(%rip), %rcx      # 0x9180
xorl %edx, %edx
leaq 0x545c(%rip), %rsi      # 0x92b0
cmpq $0x10, %rdx
je 0x3e86
cmpb $0x1, (%rdx,%rsi)
jne 0x3e7d
xorl %edi, %edi
cmpq $0x10, %rdi
je 0x3e7d
movsbq (%rbx,%rdi), %r8
movl %r8d, %r8d
cmpq %r8, %rdx
jne 0x3e78
addl (%rcx,%rdi,4), %eax
incq %rdi
jmp 0x3e62
incq %rdx
addq $0x40, %rcx
jmp 0x3e54
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jenniferdr[P]proyectoIAI/basepatrones.cc
// Function: h_static5_M(char*)
int h_static5_M(int8 estado[16]) {
  // Busca el estado actual en la primera base de datos y suma la distancia
  // manhattan del resto de las fichas.
  int res = bd1[compactar(estado, set1)];
  for (int i = 0; i < 16; i++) {
    if (set1[i]) continue;
    for (int j = 0; j < 16; j++) {
      if (estado[j] == i) {
	res += matrizH[i][j];
      }
    }
  }
  return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x53f5(%rip), %r14      # 0x9290
movq %r14, %rsi
callq 0x397c
cltq
leaq 0x5464(%rip), %rcx      # 0x9310
movzbl (%rax,%rcx), %eax
leaq 0x52c9(%rip), %rcx      # 0x9180
xorl %edx, %edx
cmpq $0x10, %rdx
je 0x3eeb
cmpb $0x0, (%rdx,%r14)
je 0x3ecf
incq %rdx
addq $0x40, %rcx
jmp 0x3eb9
xorl %esi, %esi
cmpq $0x10, %rsi
je 0x3ec6
movsbq (%rbx,%rsi), %rdi
movl %edi, %edi
cmpq %rdi, %rdx
jne 0x3ee6
addl (%rcx,%rsi,4), %eax
incq %rsi
jmp 0x3ed1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jenniferdr[P]proyectoIAI/conflictos.cc
// Function: h_conflictos(char*)
int h_conflictos(int8 estado[16]) {
  int res = heuristicaManhattan(estado);
  for (int i = 0; i < 4; i++) {
    for (int j = i; j < 4; j++) {
      res += conflictos[estado[i]][estado[j]][i][j];
    }
  }
  for (int i = 4; i < 8; i++) {
    for (int j = i; j < 8; j++) {
      res += conflictos[estado[i]][estado[j]][i][j];
    }
  }
  for (int i = 8; i < 12; i++) {
    for (int j = i; j < 12; j++) {
      res += conflictos[estado[i]][estado[j]][i][j];
    }
  }
  for (int i = 8; i < 16; i++) {
    for (int j = i; j < 16; j++) {
      res += conflictos[estado[i]][estado[j]][i][j];
    }
  }

  return res;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x375b
leaq 0x3004cc6(%rip), %rcx   # 0x3009320
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x4699
movq %rcx, %rsi
movq %rdx, %rdi
cmpq $0x4, %rdi
je 0x4690
movsbq (%rbx,%rdx), %r8
movsbq (%rbx,%rdi), %r9
shlq $0xe, %r8
shlq $0xa, %r9
addq %r8, %r9
addl (%rsi,%r9), %eax
incq %rdi
addq $0x4, %rsi
jmp 0x4668
incq %rdx
addq $0x44, %rcx
jmp 0x465c
pushq $0x4
popq %rcx
leaq 0x3004d8d(%rip), %rdx   # 0x3009430
xorl %esi, %esi
cmpq $0x8, %rcx
je 0x46e6
movq %rdx, %rdi
movq %rsi, %r8
cmpq $0x4, %r8
je 0x46da
movsbq (%rbx,%rcx), %r9
movsbq 0x4(%rbx,%r8), %r10
shlq $0xe, %r9
shlq $0xa, %r10
addq %r9, %r10
addl (%rdi,%r10), %eax
incq %r8
addq $0x4, %rdi
jmp 0x46b1
incq %rcx
incq %rsi
addq $0x44, %rdx
jmp 0x46a5
pushq $0x8
popq %rcx
leaq 0x3004e50(%rip), %rdx   # 0x3009540
xorl %esi, %esi
cmpq $0xc, %rcx
je 0x4733
movq %rdx, %rdi
movq %rsi, %r8
cmpq $0x4, %r8
je 0x4727
movsbq (%rbx,%rcx), %r9
movsbq 0x8(%rbx,%r8), %r10
shlq $0xe, %r9
shlq $0xa, %r10
addq %r9, %r10
addl (%rdi,%r10), %eax
incq %r8
addq $0x4, %rdi
jmp 0x46fe
incq %rcx
incq %rsi
addq $0x44, %rdx
jmp 0x46f2
pushq $0x8
popq %rcx
leaq 0x3004e03(%rip), %rdx   # 0x3009540
xorl %esi, %esi
cmpq $0x10, %rcx
je 0x4780
movq %rdx, %rdi
movq %rsi, %r8
cmpq $0x8, %r8
je 0x4774
movsbq (%rbx,%rcx), %r9
movsbq 0x8(%rbx,%r8), %r10
shlq $0xe, %r9
shlq $0xa, %r10
addq %r9, %r10
addl (%rdi,%r10), %eax
incq %r8
addq $0x4, %rdi
jmp 0x474b
incq %rcx
incq %rsi
addq $0x44, %rdx
jmp 0x473f
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jenniferdr[P]proyectoIAI/ida_estrella.cc
// Function: DFS_acotado(int, int, int (*)(char*))
std::pair<Nodo*,int> DFS_acotado(int nodo,int t,int (*h)(int8 estado[16])){
  //std::cout << (int) n->distancia << std::endl;
  Nodo* n = &nodos[nodo];

  int c = n->distancia + peso*(*h)(n->estado);
  if ( c > t ){
    return std::pair<Nodo*,int>(NULL,c);
  }

  if (is_goal(n)) {
    return std::pair<Nodo*,int>(n,n->distancia);
  }

  int nueva_t = 1000;

  int posCero;
  //buscar posicion del cero
  for(int i = 0; i < 16; i++){
    if(n->estado[i]==0){
      posCero=i;
      break;
    }
  }
  
  for(int i=0; i<4 ;i++){

    if(!puedeMoverse(movimientos[i],posCero)) continue;

    int8* nuevoEstado = nodos[nodo+1].estado;
 
    // Generar el nuevo estado
    memcpy(nuevoEstado,n->estado,sizeof(int8)*16);
    nuevoEstado[posCero]= nuevoEstado[posCero+movimientos[i]];
    nuevoEstado[posCero+movimientos[i]]=0;

    num_nodos++;
   
    //	  if (num_nodos == 500000000) { std::exit(0); }
    //std::cout << num_nodos << "\n";

    nodos[nodo+1].distancia = nodos[nodo].distancia + 1;
    nodos[nodo+1].predecesor = n;

    std::pair<Nodo*,int> par= DFS_acotado(nodo+1, t,h);
    if (par.first!=NULL) return par;
    nueva_t= std::min(nueva_t,par.second);
  }
  return std::pair<Nodo*,int>(NULL,nueva_t);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r13d
movl %edi, 0x8(%rsp)
movslq %edi, %rax
imulq $0x28, %rax, %rax
leaq 0x3044b89(%rip), %rbp   # 0x3049330
leaq (%rax,%rbp), %rbx
movsbl 0x10(%rax,%rbp), %r14d
movl 0x3044b6c(%rip), %r15d  # 0x3049324
movq %rbx, %rdi
movq %rdx, 0x10(%rsp)
callq *%rdx
movl %eax, %r12d
imull %r15d, %r12d
addl %r14d, %r12d
movl %r13d, 0xc(%rsp)
cmpl %r13d, %r12d
jle 0x47dd
xorl %ebx, %ebx
jmp 0x48a3
movq %rbx, %rdi
callq 0x3863
testb %al, %al
je 0x47f3
movsbl 0x10(%rbx), %r12d
jmp 0x48a3
xorl %ecx, %ecx
pushq $0x10
popq %rax
cmpq $0x10, %rcx
je 0x480b
cmpb $0x0, (%rbx,%rcx)
je 0x4809
incq %rcx
jmp 0x47f8
movl %ecx, %eax
movl 0x8(%rsp), %ecx
incl %ecx
movl %ecx, 0x8(%rsp)
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rbp
movl %eax, %r13d
movl $0x3e8, %r12d           # imm = 0x3E8
xorl %r15d, %r15d
cmpq $0x10, %r15
je 0x47d6
leaq 0x18b8(%rip), %rax      # 0x60f0
movl (%r15,%rax), %r14d
movl %r14d, %edi
movl %r13d, %esi
callq 0x39d6
testb %al, %al
je 0x4897
movups (%rbx), %xmm0
movups %xmm0, (%rbp)
addl %r13d, %r14d
movslq %r14d, %rax
movb (%rbp,%rax), %cl
movb %cl, (%rbp,%r13)
movb $0x0, (%rbp,%rax)
incq 0x3044abb(%rip)         # 0x3049328
movb 0x10(%rbx), %al
incb %al
movb %al, 0x10(%rbp)
movq %rbx, 0x18(%rbp)
movl 0x8(%rsp), %edi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x4784
testq %rax, %rax
jne 0x489d
cmpl %r12d, %edx
cmovll %edx, %r12d
addq $0x4, %r15
jmp 0x482b
movq %rax, %rbx
movl %edx, %r12d
movq %rbx, %rax
movl %r12d, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jenniferdr[P]proyectoIAI/ida_estrella.cc
// Function: ida_estrella[abi:cxx11](char*, int (*)(char*))
std::list<Nodo*> ida_estrella(int8 estado[16], int (*h)(int8 inicial[16])){
  // Por eficiencia todos los nodos estaran en nodos[]
  
  // Atributos del nodo raiz
  for (int i = 0; i < 16; i++) {
    nodos[0].estado[i] = estado[i];
  }
  nodos[0].distancia = 0;
  nodos[0].predecesor = NULL;

  // (*h) es la funcion heuristica
  int t = (*h)((&nodos[0])->estado)*peso;
  Nodo* solucion;
  std::pair<Nodo*,int> par;

  while (solucion==NULL and t<1000){
    num_nodos=0;
    par = DFS_acotado(0,t,h);
    solucion= par.first;
    t= par.second;
    std::cout << " " << t;
  }
  std::cout <<" "<< num_nodos;
  return extract_solution(solucion);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x3044a5e(%rip), %rcx   # 0x3049330
cmpq $0x10, %rax
je 0x48e3
movb (%rsi,%rax), %dl
movb %dl, (%rax,%rcx)
incq %rax
jmp 0x48d2
movb $0x0, 0x3044a56(%rip)   # 0x3049340
leaq 0x3044a3f(%rip), %rdi   # 0x3049330
andq $0x0, 0x3044a4f(%rip)   # 0x3049348
callq *%r14
movl %eax, %ebp
imull 0x3044a1f(%rip), %ebp   # 0x3049324
movq 0x46cc(%rip), %r12      # 0x8fd8
leaq 0x1862(%rip), %r13      # 0x6175
testq %r15, %r15
jne 0x4950
cmpl $0x3e7, %ebp            # imm = 0x3E7
jg 0x4950
andq $0x0, 0x3044a00(%rip)   # 0x3049328
xorl %edi, %edi
movl %ebp, %esi
movq %r14, %rdx
callq 0x4784
movq %rax, %r15
movl %edx, %ebp
movq %r12, %rdi
movq %r13, %rsi
callq 0x2170
movq %rax, %rdi
movl %ebp, %esi
callq 0x2270
jmp 0x4913
movq 0x4681(%rip), %rdi      # 0x8fd8
leaq 0x1817(%rip), %rsi      # 0x6175
callq 0x2170
movq 0x30449be(%rip), %rsi   # 0x3049328
movq %rax, %rdi
callq 0x20b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x36fe
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::bigIntegers(long long)
bigIntegers(Ts pInteger) : negative(pInteger < Ts(0)), cell(0) {
    if (pInteger == Ts(0)) {
      negative = false;
    } else {
      cellType v[cellsPerLong];
      Tu q = ((pInteger < Ts(0)) ? -pInteger : pInteger);
      cellType s = 0;

      for (cellType i = 0; (q != 0) && (i < cellsPerLong); i++) {
        v[i] = cellType(q & lowMask);
        q >>= cellBitCount;
        if (v[i] != 0) {
          s = i + 1;
        }
      }

      cell.resize(s);

      for (cellType i = 0; i < s; i++) {
        cell[i] = v[i];
      }
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rax
shrq $0x3f, %rax
movb %al, (%rdi)
leaq 0x8(%rdi), %rbx
xorl %r12d, %r12d
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x15084
testq %r14, %r14
je 0x85cb
movq %r14, %rcx
negq %rcx
cmovsq %r14, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x85a7
cmpq $0x2, %rax
jae 0x85a7
movl %ecx, 0x10(%rsp,%rax,4)
movq %rcx, %rdx
shrq $0x20, %rdx
incq %rax
testl %ecx, %ecx
cmovnel %eax, %r12d
movq %rdx, %rcx
jmp 0x8583
movl %r12d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x150d6
movq (%rbx), %rax
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x85cf
movl 0x10(%rsp,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x85ba
movb $0x0, (%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x127b2
movq %r14, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::operator<<=(unsigned int const&)
bigIntegers &operator<<=(const cellType &b) {
    if (*this == zero()) {
      return *this;
    }

    if (b == zero()) {
      return *this;
    }

    if ((cell.size() * cellBitCount + b) <= longBitCount) {
      *this = bigIntegers((*this).toInteger() << b, false);
      return *this;
    }

    if (b < cellBitCount) {
      const cellType &q = b;
      const cellType negQ = (cellBitCount - q);
      const cellType mask = ((1 << q) - 1) << negQ;

      if ((cell[(cell.size() - 1)] & mask) == 0) {
        /* no additional cells needed */
        cellType overflow = 0;

        for (cellType i = 0; i < cell.size(); i++) {
          cellType newContent = (cell[i] << q) | overflow;
          overflow = (cell[i] & mask) >> negQ;
          cell[i] = newContent;
        }

        return *this;
      }
    }

    return (*this = (*this << b));
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
subq %rsi, %rdi
je 0x8693
movl (%r14), %eax
testq %rax, %rax
je 0x8693
leaq (%rax,%rdi,8), %rcx
cmpq $0x40, %rcx
ja 0x864b
movq %rbx, %rdi
callq 0x15408
movb (%r14), %cl
shlq %cl, %rax
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1543a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x154e0
jmp 0x8689
cmpl $0x1f, %eax
ja 0x866a
pushq $-0x1
popq %r8
movl %eax, %ecx
shll %cl, %r8d
notl %r8d
movl %eax, %ecx
negl %ecx
shll %cl, %r8d
testl %r8d, -0x4(%rsi,%rdi)
je 0x86a0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x15500
movq %rbx, %rdi
movq %r15, %rsi
callq 0x154e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x127b2
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
sarq $0x2, %rdi
pushq $0x20
popq %rdx
subl %eax, %edx
xorl %eax, %eax
xorl %ecx, %ecx
movl %ecx, %r9d
cmpq %r9, %rdi
jbe 0x8693
movl (%rsi,%r9,4), %r10d
movb (%r14), %cl
movl %r10d, %r11d
shll %cl, %r11d
andl %r8d, %r10d
movl %edx, %ecx
shrl %cl, %r10d
orl %eax, %r11d
movl %r11d, (%rsi,%r9,4)
leal 0x1(%r9), %ecx
movl %r10d, %eax
jmp 0x86ad
jmp 0x86dc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x127b2
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::bigIntegers(unsigned long long, bool)
bigIntegers(Tu pInteger, bool pNegative)
      : cell(0), negative((pInteger == 0) ? false : pNegative) {
    if (pInteger == Tu(0)) {
      negative = false;
    } else {
      cellType v[cellsPerLong];
      Tu q = pInteger;

      cellType s = 0;

      for (cellType i = 0; (q != 0) && (i < cellsPerLong); i++) {
        v[i] = cellType(q & lowMask);
        q >>= cellBitCount;
        if (v[i] != 0) {
          s = i + 1;
        }
      }

      cell.resize(s);

      for (cellType i = 0; i < s; i++) {
        cell[i] = v[i];
      }
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
setne %al
andb %dl, %al
movb %al, (%rdi)
leaq 0x8(%rdi), %rbx
xorl %r12d, %r12d
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x15084
testq %r14, %r14
je 0x154bc
xorl %eax, %eax
testq %r14, %r14
je 0x15498
cmpq $0x2, %rax
jae 0x15498
movl %r14d, 0x10(%rsp,%rax,4)
movq %r14, %rcx
shrq $0x20, %rcx
incq %rax
testl %r14d, %r14d
cmovnel %eax, %r12d
movq %rcx, %r14
jmp 0x15472
movl %r12d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x150d6
movq (%rbx), %rax
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x154c0
movl 0x10(%rsp,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x154ab
movb $0x0, (%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x127b2
movq %r14, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::operator=(efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u> const&)
bigIntegers &operator=(const bigIntegers &b) {
    if (this != &b) {
      negative = b.negative;
      cell = b.cell;
    }

    return *this;
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x154fa
movb (%rsi), %al
movb %al, (%rbx)
addq $0x8, %rsi
leaq 0x8(%rbx), %rdi
callq 0x156d8
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::shrink()
void shrink(void) {
    cellType i = cell.size();
    cellType rem = 0;

    if (i == 0) {
      negative = false;
      return;
    }

    while (i > 0) {
      i--;

      if (cell[i] == cellType(0)) {
        rem++;
      } else {
        break;
      }
    }

    if (rem == 0) {
      return;
    }

    cell.resize(cell.size() - rem);

    if (cell.size() == 0) {
      negative = false;
    }
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rsi
subq %rax, %rsi
sarq $0x2, %rsi
testl %esi, %esi
je 0x15862
leaq 0x8(%rbx), %rdi
movl %esi, %ecx
leaq (%rax,%rcx,4), %rdx
addq $-0x4, %rdx
xorl %eax, %eax
cmpq %rax, %rcx
je 0x15848
cmpl $0x0, (%rdx)
jne 0x1584a
incq %rax
addq $-0x4, %rdx
jmp 0x15835
movl %esi, %eax
testl %eax, %eax
je 0x15865
movl %eax, %eax
subq %rax, %rsi
callq 0x150d6
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x15865
movb $0x0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::operator%(efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u> const&) const
bigIntegers operator%(const bigIntegers &b) const {
    if (*this == zero()) {
      return zero();
    } else if (b == zero()) {
      return zero();
    } else if (b == one()) {
      return zero();
    }

    if ((cell.size() <= cellsPerLong) && (b.cell.size() <= cellsPerLong)) {
      return bigIntegers((*this).toInteger() % (b).toInteger(), negative);
    }

    bigIntegers r;
    const bigIntegers &ap = negative ? -*this : *this;
    const bigIntegers &bp = b.negative ? -b : b;

    if (b.cell.size() == 1) {
      r.doModuloHorner(ap, b.cell[0]);
    } /*
                              else if (b.cell.size() < (cellsPerLong - 1))
                              {
                                  r.doModuloHorner(ap, bp);
                              }
      */
    else {
      r.doModulo(ap, bp);
    }

    r.negative = negative;

    return r;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x15901
movq %rdx, %r15
movq 0x10(%rdx), %rax
cmpq 0x8(%rdx), %rax
je 0x15901
movq %rsi, %r14
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x15d04
testb %al, %al
je 0x1591a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8542
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
cmpq $0x8, %rax
ja 0x15967
movq 0x10(%r15), %rax
subq 0x8(%r15), %rax
cmpq $0x8, %rax
ja 0x15967
movq %r14, %rdi
callq 0x15408
movq %rax, %r12
movq %r15, %rdi
callq 0x15408
movq %rax, %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
movzbl (%r14), %eax
movq %rbx, %rdi
movq %rdx, %rsi
movl %eax, %edx
callq 0x1543a
jmp 0x1590b
movq %rbx, %rdi
callq 0x157f8
cmpb $0x1, (%r14)
jne 0x15984
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x158b6
jmp 0x15991
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x157d4
cmpb $0x1, (%r15)
jne 0x159a6
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x158b6
jmp 0x159b3
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x157d4
movq 0x8(%r15), %rdx
movq 0x10(%r15), %rax
subq %rdx, %rax
cmpq $0x4, %rax
jne 0x159d6
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rcx
movq %rbx, %rdi
callq 0x15d24
jmp 0x159eb
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
callq 0x15da4
movb (%r14), %al
movb %al, (%rbx)
leaq 0x30(%rsp), %rdi
callq 0x127b2
leaq 0x10(%rsp), %rdi
callq 0x127b2
jmp 0x1590b
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x127b2
jmp 0x15a1b
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x127b2
jmp 0x15a2a
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x127b2
movq %r14, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::operator/=(efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u> const&)
bigIntegers &operator/=(const bigIntegers &b) {
    if (*this == zero()) {
      return (*this = zero());
    } else if (b == zero()) {
      return (*this = zero());
    } else if (b == one()) {
      return *this;
    } else if (b == negativeOne()) {
      return (*this = -*this);
    }

    if ((cell.size() <= cellsPerLong) && (b.cell.size() <= cellsPerLong)) {
      *this = bigIntegers((*this).toInteger() / (b).toInteger(),
                          (negative != b.negative));
      return *this;
    }

    bool rnegative = (negative != b.negative);
    const bigIntegers &aa = negative ? -*this : *this;
    const bigIntegers &ba = b.negative ? -b : b;
    doDivide(aa, ba);
    negative = rnegative && (cell.size() > 0);
    return *this;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq 0x8(%rdi), %rax
je 0x15ad9
movq %rsi, %r14
movq 0x10(%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x15af5
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x15d04
testb %al, %al
jne 0x15b1c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x164b2
testb %al, %al
je 0x15b2a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x158b6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x154e0
jmp 0x15b0f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x8542
movq %rbx, %rdi
movq %r14, %rsi
callq 0x154e0
jmp 0x15b0f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x8542
movq %rbx, %rdi
movq %r14, %rsi
callq 0x154e0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x127b2
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
cmpq $0x8, %rax
ja 0x15b8b
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
cmpq $0x8, %rax
ja 0x15b8b
movq %rbx, %rdi
callq 0x15408
movq %rax, %r15
movq %r14, %rdi
callq 0x15408
movq %rax, %rcx
movq %r15, %rax
xorl %edx, %edx
divq %rcx
movb (%rbx), %cl
xorl %edx, %edx
cmpb (%r14), %cl
setne %dl
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1543a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x154e0
jmp 0x15b12
movb (%rbx), %bpl
movb (%r14), %r15b
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
cmpb $0x1, %bpl
jne 0x15ba6
callq 0x158b6
jmp 0x15bab
callq 0x157d4
cmpb $0x1, (%r14)
jne 0x15bc0
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x158b6
jmp 0x15bcd
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x157d4
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
callq 0x164d2
cmpb %r15b, %bpl
setne %al
movq 0x8(%rbx), %rcx
cmpq %rcx, 0x10(%rbx)
setne %cl
andb %al, %cl
movb %cl, (%rbx)
leaq 0x30(%rsp), %rdi
callq 0x127b2
jmp 0x15b12
jmp 0x15c1d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x127b2
jmp 0x15c20
jmp 0x15c1d
jmp 0x15c1d
jmp 0x15c1d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x127b2
movq %rbx, %rdi
callq 0x4430