LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::operator<<(std::ostream&, CSA::STNode const&)
std::ostream&
operator<<(std::ostream& stream, const STNode& data)
{
  stream << "(depth = " << data.string_depth << ", range = " << data.range << ", parent = " << data.parent;

  stream << ", siblings = (";
  for(STNode* curr = data.sibling; curr != 0; curr = curr->sibling)
  {
    if(curr != data.sibling) { stream << ", "; }
    stream << curr;
  }
  stream << ")";

  stream << ", children = (";
  for(STNode* curr = data.child; curr != 0; curr = curr->sibling)
  {
    if(curr != data.child) { stream << ", "; }
    stream << curr;
  }
  stream << ")";

  stream << ")";
  return stream;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x153ef(%rip), %rsi     # 0x3493a
callq 0x32c0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x3420
movq %rax, %rdi
leaq 0x153dc(%rip), %rsi     # 0x34944
callq 0x32c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x23750
movq %rax, %rdi
leaq 0x153c8(%rip), %rsi     # 0x3494f
callq 0x32c0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3230
movq -0x8(%rbp), %rdi
leaq 0x153b4(%rip), %rsi     # 0x3495b
callq 0x32c0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1f5f8
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x1f5dd
movq -0x8(%rbp), %rdi
leaq 0x1544d(%rip), %rsi     # 0x34a25
callq 0x32c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3230
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1f5b8
movq -0x8(%rbp), %rdi
leaq 0x14d3d(%rip), %rsi     # 0x34340
callq 0x32c0
movq -0x8(%rbp), %rdi
leaq 0x15357(%rip), %rsi     # 0x3496a
callq 0x32c0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1f664
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x1f649
movq -0x8(%rbp), %rdi
leaq 0x153e1(%rip), %rsi     # 0x34a25
callq 0x32c0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3230
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1f624
movq -0x8(%rbp), %rdi
leaq 0x14cd1(%rip), %rsi     # 0x34340
callq 0x32c0
movq -0x8(%rbp), %rdi
leaq 0x14cc1(%rip), %rsi     # 0x34340
callq 0x32c0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::STNode::remove()
void
STNode::remove()
{
  if(this->child == 0 || this->parent == 0) { return; }  // Cannot remove root or leaves.

  STNode* curr;
  for(curr = this->child; curr != 0; curr = curr->sibling) { curr->parent = this->parent; }
  if(this == this->parent->child) { this->parent->child = this->child; }
  else
  {
    for(curr = this->parent->child; curr->sibling != this; curr = curr->sibling);
    curr->sibling = this->child;
  }
  for(curr = this->child; curr->sibling != 0; curr = curr->sibling);
  curr->sibling = this->sibling;

  this->parent = this->child = this->sibling = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x1f6b2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1f6b7
jmp 0x1f795
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1f6e8
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1f6c3
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
cmpq 0x18(%rcx), %rax
jne 0x1f708
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x1f746
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, 0x20(%rax)
je 0x1f736
jmp 0x1f728
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1f718
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1f76d
jmp 0x1f75f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1f752
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x20(%rcx)
movq $0x0, 0x20(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::STNode::determineSize(unsigned int&, unsigned int&)
void
STNode::determineSize(uint& nodes, uint& leaves)
{
  nodes++;
  if(this->child == 0) { leaves++; }
  else { this->child->determineSize(nodes, leaves); }
  if(this->sibling != 0) { this->sibling->determineSize(nodes, leaves); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %edx
addl $0x1, %edx
movl %edx, (%rcx)
cmpq $0x0, 0x18(%rax)
jne 0x1f7db
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1f7f0
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1f7a0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1f810
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1f7a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::STNode::computeStoredDocuments(unsigned int*)
void
STNode::computeStoredDocuments(usint* documents)
{
  this->stored_documents = 0;
  delete this->docs; this->docs = 0;
  if(this->child == 0)
  {
    this->docs = new std::vector<uint>(documents + this->range.first, documents + this->range.second + 1);
  }
  else
  {
    this->docs = new std::vector<uint>;
    for(STNode* curr = this->child; curr != 0; curr = curr->sibling)
    {
      this->docs->insert(this->docs->end(), curr->docs->begin(), curr->docs->end());
      this->stored_documents += curr->stored_documents;
    }
  }
  removeDuplicates(this->docs, (this->docs->size() >= 65536));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x0, 0x30(%rax)
movq 0x40(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x1f867
movq -0x60(%rbp), %rdi
callq 0x1c250
movq -0x60(%rbp), %rdi
movl $0x18, %esi
callq 0x32f0
movq -0x68(%rbp), %rax
movq $0x0, 0x40(%rax)
cmpq $0x0, 0x18(%rax)
jne 0x1f934
movl $0x18, %edi
callq 0x32e0
movq -0x68(%rbp), %rcx
movq %rax, -0x88(%rbp)
movq %rax, -0x90(%rbp)
movb $0x1, -0x25(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rcx), %edx
movl 0x8(%rcx), %ecx
leaq (%rax,%rdx,4), %rdx
movq %rdx, -0x80(%rbp)
leaq 0x4(%rax,%rcx,4), %rax
movq %rax, -0x78(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x11d30
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x70(%rbp), %rcx
callq 0x233f0
jmp 0x1f8e0
movq -0x68(%rbp), %rax
movq -0x90(%rbp), %rcx
movb $0x0, -0x25(%rbp)
movq %rcx, 0x40(%rax)
leaq -0x11(%rbp), %rdi
callq 0x1cb80
jmp 0x1f9fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x1cb80
testb $0x1, -0x25(%rbp)
jne 0x1f91e
jmp 0x1f92f
movq -0x90(%rbp), %rdi
movl $0x18, %esi
callq 0x32f0
jmp 0x1fa39
movl $0x18, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, -0x98(%rbp)
callq 0x10bc0
movq -0x98(%rbp), %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x40(%rax)
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1f9fb
movq -0x68(%rbp), %rax
movq 0x40(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movq 0x40(%rax), %rdi
callq 0x78e0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x23520
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x7870
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x78e0
movq -0xa0(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x23470
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq -0x30(%rbp), %rcx
movl 0x30(%rcx), %ecx
addl 0x30(%rax), %ecx
movl %ecx, 0x30(%rax)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x1f964
jmp 0x1f9fd
movq -0x68(%rbp), %rax
movq 0x40(%rax), %rcx
movq %rcx, -0xa8(%rbp)
movq 0x40(%rax), %rdi
callq 0x7810
movq -0xa8(%rbp), %rdi
cmpq $0x10000, %rax          # imm = 0x10000
setae %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x10be0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3570
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::STNode::containsAllDocuments()
void
STNode::containsAllDocuments()
{
  if(this->docs != 0)
  {
    this->stored_documents = this->docs->size();
    delete this->docs; this->docs = 0;
  }
  for(STNode* curr = this; curr != 0; curr = curr->parent)
  {
    curr->contains_all = true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x40(%rax)
je 0x1fab3
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x7810
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl %ecx, 0x30(%rax)
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1faa7
movq -0x20(%rbp), %rdi
callq 0x1c250
movq -0x20(%rbp), %rdi
movl $0x18, %esi
callq 0x32f0
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1fad8
movq -0x10(%rbp), %rax
movb $0x1, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1fabb
addq $0x20, %rsp
popq %rbp
retq
nop
// File: adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::STNode::setNext()
void
STNode::setNext()
{
  std::stack<STNode*> nodestack;
  std::vector<STNode*> previous;
  for(STNode* temp = this; temp != 0; temp = temp->child) { nodestack.push(temp); }
  this->next = 0;

  while(nodestack.top() != this)
  {
    STNode* curr = nodestack.top(); nodestack.pop();
    for(STNode* temp = curr->sibling; temp != 0; temp = temp->child) { nodestack.push(temp); }

    if(curr->child == 0)
    {
      for(std::vector<STNode*>::iterator iter = previous.begin(); iter != previous.end(); ++iter)
      {
        (*iter)->next = curr;
      }
      previous.clear();
    }
    curr->next = 0; previous.push_back(curr);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x7620
leaq -0x70(%rbp), %rdi
callq 0x23560
movq -0xb0(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x78(%rbp)
je 0x1fbf3
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x7740
jmp 0x1fbbd
jmp 0x1fbbf
movq -0x78(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x78(%rbp)
jmp 0x1fba7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x236f0
leaq -0x58(%rbp), %rdi
callq 0x79b0
jmp 0x1fd64
movq -0xb0(%rbp), %rax
movq $0x0, 0x28(%rax)
leaq -0x58(%rbp), %rdi
callq 0x76b0
movq %rax, -0xb8(%rbp)
jmp 0x1fc14
movq -0xb8(%rbp), %rax
movq -0xb0(%rbp), %rcx
cmpq %rcx, (%rax)
je 0x1fd49
leaq -0x58(%rbp), %rdi
callq 0x76b0
movq %rax, -0xc0(%rbp)
jmp 0x1fc3d
movq -0xc0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x76d0
jmp 0x1fc59
movq -0x90(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
je 0x1fc9d
leaq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x7740
jmp 0x1fc87
jmp 0x1fc89
movq -0x98(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x98(%rbp)
jmp 0x1fc6b
movq -0x90(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1fd23
leaq -0x70(%rbp), %rdi
callq 0x23580
movq %rax, -0xa0(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x235f0
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x235b0
testb $0x1, %al
jne 0x1fce4
jmp 0x1fd1a
movq -0x90(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x23620
movq -0xc8(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x28(%rax)
leaq -0xa0(%rbp), %rdi
callq 0x23640
jmp 0x1fcbb
leaq -0x70(%rbp), %rdi
callq 0x23660
movq -0x90(%rbp), %rax
movq $0x0, 0x28(%rax)
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x23680
jmp 0x1fd44
jmp 0x1fc02
leaq -0x70(%rbp), %rdi
callq 0x236f0
leaq -0x58(%rbp), %rdi
callq 0x79b0
addq $0xd0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x3570
nopl (%rax)
// File: adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::DocArray::~DocArray()
DocArray::~DocArray()
{
  delete this->leaf_ranges; this->leaf_ranges = 0;
  delete this->first_children; this->first_children = 0;
  delete this->parents; this->parents = 0;
  delete this->next_leaves; this->next_leaves = 0;

  delete this->rule_borders; this->rule_borders = 0;
  delete this->rules; this->rules = 0;

  delete this->block_borders; this->block_borders = 0;
  delete this->blocks; this->blocks = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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 0x20ba9
movq -0x10(%rbp), %rdi
callq 0x2aa50
movq -0x10(%rbp), %rdi
movl $0x48, %esi
callq 0x32f0
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x20bda
movq -0x20(%rbp), %rdi
callq 0x2c700
movq -0x20(%rbp), %rdi
movl $0x48, %esi
callq 0x32f0
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x20c0b
movq -0x28(%rbp), %rdi
callq 0x28c30
movq -0x28(%rbp), %rdi
movl $0x28, %esi
callq 0x32f0
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x20c3c
movq -0x30(%rbp), %rdi
callq 0x28c30
movq -0x30(%rbp), %rdi
movl $0x28, %esi
callq 0x32f0
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x20c6d
movq -0x38(%rbp), %rdi
callq 0x2c700
movq -0x38(%rbp), %rdi
movl $0x48, %esi
callq 0x32f0
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq 0x30(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x20c9e
movq -0x40(%rbp), %rdi
callq 0x28c30
movq -0x40(%rbp), %rdi
movl $0x28, %esi
callq 0x32f0
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq 0x38(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x20ccf
movq -0x48(%rbp), %rdi
callq 0x2c700
movq -0x48(%rbp), %rdi
movl $0x48, %esi
callq 0x32f0
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq 0x40(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x20d00
movq -0x50(%rbp), %rdi
callq 0x28c30
movq -0x50(%rbp), %rdi
movl $0x28, %esi
callq 0x32f0
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::parseLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<unsigned int, std::allocator<unsigned int>>&, int, std::vector<unsigned int, std::allocator<unsigned int>>&)
void
parseLine(std::string& row, std::vector<usint>& before, int separator, std::vector<usint>& after)
{
  bool found = false, num = false;
  usint value = 0;
  for(usint i = 0; i < row.length(); i++)
  {
    if(isdigit(row[i])) { value = 10 * value + row[i] - '0'; num = true; }
    else if(num)
    {
      if(found) { after.push_back(value); }
      else      { before.push_back(value); }
      value = 0; num = false;
    }
    if(row[i] == separator) { found = true; }
  }
  if(num)
  {
    if(found) { after.push_back(value); }
    else      { before.push_back(value); }
    value = 0; num = false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movb $0x0, -0x22(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x34a0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x20e13
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x3620
movsbl (%rax), %edi
callq 0x32a0
cmpl $0x0, %eax
je 0x20db4
imull $0xa, -0x28(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x3620
movq %rax, %rcx
movl -0x3c(%rbp), %eax
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x28(%rbp)
movb $0x1, -0x22(%rbp)
jmp 0x20de9
testb $0x1, -0x22(%rbp)
je 0x20de7
testb $0x1, -0x21(%rbp)
je 0x20dcf
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x10cc0
jmp 0x20ddc
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x10cc0
movl $0x0, -0x28(%rbp)
movb $0x0, -0x22(%rbp)
jmp 0x20de9
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x3620
movsbl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x20e03
movb $0x1, -0x21(%rbp)
jmp 0x20e05
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x20d4d
testb $0x1, -0x22(%rbp)
je 0x20e46
testb $0x1, -0x21(%rbp)
je 0x20e2e
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x10cc0
jmp 0x20e3b
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x10cc0
movl $0x0, -0x28(%rbp)
movb $0x0, -0x22(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::DocArray::listDocuments(std::pair<unsigned int, unsigned int>) const
std::vector<usint>*
DocArray::listDocuments(pair_type range) const
{
  if(isEmpty(range) || range.second >= this->getSize()) { return 0; }

  std::vector<usint>* result = this->documentListing<usint>(range);
  if(result != 0) { removeDuplicates(result, false); }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x103a0
testb $0x1, %al
jne 0x23175
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x23b40
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jb 0x2317f
movq $0x0, -0x8(%rbp)
jmp 0x231b2
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x23b60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x231aa
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x10be0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::DocArray::listDocumentsRLE(std::pair<unsigned int, unsigned int>) const
std::vector<pair_type>*
DocArray::listDocumentsRLE(pair_type range) const
{
  if(isEmpty(range) || range.second >= this->getSize()) { return 0; }

  std::vector<pair_type>* result = this->documentListing<pair_type>(range);
  if(result != 0) { mergeRanges(result, false); }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x103a0
testb $0x1, %al
jne 0x23245
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x23b40
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jb 0x2324f
movq $0x0, -0x8(%rbp)
jmp 0x23282
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x24040
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2327a
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x304d0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::DocArray::directListing(std::pair<unsigned int, unsigned int>) const
std::vector<usint>*
DocArray::directListing(pair_type range) const
{
  if(isEmpty(range) || range.second >= this->getSize()) { return 0; }
  std::vector<usint>* result = new std::vector<usint>;
  this->processRange(range, *result);
  removeDuplicates(result, false);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x103a0
testb $0x1, %al
jne 0x232d5
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x23b40
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jb 0x232df
movq $0x0, -0x8(%rbp)
jmp 0x23329
movl $0x18, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
callq 0x10bc0
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rsi
callq 0x24510
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x10be0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::DocArray::directListingRLE(std::pair<unsigned int, unsigned int>) const
std::vector<pair_type>*
DocArray::directListingRLE(pair_type range) const
{
  if(isEmpty(range) || range.second >= this->getSize()) { return 0; }
  std::vector<pair_type>* result = new std::vector<pair_type>;
  this->processRange(range, *result);
  mergeRanges(result, false);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x103a0
testb $0x1, %al
jne 0x23385
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x23b40
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jb 0x2338f
movq $0x0, -0x8(%rbp)
jmp 0x233d9
movl $0x18, %edi
callq 0x32e0
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
callq 0x17910
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rsi
callq 0x245f0
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x304d0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: adamnovak[P]rlcsa/./docarray.h
// Function: void CSA::DocArray::processRange<unsigned int>(std::pair<unsigned int, unsigned int>, std::vector<unsigned int, std::allocator<unsigned int>>&) const
void
    processRange(pair_type range, std::vector<T>& result) const
    {
      if(isEmpty(range)) { return; }

      usint* res = this->rlcsa.locate(range);
      this->rlcsa.getSequenceForPosition(res, length(range));
      for(usint i = 0; i < length(range); i++)
      {
        this->addItem(res[i], result);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x103a0
testb $0x1, %al
jne 0x24543
jmp 0x24548
jmp 0x245e7
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0xc240
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x76f0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl %eax, %edx
callq 0xd9e0
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x44(%rbp)
movq -0x44(%rbp), %rdi
callq 0x76f0
movl %eax, %ecx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jae 0x245e7
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl (%rax,%rcx,4), %esi
movq -0x18(%rbp), %rdx
callq 0x268e0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x245a5
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::SuccinctVector(std::basic_ifstream<char, std::char_traits<char>>&)
SuccinctVector::SuccinctVector(std::ifstream& file) :
  BitVector()
{
  this->readHeader(file);
  this->readArray(file);

  this->integer_bits = length(this->size);
  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, -0x28(%rbp)
callq 0x29d90
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x29330
jmp 0x2c12c
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x293a0
jmp 0x2c13b
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0x178e0
movl %eax, -0x2c(%rbp)
jmp 0x2c14b
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, 0x20(%rdi)
callq 0x2c190
jmp 0x2c15c
movq -0x28(%rbp), %rdi
callq 0x2c2d0
jmp 0x2c167
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x29dc0
movq -0x18(%rbp), %rdi
callq 0x3570
nopl (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::indexForRank()
void
SuccinctVector::indexForRank()
{
  delete this->rank_index; this->rank_index = 0;

  WriteBuffer buffer(this->number_of_blocks + 1, this->integer_bits);
  const usint* data = this->array;

  buffer.writeItem(0);
  usint bitcount = 0;
  for(usint block = 0; block < this->number_of_blocks; block++)
  {
    for(usint word = 0; word < this->block_size; word++, ++data) { bitcount += popcount(*data); }
    buffer.writeItem(bitcount);
  }

  this->rank_index = buffer.getReadBuffer();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x2c1cc
movq -0x58(%rbp), %rdi
callq 0x28c30
movq -0x58(%rbp), %rdi
movl $0x28, %esi
callq 0x32f0
movq -0x60(%rbp), %rax
movq $0x0, 0x28(%rax)
movl 0x14(%rax), %esi
movl 0x20(%rax), %edx
incl %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x28e30
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rdi
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
xorl %esi, %esi
callq 0x179c0
jmp 0x2c206
movl $0x0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x60(%rbp), %rcx
movl -0x4c(%rbp), %eax
cmpl 0x14(%rcx), %eax
jae 0x2c298
movl $0x0, -0x50(%rbp)
movq -0x60(%rbp), %rcx
movl -0x50(%rbp), %eax
cmpl 0x10(%rcx), %eax
jae 0x2c27a
movq -0x38(%rbp), %rax
movl (%rax), %edi
callq 0x2d120
movl %eax, -0x6c(%rbp)
jmp 0x2c243
movl -0x6c(%rbp), %eax
addl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0x2c227
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x28f70
jmp 0x2c2c5
movl -0x48(%rbp), %esi
leaq -0x30(%rbp), %rdi
callq 0x179c0
jmp 0x2c288
jmp 0x2c28a
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x2c214
leaq -0x30(%rbp), %rdi
callq 0x28fb0
movq %rax, -0x78(%rbp)
jmp 0x2c2a7
movq -0x60(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, 0x28(%rax)
leaq -0x30(%rbp), %rdi
callq 0x28f70
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3570
nop
// File: adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::indexForSelect()
void
SuccinctVector::indexForSelect()
{
  delete this->select_index; this->select_index = 0;

  this->select_rate = (this->items + this->number_of_blocks - 1) / this->number_of_blocks;
  usint index_samples = (this->items + this->select_rate - 1) / this->select_rate + 1;
  WriteBuffer buffer(index_samples, this->integer_bits);

  // pointer is the largest block number such that rank_index[pointer] <= current.
  usint pointer = 0;
  usint next_rank = this->rank_index->readItem(1);
  for(usint current = 0; current < this->items; current += this->select_rate)
  {
    while(next_rank <= current)
    {
      pointer++; next_rank = this->rank_index->readItem();
    }
    buffer.writeItem(pointer);
  }
  buffer.writeItem(this->number_of_blocks - 1);

  this->select_index = buffer.getReadBuffer();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x2c30c
movq -0x58(%rbp), %rdi
callq 0x28c30
movq -0x58(%rbp), %rdi
movl $0x28, %esi
callq 0x32f0
movq -0x60(%rbp), %rax
movq $0x0, 0x38(%rax)
movl 0x4(%rax), %esi
movl 0x14(%rax), %ecx
movl %ecx, %edx
movl %esi, %eax
leal -0x1(%rax,%rdx), %eax
xorl %edx, %edx
movl %edx, -0x68(%rbp)
divl %ecx
movl -0x68(%rbp), %edx
movl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, 0x40(%rax)
movl 0x4(%rax), %edi
movl 0x40(%rax), %ecx
movl %ecx, %esi
movl %edi, %eax
leal -0x1(%rax,%rsi), %eax
divl %ecx
movl %eax, %ecx
movq -0x60(%rbp), %rax
incl %ecx
movl %ecx, -0xc(%rbp)
movl -0xc(%rbp), %esi
movl 0x20(%rax), %edx
leaq -0x38(%rbp), %rdi
callq 0x28e30
movq -0x60(%rbp), %rax
movl $0x0, -0x3c(%rbp)
movq 0x28(%rax), %rdi
movl $0x1, %esi
callq 0x17ad0
movl %eax, -0x64(%rbp)
jmp 0x2c381
movl -0x64(%rbp), %eax
movl %eax, -0x40(%rbp)
movl $0x0, -0x50(%rbp)
movq -0x60(%rbp), %rcx
movl -0x50(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x2c3fc
jmp 0x2c39c
movl -0x40(%rbp), %eax
cmpl -0x50(%rbp), %eax
ja 0x2c3dd
movq -0x60(%rbp), %rax
movl -0x3c(%rbp), %ecx
incl %ecx
movl %ecx, -0x3c(%rbp)
movq 0x28(%rax), %rdi
callq 0x17b30
movl %eax, -0x6c(%rbp)
jmp 0x2c3be
movl -0x6c(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x2c39c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28f70
jmp 0x2c43d
movl -0x3c(%rbp), %esi
leaq -0x38(%rbp), %rdi
callq 0x179c0
jmp 0x2c3eb
jmp 0x2c3ed
movq -0x60(%rbp), %rax
movl 0x40(%rax), %eax
addl -0x50(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0x2c38e
movq -0x60(%rbp), %rax
movl 0x14(%rax), %esi
decl %esi
leaq -0x38(%rbp), %rdi
callq 0x179c0
jmp 0x2c410
leaq -0x38(%rbp), %rdi
callq 0x28fb0
movq %rax, -0x78(%rbp)
jmp 0x2c41f
movq -0x60(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, 0x38(%rax)
leaq -0x38(%rbp), %rdi
callq 0x28f70
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3570
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::SuccinctVector(_IO_FILE*)
SuccinctVector::SuccinctVector(FILE* file) :
  BitVector()
{
  if(file == 0) { return; }

  this->readHeader(file);
  this->readArray(file);

  this->integer_bits = length(this->size);
  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, -0x28(%rbp)
callq 0x29d90
cmpq $0x0, -0x10(%rbp)
jne 0x2c476
jmp 0x2c4c0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x29850
jmp 0x2c485
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x29910
jmp 0x2c494
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0x178e0
movl %eax, -0x2c(%rbp)
jmp 0x2c4a4
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, 0x20(%rdi)
callq 0x2c190
jmp 0x2c4b5
movq -0x28(%rbp), %rdi
callq 0x2c2d0
jmp 0x2c4c0
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x29dc0
movq -0x18(%rbp), %rdi
callq 0x3570
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::SuccinctVector(CSA::SuccinctEncoder&, unsigned int)
SuccinctVector::SuccinctVector(Encoder& encoder, usint universe_size) :
  BitVector()
{
  if(encoder.items == 0)
  {
    std::cerr << "SuccinctVector: Cannot create a bit vector with no 1-bits!" << std::endl;
    return;
  }

  this->size = universe_size;
  this->items = encoder.items;
  this->block_size = encoder.block_size;

  this->number_of_blocks = (this->size + this->block_size * WORD_BITS - 1) / (this->block_size * WORD_BITS);
  this->copyArray(encoder);

  this->integer_bits = length(this->size);
  this->indexForRank();
  this->indexForSelect();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x29d90
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x2c561
movq 0x19acf(%rip), %rdi     # 0x45ff0
leaq 0x8684(%rip), %rsi      # 0x34bac
callq 0x32c0
movq %rax, -0x38(%rbp)
jmp 0x2c533
movq -0x38(%rbp), %rdi
movq 0x19a72(%rip), %rsi     # 0x45fb0
callq 0x3330
jmp 0x2c545
jmp 0x2c5d2
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x29dc0
jmp 0x2c5d8
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rdi)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x10(%rdi)
movl (%rdi), %edx
movl 0x10(%rdi), %ecx
shll $0x5, %ecx
movl %edx, %eax
movl %ecx, %edx
leal -0x1(%rax,%rdx), %eax
xorl %edx, %edx
movl %edx, -0x3c(%rbp)
divl %ecx
movl -0x3c(%rbp), %edx
movl %eax, 0x14(%rdi)
movq -0x10(%rbp), %rsi
callq 0x29bd0
jmp 0x2c5a6
movq -0x30(%rbp), %rax
movl (%rax), %edi
callq 0x178e0
movl %eax, -0x40(%rbp)
jmp 0x2c5b6
movq -0x30(%rbp), %rdi
movl -0x40(%rbp), %eax
movl %eax, 0x20(%rdi)
callq 0x2c190
jmp 0x2c5c7
movq -0x30(%rbp), %rdi
callq 0x2c2d0
jmp 0x2c5d2
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3570
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::SuccinctVector(CSA::SuccinctEncoder&)
SuccinctVector::SuccinctVector(Encoder& encoder) :
  BitVector()
{
  if(encoder.items == 0)
  {
    std::cerr << "SuccinctVector: Cannot create a bit vector with no 1-bits!" << std::endl;
    return;
  }

  this->size = std::max(encoder.size, encoder.superblock_bytes * CHAR_BIT);
  this->items = encoder.items;
  this->block_size = encoder.block_size;

  this->number_of_blocks = (this->size + this->block_size * WORD_BITS - 1) / (this->block_size * WORD_BITS);
  this->copyArray(encoder, true);

  this->integer_bits = length(this->size);
  this->indexForRank();
  this->indexForSelect();
}

// 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)
callq 0x29d90
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x2c661
movq 0x199d2(%rip), %rdi     # 0x45ff0
leaq 0x8587(%rip), %rsi      # 0x34bac
callq 0x32c0
movq %rax, -0x30(%rbp)
jmp 0x2c630
movq -0x30(%rbp), %rdi
movq 0x19975(%rip), %rsi     # 0x45fb0
callq 0x3330
jmp 0x2c642
jmp 0x2c6f0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x29dc0
jmp 0x2c6f6
movq -0x10(%rbp), %rdi
movl 0x10(%rdi), %eax
shll $0x3, %eax
movl %eax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x11590
movq %rax, -0x38(%rbp)
jmp 0x2c67d
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rdi)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x10(%rdi)
movl (%rdi), %edx
movl 0x10(%rdi), %ecx
shll $0x5, %ecx
movl %edx, %eax
movl %ecx, %edx
leal -0x1(%rax,%rdx), %eax
xorl %edx, %edx
divl %ecx
movl %eax, 0x14(%rdi)
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x29bd0
jmp 0x2c6c4
movq -0x28(%rbp), %rax
movl (%rax), %edi
callq 0x178e0
movl %eax, -0x3c(%rbp)
jmp 0x2c6d4
movq -0x28(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, 0x20(%rdi)
callq 0x2c190
jmp 0x2c6e5
movq -0x28(%rbp), %rdi
callq 0x2c2d0
jmp 0x2c6f0
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3570
nop
// File: adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::Iterator::rank(unsigned int, bool)
usint
SuccinctVector::Iterator::rank(usint value, bool at_least)
{
  const SuccinctVector& par = (const SuccinctVector&)(this->parent);

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

  usint block = value / (par.block_size * WORD_BITS);
  usint result = par.rank_index->readItemConst(block);
  const usint* data = par.array + block * par.block_size;

  // Value is now the number of bits to be read within the block.
  // Add popcounts for entire words as long as possible.
  value = value - block * par.block_size * WORD_BITS + 1;
  while(value >= WORD_BITS)
  {
    result += popcount(*data);
    ++data; value -= WORD_BITS;
  }

  // Add popcount for the last bits.
  if(value > 0)
  {
    result += popcount(GET(LOWER(*data, WORD_BITS - value), value));
  }

  return result;
}

// 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), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x2c83b
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2c901
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
movl 0x10(%rcx), %ecx
shll $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0x24(%rbp), %esi
callq 0x11b90
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rdx
imull 0x10(%rdx), %ecx
movl %ecx, %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rdx
imull 0x10(%rdx), %ecx
shll $0x5, %ecx
subl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jb 0x2c8c9
movq -0x30(%rbp), %rax
movl (%rax), %edi
callq 0x2d120
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
subl $0x20, %eax
movl %eax, -0x14(%rbp)
jmp 0x2c89b
cmpl $0x0, -0x14(%rbp)
jbe 0x2c8fb
movq -0x30(%rbp), %rax
movl (%rax), %edi
movl $0x20, %ecx
subl -0x14(%rbp), %ecx
shrl %cl, %edi
movl $0x20, %ecx
subl -0x14(%rbp), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shrl %cl, %eax
andl %eax, %edi
callq 0x2d120
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::Iterator::valueBefore(unsigned int)
pair_type
SuccinctVector::Iterator::valueBefore(usint value)
{
  const SuccinctVector& par = (const SuccinctVector&)(this->parent);
  if(value >= par.size) { return pair_type(par.size, par.items); }

	usint temp = this->rank(value);
	if(temp == 0)         { return pair_type(par.size, par.items); }
	return pair_type(this->select(temp - 1), temp - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x2cce0
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x4, %rdx
leaq -0x8(%rbp), %rdi
callq 0x11200
jmp 0x2cd3a
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x2c800
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x2cd0e
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x4, %rdx
leaq -0x8(%rbp), %rdi
callq 0x11200
jmp 0x2cd3a
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %esi
subl $0x1, %esi
callq 0x2c910
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x17b00
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::Iterator::valueAfter(unsigned int)
pair_type
SuccinctVector::Iterator::valueAfter(usint value)
{
  const SuccinctVector& par = (const SuccinctVector&)(this->parent);
  if(value >= par.size) { return pair_type(par.size, par.items); }

	if(value == 0) { return pair_type(this->select(0), 0); }
	usint temp = this->rank(value - 1);
	return pair_type(this->select(temp), temp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x2cd90
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x4, %rdx
leaq -0x8(%rbp), %rdi
callq 0x11200
jmp 0x2cdf2
cmpl $0x0, -0x14(%rbp)
jne 0x2cdbe
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x2c910
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x2b380
jmp 0x2cdf2
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
xorl %edx, %edx
callq 0x2c800
movq -0x38(%rbp), %rdi
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %esi
callq 0x2c910
movl %eax, -0x30(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x11340
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::Iterator::countRuns()
usint
SuccinctVector::Iterator::countRuns()
{
  usint runs = 0;
  usint prev = this->select(0);
  while(this->hasNext())
  {
    usint temp = this->selectNext();
    if(temp != prev + 1) { runs++; }
    prev = temp;
  }
  return runs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
xorl %esi, %esi
callq 0x2c910
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2d160
testb $0x1, %al
jne 0x2cee4
jmp 0x2cf0e
movq -0x20(%rbp), %rdi
callq 0x2cbd0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
je 0x2cf06
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x2ced5
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctEncoder::setBit(unsigned int)
void
SuccinctEncoder::setBit(usint value)
{
  // We can set any bit in the current superblock as well as those bits after it.
  if(value < this->array_blocks.size() * this->superblock_bytes * CHAR_BIT) { return; }
  this->size = std::max(this->size, value + 1);

  value -= this->array_blocks.size() * this->superblock_bytes * CHAR_BIT;
  while(value >= this->superblock_bytes * CHAR_BIT)
  {
    this->addNewBlock();
    value -= this->superblock_bytes * CHAR_BIT;
  }

  if(!(this->buffer->isSet(value))) { this->items++; }
  this->buffer->setBit(value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
addq $0x20, %rdi
callq 0x2a8c0
movq -0x20(%rbp), %rdx
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl 0x10(%rdx), %edx
imulq %rdx, %rcx
shlq $0x3, %rcx
cmpq %rcx, %rax
jae 0x2cfb7
jmp 0x2d059
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x11590
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, (%rdi)
addq $0x20, %rdi
callq 0x2a8c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
imulq %rax, %rcx
shlq $0x3, %rcx
movl -0xc(%rbp), %eax
subq %rcx, %rax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x10(%rcx), %ecx
shll $0x3, %ecx
cmpl %ecx, %eax
jb 0x2d027
movq -0x20(%rbp), %rdi
callq 0x2a700
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
shll $0x3, %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x2cff9
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x2d190
cmpl $0x0, %eax
jne 0x2d049
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x2d1d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ushitora-anqou[P]femtoyaml/./femtoyaml.hpp
// Function: femtoyaml::load(std::istream&)
inline value load(std::istream& is)
{
    detail::stream st = is;
    auto tokens = detail::tokenizer(st).get();
    // for (auto&& tk : tokens)
    //    std::cout << femtoyaml::detail::to_string(tk) << std::endl;
    return detail::parser(tokens.begin()).get();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x128(%rbp)
movq %rdi, %rax
movq %rax, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x6d50
movq -0x118(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x6d90
jmp 0x48cd
leaq -0xc8(%rbp), %rdi
callq 0x6e20
movq %rax, -0x130(%rbp)
jmp 0x48e2
movq -0x130(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x6e40
jmp 0x48f7
leaq -0xc8(%rbp), %rdi
callq 0x6f30
leaq -0x88(%rbp), %rdi
callq 0x6f60
movq %rax, -0x110(%rbp)
movq -0x110(%rbp), %rsi
leaq -0x108(%rbp), %rdi
callq 0x6f90
jmp 0x492b
leaq -0x108(%rbp), %rdi
callq 0x6ff0
movq %rax, -0x138(%rbp)
jmp 0x4940
movq -0x138(%rbp), %rsi
movq -0x128(%rbp), %rdi
callq 0x7010
jmp 0x4955
leaq -0x108(%rbp), %rdi
callq 0x7040
leaq -0x88(%rbp), %rdi
callq 0x7060
leaq -0x70(%rbp), %rdi
callq 0x70c0
movq -0x120(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x49f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x6f30
jmp 0x49f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x49ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x7040
leaq -0x88(%rbp), %rdi
callq 0x7060
leaq -0x70(%rbp), %rdi
callq 0x70c0
movq -0xd0(%rbp), %rdi
callq 0x3390
nopl (%rax)
// File: ushitora-anqou[P]femtoyaml/./femtoyaml.hpp
// Function: femtoyaml::detail::serializer::print_char(char)
void print_char(char ch)
    {
        os_ << ch;
        if (ch == '\n')
            column_ = 0;
        else
            column_++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
movsbl -0x9(%rbp), %esi
callq 0x3260
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
jne 0x618c
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x6199
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ushitora-anqou[P]femtoyaml/./femtoyaml.hpp
// Function: femtoyaml::detail::stream::skip_ws()
void skip_ws()
    {
        while (true) {
            switch (peek()) {
            case ' ':
            case '\n':
                next();
                break;

            default:
                return;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x8120
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
subl $0xa, %eax
je 0x8035
jmp 0x802b
movl -0x14(%rbp), %eax
subl $0x20, %eax
jne 0x8040
jmp 0x8035
movq -0x10(%rbp), %rdi
callq 0x8270
jmp 0x8046
addq $0x20, %rsp
popq %rbp
retq
jmp 0x8014
nopl (%rax,%rax)
// File: ushitora-anqou[P]femtoyaml/./femtoyaml.hpp
// Function: femtoyaml::detail::tokenizer::unroll_indent(int)
void unroll_indent(int column)
    {
        // check indent and unroll it if needed
        while (indent_ > column) {
            indent_ = indents_.back();
            indents_.pop_back();
            tks_.push_back(tk_block_end{});
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x80e7
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x70(%rbp)
callq 0x8730
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movq -0x58(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x20(%rax)
callq 0x8770
movq -0x58(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq -0x39(%rbp), %rsi
callq 0x87a0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x82c0
jmp 0x80c5
leaq -0x38(%rbp), %rdi
callq 0x8320
jmp 0x8067
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8320
jmp 0x80ed
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)