LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq (%rdi), %rax
movl (%rax), %esi
cmpl %ebp, %esi
jbe 0x1321a
movq %rdi, %rbx
movl %ebp, %esi
callq 0x12586
movq %rbx, %rdi
movl %eax, %esi
callq 0x135a4
movl 0x20(%rbx), %r8d
movl 0x14(%rbx), %edi
movl 0x18(%rbx), %esi
cmpl %r8d, %edi
jae 0x131fe
movq 0x28(%rbx), %r9
movl 0x44(%rbx), %eax
movl 0x40(%rbx), %r10d
cmpl %ebp, %esi
jae 0x131fe
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %eax, %ecx
decl %ecx
movl %ecx, 0x44(%rbx)
movl %r10d, %eax
movl (%r9,%rax,4), %r11d
je 0x1310c
movl %ecx, %eax
jmp 0x1311f
incl %r10d
movl %r10d, 0x40(%rbx)
movl $0x20, 0x44(%rbx)
movl $0x20, %eax
incl %edx
btl %ecx, %r11d
jae 0x130f8
movl $0x1, %r14d
movl %edx, %ecx
shll %cl, %r14d
xorl %r11d, %r11d
cmpl %edx, %eax
ja 0x13164
subl %eax, %edx
movl %r10d, %ecx
movl (%r9,%rcx,4), %r11d
negb %al
movl %eax, %ecx
shll %cl, %r11d
shrl %cl, %r11d
movl %edx, %ecx
shll %cl, %r11d
incl %r10d
movl %r10d, 0x40(%rbx)
movl $0x20, 0x44(%rbx)
movl $0x20, %eax
movl %r10d, %r15d
testl %edx, %edx
je 0x13186
subl %edx, %eax
movl %eax, 0x44(%rbx)
movl (%r9,%r15,4), %r12d
movl %eax, %ecx
shrl %cl, %r12d
negb %dl
movl %edx, %ecx
shll %cl, %r12d
shrl %cl, %r12d
orl %r12d, %r11d
orl %r14d, %r11d
decl %r11d
xorl %r14d, %r14d
movl %r11d, %edx
subl %eax, %edx
jae 0x1319b
movl %r11d, %edx
jmp 0x131c1
movl (%r9,%r15,4), %r14d
negb %al
movl %eax, %ecx
shll %cl, %r14d
shrl %cl, %r14d
movl %edx, %ecx
shll %cl, %r14d
incl %r10d
movl %r10d, 0x40(%rbx)
movl $0x20, 0x44(%rbx)
movl $0x20, %eax
testl %edx, %edx
je 0x131e3
subl %edx, %eax
movl %eax, 0x44(%rbx)
movl %r10d, %ecx
movl (%r9,%rcx,4), %r15d
movl %eax, %ecx
shrl %cl, %r15d
negb %dl
movl %edx, %ecx
shll %cl, %r15d
shrl %cl, %r15d
orl %r15d, %r14d
btsl %r11d, %r14d
addl %r14d, %esi
movl %esi, 0x18(%rbx)
incl %edi
movl %edi, 0x14(%rbx)
cmpl %r8d, %edi
jne 0x130eb
movl %r8d, %edi
cmpl %ebp, %esi
jae 0x13215
movl 0x8(%rbx), %esi
incl %esi
movq %rbx, %rdi
callq 0x135a4
movl 0x14(%rbx), %edi
movl 0x18(%rbx), %esi
addl 0xc(%rbx), %edi
jmp 0x1321d
movl 0x4(%rax), %edi
shlq $0x20, %rdi
movl %esi, %eax
orq %rdi, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x14(%rdi), %esi
cmpl 0x20(%rdi), %esi
jae 0x132f7
incl %esi
movl %esi, 0x14(%rbx)
movq 0x28(%rbx), %rdi
movl 0x44(%rbx), %eax
movl 0x40(%rbx), %r8d
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %eax, %ecx
decl %ecx
movl %ecx, 0x44(%rbx)
movl %r8d, %eax
movl (%rdi,%rax,4), %r9d
je 0x1326b
movl %ecx, %eax
jmp 0x1327e
incl %r8d
movl %r8d, 0x40(%rbx)
movl $0x20, 0x44(%rbx)
movl $0x20, %eax
incl %edx
btl %ecx, %r9d
jae 0x13257
movl $0x1, %r10d
movl %edx, %ecx
shll %cl, %r10d
xorl %r9d, %r9d
cmpl %edx, %eax
ja 0x132c3
subl %eax, %edx
movl %r8d, %ecx
movl (%rdi,%rcx,4), %r9d
negb %al
movl %eax, %ecx
shll %cl, %r9d
shrl %cl, %r9d
movl %edx, %ecx
shll %cl, %r9d
incl %r8d
movl %r8d, 0x40(%rbx)
movl $0x20, 0x44(%rbx)
movl $0x20, %eax
movl %r8d, %r11d
testl %edx, %edx
je 0x132e2
subl %edx, %eax
movl %eax, 0x44(%rbx)
movl (%rdi,%r11,4), %ebp
movl %eax, %ecx
shrl %cl, %ebp
negb %dl
movl %edx, %ecx
shll %cl, %ebp
shrl %cl, %ebp
orl %ebp, %r9d
orl %r10d, %r9d
decl %r9d
xorl %r10d, %r10d
movl %r9d, %edx
subl %eax, %edx
jae 0x1330d
movl %r9d, %edx
jmp 0x13333
movl 0x8(%rbx), %esi
incl %esi
movq %rbx, %rdi
callq 0x135a4
movl 0xc(%rbx), %esi
movl 0x18(%rbx), %r10d
jmp 0x13360
movl (%rdi,%r11,4), %r10d
negb %al
movl %eax, %ecx
shll %cl, %r10d
shrl %cl, %r10d
movl %edx, %ecx
shll %cl, %r10d
incl %r8d
movl %r8d, 0x40(%rbx)
movl $0x20, 0x44(%rbx)
movl $0x20, %eax
testl %edx, %edx
je 0x13351
subl %edx, %eax
movl %eax, 0x44(%rbx)
movl %r8d, %ecx
movl (%rdi,%rcx,4), %edi
movl %eax, %ecx
shrl %cl, %edi
negb %dl
movl %edx, %ecx
shll %cl, %edi
shrl %cl, %edi
orl %edi, %r10d
btsl %r9d, %r10d
addl 0x18(%rbx), %r10d
movl %r10d, 0x18(%rbx)
addl 0xc(%rbx), %esi
shlq $0x20, %rsi
movl %r10d, %eax
orq %rsi, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rdi), %rax
cmpl %esi, (%rax)
jbe 0x134ee
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x12586
movq %r14, %rdi
movl %eax, %esi
callq 0x135a4
movl 0x20(%r14), %edi
movl 0x14(%r14), %r8d
movl 0x18(%r14), %esi
cmpl %edi, %r8d
jae 0x134e0
movq 0x28(%r14), %r9
movl 0x44(%r14), %eax
movl 0x40(%r14), %r10d
cmpl %ebx, %esi
jae 0x134e0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %eax, %ecx
decl %ecx
movl %ecx, 0x44(%r14)
movl %r10d, %eax
movl (%r9,%rax,4), %r11d
je 0x133f0
movl %ecx, %eax
jmp 0x13404
incl %r10d
movl %r10d, 0x40(%r14)
movl $0x20, 0x44(%r14)
movl $0x20, %eax
incl %edx
btl %ecx, %r11d
jae 0x133db
movl $0x1, %ebp
movl %edx, %ecx
shll %cl, %ebp
xorl %r11d, %r11d
cmpl %edx, %eax
ja 0x13448
subl %eax, %edx
movl %r10d, %ecx
movl (%r9,%rcx,4), %r11d
negb %al
movl %eax, %ecx
shll %cl, %r11d
shrl %cl, %r11d
movl %edx, %ecx
shll %cl, %r11d
incl %r10d
movl %r10d, 0x40(%r14)
movl $0x20, 0x44(%r14)
movl $0x20, %eax
movl %r10d, %r15d
testl %edx, %edx
je 0x1346b
subl %edx, %eax
movl %eax, 0x44(%r14)
movl (%r9,%r15,4), %r12d
movl %eax, %ecx
shrl %cl, %r12d
negb %dl
movl %edx, %ecx
shll %cl, %r12d
shrl %cl, %r12d
orl %r12d, %r11d
orl %ebp, %r11d
decl %r11d
xorl %ebp, %ebp
movl %r11d, %edx
subl %eax, %edx
jae 0x1347f
movl %r11d, %edx
jmp 0x134a3
movl (%r9,%r15,4), %ebp
negb %al
movl %eax, %ecx
shll %cl, %ebp
shrl %cl, %ebp
movl %edx, %ecx
shll %cl, %ebp
incl %r10d
movl %r10d, 0x40(%r14)
movl $0x20, 0x44(%r14)
movl $0x20, %eax
testl %edx, %edx
je 0x134c6
subl %edx, %eax
movl %eax, 0x44(%r14)
movl %r10d, %ecx
movl (%r9,%rcx,4), %r15d
movl %eax, %ecx
shrl %cl, %r15d
negb %dl
movl %edx, %ecx
shll %cl, %r15d
shrl %cl, %r15d
orl %r15d, %ebp
btsl %r11d, %ebp
addl %ebp, %esi
movl %esi, 0x18(%r14)
incl %r8d
movl %r8d, 0x14(%r14)
cmpl %edi, %r8d
jne 0x133ce
cmpl %ebx, %esi
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
testl %eax, %eax
je 0x1352d
movl (%rbx), %ecx
cmpl %esi, %ecx
ja 0x1352b
incl %esi
movl %esi, (%rbx)
subl %ecx, %esi
incl %eax
movl %eax, 0x4(%rbx)
movq 0x18(%rbx), %rdi
callq 0x10f3e
testb %al, %al
je 0x13536
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x12a70
movq %rbx, %rdi
popq %rbx
jmp 0x12964
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, 0x8(%rdi)
leal (%rsi,%rsi), %r11d
movl 0x5c(%rdi), %r10d
movl %r10d, %ecx
imull %r11d, %ecx
movl %ecx, %r9d
shrl $0x5, %r9d
movl %r9d, 0x68(%rdi)
andl $0x1e, %ecx
movl $0x20, %eax
movl $0x20, %ebx
subl %ecx, %ebx
movl %ebx, 0x6c(%rdi)
leal 0x1(,%rsi,2), %edx
movl %edx, 0x70(%rdi)
xorl %r8d, %r8d
movl %r10d, %edx
subl %ebx, %edx
jae 0x135f2
movl %ebx, %eax
movl %r10d, %edx
jmp 0x13616
movq 0x50(%rdi), %r8
movl %r9d, %ebx
movl (%r8,%rbx,4), %r8d
shll %cl, %r8d
shrl %cl, %r8d
movl %edx, %ecx
shll %cl, %r8d
incl %r9d
movl %r9d, 0x68(%rdi)
movl $0x20, 0x6c(%rdi)
movl %r9d, %r14d
testl %edx, %edx
je 0x13639
subl %edx, %eax
movl %eax, 0x6c(%rdi)
movq 0x50(%rdi), %rcx
movl (%rcx,%r14,4), %ebx
movl %eax, %ecx
shrl %cl, %ebx
negb %dl
movl %edx, %ecx
shll %cl, %ebx
shrl %cl, %ebx
orl %ebx, %r8d
movl %r8d, 0xc(%rdi)
leal 0x2(%r11), %ecx
movl %ecx, 0x70(%rdi)
xorl %ebx, %ebx
movl %r10d, %edx
subl %eax, %edx
jae 0x13652
movl %r10d, %edx
jmp 0x13679
movq 0x50(%rdi), %rcx
movl (%rcx,%r14,4), %ebx
negb %al
movl %eax, %ecx
shll %cl, %ebx
shrl %cl, %ebx
movl %edx, %ecx
shll %cl, %ebx
incl %r9d
movl %r9d, 0x68(%rdi)
movl $0x20, 0x6c(%rdi)
movl $0x20, %eax
movl %r9d, %r14d
testl %edx, %edx
je 0x1369b
subl %edx, %eax
movl %eax, 0x6c(%rdi)
movq 0x50(%rdi), %rcx
movl (%rcx,%r14,4), %ebp
movl %eax, %ecx
shrl %cl, %ebp
negb %dl
movl %edx, %ecx
shll %cl, %ebp
shrl %cl, %ebp
orl %ebp, %ebx
movl %ebx, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
movl %ebx, 0x18(%rdi)
addl $0x3, %r11d
movl %r11d, 0x70(%rdi)
xorl %r11d, %r11d
movl %r10d, %edx
subl %eax, %edx
jae 0x136bf
movl %r10d, %edx
jmp 0x136e9
movq 0x50(%rdi), %rcx
movl (%rcx,%r14,4), %r11d
negb %al
movl %eax, %ecx
shll %cl, %r11d
shrl %cl, %r11d
movl %edx, %ecx
shll %cl, %r11d
incl %r9d
movl %r9d, 0x68(%rdi)
movl $0x20, 0x6c(%rdi)
movl $0x20, %eax
testl %edx, %edx
je 0x1370f
subl %edx, %eax
movl %eax, 0x6c(%rdi)
movq 0x50(%rdi), %rcx
movl %r9d, %r9d
movl (%rcx,%r9,4), %r9d
movl %eax, %ecx
shrl %cl, %r9d
negb %dl
movl %edx, %ecx
shll %cl, %r9d
shrl %cl, %r9d
orl %r9d, %r11d
notl %r8d
addl %r11d, %r8d
movl %r8d, 0x20(%rdi)
movq (%rdi), %rax
addq $0x28, %rdi
imull 0x10(%rax), %esi
shlq $0x2, %rsi
addq 0x8(%rax), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x11306
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq (%rdi), %rax
cmpl %esi, (%rax)
jbe 0x137b2
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x137cc
cmpl %r14d, 0x18(%rbx)
setbe %al
setb %cl
andb %bpl, %cl
cmpb $0x1, %cl
jne 0x137b7
movl 0x8(%rbx), %esi
incl %esi
movq %rbx, %rdi
callq 0x135a4
movl $0x0, 0x1c(%rbx)
movl 0xc(%rbx), %eax
movl 0x14(%rbx), %ecx
addl %ecx, %eax
incl %eax
jmp 0x137c6
movl 0x4(%rax), %eax
jmp 0x137c6
movl 0x14(%rbx), %ecx
addl 0xc(%rbx), %ecx
orb %al, %bpl
movzbl %bpl, %eax
addl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rdi), %rcx
movl (%rcx), %eax
cmpl %esi, %eax
jbe 0x1420a
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x137cc
movl 0x18(%rbx), %eax
cmpl %ebp, %eax
jae 0x141fc
movl 0x8(%rbx), %esi
incl %esi
movq %rbx, %rdi
callq 0x135a4
movl $0x0, 0x1c(%rbx)
movl 0x18(%rbx), %eax
movl 0x14(%rbx), %ecx
addl 0xc(%rbx), %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1420d
movl 0x4(%rcx), %ecx
shlq $0x20, %rcx
movl %eax, %eax
orq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x13cb8
movl 0x1c(%r14), %ecx
cmpl %ebx, %ecx
cmovbl %ecx, %ebx
subl %ebx, %ecx
movl %ecx, 0x1c(%r14)
movq 0x14(%r14), %xmm0
movd %ebx, %xmm1
pshufd $0x50, %xmm1, %xmm1     # xmm1 = xmm1[0,0,1,1]
paddd %xmm0, %xmm1
movq %xmm1, 0x14(%r14)
shlq $0x20, %rbx
movl %eax, %eax
orq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rdi), %rax
cmpl %esi, (%rax)
jbe 0x1451c
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x137cc
cmpl %ebx, 0x18(%r14)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r14
movl 0x4(%r14), %r15d
testl %r15d, %r15d
je 0x145d3
movq %rdi, %rbx
xorl %esi, %esi
callq 0x13a48
movl 0x1c(%rbx), %ecx
cmpl %r15d, %ecx
cmovbl %ecx, %r15d
subl %r15d, %ecx
movl %ecx, 0x1c(%rbx)
movq 0x14(%rbx), %xmm0
movd %r15d, %xmm1
pshufd $0x50, %xmm1, %xmm1     # xmm1 = xmm1[0,0,1,1]
paddd %xmm0, %xmm1
movq %xmm1, 0x14(%rbx)
addl %eax, %r15d
movl $0x1, %ebp
cmpl (%r14), %r15d
jae 0x145d5
movl 0x4(%r14), %r12d
movq %rbx, %rdi
callq 0x13cb8
movl 0x1c(%rbx), %ecx
cmpl %r12d, %ecx
cmovbl %ecx, %r12d
subl %r12d, %ecx
movl %ecx, 0x1c(%rbx)
movq 0x14(%rbx), %xmm0
movd %r12d, %xmm1
pshufd $0x50, %xmm1, %xmm1     # xmm1 = xmm1[0,0,1,1]
paddd %xmm0, %xmm1
movq %xmm1, 0x14(%rbx)
movl (%r14), %ecx
cmpl %ecx, %eax
setb %dl
incl %r15d
cmpl %r15d, %eax
seta %sil
andb %dl, %sil
movzbl %sil, %edx
addl %edx, %ebp
addl %eax, %r12d
movl %r12d, %r15d
cmpl %ecx, %r12d
jb 0x14577
jmp 0x145d5
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl 0x74(%rdi), %edx
testl %edx, %edx
je 0x14829
movl 0x70(%r14), %esi
leal (%rsi,%rdx), %eax
cmpl %ebp, %eax
jne 0x14821
addl %ebx, %edx
movl %edx, %ebx
jmp 0x1482d
movq %r14, %rdi
callq 0x14608
movl %ebp, 0x70(%r14)
movl %ebx, 0x74(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq (%rsi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsi,%rax)
jne 0x1499e
movq %rsi, %rbx
leaq 0x20(%rsp), %r14
leaq 0x40(%rsp), %r13
xorl %ebp, %ebp
leaq 0x30(%rsp), %r12
movq %r14, 0x10(%rsp)
movq %rbp, 0x18(%rsp)
movb %bpl, 0x20(%rsp)
movq %r13, 0x30(%rsp)
movq %rbp, 0x38(%rsp)
movb %bpl, 0x40(%rsp)
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x32f0
movq %rax, %rdi
movq %r12, %rsi
callq 0x32f0
movq %rax, %rdi
leaq 0xc(%rsp), %rsi
callq 0x3450
movq %r12, %rdi
leaq 0x4030(%rip), %rsi      # 0x1896e
callq 0x30c0
testl %eax, %eax
jne 0x1495e
movl 0xc(%rsp), %r15d
movq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x14fb4
movl %r15d, (%rax)
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x14975
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1498c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3270
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x148f1
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x149c7
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x149de
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5c8, %rsp            # imm = 0x5C8
movq %rdi, 0x50(%rsp)
testq %rsi, %rsi
je 0x14b3f
movq %rsi, %r14
movq %rsi, %rdi
callq 0x3380
testl %eax, %eax
jne 0x14b3f
leaq 0x40(%rsp), %rbx
leaq 0x1e0(%rsp), %r13
leaq 0x58(%rsp), %rbp
xorl %r15d, %r15d
movq %r13, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
movq %r14, %rdx
callq 0x33a0
testq %rax, %rax
je 0x14b3f
movq %rbp, %rdi
callq 0x31b0
movq %r13, %rdi
callq 0x3110
leaq 0x68(%rsp), %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x32b0
movq %rbx, %r12
movq %rbx, 0x30(%rsp)
movq %r15, 0x38(%rsp)
movb %r15b, 0x40(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movb %r15b, 0x20(%rsp)
movq %rbp, %rdi
leaq 0x30(%rsp), %rsi
callq 0x32f0
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x32f0
movq %rax, %rdi
leaq 0xc(%rsp), %rsi
callq 0x3450
leaq 0x10(%rsp), %rdi
leaq 0x3eaf(%rip), %rsi      # 0x1896e
callq 0x30c0
testl %eax, %eax
jne 0x14add
movl 0xc(%rsp), %ebx
movq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x14fb4
movl %ebx, (%rax)
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x14af9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x30(%rsp), %rdi
movq %r12, %rbx
cmpq %r12, %rdi
je 0x14b13
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3270
movq %rbp, %rdi
movq 0xb483(%rip), %rsi      # 0x1ffa0
callq 0x31d0
leaq 0xd8(%rsp), %rdi
callq 0x30e0
movq %r14, %rdi
callq 0x3380
testl %eax, %eax
je 0x14a2d
addq $0x5c8, %rsp            # imm = 0x5C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x14b8c
movq %rax, %r14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x14b75
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x14b8c
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0xb40d(%rip), %rsi      # 0x1ffa0
leaq 0x58(%rsp), %rdi
callq 0x31d0
leaq 0xd8(%rsp), %rdi
callq 0x30e0
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x4, %edx
callq 0x3480
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
je 0x14c52
movq 0xb402(%rip), %rdi      # 0x1fff0
leaq 0x3d0f(%rip), %rsi      # 0x18904
movl $0x1b, %edx
callq 0x32b0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xb3e3(%rip), %rdi      # 0x1fff0
callq 0x32b0
movq %rax, %rbx
leaq 0x3d04(%rip), %rsi      # 0x18920
movl $0xd, %edx
movq %rax, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
jmp 0x14c69
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x148b8
leaq 0x8(%rsp), %rdi
callq 0x3090
leaq 0x8(%rsp), %rdi
callq 0x30a0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
testq %rsi, %rsi
je 0x14e75
movq %rdi, %r15
movq 0x18(%rdi), %r12
addq $0x8, %r15
cmpq %r15, %r12
je 0x14e75
movq %rsi, %r14
leaq 0x20(%rsp), %rbx
movq 0xb1ff(%rip), %r13      # 0x1ffa0
movq %rbx, %rdi
callq 0x31b0
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
leaq 0x30(%rsp), %rdi
callq 0x32b0
movq %rax, %rbp
movl $0x3, %edx
movq %rax, %rdi
leaq 0x3b5f(%rip), %rsi      # 0x1892e
callq 0x32b0
movl 0x40(%r12), %esi
movq %rbp, %rdi
callq 0x3180
movq %rax, %rbp
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbp, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
movq %rsp, %rdi
leaq 0x38(%rsp), %rsi
callq 0x33b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
movq %r14, %rcx
callq 0x34a0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x14e49
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
movq %rbx, %rdi
movq %r13, %rsi
callq 0x31d0
leaq 0xa0(%rsp), %rdi
callq 0x30e0
movq %r12, %rdi
callq 0x32c0
movq %rax, %r12
cmpq %r15, %rax
jne 0x14da1
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14e89
movq %rax, %rbx
movq 0xb10d(%rip), %rsi      # 0x1ffa0
leaq 0x20(%rsp), %rdi
callq 0x31d0
leaq 0xa0(%rsp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/misc/parameters.cpp
// Function: CSA::Parameters::write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
void
Parameters::write(const std::string& file_name) const
{
  std::ofstream file(file_name.c_str(), std::ios_base::binary);
  if(!file)
  {
    std::cerr << "Cannot open parameter file " << file_name << " for writing!" << std::endl;
    return;
  }
  this->write(file);
  file.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movq %rsp, %r15
movq %r15, %rdi
movl $0x4, %edx
callq 0x32a0
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
je 0x14f50
movq 0xb104(%rip), %rdi      # 0x1fff0
leaq 0x3a11(%rip), %rsi      # 0x18904
movl $0x1b, %edx
callq 0x32b0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xb0e5(%rip), %rdi      # 0x1fff0
callq 0x32b0
movq %rax, %rbx
leaq 0x3a18(%rip), %rsi      # 0x18932
movl $0xd, %edx
movq %rax, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
jmp 0x14f63
movq %rsp, %rsi
movq %r14, %rdi
callq 0x14cce
movq %rsp, %rdi
callq 0x3330
movq 0xb05e(%rip), %rax      # 0x1ffc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x3200
leaq 0xf8(%rsp), %rdi
callq 0x30e0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3350
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::readRows(std::basic_ifstream<char, std::char_traits<char>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, bool)
void
readRows(std::ifstream& file, std::vector<std::string>& rows, bool skipEmptyRows)
{
  while(file)
  {
    std::string buf;
    std::getline(file, buf);
    if(skipEmptyRows && buf.length() == 0) { continue; }
    rows.push_back(buf);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rax
movq -0x18(%rax), %rcx
testb $0x5, 0x20(%rdi,%rcx)
jne 0x155c2
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
addq $-0x18, %rax
leaq 0x10(%rsp), %r13
movq %rsp, %r12
movq %r13, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq (%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3490
testb %bl, %bl
je 0x1558e
cmpq $0x0, 0x8(%rsp)
je 0x15599
movq %r14, %rdi
movq %r12, %rsi
callq 0x160c8
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x155af
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
movq (%r15), %rax
movq -0x18(%rax), %rcx
addq $-0x18, %rax
testb $0x5, 0x20(%r15,%rcx)
je 0x15552
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x155e9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::initialSort(std::pair<unsigned int, unsigned int>*, unsigned int*, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&, unsigned int, unsigned int, unsigned int)
uint
initialSort(short_pair* pairs, uint* keys, std::vector<ss_range>& unsorted, uint n, uint threads, uint h)
{
  // Sort according to first h characters.
  parallelSort(pairs, pairs + n, key_comparator);
  unsorted.push_back(ss_range(0, n - 1));
  uint total = setRanks(pairs, keys, n, unsorted, threads, 1);
//  std::cout << "Sorted with h = " << h << ", unsorted total = " << total << " (" << unsorted.size() << " ranges)" << std::endl;

  return total;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebx
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl %ecx, %eax
leaq (%rdi,%rax,8), %rsi
leaq 0xafea(%rip), %rdx      # 0x20848
callq 0x16105
leal -0x1(%r14), %eax
leaq 0x8(%rsp), %rsi
movl $0x0, (%rsi)
movl %eax, 0x4(%rsi)
movq %r15, %rdi
callq 0xc7da
movq %r13, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
movl %ebx, %r8d
movl $0x1, %r9d
callq 0x16143
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::prefixDoubling(std::pair<unsigned int, unsigned int>*, unsigned int*, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&, unsigned int, unsigned int, unsigned int, unsigned int)
short_pair*
prefixDoubling(short_pair* pairs, uint* keys, std::vector<ss_range>& unsorted, uint n, uint threads, uint total, uint h)
{
  // Double prefix length until sorted.
  while(total > 0)
  {
    uint chunk = std::max((size_t)1, unsorted.size() / (threads * threads));
    #pragma omp parallel for schedule(dynamic, chunk)
    for(uint i = 0; i < unsorted.size(); i++)
    {
      // Set sort keys for the current range.
      short_pair* limit = pairs + unsorted[i].second;
      for(short_pair* curr = pairs + unsorted[i].first; curr <= limit; ++curr)
      {
        curr->second = keys[curr->first + h];
      }
      sequentialSort(pairs + unsorted[i].first, pairs + unsorted[i].second + 1, key_comparator);
    }
    total = setRanks(pairs, keys, n, unsorted, threads, chunk);
    h *= 2;
//    std::cout << "Sorted with h = " << h << ", unsorted total = " << total << " (" << unsorted.size() << " ranges)" << std::endl;
  }

  #pragma omp parallel for schedule(static)
  for(uint i = 0; i < n; i++) { pairs[i].second = keys[i]; }
  delete[] keys; keys = 0;
  return pairs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, (%rsp)
movl %ecx, %r13d
movq %rsi, %r14
movq %rdi, %rbx
testl %r9d, %r9d
je 0x15999
movq %rdx, %r12
movl 0x50(%rsp), %ebp
movl (%rsp), %eax
imull %eax, %eax
movq %rax, 0x8(%rsp)
leaq 0x8(%rbx), %r15
movl %r13d, 0x4(%rsp)
movq (%r12), %rcx
movq 0x8(%r12), %rsi
movq %rsi, %rax
subq %rcx, %rax
sarq $0x3, %rax
xorl %edx, %edx
divq 0x8(%rsp)
cmpq $0x1, %rax
adcq $0x0, %rax
movq %rax, 0x10(%rsp)
cmpq %rcx, %rsi
je 0x15970
xorl %r13d, %r13d
movl (%rcx,%r13,8), %edx
movl 0x4(%rcx,%r13,8), %eax
leaq (%rbx,%rdx,8), %rdi
cmpl %eax, %edx
ja 0x15948
leaq (%rbx,%rax,8), %rax
movq %rdi, %rdx
movl (%rdx), %esi
addl %ebp, %esi
movl (%r14,%rsi,4), %esi
movl %esi, 0x4(%rdx)
addq $0x8, %rdx
cmpq %rax, %rdx
jbe 0x1592f
movl 0x4(%rcx,%r13,8), %eax
leaq (%r15,%rax,8), %rsi
leaq 0xaef5(%rip), %rdx      # 0x20848
callq 0x162fa
incl %r13d
movq (%r12), %rcx
movq 0x8(%r12), %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq %r13, %rax
ja 0x15917
movq %rbx, %rdi
movq %r14, %rsi
movl 0x4(%rsp), %r13d
movl %r13d, %edx
movq %r12, %rcx
movl (%rsp), %r8d
movq 0x10(%rsp), %r9
callq 0x16143
addl %ebp, %ebp
testl %eax, %eax
jne 0x158e8
testl %r13d, %r13d
je 0x159b5
movl %r13d, %eax
xorl %ecx, %ecx
movl (%r14,%rcx,4), %edx
movl %edx, 0x4(%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x159a3
jmp 0x159ba
testq %r14, %r14
je 0x159c2
movq %r14, %rdi
callq 0x3300
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::simpleSuffixSort(unsigned int const*, unsigned int, unsigned int)
short_pair*
simpleSuffixSort(const usint* sequence, uint n, uint threads)
{
  if(sequence == 0 || n == 0) { return 0; }

  skew_pair* pairs = (skew_pair*)new short_pair[n * sizeof(skew_pair) / sizeof(short_pair) + 1];
  uint* keys = new uint[n];               // In text order.
  std::vector<ss_range> unsorted;
  threads = std::max(threads, (uint)1);
  #ifdef MULTITHREAD_SUPPORT
  omp_set_num_threads(threads);
  #endif

  // Initialize pairs.
  #pragma omp parallel for schedule(static)
  for(uint i = 0; i < n; i++) { pairs[i].first = i; pairs[i].second = sequence[i]; }

  // Sort according to first character.
  parallelSort(pairs, pairs + n, skew_comparator);
  unsorted.push_back(ss_range(0, n - 1));
  uint total = setRanks(pairs, keys, n, unsorted, threads, 1);

  if(sizeof(usint) < 2 * sizeof(uint))
  {
    return prefixDoubling(packPairs(pairs, n), keys, unsorted, n, threads, total, 1);
  }
  else
  {
    return prefixTripling(pairs, keys, unsorted, n, threads, total, 1);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rdi, %rdi
sete %al
testl %esi, %esi
sete %cl
orb %al, %cl
je 0x15b65
xorl %ebx, %ebx
jmp 0x15c62
movq %rdi, %r13
movl %edx, %r14d
movq %rsi, 0x28(%rsp)
movl %esi, %r15d
leaq 0x8(,%r15,8), %r12
movq %r12, %rdi
callq 0x3030
movq %rax, %rbx
xorl %ebp, %ebp
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3150
leaq (,%r15,4), %rdi
callq 0x3030
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $0x1, %r14d
adcl $0x0, %r14d
movl %r14d, 0xc(%rsp)
movl %ebp, (%rbx,%rbp,8)
movl (%r13,%rbp,4), %eax
movl %eax, 0x4(%rbx,%rbp,8)
incq %rbp
cmpq %rbp, %r15
jne 0x15bc3
leaq (%rbx,%r15,8), %rsi
leaq 0xac65(%rip), %rdx      # 0x20847
movq %rbx, %rdi
callq 0x16376
movq 0x28(%rsp), %rax
decl %eax
leaq 0x30(%rsp), %rsi
movl $0x0, (%rsi)
movl %eax, 0x4(%rsi)
leaq 0x10(%rsp), %rdi
callq 0xc7da
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl 0xc(%rsp), %ebp
movl %ebp, %r8d
movl $0x1, %r9d
callq 0x16143
movl $0x1, (%rsp)
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq 0x28(%rsp), %rcx
movl %ebp, %r8d
movl %eax, %r9d
callq 0x158a9
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x15c62
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15c78
jmp 0x15c78
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x15c92
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::simpleSuffixSort(std::pair<unsigned int, unsigned int>*, unsigned int, unsigned int)
short_pair*
simpleSuffixSort(short_pair* pairs, uint n, uint threads)
{
  if(pairs == 0 || n == 0) { return 0; }

  uint* keys = new uint[n];   // In text order.
  std::vector<ss_range> unsorted;
  threads = std::max(threads, (uint)1);
  #ifdef MULTITHREAD_SUPPORT
  omp_set_num_threads(threads);
  #endif

  // Initialize pairs.
  #pragma omp parallel for schedule(static)
  for(uint i = 0; i < n; i++) { pairs[i].first = i; }

  uint total = initialSort(pairs, keys, unsorted, n, threads, 1);
  return prefixDoubling(pairs, keys, unsorted, n, threads, total, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
testq %rdi, %rdi
sete %al
testl %esi, %esi
sete %cl
orb %al, %cl
je 0x15cbc
xorl %ebx, %ebx
jmp 0x15dc9
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %r12d
leaq (,%r12,4), %rdi
callq 0x3030
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x1(%r12), %rax
andq $-0x2, %rax
decq %r12
movq %r12, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x263a(%rip), %xmm1     # 0x18340
xorl %ecx, %ecx
movdqa 0x2640(%rip), %xmm2     # 0x18350
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x2c30(%rip), %xmm4     # 0x18950
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0x15d54
movl %ecx, (%rbx,%rcx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x15d69
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx,%rcx,8)
addq $0x2, %rcx
paddq %xmm4, %xmm1
cmpq %rcx, %rax
jne 0x15d20
cmpl $0x1, %ebp
adcl $0x0, %ebp
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %ecx
movl %ebp, %r8d
callq 0x15835
movl $0x1, (%rsp)
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %ecx
movl %ebp, %r8d
movl %eax, %r9d
callq 0x158a9
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x15dc9
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x15df3
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::mergeRanges(std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>*, bool)
void
mergeRanges(std::vector<pair_type>* vec, bool parallel)
{
  if(vec == 0 || vec->size() <= 1) { return; }
  if(parallel) { parallelSort(vec->begin(), vec->end()); }
  else         { sequentialSort(vec->begin(), vec->end()); }

  std::vector<pair_type>::iterator prev = vec->begin();
  for(std::vector<pair_type>::iterator curr = prev + 1; curr != vec->end(); ++curr)
  {
    if(prev->second + 1 >= curr->first) { prev->second = std::max(curr->second, prev->second); }
    else { ++prev; *prev = *curr; }
  }
  vec->resize((prev - vec->begin()) + 1);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x16056
movl %esi, %eax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
movq %rsi, %rcx
subq %rdi, %rcx
cmpq $0x9, %rcx
jae 0x16058
popq %rbx
retq
testb %al, %al
je 0x16063
callq 0xc75d
jmp 0x16068
callq 0x163b4
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x8(%rax), %rdx
movq %rax, %rsi
cmpq %rcx, %rdx
je 0x160b4
movq %rax, %rsi
movl 0x4(%rsi), %edi
leal 0x1(%rdi), %r9d
movl (%rdx), %r8d
cmpl %r8d, %r9d
jae 0x1609d
movl %r8d, 0x8(%rsi)
movl 0x4(%rdx), %edi
movl %edi, 0xc(%rsi)
addq $0x8, %rsi
jmp 0x160ab
movl 0x4(%rdx), %r8d
cmpl %edi, %r8d
cmoval %r8d, %edi
movl %edi, 0x4(%rsi)
addq $0x8, %rdx
cmpq %rcx, %rdx
jne 0x1607e
subq %rax, %rsi
sarq $0x3, %rsi
incq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x163f2
nop
// File: /workspace/github_cpp_makefile_star2_O3/yangwanyuan[P]HLKVDS/tools/CreateDb.cc
// Function: CreateExample(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void CreateExample(string filename) {

    Options opts;
    if (!hlkvds::DB::CreateDB(filename, opts)) {
        std::cout << "CreateDB Failed!" << std::endl;
        return;
    }

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x16760
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x9b4e
movl $0xa, %ecx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x12290
movl %eax, %ebx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x9a3f
callq 0x63e0
testb %bl, %bl
jne 0x9a85
movq 0x29586(%rip), %rbx     # 0x32fd0
leaq 0x175b3(%rip), %rsi     # 0x21004
movl $0x10, %edx
movq %rbx, %rdi
callq 0x6440
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x63f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x62c0
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x9aa4
callq 0x63e0
movq %rbx, %rdi
callq 0x6660
// File: /workspace/github_cpp_makefile_star2_O3/nikolausmayer[P]SimplePlot/./Sparkline.h
// Function: Sparkline::Sparkline(float const*, unsigned long, unsigned long, unsigned long, bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, double)
std::string Sparkline( const float* const data,
                         size_t number_of_data_points,
                         size_t this_many_lines_high,
                         size_t this_many_characters_wide,
                         bool enclose_in_box,
                         bool print_colored,
                         std::string title,
                         double max,
                         double min
                       ) 
  {
    return Sparkline( data,
                      number_of_data_points,
                      this_many_lines_high,
                      this_many_characters_wide,
                      enclose_in_box,
                      print_colored,
                      title,
                      (float)max,
                      (float)min
                    );
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm1, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movl %r9d, %ebp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x78(%rsp), %rax
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x4c5e
xorps %xmm0, %xmm0
cvtsd2ss 0x28(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsd2ss 0x30(%rsp), %xmm1
movzbl 0x70(%rsp), %eax
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movl %ebp, %r9d
leaq 0x8(%rsp), %r10
pushq %r10
pushq %rax
callq 0x3d3d
addq $0x10, %rsp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x27f8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2829
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/nikolausmayer[P]SimplePlot/./Sparkline.h
// Function: Sparkline::ShowExampleGaussian[abi:cxx11]()
std::string ShowExampleGaussian()
  {
    std::vector<float> data_vec{
      0.000514092998764,
      0.00147728280398,
      0.00379866200793,
      0.0087406296979,
      0.0179969888377,
      0.0331590462642,
      0.054670024892,
      0.080656908173,
      0.106482668507,
      0.125794409231,
      0.132980760134,
      0.125794409231,
      0.106482668507,
      0.080656908173,
      0.054670024892,
      0.0331590462642,
      0.0179969888377,
      0.0087406296979,
      0.00379866200793,
      0.00147728280398,
      0.000514092998764
    };

    Configuration<float> config;
    config.setHeight(3);
    config.setMin(0);
    config.setMax(0.15);
    config.setBox(true);
    config.setTitle("Gaussian");
    config.setColor(false);
    return Sparkline(data_vec, config);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x3c11(%rip), %rsi      # 0x6534
leaq 0x40(%rsp), %rax
movl $0x15, %ecx
movq %rax, %rdi
rep  movsl (%rsi), %es:(%rdi)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movl $0x15, %edx
movq %rax, %rsi
callq 0x4b4c
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x3845(%rip), %rdx      # 0x619f
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x4cf4
leaq 0x58(%rsp), %r14
movq $0x1, -0x18(%r14)
movq $0x0, -0x10(%r14)
movw $0x100, -0x8(%r14)      # imm = 0x100
leaq 0x68(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4c5e
movsd 0x36b7(%rip), %xmm0     # 0x6060
movsd %xmm0, 0x78(%rsp)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x29c6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq $0x3, 0x40(%rsp)
movsd 0x3699(%rip), %xmm0     # 0x6070
movsd %xmm0, 0x78(%rsp)
movb $0x1, 0x50(%rsp)
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x3727(%rip), %rsi      # 0x6118
leaq 0x3728(%rip), %rdx      # 0x6120
callq 0x4cf4
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2100
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2a21
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x40(%rsp), %rdx
movb $0x0, 0x11(%rdx)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x4b91
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x2a4e
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2a65
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2a95
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2a98
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x2a98
movq %rax, %rbx
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ac8
movq 0x68(%rsp), %rsi
jmp 0x2abb
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2ac8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x2ac8
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2adf
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/nikolausmayer[P]SimplePlot/./Sparkline.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Sparkline::Sparkline<float>(std::vector<float, std::allocator<float>> const&, unsigned long, unsigned long, bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float, float)
std::string Sparkline( const std::vector<T>& data,
                         size_t this_many_lines_high=1,
                         size_t this_many_characters_wide=0,
                         bool enclose_in_box=false,
                         bool print_colored=true,
                         std::string title="",
                         T minv=std::numeric_limits<T>::max(),
                         T maxv=std::numeric_limits<T>::min()
                       )
  {
    /// TODO The standard guarantees that vector elements are
    /// stored contiguously, but does that hold for all compiler
    /// and language versions (VERY young issue; May 2014)?
    /// (www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#69)
    const T* const ptr = &data[0];
    return Sparkline( ptr,
                      (size_t)data.size(),
                      this_many_lines_high,
                      this_many_characters_wide,
                      enclose_in_box,
                      print_colored,
                      title,
                      minv,
                      maxv );
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm1, 0xc(%rsp)
movss %xmm0, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movl %r8d, 0x4(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movq 0x70(%rsp), %rax
movq (%rsi), %r13
movq 0x8(%rsi), %r14
subq %r13, %r14
sarq $0x2, %r14
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
callq 0x4c5e
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq %r15, %r8
movl 0x4(%rsp), %r9d
movss 0x8(%rsp), %xmm0
movss 0xc(%rsp), %xmm1
pushq %rbp
pushq 0x18(%rsp)
callq 0x3d3d
addq $0x10, %rsp
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x4b12
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x4b43
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280
nop