LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng_load_file(unsigned char**, unsigned long*, char const*)
unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename)
{
  FILE* file;
  long size;

  /*provide some proper output values if error will happen*/
  *out = 0;
  *outsize = 0;

  file = fopen(filename, "rb");
  if(!file) return 78;

  /*get filesize:*/
  fseek(file , 0 , SEEK_END);
  size = ftell(file);
  rewind(file);

  /*read contents of the file into the vector*/
  *outsize = 0;
  *out = (unsigned char*)lodepng_malloc((size_t)size);
  if(size && (*out)) (*outsize) = fread(*out, 1, (size_t)size, file);

  fclose(file);
  if(!(*out) && size) return 83; /*the above malloc failed*/
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rdi
leaq 0x13bf3(%rip), %rsi     # 0x25aa8
callq 0x32f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x11ed1
movl $0x4e, -0x4(%rbp)
jmp 0x11f75
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x32d0
movq -0x28(%rbp), %rdi
callq 0x3030
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3050
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rdi
callq 0x11f80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x11f4b
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x11f4b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x3400
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x3230
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x11f6e
cmpq $0x0, -0x30(%rbp)
je 0x11f6e
movl $0x53, -0x4(%rbp)
jmp 0x11f75
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: logicx24[P]RayTracer/lodepng.cpp
// Function: append_symbol_coins(Coin*, unsigned int const*, unsigned int, unsigned long)
static unsigned append_symbol_coins(Coin* coins, const unsigned* frequencies, unsigned numcodes, size_t sum)
{
  unsigned i;
  unsigned j = 0; /*index of present symbols*/
  for(i = 0; i != numcodes; ++i)
  {
    if(frequencies[i] != 0) /*only include symbols that are present*/
    {
      coins[j].weight = frequencies[i] / (float)sum;
      uivector_push_back(&coins[j].symbols, i);
      ++j;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x1256f
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,4)
je 0x1255f
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movl (%rax,%rcx,4), %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x30(%rbp)
testq %rax, %rax
movss %xmm0, -0x2c(%rbp)
js 0x1251f
movss -0x30(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x34(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movss %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %eax
shlq $0x5, %rax
addq %rax, %rdi
movl -0x24(%rbp), %esi
callq 0x1bb40
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x12561
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x124b5
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng_crc32(unsigned char const*, unsigned long)
unsigned lodepng_crc32(const unsigned char* buf, size_t len)
{
  unsigned c = 0xffffffffL;
  size_t n;

  for(n = 0; n < len; ++n)
  {
    c = lodepng_crc32_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);
  }
  return c ^ 0xffffffffL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x130e2
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x1d23a(%rip), %rax     # 0x30300
movl (%rax,%rcx,4), %eax
movl -0x14(%rbp), %ecx
shrl $0x8, %ecx
xorl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1309b
movl -0x14(%rbp), %eax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
xorq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng_color_mode_equal(LodePNGColorMode const*, LodePNGColorMode const*)
static int lodepng_color_mode_equal(const LodePNGColorMode* a, const LodePNGColorMode* b)
{
  size_t i;
  if(a->colortype != b->colortype) return 0;
  if(a->bitdepth != b->bitdepth) return 0;
  if(a->key_defined != b->key_defined) return 0;
  if(a->key_defined)
  {
    if(a->key_r != b->key_r) return 0;
    if(a->key_g != b->key_g) return 0;
    if(a->key_b != b->key_b) return 0;
  }
  if(a->palettesize != b->palettesize) return 0;
  for(i = 0; i != a->palettesize * 4; ++i)
  {
    if(a->palette[i] != b->palette[i]) return 0;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x14b86
movl $0x0, -0x4(%rbp)
jmp 0x14c97
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0x14ba2
movl $0x0, -0x4(%rbp)
jmp 0x14c97
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
je 0x14bbe
movl $0x0, -0x4(%rbp)
jmp 0x14c97
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x14c1b
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
je 0x14be4
movl $0x0, -0x4(%rbp)
jmp 0x14c97
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
je 0x14c00
movl $0x0, -0x4(%rbp)
jmp 0x14c97
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x24(%rcx), %eax
je 0x14c19
movl $0x0, -0x4(%rbp)
jmp 0x14c97
jmp 0x14c1b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x14c36
movl $0x0, -0x4(%rbp)
jmp 0x14c97
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
cmpq %rcx, %rax
je 0x14c90
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x14c80
movl $0x0, -0x4(%rbp)
jmp 0x14c97
jmp 0x14c82
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x14c3e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: logicx24[P]RayTracer/lodepng.cpp
// Function: addChunk_bKGD(ucvector*, LodePNGInfo const*)
static unsigned addChunk_bKGD(ucvector* out, const LodePNGInfo* info)
{
  unsigned error = 0;
  ucvector bKGD;
  ucvector_init(&bKGD);
  if(info->color.colortype == LCT_GREY || info->color.colortype == LCT_GREY_ALPHA)
  {
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r / 256));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r % 256));
  }
  else if(info->color.colortype == LCT_RGB || info->color.colortype == LCT_RGBA)
  {
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r / 256));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r % 256));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_g / 256));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_g % 256));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_b / 256));
    ucvector_push_back(&bKGD, (unsigned char)(info->background_b % 256));
  }
  else if(info->color.colortype == LCT_PALETTE)
  {
    ucvector_push_back(&bKGD, (unsigned char)(info->background_r % 256)); /*palette index*/
  }

  error = addChunk(out, "bKGD", bKGD.data, bKGD.size);
  ucvector_cleanup(&bKGD);

  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x19560
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x19b84
movq -0x10(%rbp), %rax
cmpl $0x4, 0x10(%rax)
jne 0x19bb7
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
shrl $0x8, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x12eb0
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
andl $0xff, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x12eb0
jmp 0x19c81
movq -0x10(%rbp), %rax
cmpl $0x2, 0x10(%rax)
je 0x19bcf
movq -0x10(%rbp), %rax
cmpl $0x6, 0x10(%rax)
jne 0x19c5b
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
shrl $0x8, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x12eb0
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
andl $0xff, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x12eb0
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
shrl $0x8, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x12eb0
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
andl $0xff, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x12eb0
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
shrl $0x8, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x12eb0
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
andl $0xff, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x12eb0
jmp 0x19c7f
movq -0x10(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0x19c7d
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
andl $0xff, %eax
leaq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x12eb0
jmp 0x19c7f
jmp 0x19c81
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0xccca(%rip), %rsi      # 0x2695e
callq 0x22ea0
movl %eax, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20750
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: logicx24[P]RayTracer/lodepng.cpp
// Function: addChunk_tIME(ucvector*, LodePNGTime const*)
static unsigned addChunk_tIME(ucvector* out, const LodePNGTime* time)
{
  unsigned error = 0;
  unsigned char* data = (unsigned char*)lodepng_malloc(7);
  if(!data) return 83; /*alloc fail*/
  data[0] = (unsigned char)(time->year / 256);
  data[1] = (unsigned char)(time->year % 256);
  data[2] = (unsigned char)time->month;
  data[3] = (unsigned char)time->day;
  data[4] = (unsigned char)time->hour;
  data[5] = (unsigned char)time->minute;
  data[6] = (unsigned char)time->second;
  error = addChunk(out, "tIME", data, 7);
  lodepng_free(data);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x7, %edi
callq 0x11f80
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x19df8
movl $0x53, -0x4(%rbp)
jmp 0x19e98
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0xcaf6(%rip), %rsi      # 0x26972
movl $0x7, %ecx
callq 0x22ea0
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x12420
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng::load_file(std::vector<unsigned char, std::allocator<unsigned char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void load_file(std::vector<unsigned char>& buffer, const std::string& filename)
{
  std::ifstream file(filename.c_str(), std::ios::in|std::ios::binary|std::ios::ate);

  /*get filesize*/
  std::streamsize size = 0;
  if(file.seekg(0, std::ios::end).good()) size = file.tellg();
  if(file.seekg(0, std::ios::beg).good()) size -= file.tellg();

  /*read contents of the file into the vector*/
  buffer.resize(size_t(size));
  if(size > 0) file.read((char*)(&buffer[0]), size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30f0
movq %rax, -0x270(%rbp)
movl $0x8, %edi
movl $0x4, %esi
callq 0x22f80
movl %eax, %edi
movl $0x2, %esi
movl %esi, -0x25c(%rbp)
callq 0x22f80
movq -0x270(%rbp), %rsi
movl %eax, %edx
leaq -0x218(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x3530
movq -0x268(%rbp), %rdi
movl -0x25c(%rbp), %edx
movq $0x0, -0x220(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3390
movq %rax, -0x258(%rbp)
jmp 0x1abca
movq -0x258(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x34b0
movb %al, -0x271(%rbp)
jmp 0x1abe8
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x1abf7
jmp 0x1ac77
leaq -0x218(%rbp), %rdi
callq 0x34d0
movq %rdx, -0x288(%rbp)
movq %rax, -0x280(%rbp)
jmp 0x1ac13
movq -0x288(%rbp), %rax
movq -0x280(%rbp), %rcx
movq %rcx, -0x240(%rbp)
movq %rax, -0x238(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x22fa0
movq %rax, -0x290(%rbp)
jmp 0x1ac44
movq -0x290(%rbp), %rax
movq %rax, -0x220(%rbp)
jmp 0x1ac77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x30b0
jmp 0x1ad77
xorl %edx, %edx
movl %edx, %esi
leaq -0x218(%rbp), %rdi
callq 0x3390
movq %rax, -0x298(%rbp)
jmp 0x1ac90
movq -0x298(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x34b0
movb %al, -0x299(%rbp)
jmp 0x1acae
movb -0x299(%rbp), %al
testb $0x1, %al
jne 0x1acba
jmp 0x1ad1f
leaq -0x218(%rbp), %rdi
callq 0x34d0
movq %rdx, -0x2b0(%rbp)
movq %rax, -0x2a8(%rbp)
jmp 0x1acd6
movq -0x2b0(%rbp), %rax
movq -0x2a8(%rbp), %rcx
movq %rcx, -0x250(%rbp)
movq %rax, -0x248(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x22fa0
movq %rax, -0x2b8(%rbp)
jmp 0x1ad07
movq -0x2b8(%rbp), %rcx
movq -0x220(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x220(%rbp)
movq -0x8(%rbp), %rdi
movq -0x220(%rbp), %rsi
callq 0x22fc0
jmp 0x1ad31
cmpq $0x0, -0x220(%rbp)
jle 0x1ad62
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xfb30
movq %rax, %rsi
movq -0x220(%rbp), %rdx
leaq -0x218(%rbp), %rdi
callq 0x3350
jmp 0x1ad60
jmp 0x1ad62
leaq -0x218(%rbp), %rdi
callq 0x30b0
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: logicx24[P]RayTracer/lodepng.cpp
// Function: searchCodeIndex(unsigned int const*, unsigned long, unsigned long)
static size_t searchCodeIndex(const unsigned* array, size_t array_size, size_t value)
{
  /*linear search implementation*/
  /*for(size_t i = 1; i < array_size; ++i) if(array[i] > value) return i - 1;
  return array_size - 1;*/

  /*binary search implementation (not that much faster) (precondition: array_size > 0)*/
  size_t left  = 1;
  size_t right = array_size - 1;
  while(left <= right)
  {
    size_t mid = (left + right) / 2;
    if(array[mid] <= value) left = mid + 1; /*the value to find is more to the right*/
    else if(array[mid - 1] > value) right = mid - 1; /*the value to find is more to the left*/
    else return mid - 1;
  }
  return array_size - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0x1f371
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
shrq %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpq -0x20(%rbp), %rax
ja 0x1f33c
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1f36f
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
cmpq -0x20(%rbp), %rax
jbe 0x1f35f
movq -0x38(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1f36d
movq -0x38(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1f37d
jmp 0x1f36f
jmp 0x1f304
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: logicx24[P]RayTracer/lodepng.cpp
// Function: readBitsFromReversedStream(unsigned long*, unsigned char const*, unsigned long)
static unsigned readBitsFromReversedStream(size_t* bitpointer, const unsigned char* bitstream, size_t nbits)
{
  unsigned result = 0;
  size_t i;
  for(i = nbits - 1; i < nbits; --i)
  {
    result += (unsigned)readBitFromReversedStream(bitpointer, bitstream) << i;
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1f79b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1f7b0
movzbl %al, %eax
movq -0x28(%rbp), %rcx
shll %cl, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1f767
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: logicx24[P]RayTracer/lodepng.cpp
// Function: ucvector_resizev(ucvector*, unsigned long, unsigned char)
static unsigned ucvector_resizev(ucvector* p, size_t size, unsigned char value)
{
  size_t oldsize = p->size, i;
  if(!ucvector_resize(p, size)) return 0;
  for(i = oldsize; i < size; ++i) p->data[i] = value;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c320
cmpl $0x0, %eax
jne 0x207dc
movl $0x0, -0x4(%rbp)
jmp 0x20814
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2080d
movb -0x19(%rbp), %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x207e4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: superblocks[P]superblocks/set-spt.cpp
// Function: Superblocks::init()
void Superblocks::init() {

	coin = "SPT"; 
	coin_name = "Spots";

	hash_length = 64;

	// normal (step 0)
	reward[0] = 49;

	// superblock (step 1)
	reward[1] = 10045; // superblock reward (step 1)
	seed_type[1] = SEED_WITH_PREVIOUS_BLOCK_HASH;
	cutout_start[1] = 8;
	cutout_length[1] = 7;
	rnd_range_low[1] = 1;
	rnd_range_high[1] = 100000;
	luck_type[1] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[1] = 50000;
	luck_y[1] = 50011;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x18, %rdi
leaq 0xce1(%rip), %rsi       # 0x4b00
callq 0x21c0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
leaq 0xcd1(%rip), %rsi       # 0x4b04
callq 0x21c0
movq -0x10(%rbp), %rax
movl $0x40, 0x58(%rax)
movl $0x31, 0xd4(%rax)
movl $0x273d, 0xd8(%rax)     # imm = 0x273D
movl $0x2, 0x60(%rax)
movl $0x8, 0x68(%rax)
movl $0x7, 0x70(%rax)
movl $0x1, 0x78(%rax)
movl $0x186a0, 0x80(%rax)    # imm = 0x186A0
movl $0x3, 0xc0(%rax)
movl $0xc350, 0xc8(%rax)     # imm = 0xC350
movl $0xc35b, 0xd0(%rax)     # imm = 0xC35B
addq $0x10, %rsp
popq %rbp
retq
// File: HQarroum[P]thread-pool/examples/working-with-tokens/main.cpp
// Function: main
int main() {
 thread::pool::pool_t pool(std::thread::hardware_concurrency() + 1);
 
 // Creating a producer token.
 auto producer_token = pool.create_token_of<thread::pool::producer_token_t>();

 // Filling our array with `iterations` amount of functions,
 // bound to the number `42`.
 std::fill_n(callables, iterations, std::bind(static_void_function, 42));
 // Scheduling the execution in bulk.
 auto result = pool.schedule_bulk(producer_token, callables, iterations);
 // Log whether the insertion was successful.
 std::cout << "The insertion has " << (result ? "succeeded." : "failed.") << std::endl;
 assert(result == true);
 return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp            # imm = 0x2F0
movl $0x0, -0x4(%rbp)
callq 0x21b0
incl %eax
movl %eax, %esi
leaq -0x2a0(%rbp), %rdi
movq %rdi, -0x2d8(%rbp)
callq 0x2900
movq -0x2d8(%rbp), %rsi
leaq -0x2a8(%rbp), %rdi
callq 0x2a10
jmp 0x24c3
movl $0x2a, -0x2cc(%rbp)
leaq -0x94(%rip), %rsi       # 0x2440
leaq -0x2c8(%rbp), %rdi
leaq -0x2cc(%rbp), %rdx
callq 0x2aa0
jmp 0x24e9
leaq 0x13c80(%rip), %rdi     # 0x16170
movl $0x64, %esi
leaq -0x2c8(%rbp), %rdx
callq 0x2a40
jmp 0x2503
leaq 0x13c66(%rip), %rdx     # 0x16170
leaq -0x2a0(%rbp), %rdi
leaq -0x2a8(%rbp), %rsi
movl $0x64, %ecx
callq 0x2ae0
movb %al, -0x2cd(%rbp)
movq 0x13aa1(%rip), %rdi     # 0x15fd0
leaq 0xcd4a(%rip), %rsi      # 0xf280
callq 0x2150
movq %rax, -0x2e0(%rbp)
jmp 0x2544
movq -0x2e0(%rbp), %rdi
movb -0x2cd(%rbp), %cl
leaq 0xcd3b(%rip), %rax      # 0xf293
leaq 0xcd3f(%rip), %rsi      # 0xf29e
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x2150
movq %rax, -0x2e8(%rbp)
jmp 0x2574
movq -0x2e8(%rbp), %rdi
movq 0x13a1e(%rip), %rsi     # 0x15fa0
callq 0x2180
jmp 0x2589
movb -0x2cd(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x259b
jmp 0x25ee
leaq 0xcd04(%rip), %rdi      # 0xf2a6
leaq 0xcd0c(%rip), %rsi      # 0xf2b5
movl $0x25, %edx
leaq 0xcd09(%rip), %rcx      # 0xf2be
callq 0x20f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2b0(%rbp)
movl %eax, -0x2b4(%rbp)
jmp 0x2619
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2b0(%rbp)
movl %eax, -0x2b4(%rbp)
leaq -0x2a8(%rbp), %rdi
callq 0x2b30
jmp 0x2619
movl $0x0, -0x4(%rbp)
leaq -0x2a8(%rbp), %rdi
callq 0x2b30
leaq -0x2a0(%rbp), %rdi
callq 0x2b80
movl -0x4(%rbp), %eax
addq $0x2f0, %rsp            # imm = 0x2F0
popq %rbp
retq
leaq -0x2a0(%rbp), %rdi
callq 0x2b80
movq -0x2b0(%rbp), %rdi
callq 0x2230
nopw %cs:(%rax,%rax)
// File: HQarroum[P]thread-pool/examples/working-with-tokens/./../../includes/blocking_concurrent_queue.hpp
// Function: bool moodycamel::BlockingConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::enqueue_bulk<std::function<void ()> const*>(moodycamel::ProducerToken const&, std::function<void ()> const*, unsigned long)
inline bool enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
	{
		if ((details::likely)(inner.enqueue_bulk(token, std::forward<It>(itemFirst), count))) {
			sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count);
			return true;
		}
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xd3d0
movzbl %al, %edi
andl $0x1, %edi
callq 0x27b0
testb $0x1, %al
jne 0xd392
jmp 0xd3b4
movq -0x30(%rbp), %rdi
addq $0x268, %rdi            # imm = 0x268
callq 0x5710
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0xd410
movb $0x1, -0x1(%rbp)
jmp 0xd3b8
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ipatix[P]wav2agb/converter.cpp
// Function: agb_out(std::basic_ofstream<char, std::char_traits<char>>&, char const*, ...)
static void agb_out(std::ofstream& ofs, const char *msg, ...) {
    char buf[256];
    va_list args;
    va_start(args, msg);
    vsnprintf(buf, sizeof(buf), msg, args);
    va_end(args);
    ofs << buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
testb %al, %al
je 0x3db7
movaps %xmm0, -0x1b0(%rbp)
movaps %xmm1, -0x1a0(%rbp)
movaps %xmm2, -0x190(%rbp)
movaps %xmm3, -0x180(%rbp)
movaps %xmm4, -0x170(%rbp)
movaps %xmm5, -0x160(%rbp)
movaps %xmm6, -0x150(%rbp)
movaps %xmm7, -0x140(%rbp)
movq %r9, -0x1b8(%rbp)
movq %r8, -0x1c0(%rbp)
movq %rcx, -0x1c8(%rbp)
movq %rdx, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x1e0(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movl $0x30, -0x12c(%rbp)
movl $0x10, -0x130(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x110(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
movl $0x100, %esi            # imm = 0x100
leaq -0x130(%rbp), %rcx
callq 0x31c0
movq -0x1e8(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x3290
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ipatix[P]wav2agb/converter.cpp
// Function: convert_uncompressed(wav_file&, std::basic_ofstream<char, std::char_traits<char>>&)
static void convert_uncompressed(wav_file& wf, std::ofstream& ofs)
{
    int loop_sample = 0;

    uint32_t block_pos = 0;

    for (size_t i = 0; i < wf.loopEnd; i++) {
        double ds;
        wf.readData(i, &ds, 1);
        // TODO apply dither noise
        int s = clamp(static_cast<int>(floor(ds * 128.0)), -128, 127);

        if (wf.loopEnabled && i == wf.loopStart)
            loop_sample = s;

        data_write(ofs, block_pos, s, false);
    }

    data_write(ofs, block_pos, loop_sample, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x258(%rcx), %ecx
cmpq %rcx, %rax
jae 0x3f29
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
movl $0x1, %ecx
callq 0x84d0
movsd 0x8185(%rip), %xmm0     # 0xc030
mulsd -0x28(%rbp), %xmm0
callq 0x3480
cvttsd2si %xmm0, %eax
movl %eax, -0x30(%rbp)
movl $0xffffff80, -0x34(%rbp) # imm = 0xFFFFFF80
movl $0x7f, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x4650
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x25c(%rax)
je 0x3f06
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x254(%rcx), %ecx
cmpq %rcx, %rax
jne 0x3f06
movl -0x2c(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq -0x18(%rbp), %rsi
xorl %ecx, %ecx
callq 0x4250
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3e76
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x18(%rbp), %rsi
xorl %ecx, %ecx
callq 0x4250
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ipatix[P]wav2agb/converter.cpp
// Function: data_write(std::basic_ofstream<char, std::char_traits<char>>&, unsigned int&, int, bool)
static void data_write(std::ofstream& ofs, uint32_t& block_pos, int data, bool hex) {
    if (block_pos++ == 0) {
        if (hex)
            agb_out(ofs, "\n    .byte   0x%02X", data);
        else
            agb_out(ofs, "\n    .byte   %4d", data);
    } else {
        if (hex)
            agb_out(ofs, ", 0x%02X", data);
        else
            agb_out(ofs, ", %4d", data);
    }
    block_pos %= 16;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, (%rcx)
cmpl $0x0, %eax
jne 0x42b0
testb $0x1, -0x15(%rbp)
je 0x4299
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x7e8c(%rip), %rsi      # 0xc11c
movb $0x0, %al
callq 0x3d70
jmp 0x42ae
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x7e89(%rip), %rsi      # 0xc130
movb $0x0, %al
callq 0x3d70
jmp 0x42e4
testb $0x1, -0x15(%rbp)
je 0x42cd
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x7e7d(%rip), %rsi      # 0xc141
movb $0x0, %al
callq 0x3d70
jmp 0x42e2
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x7e6f(%rip), %rsi      # 0xc14a
movb $0x0, %al
callq 0x3d70
jmp 0x42e4
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xf, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ipatix[P]wav2agb/wav2agb.cpp
// Function: usage()
static void usage() {
    fprintf(stderr, "wav2agb\n");
    fprintf(stderr, "\n");
    fprintf(stderr, "Usage: wav2agb [options] <input.wav> [<output.s>]\n");
    fprintf(stderr, "\n");
    fprintf(stderr, "Options:\n");
    fprintf(stderr, "-s, --symbol <sym>       | symbol name for wave header (default: file name)\n");
    fprintf(stderr, "-l, --lookahead <amount> | DPCM compression lookahead 1..8 (default: 3)\n");
    fprintf(stderr, "-c, --compress           | compress output with DPCM\n");
    fprintf(stderr, "--loop-start <pos>       | override loop start (integer)\n");
    fprintf(stderr, "--loop-end <pos>         | override loop end (integer)\n");
    fprintf(stderr, "--tune <cents>           | override tuning (float)\n");
    fprintf(stderr, "--key <key>              | override midi key (int)\n");
    fprintf(stderr, "--rate <rate>            | override base samplerate (int)\n");
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb495(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
leaq 0x6843(%rip), %rsi      # 0xc388
movb $0x0, %al
callq 0x33d0
movq 0xb47d(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
leaq 0x6538(%rip), %rsi      # 0xc095
movb $0x0, %al
callq 0x33d0
movq 0xb465(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
leaq 0x681c(%rip), %rsi      # 0xc391
movb $0x0, %al
callq 0x33d0
movq 0xb44d(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
leaq 0x6508(%rip), %rsi      # 0xc095
movb $0x0, %al
callq 0x33d0
movq 0xb435(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
leaq 0x681f(%rip), %rsi      # 0xc3c4
movb $0x0, %al
callq 0x33d0
movq 0xb41d(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
leaq 0x6811(%rip), %rsi      # 0xc3ce
movb $0x0, %al
callq 0x33d0
movq 0xb405(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
leaq 0x6846(%rip), %rsi      # 0xc41b
movb $0x0, %al
callq 0x33d0
movq 0xb3ed(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
leaq 0x6877(%rip), %rsi      # 0xc464
movb $0x0, %al
callq 0x33d0
movq 0xb3d5(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
leaq 0x6895(%rip), %rsi      # 0xc49a
movb $0x0, %al
callq 0x33d0
movq 0xb3bd(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
leaq 0x68b7(%rip), %rsi      # 0xc4d4
movb $0x0, %al
callq 0x33d0
movq 0xb3a5(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
leaq 0x68d7(%rip), %rsi      # 0xc50c
movb $0x0, %al
callq 0x33d0
movq 0xb38d(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
leaq 0x68f3(%rip), %rsi      # 0xc540
movb $0x0, %al
callq 0x33d0
movq 0xb375(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
leaq 0x690f(%rip), %rsi      # 0xc574
movb $0x0, %al
callq 0x33d0
movl $0x1, %edi
callq 0x3340
nopw %cs:(%rax,%rax)
// File: ipatix[P]wav2agb/wav2agb.cpp
// Function: die(char const*, ...)
static void die(const char *msg, ...) {
    va_list args;
    va_start(args, msg);
    vfprintf(stderr, msg, args);
    va_end(args);
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x5cb5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xb2c9(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3380
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x3340
nopw %cs:(%rax,%rax)
// File: ipatix[P]wav2agb/wav2agb.cpp
// Function: fix_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
static void fix_str(std::string& str) {
    // replaces all characters that are not alphanumerical
    for (size_t i = 0; i < str.size(); i++) {
        if (str[i] >= 'a' && str[i] <= 'z')
            continue;
        if (str[i] >= 'A' && str[i] <= 'Z')
            continue;
        if (str[i] >= '0' && str[i] <= '9' && i > 0)
            continue;
        str[i] = '_';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x5e11
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3560
movsbl (%rax), %eax
cmpl $0x61, %eax
jl 0x5d91
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3560
movsbl (%rax), %eax
cmpl $0x7a, %eax
jg 0x5d91
jmp 0x5e00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3560
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0x5dbd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3560
movsbl (%rax), %eax
cmpl $0x5a, %eax
jg 0x5dbd
jmp 0x5e00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3560
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x5df0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3560
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x5df0
cmpq $0x0, -0x10(%rbp)
jbe 0x5df0
jmp 0x5e00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3560
movb $0x5f, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5d44
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ipatix[P]wav2agb/wav2agb.cpp
// Function: filename_without_ext(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string filename_without_ext(const std::string& str) {
    size_t last_path_seperator = 0;
    char *sep = path_seperators;
    while (*sep) {
        size_t pos = str.find_last_of(*sep);
        if (pos != std::string::npos)
            last_path_seperator = std::max(pos, last_path_seperator);
        sep += 1;
    }
    size_t file_ext_dot_pos = str.find_last_of('.');
    if (file_ext_dot_pos == std::string::npos)
        return std::string(str);
    assert(file_ext_dot_pos != last_path_seperator);
    if (file_ext_dot_pos > last_path_seperator)
        return str.substr(0, file_ext_dot_pos);
    return std::string(str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0xb46e(%rip), %rax      # 0x112d8
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5ebb
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq $-0x1, %rdx
movsbl (%rax), %esi
callq 0x3520
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x5ead
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x66d0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5e6e
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x3520
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
jne 0x5eea
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3140
jmp 0x5f43
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x5ef6
jmp 0x5f15
leaq 0x66e0(%rip), %rdi      # 0xc5dd
leaq 0x6701(%rip), %rsi      # 0xc605
movl $0x4a, %edx
leaq 0x6701(%rip), %rcx      # 0xc611
callq 0x31d0
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x5f36
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x32c0
jmp 0x5f43
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3140
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ipatix[P]wav2agb/wav2agb.cpp
// Function: filename_without_dir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string filename_without_dir(const std::string& str) {
    size_t last_path_seperator = 0;
    bool path_seperator_found = false;
    char *sep = path_seperators;
    while (*sep) {
        size_t pos = str.find_last_of(*sep);
        if (pos != std::string::npos) {
            last_path_seperator = std::max(pos, last_path_seperator);
            path_seperator_found = true;
        }
        sep += 1;
    }
    if (str.size() > 0 && path_seperator_found) {
        return str.substr(last_path_seperator + 1);
    } else {
        return std::string(str);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq 0xb35a(%rip), %rax      # 0x112d8
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5fd3
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq $-0x1, %rdx
movsbl (%rax), %esi
callq 0x3520
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
je 0x5fc5
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x66d0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5f82
movq -0x10(%rbp), %rdi
callq 0x31f0
cmpq $0x0, %rax
jbe 0x6006
testb $0x1, -0x19(%rbp)
je 0x6006
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
movq $-0x1, %rcx
callq 0x32c0
jmp 0x6013
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3140
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ipatix[P]wav2agb/wav_file.cpp
// Function: wav_file::fmt_size() const
uint32_t wav_file::fmt_size() const
{
    if (fmt == format_type::u8)
        return 1;
    else if (fmt == format_type::s16)
        return 2;
    else if (fmt == format_type::s24)
        return 3;
    else if (fmt == format_type::s32)
        return 4;
    else if (fmt == format_type::f32)
        return 4;
    else if (fmt == format_type::f64)
        return 8;
    else
        throw std::runtime_error("INTERNAL ERROR: invalid format type");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0x250(%rax)
jne 0x69c9
movl $0x1, -0x4(%rbp)
jmp 0x6a8d
movq -0x28(%rbp), %rax
cmpl $0x1, 0x250(%rax)
jne 0x69e2
movl $0x2, -0x4(%rbp)
jmp 0x6a8d
movq -0x28(%rbp), %rax
cmpl $0x2, 0x250(%rax)
jne 0x69fb
movl $0x3, -0x4(%rbp)
jmp 0x6a8d
movq -0x28(%rbp), %rax
cmpl $0x3, 0x250(%rax)
jne 0x6a11
movl $0x4, -0x4(%rbp)
jmp 0x6a8d
movq -0x28(%rbp), %rax
cmpl $0x4, 0x250(%rax)
jne 0x6a27
movl $0x4, -0x4(%rbp)
jmp 0x6a8d
movq -0x28(%rbp), %rax
cmpl $0x5, 0x250(%rax)
jne 0x6a3d
movl $0x8, -0x4(%rbp)
jmp 0x6a8d
movl $0x10, %edi
callq 0x3160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x5c40(%rip), %rsi      # 0xc698
callq 0x3110
jmp 0x6a5f
movq -0x30(%rbp), %rdi
movq 0xa58e(%rip), %rsi      # 0x10ff8
movq 0xa557(%rip), %rdx      # 0x10fc8
callq 0x34a0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3210
jmp 0x6a96
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34e0
nop
// File: brunokeymolen[P]ssdp/src/tools.cpp
// Function: hexdump(unsigned char*, unsigned int)
void hexdump(u8* buf, u32 len){
    for(u32 pos=0;pos<len;pos++){
        printf("%02x ", buf[pos]);
        if(pos%32 == 0 && pos !=0){
            printf("\n");
        }
    }
   printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x3793
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movzbl (%rax,%rcx), %esi
leaq 0xc8a4(%rip), %rdi      # 0x10004
movb $0x0, %al
callq 0x3040
movl -0x10(%rbp), %eax
andl $0x1f, %eax
cmpl $0x0, %eax
jne 0x3786
cmpl $0x0, -0x10(%rbp)
je 0x3786
leaq 0xcc72(%rip), %rdi      # 0x103f1
movb $0x0, %al
callq 0x3040
jmp 0x3788
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3746
leaq 0xcc57(%rip), %rdi      # 0x103f1
movb $0x0, %al
callq 0x3040
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: brunokeymolen[P]ssdp/src/tools.cpp
// Function: createUUID(char*)
int createUUID(char uuid[UUID_LEN]){
    static u8 _rand_init = 0;
    static char randstate[2048];
    if(_rand_init == 0){
        initstate((unsigned int)time(NULL), randstate, 2048);
        setstate(randstate);
        _rand_init = 1;
    }

    u32 r[8];
    for(int x=0;x<8;x++){
        r[x] = (unsigned int)random();
    }
    //Make repres
    //Fix this
    /* IcY: there are 14 arguments specified in the printf format string
     * but 16 arguments?
     */
    sprintf(uuid, "%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X", r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7], r[0], r[1], r[2], r[3], r[4], r[5]/*, r[6], r[7]*/);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, -0x30(%rbp)
movzbl 0x14b01(%rip), %eax     # 0x182d0
cmpl $0x0, %eax
jne 0x3803
xorl %eax, %eax
movl %eax, %edi
callq 0x3280
movl %eax, %edi
leaq 0x14afa(%rip), %rsi     # 0x182e0
movl $0x800, %edx            # imm = 0x800
callq 0x31e0
leaq 0x14ae9(%rip), %rdi     # 0x182e0
callq 0x3370
movb $0x1, 0x14acd(%rip)     # 0x182d0
movl $0x0, -0x54(%rbp)
cmpl $0x8, -0x54(%rbp)
jge 0x382a
callq 0x3140
movl %eax, %ecx
movslq -0x54(%rbp), %rax
movl %ecx, -0x50(%rbp,%rax,4)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x380a
movq -0x30(%rbp), %rdi
movl -0x50(%rbp), %edx
movl -0x4c(%rbp), %ecx
movl -0x48(%rbp), %r8d
movl -0x44(%rbp), %r9d
movl -0x40(%rbp), %eax
movl -0x3c(%rbp), %esi
movl %esi, -0x5c(%rbp)
movl -0x38(%rbp), %r13d
movl -0x34(%rbp), %r12d
movl -0x50(%rbp), %r15d
movl -0x4c(%rbp), %r14d
movl -0x48(%rbp), %ebx
movl -0x44(%rbp), %r11d
movl -0x40(%rbp), %r10d
movl -0x3c(%rbp), %esi
movl %esi, -0x58(%rbp)
leaq 0xc79d(%rip), %rsi      # 0x1000a
movl %eax, (%rsp)
movl -0x5c(%rbp), %eax
movl %eax, 0x8(%rsp)
movl -0x58(%rbp), %eax
movl %r13d, 0x10(%rsp)
movl %r12d, 0x18(%rsp)
movl %r15d, 0x20(%rsp)
movl %r14d, 0x28(%rsp)
movl %ebx, 0x30(%rsp)
movl %r11d, 0x38(%rsp)
movl %r10d, 0x40(%rsp)
movl %eax, 0x48(%rsp)
movb $0x0, %al
callq 0x30a0
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax,%rax)
// File: brunokeymolen[P]ssdp/src/tools.cpp
// Function: lefttrim(unsigned char*, unsigned int)
u8* lefttrim(u8* buf, u32 len){
    if(len==0){
        return buf;
    }
    u8* pos = buf;
    while(pos<=(buf+len) && *pos==' '){
        pos++;
    }
    return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x38db
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x392a
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %eax
addq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x21(%rbp)
ja 0x390b
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3914
jmp 0x3922
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x38e3
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: brunokeymolen[P]ssdp/src/tools.cpp
// Function: righttrim(unsigned char*, unsigned int)
u32 righttrim(u8* buf, u32 len){
    if(len==0){
        return len;
    }
    u8* pos = buf+len-1;
    while(pos>=buf && *pos==' '){
        pos--;
    }
    return (unsigned int)((pos-buf)+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x3949
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x39a3
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x21(%rbp)
jb 0x397a
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3983
jmp 0x3991
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x395b
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: brunokeymolen[P]ssdp/src/tools.cpp
// Function: trimspaces(unsigned char**, unsigned int*)
void trimspaces(u8** buf, u32* len){
    u8 *b = *buf;
    u32 l = *len;
    //left
    b = lefttrim(*buf, *len);
    l = (int)(l - (b - *buf));
    //right
    l = righttrim(b, l);

    *buf = b;
    *len = l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x38c0
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3930
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: brunokeymolen[P]ssdp/src/tools.cpp
// Function: getchar(unsigned char*, unsigned int, char)
int getchar(u8* buf, u32 len, char c){
    int ret = -1;
    for(int x=0;x<(int)len;x++){
        if(buf[x]==c){
            ret=x;
            break;
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3c1f
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movsbl -0xd(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3c12
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x3c1f
jmp 0x3c14
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3bee
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: brunokeymolen[P]ssdp/src/tools.cpp
// Function: getchar(unsigned char*, unsigned int, char, int)
int getchar(u8* buf, u32 len, char c, int seq){
    int ret = -1;
    int found=0;
    for(int x=0;x<(int)len;x++){
        if(buf[x]==c){
            found++;
            if(found==seq){
                ret=x;
                break;
            }
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movl %ecx, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3c9c
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movsbl -0xd(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3c8f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x3c8d
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x3c9c
jmp 0x3c8f
jmp 0x3c91
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3c58
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: brunokeymolen[P]ssdp/src/ssdp.cpp
// Function: SSDP::~SSDP()
SSDP::~SSDP(){
    Stop();
    delete(mParser);
    mParser = NULL;
    mDB->Stop();
    delete(mDB);
    mDB = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x13a3d(%rip), %rax     # 0x178d8
movq %rax, (%rdi)
callq 0x3f60
jmp 0x3ea5
movq -0x10(%rbp), %rax
movq 0x240(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3ed1
movq -0x18(%rbp), %rdi
callq 0xc590
movq -0x18(%rbp), %rdi
movl $0x40, %esi
callq 0x32f0
movq -0x10(%rbp), %rax
movq $0x0, 0x240(%rax)
movq 0x248(%rax), %rdi
callq 0x6f20
jmp 0x3eee
movq -0x10(%rbp), %rax
movq 0x248(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x3f1a
movq -0x20(%rbp), %rdi
callq 0x6db0
movq -0x20(%rbp), %rdi
movl $0x70, %esi
callq 0x32f0
movq -0x10(%rbp), %rdi
movq $0x0, 0x248(%rdi)
addq $0x220, %rdi            # imm = 0x220
callq 0x3548
movq -0x10(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0x3548
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x5850
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x58b0