LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movl %esi, 0x8(%rdi)
leal (%rsi,%rsi), %r10d
movl 0x5c(%rdi), %eax
movl %eax, %ecx
imull %r10d, %ecx
movl %ecx, %r11d
shrl $0x5, %r11d
movl %r11d, 0x68(%rdi)
andl $0x1e, %ecx
movl $0x20, %ebx
subl %ecx, %ebx
movl %ebx, 0x6c(%rdi)
leal 0x1(,%rsi,2), %edx
movl %edx, 0x70(%rdi)
xorl %r9d, %r9d
movl %eax, %r8d
movl %eax, %edx
subl %ebx, %r8d
jb 0x13140
movq 0x50(%rdi), %rdx
movl %r11d, %r9d
movl (%rdx,%r9,4), %r9d
shll %cl, %r9d
shrl %cl, %r9d
movl %r8d, %ecx
shll %cl, %r9d
incl %r11d
movl %r11d, 0x68(%rdi)
movl $0x20, 0x6c(%rdi)
movl %r8d, %edx
testl %edx, %edx
je 0x13168
movl 0x6c(%rdi), %ecx
subl %edx, %ecx
movl %ecx, 0x6c(%rdi)
movq 0x50(%rdi), %r8
movl 0x68(%rdi), %r11d
movl (%r8,%r11,4), %r8d
shrl %cl, %r8d
negb %dl
movl %edx, %ecx
shll %cl, %r8d
shrl %cl, %r8d
orl %r8d, %r9d
movl %r9d, 0xc(%rdi)
leal 0x2(%r10), %ecx
movl %ecx, 0x70(%rdi)
movl 0x6c(%rdi), %ecx
xorl %r11d, %r11d
movl %eax, %r8d
movl %eax, %edx
subl %ecx, %r8d
jb 0x131ac
movq 0x50(%rdi), %rdx
movl 0x68(%rdi), %ebx
movl (%rdx,%rbx,4), %r11d
negb %cl
shll %cl, %r11d
shrl %cl, %r11d
movl %r8d, %ecx
shll %cl, %r11d
leal 0x1(%rbx), %ecx
movl %ecx, 0x68(%rdi)
movl $0x20, 0x6c(%rdi)
movl %r8d, %edx
testl %edx, %edx
je 0x131d3
movl 0x6c(%rdi), %ecx
subl %edx, %ecx
movl %ecx, 0x6c(%rdi)
movq 0x50(%rdi), %r8
movl 0x68(%rdi), %ebx
movl (%r8,%rbx,4), %r8d
shrl %cl, %r8d
negb %dl
movl %edx, %ecx
shll %cl, %r8d
shrl %cl, %r8d
orl %r8d, %r11d
movl %r11d, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
movl %r11d, 0x18(%rdi)
addl $0x3, %r10d
movl %r10d, 0x70(%rdi)
movl 0x6c(%rdi), %ecx
xorl %r8d, %r8d
movl %eax, %edx
subl %ecx, %edx
jb 0x1321f
movq 0x50(%rdi), %rax
movl 0x68(%rdi), %r10d
movl (%rax,%r10,4), %r8d
negb %cl
shll %cl, %r8d
shrl %cl, %r8d
movl %edx, %ecx
shll %cl, %r8d
leal 0x1(%r10), %eax
movl %eax, 0x68(%rdi)
movl $0x20, 0x6c(%rdi)
movl %edx, %eax
testl %eax, %eax
je 0x13244
movl 0x6c(%rdi), %ecx
subl %eax, %ecx
movl %ecx, 0x6c(%rdi)
movq 0x50(%rdi), %rdx
movl 0x68(%rdi), %r10d
movl (%rdx,%r10,4), %edx
shrl %cl, %edx
negb %al
movl %eax, %ecx
shll %cl, %edx
shrl %cl, %edx
orl %edx, %r8d
notl %r9d
addl %r8d, %r9d
movl %r9d, 0x20(%rdi)
movq (%rdi), %rax
addq $0x28, %rdi
imull 0x10(%rax), %esi
shlq $0x2, %rsi
addq 0x8(%rax), %rsi
popq %rbx
jmp 0x10fe6
nop
// File: /workspace/github_cpp_makefile_star2_O1/adamnovak[P]rlcsa/bits/bitbuffer.h
// Function: CSA::ReadBuffer::readDeltaCode(unsigned int)
inline usint readDeltaCode(usint limit)
    {
       usint _pos = this->pos, _bits = this->bits;
       usint value = this->readDeltaCode();
       if(value > limit)
       {
         this->pos = _pos; this->bits = _bits;
         return 0;
       }
       return value;
    }

// Assembly:
pushq %rbx
movl 0x18(%rdi), %r9d
movl 0x1c(%rdi), %r10d
movq (%rdi), %r11
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %r9d, %ecx
movl %r10d, %edx
decl %edx
movl %edx, 0x1c(%rdi)
movl %ecx, %r8d
movl (%r11,%r8,4), %r8d
je 0x13291
movl %edx, %ebx
jmp 0x132a2
incl %ecx
movl %ecx, 0x18(%rdi)
movl $0x20, 0x1c(%rdi)
movl $0x20, %ebx
incl %eax
btl %edx, %r8d
movl %ebx, %edx
jae 0x1327f
movl $0x1, %edx
movl %eax, %ecx
shll %cl, %edx
movl 0x1c(%rdi), %ecx
xorl %ebx, %ebx
cmpl %eax, %ecx
ja 0x132e0
subl %ecx, %eax
movl 0x18(%rdi), %r8d
movl (%r11,%r8,4), %ebx
negb %cl
shll %cl, %ebx
shrl %cl, %ebx
movl %eax, %ecx
shll %cl, %ebx
leal 0x1(%r8), %ecx
movl %ecx, 0x18(%rdi)
movl $0x20, 0x1c(%rdi)
testl %eax, %eax
je 0x13304
movl 0x18(%rdi), %r8d
movl 0x1c(%rdi), %ecx
subl %eax, %ecx
movl %ecx, 0x1c(%rdi)
movl (%r11,%r8,4), %r8d
shrl %cl, %r8d
negb %al
movl %eax, %ecx
shll %cl, %r8d
shrl %cl, %r8d
orl %r8d, %ebx
orl %edx, %ebx
decl %ebx
movl 0x1c(%rdi), %ecx
xorl %eax, %eax
movl %ebx, %r8d
movl %ebx, %edx
subl %ecx, %r8d
jb 0x13339
movl 0x18(%rdi), %edx
movl (%r11,%rdx,4), %eax
negb %cl
shll %cl, %eax
shrl %cl, %eax
movl %r8d, %ecx
shll %cl, %eax
leal 0x1(%rdx), %ecx
movl %ecx, 0x18(%rdi)
movl $0x20, 0x1c(%rdi)
movl %r8d, %edx
testl %edx, %edx
je 0x1335d
movl 0x18(%rdi), %r8d
movl 0x1c(%rdi), %ecx
subl %edx, %ecx
movl %ecx, 0x1c(%rdi)
movl (%r11,%r8,4), %r8d
shrl %cl, %r8d
negb %dl
movl %edx, %ecx
shll %cl, %r8d
shrl %cl, %r8d
orl %r8d, %eax
btsl %ebx, %eax
cmpl %esi, %eax
jbe 0x1336e
movl %r9d, 0x18(%rdi)
movl %r10d, 0x1c(%rdi)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x133ea
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x13404
cmpl %r14d, 0x18(%rbx)
setbe %al
setb %cl
andb %bpl, %cl
cmpb $0x1, %cl
jne 0x133ef
movl 0x8(%rbx), %esi
incl %esi
movq %rbx, %rdi
callq 0x130d8
movl $0x0, 0x1c(%rbx)
movl 0xc(%rbx), %eax
movl 0x14(%rbx), %ecx
addl %ecx, %eax
incl %eax
jmp 0x133fe
movl 0x4(%rax), %eax
jmp 0x133fe
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_O1/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 0x13d02
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x13404
cmpl %ebp, 0x18(%rbx)
jae 0x13cf1
movl 0x8(%rbx), %esi
incl %esi
movq %rbx, %rdi
callq 0x130d8
movl $0x0, 0x1c(%rbx)
movl 0x14(%rbx), %ecx
movl 0x18(%rbx), %eax
addl 0xc(%rbx), %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x13d05
movl 0x4(%rcx), %ecx
shlq $0x20, %rcx
movl %eax, %eax
orq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/adamnovak[P]rlcsa/bits/rlevector.cpp
// Function: CSA::RLEVector::Iterator::selectRun(unsigned int, unsigned int)
pair_type
RLEVector::Iterator::selectRun(usint index, usint max_length)
{
  usint value = this->select(index);

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

  return pair_type(value, len);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
callq 0x1368a
movl 0x1c(%r14), %ecx
cmpl %ebx, %ecx
cmovbl %ecx, %ebx
subl %ebx, %ecx
movl %ecx, 0x1c(%r14)
addl %ebx, 0x14(%r14)
addl %ebx, 0x18(%r14)
shlq $0x20, %rbx
movl %eax, %eax
orq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13900
movl 0x1c(%r14), %ecx
cmpl %ebx, %ecx
cmovbl %ecx, %ebx
subl %ebx, %ecx
movl %ecx, 0x1c(%r14)
addl %ebx, 0x14(%r14)
addl %ebx, 0x18(%r14)
shlq $0x20, %rbx
movl %eax, %eax
orq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13fe2
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x13404
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_O1/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 0x14075
movq %rdi, %rbx
xorl %esi, %esi
callq 0x1368a
movl 0x1c(%rbx), %ecx
cmpl %r15d, %ecx
cmovbl %ecx, %r15d
subl %r15d, %ecx
movl %ecx, 0x1c(%rbx)
addl %r15d, 0x14(%rbx)
addl %r15d, 0x18(%rbx)
addl %eax, %r15d
movl $0x1, %ebp
cmpl (%r14), %r15d
jae 0x14077
movl 0x4(%r14), %r12d
movq %rbx, %rdi
callq 0x13900
movl 0x1c(%rbx), %ecx
cmpl %r12d, %ecx
cmovbl %ecx, %r12d
subl %r12d, %ecx
movl %ecx, 0x1c(%rbx)
addl %r12d, 0x14(%rbx)
addl %r12d, 0x18(%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 0x14029
jmp 0x14077
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14287
movl 0x70(%r14), %esi
leal (%rsi,%rdx), %eax
cmpl %ebp, %eax
jne 0x1427f
addl %ebx, %edx
movl %edx, 0x74(%r14)
jmp 0x1428f
movq %r14, %rdi
callq 0x140aa
movl %ebp, 0x70(%r14)
movl %ebx, 0x74(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x143fa
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 0x3574(%rip), %rsi      # 0x1790e
callq 0x30c0
testl %eax, %eax
jne 0x143ba
movl 0xc(%rsp), %r15d
movq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x14a22
movl %r15d, (%rax)
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x143d1
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x143e8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3270
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x1434d
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 0x14423
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1443a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x48(%rsp)
testq %rsi, %rsi
je 0x145af
movq %rsi, %rbx
leaq 0x38(%rsp), %r15
leaq 0x1e0(%rsp), %r13
leaq 0x8(%rsp), %r14
movq %rsi, 0x50(%rsp)
movq %rbx, %rdi
callq 0x3380
testl %eax, %eax
jne 0x145af
movq %r13, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
movq %rbx, %rdx
callq 0x33a0
testq %rax, %rax
je 0x145af
movq %rax, %r12
movq %r14, %rbx
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x31b0
movq %r13, %rdi
callq 0x3110
leaq 0x68(%rsp), %rdi
movq %r13, %rbp
movq %r13, %rsi
movq %rax, %rdx
callq 0x32b0
movq %r15, %r13
movq %r15, 0x28(%rsp)
xorl %ecx, %ecx
movq %rcx, 0x30(%rsp)
movb %cl, 0x38(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movb %cl, 0x18(%rsp)
movq %r14, %rdi
leaq 0x28(%rsp), %rsi
callq 0x32f0
movq %rbx, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32f0
movq %rax, %rdi
leaq 0x4(%rsp), %rsi
callq 0x3450
movq %r14, %rdi
leaq 0x33e4(%rip), %rsi      # 0x1790e
callq 0x30c0
testl %eax, %eax
jne 0x1454a
movl 0x4(%rsp), %r15d
movq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x14a22
movl %r15d, (%rax)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x14566
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x28(%rsp), %rdi
movq %r13, %r15
cmpq %r13, %rdi
je 0x14580
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x58(%rsp), %rdi
movq 0xaa14(%rip), %rsi      # 0x1efa0
callq 0x31d0
leaq 0xd8(%rsp), %rdi
callq 0x30e0
testq %r12, %r12
movq %rbp, %r13
movq 0x50(%rsp), %rbx
jne 0x1447b
addq $0x5c8, %rsp            # imm = 0x5C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x145fc
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x145e5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x145fc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0xa99d(%rip), %rsi      # 0x1efa0
leaq 0x58(%rsp), %rdi
callq 0x31d0
leaq 0xd8(%rsp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O1/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 0x146c2
movq 0xa992(%rip), %rdi      # 0x1eff0
leaq 0x3252(%rip), %rsi      # 0x178b7
movl $0x1b, %edx
callq 0x32b0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xa973(%rip), %rdi      # 0x1eff0
callq 0x32b0
movq %rax, %rbx
leaq 0x3247(%rip), %rsi      # 0x178d3
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 0x146d9
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x14314
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_O1/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 0x148e2
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x148e2
movq %rsi, %rbx
leaq 0x20(%rsp), %r12
movq 0xa78f(%rip), %r13      # 0x1efa0
movq %r12, %rdi
callq 0x31b0
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
leaq 0x30(%rsp), %rdi
callq 0x32b0
movq %rax, %rbp
movl $0x3, %edx
movq %rax, %rdi
leaq 0x30a4(%rip), %rsi      # 0x178e1
callq 0x32b0
movl 0x40(%r15), %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 %rbx, %rcx
callq 0x34a0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x148b6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
movq %r12, %rdi
movq %r13, %rsi
callq 0x31d0
leaq 0xa0(%rsp), %rdi
callq 0x30e0
movq %r15, %rdi
callq 0x32c0
movq %rax, %r15
cmpq %r14, %rax
jne 0x14811
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x148f6
movq %rax, %rbx
movq 0xa6a0(%rip), %rsi      # 0x1efa0
leaq 0x20(%rsp), %rdi
callq 0x31d0
leaq 0xa0(%rsp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x149be
movq 0xa696(%rip), %rdi      # 0x1eff0
leaq 0x2f56(%rip), %rsi      # 0x178b7
movl $0x1b, %edx
callq 0x32b0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xa677(%rip), %rdi      # 0x1eff0
callq 0x32b0
movq %rax, %rbx
leaq 0x2f5d(%rip), %rsi      # 0x178e5
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 0x149d1
movq %rsp, %rsi
movq %r14, %rdi
callq 0x1473e
movq %rsp, %rdi
callq 0x3330
movq 0xa5f0(%rip), %rax      # 0x1efc8
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_O1/adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::fileSize(std::basic_ifstream<char, std::char_traits<char>>&)
std::streamoff
fileSize(std::ifstream& file)
{
  std::streamoff curr = file.tellg();

  file.seekg(0, std::ios::end);
  std::streamoff size = file.tellg();
  file.seekg(0, std::ios::beg);
  size -= file.tellg();

  file.seekg(curr, std::ios::beg);
  return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3430
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x3320
movq %rbx, %rdi
callq 0x3430
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3320
movq %rbx, %rdi
callq 0x3430
subq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3320
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::fileSize(std::basic_ofstream<char, std::char_traits<char>>&)
std::streamoff
fileSize(std::ofstream& file)
{
  std::streamoff curr = file.tellp();

  file.seekp(0, std::ios::end);
  std::streamoff size = file.tellp();
  file.seekp(0, std::ios::beg);
  size -= file.tellp();

  file.seekp(curr, std::ios::beg);
  return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3210
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x3250
movq %rbx, %rdi
callq 0x3210
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3250
movq %rbx, %rdi
callq 0x3210
subq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3250
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/adamnovak[P]rlcsa/misc/utils.cpp
// Function: CSA::largeWrite(std::basic_ofstream<char, std::char_traits<char>>&, char*, long, long)
void
largeWrite(std::ofstream& file, char* data, std::streamoff size, std::streamoff block_size)
{
	block_size = std::max(block_size, (std::streamoff)1);
	block_size *= MEGABYTE;

	for(std::streamoff i = 0; i < size; i += block_size)
	{
		file.write(data + i, std::min(size - i, block_size));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x2, %rcx
movl $0x1, %r12d
cmovgeq %rcx, %r12
testq %rdx, %rdx
jle 0x14f80
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
shlq $0x14, %r12
xorl %r13d, %r13d
leaq (%r14,%r13), %rsi
movq %r12, %rbp
subq %rdx, %rbp
cmovlq %r12, %rdx
negq %rbp
movq %r15, %rdi
callq 0x3310
addq %r12, %r13
movq %rbp, %rdx
cmpq %rbx, %r13
jl 0x14f5c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15032
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 0x14ffe
cmpq $0x0, 0x8(%rsp)
je 0x15009
movq %r14, %rdi
movq %r12, %rsi
callq 0x15aba
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1501f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
movq (%r15), %rax
movq -0x18(%rax), %rcx
addq $-0x18, %rax
testb $0x5, 0x20(%r15,%rcx)
je 0x14fc2
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x15059
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa56e(%rip), %rdx      # 0x1f848
callq 0x15af7
leal -0x1(%r14), %eax
leaq 0x8(%rsp), %rsi
movl $0x0, (%rsi)
movl %eax, 0x4(%rsi)
movq %r15, %rdi
callq 0xc6a6
movq %r13, %rdi
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
movl %ebx, %r8d
movl $0x1, %r9d
callq 0x15b35
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15415
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 0x153ec
xorl %r13d, %r13d
movl (%rcx,%r13,8), %edx
movl 0x4(%rcx,%r13,8), %eax
leaq (%rbx,%rdx,8), %rdi
cmpl %eax, %edx
ja 0x153bf
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 0x153ab
movl 0x4(%rcx,%r13,8), %eax
leaq (%r15,%rax,8), %rsi
leaq 0xa479(%rip), %rdx      # 0x1f848
callq 0x15d00
incl %r13d
movq (%r12), %rcx
movq 0x8(%r12), %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq %r13, %rax
ja 0x15393
movq %rbx, %rdi
movq %r14, %rsi
movl 0x4(%rsp), %r13d
movl %r13d, %edx
movq %r12, %rcx
movl (%rsp), %r8d
movq 0x10(%rsp), %r9
callq 0x15b35
addl %ebp, %ebp
testl %eax, %eax
jne 0x15364
testl %r13d, %r13d
je 0x1542f
movl %r13d, %eax
xorl %ecx, %ecx
movl (%r14,%rcx,4), %edx
movl %edx, 0x4(%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1541f
testq %r14, %r14
je 0x1543c
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_O1/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 0x155d9
xorl %ebx, %ebx
jmp 0x156d6
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 0x15637
leaq (%rbx,%r15,8), %rsi
leaq 0xa1f1(%rip), %rdx      # 0x1f847
movq %rbx, %rdi
callq 0x15d7c
movq 0x28(%rsp), %rax
decl %eax
leaq 0x30(%rsp), %rsi
movl $0x0, (%rsi)
movl %eax, 0x4(%rsi)
leaq 0x10(%rsp), %rdi
callq 0xc6a6
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl 0xc(%rsp), %ebp
movl %ebp, %r8d
movl $0x1, %r9d
callq 0x15b35
movl $0x1, (%rsp)
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq 0x28(%rsp), %rcx
movl %ebp, %r8d
movl %eax, %r9d
callq 0x15325
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x156d6
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 0x156ec
jmp 0x156ec
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x15706
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15730
xorl %ebx, %ebx
jmp 0x157bc
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)
xorl %eax, %eax
movl %eax, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x1575e
cmpl $0x1, %ebp
adcl $0x0, %ebp
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %ecx
movl %ebp, %r8d
callq 0x152b1
movl $0x1, (%rsp)
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %ecx
movl %ebp, %r8d
movl %eax, %r9d
callq 0x15325
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x157bc
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 0x157e6
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15a39
movl %esi, %eax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
movq %rsi, %rcx
subq %rdi, %rcx
cmpq $0x9, %rcx
jae 0x15a3b
popq %rbx
retq
testb %al, %al
je 0x15a46
callq 0xc629
jmp 0x15a4b
callq 0x15dba
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x8(%rax), %rdx
movq %rax, %rsi
cmpq %rcx, %rdx
je 0x15aa6
leaq 0xc(%rax), %rdx
movq %rax, %rsi
movl 0x4(%rsi), %edi
leal 0x1(%rdi), %r9d
movl -0x4(%rdx), %r8d
cmpl %r8d, %r9d
jae 0x15a84
movl %r8d, 0x8(%rsi)
movl (%rdx), %edi
movl %edi, 0xc(%rsi)
addq $0x8, %rsi
jmp 0x15a96
leaq 0x4(%rsi), %r8
cmpl %edi, (%rdx)
movq %rdx, %rdi
cmovbq %r8, %rdi
movl (%rdi), %edi
movl %edi, (%r8)
leaq 0x8(%rdx), %rdi
addq $0x4, %rdx
cmpq %rcx, %rdx
movq %rdi, %rdx
jne 0x15a65
subq %rax, %rsi
sarq $0x3, %rsi
incq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x15df8
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16660
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 0x99be
movl $0xa, %ecx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x1215c
movl %eax, %ebx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x98af
callq 0x63f0
testb %bl, %bl
jne 0x98f5
movq 0x29716(%rip), %rbx     # 0x32fd0
leaq 0x17743(%rip), %rsi     # 0x21004
movl $0x10, %edx
movq %rbx, %rdi
callq 0x6450
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6400
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x62d0
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x9914
callq 0x63f0
movq %rbx, %rdi
callq 0x6670
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b8e
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 0x3d51
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_O1/nikolausmayer[P]SimplePlot/./Sparkline.h
// Function: Sparkline::Sparkline(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>>, double, double)
std::string Sparkline( const std::vector<float>& data,
                         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,
                      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 $0x48, %rsp
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movl %r9d, 0x14(%rsp)
movl %r8d, %r14d
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x80(%rsp), %rax
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
callq 0x4b8e
xorps %xmm0, %xmm0
cvtsd2ss 0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsd2ss 0x20(%rsp), %xmm1
movq %rbp, (%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movl %r14d, %r8d
movl 0x14(%rsp), %r9d
callq 0x4999
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x28d2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2903
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ba5(%rip), %rsi      # 0x54c8
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 0x4a7c
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x27d5(%rip), %rdx      # 0x512f
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x4c1e
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 0x4b8e
movabsq $0x8000007f7fffff, %rax # imm = 0x8000007F7FFFFF
movq %rax, 0x78(%rsp)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x29c7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq $0x3, 0x40(%rsp)
movabsq $0x3e19999a00000000, %rax # imm = 0x3E19999A00000000
movq %rax, 0x78(%rsp)
movb $0x1, 0x50(%rsp)
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x26b5(%rip), %rsi      # 0x50a8
leaq 0x26b6(%rip), %rdx      # 0x50b0
callq 0x4c1e
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2100
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2a23
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x40(%rsp), %rdx
movb $0x0, 0x11(%rdx)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ac1
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x2a50
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2a67
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 0x2a97
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2a9a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x2a9a
movq %rax, %rbx
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x2aca
movq 0x68(%rsp), %rsi
jmp 0x2abd
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2aca
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x2aca
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2ae1
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b8e
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 0x3d51
addq $0x10, %rsp
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x4a43
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 0x4a74
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/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&, Sparkline::Configuration<float> const&)
std::string Sparkline( const std::vector<T>& data,
                         const Configuration<T>& config
                       )
  {
    return Sparkline( data,
                      config.this_many_lines_high,
                      config.this_many_characters_wide,
                      config.enclose_in_box,
                      config.print_colored,
                      config.title,
                      config.minv,
                      config.maxv 
                    );
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movq (%rdx), %r12
movq 0x8(%rdx), %r13
movzbl 0x10(%rdx), %ebp
movzbl 0x11(%rdx), %eax
movl %eax, 0xc(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x18(%rdx), %rsi
movq 0x20(%rdx), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x4b8e
movss 0x38(%r14), %xmm0
movss 0x3c(%r14), %xmm1
movq %r15, (%rsp)
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %ebp, %r8d
movl 0xc(%rsp), %r9d
callq 0x4999
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x4b55
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 0x4b86
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280