LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: crtInvec(char*, int, chUTF8**)
double** crtInvec(char* str,int invecdim,ChUTF8* tab){

    int senlen=strLenUTF8(str);
    double** ret = (double**)malloc(sizeof(double*)*senlen);
    int i,j;
    char* point=str;
    char* now;
    ChUTF8 tmp;
    for(i=0;i<senlen;++i){
        ret[i]=(double*)malloc(sizeof(double)*invecdim);
        tmp=hashget(tab,point);
        point+=retLenUTF8(point);
    //    std::cout<< tmp->schar << retLenUTF8(point) <<std::endl;
        if(tmp!=NULL){
            for(j=0;j<invecdim;++j){
                ret[i][j]=tmp->vecftr[j];
            }
        }else{
            now=point;            
            do{
                tmp=hashget(tab,now);
                now+=retLenUTF8(now);
            }while(tmp==NULL);
            printf("pre not found \n %s\n ",point);
            for(j=0;j<invecdim;++j){
                ret[i][j]=tmp->vecftr[j]+ret[i-1][j];
                ret[i][j]/=2.0;
            }
        }
    }

    return ret;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, -0x30(%rbp)
callq 0x4fc2
movslq %eax, %r12
leaq (,%r12,8), %rdi
callq 0x21d0
movslq %r14d, %rbx
leaq (,%rbx,8), %rcx
movq %rcx, -0x48(%rbp)
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
testl %r12d, %r12d
cmovlel %ecx, %r12d
movq %r12, -0x58(%rbp)
movq %rax, %r14
xorl %r12d, %r12d
movq %r15, -0x50(%rbp)
movq %rax, -0x38(%rbp)
cmpq -0x58(%rbp), %r12
je 0x5136
movq -0x48(%rbp), %rdi
callq 0x21d0
movq %rax, %r13
movq %r12, -0x40(%rbp)
movq %rax, (%r14,%r12,8)
movq %r15, %rdi
movq -0x30(%rbp), %r14
movq %r14, %rsi
callq 0x4f67
movq %r15, %r12
movq %rax, %r15
movq %r14, %rdi
callq 0x5257
cltq
addq %rax, %r14
movq %r14, -0x30(%rbp)
testq %r15, %r15
je 0x50bc
xorl %eax, %eax
movq -0x38(%rbp), %r14
movq -0x40(%rbp), %r12
cmpq %rax, %rbx
je 0x512a
movq 0x8(%r15), %rcx
movsd (%rcx,%rax,8), %xmm0
movsd %xmm0, (%r13,%rax,8)
incq %rax
jmp 0x509e
movq %r12, %rdi
movq %r14, %rsi
callq 0x4f67
movq %rax, %r13
movq %r14, %rdi
callq 0x5257
cltq
addq %rax, %r14
testq %r13, %r13
je 0x50bc
leaq 0x110c(%rip), %rdi      # 0x61ef
movq -0x30(%rbp), %rsi
xorl %eax, %eax
callq 0x2030
xorl %eax, %eax
movq -0x38(%rbp), %r14
movsd 0x10d4(%rip), %xmm1     # 0x61d0
movq -0x40(%rbp), %r12
cmpq %rax, %rbx
je 0x512a
movq 0x8(%r13), %rcx
movsd (%rcx,%rax,8), %xmm0
movq -0x8(%r14,%r12,8), %rcx
addsd (%rcx,%rax,8), %xmm0
movq (%r14,%r12,8), %rcx
mulsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rax,8)
incq %rax
jmp 0x5100
incq %r12
movq -0x50(%rbp), %r15
jmp 0x504b
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: upgradeDict(chUTF8**, char*, double**, int, double)
void upgradeDict(ChUTF8* tab,char* str,double** dInvec,int indim,double lnrt){

    int offset,i,j;
    ChUTF8 dicbody;
    char* now=str;
    j=0;
  //  dicbody=hashget(tab,str);
  //  std::cout<< "dic : "<<dicbody->vecftr[0] << " ";
    while(*now!='\0'){
        dicbody=hashget(tab,now);
    //    std::cout<< dicbody->schar <<std::endl;
        offset=retLenUTF8(now);
        now+=offset;
        for(i=0;i<indim;++i){
    //        std::cout<< dicbody->schar<< " ";
    //        std::cout<< dicbody->vecftr[0] << " ";
            dicbody->vecftr[i]-=dInvec[j][i]*lnrt;
        }
        ++j;
    }
 //   dicbody=hashget(tab,str);
 //   std::cout<< dicbody->vecftr[0] << std::endl;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
xorl %r12d, %r12d
testl %ecx, %ecx
cmovlel %r12d, %ebx
movsd %xmm0, -0x38(%rbp)
cmpb $0x0, (%r15)
je 0x51ca
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x4f67
movq %rax, %r13
movq %r15, %rdi
callq 0x5257
movsd -0x38(%rbp), %xmm0
cltq
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x51c2
movq (%r14,%r12,8), %rdx
movq 0x8(%r13), %rsi
movsd (%rsi,%rcx,8), %xmm2
movsd (%rdx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
subsd %xmm1, %xmm2
movsd %xmm2, (%rsi,%rcx,8)
incq %rcx
jmp 0x5199
addq %rax, %r15
incq %r12
jmp 0x5173
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: upDictbyTab(chUTF8**, chUTF8**, int, double)
void upDictbyTab(ChUTF8* tab,ChUTF8* ttab,int indim,double lnrt){

    int i,j;
    ChUTF8 tmp,adj;

    for(i=0;i<32*64*64;++i){
        tmp=ttab[i];
        while(tmp){
            adj=hashget(tab,tmp->schar);
            for(j=0;j<indim;++j){
                adj->vecftr[j]-=tmp->vecftr[j];
            }                      
            tmp=tmp->next;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testl %edx, %edx
cmovlel %r12d, %ebx
cmpq $0x20000, %r12          # imm = 0x20000
je 0x5248
leaq (%r14,%r12,8), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x5243
movq (%r13), %rsi
movq %r15, %rdi
callq 0x4f67
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x523d
movq 0x8(%r13), %rdx
movq 0x8(%rax), %rsi
movsd (%rsi,%rcx,8), %xmm0
subsd (%rdx,%rcx,8), %xmm0
movsd %xmm0, (%rsi,%rcx,8)
incq %rcx
jmp 0x521c
addq $0x10, %r13
jmp 0x5205
incq %r12
jmp 0x51f8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/DictCreate.hpp
// Function: retLenUTF8(char const*)
inline int retLenUTF8(const char* head){
    int ch=(unsigned char)*head;
    if(ch<0xC0)
        return 1;
    else if(ch<0xE0)
        return 2;
    else if(ch<0xF0)
        return 3;
    else if(ch<0xF8)
        return 4;
    else if(ch<0xFC)
        return 5;
    else
        return 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %al
cmpb $-0x40, %al
jae 0x5268
movl $0x1, %eax
jmp 0x5293
cmpb $-0x20, %al
jae 0x5273
movl $0x2, %eax
jmp 0x5293
cmpb $-0x10, %al
jae 0x527e
movl $0x3, %eax
jmp 0x5293
cmpb $-0x8, %al
jae 0x5289
movl $0x4, %eax
jmp 0x5293
cmpb $-0x4, %al
movl $0x6, %eax
sbbl $0x0, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/DictCreate.hpp
// Function: hFuncUTF8(char const*)
inline int hFuncUTF8(const char* head){
    int lenUTF8=retLenUTF8(head);

    if(lenUTF8 < 3){
        int ch=(unsigned char)head[0];
        ch=ch%64;
        return ch*32*64;

    }else{
        int ch1 = (unsigned char)head[0];
        int ch2 = (unsigned char)head[1];
        int ch3 = (unsigned char)head[2];

        int ret,l1,l2,l3;
        l1 = ch1%32;
        l2 = ch2%64;
        l3 = ch3%64;
        ret = l1*64*64+l2*64+l3;
        return ret;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5257
movl %eax, %ecx
movzbl (%rbx), %eax
cmpl $0x2, %ecx
jg 0x52ce
andl $0x3f, %eax
shll $0xb, %eax
jmp 0x52eb
movzbl 0x1(%rbx), %ecx
movzbl 0x2(%rbx), %edx
andl $0x1f, %eax
andl $0x3f, %ecx
andl $0x3f, %edx
shll $0xc, %eax
shll $0x6, %ecx
orl %eax, %ecx
orl %edx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/adamnovak[P]rlcsa/merge_rlcsa.cpp
// Function: getRLCSA(CSA::RLCSABuilder&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double
getRLCSA(RLCSABuilder& builder, const std::string& base_name)
{
  double megabytes = 0.0;

  RLCSA* index = builder.getRLCSA();
  if(index != 0 && index->isOk())
  {
    index->printInfo();
    index->reportSize(true);
    index->writeTo(base_name);
    megabytes = index->getSize() / (double)MEGABYTE;
  }

  delete index;
  return megabytes;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0xa53e
movq %rax, %rbx
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0x47f4
cmpb $0x1, (%rbx)
jne 0x47e5
movq %rbx, %rdi
callq 0x78a8
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x76e4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5fd4
movl 0x4(%rbx), %eax
cvtsi2sd %rax, %xmm0
mulsd 0xf823(%rip), %xmm0     # 0x14008
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x5f1e
jmp 0x47f9
movsd %xmm0, (%rsp)
movl $0x830, %esi            # imm = 0x830
movq %rbx, %rdi
callq 0x3230
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::RLCSABuilder(unsigned int, unsigned int, unsigned int, unsigned int, CSA::RLCSA*)
RLCSABuilder::RLCSABuilder(usint _block_size, usint _sample_rate, usint _buffer_size, usint _threads, RLCSA* _index) :
  block_size(_block_size), sample_rate(_sample_rate), buffer_size(_buffer_size),
  threads(_threads),
  buffer(0)
{
  this->reset();
  this->build_time = this->search_time = this->sort_time = this->merge_time = 0.0;
  
  if(_index != NULL)
  {
    this->setRLCSA(_index);
  }
  
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rdi, %r14
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl %ecx, 0x10(%rdi)
movl %r8d, 0x14(%rdi)
andq $0x0, 0x18(%rdi)
callq 0x9c38
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x28(%r14)
testq %rbx, %rbx
je 0x9c30
movq %rbx, (%r14)
movb (%rbx), %al
andb %al, 0x24(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::reset()
void
RLCSABuilder::reset()
{
  this->index = 0;

  if(this->buffer_size != 0)
  {
    delete[] this->buffer;
    this->buffer = new uchar[this->buffer_size];
  }
  this->chars = 0;

  this->ok = true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andq $0x0, (%rdi)
movl 0x10(%rdi), %eax
testl %eax, %eax
je 0x9c63
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9c58
callq 0x32a0
movl 0x10(%rbx), %eax
movl %eax, %edi
callq 0x3030
movq %rax, 0x18(%rbx)
andl $0x0, 0x20(%rbx)
movb $0x1, 0x24(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::insertSequence(char*, unsigned int, bool)
void
RLCSABuilder::insertSequence(char* sequence, usint length, bool delete_sequence)
{
  if(sequence == 0 || length == 0 || !this->ok)
  {
    if(delete_sequence) { delete[] sequence; }
    return;
  }

  #ifdef MULTITHREAD_SUPPORT
  omp_set_num_threads(this->threads);
  #endif

  if(this->buffer == 0)
  {
    this->addLongSequence((uchar*)sequence, length, delete_sequence);
    return;
  }

  if(this->buffer_size - this->chars > length)
  {
    memcpy(this->buffer + this->chars, sequence, length);
    if(delete_sequence) { delete[] sequence; }
    this->chars += length;
    this->buffer[this->chars] = 0;
    this->chars++;
  }
  else
  {
    if(this->chars > 0) { this->flush(); }
    if(length >= this->buffer_size - 1)
    {
      this->addLongSequence((uchar*)sequence, length, delete_sequence);
    }
    else
    {
      memcpy(this->buffer + this->chars, sequence, length);
      if(delete_sequence) { delete[] sequence; }
      this->chars += length;
      this->buffer[this->chars] = 0;
      this->chars++;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %r15
testq %rsi, %rsi
sete %al
testl %edx, %edx
sete %cl
orb %al, %cl
jne 0x9cfe
movq %rdi, %r14
cmpb $0x0, 0x24(%rdi)
je 0x9cfe
movl %edx, %ebx
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x9d74
movl 0x10(%r14), %eax
movl 0x20(%r14), %ecx
movl %eax, %edx
subl %ecx, %edx
cmpl %ebx, %edx
jbe 0x9d1f
addq %rcx, %rdi
jmp 0x9d3e
testq %r15, %r15
sete %al
xorb $0x1, %bpl
orb %al, %bpl
jne 0x9d69
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x32a0
testq %rcx, %rcx
je 0x9d30
movq %r14, %rdi
callq 0x9e2c
movl 0x10(%r14), %eax
decl %eax
cmpl %ebx, %eax
jbe 0x9d74
movl 0x20(%r14), %edi
addq 0x18(%r14), %rdi
movl %ebx, %edx
movq %r15, %rsi
callq 0x31c0
testb %bpl, %bpl
je 0x9d55
movq %r15, %rdi
callq 0x32a0
addl 0x20(%r14), %ebx
movl %ebx, 0x20(%r14)
movq 0x18(%r14), %rax
movb $0x0, (%rax,%rbx)
incl 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %ecx
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9d90
nop
// File: /workspace/github_cpp_makefile_star2_O2/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::addLongSequence(unsigned char*, unsigned int, bool)
void
RLCSABuilder::addLongSequence(uchar* sequence, usint length, bool delete_sequence)
{
  double start = readTimer();
  RLCSA* temp = new RLCSA(sequence, length, this->block_size, this->sample_rate, this->threads, 0, false);
  this->build_time += readTimer() - start;
  this->addRLCSA(temp, sequence, length, delete_sequence); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x11ef8
movsd %xmm0, 0x8(%rsp)
movl $0x830, %edi            # imm = 0x830
callq 0x3220
movq %rax, %r12
movl 0x8(%r15), %ecx
movl 0xc(%r15), %r8d
movl 0x14(%r15), %r9d
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
pushq $0x0
pushq $0x0
callq 0x588e
popq %rax
popq %rcx
callq 0x11ef8
subsd 0x8(%rsp), %xmm0
addsd 0x28(%r15), %xmm0
movsd %xmm0, 0x28(%r15)
movzbl %bpl, %r8d
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9fc8
movq %rax, %rbx
movl $0x830, %esi            # imm = 0x830
movq %r12, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O2/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::flush()
void
RLCSABuilder::flush()
{
  if(this->buffer == 0 || this->chars == 0) { return; }

  double start = readTimer();
  RLCSA* temp = new RLCSA(this->buffer, this->chars, this->block_size, this->sample_rate, this->threads, (this->index == 0));
  this->build_time += readTimer() - start;
  this->addRLCSA(temp, this->buffer, this->chars, (this->index != 0));

  this->chars = 0;
  this->buffer = new uchar[this->buffer_size];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0x18(%rdi)
je 0x9ecb
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
je 0x9ecb
callq 0x11ef8
movsd %xmm0, 0x10(%rsp)
movl $0x830, %edi            # imm = 0x830
callq 0x3220
movq %rax, %r14
movq 0x18(%rbx), %rsi
movl 0x20(%rbx), %edx
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %r8d
movl 0x14(%rbx), %r9d
xorl %eax, %eax
cmpq $0x0, (%rbx)
sete %al
movl %eax, (%rsp)
movq %r14, %rdi
callq 0x509a
callq 0x11ef8
subsd 0x10(%rsp), %xmm0
addsd 0x28(%rbx), %xmm0
movsd %xmm0, 0x28(%rbx)
movq 0x18(%rbx), %rdx
movl 0x20(%rbx), %ecx
xorl %r8d, %r8d
cmpq $0x0, (%rbx)
setne %r8b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9fc8
andl $0x0, 0x20(%rbx)
movl 0x10(%rbx), %edi
callq 0x3030
movq %rax, 0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x830, %esi            # imm = 0x830
movq %r14, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O2/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::insertFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void
RLCSABuilder::insertFromFile(const std::string& base_name)
{
  if(!this->ok) { return; }

  #ifdef MULTITHREAD_SUPPORT
  omp_set_num_threads(this->threads);
  #endif

  this->flush();

  std::ifstream input(base_name.c_str(), std::ios_base::binary);
  if(!input) { return; }
  RLCSA* increment = new RLCSA(base_name);
  usint data_size = increment->getSize() + increment->getNumberOfSequences();
  uchar* data = new uchar[data_size];
  input.read((char*)data, data_size);
  input.close();

  this->addRLCSA(increment, data, data_size, true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
cmpb $0x1, 0x24(%rdi)
jne 0x9f91
movq %rsi, %r15
movq %rdi, %rbx
callq 0x9e2c
movq (%r15), %rsi
movq %rsp, %r14
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x3420
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x9f89
movl $0x830, %edi            # imm = 0x830
callq 0x3220
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x4c9c
movl 0x820(%r14), %r15d
addl 0x4(%r14), %r15d
movq %r15, %rdi
callq 0x3030
movq %rax, %r12
movq %rsp, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x3280
movq %rsp, %rdi
callq 0x3080
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x9fc8
movq %rsp, %rdi
callq 0x3090
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x830, %esi            # imm = 0x830
movq %r14, %rdi
callq 0x3230
jmp 0x9fb7
jmp 0x9fb4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O2/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::addRLCSA(CSA::RLCSA*, unsigned char*, unsigned int, bool)
void
RLCSABuilder::addRLCSA(RLCSA* increment, uchar* sequence, usint length, bool delete_sequence)
{
  if(this->index == 0)
  {
    if(delete_sequence) { delete[] sequence; }
    this->setRLCSA(increment);
    return;
  }

  std::vector<usint> end_markers;
  usint* ranks = this->getRanks(sequence, length, end_markers);
  if(delete_sequence) { delete[] sequence; }

  double mark = readTimer();
  parallelSort(ranks, ranks + length);
  #pragma omp parallel for schedule(static)
  for(usint i = 0; i < length; i++) { ranks[i] += i + 1; }
  this->sort_time += readTimer() - mark;

  this->mergeRLCSA(increment, ranks, length);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r13d
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0xa08a
movl %ecx, %ebp
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movapd %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0xa3ae
movq %rax, %r15
testq %r12, %r12
sete %al
xorb $0x1, %r13b
orb %al, %r13b
jne 0xa027
movq %r12, %rdi
callq 0x32a0
callq 0x11ef8
movsd %xmm0, 0x8(%rsp)
movl %ebp, %r12d
leaq (%r15,%r12,4), %rsi
movq %r15, %rdi
callq 0xa5e6
xorl %eax, %eax
cmpq %rax, %r12
je 0xa059
movl (%r15,%rax,4), %ecx
addl %eax, %ecx
incl %ecx
movl %ecx, (%r15,%rax,4)
incq %rax
jmp 0xa043
callq 0x11ef8
subsd 0x8(%rsp), %xmm0
addsd 0x38(%r14), %xmm0
movsd %xmm0, 0x38(%r14)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xa47a
leaq 0x10(%rsp), %rdi
callq 0xa5c8
jmp 0xa0aa
testq %r12, %r12
sete %al
xorb $0x1, %r13b
orb %al, %r13b
jne 0xa0a1
movq %r12, %rdi
callq 0x32a0
movq %rbx, (%r14)
movb (%rbx), %al
andb %al, 0x24(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa0bb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa5c8
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O2/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::addCollection(unsigned char*, unsigned int, bool)
void
RLCSABuilder::addCollection(uchar* sequence, usint length, bool delete_sequence)
{
  double start = readTimer();
  RLCSA* temp = new RLCSA(sequence, length, this->block_size, this->sample_rate, this->threads, delete_sequence);
  this->build_time += readTimer() - start;
  this->setRLCSA(temp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
callq 0x11ef8
movsd %xmm0, 0x8(%rsp)
movl $0x830, %edi            # imm = 0x830
callq 0x3220
movq %rax, %r14
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %r8d
movl 0x14(%rbx), %r9d
movl %ebp, (%rsp)
movq %rax, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x509a
callq 0x11ef8
subsd 0x8(%rsp), %xmm0
addsd 0x28(%rbx), %xmm0
movsd %xmm0, 0x28(%rbx)
movq %r14, (%rbx)
movb (%r14), %al
andb %al, 0x24(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x830, %esi            # imm = 0x830
movq %r14, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O2/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::getRanks(unsigned char*, unsigned int, std::vector<unsigned int, std::allocator<unsigned int>>&)
usint*
RLCSABuilder::getRanks(uchar* sequence, usint length, std::vector<usint>& end_markers)
{
  double start = readTimer();

  usint sequences = 0;
  for(usint i = 0; i < length; i++)
  {
    if(sequence[i] == 0) { end_markers.push_back(i); sequences++; }
  }

  usint* ranks = new usint[length];
  #ifdef MULTITHREAD_SUPPORT
  usint chunk = std::max((usint)1, sequences / (8 * this->threads));
  #endif
  #pragma omp parallel for schedule(dynamic, chunk)
  for(usint i = 0; i < sequences; i++)
  {
    usint begin = (i > 0 ? end_markers[i - 1] + 1 : 0);
    this->index->reportPositions(sequence + begin, end_markers[i] - begin, ranks + begin);
  }

  this->index->strip();

  this->search_time += readTimer() - start;
  return ranks;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x11ef8
movsd %xmm0, 0x10(%rsp)
xorl %eax, %eax
leaq 0xc(%rsp), %r12
xorl %r13d, %r13d
movl %eax, 0xc(%rsp)
cmpl %ebp, %eax
jae 0xa403
movl %eax, %ecx
cmpb $0x0, (%r15,%rcx)
jne 0xa3ff
movq %r14, %rdi
movq %r12, %rsi
callq 0x8b46
incl %r13d
movl 0xc(%rsp), %eax
incl %eax
jmp 0xa3dc
movl %ebp, %edi
shlq $0x2, %rdi
callq 0x3030
movq %rax, %r12
movl %r13d, %r13d
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0xa44a
movq (%r14), %rax
testq %rbp, %rbp
je 0xa42b
movl -0x4(%rax,%rbp,4), %ecx
incl %ecx
jmp 0xa42d
xorl %ecx, %ecx
movq (%rbx), %rdi
movl %ecx, %r8d
leaq (%r15,%r8), %rsi
movl (%rax,%rbp,4), %edx
subl %ecx, %edx
leaq (%r12,%r8,4), %rcx
callq 0x646c
incq %rbp
jmp 0xa416
movq (%rbx), %rdi
callq 0x5c48
callq 0x11ef8
subsd 0x10(%rsp), %xmm0
addsd 0x30(%rbx), %xmm0
movsd %xmm0, 0x30(%rbx)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::mergeRLCSA(CSA::RLCSA*, unsigned int*, unsigned int)
void
RLCSABuilder::mergeRLCSA(RLCSA* increment, usint* ranks, usint length)
{
  double mark = readTimer();

  RLCSA* merged = new RLCSA(*(this->index), *increment, ranks, this->block_size, this->threads);
  delete[] ranks;
  delete this->index;
  delete increment;
  this->index = merged;

  this->merge_time += readTimer() - mark;

  this->ok &= this->index->isOk();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x11ef8
movsd %xmm0, (%rsp)
movl $0x830, %edi            # imm = 0x830
callq 0x3220
movq %rax, %r15
movq (%rbx), %rsi
movl 0x8(%rbx), %r8d
movl 0x14(%rbx), %r9d
movq %rax, %rdi
movq %r14, %rdx
movq %r12, %rcx
callq 0x59c8
testq %r12, %r12
je 0xa4c8
movq %r12, %rdi
callq 0x32a0
movq (%rbx), %r12
testq %r12, %r12
je 0xa4d8
movq %r12, %rdi
callq 0x5f1e
movl $0x830, %esi            # imm = 0x830
movq %r12, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x5f1e
movl $0x830, %esi            # imm = 0x830
movq %r14, %rdi
callq 0x3230
movq %r15, (%rbx)
callq 0x11ef8
subsd (%rsp), %xmm0
addsd 0x40(%rbx), %xmm0
movsd %xmm0, 0x40(%rbx)
movq (%rbx), %rax
movb (%rax), %al
andb %al, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x830, %esi            # imm = 0x830
movq %r15, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O2/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::getRLCSA()
RLCSA*
RLCSABuilder::getRLCSA()
{
  if(this->chars > 0) { this->flush(); }

  RLCSA* temp = this->index;
  this->reset();

  return temp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
je 0xa553
movq %rbx, %rdi
callq 0x9e2c
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x9c38
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/adamnovak[P]rlcsa/rlcsa_builder.cpp
// Function: CSA::RLCSABuilder::getBWT(unsigned int&)
char*
RLCSABuilder::getBWT(usint& length)
{
  this->flush();

  if(this->index == 0 || !(this->ok))
  {
    length = 0;
    return 0;
  }

  length = this->index->getSize() + this->index->getNumberOfSequences();
  return (char*)(this->index->readBWT());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x9e2c
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa59f
cmpb $0x0, 0x24(%r14)
je 0xa59f
movl 0x820(%rdi), %eax
addl 0x4(%rdi), %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x74dc
andl $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/variadic.cc
// Function: main
int main()
{
	Sales_data item("978-0590353403", 25, 15.99);
	string fcnName("itemProcess");
	ErrorCode code(42);
	string otherData("invalid ISBN");

	errorMsg(cerr, fcnName, code.num(), otherData, "other", item);
	cerr << endl;

	print(cerr, debug_rep(fcnName), debug_rep(code.num()),
	            debug_rep(otherData), debug_rep("otherData"),
	            debug_rep(item));
	cerr << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
leaq 0x1a8b(%rip), %rsi      # 0x401d
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x2080
leaq -0x98(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x21b0
movl $0x19, -0x78(%rbp)
movabsq $0x4078fc0000000000, %rax # imm = 0x4078FC0000000000
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20a0
leaq 0x1a58(%rip), %rsi      # 0x402c
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x2080
leaq 0x1a50(%rip), %rsi      # 0x4038
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x2080
leaq -0x68(%rbp), %rdx
movq $0x2a, (%rdx)
movq 0x39e9(%rip), %rdi      # 0x5ff0
leaq 0x1a37(%rip), %r8       # 0x4045
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rcx
leaq -0x98(%rbp), %r9
callq 0x28f6
movq 0x39c7(%rip), %rdi      # 0x5ff0
callq 0x20b0
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x247c
leaq -0x100(%rbp), %rsi
movq $0x2a, (%rsi)
leaq -0x120(%rbp), %rdi
callq 0x2a76
leaq -0xf8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x247c
leaq 0x19df(%rip), %rsi      # 0x404b
leaq -0xd8(%rbp), %rdi
callq 0x252d
leaq -0xb8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2ae9
movq 0x395e(%rip), %rdi      # 0x5ff0
leaq -0x68(%rbp), %rsi
leaq -0x120(%rbp), %rdx
leaq -0xf8(%rbp), %rcx
leaq -0xd8(%rbp), %r8
leaq -0xb8(%rbp), %r9
callq 0x2a23
leaq -0xb8(%rbp), %rdi
callq 0x20a0
leaq -0xd8(%rbp), %rdi
callq 0x20a0
leaq -0xf8(%rbp), %rdi
callq 0x20a0
leaq -0x120(%rbp), %rdi
callq 0x20a0
leaq -0x68(%rbp), %rdi
callq 0x20a0
movq 0x38f9(%rip), %rdi      # 0x5ff0
callq 0x20b0
leaq -0x48(%rbp), %rdi
callq 0x20a0
leaq -0x28(%rbp), %rdi
callq 0x20a0
leaq -0x98(%rbp), %rdi
callq 0x20a0
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x20a0
jmp 0x273a
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
callq 0x20a0
jmp 0x274b
movq %rax, %rbx
leaq -0xf8(%rbp), %rdi
callq 0x20a0
jmp 0x275c
movq %rax, %rbx
leaq -0x120(%rbp), %rdi
callq 0x20a0
jmp 0x276d
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x20a0
jmp 0x2797
jmp 0x2794
jmp 0x2794
movq %rax, %rbx
jmp 0x27a0
movq %rax, %rbx
jmp 0x27a9
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
jmp 0x27b0
movq %rax, %rbx
jmp 0x27b5
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20a0
leaq -0x28(%rbp), %rdi
callq 0x20a0
leaq -0x98(%rbp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/ArthoPacini[P]blockchaincpp/./timestamp_as_string.hpp
// Function: getTimestampAsString[abi:cxx11](std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>)
std::string getTimestampAsString(std::chrono::time_point<std::chrono::system_clock> chrono_inputTime)
{
    std::time_t inputTime = std::chrono::system_clock::to_time_t(chrono_inputTime);
    std::ostringstream os;
    os << std::put_time(std::localtime(&inputTime), "%c");
    return os.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %rax
movq %rdi, %rbx
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
cqto
idivq %rcx
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x4430
movq %r14, %rdi
callq 0x42d0
leaq 0x10ba8(%rip), %rdx     # 0x15821
movq %r15, %rdi
movq %rax, %rsi
callq 0x52ed
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
leaq 0x8(%rsp), %rdi
callq 0x40b0
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40b0
movq %rbx, %rdi
callq 0x4570
// File: /workspace/github_cpp_makefile_star2_O2/ArthoPacini[P]blockchaincpp/./Blockchain.hpp
// Function: Blockchain::push_transaction(Transaction)
void push_transaction(Transaction transaction)
    {
        if(chain.back().push_transaction(transaction))    
            return;

        chain.back().mine(difficulty);
        chain.push_back({chain.size(), chain.back().calculateHash(), difficulty, maxTransactionsCount, transaction});
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
movq $-0xb0, %r15
addq 0x10(%rdi), %r15
leaq 0x90(%rsp), %r12
movq %r12, %rdi
callq 0x6422
movq %r15, %rdi
movq %r12, %rsi
callq 0x670e
movl %eax, %ebp
leaq 0x90(%rsp), %rdi
callq 0x56cc
testb %bpl, %bpl
jne 0x55c3
movq $-0xb0, %r15
movq 0x10(%rbx), %rdi
addq %r15, %rdi
movl (%rbx), %esi
callq 0x6748
movq 0x8(%rbx), %r13
movq 0x10(%rbx), %r12
addq %r12, %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x68a6
movl (%rbx), %ebp
movl 0x4(%rbx), %r15d
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x6422
subq %r13, %r12
movl $0xb0, %ecx
movq %r12, %rax
cqto
idivq %rcx
leaq 0xf8(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %r9
movq %rax, %rsi
movl %ebp, %ecx
movl %r15d, %r8d
callq 0x61a0
addq $0x8, %rbx
leaq 0xf8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5f16
leaq 0xf8(%rsp), %rdi
callq 0x5ebc
leaq 0x28(%rsp), %rdi
callq 0x56cc
leaq 0x8(%rsp), %rdi
callq 0x41a0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0x5ebc
jmp 0x55ea
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x56cc
jmp 0x55f9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x41a0
jmp 0x5615
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x56cc
movq %rbx, %rdi
callq 0x4570
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArthoPacini[P]blockchaincpp/./Blockchain.hpp
// Function: Blockchain::save(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, short)
void save(const std::string output_filename = "blockchain.json", const std::int16_t indent = 4)
    {
        std::filesystem::path output_path = std::filesystem::path(std::filesystem::current_path() / "blockchain" / output_filename);

        if(!std::filesystem::exists(output_path.parent_path()))
            std::filesystem::create_directories(output_path.parent_path());

        std::ofstream output_file(output_path);
        output_file << dump();
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x44d0
leaq 0x124ec(%rip), %rsi     # 0x17ebe
leaq 0x78(%rsp), %rdi
pushq $0x2
popq %rdx
callq 0xcf24
leaq 0xa0(%rsp), %rdi
movq %rsp, %rsi
leaq 0x78(%rsp), %rdx
callq 0xceeb
leaq 0x50(%rsp), %rdi
pushq $0x2
popq %rdx
movq %r14, %rsi
callq 0xcf90
leaq 0x28(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xceeb
leaq 0x50(%rsp), %rdi
callq 0xcff8
leaq 0xa0(%rsp), %rdi
callq 0xcff8
leaq 0x78(%rsp), %rdi
callq 0xcff8
movq %rsp, %rdi
callq 0xcff8
leaq 0xa0(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x45c0
leaq 0xa0(%rsp), %rdi
callq 0xd00e
movl %eax, %ebp
leaq 0xa0(%rsp), %rdi
callq 0xcff8
testb %bpl, %bpl
jne 0x5aa3
leaq 0xa0(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x45c0
leaq 0xa0(%rsp), %rdi
callq 0x4280
leaq 0xa0(%rsp), %rdi
callq 0xcff8
movq 0x28(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x43c0
movq %rsp, %rdi
pushq $0x4
popq %rdx
movq %rbx, %rsi
callq 0x56f0
leaq 0xa0(%rsp), %rdi
movq %rsp, %rsi
callq 0x4350
movq %rsp, %rdi
callq 0x41a0
leaq 0xa0(%rsp), %rdi
callq 0x44a0
leaq 0x28(%rsp), %rdi
callq 0xcff8
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x5b26
jmp 0x5b38
movq %rax, %rbx
movq %rsp, %rdi
callq 0x41a0
jmp 0x5b15
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x44a0
jmp 0x5b3b
jmp 0x5b38
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0xcff8
jmp 0x5b3b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x5b78
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xcff8
jmp 0x5b54
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0xcff8
jmp 0x5b66
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xcff8
jmp 0x5b75
movq %rax, %rbx
movq %rsp, %rdi
callq 0xcff8
movq %rbx, %rdi
callq 0x4570
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArthoPacini[P]blockchaincpp/./Blockchain.hpp
// Function: Blockchain::validate()
bool validate() 
    {
        std::vector<Block>::iterator it;
        for(it = chain.begin(); it != chain.end(); ++it)
        {
            Block & currentBlock = *it;
            if(it == (chain.end() - 1))
                continue;

            if(!currentBlock.validate())
                {
                    std::cout << "Block " << currentBlock << " is invalid\n";
                    return false;
                }

            if(chain.size() > 1 && it != chain.begin())
            {
                Block previousBlock = *(it-1);
                if(currentBlock.previousHash() != previousBlock.calculateHash())
                {
                    std::cout << "Block " << currentBlock << " is invalid\n";
                    return false;
                }
            }
            
        }

        return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rbx
movl $0xb0, %ebp
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
movq 0x10(%r14), %r15
cmpq %r15, %rbx
je 0x5cc3
leaq -0xb0(%r15), %rax
cmpq %rax, %rbx
je 0x5c51
movq %rbx, %rdi
callq 0xd13c
testb %al, %al
je 0x5c5d
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
subq %rcx, %rax
cqto
idivq %rbp
cmpq %rcx, %rbx
je 0x5c51
cmpq $0x2, %rax
jb 0x5c51
leaq -0xb0(%rbx), %rsi
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
callq 0xd17e
leaq 0x28(%rbx), %rsi
movq %r12, %rdi
callq 0x4450
movq %r13, %rdi
movq %rbp, %rsi
callq 0x68a6
movq %r12, %rdi
movq %r13, %rsi
callq 0xd23e
movl %eax, %ebp
movq %r13, %rdi
callq 0x41a0
movq %r12, %rdi
callq 0x41a0
testb %bpl, %bpl
jne 0x5c8c
leaq 0x48(%rsp), %rdi
callq 0x5ebc
movl $0xb0, %ebp
addq $0xb0, %rbx
jmp 0x5bad
movq 0x1f36c(%rip), %rdi     # 0x24fd0
leaq 0xfc67(%rip), %rsi      # 0x158d2
callq 0x4370
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd176
leaq 0x12247(%rip), %rsi     # 0x17ec9
movq %rax, %rdi
callq 0x4370
jmp 0x5cc3
movq 0x1f33d(%rip), %rdi     # 0x24fd0
leaq 0xfc38(%rip), %rsi      # 0x158d2
callq 0x4370
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd176
leaq 0x12218(%rip), %rsi     # 0x17ec9
movq %rax, %rdi
callq 0x4370
leaq 0x48(%rsp), %rdi
callq 0x5ebc
cmpq %r15, %rbx
sete %al
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5cec
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x41a0
jmp 0x5cef
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5ebc
movq %rbx, %rdi
callq 0x4570
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArthoPacini[P]blockchaincpp/./Block.hpp
// Function: Block::Block(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int, unsigned int, Transaction)
Block(std::uint64_t index, std::string previousBlockHash, std::uint32_t difficulty, std::uint32_t maxTransactionsCount, Transaction transaction)
    {
        this->index = index;
        this->previousBlockHash = previousBlockHash;
        this->difficulty = difficulty;
        this->maxTransactionsCount = maxTransactionsCount;
        transactions.push_back(transaction);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, 0x10(%rsp)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
andq $0x0, 0x48(%rdi)
movl $0x3, 0x50(%rdi)
leaq 0x58(%rdi), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rdi)
andq $0x0, 0x68(%rdi)
addq $0x70, %rdi
leaq 0x110f2(%rip), %rsi     # 0x1730b
leaq 0x7(%rsp), %rdx
movq %rdi, 0x18(%rsp)
callq 0x52b2
leaq 0x90(%rbx), %r12
leaq 0xf64a(%rip), %rsi      # 0x15880
leaq 0x6(%rsp), %rdx
movq %r12, %rdi
callq 0x52b2
movq %r13, (%rbx)
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x4210
movl %r14d, 0x54(%rbx)
movl %ebp, 0x50(%rbx)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x62c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x628d
movq %rax, %r14
jmp 0x6297
movq %rax, %r14
movq %r12, %rdi
callq 0x41a0
movq 0x18(%rsp), %rdi
callq 0x41a0
addq $0x8, %rbx
movq 0x8(%rsp), %rdi
callq 0x62ec
movq 0x10(%rsp), %rdi
callq 0x41a0
movq %rbx, %rdi
callq 0x41a0
movq %r14, %rdi
callq 0x4570
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArthoPacini[P]blockchaincpp/./Block.hpp
// Function: Block::mine(unsigned int)
void mine(std::uint32_t difficulty = 1)
    {
        std::cout << "Starting mining of block " << index << '\n';
        const auto miningStartTime = std::chrono::system_clock::now();

        do
        {
            ++nounce;
            blockHash = calculateHash();
        } while (!std::all_of(blockHash.begin(), blockHash.begin() + difficulty, [](char & a){
                return a == '0';
            }));

        minedAt = getTimestampAsString(std::chrono::system_clock::now());
        std::cout << "Block "<< index << " mined, nounce " << nounce << ", hash: " << blockHash << '\n'; 
        std::cout << "Took " << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - miningStartTime).count() << " milliseconds to mine block\n";
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %r14
movq 0x1e86e(%rip), %rdi     # 0x24fd0
leaq 0xf14f(%rip), %rsi      # 0x158b8
callq 0x4370
movq (%r14), %rsi
movq %rax, %rdi
callq 0x4290
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x43f0
callq 0x4050
movq %rax, %rbx
leaq 0x8(%r14), %r15
movl %ebp, %r13d
leaq 0x8(%rsp), %r12
incq 0x48(%r14)
movq %r12, %rdi
movq %r14, %rsi
callq 0x68a6
movq %r15, %rdi
movq %r12, %rsi
callq 0x4400
movq %r12, %rdi
callq 0x41a0
movq 0x8(%r14), %rdi
leaq (%rdi,%r13), %rsi
callq 0x69d0
testb %al, %al
je 0x6798
callq 0x4050
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x4c3b
leaq 0x90(%r14), %rdi
movq %r12, %rsi
callq 0x4400
movq %r12, %rdi
callq 0x41a0
movq 0x1e7d2(%rip), %r12     # 0x24fd0
leaq 0xf0cd(%rip), %rsi      # 0x158d2
movq %r12, %rdi
callq 0x4370
movq (%r14), %rsi
movq %rax, %rdi
callq 0x4290
leaq 0xf0ba(%rip), %rsi      # 0x158d9
movq %rax, %rdi
callq 0x4370
movq 0x48(%r14), %rsi
movq %rax, %rdi
callq 0x4290
leaq 0xf0af(%rip), %rsi      # 0x158e9
movq %rax, %rdi
callq 0x4370
movq %rax, %rdi
movq %r15, %rsi
callq 0x4350
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x43f0
leaq 0xf093(%rip), %rsi      # 0x158f2
movq %r12, %rdi
callq 0x4370
movq %rax, %r14
callq 0x4050
subq %rbx, %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %r14, %rdi
movq %rax, %rsi
callq 0x4360
leaq 0xf06a(%rip), %rsi      # 0x158f8
movq %rax, %rdi
callq 0x4370
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArthoPacini[P]blockchaincpp/./Block.hpp
// Function: Block::calculateHash[abi:cxx11]()
std::string calculateHash() 
    {
        transactionsHashesSum.clear();

        std::for_each(transactions.begin(), transactions.end(), [&](Transaction & transaction){
            transactionsHashesSum = sha256(transactionsHashesSum + transaction.getHash());
        });

        return sha256(transactionsHashesSum + previousBlockHash + std::to_string(index) + std::to_string(nounce));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x70(%rsi), %r15
andq $0x0, 0x78(%rsi)
movq 0x70(%rsi), %rax
movb $0x0, (%rax)
movq 0x58(%rsi), %rdi
movq 0x60(%rsi), %rsi
movq %r14, %rdx
callq 0x6a63
leaq 0x28(%r14), %rdx
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x6b06
movq (%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x6b3e
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x6a9f
movq 0x48(%r14), %rsi
movq %rsp, %rdi
callq 0x6b3e
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq %rsp, %rdx
callq 0x6a9f
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ad9
leaq 0x80(%rsp), %rdi
callq 0x41a0
movq %rsp, %rdi
callq 0x41a0
leaq 0x60(%rsp), %rdi
callq 0x41a0
leaq 0x20(%rsp), %rdi
callq 0x41a0
leaq 0x40(%rsp), %rdi
callq 0x41a0
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x41a0
jmp 0x6993
movq %rax, %rbx
movq %rsp, %rdi
callq 0x41a0
jmp 0x69a0
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x41a0
jmp 0x69af
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x41a0
jmp 0x69be
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x41a0
movq %rbx, %rdi
callq 0x4570
// File: /workspace/github_cpp_makefile_star2_O2/ArthoPacini[P]blockchaincpp/./nlohmann/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::push_back(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const&)
void push_back(const basic_json& val)
    {
        // push_back only works for null objects or arrays
        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
        {
            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
        }

        // transform null object into an array
        if (is_null())
        {
            m_type = value_t::array;
            m_value = value_t::array;
            assert_invariant();
        }

        // add element to array
        m_value.array->push_back(val);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0x9b32
movb $0x2, (%r14)
callq 0x8320
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x7766
jmp 0x9b37
cmpl $0x2, %eax
jne 0x9b4b
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xaac2
pushq $0x20
popq %rdi
callq 0x41d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x7fbe
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x52b2
leaq 0xd422(%rip), %rsi      # 0x16f99
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x7f9a
movb $0x1, %bpl
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movl $0x134, %esi            # imm = 0x134
callq 0x7ba2
xorl %ebp, %ebp
leaq 0x1aff4(%rip), %rsi     # 0x24b98
leaq 0x63bf(%rip), %rdx      # 0xff6a
movq %rbx, %rdi
callq 0x4560
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x41a0
jmp 0x9bc8
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x41a0
testb %bpl, %bpl
jne 0x9bdc
jmp 0x9be4
movq %rax, %r14
movq %rbx, %rdi
callq 0x42c0
movq %r14, %rdi
callq 0x4570
// File: /workspace/github_cpp_makefile_star2_O2/ArthoPacini[P]blockchaincpp/./nlohmann/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::push_back(std::initializer_list<nlohmann::detail::json_ref<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>>)
void push_back(initializer_list_t init)
    {
        if (is_object() && init.size() == 2 && (*init.begin())->is_string())
        {
            basic_json&& key = init.begin()->moved_or_copied();
            push_back(typename object_t::value_type(
                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
        }
        else
        {
            push_back(basic_json(init));
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rdi)
sete %al
cmpq $0x2, %rdx
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xa2c3
movq 0x10(%r14), %rax
cmpb $0x3, (%rax)
jne 0xa2c3
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x85b4
movq %r15, %rdi
callq 0xa5ce
movq %rax, %r15
addq $0x20, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x85b4
leaq 0x20(%rsp), %r14
movq %rsp, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x8f4a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa35a
leaq 0x20(%rsp), %rdi
callq 0x899c
movq %rsp, %rdi
callq 0x7048
leaq 0x10(%rsp), %rdi
jmp 0xa2ea
leaq 0x20(%rsp), %r15
pushq $0x1
popq %rcx
pushq $0x2
popq %r8
movq %r15, %rdi
movq %r14, %rsi
callq 0x6f34
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa440
leaq 0x20(%rsp), %rdi
callq 0x7048
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x899c
movq %rsp, %rdi
callq 0x7048
jmp 0xa315
jmp 0xa312
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0xa324
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7048
movq %rbx, %rdi
callq 0x4570
nop