LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: timothyqiu[P]ssoaag/bitmap.cc
// Function: Bitmap::Load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Bitmap::Load(std::string const& filename)
{
    this->Free();

    FILE *file = fopen(filename.c_str(), "rb");
    if (file == NULL) {
        this->error_type_ = kIOError;
        this->error_description_ = strerror(errno);
        return false;
    }

    fseek(file, 0, SEEK_END);
    auto length = ftell(file);
    fseek(file, 0, SEEK_SET);

    std::vector<char> buffer;

    buffer.resize(length);
    if (fread(buffer.data(), length, 1, file) != 1) {
        this->error_type_ = kIOError;
        this->error_description_ = "Failed reading data";
        return false;
    }

    fclose(file);

    return this->LoadData(buffer.data(), length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3c90
movq -0x18(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
leaq 0x25ab(%rip), %rsi      # 0x62de
callq 0x2290
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3d73
movq -0x58(%rbp), %rax
movl $0x1, 0x10(%rax)
callq 0x2060
movl (%rax), %edi
callq 0x20b0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x18, %rdi
callq 0x22d0
movb $0x0, -0x1(%rbp)
jmp 0x3e75
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, -0x64(%rbp)
movl %eax, %esi
movq %rsi, -0x70(%rbp)
movl $0x2, %edx
callq 0x2280
movq -0x20(%rbp), %rdi
callq 0x2030
movq -0x70(%rbp), %rsi
movl -0x64(%rbp), %edx
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2280
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4990
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x49b0
jmp 0x3dc5
leaq -0x40(%rbp), %rdi
callq 0x4a40
movq %rax, %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x1, %edx
callq 0x2310
movq %rax, -0x78(%rbp)
jmp 0x3de9
movq -0x78(%rbp), %rax
cmpq $0x1, %rax
je 0x3e34
movq -0x58(%rbp), %rdi
movl $0x1, 0x10(%rdi)
addq $0x18, %rdi
leaq 0x24d8(%rip), %rsi      # 0x62e1
callq 0x22d0
jmp 0x3e10
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x3e6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4a60
jmp 0x3e83
movq -0x20(%rbp), %rdi
callq 0x2200
jmp 0x3e3f
leaq -0x40(%rbp), %rdi
callq 0x4a40
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rdx
callq 0x3e90
movb %al, -0x79(%rbp)
jmp 0x3e5d
movb -0x79(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4a60
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2380
nopl (%rax)
// File: timothyqiu[P]ssoaag/bitmap.cc
// Function: Bitmap::LoadData(char const*, unsigned long)
bool Bitmap::LoadData(char const *data, size_t size)
{
    if (!CheckFormat(data, size)) {
        this->error_type_ = kInvalidBitmap;
        return false;
    }

    auto *bf = reinterpret_cast<BITMAPFILEHEADER const *>(data);
    auto *bi = reinterpret_cast<BITMAPINFOHEADER const *>(bf + 1);

    int w = this->width_  = abs(bi->biWidth );
    int h = this->height_ = abs(bi->biHeight);

    this->pixels_ = new Color[w * h];

    if (bi->biSize < sizeof(BITMAPINFOHEADER)) {
        this->error_type_ = kUnsupportedBitmap;
        this->error_description_ = "DIB header type not supported";
        return false;   // mainly means no BITMAPCOREHEADER support
    }

    if (bi->biCompression != BI_RGB) {
        this->error_type_ = kUnsupportedBitmap;
        this->error_description_ = "Compressed format not supported";
        return false;   // unsupported
    }

    return this->LoadUncompressedPixelData(bf, bi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3fc0
testb $0x1, %al
jne 0x3ed1
movq -0x40(%rbp), %rax
movl $0x2, 0x10(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x3fb3
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0xe, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
negl %edx
cmovnsl %edx, %eax
movl %eax, (%rcx)
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
negl %edx
cmovnsl %edx, %eax
movl %eax, 0x4(%rcx)
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
imull -0x38(%rbp), %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2040
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movl (%rax), %eax
cmpq $0x28, %rax
jae 0x3f72
movq -0x40(%rbp), %rdi
movl $0x3, 0x10(%rdi)
addq $0x18, %rdi
leaq 0x2444(%rip), %rsi      # 0x63ab
callq 0x22d0
movb $0x0, -0x1(%rbp)
jmp 0x3fb3
movq -0x30(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x3f9d
movq -0x40(%rbp), %rdi
movl $0x3, 0x10(%rdi)
addq $0x18, %rdi
leaq 0x2437(%rip), %rsi      # 0x63c9
callq 0x22d0
movb $0x0, -0x1(%rbp)
jmp 0x3fb3
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x4220
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: timothyqiu[P]ssoaag/bitmap.cc
// Function: HasBitmapSignature(char const*, unsigned long)
static bool HasBitmapSignature(char const *data, size_t size)
{
    if (size < 2)
        return false;

    // http://en.wikipedia.org/wiki/BMP_file_format#Bitmap_file_header
    return (memcmp(data, "BM", 2) == 0 ||   // Windows 3.1x, 95, NT, ... etc.
            memcmp(data, "BA", 2) == 0 ||   // OS/2 struct Bitmap Array
            memcmp(data, "CI", 2) == 0 ||   // OS/2 struct Color Icon
            memcmp(data, "CP", 2) == 0 ||   // OS/2 const Color Pointer
            memcmp(data, "IC", 2) == 0 ||   // OS/2 struct Icon
            memcmp(data, "PT", 2) == 0);    // OS/2 Pointer
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
jae 0x416c
movb $0x0, -0x1(%rbp)
jmp 0x4219
movq -0x10(%rbp), %rax
movw (%rax), %ax
subw $0x4d42, %ax            # imm = 0x4D42
setne %al
movzbl %al, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x4211
movq -0x10(%rbp), %rax
movw (%rax), %ax
subw $0x4142, %ax            # imm = 0x4142
setne %al
movzbl %al, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x4211
movq -0x10(%rbp), %rax
movw (%rax), %ax
subw $0x4943, %ax            # imm = 0x4943
setne %al
movzbl %al, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x4211
movq -0x10(%rbp), %rax
movw (%rax), %ax
subw $0x5043, %ax            # imm = 0x5043
setne %al
movzbl %al, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x4211
movq -0x10(%rbp), %rax
movw (%rax), %ax
subw $0x4349, %ax            # imm = 0x4349
setne %al
movzbl %al, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x4211
movq -0x10(%rbp), %rax
movw (%rax), %ax
subw $0x5450, %ax            # imm = 0x5450
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: timothyqiu[P]ssoaag/./bitmap.h
// Function: Bitmap::MakeColor(unsigned char, unsigned char, unsigned char, unsigned char)
static Color MakeColor(uint8_t a, uint8_t r, uint8_t g, uint8_t b) {
        return static_cast<uint32_t>(a) << 24 |
               static_cast<uint32_t>(r) << 16 |
               static_cast<uint32_t>(g) <<  8 |
               static_cast<uint32_t>(b) <<  0 ;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movb %dil, %sil
movb %sil, -0x1(%rbp)
movb %dl, -0x2(%rbp)
movb %cl, -0x3(%rbp)
movb %al, -0x4(%rbp)
movzbl -0x1(%rbp), %eax
shll $0x18, %eax
movzbl -0x2(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movzbl -0x3(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzbl -0x4(%rbp), %ecx
shll $0x0, %ecx
orl %ecx, %eax
popq %rbp
retq
nop
// File: ctSkennerton[P]fxtract/util/realpath.c
// Function: main
int main(int argc, char **argv)
{
    int     i;
    char    path[argc][8192];

    if (argc > 1 && !strcmp(argv[1], "-q"))
        --argc, ++argv, fclose(stderr);

    if (argc < 2)
        return fputs("usage: realpath [-q] path [...]\n", stderr), 1;

    for (i = 1; i < argc; ++i)
        if (!realpath(argv[i], path[i]))
            return perror(argv[i]), 1;

    for (i = 1; i < argc; ++i)
        puts(path[i]);

    return  0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, %rdx
shlq $0xd, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x120b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe27(%rip), %rsi       # 0x2004
callq 0x1070
cmpl $0x0, %eax
jne 0x120b
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq 0x2ddd(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1050
cmpl $0x2, -0x8(%rbp)
jge 0x123a
movq 0x2dc8(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
leaq 0xde5(%rip), %rdi       # 0x2007
callq 0x1060
movl $0x1, -0x4(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0x12d9
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x129d
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movslq -0x14(%rbp), %rax
shlq $0xd, %rax
addq %rax, %rsi
callq 0x1030
cmpq $0x0, %rax
jne 0x1290
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1040
movl $0x1, -0x4(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0x12d9
jmp 0x1292
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1241
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x12cb
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0xd, %rax
addq %rax, %rdi
callq 0x1080
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12a4
movl $0x0, -0x4(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: brianquinlan[P]brainfuck-jit/bf_main.cpp
// Function: bf_read(void*)
static char bf_read(void*) {
  int c = getchar();
  if (c == EOF) {
    return 0;
  } else {
    return c;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
callq 0x3340
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
jne 0x3980
movb $0x0, 0x17(%rsp)
jmp 0x3988
movl 0x4(%rsp), %eax
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: brianquinlan[P]brainfuck-jit/bf_compile_and_go.cpp
// Function: find_loop_end(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
static bool find_loop_end(string::const_iterator loop_start,
                          string::const_iterator string_end,
                          string::const_iterator* loop_end) {
  int level = 1;
  for (string::const_iterator it = loop_start+1; it != string_end; ++it) {
    if (*it == '[') {
      level += 1;
    } else if (*it == ']') {
      level -= 1;
      if (level == 0) {
        *loop_end = it;
        return true;
      }
    }
  }
  return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x6c80
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6db0
testb $0x1, %al
jne 0x6714
jmp 0x677d
leaq 0x8(%rsp), %rdi
callq 0x6df0
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0x6733
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x676f
leaq 0x8(%rsp), %rdi
callq 0x6df0
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x676d
movl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x676b
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movb $0x1, 0x37(%rsp)
jmp 0x6782
jmp 0x676d
jmp 0x676f
jmp 0x6771
leaq 0x8(%rsp), %rdi
callq 0x6fa0
jmp 0x66ff
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: Shenggan[P]SnowFlake/test/test_SnowFlake.cc
// Function: test(void*)
void *test(void *arg) {
    SnowFlake* sf;
    sf = (SnowFlake*)arg;
    for (int i = 0; i < (1<<12); i++) {
        LLOG(INFO) << sf->nextId();
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x1000, -0x14(%rbp)    # imm = 0x1000
jge 0x2766
callq 0x2b40
movq %rax, %rdi
callq 0x2bf0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jl 0x2756
leaq -0x99(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x23b0
movq -0xe8(%rbp), %rdx
leaq 0x3a2f(%rip), %rsi      # 0x6004
leaq -0x98(%rbp), %rdi
callq 0x2c00
jmp 0x25e3
leaq -0xd1(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x23b0
movq -0xf0(%rbp), %rdx
leaq 0x3a17(%rip), %rsi      # 0x601b
leaq -0xd0(%rbp), %rdi
callq 0x2c00
jmp 0x2612
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
leaq -0x98(%rbp), %rdx
leaq -0xd0(%rbp), %rcx
movl $0x8, %r8d
callq 0x2cb0
jmp 0x2633
movq -0x10(%rbp), %rdi
callq 0x2ff0
movq %rax, -0xf8(%rbp)
jmp 0x2645
movq -0xf8(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x2f10
movq %rax, -0x100(%rbp)
jmp 0x266c
callq 0x2b40
movq %rax, -0x108(%rbp)
jmp 0x267a
movq -0x100(%rbp), %rsi
movq -0x108(%rbp), %rdi
callq 0x32e0
jmp 0x268f
leaq -0x78(%rbp), %rdi
callq 0x3470
leaq -0xd0(%rbp), %rdi
callq 0x20e0
leaq -0xd1(%rbp), %rdi
callq 0x2250
leaq -0x98(%rbp), %rdi
callq 0x20e0
leaq -0x99(%rbp), %rdi
callq 0x2250
jmp 0x2756
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x2748
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x2730
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x2724
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3470
leaq -0xd0(%rbp), %rdi
callq 0x20e0
leaq -0xd1(%rbp), %rdi
callq 0x2250
leaq -0x98(%rbp), %rdi
callq 0x20e0
leaq -0x99(%rbp), %rdi
callq 0x2250
jmp 0x2771
jmp 0x2758
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x258e
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x23a0
nopl (%rax)
// File: Shenggan[P]SnowFlake/test/../utils/lightlog.h
// Function: llog::Logger::get_instance()
static Logger* get_instance() {
        if (m_instance_ == nullptr) {
            mtx_.lock();
            if (m_instance_ == nullptr) {
                m_instance_.reset(new Logger);
            }
            mtx_.unlock();
        }
        return m_instance_.get();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x66e1(%rip), %rdi      # 0x9230
xorl %eax, %eax
movl %eax, %esi
callq 0x3900
testb $0x1, %al
jne 0x2b5e
jmp 0x2bd5
leaq 0x66d3(%rip), %rdi      # 0x9238
callq 0x3930
leaq 0x66bf(%rip), %rdi      # 0x9230
xorl %eax, %eax
movl %eax, %esi
callq 0x3900
testb $0x1, %al
jne 0x2b80
jmp 0x2bc9
movl $0x208, %edi            # imm = 0x208
callq 0x2200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x18(%rbp)
callq 0x3990
jmp 0x2b9b
movq -0x18(%rbp), %rsi
leaq 0x668a(%rip), %rdi      # 0x9230
callq 0x3960
jmp 0x2bc9
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl $0x208, %esi            # imm = 0x208
callq 0x2210
jmp 0x2be7
leaq 0x6668(%rip), %rdi      # 0x9238
callq 0x3ad0
leaq 0x6654(%rip), %rdi      # 0x9230
callq 0x3af0
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0x23a0
// File: Shenggan[P]SnowFlake/test/../utils/lightlog.h
// Function: llog::Message& llog::Message::operator<<<unsigned long>(unsigned long const&)
Message& operator<<(const T & t) {
        std::stringstream ss;
        ss << t;
        msg += ss.str();
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2120
leaq -0x188(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x2040
jmp 0x2f4f
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x21e0
jmp 0x2f64
movq -0x1d0(%rbp), %rdi
addq $0x40, %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x22d0
jmp 0x2f7d
leaq -0x1c8(%rbp), %rdi
callq 0x20e0
leaq -0x198(%rbp), %rdi
callq 0x2150
movq -0x1d0(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x2fd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x20e0
leaq -0x198(%rbp), %rdi
callq 0x2150
movq -0x1a0(%rbp), %rdi
callq 0x23a0
nop
// File: Shenggan[P]SnowFlake/test/../utils/lightlog.h
// Function: llog::Logger::operator+=(llog::Message const&)
void operator+=(const Message& m)
    {
        mtx_.lock();
        if (console_)
            std::cout << m.get_string() + '\n';
        if (file_)
            log_file << m.get_string(false) + '\n';
        mtx_.unlock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq 0x5f33(%rip), %rdi      # 0x9238
callq 0x3930
movq -0xa8(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x33a2
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movl $0x1, %edx
callq 0x5080
movq -0xb0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movl $0xa, %edx
callq 0x5030
jmp 0x334b
movq 0x5c86(%rip), %rdi      # 0x8fd8
leaq -0x30(%rbp), %rsi
callq 0x21b0
jmp 0x335d
leaq -0x30(%rbp), %rdi
callq 0x20e0
leaq -0x50(%rbp), %rdi
callq 0x20e0
jmp 0x33a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3394
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20e0
leaq -0x50(%rbp), %rdi
callq 0x20e0
jmp 0x3464
movq -0xa8(%rbp), %rax
testb $0x1, 0x5(%rax)
je 0x344f
movq -0xa8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
xorl %edx, %edx
callq 0x5080
movq -0xb8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movl $0xa, %edx
callq 0x5030
jmp 0x33f5
movq -0xc0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x21b0
jmp 0x3407
leaq -0x80(%rbp), %rdi
callq 0x20e0
leaq -0xa0(%rbp), %rdi
callq 0x20e0
jmp 0x344f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3441
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x20e0
leaq -0xa0(%rbp), %rdi
callq 0x20e0
jmp 0x3464
leaq 0x5de2(%rip), %rdi      # 0x9238
callq 0x3ad0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x23a0
nopl (%rax)
// File: Shenggan[P]SnowFlake/test/../utils/lightlog.h
// Function: llog::Logger::init_log_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void init_log_file(std::string log_file_name = "output.log") {
        if (file_ == true)
            log_file.close();
        log_file.open(log_file_name);
        file_ = true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0x5(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x34e6
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x2300
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rdi
movl $0x10, %edx
callq 0x20b0
movq -0x18(%rbp), %rax
movb $0x1, 0x5(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Shenggan[P]SnowFlake/test/../utils/lightlog.h
// Function: llog::Logger::Logger()
Logger() {
        if (getenv("LLOG_LV") == NULL)
            m_level_ = LOG_LEVEL_INFO;
        else{
            std::string ev_level = getenv("LLOG_LV");
            if (ev_level == "WARN")
                m_level_ = LOG_LEVEL_WARNING;
            else if (ev_level == "ERRO")
                m_level_ = LOG_LEVEL_ERROR;
            else
                m_level_ = LOG_LEVEL_INFO;
        }
        console_ = true;
        file_ = false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
callq 0x2380
leaq 0x2678(%rip), %rdi      # 0x6030
callq 0x22a0
cmpq $0x0, %rax
jne 0x39d2
movq -0x50(%rbp), %rax
movl $0x0, (%rax)
jmp 0x3aa2
leaq 0x2657(%rip), %rdi      # 0x6030
callq 0x22a0
movq %rax, -0x60(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x23b0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x2c00
jmp 0x3a02
leaq -0x29(%rbp), %rdi
callq 0x2250
leaq 0x2626(%rip), %rsi      # 0x6038
leaq -0x28(%rbp), %rdi
callq 0x3d70
movb %al, -0x61(%rbp)
jmp 0x3a20
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x3a29
jmp 0x3a63
movq -0x50(%rbp), %rax
movl $0x1, (%rax)
jmp 0x3a99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x2250
jmp 0x3ab4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20e0
jmp 0x3ab4
leaq 0x25d3(%rip), %rsi      # 0x603d
leaq -0x28(%rbp), %rdi
callq 0x3d70
movb %al, -0x62(%rbp)
jmp 0x3a78
movb -0x62(%rbp), %al
testb $0x1, %al
jne 0x3a81
jmp 0x3a8d
movq -0x50(%rbp), %rax
movl $0x2, (%rax)
jmp 0x3a97
movq -0x50(%rbp), %rax
movl $0x0, (%rax)
jmp 0x3a99
leaq -0x28(%rbp), %rdi
callq 0x20e0
movq -0x50(%rbp), %rax
movb $0x1, 0x4(%rax)
movb $0x0, 0x5(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2330
movq -0x38(%rbp), %rdi
callq 0x23a0
nopw %cs:(%rax,%rax)
// File: Shenggan[P]SnowFlake/test/../utils/lightlog.h
// Function: llog::Message::colorStr(int, int, 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>> const&, bool)
std::string colorStr(int color, int bold, const std::string & delimiter, const std::string & t, bool if_color = true) {
        std::stringstream ss;
        if (if_color)
            ss << "\033[" << bold << ";" << color << "m";
        ss << t;
        if (if_color)
            ss << "\033[0m";
        ss << delimiter;
		return ss.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x2120
testb $0x1, -0x29(%rbp)
je 0x48bf
leaq -0x1a8(%rbp), %rdi
leaq 0x1841(%rip), %rsi      # 0x606f
callq 0x21f0
movq %rax, -0x1e0(%rbp)
jmp 0x483c
movq -0x1e0(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x2390
movq %rax, -0x1e8(%rbp)
jmp 0x4854
movq -0x1e8(%rbp), %rdi
leaq 0x1810(%rip), %rsi      # 0x6072
callq 0x21f0
movq %rax, -0x1f0(%rbp)
jmp 0x4870
movq -0x1f0(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2390
movq %rax, -0x1f8(%rbp)
jmp 0x4888
movq -0x1f8(%rbp), %rdi
leaq 0x17e1(%rip), %rsi      # 0x6077
callq 0x21f0
jmp 0x489d
jmp 0x48bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x2150
jmp 0x4931
leaq -0x1a8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x21b0
jmp 0x48d1
testb $0x1, -0x29(%rbp)
je 0x48ee
leaq -0x1a8(%rbp), %rdi
leaq 0x178f(%rip), %rsi      # 0x6074
callq 0x21f0
jmp 0x48ec
jmp 0x48ee
leaq -0x1a8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x21b0
jmp 0x4900
movq -0x1d8(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x21e0
jmp 0x4915
leaq -0x1b8(%rbp), %rdi
callq 0x2150
movq -0x1d0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1c0(%rbp), %rdi
callq 0x23a0
nopl (%rax)
// File: Shenggan[P]SnowFlake/test/../SnowFlake.h
// Function: SnowFlake::getNewstmp()
uint64_t getNewstmp() {
        struct timeval tv;
        gettimeofday(&tv, NULL);

        uint64_t time = tv.tv_usec;
        time /= 1000;
        time += (tv.tv_sec * 1000);
        return time;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
movq %rax, -0x20(%rbp)
imulq $0x3e8, -0x18(%rbp), %rax # imm = 0x3E8
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Shenggan[P]SnowFlake/test/../SnowFlake.h
// Function: SnowFlake::getNextMill()
uint64_t getNextMill() {
        uint64_t mill = getNewstmp();
        while (mill <= lastStmp) {
            mill = getNewstmp();
        }
        return mill;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x4dc0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x18(%rcx), %rax
ja 0x4f2a
movq -0x18(%rbp), %rdi
callq 0x4dc0
movq %rax, -0x10(%rbp)
jmp 0x4f0d
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: YerevaNN[P]pmi/pmi.cpp
// Function: hash(unsigned long, unsigned long, unsigned long)
ngram hash(word a, word b, word c) {
    if (a > c) {
        std::swap(a, c);
    }
    if (a > b) {
        std::swap(a, b);
    }
    if (b > c) {
        std::swap(b, c);
    }

    return a | (b << 21) | (c << 42);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
cmpq (%rsp), %rax
jbe 0x370a
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x43b0
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0x3725
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x43b0
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jbe 0x373d
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x43b0
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
shlq $0x15, %rcx
orq %rcx, %rax
movq (%rsp), %rcx
shlq $0x2a, %rcx
orq %rcx, %rax
addq $0x18, %rsp
retq
nop
// File: YerevaNN[P]pmi/pmi.cpp
// Function: model::clear()
void model::clear() {
    locked = false;
    dictionary.clear();
    words.clear();
    unlockedCount.clear();
    lockedCount.clear();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movb $0x0, (%rdi)
addq $0x8, %rdi
callq 0x4430
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0x4440
movq 0x8(%rsp), %rdi
addq $0x58, %rdi
callq 0x4460
movq 0x8(%rsp), %rdi
addq $0x90, %rdi
callq 0x4470
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: YerevaNN[P]pmi/pmi.cpp
// Function: model::lock()
void model::lock() {
    if(locked) {
        return;
    }
    report("Locking...");
    lockedCount.clear();
    while(!unlockedCount.empty()) {
        lockedCount.push_back(*unlockedCount.begin());
        unlockedCount.erase(unlockedCount.begin());
    }
    report("Indexing...");
    std::sort(lockedCount.begin(), lockedCount.end());
    locked = true;
    report("Done\n");
    return;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, (%rax)
je 0x3bad
jmp 0x3d09
movq 0x15414(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
leaq 0xd47d(%rip), %rsi      # 0x1103b
movb $0x0, %al
callq 0x21f0
movq 0x153fc(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
callq 0x2170
movq 0x10(%rsp), %rdi
addq $0x90, %rdi
callq 0x4470
movq 0x10(%rsp), %rdi
addq $0x58, %rdi
callq 0x4600
xorb $-0x1, %al
testb $0x1, %al
jne 0x3bfb
jmp 0x3c78
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x90, %rax
movq %rax, (%rsp)
addq $0x58, %rdi
callq 0x4650
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4680
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x46a0
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x4620
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x58, %rax
movq %rax, 0x8(%rsp)
addq $0x58, %rdi
callq 0x4650
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
callq 0x46d0
movq %rax, 0x28(%rsp)
jmp 0x3be5
movq 0x15349(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
leaq 0xd3bd(%rip), %rsi      # 0x11046
movb $0x0, %al
callq 0x21f0
movq 0x15331(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
callq 0x2170
movq 0x10(%rsp), %rdi
addq $0x90, %rdi
callq 0x4750
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x90, %rdi
callq 0x4780
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4710
movq 0x10(%rsp), %rax
movb $0x1, (%rax)
movq 0x152df(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
leaq 0xd35f(%rip), %rsi      # 0x11052
movb $0x0, %al
callq 0x21f0
movq 0x152c7(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
callq 0x2170
addq $0x68, %rsp
retq
nop
// File: YerevaNN[P]pmi/pmi.cpp
// Function: model::unlock()
void model::unlock() {
    if(!locked) {
        return;
    }
    report("Unlocking...");
    while(!lockedCount.empty()) {
        unlockedCount.insert(lockedCount.back());
        lockedCount.pop_back();
    }
    locked = false;
    report("Done\n");
    return;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, (%rax)
jne 0x3d2d
jmp 0x3de0
movq 0x15294(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
leaq 0xd31a(%rip), %rsi      # 0x11058
movb $0x0, %al
callq 0x21f0
movq 0x1527c(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
callq 0x2170
movq 0x8(%rsp), %rdi
addq $0x90, %rdi
callq 0x47b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x3d6d
jmp 0x3db1
movq 0x8(%rsp), %rdi
movq %rdi, %rax
addq $0x58, %rax
movq %rax, (%rsp)
addq $0x90, %rdi
callq 0x4850
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x4800
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movb %dl, 0x18(%rsp)
addq $0x90, %rdi
callq 0x4890
jmp 0x3d54
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x15208(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
leaq 0xd288(%rip), %rsi      # 0x11052
movb $0x0, %al
callq 0x21f0
movq 0x151f0(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
callq 0x2170
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: YerevaNN[P]pmi/pmi.cpp
// Function: model::load(std::istream&)
void model::load(std::istream& in) {
    clear();
    lock();
    
    report("Loading...");
    
    size dictionarySize;
    in.read((char*)&dictionarySize, sizeof(dictionarySize));
    for(word i = 0; i < dictionarySize; ++i) {
        char s[wordMaxLength];
        in.read(s, wordMaxLength);
        std::string w(s);
        dictionary[w] = i;
        words.push_back(w);
    }
    size matrixSize;
    in.read((char*)&matrixSize, sizeof(matrixSize));
    for(size i = 0; i < matrixSize; ++i) {
        pair key;
        in.read((char*)&key, sizeof(key));
        occurences val;
        in.read((char*)&val, sizeof(val));
        lockedCount.push_back(std::make_pair(key, val));
    }
    report("Done\n");
    return;
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq 0x120(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x3870
movq 0x28(%rsp), %rdi
callq 0x3b90
movq 0x14e6e(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
leaq 0xcf2c(%rip), %rsi      # 0x11090
movb $0x0, %al
callq 0x21f0
movq 0x14e56(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
callq 0x2170
movq 0x118(%rsp), %rdi
leaq 0x110(%rsp), %rsi
movl $0x8, %edx
callq 0x2180
movq $0x0, 0x108(%rsp)
movq 0x108(%rsp), %rax
cmpq 0x110(%rsp), %rax
jae 0x42ce
movq 0x118(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movl $0x40, %edx
callq 0x2180
leaq 0x9f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2290
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
callq 0x21d0
jmp 0x4200
leaq 0x9f(%rsp), %rdi
callq 0x2160
movq 0x28(%rsp), %rdi
movq 0x108(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
leaq 0xa0(%rsp), %rsi
callq 0x4a30
movq %rax, 0x10(%rsp)
jmp 0x4237
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
addq $0x40, %rdi
leaq 0xa0(%rsp), %rsi
callq 0x4a60
jmp 0x425c
leaq 0xa0(%rsp), %rdi
callq 0x20e0
movq 0x108(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x108(%rsp)
jmp 0x41a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x9f(%rsp), %rdi
callq 0x2160
jmp 0x439e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x20e0
jmp 0x439e
movq 0x118(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movl $0x8, %edx
callq 0x2180
movq $0x0, 0x78(%rsp)
movq 0x78(%rsp), %rax
cmpq 0x80(%rsp), %rax
jae 0x436f
movq 0x118(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x10, %edx
callq 0x2180
movq 0x118(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
movl $0x4, %edx
callq 0x2180
movq 0x28(%rsp), %rax
addq $0x90, %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x5c(%rsp), %rdx
callq 0x4ad0
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x4620
movq 0x78(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0x42f1
movq 0x14c52(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
leaq 0xccd2(%rip), %rsi      # 0x11052
movb $0x0, %al
callq 0x21f0
movq 0x14c3a(%rip), %rax     # 0x18fc8
movq (%rax), %rdi
callq 0x2170
addq $0x128, %rsp            # imm = 0x128
retq
movq 0x90(%rsp), %rdi
callq 0x2280
nopl (%rax,%rax)
// File: YerevaNN[P]pmi/train.cpp
// Function: model::lookup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
word model::lookup(const std::string& s) {
    if(s.empty()) {
        return emptyWord;
    }
    auto I = dictionary.find(s);
    if(I != dictionary.end()) {
        return I->second;
    }
    word index = words.size();
    words.push_back(s);
    return dictionary[s] = index;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2260
testb $0x1, %al
jne 0xa218
jmp 0xa226
movq $0x1fffff, 0x40(%rsp)   # imm = 0x1FFFFF
jmp 0xa2ce
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x30(%rsp), %rsi
callq 0xa620
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x8, %rdi
callq 0xa670
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xa650
testb $0x1, %al
jne 0xa266
jmp 0xa27b
leaq 0x28(%rsp), %rdi
callq 0x8cc0
movq 0x20(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0xa2ce
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
callq 0x48b0
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x40, %rdi
movq 0x30(%rsp), %rsi
callq 0x4a60
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
movq 0x30(%rsp), %rsi
callq 0x4a30
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rax, (%rcx)
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: YerevaNN[P]pmi/train.cpp
// Function: model::push(unsigned long, unsigned long)
void model::push(ngram x, ngram y) {
    if(x > y) {
        std::swap(x, y);
    }
    ++unlockedCount[(pair(x) << (3 * 21)) | pair(y)];
    return;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jbe 0xa318
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x43b0
movq 0x8(%rsp), %rdi
addq $0x58, %rdi
movq 0x28(%rsp), %rax
movq %rax, %rcx
shrq %rcx
shlq $0x3f, %rax
movq 0x20(%rsp), %rdx
orq %rdx, %rax
movq %rcx, 0x18(%rsp)
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0xa6a0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: YerevaNN[P]pmi/train.cpp
// Function: model::train(std::istream&, unsigned long)
void model::train(std::istream& in, size_t windowSize) {
    clear();
    
    std::deque<word> window;
    
    std::string s;
    
    while(window.size() != windowSize) {
        window.push_back(readWord(in));
    }
    
    size counter = 0;
    
    while(true) {
        processWindow(window.begin(), window.end());
        
        word add = readWord(in);
        if(add == emptyWord) {
            break;
        }
        window.push_back(add);
        window.pop_front();
        
        ++counter;
        if(counter % 731 == 0)
            report("\r%lld\t\t", counter);
    }
    std::cerr << std::endl;

    return;
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x120(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x3870
leaq 0xc0(%rsp), %rdi
callq 0xa6d0
leaq 0xa0(%rsp), %rdi
callq 0x21e0
leaq 0xc0(%rsp), %rdi
callq 0xa6e0
cmpq 0x110(%rsp), %rax
je 0xa4c4
movq 0x30(%rsp), %rdi
movq 0x118(%rsp), %rsi
callq 0xa360
movq %rax, 0x28(%rsp)
jmp 0xa46b
movq 0x28(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xa700
jmp 0xa48f
jmp 0xa43b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x20e0
leaq 0xc0(%rsp), %rdi
callq 0xa9b0
jmp 0xa605
movq $0x0, 0x80(%rsp)
jmp 0xa4d2
leaq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0xc0(%rsp), %rsi
movq %rsi, 0x10(%rsp)
callq 0xa880
movq 0x10(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xa8b0
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xa730
jmp 0xa518
movq 0x30(%rsp), %rdi
movq 0x118(%rsp), %rsi
callq 0xa360
movq %rax, 0x8(%rsp)
jmp 0xa531
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x1fffff, 0x38(%rsp)   # imm = 0x1FFFFF
jne 0xa54b
jmp 0xa5ce
leaq 0xc0(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xa8e0
jmp 0xa55f
leaq 0xc0(%rsp), %rdi
callq 0xa940
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movl $0x2db, %ecx            # imm = 0x2DB
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0xa5b8
movq 0xea29(%rip), %rax      # 0x18fc8
movq (%rax), %rdi
movq 0x80(%rsp), %rdx
leaq 0x6b13(%rip), %rsi      # 0x110c4
movb $0x0, %al
callq 0x21f0
movq 0xea09(%rip), %rax      # 0x18fc8
movq (%rax), %rdi
callq 0x2170
jmp 0xa5c9
jmp 0xa4d0
movq 0xea1b(%rip), %rdi      # 0x18ff0
movq 0xe9d4(%rip), %rsi      # 0x18fb0
callq 0x2150
jmp 0xa5e3
leaq 0xa0(%rsp), %rdi
callq 0x20e0
leaq 0xc0(%rsp), %rdi
callq 0xa9b0
addq $0x128, %rsp            # imm = 0x128
retq
movq 0x90(%rsp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: YerevaNN[P]pmi/train.cpp
// Function: void model::processWindow<std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*>>(std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&, std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&)
void model::processWindow(const ForwardIterator& begin, const ForwardIterator& end) {
    auto ngrams = getNgrams(begin, end);
    for(auto i : ngrams) {
        for(auto j : ngrams) {
            push(i, j);
        }
    }
    return;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, (%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0xc190
leaq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc5d0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc600
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xc630
testb $0x1, %al
jne 0xa7a9
jmp 0xa858
leaq 0x48(%rsp), %rdi
callq 0xc670
movq (%rax), %rax
movq %rax, 0x38(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc5d0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc600
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xc630
testb $0x1, %al
jne 0xa7f8
jmp 0xa847
leaq 0x28(%rsp), %rdi
callq 0xc670
movq (%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xa2e0
jmp 0xa81f
jmp 0xa821
leaq 0x28(%rsp), %rdi
callq 0xc680
jmp 0xa7e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xc6a0
jmp 0xa86a
jmp 0xa849
leaq 0x48(%rsp), %rdi
callq 0xc680
jmp 0xa791
leaq 0x58(%rsp), %rdi
callq 0xc6a0
addq $0x88, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
nop
// File: YerevaNN[P]pmi/train.cpp
// Function: std::vector<unsigned long, std::allocator<unsigned long>> getUnigrams<std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*>>(std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&, std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&)
std::vector<ngram> getUnigrams(const T& begin, const T& end) {
    std::unordered_set<ngram> ngrams;
    for(auto I = begin; I != end; ++I) {
        ngrams.insert(hash(*I));
    }
    return std::vector<ngram> (ngrams.begin(), ngrams.end());
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xcf10
movq 0xd8(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0xc140
movq 0xd0(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0xcf20
testb $0x1, %al
jne 0xc7d3
jmp 0xc84c
leaq 0x78(%rsp), %rdi
callq 0xcfa0
movq (%rax), %rdi
movl $0x1fffff, %edx         # imm = 0x1FFFFF
movq %rdx, %rsi
callq 0x36e0
movq %rax, 0x20(%rsp)
jmp 0xc7f4
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xcf50
movb %dl, 0x17(%rsp)
movq %rax, 0x18(%rsp)
jmp 0xc81b
movb 0x17(%rsp), %al
movq 0x18(%rsp), %rcx
movq %rcx, 0x50(%rsp)
movb %al, 0x58(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xcfb0
jmp 0xc7bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xc8d6
leaq 0x98(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xd000
movq (%rsp), %rdi
movq %rax, 0x48(%rsp)
callq 0xd030
movq %rax, 0x40(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd060
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0xd070
jmp 0xc89a
leaq 0x3f(%rsp), %rdi
callq 0xd100
leaq 0x98(%rsp), %rdi
callq 0xd110
movq 0x30(%rsp), %rax
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0xd100
leaq 0x98(%rsp), %rdi
callq 0xd110
movq 0x68(%rsp), %rdi
callq 0x2280
nopl (%rax)
// File: YerevaNN[P]pmi/train.cpp
// Function: std::vector<unsigned long, std::allocator<unsigned long>> getBigrams<std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*>>(std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&, std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&)
std::vector<ngram> getBigrams(const T& begin, const T& end) {
    std::unordered_set<ngram> ngrams;
    for(auto I = begin, J = std::next(I); J != end; ++I, ++J) {
        ngrams.insert(hash(*I, *J));
    }
    return std::vector<ngram> (ngrams.begin(), ngrams.end());
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
leaq 0xf8(%rsp), %rdi
callq 0xcf10
movq 0x138(%rsp), %rsi
leaq 0xd8(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0xc140
movq 0x48(%rsp), %rsi
leaq 0x98(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0xc140
movq 0x50(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
movl $0x1, %edx
callq 0x10190
jmp 0xca73
jmp 0xca75
movq 0x130(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
callq 0xcf20
testb $0x1, %al
jne 0xca93
jmp 0xcb45
leaq 0xd8(%rsp), %rdi
callq 0xcfa0
movq (%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0xcfa0
movq 0x28(%rsp), %rdi
movq (%rax), %rsi
movl $0x1fffff, %edx         # imm = 0x1FFFFF
callq 0x36e0
movq %rax, 0x30(%rsp)
jmp 0xcace
movq 0x30(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0xf8(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xcf50
movb %dl, 0x1f(%rsp)
movq %rax, 0x20(%rsp)
jmp 0xcafb
movb 0x1f(%rsp), %al
movq 0x20(%rsp), %rcx
movq %rcx, 0x70(%rsp)
movb %al, 0x78(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0xcfb0
leaq 0xb8(%rsp), %rdi
callq 0xcfb0
jmp 0xca75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xcbd7
leaq 0xf8(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd000
movq 0x8(%rsp), %rdi
movq %rax, 0x68(%rsp)
callq 0xd030
movq %rax, 0x60(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd060
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0xd070
jmp 0xcb95
leaq 0x5f(%rsp), %rdi
callq 0xd100
leaq 0xf8(%rsp), %rdi
callq 0xd110
movq 0x40(%rsp), %rax
addq $0x148, %rsp            # imm = 0x148
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x5f(%rsp), %rdi
callq 0xd100
leaq 0xf8(%rsp), %rdi
callq 0xd110
movq 0x90(%rsp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: YerevaNN[P]pmi/train.cpp
// Function: std::vector<unsigned long, std::allocator<unsigned long>> getTrigrams<std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*>>(std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&, std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*> const&)
std::vector<ngram> getTrigrams(const T& begin, const T& end) {
    std::unordered_set<ngram> ngrams;
    for(auto I = begin, J = std::next(I), K = std::next(J); K != end; ++I, ++J, ++K) {
        ngrams.insert(hash(*I, *J, *K));
    }
    return std::vector<ngram> (ngrams.begin(), ngrams.end());
}

// Assembly:
subq $0x198, %rsp            # imm = 0x198
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x190(%rsp)
movq %rsi, 0x188(%rsp)
movq %rdx, 0x180(%rsp)
leaq 0x148(%rsp), %rdi
callq 0xcf10
movq 0x188(%rsp), %rsi
leaq 0x128(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0xc140
movq 0x58(%rsp), %rsi
leaq 0xe8(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0xc140
movq 0x60(%rsp), %rsi
leaq 0x108(%rsp), %rdi
movl $0x1, %edx
callq 0x10190
jmp 0xcc83
leaq 0x98(%rsp), %rdi
movq %rdi, 0x40(%rsp)
leaq 0x108(%rsp), %rsi
callq 0xc140
movq 0x40(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
movl $0x1, %edx
callq 0x10190
jmp 0xccb6
jmp 0xccb8
movq 0x180(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
callq 0xcf20
testb $0x1, %al
jne 0xccd6
jmp 0xcdb0
leaq 0x128(%rsp), %rdi
callq 0xcfa0
movq (%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x108(%rsp), %rdi
callq 0xcfa0
movq (%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0xcfa0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq (%rax), %rdx
callq 0x36e0
movq %rax, 0x38(%rsp)
jmp 0xcd26
movq 0x38(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0x148(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xcf50
movb %dl, 0x1f(%rsp)
movq %rax, 0x20(%rsp)
jmp 0xcd53
movb 0x1f(%rsp), %al
movq 0x20(%rsp), %rcx
movq %rcx, 0x80(%rsp)
movb %al, 0x88(%rsp)
leaq 0x128(%rsp), %rdi
callq 0xcfb0
leaq 0x108(%rsp), %rdi
callq 0xcfb0
leaq 0xb8(%rsp), %rdi
callq 0xcfb0
jmp 0xccb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
jmp 0xce42
leaq 0x148(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd000
movq 0x8(%rsp), %rdi
movq %rax, 0x78(%rsp)
callq 0xd030
movq %rax, 0x70(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd060
movq 0x48(%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0xd070
jmp 0xce00
leaq 0x6f(%rsp), %rdi
callq 0xd100
leaq 0x148(%rsp), %rdi
callq 0xd110
movq 0x50(%rsp), %rax
addq $0x198, %rsp            # imm = 0x198
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
leaq 0x6f(%rsp), %rdi
callq 0xd100
leaq 0x148(%rsp), %rdi
callq 0xd110
movq 0xe0(%rsp), %rdi
callq 0x2280
nopl (%rax)