LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: pcache1Init
static int pcache1Init(void *NotUsed){
  UNUSED_PARAMETER(NotUsed);
  assert( pcache1.isInit==0 );
  memset(&pcache1, 0, sizeof(pcache1));
  if( sqlite3GlobalConfig.bCoreMutex ){
    pcache1.grp.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU);
    pcache1.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_PMEM);
  }
  pcache1.grp.mxPinned = 10;
  pcache1.isInit = 1;
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x2eed4(%rip)    # 0x95fc0
movups %xmm0, 0x2eebd(%rip)    # 0x95fb0
movups %xmm0, 0x2eea6(%rip)    # 0x95fa0
movups %xmm0, 0x2ee8f(%rip)    # 0x95f90
movups %xmm0, 0x2ee78(%rip)    # 0x95f80
movups %xmm0, 0x2ee61(%rip)    # 0x95f70
cmpl $0x0, 0x2d2ee(%rip)     # 0x94404
je 0x6712b
movl $0x8, %eax
movq %rax, 0x2ee4c(%rip)     # 0x95f70
movq %rax, 0x2ee8d(%rip)     # 0x95fb8
movl $0xa, 0x2ee4b(%rip)     # 0x95f80
movl $0x1, 0x2ee59(%rip)     # 0x95f98
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: pcache1Create
static sqlite3_pcache *pcache1Create(int szPage, int szExtra, int bPurgeable){
  PCache1 *pCache;      /* The newly created page cache */
  PGroup *pGroup;       /* The group the new page cache will belong to */
  int sz;               /* Bytes of memory required to allocate the new cache */

  /*
  ** The separateCache variable is true if each PCache has its own private
  ** PGroup.  In other words, separateCache is true for mode (1) where no
  ** mutexing is required.
  **
  **   *  Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT
  **
  **   *  Always use a unified cache in single-threaded applications
  **
  **   *  Otherwise (if multi-threaded and ENABLE_MEMORY_MANAGEMENT is off)
  **      use separate caches (mode-1)
  */
#if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) || SQLITE_THREADSAFE==0
  const int separateCache = 0;
#else
  int separateCache = sqlite3GlobalConfig.bCoreMutex>0;
#endif

  assert( (szPage & (szPage-1))==0 && szPage>=512 && szPage<=65536 );
  assert( szExtra < 300 );

  sz = sizeof(PCache1) + sizeof(PGroup)*separateCache;
  pCache = (PCache1 *)sqlite3MallocZero(sz);
  if( pCache ){
    if( separateCache ){
      pGroup = (PGroup*)&pCache[1];
      pGroup->mxPinned = 10;
    }else{
      pGroup = &pcache1.grp;
    }
    pCache->pGroup = pGroup;
    pCache->szPage = szPage;
    pCache->szExtra = szExtra;
    pCache->bPurgeable = (bPurgeable ? 1 : 0);
    if( bPurgeable ){
      pCache->nMin = 10;
      pcache1EnterMutex(pGroup);
      pGroup->nMinPage += pCache->nMin;
      pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
      pcache1LeaveMutex(pGroup);
    }
  }
  return (sqlite3_pcache *)pCache;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %r15d
cmpl $0x0, 0x2d26c(%rip)     # 0x94400
je 0x671ad
leaq -0x28(%rbp), %r12
movl $0x38, %edi
movq %r12, %rsi
callq 0x171f8
movq (%r12), %rax
jmp 0x671b8
movl $0x38, %edi
callq *0x2d268(%rip)          # 0x94420
testq %rax, %rax
je 0x67211
xorps %xmm0, %xmm0
movups %xmm0, 0x24(%rax)
movups %xmm0, 0x14(%rax)
movl $0x0, 0x34(%rax)
leaq 0x2ed9a(%rip), %rcx     # 0x95f70
movq %rcx, (%rax)
movl %r15d, 0x8(%rax)
movl %r14d, 0xc(%rax)
xorl %ecx, %ecx
testl %ebx, %ebx
setne %cl
movl %ecx, 0x10(%rax)
je 0x67211
movl $0xa, 0x14(%rax)
movl 0x2ed82(%rip), %ecx     # 0x95f7c
leal 0xa(%rcx), %edx
movl %edx, 0x2ed79(%rip)     # 0x95f7c
movl 0x2ed6f(%rip), %edx     # 0x95f78
subl %ecx, %edx
movl %edx, 0x2ed6f(%rip)     # 0x95f80
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: pcache1Unpin
static void pcache1Unpin(
  sqlite3_pcache *p, 
  sqlite3_pcache_page *pPg, 
  int reuseUnlikely
){
  PCache1 *pCache = (PCache1 *)p;
  PgHdr1 *pPage = (PgHdr1 *)pPg;
  PGroup *pGroup = pCache->pGroup;
 
  assert( pPage->pCache==pCache );
  pcache1EnterMutex(pGroup);

  /* It is an error to call this function if the page is already 
  ** part of the PGroup LRU list.
  */
  assert( pPage->pLruPrev==0 && pPage->pLruNext==0 );
  assert( pGroup->pLruHead!=pPage && pGroup->pLruTail!=pPage );

  if( reuseUnlikely || pGroup->nCurrentPage>pGroup->nMaxPage ){
    pcache1RemoveFromHash(pPage);
    pcache1FreePage(pPage);
  }else{
    /* Add the page to the PGroup LRU list. */
    if( pGroup->pLruHead ){
      pGroup->pLruHead->pLruPrev = pPage;
      pPage->pLruNext = pGroup->pLruHead;
      pGroup->pLruHead = pPage;
    }else{
      pGroup->pLruTail = pPage;
      pGroup->pLruHead = pPage;
    }
    pCache->nRecyclable++;
  }

  pcache1LeaveMutex(pCache->pGroup);
}

// Assembly:
testl %edx, %edx
jne 0x6759c
movq (%rdi), %rax
movl 0x14(%rax), %ecx
cmpl 0x8(%rax), %ecx
jbe 0x675d5
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rsi), %rcx
movl 0x10(%rsi), %eax
xorl %edx, %edx
divl 0x2c(%rcx)
shlq $0x3, %rdx
addq 0x30(%rcx), %rdx
movq %rdx, %rax
movq (%rdx), %rdi
leaq 0x18(%rdi), %rdx
cmpq %rsi, %rdi
jne 0x675b4
movq (%rdx), %rdx
movq %rdx, (%rax)
decl 0x28(%rcx)
movq %rsi, %rdi
popq %rbp
jmp 0x677b9
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x675e8
movq %rsi, 0x30(%rcx)
movq %rcx, 0x28(%rsi)
jmp 0x675ec
movq %rsi, 0x20(%rax)
movq %rsi, 0x18(%rax)
incl 0x24(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x677e6
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 0x676e2
movq 0x30(%rbx), %rdi
callq 0xa3c7
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xa3c7
// File: /workspace/github_c_makefile_star2_O3/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 0x676e1
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movl 0x8(%rbx), %r14d
movl $0x0, 0x8(%rbx)
movq %rbx, %rdi
callq 0x676e2
movl %r14d, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x14(%rdi), %eax
cmpl 0x8(%rdi), %eax
jbe 0x67757
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x67753
movq %r14, %rdi
callq 0x67758
movq 0x20(%r14), %rcx
movl 0x10(%r14), %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 %r14, %rsi
jne 0x6771a
movq (%rdx), %rdx
movq %rdx, (%rax)
decl 0x28(%rcx)
movq (%r14), %rdi
movq 0x20(%r14), %r14
callq 0x1cdc9
cmpl $0x0, 0x10(%r14)
je 0x6774b
movq (%r14), %rax
decl 0x14(%rax)
movl 0x14(%rbx), %eax
cmpl 0x8(%rbx), %eax
ja 0x676f4
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x677b8
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rsi
movq (%rax), %rcx
testq %rsi, %rsi
je 0x677b1
leaq 0x28(%rdi), %rdx
movq 0x30(%rdi), %r8
testq %r8, %r8
je 0x67785
movq %rsi, 0x28(%r8)
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x6778e
movq %r8, 0x30(%rsi)
cmpq %rdi, 0x18(%rcx)
jne 0x67798
movq %rsi, 0x18(%rcx)
cmpq %rdi, 0x20(%rcx)
jne 0x677a6
movq 0x30(%rdi), %rsi
movq %rsi, 0x20(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
decl 0x24(%rax)
jmp 0x677b7
cmpq %rdi, 0x20(%rcx)
je 0x67771
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x677e5
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x20(%rdi), %rbx
movq %rax, %rdi
callq 0x1cdc9
cmpl $0x0, 0x10(%rbx)
je 0x677df
movq (%rbx), %rax
decl 0x14(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x2c(%rdi), %eax
testl %eax, %eax
je 0x67879
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
movq 0x30(%r14), %rcx
movq (%rcx,%r12,8), %r15
testq %r15, %r15
je 0x67861
leaq (%rcx,%r12,8), %r13
cmpl %ebx, 0x10(%r15)
jae 0x67827
addq $0x18, %r15
movq %r15, %r13
jmp 0x67854
decl 0x28(%r14)
movq 0x18(%r15), %rax
movq %rax, (%r13)
movq %r15, %rdi
callq 0x67758
movq (%r15), %rdi
movq 0x20(%r15), %r15
callq 0x1cdc9
cmpl $0x0, 0x10(%r15)
je 0x67854
movq (%r15), %rax
decl 0x14(%rax)
movq (%r13), %r15
testq %r15, %r15
jne 0x67818
movl 0x2c(%r14), %eax
incq %r12
movl %eax, %ecx
cmpq %rcx, %r12
jb 0x67807
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x67887
retq
movslq 0x28(%rdi), %rcx
testq %rcx, %rcx
jle 0x678bb
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rdx
shlq $0x5, %rcx
xorl %esi, %esi
movq 0x8(%rdx,%rsi), %rdi
testq %rdi, %rdi
je 0x678ae
cmpl $0x0, 0x18(%rdi)
jne 0x678b9
addq $0x20, %rsi
cmpq %rsi, %rcx
jne 0x6789e
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
je 0x678d1
movq %rsi, %rbx
decl (%rsi)
je 0x678d6
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 0x9ca4
// File: /workspace/github_c_makefile_star2_O3/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 0x67910
movl $0x6, %eax
cmpq $0x0, 0x18(%rdi)
jne 0x6794a
xorl %ecx, %ecx
cmpq $0x0, 0x20(%rdi)
cmovel %ecx, %eax
jmp 0x6794a
movswl (%rdi), %ecx
testl %ecx, %ecx
setns %r8b
cmpl %esi, %ecx
setne %r9b
xorl %eax, %eax
testb %r9b, %r8b
jne 0x6794a
xorl %eax, %eax
cmpl %esi, %ecx
sete %al
leal (%rax,%rax,2), %eax
incl %eax
movb 0x2(%rdi), %cl
cmpb %dl, %cl
jne 0x6793e
orl $0x2, %eax
jmp 0x6794a
andb %dl, %cl
movzbl %cl, %ecx
btl $0x1, %ecx
adcl $0x0, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %ebx
movl %esi, %r12d
movq %rdi, -0x30(%rbp)
movl %esi, %r13d
subl %ecx, %r13d
movl %ecx, %r14d
cmovll %esi, %r14d
movslq %r14d, %r15
movq %rdx, -0x38(%rbp)
movq %rdx, %rdi
movq %r8, -0x40(%rbp)
movq %r8, %rsi
movq %r15, %rdx
callq 0x81a0
testl %eax, %eax
jne 0x679ea
movq -0x38(%rbp), %rax
cmpq $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rsi
je 0x679e7
subl %r14d, %r12d
jle 0x679c3
addq %r15, %rax
decq %rax
movl %r12d, %ecx
cmpb $0x20, (%rax,%rcx)
jne 0x679e7
leal -0x1(%r12), %ecx
cmpl $0x1, %r12d
movl %ecx, %r12d
jg 0x679aa
jmp 0x679c5
jne 0x679e7
subl %r14d, %ebx
jle 0x679e5
leaq (%rsi,%r15), %rax
decq %rax
movl %ebx, %ecx
cmpb $0x20, (%rax,%rcx)
jne 0x679e7
leal -0x1(%rbx), %ecx
cmpl $0x1, %ebx
movl %ecx, %ebx
jg 0x679d1
jmp 0x679f9
je 0x679f9
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x679ea
// File: /workspace/github_c_makefile_star2_O3/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
movl %esi, %eax
subl %ecx, %eax
movl %ecx, %edi
cmovll %esi, %edi
testl %edi, %edi
jle 0x67a5f
incl %edi
xorl %r10d, %r10d
leaq 0xe695(%rip), %r9       # 0x760b0
movzbl (%rdx,%r10), %r11d
testq %r11, %r11
je 0x67a44
movzbl (%r11,%r9), %r11d
movzbl (%r8,%r10), %ebx
movb (%rbx,%r9), %bl
cmpb %bl, %r11b
jne 0x67a50
decl %edi
incq %r10
cmpl $0x1, %edi
ja 0x67a1b
jmp 0x67a5f
movzbl (%r8,%r10), %eax
movb (%rax,%r9), %bl
xorl %r11d, %r11d
movzbl %bl, %eax
subl %ecx, %esi
subl %eax, %r11d
cmovel %esi, %r11d
movl %r11d, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3AutoLoadExtensions
SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3 *db){
  int i;
  int go = 1;
  int rc;
  int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*);

  wsdAutoextInit;
  if( wsdAutoext.nExt==0 ){
    /* Common case: early out without every having to acquire a mutex */
    return;
  }
  for(i=0; go; i++){
    char *zErrmsg;
#if SQLITE_THREADSAFE
    sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
#endif
    sqlite3_mutex_enter(mutex);
    if( i>=wsdAutoext.nExt ){
      xInit = 0;
      go = 0;
    }else{
      xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
              wsdAutoext.aExt[i];
    }
    sqlite3_mutex_leave(mutex);
    zErrmsg = 0;
    if( xInit && (rc = xInit(db, &zErrmsg, &sqlite3Apis))!=0 ){
      sqlite3Error(db, rc,
            "automatic extension loading failed: %s", zErrmsg);
      go = 0;
    }
    sqlite3_free(zErrmsg);
  }
}

// Assembly:
cmpl $0x0, 0x2e40f(%rip)     # 0x95e78
je 0x67b12
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x0, 0x2e3f3(%rip)     # 0x95e78
jle 0x67ade
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x111bc(%rip), %r14     # 0x78c50
leaq -0x28(%rbp), %r15
movq 0x2e3e1(%rip), %rax     # 0x95e80
movq (%rax,%r12,8), %rax
movq $0x0, -0x28(%rbp)
testq %rax, %rax
je 0x67ac5
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *%rax
movq -0x28(%rbp), %rcx
testl %eax, %eax
je 0x67ac7
jmp 0x67aea
xorl %ecx, %ecx
movq %rcx, %rdi
callq 0xa3c7
incq %r12
movslq 0x2e39f(%rip), %rax     # 0x95e78
cmpq %rax, %r12
jl 0x67a98
movq $0x0, -0x28(%rbp)
xorl %edi, %edi
jmp 0x67b01
leaq 0x15888(%rip), %rdx     # 0x7d379
movq %rbx, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0xca2d
movq -0x28(%rbp), %rdi
callq 0xa3c7
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x2c6ac(%rip), %al      # 0x96390
testb %al, %al
je 0x69e57
cmpb $0x0, 0x2c695(%rip)     # 0x96388
jne 0x69e41
movq 0x2a2c8(%rip), %rax     # 0x93fc8
movq (%rax), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0x69e3a
leaq 0x38(%rsp), %r13
movl $0x8, %r12d
leaq 0x48(%rsp), %rbx
leaq 0x28(%rsp), %r14
leaq 0x13ce6(%rip), %r15     # 0x7da11
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8170
movl $0x8, %ecx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x8420
movq %r14, %rdi
movq %r15, %rsi
callq 0x80f0
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x69d64
callq 0x8390
testl %ebp, %ebp
jne 0x69e0b
movq %rbx, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x8500
movq %rax, %rbp
shlq $0x20, %rbp
movabsq $-0x800000000, %rax     # imm = 0xFFFFFFF800000000
leaq (%rax,%rbp), %rcx
sarq $0x20, %rcx
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8420
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rbp
sarq $0x20, %rbp
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq $-0x1, %rcx
callq 0x8420
leaq 0x2c585(%rip), %rdi     # 0x96358
movq %r14, %rsi
callq 0x695f2
movq %rax, %rdi
leaq 0x8(%rsp), %rsi
callq 0x81f0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x69dfc
callq 0x8390
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x69e0b
callq 0x8390
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x69e1f
callq 0x8390
movq 0x2a1a2(%rip), %rax     # 0x93fc8
movq (%rax), %rax
movq (%rax,%r12), %rsi
addq $0x8, %r12
testq %rsi, %rsi
jne 0x69d2b
movb $0x1, 0x2c547(%rip)     # 0x96388
leaq 0x2c510(%rip), %rax     # 0x96358
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x87f0
jmp 0x69cec
jmp 0x69e85
jmp 0x69e80
jmp 0x69e80
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x69e88
callq 0x8390
jmp 0x69e88
movq %rax, %rbx
jmp 0x69e97
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x69e97
callq 0x8390
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x69eab
callq 0x8390
movq %rbx, %rdi
callq 0x8720
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0x10(%rdi), %r15
cmpq $0x0, 0x8(%rsi)
movq %r15, (%rdi)
je 0x6a52c
movq %rsi, %r14
leaq 0x13ed3(%rip), %rsi     # 0x7e393
leaq 0x13ecd(%rip), %rdx     # 0x7e394
movq %rbx, %rdi
callq 0x68bce
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x6a51d
movq (%r14), %r14
xorl %r13d, %r13d
movzbl (%r14,%r13), %eax
movsbl %al, %ebp
leal -0x9(%rax), %ecx
cmpl $0x2, %ecx
jb 0x6a50b
cmpl $0x27, %eax
jne 0x6a500
movq %rbx, %rdi
movl $0x27, %esi
callq 0x8310
movl %ebp, %edi
callq 0x8730
testl %eax, %eax
je 0x6a515
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8310
incq %r13
cmpq %r13, %r12
jne 0x6a4de
movq %rbx, %rdi
movl $0x27, %esi
callq 0x8310
jmp 0x6a542
leaq 0x13db2(%rip), %rsi     # 0x7e2e5
leaq 0x13daf(%rip), %rdx     # 0x7e2e9
movq %rbx, %rdi
callq 0x68bce
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6a556
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6a566
callq 0x8390
movq %r14, %rdi
callq 0x8720
// File: /workspace/github_c_makefile_star2_O3/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 0x6af58
movq %rsp, %r8
movq $0x0, (%r8)
movq 0x28(%rbx), %rdi
movq (%r14), %rsi
leaq 0x187(%rip), %rdx       # 0x6af54
xorl %ecx, %ecx
callq 0x1286d
testl %eax, %eax
je 0x6ae8b
movq 0x29205(%rip), %rdi     # 0x93fe8
leaq 0x12cf4(%rip), %rsi     # 0x7dade
movl $0x19, %edx
callq 0x8470
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x291e3(%rip), %rdi     # 0x93fe8
callq 0x8470
movq %rax, %rbx
leaq 0x130bc(%rip), %rsi     # 0x7ded0
movl $0x7, %edx
movq %rax, %rdi
callq 0x8470
movq (%rsp), %r14
testq %r14, %r14
je 0x6ae42
movq %r14, %rdi
callq 0x8190
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8470
jmp 0x6ae5b
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x86b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x83c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8250
movq (%rsp), %rdi
callq 0xa3c7
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ae9e
callq 0x8390
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6aebc
callq 0x8390
movq %rbx, %rdi
callq 0x8720
// File: /workspace/github_c_makefile_star2_O3/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 0x8290
leaq 0x18(%rsp), %r14
leaq 0x12f57(%rip), %rsi     # 0x7ded8
movl $0x18, %edx
movq %r14, %rdi
callq 0x8470
leaq 0x12f5c(%rip), %rsi     # 0x7def1
movl $0x12, %edx
movq %r14, %rdi
callq 0x8470
leaq 0x2b40f(%rip), %r12     # 0x963b8
leaq 0x12f75(%rip), %r15     # 0x7df25
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x6afde
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rdx
movq %r14, %rdi
callq 0x8470
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x8470
jmp 0x6afb3
leaq 0x12f1f(%rip), %rsi     # 0x7df04
movl $0x7, %edx
movq %r14, %rdi
callq 0x8470
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x8630
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 0x6b01f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x87e8
movq %rbx, %rdi
callq 0x8720
movq %rax, %rdi
callq 0x68a31
// File: /workspace/github_c_makefile_star2_O3/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 0x8290
leaq 0x30(%rsp), %r14
leaq 0x122b7(%rip), %rsi     # 0x7df0c
movl $0xc, %edx
movq %r14, %rdi
callq 0x8470
movq (%r15), %rax
movq %rsp, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x8470
leaq 0x1229b(%rip), %rsi     # 0x7df21
movl $0x2, %edx
movq %rax, %rdi
callq 0x8470
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6bca6
callq 0x8390
movq 0x20(%r15), %r13
leaq 0x10(%r15), %rbp
leaq 0x1019c(%rip), %r12     # 0x7be51
cmpq %rbp, %r13
je 0x6bcec
movq 0x20(%r13), %rsi
movq 0x28(%r13), %rdx
movq %r14, %rdi
callq 0x8470
movq %r13, %rdi
callq 0x8480
cmpq %rbp, %rax
je 0x6bcec
movq %rax, %r13
movl $0x2, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x8470
jmp 0x6bcb5
leaq 0x12226(%rip), %rsi     # 0x7df19
movl $0xa, %edx
movq %r14, %rdi
callq 0x8470
movq 0x20(%r15), %r12
leaq 0x10146(%rip), %r15     # 0x7be51
cmpq %rbp, %r12
je 0x6bd44
movq 0x40(%r12), %rsi
movq 0x48(%r12), %rdx
movq %r14, %rdi
callq 0x8470
movq %r12, %rdi
callq 0x8480
cmpq %rbp, %rax
je 0x6bd44
movq %rax, %r12
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x8470
jmp 0x6bd0b
leaq 0x121d9(%rip), %rsi     # 0x7df24
movl $0x3, %edx
movq %r14, %rdi
callq 0x8470
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x8630
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 0x6bda2
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6bda5
callq 0x8390
jmp 0x6bda5
jmp 0x6bda2
jmp 0x6bda2
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x87e8
movq %rbx, %rdi
callq 0x8720
movq %rax, %rdi
callq 0x68a31
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x29d7a(%rip), %rdi     # 0x963d8
callq 0x8760
movq %rax, %r14
leaq 0x1191a(%rip), %rsi     # 0x7df87
movl $0x8, %edx
movq %rbx, %rdi
callq 0x8470
movq %r14, %rdi
callq 0x86e0
testq %rax, %rax
je 0x6c6a2
movq %rax, %r14
movq %rax, %rdi
callq 0x8190
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8470
jmp 0x6c6b9
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x86b0
callq 0x6d2d2
cmpq %rax, (%rax)
je 0x6c75a
movq %rax, %r14
leaq 0x118bf(%rip), %rsi     # 0x7df90
movl $0xa, %edx
movq %rbx, %rdi
callq 0x8470
movq (%r14), %r12
cmpq %r14, %r12
je 0x6c714
leaq 0x11cc2(%rip), %r15     # 0x7e3af
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8470
movq 0x10(%r12), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movq (%r12), %r12
cmpq %r14, %r12
jne 0x6c6ed
leaq 0x11c94(%rip), %rsi     # 0x7e3af
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8470
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x83c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8250
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movb $0x1, %al
testq %rdi, %rdi
je 0x6cac7
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %cl
testb %cl, %cl
je 0x6cac6
incq %rbx
movsbl %cl, %edi
callq 0x8380
testl %eax, %eax
setne %al
je 0x6cac6
movb (%rbx), %cl
incq %rbx
testb %cl, %cl
jne 0x6caae
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x10(%rdi)
je 0x6ce08
leaq 0x11244(%rip), %rsi     # 0x7e02d
movl $0x3, %edx
movq %rbx, %rdi
callq 0x8470
movb 0x10(%r14), %al
leaq 0x8(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
jmp 0x6ce14
leaq 0x11222(%rip), %rsi     # 0x7e031
movl $0x4, %edx
movq %rbx, %rdi
callq 0x8470
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x6cf00
movl 0x295fc(%rip), %r13d    # 0x9642c
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x8170
movl 0x8(%r15), %ebp
negl %ebp
movq (%r15), %rdi
leaq 0x18(%rsp), %r12
cmpq %r12, %rdi
je 0x6ce5a
callq 0x8390
leaq 0x111d5(%rip), %rsi     # 0x7e036
movl $0x4, %edx
movq %rbx, %rdi
callq 0x8470
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x6ce8f
movq %r15, %rdi
callq 0x8190
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x8470
jmp 0x6cea6
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x86b0
addl %r13d, %ebp
addl $0x2, %ebp
cmpb $0x1, 0x20(%r14)
jne 0x6ceca
leaq 0x11147(%rip), %rsi     # 0x7e001
movl $0x6, %edx
movq %rbx, %rdi
callq 0x8470
addl $-0x6, %ebp
movslq %ebp, %rsi
leaq 0x8(%rsp), %r15
movq %r12, (%r15)
movq %r15, %rdi
movl $0x20, %edx
callq 0x8490
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x8470
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6cf00
callq 0x8390
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x6cf1f
movq %r14, %rdi
callq 0x8190
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8470
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6cf43
callq 0x8390
movq %rbx, %rdi
callq 0x8720
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x6cdc8
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x6cfd3
cmpl $0x0, (%rax)
je 0x6cfd3
leaq 0x11083(%rip), %rsi     # 0x7e03b
movl $0xb, %edx
movq %rbx, %rdi
callq 0x8470
movq 0x28(%r14), %rax
movl (%rax), %esi
movq %rbx, %rdi
callq 0x86d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x6d071
movq %rsi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x8190
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x68bce
movq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x81f0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6d083
callq 0x8390
jmp 0x6d083
movq 0x28(%rbx), %rax
movq $0x0, 0x8(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6d0a1
callq 0x8390
movq %rbx, %rdi
callq 0x8720
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x6cdc8
movq 0x28(%r14), %rax
cmpq $0x0, 0x8(%rax)
je 0x6d0ff
leaq 0x10f7c(%rip), %rsi     # 0x7e047
movl $0xc, %edx
movq %rbx, %rdi
callq 0x8470
movq 0x28(%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x8470
leaq 0x112a1(%rip), %rsi     # 0x7e393
movl $0x1, %edx
movq %rax, %rdi
callq 0x8470
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
testq %rsi, %rsi
je 0x6d228
movq %rsi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x8190
leaq (%rax,%rbx), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x68bce
leaq 0x10895(%rip), %rsi     # 0x7da1a
movq %r15, %rdi
callq 0x80f0
testl %eax, %eax
je 0x6d231
leaq 0x10eb8(%rip), %rsi     # 0x7e054
leaq 0x8(%rsp), %rdi
callq 0x80f0
testl %eax, %eax
je 0x6d235
movq 0x26e33(%rip), %rdi     # 0x93fe8
leaq 0x10e9e(%rip), %rsi     # 0x7e05a
movl $0x39, %edx
callq 0x8470
movq %rbx, %rdi
callq 0x8190
movq 0x26e13(%rip), %rdi     # 0x93fe8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x8470
movq 0x26e01(%rip), %rbx     # 0x93fe8
leaq 0x111a5(%rip), %rsi     # 0x7e393
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8470
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x83c0
movsbl %al, %esi
movq 0x26dcf(%rip), %rdi     # 0x93fe8
callq 0x8040
movq %rax, %rdi
callq 0x8250
jmp 0x6d23d
movq 0x28(%r14), %rax
movb $0x1, (%rax)
jmp 0x6d24c
movb $0x1, %al
jmp 0x6d237
xorl %eax, %eax
movq 0x28(%r14), %rcx
movb %al, (%rcx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6d24c
callq 0x8390
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6d26a
callq 0x8390
movq %rbx, %rdi
callq 0x8720
// File: /workspace/github_c_makefile_star2_O3/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 0x6cdc8
cmpb $0x1, 0x20(%r14)
jne 0x6d2c4
leaq 0x10dac(%rip), %rsi     # 0x7e03b
movl $0xb, %edx
movq %rbx, %rdi
callq 0x8470
movq 0x28(%r14), %rax
movzbl (%rax), %edx
leaq 0x10770(%rip), %rax     # 0x7da1a
leaq 0x10da3(%rip), %rsi     # 0x7e054
testq %rdx, %rdx
cmovneq %rax, %rsi
xorq $0x5, %rdx
movq %rbx, %rdi
callq 0x8470
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movb %bpl, 0x6(%rsp)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x6d5b9
leaq 0x8(%r14), %rdx
movq %rdx, %rcx
xorl %esi, %esi
cmpb %bpl, 0x20(%rax)
setl %sil
cmovgeq %rax, %rcx
movq 0x10(%rax,%rsi,8), %rax
testq %rax, %rax
jne 0x6d4cd
cmpq %rdx, %rcx
je 0x6d5b9
cmpb %bpl, 0x20(%rcx)
jg 0x6d5b9
movq 0x26ae9(%rip), %r15     # 0x93fe8
leaq 0x10b8e(%rip), %rsi     # 0x7e094
movl $0x2f, %edx
movq %r15, %rdi
callq 0x8470
leaq 0x10e79(%rip), %rsi     # 0x7e393
movl $0x1, %edx
movq %r15, %rdi
callq 0x8470
leaq 0x7(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x8470
movq %rax, %r15
leaq 0x10935(%rip), %rsi     # 0x7de7b
movl $0x2, %edx
movq %rax, %rdi
callq 0x8470
leaq 0x6(%rsp), %rsi
movq %r14, %rdi
callq 0x6d442
movq (%rax), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x10(%rax)
movq %rax, %r15
leaq 0x10e39(%rip), %rsi     # 0x7e3af
movl $0x1, %edx
movq %rax, %rdi
callq 0x8470
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x83c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8250
leaq 0x6(%rsp), %rsi
movq %r14, %rdi
callq 0x6d442
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq 0x2883d(%rip), %r14     # 0x96528
leaq 0x28826(%rip), %r12     # 0x96518
cmpq %r12, %r14
je 0x6dd2b
movq 0x40(%r14), %r15
testq %r15, %r15
je 0x6dd1b
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x695f2
addq $0x28, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x81f0
movq %r14, %rdi
callq 0x8270
movq %rax, %r14
cmpq %r12, %rax
jne 0x6dcf7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x68a76
movq %r14, %rdi
callq 0x8720
movq %rax, %rdi
callq 0x68a31
nop
// File: /workspace/github_c_makefile_star2_O3/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
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq $0x4, 0x8(%rsp)
movq (%rsi), %r13
cmpq %rsi, %r13
je 0x6e027
movl %edx, %ebp
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
testb %bpl, %bpl
je 0x6dff7
movq 0x18(%r13), %rax
addq $0x4, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
jne 0x6e006
movq %rbx, %rdi
movq %r15, %rdx
callq 0x6f65c
jmp 0x6e01e
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6e013
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6e01e
movq %rbx, %rdi
movq %r12, %rdx
callq 0x6f65c
movq (%r13), %r13
cmpq %r14, %r13
jne 0x6dfce
movq 0x30(%r14), %rsi
testq %rsi, %rsi
je 0x6e094
movq (%rbx), %rax
movq 0x38(%r14), %rdi
xorl %ecx, %ecx
movl $0x50, %edx
testq %rdi, %rdi
je 0x6e08a
movq 0x18(%r14), %rsi
leaq (%rcx,%rcx,2), %rdi
movq (%rsi,%rdi,8), %rsi
addq $0x8, %rsi
xorl %r8d, %r8d
movq (%rsi), %rdi
addq $0x4, %rdi
movq (%rax,%r8,8), %r9
cmpq $0x50, %rdi
cmovaeq %rdx, %rdi
cmpq %rdi, %r9
cmovaq %r9, %rdi
movq %rdi, (%rax,%r8,8)
incq %r8
movq 0x38(%r14), %rdi
addq $0x20, %rsi
cmpq %rdi, %r8
jb 0x6e056
movq 0x30(%r14), %rsi
jmp 0x6e08c
xorl %edi, %edi
incq %rcx
cmpq %rsi, %rcx
jb 0x6e03e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e0a8
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6e0b8
callq 0x8390
movq %r14, %rdi
callq 0x8720
// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
testq %rsi, %rsi
je 0x6e241
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movzbl 0x48(%rdi), %edx
movq %rsp, %rdi
callq 0x6df8f
cmpb $0x1, 0x48(%r15)
jne 0x6e181
movq 0x8(%rsp), %r15
subq (%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 0x6e15a
cmpq %r15, %r12
jae 0x6e148
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl %ebp, %edx
orl $0x20, %edx
movl %edx, 0x18(%rbx,%rcx)
movq (%rsp), %rcx
movslq (%rcx,%r12,8), %rcx
incq %r12
movq -0x18(%rax), %rax
movq %rcx, 0x10(%rbx,%rax)
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rdx
movq %rbx, %rdi
callq 0x8470
jmp 0x6e112
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x83c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8250
cmpq $0x0, 0x30(%r14)
je 0x6e233
xorl %r15d, %r15d
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x6e1ff
movl $0x8, %r12d
leaq (%r15,%r15,2), %r13
xorl %ebp, %ebp
decq %rax
cmpq %rax, %rbp
jae 0x6e1d6
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
movl $0xffffff4f, %esi       # imm = 0xFFFFFF4F
andl %esi, %edx
orl $0x20, %edx
movl %edx, 0x18(%rbx,%rcx)
movq (%rsp), %rcx
movslq (%rcx,%rbp,8), %rcx
movq -0x18(%rax), %rax
movq %rcx, 0x10(%rbx,%rax)
movq 0x18(%r14), %rax
movq (%rax,%r13,8), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x8470
incq %rbp
movq 0x38(%r14), %rax
addq $0x20, %r12
cmpq %rax, %rbp
jb 0x6e1a4
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x83c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8250
incq %r15
cmpq 0x30(%r14), %r15
jb 0x6e18f
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6e241
callq 0x8390
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e256
jmp 0x6e256
jmp 0x6e256
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6e267
callq 0x8390
movq %rbx, %rdi
callq 0x8720