LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: adamnovak[P]rlcsa/bits/bitvector.cpp
// Function: CSA::VectorEncoder::addNewBlock()
void
VectorEncoder::addNewBlock()
{
  // Do we need a new superblock for the block?
  this->blocks++; this->current_blocks++;
  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->use_small_blocks)
  {
    this->current_samples++;
    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[2 * this->current_samples - 2] = this->items - 1;
    this->samples[2 * this->current_samples - 1] = this->size - 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0x8(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x8(%rcx)
movl 0x44(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x44(%rcx)
movl 0x44(%rcx), %eax
cmpl 0x40(%rcx), %eax
jbe 0x1fd94
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x20, %rdi
addq $0x38, %rsi
callq 0x1d7c0
movq -0x10(%rbp), %rax
movl 0x10(%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 -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq 0x38(%rax), %rdi
movl 0x10(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x3190
movq -0x10(%rbp), %rax
movl $0x1, 0x44(%rax)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq 0x38(%rcx), %rsi
movl 0xc(%rcx), %eax
movl 0x44(%rcx), %ecx
subl $0x1, %ecx
imull %ecx, %eax
movl %eax, %eax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x1e720
movq -0x10(%rbp), %rax
testb $0x1, 0x14(%rax)
je 0x1fe60
movq -0x10(%rbp), %rcx
movl 0x6c(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rcx)
movl 0x6c(%rcx), %eax
cmpl 0x68(%rcx), %eax
jbe 0x1fe2f
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x48, %rdi
addq $0x60, %rsi
callq 0x1d7c0
movq -0x10(%rbp), %rax
movl 0x10(%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 -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movl $0x1, 0x6c(%rax)
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %esi
subl $0x1, %esi
movq 0x60(%rcx), %rax
movl 0x6c(%rcx), %edx
shll %edx
subl $0x2, %edx
movl %edx, %edx
movl %esi, (%rax,%rdx,4)
movl (%rcx), %edx
subl $0x1, %edx
movq 0x60(%rcx), %rax
movl 0x6c(%rcx), %ecx
shll %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitvector.cpp
// Function: CSA::VectorEncoder::setFirstBit(unsigned int)
void
VectorEncoder::setFirstBit(usint value)
{
  this->samples[0] = 0;
  this->samples[1] = value;

  this->size = value + 1;
  this->items = 1;
  this->blocks = 1;

  this->current_blocks = 1;
  this->current_samples = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
movl $0x0, (%rcx)
movl -0xc(%rbp), %edx
movq 0x60(%rax), %rcx
movl %edx, 0x4(%rcx)
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x1, 0x4(%rax)
movl $0x1, 0x8(%rax)
movl $0x1, 0x44(%rax)
movl $0x1, 0x6c(%rax)
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/bitbuffer.h
// Function: CSA::ReadBuffer::skipBits(unsigned int)
inline void skipBits(usint count)
    {
      if(count < this->bits)
      {
        this->bits -= count;
        return;
      }

      count -= this->bits;
      this->pos += 1 + count / WORD_BITS;
      this->bits = WORD_BITS - count % WORD_BITS;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x1ff4c
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
movl 0x1c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x1c(%rax)
jmp 0x1ff7a
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %edx
movl -0xc(%rbp), %ecx
subl %edx, %ecx
movl %ecx, -0xc(%rbp)
movl -0xc(%rbp), %ecx
shrl $0x5, %ecx
addl $0x1, %ecx
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movl -0xc(%rbp), %edx
andl $0x1f, %edx
movl $0x20, %ecx
subl %edx, %ecx
movl %ecx, 0x1c(%rax)
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/deltavector.cpp
// Function: CSA::DeltaVector::Iterator::rank(unsigned int, bool)
usint
DeltaVector::Iterator::rank(usint value, bool at_least)
{
  const DeltaVector& par = (const DeltaVector&)(this->parent);

  if(value >= par.size) { return par.items; }
  this->getSample(this->sampleForValue(value));

  while(this->cur < this->block_items && this->val < value)
  {
    this->val += this->buffer.readDeltaCode();
    this->cur++;
  }

  usint idx = this->sample.first + this->cur + 1;
  if(!at_least && this->val > value) { idx--; }
  if(at_least && this->val < value)
  {
    this->getSample(this->block + 1);
    idx = this->sample.first + this->cur + 1;
  }
  return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x2012f
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x201f6
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f8f0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x20880
movq -0x30(%rbp), %rdx
movl 0x14(%rdx), %ecx
xorl %eax, %eax
cmpl 0x20(%rdx), %ecx
movb %al, -0x31(%rbp)
jae 0x20167
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
setb %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x20170
jmp 0x20194
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x1d660
movl %eax, %ecx
movq -0x30(%rbp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x20146
movq -0x30(%rbp), %rcx
movl 0xc(%rcx), %eax
addl 0x14(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x201bf
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0x201bf
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
testb $0x1, -0x15(%rbp)
je 0x201f0
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jae 0x201f0
movq -0x30(%rbp), %rdi
movl 0x8(%rdi), %esi
addl $0x1, %esi
callq 0x20880
movq -0x30(%rbp), %rcx
movl 0xc(%rcx), %eax
addl 0x14(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/bits/deltavector.cpp
// Function: CSA::DeltaVector::Iterator::select(unsigned int)
usint
DeltaVector::Iterator::select(usint index)
{
  const DeltaVector& par = (const DeltaVector&)(this->parent);

  if(index >= par.items) { return par.size; }
  this->getSample(this->sampleForIndex(index));

  usint lim = index - this->sample.first;
  for(; this->cur < lim; this->cur++)
  {
    this->val += this->buffer.readDeltaCode();
  }

  return this->val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jb 0x20235
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x20297
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f850
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x20880
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
subl 0xc(%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x24(%rbp), %eax
jae 0x2028d
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x1d660
movl %eax, %ecx
movq -0x30(%rbp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movq -0x30(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x20259
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: adamnovak[P]rlcsa/bits/deltavector.cpp
// Function: CSA::DeltaVector::Iterator::selectNext()
usint
DeltaVector::Iterator::selectNext()
{
  if(this->cur >= this->block_items)
  {
    this->getSample(this->block + 1);
    return this->val;
  }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0x14(%rcx), %eax
cmpl 0x20(%rcx), %eax
jb 0x202d7
movq -0x18(%rbp), %rdi
movl 0x8(%rdi), %esi
addl $0x1, %esi
callq 0x20880
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x202ff
movq -0x18(%rbp), %rdi
movl 0x14(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x14(%rdi)
addq $0x28, %rdi
callq 0x1d660
movl %eax, %ecx
movq -0x18(%rbp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/deltavector.cpp
// Function: CSA::DeltaVector::Iterator::valueBefore(unsigned int)
pair_type
DeltaVector::Iterator::valueBefore(usint value)
{
  const DeltaVector& par = (const DeltaVector&)(this->parent);

  if(value >= par.size) { return pair_type(par.size, par.items); }

  this->getSample(this->sampleForValue(value));
  if(this->val > value) { return pair_type(par.size, par.items); }

  while(this->cur < this->block_items && this->val < value)
  {
    usint temp = this->buffer.readDeltaCode(value - this->val);
    if(temp == 0) { break; }
    this->val += temp;
    this->cur++;
  }

  return pair_type(this->val, this->sample.first + this->cur);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x20353
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x4, %rdx
leaq -0x8(%rbp), %rdi
callq 0xea00
jmp 0x20416
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f8f0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x20880
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0x20390
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x4, %rdx
leaq -0x8(%rbp), %rdi
callq 0xea00
jmp 0x20416
jmp 0x20392
movq -0x30(%rbp), %rdx
movl 0x14(%rdx), %ecx
xorl %eax, %eax
cmpl 0x20(%rdx), %ecx
movb %al, -0x31(%rbp)
jae 0x203b3
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
setb %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x203bc
jmp 0x203f5
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movl -0x14(%rbp), %esi
subl 0x18(%rax), %esi
callq 0x20920
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x203dd
jmp 0x203f5
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x20392
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x18, %rsi
movl 0xc(%rcx), %eax
addl 0x14(%rcx), %eax
movl %eax, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0xea30
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: adamnovak[P]rlcsa/bits/deltavector.cpp
// Function: CSA::DeltaVector::Iterator::valueAfter(unsigned int)
pair_type
DeltaVector::Iterator::valueAfter(usint value)
{
  const DeltaVector& par = (const DeltaVector&)(this->parent);

  if(value >= par.size) { return pair_type(par.size, par.items); }
  this->getSample(this->sampleForValue(value));

  while(this->cur < this->block_items && this->val < value)
  {
    this->val += this->buffer.readDeltaCode();
    this->cur++;
  }
  if(this->val < value)
  {
    this->getSample(this->block + 1);
  }

  return pair_type(this->val, this->sample.first + this->cur);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x20463
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x4, %rdx
leaq -0x8(%rbp), %rdi
callq 0xea00
jmp 0x20504
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f8f0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x20880
movq -0x30(%rbp), %rdx
movl 0x14(%rdx), %ecx
xorl %eax, %eax
cmpl 0x20(%rdx), %ecx
movb %al, -0x31(%rbp)
jae 0x2049b
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
setb %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x204a4
jmp 0x204c8
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x1d660
movl %eax, %ecx
movq -0x30(%rbp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x2047a
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jae 0x204e3
movq -0x30(%rbp), %rdi
movl 0x8(%rdi), %esi
addl $0x1, %esi
callq 0x20880
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x18, %rsi
movl 0xc(%rcx), %eax
addl 0x14(%rcx), %eax
movl %eax, -0x24(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rdx
callq 0xea30
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/bits/deltavector.cpp
// Function: CSA::DeltaVector::Iterator::nextValue()
pair_type
DeltaVector::Iterator::nextValue()
{
  if(this->cur >= this->block_items)
  {
    this->getSample(this->block + 1);
    return pair_type(this->val, this->sample.first);
  }

  this->cur++;
  this->val += this->buffer.readDeltaCode();
  return pair_type(this->val, this->sample.first + this->cur);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x14(%rcx), %eax
cmpl 0x20(%rcx), %eax
jb 0x20555
movq -0x20(%rbp), %rdi
movl 0x8(%rdi), %esi
addl $0x1, %esi
callq 0x20880
movq -0x20(%rbp), %rdx
movq %rdx, %rsi
addq $0x18, %rsi
addq $0xc, %rdx
leaq -0x8(%rbp), %rdi
callq 0xdec0
jmp 0x20592
movq -0x20(%rbp), %rdi
movl 0x14(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x14(%rdi)
addq $0x28, %rdi
callq 0x1d660
movq -0x20(%rbp), %rcx
addl 0x18(%rcx), %eax
movl %eax, 0x18(%rcx)
movq %rcx, %rsi
addq $0x18, %rsi
movl 0xc(%rcx), %eax
addl 0x14(%rcx), %eax
movl %eax, -0x14(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rdx
callq 0xea30
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/deltavector.cpp
// Function: CSA::DeltaVector::Iterator::isSet(unsigned int)
bool
DeltaVector::Iterator::isSet(usint value)
{
  const DeltaVector& par = (const DeltaVector&)(this->parent);

  if(value >= par.size) { return false; }
  this->getSample(this->sampleForValue(value));

  while(this->cur < this->block_items && this->val < value)
  {
    this->val += this->buffer.readDeltaCode();
    this->cur++;
  }

  return (this->val == value);
}

// 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)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x2065f
movb $0x0, -0x1(%rbp)
jmp 0x206d6
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f8f0
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x20880
movq -0x28(%rbp), %rdx
movl 0x14(%rdx), %ecx
xorl %eax, %eax
cmpl 0x20(%rdx), %ecx
movb %al, -0x29(%rbp)
jae 0x20697
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x206a0
jmp 0x206c4
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x1d660
movl %eax, %ecx
movq -0x28(%rbp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x20676
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/deltavector.cpp
// Function: CSA::DeltaEncoder::setBit(unsigned int)
void
DeltaEncoder::setBit(usint value)
{
  if(this->items == 0)
  {
    this->setFirstBit(value);
    return;
  }
  if(value < this->size) { return; }

  usint diff = value + 1 - this->size;
  this->size = value + 1;
  this->items++;
  if(this->buffer->writeDeltaCode(diff)) { return; }

  // Didn't fit into the block. A new sample & block required.
  this->addNewBlock();
}

// 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)
cmpl $0x0, 0x4(%rax)
jne 0x2076b
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1fe70
jmp 0x207b5
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jae 0x20778
jmp 0x207b5
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
subl (%rax), %ecx
movl %ecx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x18(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0x1d730
testb $0x1, %al
jne 0x207aa
jmp 0x207ac
jmp 0x207b5
movq -0x18(%rbp), %rdi
callq 0x1fd00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/bitvector.h
// Function: CSA::BitVector::Iterator::getSample(unsigned int)
inline void getSample(usint sample_number)
        {
          this->block = sample_number;
          this->samples.goToItem(2 * sample_number);
          this->sample.first = this->samples.readItem();
          this->sample.second = this->samples.readItem();
          this->cur = 0;
          this->val = this->sample.second;
          this->block_items = this->samples.readItem() - this->sample.first - 1;
          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 $0x50, %rdi
movl -0xc(%rbp), %esi
shll %esi
callq 0x15070
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x14ff0
movq -0x18(%rbp), %rdi
movl %eax, 0xc(%rdi)
addq $0x50, %rdi
callq 0x14ff0
movq -0x18(%rbp), %rdi
movl %eax, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
movl 0x10(%rdi), %eax
movl %eax, 0x18(%rdi)
addq $0x50, %rdi
callq 0x14ff0
movq -0x18(%rbp), %rcx
subl 0xc(%rcx), %eax
subl $0x1, %eax
movl %eax, 0x20(%rcx)
movq %rcx, %rdi
addq $0x28, %rdi
movq (%rcx), %rax
movq 0x8(%rax), %rsi
movl 0x8(%rcx), %eax
movq (%rcx), %rcx
imull 0x10(%rcx), %eax
movl %eax, %eax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x1e310
addq $0x20, %rsp
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/bits/bitbuffer.h
// Function: CSA::ReadBuffer::readDeltaCode(unsigned int)
inline usint readDeltaCode(usint limit)
    {
       usint _pos = this->pos, _bits = this->bits;
       usint value = this->readDeltaCode();
       if(value > limit)
       {
         this->pos = _pos; this->bits = _bits;
         return 0;
       }
       return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl 0x18(%rdi), %eax
movl %eax, -0x18(%rbp)
movl 0x1c(%rdi), %eax
movl %eax, -0x1c(%rbp)
callq 0x1d660
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x2096c
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x1c(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x20972
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/rlevector.cpp
// Function: CSA::RLEVector::Iterator::rank(unsigned int, bool)
usint
RLEVector::Iterator::rank(usint value, bool at_least)
{
  const RLEVector& par = (const RLEVector&)(this->parent);

  if(value >= par.size) { return par.items; }

  this->valueLoop(value);

  usint idx = this->sample.first + this->cur + 1;
  if(!at_least && this->val > value)
  {
    idx--;
  }
  if(at_least && this->val < value)
  {
    this->getSample(this->block + 1);
    this->run = 0;
    idx = this->sample.first + this->cur + 1;
  }
  return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x20b1c
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x20b91
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x20ba0
movq -0x30(%rbp), %rcx
movl 0xc(%rcx), %eax
addl 0x14(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x20b53
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0x20b53
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
testb $0x1, -0x15(%rbp)
je 0x20b8b
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jae 0x20b8b
movq -0x30(%rbp), %rdi
movl 0x8(%rdi), %esi
addl $0x1, %esi
callq 0x20880
movq -0x30(%rbp), %rcx
movl $0x0, 0x1c(%rcx)
movl 0xc(%rcx), %eax
addl 0x14(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/rlevector.cpp
// Function: CSA::RLEVector::Iterator::valueLoop(unsigned int)
void
RLEVector::Iterator::valueLoop(usint value)
{
  this->getSample(this->sampleForValue(value));
  this->run = 0;

  if(this->val >= value) { return; }
  while(this->cur < this->block_items)
  {
    this->val += this->buffer.readDeltaCode();
    this->cur++;
    this->run = this->buffer.readDeltaCode() - 1;
    if(this->val >= value) { break; }

    this->cur += this->run;
    this->val += this->run;
    if(this->val >= value)
    {
      this->run = this->val - value;
      this->val = value;
      this->cur -= this->run;
      break;
    }
    this->run = 0;
  }
}

// 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), %esi
callq 0x1f8f0
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x20880
movq -0x18(%rbp), %rax
movl $0x0, 0x1c(%rax)
movl 0x18(%rax), %eax
cmpl -0xc(%rbp), %eax
jb 0x20be2
jmp 0x20c81
jmp 0x20be4
movq -0x18(%rbp), %rcx
movl 0x14(%rcx), %eax
cmpl 0x20(%rcx), %eax
jae 0x20c81
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x1d660
movq -0x18(%rbp), %rdi
addl 0x18(%rdi), %eax
movl %eax, 0x18(%rdi)
movl 0x14(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x14(%rdi)
addq $0x28, %rdi
callq 0x1d660
movl %eax, %ecx
movq -0x18(%rbp), %rax
subl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movl 0x18(%rax), %eax
cmpl -0xc(%rbp), %eax
jb 0x20c33
jmp 0x20c81
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %ecx
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movl 0x1c(%rax), %ecx
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movl 0x18(%rax), %eax
cmpl -0xc(%rbp), %eax
jb 0x20c71
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
subl -0xc(%rbp), %ecx
movl %ecx, 0x1c(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl 0x1c(%rax), %edx
movl 0x14(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x14(%rax)
jmp 0x20c81
movq -0x18(%rbp), %rax
movl $0x0, 0x1c(%rax)
jmp 0x20be4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/rlevector.cpp
// Function: CSA::RLEVector::Iterator::select(unsigned int)
usint
RLEVector::Iterator::select(usint index)
{
  const RLEVector& par = (const RLEVector&)(this->parent);

  if(index >= par.items) { return par.size; }
  this->getSample(this->sampleForIndex(index));
  this->run = 0;

  usint lim = index - this->sample.first;
  while(this->cur < lim)
  {
    this->val += this->buffer.readDeltaCode();
    usint temp = this->buffer.readDeltaCode();
    this->val += temp - 1;
    this->cur += temp;
  }
  if(this->cur > lim)
  {
    this->run = this->cur - lim;
    this->cur -= this->run;
    this->val -= this->run;
  }

  return this->val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jb 0x20cc8
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x20d78
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f850
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x20880
movq -0x30(%rbp), %rcx
movl $0x0, 0x1c(%rcx)
movl -0x14(%rbp), %eax
subl 0xc(%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x24(%rbp), %eax
jae 0x20d3f
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x1d660
movq -0x30(%rbp), %rdi
addl 0x18(%rdi), %eax
movl %eax, 0x18(%rdi)
addq $0x28, %rdi
callq 0x1d660
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x28(%rbp)
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movl -0x28(%rbp), %ecx
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
jmp 0x20cf3
movq -0x30(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x24(%rbp), %eax
jbe 0x20d6e
movq -0x30(%rbp), %rax
movl 0x14(%rax), %ecx
subl -0x24(%rbp), %ecx
movl %ecx, 0x1c(%rax)
movl 0x1c(%rax), %edx
movl 0x14(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x14(%rax)
movl 0x1c(%rax), %edx
movl 0x18(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x18(%rax)
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/rlevector.cpp
// Function: CSA::RLEVector::Iterator::selectNext()
usint
RLEVector::Iterator::selectNext()
{
  if(this->cur >= this->block_items)
  {
    this->getSample(this->block + 1);
    this->run = 0;
    return this->val;
  }

  this->cur++;
  if(this->run > 0)
  {
    this->val++;
    this->run--;
  }
  else
  {
    this->val += this->buffer.readDeltaCode();
    this->run = this->buffer.readDeltaCode() - 1;
  }

  return this->val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0x14(%rcx), %eax
cmpl 0x20(%rcx), %eax
jb 0x20dce
movq -0x18(%rbp), %rdi
movl 0x8(%rdi), %esi
addl $0x1, %esi
callq 0x20880
movq -0x18(%rbp), %rax
movl $0x0, 0x1c(%rax)
movl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x20e2f
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
cmpl $0x0, 0x1c(%rax)
jbe 0x20df9
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movl 0x1c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rax)
jmp 0x20e25
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x1d660
movq -0x18(%rbp), %rdi
addl 0x18(%rdi), %eax
movl %eax, 0x18(%rdi)
addq $0x28, %rdi
callq 0x1d660
movl %eax, %ecx
movq -0x18(%rbp), %rax
subl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/rlevector.cpp
// Function: CSA::RLEVector::Iterator::valueBefore(unsigned int)
pair_type
RLEVector::Iterator::valueBefore(usint value)
{
  const RLEVector& par = (const RLEVector&)(this->parent);

  if(value >= par.size) { return pair_type(par.size, par.items); }

  this->getSample(this->sampleForValue(value));
  if(this->val > value) { return pair_type(par.size, par.items); }
  this->run = 0;

  while(this->cur < this->block_items && this->val < value)
  {
    usint temp = this->buffer.readDeltaCode(value - this->val);
    if(temp == 0) { break; }
    this->val += temp;

    temp = this->buffer.readDeltaCode();
    this->cur += temp;
    this->val += temp - 1;
  }
  if(this->val > value)
  {
    this->run = this->val - value;
    this->val = value;
    this->cur -= this->run;
  }

  return pair_type(this->val, this->sample.first + this->cur);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x20e83
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x4, %rdx
leaq -0x8(%rbp), %rdi
callq 0xea00
jmp 0x20f9a
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f8f0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x20880
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0x20ec0
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x4, %rdx
leaq -0x8(%rbp), %rdi
callq 0xea00
jmp 0x20f9a
movq -0x30(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x30(%rbp), %rdx
movl 0x14(%rdx), %ecx
xorl %eax, %eax
cmpl 0x20(%rdx), %ecx
movb %al, -0x31(%rbp)
jae 0x20eec
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
setb %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x20ef5
jmp 0x20f4f
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movl -0x14(%rbp), %esi
subl 0x18(%rax), %esi
callq 0x20920
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x20f16
jmp 0x20f4f
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
addl 0x18(%rdi), %eax
movl %eax, 0x18(%rdi)
addq $0x28, %rdi
callq 0x1d660
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x24(%rbp)
movl -0x24(%rbp), %ecx
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
jmp 0x20ecb
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0x20f79
movq -0x30(%rbp), %rax
movl 0x18(%rax), %ecx
subl -0x14(%rbp), %ecx
movl %ecx, 0x1c(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl 0x1c(%rax), %edx
movl 0x14(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x14(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x18, %rsi
movl 0xc(%rcx), %eax
addl 0x14(%rcx), %eax
movl %eax, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0xea30
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/rlevector.cpp
// Function: CSA::RLEVector::Iterator::valueAfter(unsigned int)
pair_type
RLEVector::Iterator::valueAfter(usint value)
{
  const RLEVector& par = (const RLEVector&)(this->parent);

  if(value >= par.size) { return pair_type(par.size, par.items); }

  this->valueLoop(value);

  if(this->val < value)
  {
    this->getSample(this->block + 1);
    this->run = 0;
  }

  return pair_type(this->val, this->sample.first + this->cur);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x20ff0
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x4, %rdx
leaq -0x8(%rbp), %rdi
callq 0xea00
jmp 0x21043
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x20ba0
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jae 0x21022
movq -0x30(%rbp), %rdi
movl 0x8(%rdi), %esi
addl $0x1, %esi
callq 0x20880
movq -0x30(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x18, %rsi
movl 0xc(%rcx), %eax
addl 0x14(%rcx), %eax
movl %eax, -0x24(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rdx
callq 0xea30
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/rlevector.cpp
// Function: CSA::RLEVector::Iterator::nextValue()
pair_type
RLEVector::Iterator::nextValue()
{
  if(this->cur >= this->block_items)
  {
    this->getSample(this->block + 1);
    this->run = 0;
    return pair_type(this->val, this->sample.first);
  }

  this->cur++;
  if(this->run > 0)
  {
    this->val++;
    this->run--;
  }
  else
  {
    this->val += this->buffer.readDeltaCode();
    this->run = this->buffer.readDeltaCode() - 1;
  }

  return pair_type(this->val, this->sample.first + this->cur);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x14(%rcx), %eax
cmpl 0x20(%rcx), %eax
jb 0x2109c
movq -0x20(%rbp), %rdi
movl 0x8(%rdi), %esi
addl $0x1, %esi
callq 0x20880
movq -0x20(%rbp), %rdx
movl $0x0, 0x1c(%rdx)
movq %rdx, %rsi
addq $0x18, %rsi
addq $0xc, %rdx
leaq -0x8(%rbp), %rdi
callq 0xdec0
jmp 0x21114
movq -0x20(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
cmpl $0x0, 0x1c(%rax)
jbe 0x210c7
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movl 0x1c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rax)
jmp 0x210f3
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x1d660
movq -0x20(%rbp), %rdi
addl 0x18(%rdi), %eax
movl %eax, 0x18(%rdi)
addq $0x28, %rdi
callq 0x1d660
movl %eax, %ecx
movq -0x20(%rbp), %rax
subl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x18, %rsi
movl 0xc(%rcx), %eax
addl 0x14(%rcx), %eax
movl %eax, -0x14(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rdx
callq 0xea30
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/bits/rlevector.cpp
// Function: CSA::RLEVector::Iterator::selectRun(unsigned int, unsigned int)
pair_type
RLEVector::Iterator::selectRun(usint index, usint max_length)
{
  usint value = this->select(index);

  usint len = std::min(max_length, this->run);
  this->run -= len; this->cur += len; this->val += len;

  return pair_type(value, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
callq 0x20c90
movq -0x28(%rbp), %rsi
movl %eax, -0x1c(%rbp)
addq $0x1c, %rsi
leaq -0x18(%rbp), %rdi
callq 0x63a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x20(%rbp)
movl -0x20(%rbp), %edx
movl 0x1c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x1c(%rax)
movl -0x20(%rbp), %ecx
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movl -0x20(%rbp), %ecx
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
leaq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0xdec0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/rlevector.cpp
// Function: CSA::RLEVector::Iterator::selectNextRun(unsigned int)
pair_type
RLEVector::Iterator::selectNextRun(usint max_length)
{
  usint value = this->selectNext();

  usint len = std::min(max_length, this->run);
  this->run -= len; this->cur += len; this->val += len;

  return pair_type(value, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x20d90
movq -0x28(%rbp), %rsi
movl %eax, -0x18(%rbp)
addq $0x1c, %rsi
leaq -0x14(%rbp), %rdi
callq 0x63a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movl 0x1c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x1c(%rax)
movl -0x1c(%rbp), %ecx
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movl -0x1c(%rbp), %ecx
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0xdec0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/rlevector.cpp
// Function: CSA::RLEVector::Iterator::isSet(unsigned int)
bool
RLEVector::Iterator::isSet(usint value)
{
  const RLEVector& par = (const RLEVector&)(this->parent);

  if(value >= par.size) { return false; }

  this->valueLoop(value);

  return (this->val == value);
}

// 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)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x2124f
movb $0x0, -0x1(%rbp)
jmp 0x2126d
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x20ba0
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/rlevector.cpp
// Function: CSA::RLEVector::Iterator::countRuns()
usint
RLEVector::Iterator::countRuns()
{
  const RLEVector& par = (const RLEVector&)(this->parent);

  if(par.items == 0) { return 0; }

  usint runs = 1;
  pair_type res = this->selectRun(0, par.items);
  usint last = res.first + res.second;

  while(last < par.size)
  {
    res = this->selectNextRun(par.items);
    if(res.first < par.size && res.first > last + 1) { runs++; }
    last = res.first + res.second;
  }

  return runs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x212b1
movl $0x0, -0x4(%rbp)
jmp 0x21335
movq -0x38(%rbp), %rdi
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
xorl %esi, %esi
callq 0x21120
movq %rax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x2132f
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x211a0
movq %rax, -0x30(%rbp)
leaq -0x24(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdb70
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x21324
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jbe 0x21324
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x24(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x212d7
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/bits/rlevector.cpp
// Function: CSA::RLEEncoder::addRun(unsigned int, unsigned int)
void
RLEEncoder::addRun(usint start, usint len)
{
  if(this->run.second == 0)
  {
    this->run = pair_type(start, len);
  }
  else if(start == this->run.first + this->run.second)
  {
    this->run.second += len;
  }
  else
  {
    this->setRun(this->run.first, this->run.second);
    this->run = pair_type(start, len);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0x74(%rax)
jne 0x215d4
leaq -0x18(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xdec0
movq -0x28(%rbp), %rdi
addq $0x70, %rdi
leaq -0x18(%rbp), %rsi
callq 0xdb70
jmp 0x21627
movq -0x28(%rbp), %rdx
movl -0xc(%rbp), %eax
movl 0x70(%rdx), %ecx
addl 0x74(%rdx), %ecx
cmpl %ecx, %eax
jne 0x215f4
movq -0x28(%rbp), %rax
movl -0x10(%rbp), %ecx
addl 0x74(%rax), %ecx
movl %ecx, 0x74(%rax)
jmp 0x21625
movq -0x28(%rbp), %rdi
movl 0x70(%rdi), %esi
movl 0x74(%rdi), %edx
callq 0x213d0
leaq -0x20(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xdec0
movq -0x28(%rbp), %rdi
addq $0x70, %rdi
leaq -0x20(%rbp), %rsi
callq 0xdb70
jmp 0x21627
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/rlevector.h
// Function: CSA::RLEEncoder::RLEncode(unsigned int, unsigned int)
inline void RLEncode(usint diff, usint len)
    {
      this->size += diff + len - 1;
      this->items += len;
      this->buffer->writeDeltaCode(diff);
      this->buffer->writeDeltaCode(len);
    }

// 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 -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
subl $0x1, %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x1d730
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0x1d730
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: adamnovak[P]rlcsa/misc/parameters.cpp
// Function: CSA::Parameters::read(std::basic_ifstream<char, std::char_traits<char>>&)
void
Parameters::read(std::ifstream& file)
{
  while(file)
  {
    std::string key;
    std::string c;
    usint value;

    file >> key >> c >> value;
    if(c == "=") { this->parameters[key] = value; }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x33b0
testb $0x1, %al
jne 0x21894
jmp 0x21970
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3420
leaq -0x50(%rbp), %rdi
callq 0x3420
movq -0x80(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x33d0
movq %rax, -0x78(%rbp)
jmp 0x218bd
movq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x33d0
movq %rax, -0x88(%rbp)
jmp 0x218d3
movq -0x88(%rbp), %rdi
leaq -0x54(%rbp), %rsi
callq 0x3060
jmp 0x218e5
leaq 0x80d2(%rip), %rsi      # 0x299be
leaq -0x50(%rbp), %rdi
callq 0x22290
movb %al, -0x89(%rbp)
jmp 0x218fd
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x21909
jmp 0x21959
movq -0x70(%rbp), %rdi
movl -0x54(%rbp), %eax
movl %eax, -0x9c(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x221b0
movq %rax, -0x98(%rbp)
jmp 0x21928
movq -0x98(%rbp), %rax
movl -0x9c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x21959
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x35d8
leaq -0x30(%rbp), %rdi
callq 0x35d8
jmp 0x21979
leaq -0x50(%rbp), %rdi
callq 0x35d8
leaq -0x30(%rbp), %rdi
callq 0x35d8
jmp 0x2187b
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/misc/parameters.cpp
// Function: CSA::Parameters::read(_IO_FILE*)
void
Parameters::read(FILE* file)
{
  if(file == 0) { return; }

  while(!std::feof(file))
  {
    char buffer[1000];
    if(!std::fgets(buffer, 1000, file)) { break; }
    std::stringstream stream;
    stream << buffer;

    std::string key;
    std::string c;
    usint value;
    stream >> key >> c >> value;
    if(c == "=") { this->parameters[key] = value; }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x620, %rsp            # imm = 0x620
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x5e8(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x219ba
jmp 0x21b5a
jmp 0x219bc
movq -0x10(%rbp), %rdi
callq 0x34a0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x219d6
jmp 0x21b5a
leaq -0x400(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x34c0
cmpq $0x0, %rax
jne 0x219f6
jmp 0x21b5a
leaq -0x588(%rbp), %rdi
callq 0x31f0
leaq -0x578(%rbp), %rdi
leaq -0x400(%rbp), %rsi
callq 0x32a0
jmp 0x21a17
leaq -0x5b8(%rbp), %rdi
movq %rdi, -0x5f8(%rbp)
callq 0x3420
leaq -0x5d8(%rbp), %rdi
callq 0x3420
movq -0x5f8(%rbp), %rsi
leaq -0x588(%rbp), %rdi
callq 0x33d0
movq %rax, -0x5f0(%rbp)
jmp 0x21a52
movq -0x5f0(%rbp), %rdi
leaq -0x5d8(%rbp), %rsi
callq 0x33d0
movq %rax, -0x600(%rbp)
jmp 0x21a6e
movq -0x600(%rbp), %rdi
leaq -0x5dc(%rbp), %rsi
callq 0x3060
jmp 0x21a83
leaq 0x7f34(%rip), %rsi      # 0x299be
leaq -0x5d8(%rbp), %rdi
callq 0x22290
movb %al, -0x601(%rbp)
jmp 0x21a9e
movb -0x601(%rbp), %al
testb $0x1, %al
jne 0x21aaa
jmp 0x21b23
movq -0x5e8(%rbp), %rdi
movl -0x5dc(%rbp), %eax
movl %eax, -0x614(%rbp)
leaq -0x5b8(%rbp), %rsi
callq 0x221b0
movq %rax, -0x610(%rbp)
jmp 0x21ad2
movq -0x610(%rbp), %rax
movl -0x614(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x21b23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x590(%rbp)
movl %eax, -0x594(%rbp)
jmp 0x21b4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x590(%rbp)
movl %eax, -0x594(%rbp)
leaq -0x5d8(%rbp), %rdi
callq 0x35d8
leaq -0x5b8(%rbp), %rdi
callq 0x35d8
jmp 0x21b4c
leaq -0x5d8(%rbp), %rdi
callq 0x35d8
leaq -0x5b8(%rbp), %rdi
callq 0x35d8
leaq -0x588(%rbp), %rdi
callq 0x3210
jmp 0x219bc
leaq -0x588(%rbp), %rdi
callq 0x3210
jmp 0x21b63
addq $0x620, %rsp            # imm = 0x620
popq %rbp
retq
movq -0x590(%rbp), %rdi
callq 0x3530
nop
// File: adamnovak[P]rlcsa/misc/parameters.cpp
// Function: CSA::Parameters::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Parameters::read(const std::string& file_name)
{
  std::ifstream file(file_name.c_str(), std::ios_base::binary);
  if(!file)
  {
    std::cerr << "Cannot open parameter file " << file_name << " for reading!" << std::endl;
    return;
  }
  this->read(file);
  file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x238(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3130
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x4, %edx
callq 0x3560
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x3160
movb %al, -0x229(%rbp)
jmp 0x21bcb
movb -0x229(%rbp), %al
testb $0x1, %al
jne 0x21bda
jmp 0x21c6c
movq 0x1640f(%rip), %rdi     # 0x37ff0
leaq 0x7d80(%rip), %rsi      # 0x29968
callq 0x32a0
movq %rax, -0x240(%rbp)
jmp 0x21bf6
movq -0x240(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3280
movq %rax, -0x248(%rbp)
jmp 0x21c0f
movq -0x248(%rbp), %rdi
leaq 0x7d67(%rip), %rsi      # 0x29984
callq 0x32a0
movq %rax, -0x250(%rbp)
jmp 0x21c2b
movq -0x250(%rbp), %rdi
movq 0x16377(%rip), %rsi     # 0x37fb0
callq 0x3300
jmp 0x21c40
movl $0x1, -0x228(%rbp)
jmp 0x21c99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x30e0
jmp 0x21cae
movq -0x238(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x21860
jmp 0x21c81
leaq -0x218(%rbp), %rdi
callq 0x30c0
jmp 0x21c8f
movl $0x0, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x30e0
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x3530
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/misc/parameters.cpp
// Function: CSA::Parameters::write(_IO_FILE*) const
void
Parameters::write(FILE* file) const
{
  if(file == 0) { return; }

  for(std::map<std::string, usint>::const_iterator iter = this->parameters.begin(); iter != this->parameters.end(); iter++)
  {
    std::stringstream buffer;
    buffer << iter->first << " = " << iter->second << std::endl;
    std::string line = buffer.str();
    std::fwrite(line.c_str(), line.length(), 1, file);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1e8(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x21dda
jmp 0x21f61
movq -0x1e8(%rbp), %rdi
callq 0x222c0
movq %rax, -0x18(%rbp)
movq -0x1e8(%rbp), %rdi
callq 0x22130
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x220d0
testb $0x1, %al
jne 0x21e10
jmp 0x21f61
leaq -0x1a8(%rbp), %rdi
callq 0x31f0
leaq -0x198(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x22190
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
callq 0x3280
movq %rax, -0x1f0(%rbp)
jmp 0x21e4b
movq -0x1f0(%rbp), %rdi
leaq 0x7b39(%rip), %rsi      # 0x29992
callq 0x32a0
movq %rax, -0x200(%rbp)
jmp 0x21e67
leaq -0x18(%rbp), %rdi
callq 0x22190
movq -0x200(%rbp), %rdi
movl 0x20(%rax), %esi
callq 0x3400
movq %rax, -0x208(%rbp)
jmp 0x21e88
movq -0x208(%rbp), %rdi
movq 0x1611a(%rip), %rsi     # 0x37fb0
callq 0x3300
jmp 0x21e9d
leaq -0x1d8(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x3290
jmp 0x21eb2
leaq -0x1d8(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0x3130
movq -0x218(%rbp), %rdi
movq %rax, -0x210(%rbp)
callq 0x3470
movq -0x210(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rcx
movl $0x1, %edx
callq 0x3580
jmp 0x21ef2
leaq -0x1d8(%rbp), %rdi
callq 0x35d8
leaq -0x1a8(%rbp), %rdi
callq 0x3210
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x222f0
movq %rax, -0x1e0(%rbp)
jmp 0x21dea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x21f53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x35d8
leaq -0x1a8(%rbp), %rdi
callq 0x3210
jmp 0x21f6a
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)