LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: adamnovak[P]rlcsa/bits/array.cpp
// Function: CSA::Array::Array(_IO_FILE*)
Array::Array(FILE* file) :
  delete_array(true), item_index(0)
{
  if(!std::fread(&(this->items), sizeof(this->items), 1, file)) { return; }
  if(!std::fread(&(this->number_of_blocks), sizeof(this->number_of_blocks), 1, file)) { return; }
  if(!std::fread(&(this->block_size), sizeof(this->block_size), 1, file)) { return; }

  this->array = new usint[this->block_size * this->number_of_blocks];
  if(!std::fread(this->array, this->block_size * sizeof(usint), this->number_of_blocks, file)) { return; }
  this->buffer = new ReadBuffer(this->array, this->block_size);

  this->integer_bits = length(this->items);
  this->samples = new ReadBuffer(file, this->number_of_blocks + 1, this->integer_bits);

  this->buildIndex();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movb $0x1, 0x18(%rdi)
movq $0x0, 0x38(%rdi)
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x3460
cmpq $0x0, %rax
jne 0x1c772
jmp 0x1c898
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x3460
cmpq $0x0, %rax
jne 0x1c798
jmp 0x1c898
movq -0x28(%rbp), %rdi
addq $0x1c, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x3460
cmpq $0x0, %rax
jne 0x1c7be
jmp 0x1c898
movq -0x28(%rbp), %rcx
movl 0x1c(%rcx), %eax
imull 0x20(%rcx), %eax
movl %eax, %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movl 0x1c(%rax), %ecx
movl %ecx, %esi
shlq $0x2, %rsi
movl 0x20(%rax), %eax
movl %eax, %edx
movq -0x10(%rbp), %rcx
callq 0x3460
cmpq $0x0, %rax
jne 0x1c81a
jmp 0x1c898
movl $0x28, %edi
callq 0x32c0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rsi
movl 0x1c(%rax), %edx
callq 0x1e130
jmp 0x1c840
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl (%rax), %edi
callq 0x14da0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x30(%rax)
movl $0x28, %edi
callq 0x32c0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movl 0x20(%rax), %edx
movl 0x30(%rax), %ecx
incl %edx
callq 0x1e060
jmp 0x1c887
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, 0x28(%rdi)
callq 0x1c590
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x28, %esi
callq 0x32d0
jmp 0x1c8d4
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x28, %esi
callq 0x32d0
movq -0x18(%rbp), %rdi
callq 0x3530
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/array.cpp
// Function: CSA::Array::~Array()
Array::~Array()
{
  if(this->delete_array) { delete[] this->array; }
  delete this->buffer;
  delete this->samples;
  delete this->item_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x18(%rax)
je 0x1cc47
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1cc45
movq -0x18(%rbp), %rdi
callq 0x33e0
jmp 0x1cc47
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1cc70
movq -0x20(%rbp), %rdi
callq 0x1e230
movq -0x20(%rbp), %rdi
movl $0x28, %esi
callq 0x32d0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1cc99
movq -0x28(%rbp), %rdi
callq 0x1e230
movq -0x28(%rbp), %rdi
movl $0x28, %esi
callq 0x32d0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1ccc2
movq -0x30(%rbp), %rdi
callq 0x1e230
movq -0x30(%rbp), %rdi
movl $0x28, %esi
callq 0x32d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/array.cpp
// Function: CSA::Array::writeTo(std::basic_ofstream<char, std::char_traits<char>>&) const
void
Array::writeTo(std::ofstream& file) const
{
  file.write((char*)&(this->items), sizeof(this->items));
  file.write((char*)&(this->number_of_blocks), sizeof(this->number_of_blocks));
  file.write((char*)&(this->block_size), sizeof(this->block_size));
  file.write((char*)(this->array), this->block_size * this->number_of_blocks * sizeof(usint));
  this->samples->writeBuffer(file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %edx
callq 0x33f0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x20, %rsi
movl $0x4, %edx
callq 0x33f0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x1c, %rsi
movl $0x4, %edx
callq 0x33f0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdi
movq 0x10(%rcx), %rsi
movl 0x1c(%rcx), %eax
imull 0x20(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x2, %rdx
callq 0x33f0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x15010
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/array.cpp
// Function: CSA::Array::writeTo(_IO_FILE*) const
void
Array::writeTo(FILE* file) const
{
  if(file == 0) { return; }
  std::fwrite(&(this->items), sizeof(this->items), 1, file);
  std::fwrite(&(this->number_of_blocks), sizeof(this->number_of_blocks), 1, file);
  std::fwrite(&(this->block_size), sizeof(this->block_size), 1, file);
  std::fwrite(this->array, this->block_size * sizeof(usint), this->number_of_blocks, file);
  this->samples->writeTo(file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1cd81
jmp 0x1cdfe
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x3580
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x3580
movq -0x18(%rbp), %rdi
addq $0x1c, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x3580
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl 0x1c(%rax), %ecx
movl %ecx, %esi
shlq $0x2, %rsi
movl 0x20(%rax), %eax
movl %eax, %edx
movq -0x10(%rbp), %rcx
callq 0x3580
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e2c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/array.cpp
// Function: CSA::Array::reportSize() const
usint
Array::reportSize() const
{
  usint bytes = sizeof(*this);
  bytes += this->buffer->reportSize();
  bytes += this->block_size * this->number_of_blocks * sizeof(usint);
  bytes += this->samples->reportSize();
  bytes += this->item_index->reportSize();
  return bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x48, -0xc(%rbp)
movq 0x8(%rax), %rdi
callq 0x1e370
movl %eax, %ecx
movq -0x18(%rbp), %rax
addl -0xc(%rbp), %ecx
movl %ecx, -0xc(%rbp)
movl 0x1c(%rax), %ecx
imull 0x20(%rax), %ecx
movl %ecx, %ecx
movl %ecx, %edx
shlq $0x2, %rdx
movl -0xc(%rbp), %ecx
addq %rdx, %rcx
movl %ecx, -0xc(%rbp)
movq 0x28(%rax), %rdi
callq 0x1e370
movl %eax, %ecx
movq -0x18(%rbp), %rax
addl -0xc(%rbp), %ecx
movl %ecx, -0xc(%rbp)
movq 0x38(%rax), %rdi
callq 0x1e370
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/array.cpp
// Function: CSA::Array::Iterator::readItem(unsigned int)
usint
Array::Iterator::readItem(usint index)
{
  if(index >= this->parent.items) { return 0; }
  this->getSample(this->sampleForIndex(index));

  usint value = 0;
  while(this->sample + this->cur <= index)
  {
    value = this->buffer.readDeltaCode();
    this->cur++;
  }

  return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq (%rcx), %rcx
cmpl (%rcx), %eax
jb 0x1cf5a
movl $0x0, -0x4(%rbp)
jmp 0x1cfae
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1cfc0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x1d5e0
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl 0xc(%rcx), %eax
addl 0x10(%rcx), %eax
cmpl -0x14(%rbp), %eax
ja 0x1cfa8
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x1d660
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x18(%rbp)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x1cf78
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/array.cpp
// Function: CSA::Array::Iterator::sampleForIndex(unsigned int)
usint
Array::Iterator::sampleForIndex(usint index)
{
  usint low = this->parent.item_index->readItemConst(index / this->parent.index_rate);
  usint high = this->parent.number_of_blocks - 1;

  this->samples.goToItem(low + 1);
  for(; low < high; low++)
  {
    if(this->samples.readItem() > index) { return low; }
  }

  return low;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq (%rcx), %rax
movq 0x38(%rax), %rdi
movl -0x14(%rbp), %eax
movq (%rcx), %rcx
xorl %edx, %edx
divl 0x40(%rcx)
movl %eax, %esi
callq 0xeea0
movq -0x28(%rbp), %rdi
movl %eax, -0x18(%rbp)
movq (%rdi), %rax
movl 0x20(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
addq $0x40, %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0x15070
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x1d041
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0x14ff0
cmpl -0x14(%rbp), %eax
jbe 0x1d034
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1d047
jmp 0x1d036
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1d012
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: adamnovak[P]rlcsa/bits/array.cpp
// Function: CSA::Array::Iterator::nextItem()
usint
Array::Iterator::nextItem()
{
  if(this->cur >= this->block_items)
  {
    this->getSample(this->block + 1);
  }

  this->cur++;
  return this->buffer.readDeltaCode();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0x10(%rcx), %eax
cmpl 0x14(%rcx), %eax
jb 0x1d07b
movq -0x10(%rbp), %rdi
movl 0x8(%rdi), %esi
addl $0x1, %esi
callq 0x1d5e0
movq -0x10(%rbp), %rdi
movl 0x10(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x10(%rdi)
addq $0x18, %rdi
callq 0x1d660
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/array.cpp
// Function: CSA::ArrayEncoder::ArrayEncoder(unsigned int, unsigned int)
ArrayEncoder::ArrayEncoder(usint block_bytes, usint superblock_size) :
  items(0), blocks(1),
  block_size(BYTES_TO_WORDS(block_bytes)),
  superblock_bytes(superblock_size)
{
  this->array = new usint[this->superblock_bytes / sizeof(usint)];
  memset(this->array, 0, this->superblock_bytes);
  this->blocks_in_superblock = this->superblock_bytes / (sizeof(usint) * this->block_size);
  this->current_blocks = 1;

  this->samples = new usint[this->superblock_bytes / sizeof(usint)];
  this->samples_in_superblock = this->superblock_bytes / sizeof(usint);
  this->current_samples = 1;
  this->samples[0] = 0;

  this->buffer = new WriteBuffer(this->array, this->block_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x0, (%rdi)
movl $0x1, 0x4(%rdi)
movl -0xc(%rbp), %eax
addq $0x3, %rax
shrq $0x2, %rax
movl %eax, 0x8(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0xc(%rdi)
addq $0x18, %rdi
movq %rdi, -0x40(%rbp)
callq 0x1d6f0
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x38(%rbp)
callq 0x1d6f0
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
andl $-0x4, %eax
movl %eax, %edi
callq 0x3030
movq %rax, -0x28(%rbp)
jmp 0x1d110
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq 0x30(%rax), %rdi
movl 0xc(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
movl %esi, -0x4c(%rbp)
callq 0x3190
movl -0x4c(%rbp), %edx
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
movl 0xc(%rax), %eax
shlq $0x2, %rcx
divq %rcx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl %ecx, 0x38(%rax)
movl $0x1, 0x3c(%rax)
movl 0xc(%rax), %eax
andl $-0x4, %eax
movl %eax, %edi
callq 0x3030
movq %rax, -0x48(%rbp)
jmp 0x1d167
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x58(%rax)
movl 0xc(%rax), %ecx
shrl $0x2, %ecx
movl %ecx, 0x60(%rax)
movl $0x1, 0x64(%rax)
movq 0x58(%rax), %rax
movl $0x0, (%rax)
movl $0x28, %edi
callq 0x32c0
movq %rax, -0x58(%rbp)
jmp 0x1d19d
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rsi
movl 0x8(%rax), %edx
callq 0x1e4c0
jmp 0x1d1b3
movq -0x30(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1d1ed
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x28, %esi
callq 0x32d0
movq -0x38(%rbp), %rdi
callq 0x1d710
movq -0x40(%rbp), %rdi
callq 0x1d710
movq -0x18(%rbp), %rdi
callq 0x3530
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/array.cpp
// Function: CSA::ArrayEncoder::~ArrayEncoder()
ArrayEncoder::~ArrayEncoder()
{
  delete[] this->array;

  delete this->buffer;
  for(std::list<usint*>::iterator iter = this->array_blocks.begin(); iter != this->array_blocks.end(); iter++)
  {
    delete[] *iter;
  }

  delete[] this->samples;
  for(std::list<usint*>::iterator iter = this->sample_blocks.begin(); iter != this->sample_blocks.end(); iter++)
  {
    delete[] *iter;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1d23b
movq -0x40(%rbp), %rdi
callq 0x33e0
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x1d264
movq -0x50(%rbp), %rdi
callq 0x1e570
movq -0x50(%rbp), %rdi
movl $0x28, %esi
callq 0x32d0
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x1d4e0
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x1d540
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1d510
testb $0x1, %al
jne 0x1d299
jmp 0x1d2cb
leaq -0x10(%rbp), %rdi
callq 0x1d570
movq (%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x1d2b8
movq -0x58(%rbp), %rdi
callq 0x33e0
jmp 0x1d2ba
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x1d590
movq %rax, -0x20(%rbp)
jmp 0x1d275
movq -0x48(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x1d2e6
movq -0x60(%rbp), %rdi
callq 0x33e0
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
callq 0x1d4e0
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
callq 0x1d540
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1d510
testb $0x1, %al
jne 0x1d31b
jmp 0x1d34d
leaq -0x28(%rbp), %rdi
callq 0x1d570
movq (%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x1d33a
movq -0x68(%rbp), %rdi
callq 0x33e0
jmp 0x1d33c
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x1d590
movq %rax, -0x38(%rbp)
jmp 0x1d2f7
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
callq 0x1d710
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x1d710
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/array.cpp
// Function: CSA::ArrayEncoder::writeItem(unsigned int)
void
ArrayEncoder::writeItem(usint value)
{
  this->items++;
  if(this->buffer->writeDeltaCode(value)) { return; }

  // Didn't fit into the block. A new block & sample required.
  this->blocks++;
  this->current_blocks++;
  this->current_samples++;

  // Do we need a new superblock for the block?
  if(this->current_blocks > this->blocks_in_superblock)
  {
    this->array_blocks.push_back(this->array);
    this->array = new usint[this->superblock_bytes / sizeof(usint)];
    memset(this->array, 0, this->superblock_bytes);
    this->current_blocks = 1;
  }
  this->buffer->moveBuffer(this->array + (this->block_size * (this->current_blocks - 1)));

  // Do we need a new superblock for the sample?
  if(this->current_samples > this->samples_in_superblock)
  {
    this->sample_blocks.push_back(this->samples);
    this->samples = new usint[this->superblock_bytes / sizeof(usint)];
    this->current_samples = 1;
  }
  this->samples[this->current_samples - 1] = this->items - 1;

  // Finally, write the item.
  this->buffer->writeDeltaCode(value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x1d730
testb $0x1, %al
jne 0x1d3a0
jmp 0x1d3a5
jmp 0x1d4da
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx)
movl 0x3c(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rcx)
movl 0x64(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x64(%rcx)
movl 0x3c(%rcx), %eax
cmpl 0x38(%rcx), %eax
jbe 0x1d432
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x30, %rsi
callq 0x1d7c0
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
shrq $0x2, %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq 0x30(%rax), %rdi
movl 0xc(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x3190
movq -0x18(%rbp), %rax
movl $0x1, 0x3c(%rax)
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq 0x30(%rcx), %rsi
movl 0x8(%rcx), %eax
movl 0x3c(%rcx), %ecx
subl $0x1, %ecx
imull %ecx, %eax
movl %eax, %eax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x1e720
movq -0x18(%rbp), %rcx
movl 0x64(%rcx), %eax
cmpl 0x60(%rcx), %eax
jbe 0x1d4b6
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x40, %rdi
addq $0x58, %rsi
callq 0x1d7c0
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
shrq $0x2, %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
movl $0x1, 0x64(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %esi
subl $0x1, %esi
movq 0x58(%rax), %rcx
movl 0x64(%rax), %edx
subl $0x1, %edx
movl %edx, %edx
movl %esi, (%rcx,%rdx,4)
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x1d730
addq $0x20, %rsp
popq %rbp
retq
// File: adamnovak[P]rlcsa/bits/array.h
// Function: CSA::Array::Iterator::getSample(unsigned int)
inline void getSample(usint sample_number)
        {
          this->block = sample_number;
          this->sample = this->samples.readItem(sample_number);
          this->cur = 0;
          this->block_items = this->samples.readItem() - this->sample;
          this->buffer.moveBuffer(this->parent.array + (this->block * this->parent.block_size));
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x8(%rdi)
addq $0x40, %rdi
movl -0xc(%rbp), %esi
callq 0x14f90
movq -0x18(%rbp), %rdi
movl %eax, 0xc(%rdi)
movl $0x0, 0x10(%rdi)
addq $0x40, %rdi
callq 0x14ff0
movq -0x18(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, 0x14(%rcx)
movq %rcx, %rdi
addq $0x18, %rdi
movq (%rcx), %rax
movq 0x10(%rax), %rsi
movl 0x8(%rcx), %eax
movq (%rcx), %rcx
imull 0x1c(%rcx), %eax
movl %eax, %eax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x1e310
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitbuffer.h
// Function: CSA::ReadBuffer::readDeltaCode()
inline usint readDeltaCode()
    {
      usint len = 0;
      while(this->readBit() == 0) { len++; }

      usint temp = (((usint)1 << len) | this->readBits(len)) - 1;
      temp = ((usint)1 << temp) | this->readBits(temp);
      return temp;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d800
cmpl $0x0, %eax
jne 0x1d694
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1d67b
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %esi
callq 0x15280
movq -0x18(%rbp), %rdi
movl %eax, %ecx
movl -0x20(%rbp), %eax
orl %ecx, %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %esi
callq 0x15280
movl %eax, %ecx
movl -0x1c(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitbuffer.h
// Function: CSA::WriteBuffer::writeDeltaCode(unsigned int)
inline bool writeDeltaCode(usint value)
    {
      usint len = length(value);
      usint llen = length(len);

      if(len + llen + llen - 2 > this->bitsLeft()) { return false; }

      // this->writeBits(0, llen - 1); // Now included in the next writeBits()
      this->writeBits(len, llen + llen - 1);
      this->writeBits(value, len - 1);
      return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x14da0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
callq 0x14da0
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
addl -0x1c(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x20(%rbp)
callq 0x1db30
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jbe 0x1d784
movb $0x0, -0x1(%rbp)
jmp 0x1d7af
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
addl -0x1c(%rbp), %edx
subl $0x1, %edx
callq 0x151a0
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
subl $0x1, %edx
callq 0x151a0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitbuffer.h
// Function: CSA::ReadBuffer::readBit()
inline usint readBit()
    {
      this->bits--;
      usint bit = this->data[this->pos] & ((usint)1 << this->bits);

      if(this->bits == 0) { this->pos++; this->bits = WORD_BITS; }

      return bit;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x1c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rax)
movq (%rax), %rcx
movl 0x18(%rax), %edx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x10(%rbp)
movl 0x1c(%rax), %ecx
movl $0x1, %edx
shll %cl, %edx
movl -0x10(%rbp), %ecx
andl %edx, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, 0x1c(%rax)
jne 0x1d851
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movl $0x20, 0x1c(%rax)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitbuffer.cpp
// Function: CSA::ReadBuffer::ReadBuffer(std::basic_ifstream<char, std::char_traits<char>>&, unsigned int)
ReadBuffer::ReadBuffer(std::ifstream& file, usint words) :
  size(words),
  item_bits(1),
  items(0),
  free_buffer(true)
{
  usint* buffer = new usint[this->size];
  memset(buffer, 0, this->size * sizeof(usint));
  file.read((char*)buffer, this->size * sizeof(usint));
  this->data = buffer;
  this->reset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl $0x1, 0xc(%rax)
movl $0x0, 0x10(%rax)
movb $0x1, 0x14(%rax)
movl 0x8(%rax), %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl 0x8(%rax), %eax
movl %eax, %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x3190
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl 0x8(%rax), %eax
movl %eax, %edx
shlq $0x2, %rdx
callq 0x33c0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, (%rdi)
callq 0x1e7c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitbuffer.cpp
// Function: CSA::ReadBuffer::ReadBuffer(_IO_FILE*, unsigned int)
ReadBuffer::ReadBuffer(FILE* file, usint words) :
  size(words),
  item_bits(1),
  items(0),
  free_buffer(true)
{
  usint* buffer = new usint[this->size];
  memset(buffer, 0, this->size * sizeof(usint));
  if(file != 0)
  {
    if(!std::fread(buffer, this->size * sizeof(usint), 1, file)) { return; }
  }
  this->data = buffer;
  this->reset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl $0x1, 0xc(%rax)
movl $0x0, 0x10(%rax)
movb $0x1, 0x14(%rax)
movl 0x8(%rax), %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl 0x8(%rax), %eax
movl %eax, %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x3190
cmpq $0x0, -0x10(%rbp)
je 0x1df86
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movl 0x8(%rax), %eax
movl %eax, %esi
shlq $0x2, %rsi
movq -0x10(%rbp), %rcx
movl $0x1, %edx
callq 0x3460
cmpq $0x0, %rax
jne 0x1df84
jmp 0x1df96
jmp 0x1df86
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, (%rdi)
callq 0x1e7c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/bitbuffer.cpp
// Function: CSA::ReadBuffer::ReadBuffer(std::basic_ifstream<char, std::char_traits<char>>&, unsigned int, unsigned int)
ReadBuffer::ReadBuffer(std::ifstream& file, usint _items, usint item_size) :
  item_bits(item_size),
  items(_items),
  free_buffer(true)
{
  this->size = bitsToWords(this->items * this->item_bits);
  usint* buffer = new usint[this->size];
  memset(buffer, 0, this->size * sizeof(usint));
  file.read((char*)buffer, this->size * sizeof(usint));
  this->data = buffer;
  this->reset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movb $0x1, 0x14(%rax)
movl 0x10(%rax), %edi
imull 0xc(%rax), %edi
callq 0x1e7f0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl 0x8(%rax), %eax
movl %eax, %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x3190
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl 0x8(%rax), %eax
movl %eax, %edx
shlq $0x2, %rdx
callq 0x33c0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, (%rdi)
callq 0x1e7c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitbuffer.cpp
// Function: CSA::ReadBuffer::ReadBuffer(_IO_FILE*, unsigned int, unsigned int)
ReadBuffer::ReadBuffer(FILE* file, usint _items, usint item_size) :
  item_bits(item_size),
  items(_items),
  free_buffer(true)
{
  this->size = bitsToWords(this->items * this->item_bits);
  usint* buffer = new usint[this->size];
  memset(buffer, 0, this->size * sizeof(usint));
  if(file != 0)
  {
    if(!std::fread(buffer, this->size * sizeof(usint), 1, file)) { return; }
  }
  this->data = buffer;
  this->reset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movb $0x1, 0x14(%rax)
movl 0x10(%rax), %edi
imull 0xc(%rax), %edi
callq 0x1e7f0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl 0x8(%rax), %eax
movl %eax, %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x3190
cmpq $0x0, -0x10(%rbp)
je 0x1e116
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movl 0x8(%rax), %eax
movl %eax, %esi
shlq $0x2, %rsi
movq -0x10(%rbp), %rcx
movl $0x1, %edx
callq 0x3460
cmpq $0x0, %rax
jne 0x1e114
jmp 0x1e126
jmp 0x1e116
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, (%rdi)
callq 0x1e7c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/bitbuffer.cpp
// Function: CSA::ReadBuffer::moveBuffer(unsigned int const*)
void
ReadBuffer::moveBuffer(const usint* buffer)
{
  if(this->free_buffer)
  {
    delete[] this->data;
  }
  this->free_buffer = false;

  this->data = buffer;
  this->reset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x14(%rax)
je 0x1e34a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1e348
movq -0x20(%rbp), %rdi
callq 0x33e0
jmp 0x1e34a
movq -0x18(%rbp), %rdi
movb $0x0, 0x14(%rdi)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
callq 0x1e7c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitbuffer.cpp
// Function: CSA::WriteBuffer::WriteBuffer(unsigned int, unsigned int)
WriteBuffer::WriteBuffer(usint _items, usint item_size) :
  item_bits(item_size),
  items(_items),
  free_buffer(true)
{
  this->size = bitsToWords(this->items * this->item_bits);
  this->data = new usint[this->size];
  memset(this->data, 0, this->size * sizeof(usint));
  this->reset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movb $0x1, 0x14(%rax)
movl 0x10(%rax), %edi
imull 0xc(%rax), %edi
callq 0x1e840
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
movl 0x8(%rax), %eax
movl %eax, %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x3190
movq -0x18(%rbp), %rdi
callq 0x1e810
addq $0x20, %rsp
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/bits/bitbuffer.cpp
// Function: CSA::WriteBuffer::getReadBuffer()
ReadBuffer*
WriteBuffer::getReadBuffer()
{
  ReadBuffer* buffer;
  if(this->items > 0)
  {
    buffer = new ReadBuffer(this->data, this->items, this->item_bits);
  }
  else
  {
    buffer = new ReadBuffer(this->data, this->size);
  }

  if(this->free_buffer)
  {
    buffer->claimData();
    this->free_buffer = false;
  }

  return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0x10(%rax)
jbe 0x1e618
movl $0x28, %edi
callq 0x32c0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rsi
movl 0x10(%rax), %edx
movl 0xc(%rax), %ecx
callq 0x1e180
jmp 0x1e5f2
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1e663
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x28, %esi
callq 0x32d0
jmp 0x1e688
movl $0x28, %edi
callq 0x32c0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rsi
movl 0x8(%rax), %edx
callq 0x1e130
jmp 0x1e63d
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1e663
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x28, %esi
callq 0x32d0
jmp 0x1e688
movq -0x28(%rbp), %rax
testb $0x1, 0x14(%rax)
je 0x1e67e
movq -0x10(%rbp), %rdi
callq 0x1e270
movq -0x28(%rbp), %rax
movb $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitbuffer.cpp
// Function: CSA::WriteBuffer::moveBuffer(unsigned int*)
void
WriteBuffer::moveBuffer(usint* buffer)
{
  if(this->free_buffer)
  {
    delete[] this->data;
  }
  this->free_buffer = false;

  this->data = buffer;
  this->reset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x14(%rax)
je 0x1e75a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1e758
movq -0x20(%rbp), %rdi
callq 0x33e0
jmp 0x1e75a
movq -0x18(%rbp), %rdi
movb $0x0, 0x14(%rdi)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
callq 0x1e810
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitvector.cpp
// Function: CSA::BitVector::BitVector(std::basic_ifstream<char, std::char_traits<char>>&)
BitVector::BitVector(std::ifstream& file) :
  rank_index(0), select_index(0)
{
  this->readHeader(file);
  this->readArray(file);

  this->integer_bits = length(this->size);
  this->samples = new ReadBuffer(file, 2 * (this->number_of_blocks + 1), this->integer_bits);

  this->indexForRank();
  this->indexForSelect();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq $0x0, 0x28(%rdi)
movq $0x0, 0x38(%rdi)
movq -0x10(%rbp), %rsi
callq 0x1e930
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e9a0
movq -0x30(%rbp), %rax
movl (%rax), %edi
callq 0x14da0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x20(%rax)
movl $0x28, %edi
callq 0x32c0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movl 0x14(%rax), %edx
movl 0x20(%rax), %ecx
movl %edx, %eax
leal 0x2(%rax,%rax), %edx
callq 0x1dfa0
jmp 0x1e8e1
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, 0x18(%rdi)
callq 0x1ea20
movq -0x30(%rbp), %rdi
callq 0x1ebd0
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x28, %esi
callq 0x32d0
movq -0x18(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitvector.cpp
// Function: CSA::BitVector::readHeader(std::basic_ifstream<char, std::char_traits<char>>&)
void
BitVector::readHeader(std::ifstream& file)
{
  file.read((char*)&(this->size), sizeof(this->size));
  file.read((char*)&(this->items), sizeof(this->items));
  file.read((char*)&(this->number_of_blocks), sizeof(this->number_of_blocks));
  file.read((char*)&(this->block_size), sizeof(this->block_size));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %edx
callq 0x33c0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x4, %rsi
movl $0x4, %edx
callq 0x33c0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x14, %rsi
movl $0x4, %edx
callq 0x33c0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x10, %rsi
movl $0x4, %edx
callq 0x33c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/bits/bitvector.cpp
// Function: CSA::BitVector::BitVector(_IO_FILE*)
BitVector::BitVector(FILE* file) :
  rank_index(0), select_index(0)
{
  this->readHeader(file);
  this->readArray(file);

  this->integer_bits = length(this->size);
  this->samples = new ReadBuffer(file, 2 * (this->number_of_blocks + 1), this->integer_bits);

  this->indexForRank();
  this->indexForSelect();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq $0x0, 0x28(%rdi)
movq $0x0, 0x38(%rdi)
movq -0x10(%rbp), %rsi
callq 0x1ee50
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ef10
movq -0x30(%rbp), %rax
movl (%rax), %edi
callq 0x14da0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x20(%rax)
movl $0x28, %edi
callq 0x32c0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movl 0x14(%rax), %edx
movl 0x20(%rax), %ecx
movl %edx, %eax
leal 0x2(%rax,%rax), %edx
callq 0x1e060
jmp 0x1ee01
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, 0x18(%rdi)
callq 0x1ea20
movq -0x30(%rbp), %rdi
callq 0x1ebd0
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x28, %esi
callq 0x32d0
movq -0x18(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitvector.cpp
// Function: CSA::BitVector::readHeader(_IO_FILE*)
void
BitVector::readHeader(FILE* file)
{
  if(file == 0) { return; }
  if(!std::fread(&(this->size), sizeof(this->size), 1, file)) { return; }
  if(!std::fread(&(this->items), sizeof(this->items), 1, file)) { return; }
  if(!std::fread(&(this->number_of_blocks), sizeof(this->number_of_blocks), 1, file)) { return; }
  if(!std::fread(&(this->block_size), sizeof(this->block_size), 1, file)) { return; }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1ee74
jmp 0x1eefc
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x3460
cmpq $0x0, %rax
jne 0x1ee93
jmp 0x1eefc
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x3460
cmpq $0x0, %rax
jne 0x1eeb6
jmp 0x1eefc
movq -0x18(%rbp), %rdi
addq $0x14, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x3460
cmpq $0x0, %rax
jne 0x1eed9
jmp 0x1eefc
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x3460
cmpq $0x0, %rax
jne 0x1eefc
jmp 0x1eefc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitvector.cpp
// Function: CSA::BitVector::readArray(_IO_FILE*)
void
BitVector::readArray(FILE* file)
{
  if(file == 0) { return; }
  usint* array_buffer = new usint[this->block_size * this->number_of_blocks];
  if(!std::fread(array_buffer, this->block_size * sizeof(usint), this->number_of_blocks, file)) { return; }
  this->array = array_buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1ef31
jmp 0x1ef99
movq -0x20(%rbp), %rcx
movl 0x10(%rcx), %eax
imull 0x14(%rcx), %eax
movl %eax, %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl 0x10(%rax), %ecx
movl %ecx, %esi
shlq $0x2, %rsi
movl 0x14(%rax), %eax
movl %eax, %edx
movq -0x10(%rbp), %rcx
callq 0x3460
cmpq $0x0, %rax
jne 0x1ef8d
jmp 0x1ef99
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/bits/bitvector.cpp
// Function: CSA::BitVector::~BitVector()
BitVector::~BitVector()
{
  delete[] this->array;
  delete this->samples;
  delete this->rank_index;
  delete this->select_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1f3eb
movq -0x10(%rbp), %rdi
callq 0x33e0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1f414
movq -0x20(%rbp), %rdi
callq 0x1e230
movq -0x20(%rbp), %rdi
movl $0x28, %esi
callq 0x32d0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1f43d
movq -0x28(%rbp), %rdi
callq 0x1e230
movq -0x28(%rbp), %rdi
movl $0x28, %esi
callq 0x32d0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1f466
movq -0x30(%rbp), %rdi
callq 0x1e230
movq -0x30(%rbp), %rdi
movl $0x28, %esi
callq 0x32d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/bitvector.cpp
// Function: CSA::BitVector::writeHeader(std::basic_ofstream<char, std::char_traits<char>>&) const
void
BitVector::writeHeader(std::ofstream& file) const
{
  file.write((char*)&(this->size), sizeof(this->size));
  file.write((char*)&(this->items), sizeof(this->items));
  file.write((char*)&(this->number_of_blocks), sizeof(this->number_of_blocks));
  file.write((char*)&(this->block_size), sizeof(this->block_size));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %edx
callq 0x33f0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x4, %rsi
movl $0x4, %edx
callq 0x33f0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x14, %rsi
movl $0x4, %edx
callq 0x33f0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x10, %rsi
movl $0x4, %edx
callq 0x33f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/bits/bitvector.cpp
// Function: CSA::BitVector::writeHeader(_IO_FILE*) const
void
BitVector::writeHeader(FILE* file) const
{
  if(file == 0) { return; }
  std::fwrite(&(this->size), sizeof(this->size), 1, file);
  std::fwrite(&(this->items), sizeof(this->items), 1, file);
  std::fwrite(&(this->number_of_blocks), sizeof(this->number_of_blocks), 1, file);
  std::fwrite(&(this->block_size), sizeof(this->block_size), 1, file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1f5e1
jmp 0x1f649
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x3580
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x3580
movq -0x18(%rbp), %rdi
addq $0x14, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x3580
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x3580
addq $0x20, %rsp
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/bits/bitvector.cpp
// Function: CSA::BitVector::reportSize() const
usint
BitVector::reportSize() const
{
  // We assume the reportSize() of derived classes includes any class variables of BitVector.
  usint bytes = this->block_size * this->number_of_blocks * sizeof(usint);
  if(this->samples != 0) { bytes += this->samples->reportSize(); }
  if(this->rank_index != 0) { bytes += this->rank_index->reportSize(); }
  if(this->select_index != 0) { bytes += this->select_index->reportSize(); }
  return bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x10(%rax), %ecx
imull 0x14(%rax), %ecx
movl %ecx, %ecx
shlq $0x2, %rcx
movl %ecx, -0xc(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x1f6de
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1e370
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1f6fc
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1e370
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x1f71a
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x1e370
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitvector.cpp
// Function: CSA::BitVector::Iterator::sampleForIndex(unsigned int)
usint
BitVector::Iterator::sampleForIndex(usint index)
{
  usint low = this->parent.select_index->readItemConst(index / this->parent.select_rate);
  usint high = this->parent.number_of_blocks - 1;

  this->samples.goToItem(2 * low + 2);
  for(; low < high; low++)
  {
    if(this->samples.readItem() > index) { return low; }
    this->samples.skipItem();
  }

  return low;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq (%rcx), %rax
movq 0x38(%rax), %rdi
movl -0x14(%rbp), %eax
movq (%rcx), %rcx
xorl %edx, %edx
divl 0x40(%rcx)
movl %eax, %esi
callq 0xeea0
movq -0x28(%rbp), %rdi
movl %eax, -0x18(%rbp)
movq (%rdi), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
addq $0x50, %rdi
movl -0x18(%rbp), %esi
shll %esi
addl $0x2, %esi
callq 0x15070
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x1f8de
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
callq 0x14ff0
cmpl -0x14(%rbp), %eax
jbe 0x1f8c6
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f8e4
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
callq 0x1fef0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f8a4
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/bitvector.cpp
// Function: CSA::BitVector::Iterator::sampleForValue(unsigned int)
usint
BitVector::Iterator::sampleForValue(usint value)
{
  usint low = this->parent.rank_index->readItemConst(value / this->parent.rank_rate);
  usint high = this->parent.number_of_blocks - 1;

  this->samples.goToItem(2 * low + 3);
  for(; low < high; low++)
  {
    if(this->samples.readItem() > value) { return low; }
    this->samples.skipItem();
  }

  return low;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq (%rcx), %rax
movq 0x28(%rax), %rdi
movl -0x14(%rbp), %eax
movq (%rcx), %rcx
xorl %edx, %edx
divl 0x30(%rcx)
movl %eax, %esi
callq 0xeea0
movq -0x28(%rbp), %rdi
movl %eax, -0x18(%rbp)
movq (%rdi), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
addq $0x50, %rdi
movl -0x18(%rbp), %esi
shll %esi
addl $0x3, %esi
callq 0x15070
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x1f97e
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
callq 0x14ff0
cmpl -0x14(%rbp), %eax
jbe 0x1f966
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f984
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
callq 0x1fef0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f944
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/bitvector.cpp
// Function: CSA::VectorEncoder::~VectorEncoder()
VectorEncoder::~VectorEncoder()
{
  delete[] this->array;

  delete this->buffer;
  for(std::list<usint*>::iterator iter = this->array_blocks.begin(); iter != this->array_blocks.end(); iter++)
  {
    delete[] *iter;
  }

  delete[] this->samples;
  for(std::list<usint*>::iterator iter = this->sample_blocks.begin(); iter != this->sample_blocks.end(); iter++)
  {
    delete[] *iter;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1fbcb
movq -0x40(%rbp), %rdi
callq 0x33e0
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x1fbf4
movq -0x50(%rbp), %rdi
callq 0x1e570
movq -0x50(%rbp), %rdi
movl $0x28, %esi
callq 0x32d0
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0x1d4e0
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0x1d540
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1d510
testb $0x1, %al
jne 0x1fc29
jmp 0x1fc5b
leaq -0x10(%rbp), %rdi
callq 0x1d570
movq (%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x1fc48
movq -0x58(%rbp), %rdi
callq 0x33e0
jmp 0x1fc4a
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x1d590
movq %rax, -0x20(%rbp)
jmp 0x1fc05
movq -0x48(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x1fc76
movq -0x60(%rbp), %rdi
callq 0x33e0
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0x1d4e0
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0x1d540
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1d510
testb $0x1, %al
jne 0x1fcab
jmp 0x1fcdd
leaq -0x28(%rbp), %rdi
callq 0x1d570
movq (%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x1fcca
movq -0x68(%rbp), %rdi
callq 0x33e0
jmp 0x1fccc
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x1d590
movq %rax, -0x38(%rbp)
jmp 0x1fc87
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0x1d710
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0x1d710
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)