LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: pcache1Destroy
static void pcache1Destroy(sqlite3_pcache *p){
  PCache1 *pCache = (PCache1 *)p;
  PGroup *pGroup = pCache->pGroup;
  assert( pCache->bPurgeable || (pCache->nMax==0 && pCache->nMin==0) );
  pcache1EnterMutex(pGroup);
  pcache1TruncateUnsafe(pCache, 0);
  assert( pGroup->nMaxPage >= pCache->nMax );
  pGroup->nMaxPage -= pCache->nMax;
  assert( pGroup->nMinPage >= pCache->nMin );
  pGroup->nMinPage -= pCache->nMin;
  pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
  pcache1EnforceMaxPage(pGroup);
  pcache1LeaveMutex(pGroup);
  sqlite3_free(pCache->apHash);
  sqlite3_free(pCache);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
xorl %esi, %esi
callq 0x5b766
movl 0x8(%r14), %eax
subl 0x18(%rbx), %eax
movl 0xc(%r14), %ecx
movl %eax, 0x8(%r14)
subl 0x14(%rbx), %ecx
movl %ecx, 0xc(%r14)
subl %ecx, %eax
addl $0xa, %eax
movl %eax, 0x10(%r14)
movq %r14, %rdi
callq 0x5b63d
movq 0x30(%rbx), %rdi
callq 0x9c7b
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9c7b
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: pcache1Shrink
static void pcache1Shrink(sqlite3_pcache *p){
  PCache1 *pCache = (PCache1*)p;
  if( pCache->bPurgeable ){
    PGroup *pGroup = pCache->pGroup;
    int savedMaxPage;
    pcache1EnterMutex(pGroup);
    savedMaxPage = pGroup->nMaxPage;
    pGroup->nMaxPage = 0;
    pcache1EnforceMaxPage(pGroup);
    pGroup->nMaxPage = savedMaxPage;
    pcache1LeaveMutex(pGroup);
  }
}

// Assembly:
cmpl $0x0, 0x10(%rdi)
je 0x5b63c
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movl 0x8(%rbx), %r14d
andl $0x0, 0x8(%rbx)
movq %rbx, %rdi
callq 0x5b63d
movl %r14d, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: pcache1EnforceMaxPage
static void pcache1EnforceMaxPage(PGroup *pGroup){
  assert( sqlite3_mutex_held(pGroup->mutex) );
  while( pGroup->nCurrentPage>pGroup->nMaxPage && pGroup->pLruTail ){
    PgHdr1 *p = pGroup->pLruTail;
    assert( p->pCache->pGroup==pGroup );
    pcache1PinPage(p);
    pcache1RemoveFromHash(p);
    pcache1FreePage(p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x14(%rbx), %eax
cmpl 0x8(%rbx), %eax
jbe 0x5b672
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x5b672
movq %r14, %rdi
callq 0x5b677
movq %r14, %rdi
callq 0x5b6d8
movq %r14, %rdi
callq 0x5b70a
jmp 0x5b647
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: pcache1PinPage
static void pcache1PinPage(PgHdr1 *pPage){
  PCache1 *pCache;
  PGroup *pGroup;

  if( pPage==0 ) return;
  pCache = pPage->pCache;
  pGroup = pCache->pGroup;
  assert( sqlite3_mutex_held(pGroup->mutex) );
  if( pPage->pLruNext || pPage==pGroup->pLruTail ){
    if( pPage->pLruPrev ){
      pPage->pLruPrev->pLruNext = pPage->pLruNext;
    }
    if( pPage->pLruNext ){
      pPage->pLruNext->pLruPrev = pPage->pLruPrev;
    }
    if( pGroup->pLruHead==pPage ){
      pGroup->pLruHead = pPage->pLruNext;
    }
    if( pGroup->pLruTail==pPage ){
      pGroup->pLruTail = pPage->pLruPrev;
    }
    pPage->pLruNext = 0;
    pPage->pLruPrev = 0;
    pPage->pCache->nRecyclable--;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x5b6d7
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rsi
movq (%rax), %rcx
testq %rsi, %rsi
je 0x5b6d0
leaq 0x28(%rdi), %rdx
movq 0x30(%rdi), %r8
testq %r8, %r8
je 0x5b6a4
movq %rsi, 0x28(%r8)
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x5b6ad
movq %r8, 0x30(%rsi)
cmpq %rdi, 0x18(%rcx)
jne 0x5b6b7
movq %rsi, 0x18(%rcx)
cmpq %rdi, 0x20(%rcx)
jne 0x5b6c5
movq 0x30(%rdi), %rsi
movq %rsi, 0x20(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
decl 0x24(%rax)
jmp 0x5b6d6
cmpq %rdi, 0x20(%rcx)
je 0x5b690
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: pcache1RemoveFromHash
static void pcache1RemoveFromHash(PgHdr1 *pPage){
  unsigned int h;
  PCache1 *pCache = pPage->pCache;
  PgHdr1 **pp;

  assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
  h = pPage->iKey % pCache->nHash;
  for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext);
  *pp = (*pp)->pNext;

  pCache->nPage--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rcx
movl 0x10(%rdi), %eax
xorl %edx, %edx
divl 0x2c(%rcx)
shlq $0x3, %rdx
addq 0x30(%rcx), %rdx
movq %rdx, %rax
movq (%rdx), %rsi
leaq 0x18(%rsi), %rdx
cmpq %rdi, %rsi
jne 0x5b6f0
movq (%rdx), %rdx
movq %rdx, (%rax)
decl 0x28(%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: pcache1FreePage
static void pcache1FreePage(PgHdr1 *p){
  if( ALWAYS(p) ){
    PCache1 *pCache = p->pCache;
    assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) );
    pcache1Free(p->page.pBuf);
#ifdef SQLITE_PCACHE_SEPARATE_HEADER
    sqlite3_free(p);
#endif
    if( pCache->bPurgeable ){
      pCache->pGroup->nCurrentPage--;
    }
  }
}

// Assembly:
testq %rdi, %rdi
je 0x5b736
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x20(%rdi), %rbx
movq %rax, %rdi
callq 0x1a82f
cmpl $0x0, 0x10(%rbx)
je 0x5b730
movq (%rbx), %rax
decl 0x14(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: pcache1TruncateUnsafe
static void pcache1TruncateUnsafe(
  PCache1 *pCache,             /* The cache to truncate */
  unsigned int iLimit          /* Drop pages with this pgno or larger */
){
  TESTONLY( unsigned int nPage = 0; )  /* To assert pCache->nPage is correct */
  unsigned int h;
  assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
  for(h=0; h<pCache->nHash; h++){
    PgHdr1 **pp = &pCache->apHash[h]; 
    PgHdr1 *pPage;
    while( (pPage = *pp)!=0 ){
      if( pPage->iKey>=iLimit ){
        pCache->nPage--;
        *pp = pPage->pNext;
        pcache1PinPage(pPage);
        pcache1FreePage(pPage);
      }else{
        pp = &pPage->pNext;
        TESTONLY( nPage++; )
      }
    }
  }
  assert( pCache->nPage==nPage );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
movl 0x2c(%r14), %eax
cmpq %rax, %r12
jae 0x5b7cc
leaq (,%r12,8), %r13
addq 0x30(%r14), %r13
movq (%r13), %r15
testq %r15, %r15
je 0x5b7c7
cmpl %ebx, 0x10(%r15)
jb 0x5b7be
decl 0x28(%r14)
movq 0x18(%r15), %rax
movq %rax, (%r13)
movq %r15, %rdi
callq 0x5b677
movq %r15, %rdi
callq 0x5b70a
jmp 0x5b791
addq $0x18, %r15
movq %r15, %r13
jmp 0x5b791
incq %r12
jmp 0x5b77c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: connectionIsBusy
static int connectionIsBusy(sqlite3 *db){
  int j;
  assert( sqlite3_mutex_held(db->mutex) );
  if( db->pVdbe ) return 1;
  for(j=0; j<db->nDb; j++){
    Btree *pBt = db->aDb[j].pBt;
    if( pBt && sqlite3BtreeIsInBackup(pBt) ) return 1;
  }
  return 0;
}

// Assembly:
movl $0x1, %eax
cmpq $0x0, 0x8(%rdi)
je 0x5b7e8
retq
pushq %rbp
movq %rsp, %rbp
movl 0x28(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
shlq $0x5, %rcx
cmpq %rdx, %rcx
je 0x5b819
movq 0x20(%rdi), %rsi
movq 0x8(%rsi,%rdx), %rsi
testq %rsi, %rsi
je 0x5b813
cmpl $0x0, 0x18(%rsi)
jne 0x5b81b
addq $0x20, %rdx
jmp 0x5b7fa
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: functionDestroy
static void functionDestroy(sqlite3 *db, FuncDef *p){
  FuncDestructor *pDestructor = p->pDestructor;
  if( pDestructor ){
    pDestructor->nRef--;
    if( pDestructor->nRef==0 ){
      pDestructor->xDestroy(pDestructor->pUserData);
      sqlite3DbFree(db, pDestructor);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x40(%rsi), %rbx
testq %rbx, %rbx
je 0x5b831
decl (%rbx)
je 0x5b836
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %r14
movq 0x10(%rbx), %rdi
callq *0x8(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x968b
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: matchQuality
static int matchQuality(
  FuncDef *p,     /* The function we are evaluating for match quality */
  int nArg,       /* Desired number of arguments.  (-1)==any */
  u8 enc          /* Desired text encoding */
){
  int match;

  /* nArg of -2 is a special case */
  if( nArg==(-2) ) return (p->xFunc==0 && p->xStep==0) ? 0 : FUNC_PERFECT_MATCH;

  /* Wrong number of arguments means "no match" */
  if( p->nArg!=nArg && p->nArg>=0 ) return 0;

  /* Give a better score to a function with a specific number of arguments
  ** than to function that accepts any number of arguments. */
  if( p->nArg==nArg ){
    match = 4;
  }else{
    match = 1;
  }

  /* Bonus points if the text encoding matches */
  if( enc==p->iPrefEnc ){
    match += 2;  /* Exact encoding match */
  }else if( (enc & p->iPrefEnc & 2)!=0 ){
    match += 1;  /* Both are UTF16, but with different byte orders */
  }

  return match;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x2, %esi
jne 0x5b866
cmpq $0x0, 0x18(%rdi)
je 0x5b894
movl $0x6, %eax
jmp 0x5b8b1
movswl (%rdi), %ecx
testl %ecx, %ecx
setns %r8b
cmpl %esi, %ecx
setne %r9b
xorl %eax, %eax
testb %r9b, %r8b
jne 0x5b8b1
xorl %eax, %eax
cmpl %esi, %ecx
sete %al
leal (%rax,%rax,2), %eax
incl %eax
movb 0x2(%rdi), %cl
cmpb %dl, %cl
jne 0x5b8a5
orl $0x2, %eax
jmp 0x5b8b1
xorl %ecx, %ecx
cmpq $0x0, 0x20(%rdi)
movl $0x6, %eax
cmovel %ecx, %eax
jmp 0x5b8b1
andb %dl, %cl
movzbl %cl, %ecx
btl $0x1, %ecx
adcl $0x0, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: binCollFunc
static int binCollFunc(
  void *padFlag,
  int nKey1, const void *pKey1,
  int nKey2, const void *pKey2
){
  int rc, n;
  n = nKey1<nKey2 ? nKey1 : nKey2;
  rc = memcmp(pKey1, pKey2, n);
  if( rc==0 ){
    if( padFlag
     && allSpaces(((char*)pKey1)+n, nKey1-n)
     && allSpaces(((char*)pKey2)+n, nKey2-n)
    ){
      /* Leave rc unchanged at 0 */
    }else{
      rc = nKey1 - nKey2;
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, -0x38(%rbp)
movl %esi, %ebx
subl %ecx, %ebx
movl %ecx, %eax
cmovll %esi, %eax
movslq %eax, %r15
movq %rdx, %rdi
movq %r8, -0x30(%rbp)
movq %r8, %rsi
movq %r15, %rdx
callq 0x8180
testl %eax, %eax
jne 0x5b92b
cmpq $0x0, -0x38(%rbp)
je 0x5b929
addq %r15, %r12
subl %r15d, %r13d
movq %r12, %rdi
movl %r13d, %esi
callq 0x5b960
testl %eax, %eax
je 0x5b929
movq -0x30(%rbp), %rdi
addq %r15, %rdi
subl %r15d, %r14d
movl %r14d, %esi
callq 0x5b960
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x5b92b
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: nocaseCollatingFunc
static int nocaseCollatingFunc(
  void *NotUsed,
  int nKey1, const void *pKey1,
  int nKey2, const void *pKey2
){
  int r = sqlite3StrNICmp(
      (const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);
  UNUSED_PARAMETER(NotUsed);
  if( 0==r ){
    r = nKey1-nKey2;
  }
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rdi
movl %esi, %ebx
subl %ecx, %ebx
cmovll %esi, %ecx
movq %r8, %rsi
movl %ecx, %edx
callq 0x8f45
testl %eax, %eax
cmovel %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/ash_query.cpp
// Function: display(std::ostream&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void display(ostream & out, const RowsType & rows, const string & name) {
  RowsType::const_iterator i, e;
  const size_t XX = 4;  // The number of spaces between columns.
  size_t widths[2] = {name.size() + XX, string("Description").size() + XX};

  // Calculate the required widths for each column.
  for (i = rows.begin(), e = rows.end(); i != e; ++i) {
    widths[0] = max(widths[0], XX + (i -> first).size());
    widths[1] = max(widths[1], XX + (i -> second).size());
  }

  // Output the headings and the rows.
  cout << left
       << setw(widths[0]) << name
       << setw(widths[1]) << "Description" << endl;
  for (i = rows.begin(), e = rows.end(); i != e; ++i) {
    cout << left
         << setw(widths[0]) << i -> first
         << setw(widths[1]) << i -> second << endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdx, 0x10(%rsp)
movq 0x8(%rdx), %r13
addq $0x4, %r13
leaq 0x13c6b(%rip), %rsi     # 0x6f61c
leaq 0x18(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x8150
movq 0x8(%r14), %r15
addq $0x4, %r15
movq %r14, %rdi
callq 0x84b0
movq 0x18(%rbx), %rax
leaq 0x8(%rbx), %r12
cmpq %r12, %rax
je 0x5ba08
movq 0x28(%rax), %rcx
movq 0x48(%rax), %rdx
addq $0x4, %rcx
cmpq %rcx, %r13
cmovbeq %rcx, %r13
addq $0x4, %rdx
cmpq %rdx, %r15
cmovbeq %rdx, %r15
movq %rax, %rdi
callq 0x8440
jmp 0x5b9db
movq 0x2b5a9(%rip), %r14     # 0x86fb8
movq (%r14), %rax
movq -0x18(%rax), %rcx
movl $0xffffff4f, %ebp       # imm = 0xFFFFFF4F
movl 0x18(%r14,%rcx), %edx
andl %ebp, %edx
orl $0x20, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax), %rax
movslq %r13d, %r13
movq %r13, 0x10(%r14,%rax)
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x8320
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movslq %r15d, %r15
movq %r15, 0x10(%rax,%rcx)
leaq 0x13bc3(%rip), %rsi     # 0x6f61c
movq %rax, %rdi
callq 0x83a0
movq %rax, %rdi
callq 0x81a0
movq 0x18(%rbx), %rbx
cmpq %r12, %rbx
je 0x5baca
movq (%r14), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r14,%rcx), %edx
andl %ebp, %edx
orl $0x20, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax), %rax
movq %r13, 0x10(%r14,%rax)
leaq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x8320
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r15, 0x10(%rax,%rcx)
leaq 0x40(%rbx), %rsi
movq %rax, %rdi
callq 0x8320
movq %rax, %rdi
callq 0x81a0
movq %rbx, %rdi
callq 0x8440
movq %rax, %rbx
jmp 0x5ba6d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/command.cpp
// Function: ash::Command::register_table()
void Command::register_table() {
  string name = "commands";
  stringstream ss;
  ss << "CREATE TABLE IF NOT EXISTS " << name << " (\n"
     << "  id integer primary key autoincrement,\n"
     << "  session_id integer not null,\n"
     << "  shell_level integer not null,\n"
     << "  command_no integer,\n"
     << "  tty varchar(20) not null,\n"
     << "  euid int(16) not null,\n"
     << "  cwd varchar(256) not null,\n"
     << "  rval int(5) not null,\n"
     << "  start_time integer not null,\n"
     << "  end_time integer not null,\n"
     << "  duration integer not null,\n"
     << "  pipe_cnt int(3),\n"
     << "  pipe_vals varchar(80),\n"
     << "  command varchar(1000) not null,\n"
     << "UNIQUE(session_id, command_no)\n"
     << ");";
  DBObject::register_table(name, ss.str());
}

// Assembly:
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x12ff5(%rip), %rsi     # 0x6f744
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x8150
leaq 0x48(%rsp), %rdi
callq 0x8260
leaq 0x58(%rsp), %rdi
leaq 0x12fd9(%rip), %rsi     # 0x6f74d
callq 0x83a0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x8320
leaq 0x12fdc(%rip), %rsi     # 0x6f769
movq %rax, %rdi
callq 0x83a0
leaq 0x12fd1(%rip), %rsi     # 0x6f76d
movq %rax, %rdi
callq 0x83a0
leaq 0x12feb(%rip), %rsi     # 0x6f796
movq %rax, %rdi
callq 0x83a0
leaq 0x12ffc(%rip), %rsi     # 0x6f7b6
movq %rax, %rdi
callq 0x83a0
leaq 0x1300e(%rip), %rsi     # 0x6f7d7
movq %rax, %rdi
callq 0x83a0
leaq 0x13016(%rip), %rsi     # 0x6f7ee
movq %rax, %rdi
callq 0x83a0
leaq 0x13024(%rip), %rsi     # 0x6f80b
movq %rax, %rdi
callq 0x83a0
leaq 0x1302f(%rip), %rsi     # 0x6f825
movq %rax, %rdi
callq 0x83a0
leaq 0x1303e(%rip), %rsi     # 0x6f843
movq %rax, %rdi
callq 0x83a0
leaq 0x13048(%rip), %rsi     # 0x6f85c
movq %rax, %rdi
callq 0x83a0
leaq 0x13059(%rip), %rsi     # 0x6f87c
movq %rax, %rdi
callq 0x83a0
leaq 0x13068(%rip), %rsi     # 0x6f89a
movq %rax, %rdi
callq 0x83a0
leaq 0x13077(%rip), %rsi     # 0x6f8b8
movq %rax, %rdi
callq 0x83a0
leaq 0x1307c(%rip), %rsi     # 0x6f8cc
movq %rax, %rdi
callq 0x83a0
leaq 0x13087(%rip), %rsi     # 0x6f8e6
movq %rax, %rdi
callq 0x83a0
leaq 0x1309b(%rip), %rsi     # 0x6f909
movq %rax, %rdi
callq 0x83a0
leaq 0x12233(%rip), %rsi     # 0x6eab0
movq %rax, %rdi
callq 0x83a0
leaq 0x60(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x8610
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5ef1c
leaq 0x28(%rsp), %rdi
callq 0x84b0
leaq 0x48(%rsp), %rdi
callq 0x87e8
leaq 0x8(%rsp), %rdi
callq 0x84b0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x84b0
jmp 0x5c8e3
jmp 0x5c8e0
movq %rax, %rbx
jmp 0x5c8ed
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x87e8
leaq 0x8(%rsp), %rdi
callq 0x84b0
movq %rbx, %rdi
callq 0x86f0
movq %rax, %rdi
callq 0x5c505
nop
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/config.cpp
// Function: ash::Config::instance()
Config & Config::instance() {
  static Config _instance;
  if (!_instance.is_loaded) {
    // Find all environment variables matching a common prefix ASH_CFG_
    for (int i = 0; environ[i] != NULL; ++i) {
      string line = environ[i];
      if (line.substr(0, 8) == "ASH_CFG_") {
        int first_equals = line.find_first_of('=');
        string key = line.substr(8, first_equals - 8);
        string value = line.substr(first_equals + 1);
        _instance.values[key] = value;
      }
    }
    _instance.is_loaded = true;
  }
  return _instance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movb 0x2bcaa(%rip), %al      # 0x89390
testb %al, %al
je 0x5d813
cmpb $0x0, 0x2bc93(%rip)     # 0x89388
jne 0x5d7fd
xorl %r12d, %r12d
leaq 0x48(%rsp), %rbx
leaq 0x8(%rsp), %r14
pushq $0x8
popq %r15
leaq 0x28(%rsp), %r13
movq 0x298b8(%rip), %rax     # 0x86fd0
movq (%rax), %rax
movq (%rax,%r12), %rsi
testq %rsi, %rsi
je 0x5d7f6
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8150
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x83f0
movq %r14, %rdi
leaq 0x1226a(%rip), %rsi     # 0x6f9b7
callq 0x5c510
movl %eax, %ebp
movq %r14, %rdi
callq 0x84b0
testb %bpl, %bpl
je 0x5d7e5
movq %rbx, %rdi
pushq $0x3d
popq %rsi
xorl %edx, %edx
callq 0x84e0
movq %rax, %rbp
shlq $0x20, %rbp
movabsq $-0x800000000, %rax     # imm = 0xFFFFFFF800000000
leaq (%rax,%rbp), %rcx
sarq $0x20, %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x83f0
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rbp
sarq $0x20, %rbp
movq %r13, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
pushq $-0x1
popq %rcx
callq 0x83f0
leaq 0x2bb96(%rip), %rdi     # 0x89358
movq %r14, %rsi
callq 0x5d07c
movq %rax, %rdi
movq %r13, %rsi
callq 0x81d0
movq %r13, %rdi
callq 0x84b0
movq %r14, %rdi
callq 0x84b0
movq %rbx, %rdi
callq 0x84b0
addq $0x8, %r12
jmp 0x5d711
movb $0x1, 0x2bb8b(%rip)     # 0x89388
leaq 0x2bb54(%rip), %rax     # 0x89358
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2bb76(%rip), %rdi     # 0x89390
callq 0x8720
testl %eax, %eax
je 0x5d6ee
andl $0x0, 0x2bb32(%rip)     # 0x89360
andq $0x0, 0x2bb32(%rip)     # 0x89368
leaq 0x2bb1b(%rip), %rsi     # 0x89358
leaq 0x2bb1c(%rip), %rax     # 0x89360
movq %rax, 0x2bb25(%rip)     # 0x89370
movq %rax, 0x2bb26(%rip)     # 0x89378
andq $0x0, 0x2bb26(%rip)     # 0x89380
movb $0x0, 0x2bb27(%rip)     # 0x89388
leaq 0xc2(%rip), %rdi        # 0x5d92a
leaq 0x29b89(%rip), %rdx     # 0x873f8
callq 0x8310
leaq 0x2bb15(%rip), %rdi     # 0x89390
callq 0x8210
jmp 0x5d6ee
jmp 0x5d8b6
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x84b0
jmp 0x5d899
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x84b0
jmp 0x5d8b9
jmp 0x5d8b6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x84b0
jmp 0x5d8b9
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x84b0
movq %rbx, %rdi
callq 0x86f0
movq %rax, %rdi
callq 0x5c505
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/database.cpp
// Function: ash::DBObject::quote(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const string DBObject::quote(const string & in) {
  if (in.empty()) return "null";
  string out = "'";
  char c;
  for (string::const_iterator i = in.begin(), e = in.end(); i != e; ++i) {
    c = *i;
    switch (c) {
      case '\n':  // fallthrough
      case '\t':
        out.push_back(c);
        break;
      case '\'':
        out.push_back(c); // fallthrough
      default:
        if (isprint(c)) out.push_back(c);
    }
  }
  out.push_back('\'');
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x5ddfd
movq %rsi, %r14
leaq 0x1257a(%rip), %rsi     # 0x7030f
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
callq 0x8150
movq (%r14), %r15
movq 0x8(%r14), %r12
xorl %r13d, %r13d
pushq $0x27
popq %rbp
cmpq %r13, %r12
je 0x5ddf0
movzbl (%r15,%r13), %eax
movsbl %al, %r14d
leal -0x9(%rax), %ecx
cmpl $0x2, %ecx
jb 0x5dde0
cmpl $0x27, %eax
jne 0x5ddd4
movq %rbx, %rdi
movl %ebp, %esi
callq 0x82e0
movl %r14d, %edi
callq 0x8700
testl %eax, %eax
je 0x5ddeb
movq %rbx, %rdi
movl %r14d, %esi
callq 0x82e0
incq %r13
jmp 0x5ddaf
pushq $0x27
popq %rsi
movq %rbx, %rdi
callq 0x82e0
jmp 0x5de11
leaq 0x1245d(%rip), %rsi     # 0x70261
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x8150
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5de25
movq %rax, %r14
movq %rbx, %rdi
callq 0x84b0
movq %r14, %rdi
callq 0x86f0
movq %rax, %rdi
callq 0x5c505
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/database.cpp
// Function: ash::Database::init_db()
void Database::init_db() {
  const string & create_tables = DBObject::get_create_tables();
  char * error = 0;
  if (sqlite3_exec(db, create_tables.c_str(), NOOPCallback, 0, &error)) {
    cerr << "Failed to create tables:\n"
         << create_tables
         << "Error:\n"
         << error << endl;
    sqlite3_free(error);
    error = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5e590
movq %rsp, %r8
andq $0x0, (%r8)
movq 0x28(%rbx), %rdi
movq (%r14), %rsi
leaq 0x10a(%rip), %rdx       # 0x5e58c
xorl %ecx, %ecx
callq 0x113e2
testl %eax, %eax
je 0x5e4d9
movq 0x28b5c(%rip), %rdi     # 0x86ff0
leaq 0x115e9(%rip), %rsi     # 0x6fa84
callq 0x83a0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x8320
leaq 0x119c2(%rip), %rsi     # 0x6fe76
movq %rax, %rdi
callq 0x83a0
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x83a0
movq %rax, %rdi
callq 0x81a0
movq (%rsp), %rdi
callq 0x9c7b
leaq 0x8(%rsp), %rdi
callq 0x84b0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x84b0
movq %rbx, %rdi
callq 0x86f0
movq %rax, %rdi
callq 0x5c505
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/database.cpp
// Function: ash::DBObject::get_create_tables[abi:cxx11]()
const string DBObject::get_create_tables() {
  stringstream ss;
  ss << "PRAGMA foreign_keys=OFF;"
     << "BEGIN TRANSACTION;";
  typedef list<string>::iterator it;
  for (it i = create_tables.begin(), e = create_tables.end(); i != e; ++i) {
    ss << *i << "; ";
  }
  ss << "COMMIT;";
  return ss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8260
leaq 0x18(%rsp), %r14
leaq 0x118c5(%rip), %rsi     # 0x6fe7e
movq %r14, %rdi
callq 0x83a0
leaq 0x118cf(%rip), %rsi     # 0x6fe97
movq %rax, %rdi
callq 0x83a0
leaq 0x2ade1(%rip), %r12     # 0x893b8
leaq 0x118ed(%rip), %r15     # 0x6fecb
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x5e603
leaq 0x10(%r13), %rsi
movq %r14, %rdi
callq 0x8320
movq %rax, %rdi
movq %r15, %rsi
callq 0x83a0
jmp 0x5e5e1
leaq 0x118a0(%rip), %rsi     # 0x6feaa
movq %r14, %rdi
callq 0x83a0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x8610
leaq 0x8(%rsp), %rdi
callq 0x87e8
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5e63f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x87e8
movq %rbx, %rdi
callq 0x86f0
movq %rax, %rdi
callq 0x5c505
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/database.cpp
// Function: ash::DBObject::get_sql[abi:cxx11]() const
const string DBObject::get_sql() const {
  typedef map<string, string>::const_iterator c_iter;

  stringstream ss;
  ss << "INSERT INTO " << get_name() << " (";

  // Insert the column names.
  for (c_iter i = values.begin(), e = values.end(); i != e; ) {
    ss << (i -> first);
    if (++i == e) break;
    ss << ", ";
  }

  ss << ") VALUES (";
  // Insert the values.
  for (c_iter i = values.begin(), e = values.end(); i != e; ) {
    ss << (i -> second);
    if (++i == e) break;
    ss << ", ";
  }

  ss << "); ";

  return ss.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8260
leaq 0x30(%rsp), %r14
leaq 0x10e95(%rip), %rsi     # 0x6feb2
movq %r14, %rdi
callq 0x83a0
movq %rax, %r12
movq (%r15), %rax
movq %rsp, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq %rsp, %rsi
movq %r12, %rdi
callq 0x8320
leaq 0x10e81(%rip), %rsi     # 0x6fec7
movq %rax, %rdi
callq 0x83a0
movq %rsp, %rdi
callq 0x84b0
movq 0x20(%r15), %r13
leaq 0x10(%r15), %rbp
leaq 0xee0c(%rip), %r12      # 0x6de71
cmpq %rbp, %r13
je 0x5f093
leaq 0x20(%r13), %rsi
movq %r14, %rdi
callq 0x8320
movq %r13, %rdi
callq 0x8440
cmpq %rbp, %rax
je 0x5f093
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x83a0
jmp 0x5f065
leaq 0x10e25(%rip), %rsi     # 0x6febf
movq %r14, %rdi
callq 0x83a0
movq 0x20(%r15), %r12
leaq 0xedc4(%rip), %r15      # 0x6de71
cmpq %rbp, %r12
je 0x5f0dc
leaq 0x40(%r12), %rsi
movq %r14, %rdi
callq 0x8320
movq %r12, %rdi
callq 0x8440
cmpq %rbp, %rax
je 0x5f0dc
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x83a0
jmp 0x5f0ad
leaq 0x10de7(%rip), %rsi     # 0x6feca
movq %r14, %rdi
callq 0x83a0
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x8610
leaq 0x20(%rsp), %rdi
callq 0x87e8
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5f12a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x84b0
jmp 0x5f12d
jmp 0x5f12a
jmp 0x5f12a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x87e8
movq %rbx, %rdi
callq 0x86f0
movq %rax, %rdi
callq 0x5c505
nop
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::Flag::show_help(std::ostream&)
void Flag::show_help(ostream & out) {
  char * program_name = strdup(prog_name.c_str());
  out << "\nUsage: " << basename(program_name);

  list<Flag *> & flags = Flag::instances();
  if (flags.empty()) return;

  out << " [options]";
  for (list<Flag *>::iterator i = flags.begin(); i != flags.end(); ++i) {
    out << "\n" << **i;
  }
  out << "\n" << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x29ada(%rip), %rdi     # 0x893d8
callq 0x8730
movq %rax, %r14
leaq 0x10620(%rip), %rsi     # 0x6ff2d
movq %rbx, %rdi
callq 0x83a0
movq %rax, %r15
movq %r14, %rdi
callq 0x86b0
movq %r15, %rdi
movq %rax, %rsi
callq 0x83a0
callq 0x60256
cmpq %rax, (%rax)
je 0x5f988
movq %rax, %r14
leaq 0x105f7(%rip), %rsi     # 0x6ff36
movq %rbx, %rdi
callq 0x83a0
leaq 0x109f6(%rip), %r15     # 0x70344
movq %r14, %r12
movq (%r12), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x83a0
cmpq %r14, %r12
je 0x5f975
movq 0x10(%r12), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x10(%rcx)
jmp 0x5f951
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x81a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::all_isgraph(char const*)
bool all_isgraph(const char * input) {
  for (int i = 0; input && input[i] != '\0'; ++i) {
    if (!isgraph(input[i]))
      return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5fc54
movq %rdi, %rbx
movsbl (%rbx), %edi
testl %edi, %edi
sete %bpl
je 0x5fc57
callq 0x8360
incq %rbx
testl %eax, %eax
jne 0x5fc3b
jmp 0x5fc57
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::Flag::insert(std::ostream&) const
ostream & Flag::insert(ostream & out) const {
  if (short_name)
    out << "  -" << short_name;
  else
    out << "    ";

  if (long_name) {
    int padding = 2 + longest_long_name - string(long_name).length();
    out << "  --" << long_name;
    if (has_arg) {
      out << "=VALUE";
      padding -= 6;
    }
    out << string(padding, ' ');
  }

  if (description) out << description;
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x10(%rdi)
je 0x5fe9e
leaq 0x1014c(%rip), %rsi     # 0x6ffd3
movq %rbx, %rdi
callq 0x83a0
movsbl 0x10(%r14), %esi
movq %rax, %rdi
callq 0x8460
jmp 0x5fead
leaq 0x10132(%rip), %rsi     # 0x6ffd7
movq %rbx, %rdi
callq 0x83a0
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x5ff46
movl 0x2956c(%rip), %ebp     # 0x8942c
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x8150
subl 0x8(%r15), %ebp
addl $0x2, %ebp
movq %r15, %rdi
callq 0x84b0
leaq 0x100f4(%rip), %rsi     # 0x6ffdc
movq %rbx, %rdi
callq 0x83a0
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x83a0
cmpb $0x1, 0x20(%r14)
jne 0x5ff15
leaq 0x1009d(%rip), %rsi     # 0x6ffa7
movq %rbx, %rdi
callq 0x83a0
addl $-0x6, %ebp
movslq %ebp, %rsi
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r15
pushq $0x20
popq %rdx
movq %r15, %rdi
callq 0x8450
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8320
leaq 0x8(%rsp), %rdi
callq 0x84b0
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x5ff57
movq %rbx, %rdi
callq 0x83a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x84b0
movq %rbx, %rdi
callq 0x86f0
movq %rax, %rdi
callq 0x5c505
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::IntFlag::insert(std::ostream&) const
ostream & IntFlag::insert(ostream & out) const {
  Flag::insert(out);
  if (value && *value) {
    out << "  Default: " << *value;
  }
  return out;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5fe6a
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x60002
cmpl $0x0, (%rax)
je 0x60002
leaq 0xfff5(%rip), %rsi      # 0x6ffe1
movq %rbx, %rdi
callq 0x83a0
movq 0x28(%r14), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x86a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::StringFlag::set(char const*)
void StringFlag::set(const char * optarg) {
  if (optarg) {
    *value = string(optarg);
  } else {
    value -> clear();
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x6007f
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x8150
movq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x81d0
leaq 0x8(%rsp), %rdi
callq 0x84b0
jmp 0x6008e
movq 0x28(%rbx), %rax
andq $0x0, 0x8(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x84b0
movq %rbx, %rdi
callq 0x86f0
movq %rax, %rdi
callq 0x5c505
nop
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::StringFlag::insert(std::ostream&) const
ostream & StringFlag::insert(ostream & out) const {
  Flag::insert(out);
  if (!value -> empty()) {
    out << "  Default: '" << *value << "'";
  }
  return out;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5fe6a
movq 0x28(%r14), %rax
cmpq $0x0, 0x8(%rax)
je 0x600f8
leaq 0xff18(%rip), %rsi      # 0x6ffed
movq %rbx, %rdi
callq 0x83a0
movq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x8320
leaq 0x1021f(%rip), %rsi     # 0x7030f
movq %rax, %rdi
callq 0x83a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::BoolFlag::set(char const*)
void BoolFlag::set(const char * optarg) {
  if (optarg) {
    string opt(optarg);
    if (opt == "true") {
      *value = true;
    } else if (opt == "false") {
      *value = false;
    } else {
      cerr << "ERROR: boolean flags must be either true or false.  Got '"
           << optarg << "'" << endl;
    }
  } else {
    *value = true;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
testq %rsi, %rsi
je 0x60192
movq %rsi, %rbx
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x8150
leaq 0xf85b(%rip), %rsi      # 0x6f9c0
movq %r15, %rdi
callq 0x5c510
movb $0x1, %cl
testb %al, %al
jne 0x6018a
leaq 0xfe80(%rip), %rsi      # 0x6fffa
leaq 0x10(%rsp), %rdi
callq 0x5c510
testb %al, %al
je 0x6019b
xorl %ecx, %ecx
movq 0x28(%r14), %rax
movb %cl, (%rax)
jmp 0x601d0
movq 0x28(%r14), %rax
movb $0x1, (%rax)
jmp 0x601da
movq 0x26e4e(%rip), %rdi     # 0x86ff0
leaq 0xfe57(%rip), %rsi      # 0x70000
callq 0x83a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x83a0
leaq 0x1014f(%rip), %rsi     # 0x7030f
movq %rax, %rdi
callq 0x83a0
movq %rax, %rdi
callq 0x81a0
leaq 0x10(%rsp), %rdi
callq 0x84b0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x84b0
movq %rbx, %rdi
callq 0x86f0
movq %rax, %rdi
callq 0x5c505
nop
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::BoolFlag::insert(std::ostream&) const
ostream & BoolFlag::insert(ostream & out) const {
  Flag::insert(out);
  if (has_arg) {
    out << "  Default: " << (*value ? "true" : "false");
  }
  return out;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5fe6a
cmpb $0x1, 0x20(%r14)
jne 0x60248
leaq 0xfdc2(%rip), %rsi      # 0x6ffe1
movq %rbx, %rdi
callq 0x83a0
movq 0x28(%r14), %rcx
leaq 0xf78e(%rip), %rdx      # 0x6f9c0
leaq 0xfdc1(%rip), %rsi      # 0x6fffa
cmpb $0x0, (%rcx)
cmovneq %rdx, %rsi
movq %rax, %rdi
callq 0x83a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/flags.cpp
// Function: void flag::safe_add<char>(std::map<char const, flag::Flag*, std::less<char const>, std::allocator<std::pair<char const, flag::Flag*>>>&, char, flag::Flag*)
void safe_add(map<const T, Flag *> & known, const T key, Flag * value) {
  if (known.find(key) != known.end()) {
    cerr << "ERROR: ambiguous flags defined: duplicate key: "
         << "'" << key << "'\n" << *known[key] << "\n" << *value << endl;
  }
  known[key] = value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x7(%rsp), %rax
movb %sil, (%rax)
movq %rax, %rsi
callq 0x60b46
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x6060d
movq 0x26a5b(%rip), %rdi     # 0x86ff0
leaq 0xfa9e(%rip), %rsi      # 0x7003a
callq 0x83a0
leaq 0xfd67(%rip), %rsi      # 0x7030f
movq %rax, %rdi
callq 0x83a0
leaq 0x7(%rsp), %r15
movsbl (%r15), %esi
movq %rax, %rdi
callq 0x8460
leaq 0xf859(%rip), %rsi      # 0x6fe21
movq %rax, %rdi
callq 0x83a0
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x60516
movq (%rax), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x10(%rax)
leaq 0xfd53(%rip), %rsi      # 0x70344
movq %rax, %rdi
callq 0x83a0
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
movq %rax, %rdi
callq 0x81a0
leaq 0x7(%rsp), %rsi
movq %r14, %rdi
callq 0x60516
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/formatter.cpp
// Function: ash::Formatter::get_desc[abi:cxx11]()
map<string, string> Formatter::get_desc() {
  map<string, string> rval;
  map<string, Formatter *>::iterator i, e;

  for (i = instances.begin(), e = instances.end(); i != e; ++i) {
    if (i -> second)
      rval[i -> first] = i -> second -> description;
  }
  return rval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq 0x285c8(%rip), %r14     # 0x89528
leaq 0x285b1(%rip), %r12     # 0x89518
cmpq %r12, %r14
je 0x60f9d
movq 0x40(%r14), %r15
testq %r15, %r15
je 0x60f90
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x5d07c
addq $0x28, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x81d0
movq %r14, %rdi
callq 0x8240
movq %rax, %r14
jmp 0x60f67
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5c56c
movq %r14, %rdi
callq 0x86f0
movq %rax, %rdi
callq 0x5c505
nop
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/formatter.cpp
// Function: get_widths(ash::ResultSet const*, bool)
vector<size_t> get_widths(const ResultSet * rs, bool do_show_headings) {
  vector<size_t> widths;
  const size_t XX = 4;  // The number of spaces between columns.

  // Initialize with the widths of the headings.
  size_t c = 0;
  ResultSet::HeadersType::const_iterator i, e;
  for (i = (rs -> headers).begin(), e = (rs -> headers).end(); i != e; ++i, ++c)
    if (do_show_headings)
      widths.push_back(XX + i -> size());
    else
      widths.push_back(XX);

  // Limit the width of columns containing very wide elements.
  size_t max_w = 80;  // TODO(cpa): make this a flag or configurable.

  // Loop ofer the rs.data looking for max column widths.
  for (size_t r = 0; r < rs -> rows; ++r) {
    for (size_t c = 0; c < rs -> columns; ++c) {
      widths[c] = max(widths[c], min(max_w, XX + (rs -> data[r][c]).size()));
    }
  }

  return widths;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %r15
movq $0x4, (%r15)
leaq 0x8(%rsp), %r12
movq %rsi, %r13
movq (%r13), %r13
cmpq %r14, %r13
je 0x611ef
testb %bpl, %bpl
je 0x611e2
movq 0x18(%r13), %rax
addq $0x4, %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x61f78
jmp 0x611ba
movq %rbx, %rdi
movq %r15, %rsi
callq 0x61f78
jmp 0x611ba
xorl %eax, %eax
pushq $0x8
popq %rcx
pushq $0x50
popq %rdx
cmpq 0x30(%r14), %rax
jae 0x61247
movq (%rbx), %rsi
imulq $0x18, %rax, %rdi
movq %rcx, %r8
xorl %r9d, %r9d
cmpq 0x38(%r14), %r9
jae 0x61242
movq 0x18(%r14), %r10
movq (%r10,%rdi), %r10
movq (%r10,%r8), %r10
addq $0x4, %r10
cmpq $0x50, %r10
jb 0x61229
movq %rdx, %r10
movq (%rsi,%r9,8), %r11
cmpq %r10, %r11
ja 0x61235
movq %r10, %r11
movq %r11, (%rsi,%r9,8)
incq %r9
addq $0x20, %r8
jmp 0x6120a
incq %rax
jmp 0x611f7
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6125b
movq %rax, %r14
movq %rbx, %rdi
callq 0x6253a
movq %r14, %rdi
callq 0x86f0
movq %rax, %rdi
callq 0x5c505
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/formatter.cpp
// Function: ash::SpacedFormatter::insert(ash::ResultSet const*, std::ostream&) const
void SpacedFormatter::insert(const ResultSet * rs, ostream & out) const {
  if (!rs) return;  // Sanity check.

  vector<size_t> widths = get_widths(rs, do_show_headings);

  // Print the headings, if not suppressed.
  if (do_show_headings) {
    size_t c = 0, cols = widths.size();
    ResultSet::HeadersType::const_iterator i, e;
    for (i = (rs -> headers).begin(), e = (rs -> headers).end(); i != e; ++i) {
      if (c < cols - 1) out << left << setw(widths[c++]);
      out << *i;
    }
    out << endl;
  }

  // Iterate over the data once more, printing.
  for (size_t r = 0; r < rs -> rows; ++r) {
    for (size_t c = 0; c < rs -> columns; ++c) {
      if (c < rs -> columns - 1) out << left << setw(widths[c]);
      out << (rs -> data)[r][c];
    }
    out << endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x6139f
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movzbl 0x48(%rdi), %edx
leaq 0x8(%rsp), %rdi
callq 0x61185
cmpb $0x1, 0x48(%r15)
jne 0x61314
movq 0x10(%rsp), %r15
subq 0x8(%rsp), %r15
sarq $0x3, %r15
decq %r15
xorl %r12d, %r12d
movl $0xffffff4f, %ebp       # imm = 0xFFFFFF4F
movq %r14, %r13
movq (%r13), %r13
cmpq %r14, %r13
je 0x6130c
cmpq %r15, %r12
jae 0x612fe
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl %ebp, %edx
orl $0x20, %edx
movl %edx, 0x18(%rbx,%rcx)
movq 0x8(%rsp), %rcx
movslq (%rcx,%r12,8), %rcx
incq %r12
movq -0x18(%rax), %rax
movq %rcx, 0x10(%rbx,%rax)
leaq 0x10(%r13), %rsi
movq %rbx, %rdi
callq 0x8320
jmp 0x612c7
movq %rbx, %rdi
callq 0x81a0
xorl %eax, %eax
movl $0xffffff4f, %ebp       # imm = 0xFFFFFF4F
cmpq 0x30(%r14), %rax
jae 0x61395
movq %rax, 0x20(%rsp)
imulq $0x18, %rax, %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x38(%r14), %rax
cmpq %rax, %r15
jae 0x61383
decq %rax
cmpq %rax, %r15
jae 0x61367
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl %ebp, %edx
orl $0x20, %edx
movl %edx, 0x18(%rbx,%rcx)
movq 0x8(%rsp), %rcx
movslq (%rcx,%r15,8), %rcx
movq -0x18(%rax), %rax
movq %rcx, 0x10(%rbx,%rax)
movq 0x18(%r14), %rax
movq (%rax,%r12), %rsi
addq %r13, %rsi
movq %rbx, %rdi
callq 0x8320
incq %r15
addq $0x20, %r13
jmp 0x61330
movq %rbx, %rdi
callq 0x81a0
movq 0x20(%rsp), %rax
incq %rax
jmp 0x6131b
leaq 0x8(%rsp), %rdi
callq 0x6253a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x613b4
jmp 0x613b4
jmp 0x613b4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6253a
movq %rbx, %rdi
callq 0x86f0
movq %rax, %rdi
callq 0x5c505
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/formatter.cpp
// Function: insert_delimited(ash::ResultSet const*, std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void insert_delimited(const ResultSet * rs, ostream & out, const string & d,
                      const bool do_show_headings)
{
  if (!rs) return;

  const ResultSet::HeadersType & headers = rs -> headers;
  ResultSet::HeadersType::const_iterator i, e;

  if (do_show_headings) {
    size_t c = 0;
    for (i = headers.begin(), e = headers.end(); i != e; ++i, ++c)
      // Don't add a delimiter after the last column.
      out << *i << (c + 1 < rs -> columns ? d : "");
    out << endl;
  }

  // Loop ofer the rs.data inserting delimited text.
  for (size_t r = 0; r < rs -> rows; ++r) {
    for (size_t c = 0; c < rs -> columns; ++c) {
      out << rs -> data[r][c] << (c + 1 < rs -> columns ? d : "");
    }
    out << endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0x6151c
movq %rdi, %r15
testb %cl, %cl
je 0x6146e
pushq $0x1
popq %rbp
leaq 0x28(%rsp), %r12
movq %r15, %rbx
movq (%rbx), %rbx
cmpq %r15, %rbx
je 0x61464
leaq 0x10(%rbx), %rsi
movq 0x8(%rsp), %rdi
callq 0x8320
movq %rax, %r13
movq 0x38(%r15), %r14
cmpq %r14, %rbp
jae 0x61435
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x8500
jmp 0x61449
movq %r12, %rdi
leaq 0xef06(%rip), %rsi      # 0x70345
leaq 0x7(%rsp), %rdx
callq 0x8150
movq %r13, %rdi
movq %r12, %rsi
callq 0x8320
movq %r12, %rdi
callq 0x84b0
cmpq %r14, %rbp
incq %rbp
jmp 0x61404
movq 0x8(%rsp), %rdi
callq 0x81a0
xorl %eax, %eax
leaq 0x28(%rsp), %r12
cmpq 0x30(%r15), %rax
jae 0x6151c
movq %rax, 0x18(%rsp)
imulq $0x18, %rax, %rax
movq %rax, 0x20(%rsp)
pushq $0x1
popq %rbp
xorl %r14d, %r14d
leaq -0x1(%rbp), %rax
cmpq 0x38(%r15), %rax
jae 0x61505
movq 0x18(%r15), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx), %rsi
addq %r14, %rsi
movq 0x8(%rsp), %rdi
callq 0x8320
movq %rax, %r13
movq 0x38(%r15), %rbx
cmpq %rbx, %rbp
jae 0x614d2
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x8500
jmp 0x614e6
movq %r12, %rdi
leaq 0xee69(%rip), %rsi      # 0x70345
leaq 0x6(%rsp), %rdx
callq 0x8150
movq %r13, %rdi
movq %r12, %rsi
callq 0x8320
movq %r12, %rdi
callq 0x84b0
cmpq %rbx, %rbp
addq $0x20, %r14
incq %rbp
jmp 0x61493
movq 0x8(%rsp), %rdi
callq 0x81a0
movq 0x18(%rsp), %rax
incq %rax
jmp 0x61475
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x61544
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0x84b0
jmp 0x6153f
movq %rax, %r15
cmpq %r14, %rbp
jmp 0x6155e
movq %rax, %r15
jmp 0x6155e
movq %rax, %r15
jmp 0x6155b
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0x84b0
cmpq %rbx, %rbp
movq %r15, %rdi
callq 0x86f0
movq %rax, %rdi
callq 0x5c505
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/logger.cpp
// Function: parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const Severity parse(const string & input) {
  if (input == "DEBUG") return DEBUG;
  if (input == "INFO") return INFO;
  if (input == "WARNING") return WARNING;
  if (input == "ERROR") return ERROR;
  if (input == "FATAL") return FATAL;
  return UNKNOWN;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xda98(%rip), %rsi      # 0x7022b
callq 0x5c510
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x627e4
leaq 0xda8a(%rip), %rsi      # 0x70231
movq %rbx, %rdi
callq 0x5c510
testb %al, %al
je 0x627b7
pushq $0x1
jmp 0x627e3
leaq 0xda78(%rip), %rsi      # 0x70236
movq %rbx, %rdi
callq 0x5c510
testb %al, %al
je 0x627ce
pushq $0x2
jmp 0x627e3
leaq 0xda69(%rip), %rsi      # 0x7023e
movq %rbx, %rdi
callq 0x5c510
testb %al, %al
je 0x627e6
pushq $0x3
popq %rax
popq %rbx
retq
leaq 0xda57(%rip), %rsi      # 0x70244
movq %rbx, %rdi
callq 0x5c510
movzbl %al, %eax
xorl $0x5, %eax
jmp 0x627e4