LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: OpenFirework[P]MyJPEG_Decoder/./jpeg/jpeg_decoder.cpp
// Function: createhuftable(int*, unsigned char*, int, std::vector<hufcode, std::allocator<hufcode>>&)
void createhuftable(int tree[16], byte *value, int length, std::vector<hufcode> &OUTT) {
    int comlength = 0;
    for (int i = 0; i<16; i++) {
        comlength += tree[i];
    }
    if (comlength != length) {
        std::cout << "data error, length not match\n";
    }
    int left = 0;
    int right = 0;
    int index = 0;
    int last_depth = 0;

    for (int i = 0; i<16; i++) {
        int nums = tree[i];
        if (index != 0) {
            int mul = pow(2, i + 1 - last_depth);
            left = (right + 1)*mul;
        }
        else {
            left = 0;
        }
        if (nums != 0) {
            last_depth = i + 1;
            int cur_value = left;
            for (int j = 0; j<nums; j++) {
                hufcode unit;
                unit.codeLength = i+1;
                unit.encodeValue = cur_value++;
                unit.realVale = value[index++];
                OUTT.push_back(unit);
            }
            right = cur_value - 1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x10, -0x28(%rbp)
jge 0x3de7
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3dc5
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x3e02
movq 0x71da(%rip), %rdi      # 0xafd0
leaq 0x4831(%rip), %rsi      # 0x862e
callq 0x2130
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x10, -0x3c(%rbp)
jge 0x3ef7
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x3e6c
movl -0x3c(%rbp), %esi
addl $0x1, %esi
subl -0x38(%rbp), %esi
movl $0x2, %edi
callq 0x4ab0
cvttsd2si %xmm0, %eax
movl %eax, -0x44(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
imull -0x44(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x3e73
movl $0x0, -0x2c(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0x3ee7
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x40(%rbp), %eax
jge 0x3ede
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
movl -0x48(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x48(%rbp)
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x34(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x50(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4ae0
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x3e8f
movl -0x48(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3ee9
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3e25
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: OpenFirework[P]MyJPEG_Decoder/./jpeg/jpeg_decoder.cpp
// Function: getBit(unsigned char*&)
bool getBit(byte *&framedata) {
    static unsigned char buf;
    static unsigned char count = 0;
    if (count == 0) {
        memcpy(&buf, framedata++, 1);
        if (buf == 0xFF) {
            unsigned char check;
            memcpy(&check, framedata++, 1);
            if (check != 0x00) {
                fprintf(stderr, "data 段有不是 0xFF00 的数据\n");
            }
        }
    }
    bool ret = buf & (1 << (7 - count));
    count = (count == 7 ? 0 : count + 1);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movzbl 0x81ce(%rip), %eax      # 0xc0e1
cmpl $0x0, %eax
jne 0x3f7a
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %al
movb %al, 0x81af(%rip)       # 0xc0e0
movzbl 0x81a8(%rip), %eax      # 0xc0e0
cmpl $0xff, %eax
jne 0x3f78
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
je 0x3f76
movq 0x7073(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x46dd(%rip), %rsi      # 0x864c
movb $0x0, %al
callq 0x21e0
jmp 0x3f78
jmp 0x3f7a
movzbl 0x815f(%rip), %eax      # 0xc0e0
movzbl 0x8159(%rip), %edx      # 0xc0e1
movl $0x7, %ecx
subl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0xa(%rbp)
movzbl 0x8135(%rip), %eax      # 0xc0e1
cmpl $0x7, %eax
jne 0x3fb8
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x3fc5
movzbl 0x8122(%rip), %eax      # 0xc0e1
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movb %al, 0x8113(%rip)       # 0xc0e1
movb -0xa(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: OpenFirework[P]MyJPEG_Decoder/./jpeg/jpeg_decoder.cpp
// Function: MCU::quantify()
void quantify() {
        for (int id = 1; id <= 3; id++) {
            for (int h = 0; h < subVector[id].height; h++) {
                for (int w = 0; w < subVector[id].width; w++) {
                    for (int i = 0; i < 8; i++) {
                        for (int j = 0; j < 8; j++) {
                            mcu[id][h][w][i][j] *= quantTable[subVector[id].quant][i*8 + j];
                        }
                    }
                }
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jg 0x501d
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0x71ba(%rip), %rcx      # 0xc0d0
movzbl 0x2(%rcx,%rdx,4), %ecx
cmpl %ecx, %eax
jge 0x500d
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0x7198(%rip), %rcx      # 0xc0d0
movzbl 0x1(%rcx,%rdx,4), %ecx
cmpl %ecx, %eax
jge 0x4ffd
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0x4fed
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x4fdd
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rdx
leaq 0x715e(%rip), %rcx      # 0xc0d0
movzbl 0x3(%rcx,%rdx,4), %ecx
movl %ecx, %edx
leaq 0x68e0(%rip), %rcx      # 0xb860
shlq $0x9, %rdx
addq %rdx, %rcx
movl -0x18(%rbp), %edx
shll $0x3, %edx
addl -0x1c(%rbp), %edx
movslq %edx, %rdx
cvtsi2sdl (%rcx,%rdx,4), %xmm0
movslq -0xc(%rbp), %rcx
shlq $0xb, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
shlq $0x9, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f5d
jmp 0x4fdf
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4f4c
jmp 0x4fef
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4f2a
jmp 0x4fff
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4f08
jmp 0x500f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4ef7
popq %rbp
retq
nop
// File: OpenFirework[P]MyJPEG_Decoder/./jpeg/jpeg_decoder.cpp
// Function: MCU::chomp(double)
unsigned char chomp(double x) {
        if (x > 255.0) {
            return 255;
        } else if (x < 0) {
            return 0;
        } else {
            return (unsigned char) x;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x2886(%rip), %xmm1     # 0x8050
ucomisd %xmm1, %xmm0
jbe 0x57d6
movb $-0x1, -0x1(%rbp)
jmp 0x57ee
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x57e6
movb $0x0, -0x1(%rbp)
jmp 0x57ee
cvttsd2si -0x18(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: OpenFirework[P]MyJPEG_Decoder/./bmp/bmp_code.cpp
// Function: MyBMP::BMP::showBmpHead(tagBITMAPFILEHEADER)
void MyBMP::BMP::showBmpHead(BITMAPFILEHEADER pBmpHead) {
    printf("BMP文件大小：%dkb\n", pBmpHead.bfSize/1024);
    printf("保留字必须为0：%d\n",  pBmpHead.bfReserved1);
    printf("保留字必须为0：%d\n",  pBmpHead.bfReserved2);
    printf("实际位图数据的偏移字节数: %d\n",  pBmpHead.bfOffBits);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
shrl $0xa, %esi
leaq 0x2032(%rip), %rdi      # 0x86e3
movb $0x0, %al
callq 0x2040
movzwl -0x8(%rbp), %esi
leaq 0x2038(%rip), %rdi      # 0x86fb
movb $0x0, %al
callq 0x2040
movzwl -0x6(%rbp), %esi
leaq 0x2026(%rip), %rdi      # 0x86fb
movb $0x0, %al
callq 0x2040
movl -0x4(%rbp), %esi
leaq 0x202f(%rip), %rdi      # 0x8715
movb $0x0, %al
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: OpenFirework[P]MyJPEG_Decoder/./bmp/bmp_code.cpp
// Function: MyBMP::BMP::showBmpInfoHead(tagBITMAPINFOHEADER)
void MyBMP::BMP::showBmpInfoHead(BITMAPINFOHEADER pBmpinfoHead)
{
    //定义显示信息的函数，传入的是信息头结构体
    printf("位图信息头:\n" );
    printf("信息头的大小:%d\n" ,pBmpinfoHead.biSize);
    printf("位图宽度:%d\n" ,pBmpinfoHead.biWidth);
    printf("位图高度:%d\n" ,pBmpinfoHead.biHeight);
    printf("图像的位面数(位面数是调色板的数量,默认为1个调色板):%d\n" ,pBmpinfoHead.biPlanes);
    printf("每个像素的位数:%d\n" ,pBmpinfoHead.biBitCount);
    printf("压缩方式:%d\n" ,pBmpinfoHead.biCompression);
    printf("图像的大小:%d\n" ,pBmpinfoHead.biSizeImage);
    printf("水平方向分辨率:%d\n" ,pBmpinfoHead.biXPelsPerMeter);
    printf("垂直方向分辨率:%d\n" ,pBmpinfoHead.biYPelsPerMeter);
    printf("使用的颜色数:%d\n" ,pBmpinfoHead.biClrUsed);
    printf("重要颜色数:%d\n" ,pBmpinfoHead.biClrImportant);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x2024(%rip), %rdi      # 0x873f
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0x2022(%rip), %rdi      # 0x8751
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x2024(%rip), %rdi      # 0x8768
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x2020(%rip), %rdi      # 0x8779
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movzwl 0xc(%rax), %esi
leaq 0x201b(%rip), %rdi      # 0x878a
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movzwl 0xe(%rax), %esi
leaq 0x2053(%rip), %rdi      # 0x87d8
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0x2058(%rip), %rdi      # 0x87f2
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
leaq 0x2054(%rip), %rdi      # 0x8803
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0x2053(%rip), %rdi      # 0x8817
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %esi
leaq 0x2058(%rip), %rdi      # 0x8831
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
leaq 0x205d(%rip), %rdi      # 0x884b
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movl 0x24(%rax), %esi
leaq 0x205f(%rip), %rdi      # 0x8862
movb $0x0, %al
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
// File: rfotino[P]consolite-assembler/src/asm.cpp
// Function: main
int main(int argc, char **argv) {
  if (3 != argc) {
    usage(argv[0]);
    return 1;
  }

  Tokenizer tokenizer(argv[1]);
  Parser parser(&tokenizer, argv[2]);
  if (!parser.firstPass() || !parser.secondPass()) {
    remove(argv[2]);
    return 1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4f0, %rsp            # imm = 0x4F0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x3, %eax
cmpl -0x8(%rbp), %eax
je 0x483b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x47b0
movl $0x1, -0x4(%rbp)
jmp 0x49d7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x4e0(%rbp)
leaq -0x241(%rbp), %rdi
movq %rdi, -0x4d8(%rbp)
callq 0x23b0
movq -0x4e0(%rbp), %rsi
movq -0x4d8(%rbp), %rdx
leaq -0x240(%rbp), %rdi
callq 0x49f0
jmp 0x4879
leaq -0x220(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x56a0
jmp 0x488e
leaq -0x240(%rbp), %rdi
callq 0x2120
leaq -0x241(%rbp), %rdi
callq 0x2260
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq -0x4c8(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x4aa0
jmp 0x48c3
leaq -0x4c8(%rbp), %rdi
callq 0xb120
movb %al, -0x4e1(%rbp)
jmp 0x48d7
movb -0x4e1(%rbp), %al
testb $0x1, %al
jne 0x48e3
jmp 0x4907
leaq -0x4c8(%rbp), %rdi
callq 0xbd10
movb %al, -0x4e2(%rbp)
jmp 0x48f7
movb -0x4e2(%rbp), %al
testb $0x1, %al
jne 0x499e
jmp 0x4907
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x23d0
movl $0x1, -0x4(%rbp)
movl $0x1, -0x4cc(%rbp)
jmp 0x49af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
jmp 0x495c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x2120
leaq -0x241(%rbp), %rdi
callq 0x2260
jmp 0x49e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
jmp 0x49c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x4c8(%rbp), %rdi
callq 0x4b80
jmp 0x49c9
movl $0x0, -0x4(%rbp)
movl $0x1, -0x4cc(%rbp)
leaq -0x4c8(%rbp), %rdi
callq 0x4b80
leaq -0x220(%rbp), %rdi
callq 0x4bd0
jmp 0x49d7
leaq -0x220(%rbp), %rdi
callq 0x4bd0
jmp 0x49e3
movl -0x4(%rbp), %eax
addq $0x4f0, %rsp            # imm = 0x4F0
popq %rbp
retq
movq -0x250(%rbp), %rdi
callq 0x23a0
nop
// File: rfotino[P]consolite-assembler/src/tokenizer.cpp
// Function: Tokenizer::_isValidLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Tokenizer::_isValidLabel(const std::string& label) {
  // Labels must have nonzero length and cannot start with a digit
  if (0 == label.size() || isdigit(label[0])) {
    return false;
  }
  // All characters in label must be either alphanumeric or
  // the underscore character.
  for (size_t i = 0; i < label.size(); i++) {
    if ('_' != label[i] && !isalnum(label[i])) {
      return false;
    }
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2150
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x57ad
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2280
movsbl (%rax), %edi
callq 0x21d0
cmpl $0x0, %eax
je 0x57b3
movb $0x0, -0x1(%rbp)
jmp 0x5825
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2150
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x5821
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2280
movsbl (%rax), %ecx
movl $0x5f, %eax
cmpl %ecx, %eax
je 0x5811
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2280
movsbl (%rax), %edi
callq 0x2210
cmpl $0x0, %eax
jne 0x5811
movb $0x0, -0x1(%rbp)
jmp 0x5825
jmp 0x5813
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x57bb
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: rfotino[P]consolite-assembler/src/tokenizer.cpp
// Function: Tokenizer::_isValidData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Tokenizer::_isValidData(const std::string& text) {
  // Data must start with '0x' and must be followed by at least
  // one digit.
  if (text.size() < 3 || '0' != text[0] || 'x' != text[1]) {
    return false;
  }
  // Data after the initial '0x' must be hexadecimal
  for (size_t i = 2; i < text.size(); i++) {
    if (-1 == _getHexVal(text[i])) {
      return false;
    }
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2150
cmpq $0x3, %rax
jb 0x588a
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2280
movsbl (%rax), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jne 0x588a
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x2280
movsbl (%rax), %ecx
movl $0x78, %eax
cmpl %ecx, %eax
je 0x5890
movb $0x0, -0x1(%rbp)
jmp 0x58f4
movq $0x2, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2150
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x58f0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2280
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x5900
movsbl %al, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x58e0
movb $0x0, -0x1(%rbp)
jmp 0x58f4
jmp 0x58e2
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5898
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: rfotino[P]consolite-assembler/src/tokenizer.cpp
// Function: Tokenizer::_getHexVal(char const&)
char Tokenizer::_getHexVal(const char& c) {
  if ('0' <= c && c <= '9') {
    return c - '0';
  } else if ('a' <= c && c <= 'f') {
    return 10 + c - 'a';
  } else if ('A' <= c && c <= 'F') {
    return 10 + c - 'A';
  } else {
    return -1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x5937
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x5937
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movb %al, -0x1(%rbp)
jmp 0x5997
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0x5965
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x66, %eax
jg 0x5965
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
addl $0xa, %eax
subl $0x61, %eax
movb %al, -0x1(%rbp)
jmp 0x5997
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0x5993
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x46, %eax
jg 0x5993
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
addl $0xa, %eax
subl $0x41, %eax
movb %al, -0x1(%rbp)
jmp 0x5997
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: rfotino[P]consolite-assembler/src/tokenizer.cpp
// Function: Tokenizer::_getData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Tokenizer::_getData(const std::string& text, std::string& data) {
  size_t i;
  if (text.size() & 1) {
    data.push_back(_getHexVal(text[2]));
    i = 3;
  } else {
    data.push_back((_getHexVal(text[2]) << 4) | _getHexVal(text[3]));
    i = 4;
  }
  for (; i < text.size(); i += 2) {
    data.push_back((_getHexVal(text[i]) << 4) | _getHexVal(text[i+1]));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2150
andq $0x1, %rax
cmpq $0x0, %rax
je 0x5a07
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x2280
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x5900
movq -0x30(%rbp), %rdi
movsbl %al, %esi
callq 0x21a0
movq $0x3, -0x20(%rbp)
jmp 0x5a6a
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x2280
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x5900
movsbl %al, %eax
shll $0x4, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x2280
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x5900
movq -0x40(%rbp), %rdi
movb %al, %cl
movl -0x34(%rbp), %eax
movsbl %cl, %ecx
orl %ecx, %eax
movsbl %al, %esi
callq 0x21a0
movq $0x4, -0x20(%rbp)
jmp 0x5a6c
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2150
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x5af7
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2280
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x5900
movsbl %al, %eax
shll $0x4, %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
callq 0x2280
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x5900
movq -0x58(%rbp), %rdi
movb %al, %cl
movl -0x4c(%rbp), %eax
movsbl %cl, %ecx
orl %ecx, %eax
movsbl %al, %esi
callq 0x21a0
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
jmp 0x5a6c
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: jasmeet13n[P]HTTP-Proxy-Server-Client/proxy.cpp
// Function: get_msg_type(char*)
uint8_t get_msg_type(char *packet){	// extract 7 bit type of message from packet
	uint8_t type;
	type = (unsigned char)packet[1];
	type &= 0x7F;
	return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x7f, %eax
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jasmeet13n[P]HTTP-Proxy-Server-Client/proxy.cpp
// Function: unpacki16(char*)
unsigned short int unpacki16(char *buf){	//change  network byte order to the host order (16bit)
	unsigned short int i;
	memcpy(&i,buf,2);
	i = ntohs(i);
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %ax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %edi
callq 0x3670
movw %ax, -0xa(%rbp)
movw -0xa(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jasmeet13n[P]HTTP-Proxy-Server-Client/proxy.cpp
// Function: unpacki32(char*)
unsigned long unpacki32(char *buf){	//change  network byte order to the host order (32bit)
	unsigned long i;
	memcpy(&i,buf,2);
	i = ntohl(i);
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %ax
movw %ax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl %eax, %edi
callq 0x34f0
movl %eax, %eax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jasmeet13n[P]HTTP-Proxy-Server-Client/proxy.cpp
// Function: bringToFront(int)
void bringToFront(int block){
	if(cache[block].last==1)
		return;
	//cout << "Bringing to Front " << block << endl;
	cache[block].last = 1;
	for(int i=0; i<SIZE; i++){
		if(i!=block){
			cache[i].last++;
			if(cache[i].last>SIZE)
				cache[i].last = SIZE;
		}
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x128de(%rip), %rax     # 0x16540
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x3c73
jmp 0x3cf9
movslq -0x4(%rbp), %rcx
leaq 0x128c2(%rip), %rax     # 0x16540
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl $0x1, (%rax)
movl $0x0, -0x8(%rbp)
cmpl $0xa, -0x8(%rbp)
jge 0x3cf7
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
je 0x3cea
movslq -0x8(%rbp), %rcx
leaq 0x12895(%rip), %rax     # 0x16540
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movslq -0x8(%rbp), %rcx
leaq 0x1287c(%rip), %rax     # 0x16540
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
cmpl $0xa, (%rax)
jle 0x3ce8
movslq -0x8(%rbp), %rcx
leaq 0x12865(%rip), %rax     # 0x16540
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl $0xa, (%rax)
jmp 0x3cea
jmp 0x3cec
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3c92
jmp 0x3cf9
popq %rbp
retq
nopl (%rax,%rax)
// File: jasmeet13n[P]HTTP-Proxy-Server-Client/proxy.cpp
// Function: getFreeBlock()
int getFreeBlock(){
	int end = SIZE;
	int ans = -1;
	//for(int i=0; i<SIZE; i++)
	//	cout << cache[i].last << ",";
	//cout << endl;
	while(end>0){
		for(int i=0; i<SIZE; i++){
			if(cache[i].last==end && cache[i].inUse==0){
				ans = i;
				cache[ans].inUse=-2;
				//cache[ans].last=1;
				//cout << "Ans: "<< ans << endl;
				end=0;
				break;
			}
		}
		end--;
	}
	return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xa, -0x4(%rbp)
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, -0x4(%rbp)
jle 0x3d9d
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x3d8f
movslq -0xc(%rbp), %rcx
leaq 0x1280c(%rip), %rax     # 0x16540
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x3d82
movslq -0xc(%rbp), %rcx
leaq 0x127f3(%rip), %rax     # 0x16540
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x4(%rax)
jne 0x3d82
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x127d5(%rip), %rax     # 0x16540
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movl $0xfffffffe, 0x4(%rax)  # imm = 0xFFFFFFFE
movl $0x0, -0x4(%rbp)
jmp 0x3d8f
jmp 0x3d84
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3d23
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3d12
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jasmeet13n[P]HTTP-Proxy-Server-Client/proxy.cpp
// Function: checkCache(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int checkCache(string host_file){
	if(whichBlock.find(host_file)==whichBlock.end()){
		return -1;
	}
	int cb = whichBlock[host_file];
	if(cache[cb].host_file == host_file)
		return cb;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, %rsi
movq %rsi, -0x30(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x126e6(%rip), %rdi     # 0x164b0
callq 0x7390
movq %rax, -0x18(%rbp)
leaq 0x126d6(%rip), %rdi     # 0x164b0
callq 0x73c0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7360
testb $0x1, %al
jne 0x3df6
jmp 0x3dff
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3e48
movq -0x30(%rbp), %rsi
leaq 0x126a6(%rip), %rdi     # 0x164b0
callq 0x73f0
movq -0x30(%rbp), %rsi
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rax
leaq 0x1271d(%rip), %rdi     # 0x16540
imulq $0x50, %rax, %rax
addq %rax, %rdi
addq $0x30, %rdi
callq 0x74d0
testb $0x1, %al
jne 0x3e39
jmp 0x3e41
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3e48
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jasmeet13n[P]HTTP-Proxy-Server-Client/proxy.cpp
// Function: isExpired(int)
bool isExpired(int cb){
	time_t raw_time;
	time(&raw_time);
	struct tm * utc;
	utc = gmtime(&raw_time);
	raw_time = mktime(utc);
	//cout << "CACHE : " << cache[cb].expr << " :: CURRENT : " << raw_time << endl;
	if(cache[cb].expr-raw_time>0)
		return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3380
leaq -0x10(%rbp), %rdi
callq 0x3350
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3240
movq %rax, -0x10(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x126a7(%rip), %rax     # 0x16540
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movslq 0x8(%rax), %rax
subq -0x10(%rbp), %rax
cmpq $0x0, %rax
jle 0x3eb4
movb $0x0, -0x1(%rbp)
jmp 0x3eb8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jasmeet13n[P]HTTP-Proxy-Server-Client/proxy.cpp
// Function: parse_http_request(char*, int)
struct info * parse_http_request(char *buf, int num_bytes){
	struct info* output = (struct info *)malloc(sizeof(struct info));
	int i;
	for(i=0; i<num_bytes; i++){
		if(buf[i]==' '){
			i++;
			break;
		}
	}
	int k=0;
	output->file[0]='/';
	if(buf[i+8]=='\r' && buf[i+9]=='\n'){
		output->file[1]='\0';
	}
	else{
		while(buf[i]!=' ')
			output->file[k++]=buf[i++];
		output->file[k]='\0';
	}
	i+=1;
	while(buf[i++]!=' ');
	k=0;
	while(buf[i]!='\r')
		output->host[k++]=buf[i++];
	output->host[k]='\0';
	return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x800, %edi            # imm = 0x800
callq 0x3530
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3f45
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x3f38
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f45
jmp 0x3f3a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f14
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb $0x2f, (%rax)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x3f89
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x9, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x3f89
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
jmp 0x3fd4
jmp 0x3f8b
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x3fc8
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x3f8b
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x3ffa
jmp 0x3fdd
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
je 0x4042
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movb %dl, 0x400(%rax,%rcx)
jmp 0x4001
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, 0x400(%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: clementino1971[P]ICC065-protoTerminal/protoTerminal.cpp
// Function: runCommand(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void runCommand(vector<string> command){
    if(command.empty()) return;

    if(command[0] == "pwd") {
            pwd(dir);
    }

    //run special functions
    if(mapa.find(command[0]) != mapa.end()){
        void (*choice)(vector<string>);
        choice = mapa[command[0]];
        choice(command);
    }else{
        run(command);
    }
    return;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x4c10
testb $0x1, %al
jne 0x37ae
jmp 0x37b3
jmp 0x38ce
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4c80
movq %rax, %rdi
leaq 0x683a(%rip), %rsi      # 0xa004
callq 0x4c50
testb $0x1, %al
jne 0x37d5
jmp 0x37e1
leaq 0xbbb4(%rip), %rdi      # 0xf390
callq 0x9410
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4c80
movq %rax, %rsi
leaq 0xbb00(%rip), %rdi      # 0xf2f8
callq 0x4cd0
movq %rax, -0x10(%rbp)
leaq 0xbaf0(%rip), %rdi      # 0xf2f8
callq 0x4d00
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4ca0
testb $0x1, %al
jne 0x3824
jmp 0x388e
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4c80
movq %rax, %rsi
leaq 0xbabd(%rip), %rdi      # 0xf2f8
callq 0x4d30
movq -0x68(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4e10
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rax
callq *%rax
jmp 0x386c
leaq -0x38(%rbp), %rdi
callq 0x4f00
jmp 0x38cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4f00
jmp 0x38d7
movq -0x68(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4e10
movq -0x80(%rbp), %rdi
callq 0x9440
jmp 0x38aa
leaq -0x60(%rbp), %rdi
callq 0x4f00
jmp 0x38cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4f00
jmp 0x38d7
jmp 0x38ce
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x34e0
// File: clementino1971[P]ICC065-protoTerminal/protoTerminal.cpp
// Function: balance(char const*, char)
char balance(const char* a, char del=0) {
    int i = 0;
    while(a[i]!=0) {
        if(!del) {
            if((i==0 || a[i-1]!='\\') && possible_delimiters.count(a[i])) del=a[i];
        }
        else {
            if((i==0 || a[i-1]!='\\') && a[i]==del) del=0;
        }
        i++;
    } 
    return del;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x42c1
cmpb $0x0, -0x9(%rbp)
jne 0x427d
cmpl $0x0, -0x10(%rbp)
je 0x4250
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
je 0x427b
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rax
addq %rax, %rsi
leaq 0xb0c6(%rip), %rdi      # 0xf328
callq 0x50e0
cmpq $0x0, %rax
je 0x427b
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
jmp 0x42b3
cmpl $0x0, -0x10(%rbp)
je 0x4299
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
je 0x42b1
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x42b1
movb $0x0, -0x9(%rbp)
jmp 0x42b3
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4219
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: clementino1971[P]ICC065-protoTerminal/protoTerminal.cpp
// Function: clean_backwards(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string clean_backwards(string a) {
    string cleaned="";
    for(int i = a.size()-1;i>=0;i--) {
        if((i==0 || a[i-1]!='\\') && special_characters.count(a[i]));
        else cleaned = a[i]+cleaned;
    } 
    return cleaned;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x34f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x5ddd(%rip), %rsi      # 0xa0ef
callq 0x5140
jmp 0x4319
leaq -0x12(%rbp), %rdi
callq 0x32f0
movq -0x68(%rbp), %rdi
callq 0x31d0
subq $0x1, %rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x4420
cmpl $0x0, -0x28(%rbp)
je 0x4365
movq -0x68(%rbp), %rdi
movl -0x28(%rbp), %eax
decl %eax
movslq %eax, %rsi
callq 0x3560
movq %rax, -0x70(%rbp)
jmp 0x4359
movq -0x70(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0x43cb
movq -0x68(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x3560
movq %rax, -0x78(%rbp)
jmp 0x4378
movq -0x78(%rbp), %rsi
leaq 0xafd5(%rip), %rdi      # 0xf358
callq 0x50e0
movq %rax, -0x80(%rbp)
jmp 0x438e
movq -0x80(%rbp), %rax
cmpq $0x0, %rax
je 0x43cb
jmp 0x4410
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x32f0
jmp 0x4440
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31a0
jmp 0x4440
movq -0x68(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x3560
movq %rax, -0x88(%rbp)
jmp 0x43e1
movq -0x58(%rbp), %rdx
movq -0x88(%rbp), %rax
movsbl (%rax), %esi
leaq -0x48(%rbp), %rdi
callq 0x51f0
jmp 0x43fa
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3360
leaq -0x48(%rbp), %rdi
callq 0x31a0
jmp 0x4412
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4332
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4433
movq -0x58(%rbp), %rdi
callq 0x31a0
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34e0
nopl (%rax)
// File: clementino1971[P]ICC065-protoTerminal/source/commands.cpp
// Function: ls(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void ls(vector<string> args){
	struct dirent *namelist;
	// copia o diretorio passado
    char dir[FILENAME_MAX];

    if(args.size()<=1) getcwd(dir,FILENAME_MAX);
    else strcpy(dir,args[1].c_str());

	DIR *drt =opendir(dir);
    
	if(!drt){
		if(errno == ENOENT){
			perror("Directory does not exist");
		} else {
			perror("Unable to read the repository");
			exit(EXIT_FAILURE);
		}
	}

	//aqui ele le as entradas do diretorios
	// entradas = aquivos, diretorios etc 
	// ele le com o readdir

	while ((namelist = readdir(drt)) != NULL){
		if(namelist->d_name[0] == '.') continue;
        if(namelist->d_type==DT_DIR){
            printf(ANSI_COLOR_CYAN STYLE_BOLD "%s/\n", namelist->d_name);
            printf(STYLE_NO_BOLD);
            printf(ANSI_COLOR_RESET);

            continue;
        }
		std::cout << namelist->d_name << "\n";
	}
	std::cout << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x1020(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x4f60
cmpq $0x1, %rax
ja 0x92d4
leaq -0x1010(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x3160
jmp 0x930a
movq -0x1020(%rbp), %rdi
leaq -0x1010(%rbp), %rax
movq %rax, -0x1028(%rbp)
movl $0x1, %esi
callq 0x4c80
movq %rax, %rdi
callq 0x3100
movq -0x1028(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
leaq -0x1010(%rbp), %rdi
callq 0x3440
movq %rax, -0x1018(%rbp)
cmpq $0x0, -0x1018(%rbp)
jne 0x9357
callq 0x3050
cmpl $0x2, (%rax)
jne 0x933f
leaq 0xd73(%rip), %rdi       # 0xa0ab
callq 0x3230
jmp 0x9355
leaq 0xd7e(%rip), %rdi       # 0xa0c4
callq 0x3230
movl $0x1, %edi
callq 0x3350
jmp 0x9357
jmp 0x9359
movq -0x1018(%rbp), %rdi
callq 0x3460
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x93e7
movq -0x10(%rbp), %rax
movsbl 0x13(%rax), %eax
cmpl $0x2e, %eax
jne 0x937e
jmp 0x9359
movq -0x10(%rbp), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
jne 0x93bf
movq -0x10(%rbp), %rsi
addq $0x13, %rsi
leaq 0xd48(%rip), %rdi       # 0xa0e2
movb $0x0, %al
callq 0x3060
leaq 0xd48(%rip), %rdi       # 0xa0f0
movb $0x0, %al
callq 0x3060
leaq 0xd40(%rip), %rdi       # 0xa0f6
movb $0x0, %al
callq 0x3060
jmp 0x9359
movq -0x10(%rbp), %rsi
addq $0x13, %rsi
movq 0x5bfa(%rip), %rdi      # 0xefc8
callq 0x3280
movq %rax, %rdi
leaq 0xd11(%rip), %rsi       # 0xa0ee
callq 0x3280
jmp 0x9359
movq 0x5bda(%rip), %rdi      # 0xefc8
leaq 0xcf9(%rip), %rsi       # 0xa0ee
callq 0x3280
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: clementino1971[P]ICC065-protoTerminal/source/commands.cpp
// Function: cd(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void cd(vector<string> args){
	
    if(args.size()<=1) {
        fprintf(stderr,"cd deve ter ao menos um parâmetro\n");
        return;
    }

    char dir[FILENAME_MAX];
    char newDir[FILENAME_MAX];
    char currDir[FILENAME_MAX];

    getcwd(currDir, FILENAME_MAX);
    strcpy(dir,args[1].c_str());

    //pega permissao para voltar pra main
    uid_t uid = getuid();
    struct passwd* pwd = getpwuid(uid);
    //comando pra voltar pra main

    if(dir=="." || dir=="$HOME" || dir =="~"){
        chdir(pwd->pw_dir);
    }else{
        chdir(dir);
    }

    //verifica se o diretorio eh valido
    getcwd(newDir, FILENAME_MAX);
    if(strcmp(currDir,newDir) != 0) strcpy(currDir,newDir);
    else std::cout<<"cd:"<< dir <<": No such file or directory"<<"\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3030, %rsp           # imm = 0x3030
movq %rdi, -0x3028(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x4f60
cmpq $0x1, %rax
ja 0x969e
movq 0x5948(%rip), %rax      # 0xefd0
movq (%rax), %rdi
leaq 0xa73(%rip), %rsi       # 0xa105
movb $0x0, %al
callq 0x33f0
jmp 0x97d7
leaq -0x3010(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x3160
movq -0x3028(%rbp), %rdi
leaq -0x1010(%rbp), %rax
movq %rax, -0x3030(%rbp)
movl $0x1, %esi
callq 0x4c80
movq %rax, %rdi
callq 0x3100
movq -0x3030(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
callq 0x3150
movl %eax, -0x3014(%rbp)
movl -0x3014(%rbp), %edi
callq 0x3330
movq %rax, -0x3020(%rbp)
leaq -0x1010(%rbp), %rax
leaq 0xa19(%rip), %rcx       # 0xa129
cmpq %rcx, %rax
je 0x973b
leaq -0x1010(%rbp), %rax
leaq 0xa08(%rip), %rcx       # 0xa12b
cmpq %rcx, %rax
je 0x973b
leaq -0x1010(%rbp), %rax
leaq 0x9fb(%rip), %rcx       # 0xa131
cmpq %rcx, %rax
jne 0x974d
movq -0x3020(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3420
jmp 0x9759
leaq -0x1010(%rbp), %rdi
callq 0x3420
leaq -0x2010(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x3160
leaq -0x3010(%rbp), %rdi
leaq -0x2010(%rbp), %rsi
callq 0x33d0
cmpl $0x0, %eax
je 0x9797
leaq -0x3010(%rbp), %rdi
leaq -0x2010(%rbp), %rsi
callq 0x3270
jmp 0x97d7
movq 0x582a(%rip), %rdi      # 0xefc8
leaq 0x98e(%rip), %rsi       # 0xa133
callq 0x3280
movq %rax, %rdi
leaq -0x1010(%rbp), %rsi
callq 0x3280
movq %rax, %rdi
leaq 0x974(%rip), %rsi       # 0xa137
callq 0x3280
movq %rax, %rdi
leaq 0x91c(%rip), %rsi       # 0xa0ee
callq 0x3280
addq $0x3030, %rsp           # imm = 0x3030
popq %rbp
retq
// File: marxn[P]pupp/3rdparty/gmp/gen-jacobitab.c
// Function: main
int
main (int argc, char **argv)
{
  unsigned bits;

  for (bits = 0; bits < 208; bits++)
    {
      unsigned e, a, b, d_old, d, q;

      if (bits && !(bits & 0xf))
	printf("\n");

      q = bits & 3;
      d = (bits >> 2) & 1;

      e = JACOBI_E (bits >> 3);
      a = JACOBI_A (bits >> 3);
      b = JACOBI_B (bits >> 3);
      d_old = JACOBI_D (bits >> 3);

      if (d != d_old && a == 3 && b == 3)
	e ^= 1;

      if (d == 1)
	{
	  if (b == 2)
	    e ^= (q & (a >> 1)) ^ (q >> 1);
	  a = (a - q * b) & 3;
	}
      else
	{
	  if (a == 2)
	    e ^= (q & (b >> 1)) ^ (q >> 1);
	  b = (b - q * a) & 3;
	}

      printf("%2d,", (encode (a, b, d) << 1) | e);
    }
  printf("\n");

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xd0, -0x14(%rbp)
jae 0x12c9
cmpl $0x0, -0x14(%rbp)
je 0x11a9
movl -0x14(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x11a9
leaq 0xe62(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movl -0x14(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %eax
shrl $0x2, %eax
andl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %eax
shrl $0x3, %eax
andl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
shrl $0x3, %eax
shrl %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xea3(%rip), %rax       # 0x2080
movzbl (%rax,%rcx,2), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
shrl $0x3, %eax
shrl %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xe89(%rip), %rax       # 0x2080
movzbl 0x1(%rax,%rcx,2), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
shrl $0x3, %eax
shrl %eax
cmpl $0x7, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x1232
cmpl $0x3, -0x1c(%rbp)
jne 0x1232
cmpl $0x3, -0x20(%rbp)
jne 0x1232
movl -0x18(%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x28(%rbp)
jne 0x1269
cmpl $0x2, -0x20(%rbp)
jne 0x1255
movl -0x2c(%rbp), %eax
movl -0x1c(%rbp), %ecx
shrl %ecx
andl %ecx, %eax
movl -0x2c(%rbp), %ecx
shrl %ecx
xorl %ecx, %eax
xorl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl -0x2c(%rbp), %ecx
imull -0x20(%rbp), %ecx
subl %ecx, %eax
andl $0x3, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1298
cmpl $0x2, -0x1c(%rbp)
jne 0x1286
movl -0x2c(%rbp), %eax
movl -0x20(%rbp), %ecx
shrl %ecx
andl %ecx, %eax
movl -0x2c(%rbp), %ecx
shrl %ecx
xorl %ecx, %eax
xorl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl -0x2c(%rbp), %ecx
imull -0x1c(%rbp), %ecx
subl %ecx, %eax
andl $0x3, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x12e0
movl %eax, %esi
shll %esi
orl -0x18(%rbp), %esi
leaq 0xd52(%rip), %rdi       # 0x2006
movb $0x0, %al
callq 0x1040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x117d
leaq 0xd34(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: marxn[P]pupp/3rdparty/gmp/gen-jacobitab.c
// Function: encode
static unsigned
encode (unsigned a, unsigned b, unsigned d)
{
  unsigned i;

  assert (d < 2);
  assert (a < 4);
  assert (b < 4);
  assert ( (a | b ) & 1);

  if (a == 3 && b == 3)
    return d ? 7 : 12;

  for (i = 0; i < 12; i++)
    if (decode_table[i].a == a
	&& decode_table[i].b == b)
      return i;

  abort ();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x2, -0x10(%rbp)
jae 0x12f9
jmp 0x1318
leaq 0xd0b(%rip), %rdi       # 0x200b
leaq 0xd0a(%rip), %rsi       # 0x2011
movl $0x47, %edx
leaq 0xd0e(%rip), %rcx       # 0x2021
callq 0x1050
cmpl $0x4, -0x8(%rbp)
jae 0x1320
jmp 0x133f
leaq 0xd38(%rip), %rdi       # 0x205f
leaq 0xce3(%rip), %rsi       # 0x2011
movl $0x48, %edx
leaq 0xce7(%rip), %rcx       # 0x2021
callq 0x1050
cmpl $0x4, -0xc(%rbp)
jae 0x1347
jmp 0x1366
leaq 0xd17(%rip), %rdi       # 0x2065
leaq 0xcbc(%rip), %rsi       # 0x2011
movl $0x49, %edx
leaq 0xcc0(%rip), %rcx       # 0x2021
callq 0x1050
movl -0x8(%rbp), %eax
orl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1376
jmp 0x1395
leaq 0xcee(%rip), %rdi       # 0x206b
leaq 0xc8d(%rip), %rsi       # 0x2011
movl $0x4a, %edx
leaq 0xc91(%rip), %rcx       # 0x2021
callq 0x1050
cmpl $0x3, -0x8(%rbp)
jne 0x13b9
cmpl $0x3, -0xc(%rbp)
jne 0x13b9
movl -0x10(%rbp), %edx
movl $0xc, %eax
movl $0x7, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x140b
movl $0x0, -0x14(%rbp)
cmpl $0xc, -0x14(%rbp)
jae 0x1406
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0xcae(%rip), %rax       # 0x2080
movzbl (%rax,%rcx,2), %eax
cmpl -0x8(%rbp), %eax
jne 0x13f9
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0xc99(%rip), %rax       # 0x2080
movzbl 0x1(%rax,%rcx,2), %eax
cmpl -0xc(%rbp), %eax
jne 0x13f9
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x140b
jmp 0x13fb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13c0
callq 0x1030
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: Overv[P]pqpp/./pq.hpp
// Function: pq::connection::connection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
connection(const string& connInfo) {
            conn = shared_ptr<PGconn>(PQconnectdb(connInfo.c_str()), [=](PGconn* conn) {
                PQfinish(conn);
            });

            if (PQstatus(conn.get()) != CONNECTION_OK) {
                throw runtime_error(PQerrorMessage(conn.get()));
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x48e0
movq -0x10(%rbp), %rdi
callq 0x2060
movq %rax, %rdi
callq 0x21b0
movq %rax, -0x38(%rbp)
jmp 0x313b
movq -0x38(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x4900
jmp 0x314a
movq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x58(%rbp)
callq 0x4930
movq -0x58(%rbp), %rdi
callq 0x4960
movq -0x40(%rbp), %rdi
callq 0x4980
movq %rax, %rdi
callq 0x20b0
movl %eax, -0x4c(%rbp)
jmp 0x317a
movl -0x4c(%rbp), %eax
cmpl $0x0, %eax
je 0x31f4
movl $0x10, %edi
callq 0x2150
movq -0x40(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x4980
movq %rax, %rdi
callq 0x22c0
movq %rax, -0x60(%rbp)
jmp 0x31a7
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x20d0
jmp 0x31b6
movq -0x68(%rbp), %rdi
movq 0x12e17(%rip), %rsi     # 0x15fd8
movq 0x12df8(%rip), %rdx     # 0x15fc0
callq 0x21f0
jmp 0x320c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x31fa
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x22b0
jmp 0x31fa
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4960
movq -0x28(%rbp), %rdi
callq 0x2200
nopl (%rax)