LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0xcd9d(%rip), %rdi      # 0xffd0
leaq 0x7ee9(%rip), %rsi      # 0xb123
callq 0x21b0
movq %rax, %rdi
movq 0xcd77(%rip), %rsi      # 0xffc0
callq 0x21f0
movl $0x8, -0xc(%rbp)
movl $0x8, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x332f
movq 0xcd5c(%rip), %rdi      # 0xffd0
leaq 0x7ebd(%rip), %rsi      # 0xb138
callq 0x21b0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2330
movq %rax, %rdi
movq 0xcd2b(%rip), %rsi      # 0xffc0
callq 0x21f0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x331f
movq 0xcd20(%rip), %rdi      # 0xffd0
leaq 0x7e8a(%rip), %rsi      # 0xb141
callq 0x21b0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3301
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x18(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %esi
leaq 0x7e57(%rip), %rdi      # 0xb146
movb $0x0, %al
callq 0x2040
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x32c3
movq 0xccc8(%rip), %rdi      # 0xffd0
movq 0xccb1(%rip), %rsi      # 0xffc0
callq 0x21f0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x32a1
jmp 0x3321
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3263
movq 0xcc9a(%rip), %rdi      # 0xffd0
movq 0xcc83(%rip), %rsi      # 0xffc0
callq 0x21f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq 0x2230
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x16(%rbp), %rsi
movl $0x1, %edx
callq 0x2230
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movb -0x15(%rbp), %al
movsbl %al, %edi
movsbl -0x16(%rbp), %esi
callq 0x61d0
movl %eax, -0x1c(%rbp)
testb $0x1, 0xce64(%rip)      # 0x1021a
je 0x33e5
movq 0xcc11(%rip), %rdi      # 0xffd0
leaq 0x7d85(%rip), %rsi      # 0xb14b
callq 0x21b0
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x2260
movq %rax, %rdi
movq 0xcbe0(%rip), %rsi      # 0xffc0
callq 0x21f0
jmp 0x33e7
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x3483
movq -0x8(%rbp), %rdi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
callq 0x2230
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movsbl -0x1d(%rbp), %edi
callq 0x6210
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
sarl $0x4, %eax
movl %eax, -0x24(%rbp)
movsbl -0x1d(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x40, -0x2c(%rbp)
jge 0x347e
movq -0x8(%rbp), %rdi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
callq 0x2230
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movsbl -0x1d(%rbp), %edi
callq 0x6210
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3435
jmp 0x33e7
xorl %eax, %eax
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xcb2d(%rip), %rdi      # 0xffd0
leaq 0x7cae(%rip), %rsi      # 0xb158
callq 0x21b0
movq %rax, %rdi
movq 0xcb07(%rip), %rsi      # 0xffc0
callq 0x21f0
movq 0xcb0b(%rip), %rdi      # 0xffd0
leaq 0x7c9e(%rip), %rsi      # 0xb16a
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x2260
movq %rax, %rdi
movq 0xcad7(%rip), %rsi      # 0xffc0
callq 0x21f0
movq 0xcadb(%rip), %rdi      # 0xffd0
leaq 0x7c7d(%rip), %rsi      # 0xb179
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x2260
movq %rax, %rdi
movq 0xcaa6(%rip), %rsi      # 0xffc0
callq 0x21f0
movq 0xcaaa(%rip), %rdi      # 0xffd0
leaq 0x7c58(%rip), %rsi      # 0xb185
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x2260
movq %rax, %rdi
movq 0xca75(%rip), %rsi      # 0xffc0
callq 0x21f0
movq 0xca79(%rip), %rdi      # 0xffd0
leaq 0x7c32(%rip), %rsi      # 0xb190
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x2260
movq %rax, %rdi
movq 0xca44(%rip), %rsi      # 0xffc0
callq 0x21f0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x363c
movq 0xca31(%rip), %rdi      # 0xffd0
leaq 0x7bf8(%rip), %rsi      # 0xb19e
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %esi
callq 0x2260
movq %rax, %rdi
leaq 0x7bd6(%rip), %rsi      # 0xb1a7
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %esi
callq 0x2260
movq %rax, %rdi
leaq 0x7bb1(%rip), %rsi      # 0xb1ae
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
callq 0x2260
movq %rax, %rdi
movq 0xc997(%rip), %rsi      # 0xffc0
callq 0x21f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3588
movq 0xc98d(%rip), %rdi      # 0xffd0
movq 0xc976(%rip), %rsi      # 0xffc0
callq 0x21f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq 0xc64d(%rip), %rdi      # 0xffd0
leaq 0x7839(%rip), %rsi      # 0xb1c3
callq 0x21b0
movq %rax, %rdi
movq 0xc627(%rip), %rsi      # 0xffc0
callq 0x21f0
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jae 0x3a92
movq 0xc61a(%rip), %rdi      # 0xffd0
leaq 0x7816(%rip), %rsi      # 0xb1d3
callq 0x21b0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2260
movq %rax, %rdi
movq 0xc5e9(%rip), %rsi      # 0xffc0
callq 0x21f0
leaq -0x18(%rbp), %rdi
callq 0x6280
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x62a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x6300
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x62d0
testb $0x1, %al
jne 0x3a26
jmp 0x3a82
leaq -0x20(%rbp), %rdi
callq 0x6330
movb (%rax), %al
movb %al, -0x29(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6330
movw 0x2(%rax), %ax
movw %ax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6330
movb 0x4(%rax), %al
movb %al, -0x2d(%rbp)
movzbl -0x29(%rbp), %esi
movzwl -0x2c(%rbp), %edx
movzbl -0x2d(%rbp), %ecx
leaq 0x7775(%rip), %rdi      # 0xb1dc
movb $0x0, %al
callq 0x2040
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x6360
movq %rax, -0x38(%rbp)
jmp 0x39fc
jmp 0x3a84
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x39a5
movq 0xc537(%rip), %rdi      # 0xffd0
movq 0xc520(%rip), %rsi      # 0xffc0
callq 0x21f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xc2cd(%rip), %rdi      # 0xffd0
leaq 0x750d(%rip), %rsi      # 0xb217
callq 0x21b0
movq %rax, %rdi
movq 0xc2a7(%rip), %rsi      # 0xffc0
callq 0x21f0
movq 0xc2ab(%rip), %rdi      # 0xffd0
leaq 0x7464(%rip), %rsi      # 0xb190
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x2260
movq %rax, %rdi
movq 0xc277(%rip), %rsi      # 0xffc0
callq 0x21f0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x3dc9
movq 0xc269(%rip), %rdi      # 0xffd0
leaq 0x74bb(%rip), %rsi      # 0xb229
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,8), %esi
callq 0x2260
movq %rax, %rdi
leaq 0x74a0(%rip), %rsi      # 0xb233
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movl 0x4(%rax,%rcx,8), %esi
callq 0x2260
movq %rax, %rdi
movq 0xc207(%rip), %rsi      # 0xffc0
callq 0x21f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3d55
movq 0xc200(%rip), %rdi      # 0xffd0
leaq 0x7464(%rip), %rsi      # 0xb23b
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x2260
movq %rax, %rdi
movq 0xc1cb(%rip), %rsi      # 0xffc0
callq 0x21f0
movq 0xc1cf(%rip), %rdi      # 0xffd0
leaq 0x743b(%rip), %rsi      # 0xb243
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x2260
movq %rax, %rdi
movq 0xc19a(%rip), %rsi      # 0xffc0
callq 0x21f0
movq 0xc19e(%rip), %rdi      # 0xffd0
leaq 0x7412(%rip), %rsi      # 0xb24b
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x2260
movq %rax, %rdi
movq 0xc169(%rip), %rsi      # 0xffc0
callq 0x21f0
movq 0xc16d(%rip), %rdi      # 0xffd0
leaq 0x73e9(%rip), %rsi      # 0xb253
callq 0x21b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0x2260
movq %rax, %rdi
movq 0xc138(%rip), %rsi      # 0xffc0
callq 0x21f0
movq 0xc13c(%rip), %rdi      # 0xffd0
movq 0xc125(%rip), %rsi      # 0xffc0
callq 0x21f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movslq -0x4(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x41e7
movslq -0x8(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x41d7
movslq -0xc(%rbp), %rax
movl $0x2, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4188
jmp 0x41d9
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4141
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4293
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x4267
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x425a
movq -0x28(%rbp), %rdi
callq 0x2240
jmp 0x425c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x422b
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x4286
movq -0x30(%rbp), %rdi
callq 0x2240
jmp 0x4288
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x421c
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x42aa
movq -0x38(%rbp), %rdi
callq 0x2240
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0xd0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
leaq -0x68(%rbp), %rdi
callq 0x6440
movl $0x0, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x4381
movl $0x0, -0x70(%rbp)
movl -0x70(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x4371
movl -0x70(%rbp), %eax
movl %eax, %edi
movl %edi, %esi
movl -0x6c(%rbp), %eax
movl %eax, %r9d
movl %r9d, %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rax), %r8
movq (%rcx,%r9,8), %rcx
movzbl (%rcx,%rdi,2), %ecx
movq (%r8,%r9,8), %r8
movzbl (%r8,%rdi,2), %r8d
movq 0x10(%rax), %rax
movq (%rax,%r9,8), %rax
movzbl (%rax,%rdi,2), %r9d
leaq -0x68(%rbp), %rdi
callq 0x6510
jmp 0x4353
jmp 0x4355
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x4303
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x444c
jmp 0x4373
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x42ec
movq -0xd0(%rbp), %rdi
leaq 0x6f42(%rip), %rsi      # 0xb2d1
movq $-0x1, %rdx
callq 0x21a0
movq -0xd0(%rbp), %rsi
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0xc8(%rbp), %rdi
callq 0x21d0
jmp 0x43c2
leaq 0x6e9f(%rip), %rdx      # 0xb268
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x6980
jmp 0x43de
leaq -0x68(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x65e0
jmp 0x43f0
leaq -0xa8(%rbp), %rdi
callq 0x2120
leaq -0xc8(%rbp), %rdi
callq 0x2120
leaq -0x68(%rbp), %rdi
callq 0x69d0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x4440
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x2120
leaq -0xc8(%rbp), %rdi
callq 0x2120
leaq -0x68(%rbp), %rdi
callq 0x69d0
movq -0x78(%rbp), %rdi
callq 0x2340
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
testb $0x1, 0xa627(%rip)      # 0x1021a
je 0x5c17
movq 0xa3d4(%rip), %rdi      # 0xffd0
leaq 0x5703(%rip), %rsi      # 0xb306
callq 0x21b0
movq %rax, %rdi
movq 0xa3ae(%rip), %rsi      # 0xffc0
callq 0x21f0
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
xorl %eax, %eax
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0xdd, %eax
je 0x5cea
jmp 0x5c52
movl -0x10(%rbp), %eax
addl $0xffffff20, %eax       # imm = 0xFFFFFF20
subl $0x10, %eax
jb 0x5c70
jmp 0x5c61
movl -0x10(%rbp), %eax
subl $0xfe, %eax
je 0x5cc3
jmp 0x5d18
testb $0x1, 0xa5a3(%rip)      # 0x1021a
je 0x5cb8
movq 0xa350(%rip), %rdi      # 0xffd0
leaq 0x5685(%rip), %rsi      # 0xb30c
callq 0x21b0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movsbl %al, %edi
callq 0x6210
movq -0x18(%rbp), %rdi
movl %eax, %esi
andl $0xf, %esi
callq 0x2260
movq %rax, %rdi
leaq 0x5507(%rip), %rsi      # 0xb1ba
callq 0x21b0
movq -0x8(%rbp), %rdi
callq 0x24c0
jmp 0x5d29
testb $0x1, 0xa550(%rip)      # 0x1021a
je 0x5cdf
movq 0xa2fd(%rip), %rdi      # 0xffd0
leaq 0x5637(%rip), %rsi      # 0xb311
callq 0x21b0
movq -0x8(%rbp), %rdi
callq 0x24c0
jmp 0x5d29
testb $0x1, 0xa529(%rip)      # 0x1021a
je 0x5d06
movq 0xa2d6(%rip), %rdi      # 0xffd0
leaq 0x561d(%rip), %rsi      # 0xb31e
callq 0x21b0
movq -0x8(%rbp), %rdi
callq 0x24c0
movb $0x1, 0xa505(%rip)      # 0x1021b
jmp 0x5d29
movl -0xc(%rbp), %esi
leaq 0x5609(%rip), %rdi      # 0xb32b
movb $0x0, %al
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x2e439(%rip), %xmm0    # 0x34008
movsd %xmm0, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movl $0x1e, %ecx
movl $0x1, %r8d
callq 0x65e0
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x6670
movq -0x20(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x66b0
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x66f0
testb $0x1, %al
jne 0x5c28
jmp 0x5ccc
leaq -0x60(%rbp), %rdi
callq 0x6760
movsd %xmm0, -0x80(%rbp)
movq $0xa, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x5ce0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2e59d(%rip), %rsi     # 0x34202
callq 0x5350
movq %rax, %rdi
movsd -0x80(%rbp), %xmm0
callq 0x5610
movq %rax, %rdi
leaq 0x2e587(%rip), %rsi     # 0x34208
callq 0x5350
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x5610
movq %rax, %rdi
leaq 0x2e570(%rip), %rsi     # 0x3420d
callq 0x5350
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x5610
movq %rax, %rdi
leaq 0x2e59b(%rip), %rsi     # 0x34254
callq 0x5350
leaq -0x60(%rbp), %rdi
callq 0x67b0
jmp 0x5c12
movb $0x1, %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/trigonometric.h
// Function: double efgy::math::sines<double, unsigned long long>(double const&, double&, unsigned long long const&)
static inline Q sines(const Q &pTheta, Q &oCosine,
                      const N &iterations = N(10)) {
  complex<Q> z =
      e<complex<Q>, N>(complex<Q>(Q(1), Q(0)), complex<Q>(Q(0), pTheta),
                       complex<Q>(Q(0), Q(0)), iterations);

  oCosine = z.one;

  return z.i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd 0x2e311(%rip), %xmm0    # 0x34010
movsd %xmm0, -0x78(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x329a0
xorps %xmm0, %xmm0
movsd %xmm0, -0x98(%rbp)
movq -0x8(%rbp), %rdx
leaq -0x90(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x329a0
xorps %xmm0, %xmm0
movsd %xmm0, -0xb0(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0xb8(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x329a0
movq -0x18(%rbp), %rsi
movsd -0x70(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
movsd -0x90(%rbp), %xmm2
movsd -0x88(%rbp), %xmm3
movsd -0xa8(%rbp), %xmm4
movsd -0xa0(%rbp), %xmm5
leaq -0x60(%rbp), %rdi
callq 0x329d0
leaq -0x60(%rbp), %rdi
callq 0x32a60
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x2631
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbq (%rax,%rcx), %rax
orq -0x10(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2607
movq -0x10(%rbp), %rax
sarq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x2120
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x7a9f
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7a78
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x28, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x2120
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jge 0x7b23
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7afc
movq -0x8(%rbp), %rax
movsbl 0x10(%rax), %eax
addl $0x1, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7e60
cmpq $0x0, -0x10(%rbp)
je 0x7baf
movq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x7e80
jmp 0x7b8a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x7b74
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x7ec0
jmp 0x7bcc
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x7bc2
movq -0x38(%rbp), %rdi
callq 0x7ec0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: jenniferdr[P]proyectoIAI/algoritmos.cc
// Function: heuristicaManhattan(char*)
int heuristicaManhattan(int8 estado[16]){
  return matrizH[estado[0]][0] + matrizH[estado[1]][1]
    + matrizH[estado[2]][2] + matrizH[estado[3]][3]
    + matrizH[estado[4]][4] + matrizH[estado[5]][5]
    + matrizH[estado[6]][6] + matrizH[estado[7]][7]
    + matrizH[estado[8]][8] + matrizH[estado[9]][9]
    + matrizH[estado[10]][10] + matrizH[estado[11]][11]
    + matrizH[estado[12]][12] + matrizH[estado[13]][13]
    + matrizH[estado[14]][14] + matrizH[estado[15]][15];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbq (%rax), %rcx
leaq 0xb5c9(%rip), %rax      # 0x131e0
shlq $0x4, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
movq -0x8(%rbp), %rcx
movsbq 0x1(%rcx), %rdx
leaq 0xb5af(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0x1(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movsbq 0x2(%rcx), %rdx
leaq 0xb592(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0x2(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movsbq 0x3(%rcx), %rdx
leaq 0xb575(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0x3(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movsbq 0x4(%rcx), %rdx
leaq 0xb558(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0x4(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movsbq 0x5(%rcx), %rdx
leaq 0xb53b(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0x5(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movsbq 0x6(%rcx), %rdx
leaq 0xb51e(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0x6(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movsbq 0x7(%rcx), %rdx
leaq 0xb501(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0x7(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movsbq 0x8(%rcx), %rdx
leaq 0xb4e4(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0x8(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movsbq 0x9(%rcx), %rdx
leaq 0xb4c7(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0x9(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movsbq 0xa(%rcx), %rdx
leaq 0xb4aa(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0xa(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movsbq 0xb(%rcx), %rdx
leaq 0xb48d(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0xb(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movsbq 0xc(%rcx), %rdx
leaq 0xb470(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0xc(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movsbq 0xd(%rcx), %rdx
leaq 0xb453(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0xd(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movsbq 0xe(%rcx), %rdx
leaq 0xb436(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0xe(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movsbq 0xf(%rcx), %rdx
leaq 0xb419(%rip), %rcx      # 0x131e0
shlq $0x4, %rdx
addq %rdx, %rcx
movsbl 0xf(%rcx), %ecx
addl %ecx, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movb $0x1, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x10, -0x10(%rbp)
movb %al, -0x11(%rbp)
jge 0x7e04
movb -0x9(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x7e0d
jmp 0x7e4e
xorl %eax, %eax
testb $0x1, -0x9(%rbp)
movb %al, -0x12(%rbp)
je 0x7e3b
movslq -0x10(%rbp), %rcx
leaq 0xb4bd(%rip), %rax      # 0x132e0
movsbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7df3
movb -0x9(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x10, -0x38(%rbp)
jge 0x8589
cmpl $0x0, -0x38(%rbp)
je 0x853d
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
testb $0x1, (%rax,%rcx)
jne 0x853d
jmp 0x857e
movl $0x0, -0x3c(%rbp)
cmpl $0x10, -0x3c(%rbp)
jge 0x857c
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x38(%rbp), %eax
jne 0x856f
movl -0x3c(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x30(%rbp,%rax,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x8571
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x8544
jmp 0x857e
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x8521
movl $0x0, -0x40(%rbp)
cmpl $0x6, -0x40(%rbp)
jge 0x85b2
movslq -0x40(%rbp), %rax
movl -0x30(%rbp,%rax,4), %eax
orl -0x14(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x14(%rbp)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x8590
movl -0x14(%rbp), %eax
sarl $0x4, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl -0x8(%rbp), %eax
cmpl $0xf, %eax
jg 0x85e0
movl -0xc(%rbp), %eax
addl -0x8(%rbp), %eax
cmpl $0x0, %eax
jge 0x85e6
movb $0x0, -0x1(%rbp)
jmp 0x8645
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x3, %eax
je 0x8633
jmp 0x85f3
movl -0x10(%rbp), %eax
subl $0x4, %eax
je 0x8625
jmp 0x85fd
movl -0x10(%rbp), %eax
subl $0x7, %eax
je 0x8633
jmp 0x8607
movl -0x10(%rbp), %eax
subl $0x8, %eax
je 0x8625
jmp 0x8611
movl -0x10(%rbp), %eax
subl $0xb, %eax
je 0x8633
jmp 0x861b
movl -0x10(%rbp), %eax
subl $0xc, %eax
jne 0x8641
jmp 0x8625
cmpl $-0x1, -0x8(%rbp)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x8645
cmpl $0x1, -0x8(%rbp)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x8645
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa539(%rip), %rsi      # 0x132f0
callq 0x8500
movslq %eax, %rcx
leaq 0xa5aa(%rip), %rax      # 0x13370
movzbl (%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa528(%rip), %rsi      # 0x13300
callq 0x8500
movl %eax, %ecx
movl -0x18(%rbp), %eax
movslq %ecx, %rdx
leaq 0x100a584(%rip), %rcx   # 0x1013370
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x10, -0x10(%rbp)
jge 0x8e6c
movslq -0x10(%rbp), %rcx
leaq 0xa503(%rip), %rax      # 0x13310
testb $0x1, (%rax,%rcx)
jne 0x8e15
jmp 0x8e61
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x8e5f
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x10(%rbp), %eax
jne 0x8e52
movslq -0x10(%rbp), %rcx
leaq 0xa3a2(%rip), %rax      # 0x131e0
shlq $0x6, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x8e54
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8e1c
jmp 0x8e61
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8dfc
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa459(%rip), %rsi      # 0x132f0
callq 0x8500
movslq %eax, %rcx
leaq 0xa4ca(%rip), %rax      # 0x13370
movzbl (%rax,%rcx), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x10, -0x10(%rbp)
jge 0x8f24
movslq -0x10(%rbp), %rcx
leaq 0xa42b(%rip), %rax      # 0x132f0
testb $0x1, (%rax,%rcx)
je 0x8ecd
jmp 0x8f19
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x8f17
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x10(%rbp), %eax
jne 0x8f0a
movslq -0x10(%rbp), %rcx
leaq 0xa2ea(%rip), %rax      # 0x131e0
shlq $0x6, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x8f0c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8ed4
jmp 0x8f19
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8eb4
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jge 0xad60
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movslq -0x1c(%rbp), %rcx
leaq 0x304863e(%rip), %rax   # 0x3053390
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xad36
movb $0x0, 0x3048639(%rip)   # 0x30533a0
movq $0x0, 0x3048636(%rip) # 0x30533a8
leaq 0x3048617(%rip), %rdi   # 0x3053390
callq *-0x18(%rbp)
imull 0x3048601(%rip), %eax   # 0x3053384
movl %eax, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xb040
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x69(%rbp)
jne 0xada8
cmpl $0x3e8, -0x20(%rbp)     # imm = 0x3E8
setl %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0xadb1
jmp 0xae1d
movq $0x0, 0x30485cc(%rip) # 0x3053388
movl -0x20(%rbp), %esi
movq -0x18(%rbp), %rdx
xorl %edi, %edi
callq 0xaad0
movl %edx, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb060
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movq 0x81d7(%rip), %rdi      # 0x12fd8
leaq 0x135d(%rip), %rsi      # 0xc165
callq 0x21a0
movq %rax, %rdi
movl -0x20(%rbp), %esi
callq 0x2310
jmp 0xad8f
movq 0x81b4(%rip), %rdi      # 0x12fd8
leaq 0x133a(%rip), %rsi      # 0xc165
callq 0x21a0
movq %rax, %rdi
movq 0x304854e(%rip), %rsi   # 0x3053388
callq 0x2110
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7b50
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rcx
shrq $0x3f, %rcx
movb %cl, (%rax)
addq $0x8, %rax
movq %rax, -0x58(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3c2b0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x3c2d0
jmp 0xf97a
leaq -0x11(%rbp), %rdi
callq 0x3c340
cmpq $0x0, -0x10(%rbp)
jne 0xf9b0
movq -0x60(%rbp), %rax
movb $0x0, (%rax)
jmp 0xfaae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x3c340
jmp 0xfab4
cmpq $0x0, -0x10(%rbp)
jge 0xf9c3
xorl %eax, %eax
subq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0xf9cb
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x69(%rbp)
je 0xf9fa
movl -0x40(%rbp), %eax
cmpq $0x2, %rax
setb %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0xfa03
jmp 0xfa46
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x38(%rbp), %rax
movl %eax, %ecx
movl -0x40(%rbp), %eax
movl %ecx, -0x2c(%rbp,%rax,4)
movq -0x38(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x38(%rbp)
movl -0x40(%rbp), %eax
cmpl $0x0, -0x2c(%rbp,%rax,4)
je 0xfa39
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xfa3b
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xf9e1
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x3c360
jmp 0xfa5a
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jae 0xfaac
movq -0x60(%rbp), %rdi
movl -0x44(%rbp), %eax
movl -0x2c(%rbp,%rax,4), %eax
movl %eax, -0x70(%rbp)
addq $0x8, %rdi
movl -0x44(%rbp), %eax
movl %eax, %esi
callq 0x3c3f0
movl -0x70(%rbp), %ecx
movl %ecx, (%rax)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xfa61
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x320e0
jmp 0xfab4
jmp 0xfaae
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x55e0
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/big-integers.h
// Function: efgy::math::numeric::bigIntegers<long long, unsigned long long, unsigned int, 32u>::toInteger() const
Tu toInteger(void) const {
    Tu r = 0;

    if (cell.size() == 0) {
      return 0;
    }

    for (cellType i = 0; i < cell.size(); i++) {
      r |= Tu(cell[i]) << (i * cellBitCount);
    }

    return r;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
addq $0x8, %rdi
callq 0x3c9c0
cmpq $0x0, %rax
jne 0x3d225
movq $0x0, -0x8(%rbp)
jmp 0x3d286
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
callq 0x3c9c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x3d27e
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x3d8a0
movl (%rax), %eax
movl -0x1c(%rbp), %ecx
shll $0x5, %ecx
movl %ecx, %ecx
shlq %cl, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3d22c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3d2bd
xorl %eax, %eax
movb %al, -0x51(%rbp)
jmp 0x3d2c3
movb -0x11(%rbp), %al
movb %al, -0x51(%rbp)
movq -0x50(%rbp), %rax
movb -0x51(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
addq $0x8, %rax
movq %rax, -0x68(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3c2b0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x3c2d0
jmp 0x3d2f7
leaq -0x12(%rbp), %rdi
callq 0x3c340
cmpq $0x0, -0x10(%rbp)
jne 0x3d32d
movq -0x50(%rbp), %rax
movb $0x0, (%rax)
jmp 0x3d410
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x3c340
jmp 0x3d416
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x69(%rbp)
je 0x3d35c
movl -0x40(%rbp), %eax
cmpq $0x2, %rax
setb %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x3d365
jmp 0x3d3a8
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x38(%rbp), %rax
movl %eax, %ecx
movl -0x40(%rbp), %eax
movl %ecx, -0x2c(%rbp,%rax,4)
movq -0x38(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x38(%rbp)
movl -0x40(%rbp), %eax
cmpl $0x0, -0x2c(%rbp,%rax,4)
je 0x3d39b
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3d39d
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x3d343
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x3c360
jmp 0x3d3bc
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jae 0x3d40e
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %eax
movl -0x2c(%rbp,%rax,4), %eax
movl %eax, -0x70(%rbp)
addq $0x8, %rdi
movl -0x44(%rbp), %eax
movl %eax, %esi
callq 0x3c3f0
movl -0x70(%rbp), %ecx
movl %ecx, (%rax)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x3d3c3
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x320e0
jmp 0x3d416
jmp 0x3d410
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x55e0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x3d45d
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, (%rdi)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x3d8c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)