// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeCommit
static int vdbeCommit(sqlite3 *db, Vdbe *p){
  int i;
  int nTrans = 0;  /* Number of databases with an active write-transaction
                   ** that are candidates for a two-phase commit using a
                   ** super-journal */
  int rc = SQLITE_OK;
  int needXcommit = 0;

#ifdef SQLITE_OMIT_VIRTUALTABLE
  /* With this option, sqlite3VtabSync() is defined to be simply
  ** SQLITE_OK so p is not used.
  */
  UNUSED_PARAMETER(p);
#endif

  /* Before doing anything else, call the xSync() callback for any
  ** virtual module tables written in this transaction. This has to
  ** be done before determining whether a super-journal file is
  ** required, as an xSync() callback may add an attached database
  ** to the transaction.
  */
  rc = sqlite3VtabSync(db, p);

  /* This loop determines (a) if the commit hook should be invoked and
  ** (b) how many database files have open write transactions, not
  ** including the temp database. (b) is important because if more than
  ** one database file has an open write transaction, a super-journal
  ** file is required for an atomic commit.
  */
  for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
    Btree *pBt = db->aDb[i].pBt;
    if( sqlite3BtreeIsInTrans(pBt) ){
      /* Whether or not a database might need a super-journal depends upon
      ** its journal mode (among other things).  This matrix determines which
      ** journal modes use a super-journal and which do not */
      static const u8 aMJNeeded[] = {
        /* DELETE   */  1,
        /* PERSIST   */ 1,
        /* OFF       */ 0,
        /* TRUNCATE  */ 1,
        /* MEMORY    */ 0,
        /* WAL       */ 0
      };
      Pager *pPager;   /* Pager associated with pBt */
      needXcommit = 1;
      sqlite3BtreeEnter(pBt);
      pPager = sqlite3BtreePager(pBt);
      if( db->aDb[i].safety_level!=PAGER_SYNCHRONOUS_OFF
       && aMJNeeded[sqlite3PagerGetJournalMode(pPager)]
       && sqlite3PagerIsMemdb(pPager)==0
      ){
        assert( i!=1 );
        nTrans++;
      }
      rc = sqlite3PagerExclusiveLock(pPager);
      sqlite3BtreeLeave(pBt);
    }
  }
  if( rc!=SQLITE_OK ){
    return rc;
  }

  /* If there are any write-transactions at all, invoke the commit hook */
  if( needXcommit && db->xCommitCallback ){
    rc = db->xCommitCallback(db->pCommitArg);
    if( rc ){
      return SQLITE_CONSTRAINT_COMMITHOOK;
    }
  }

  /* The simple case - no more than one database file (not counting the
  ** TEMP database) has a transaction active.   There is no need for the
  ** super-journal.
  **
  ** If the return value of sqlite3BtreeGetFilename() is a zero length
  ** string, it means the main database is :memory: or a temp file.  In
  ** that case we do not support atomic multi-file commits, so use the
  ** simple case then too.
  */
  if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt))
   || nTrans<=1
  ){
    for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
      Btree *pBt = db->aDb[i].pBt;
      if( pBt ){
        rc = sqlite3BtreeCommitPhaseOne(pBt, 0);
      }
    }

    /* Do the commit only if all databases successfully complete phase 1.
    ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an
    ** IO error while deleting or truncating a journal file. It is unlikely,
    ** but could happen. In this case abandon processing and return the error.
    */
    for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
      Btree *pBt = db->aDb[i].pBt;
      if( pBt ){
        rc = sqlite3BtreeCommitPhaseTwo(pBt, 0);
      }
    }
    if( rc==SQLITE_OK ){
      sqlite3VtabCommit(db);
    }
  }

  /* The complex case - There is a multi-file write-transaction active.
  ** This requires a super-journal file to ensure the transaction is
  ** committed atomically.
  */
#ifndef SQLITE_OMIT_DISKIO
  else{
    sqlite3_vfs *pVfs = db->pVfs;
    char *zSuper = 0;   /* File-name for the super-journal */
    char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt);
    sqlite3_file *pSuperJrnl = 0;
    i64 offset = 0;
    int res;
    int retryCount = 0;
    int nMainFile;

    /* Select a super-journal file name */
    nMainFile = sqlite3Strlen30(zMainFile);
    zSuper = sqlite3MPrintf(db, "%.4c%s%.16c", 0,zMainFile,0);
    if( zSuper==0 ) return SQLITE_NOMEM_BKPT;
    zSuper += 4;
    do {
      u32 iRandom;
      if( retryCount ){
        if( retryCount>100 ){
          sqlite3_log(SQLITE_FULL, "MJ delete: %s", zSuper);
          sqlite3OsDelete(pVfs, zSuper, 0);
          break;
        }else if( retryCount==1 ){
          sqlite3_log(SQLITE_FULL, "MJ collide: %s", zSuper);
        }
      }
      retryCount++;
      sqlite3_randomness(sizeof(iRandom), &iRandom);
      sqlite3_snprintf(13, &zSuper[nMainFile], "-mj%06X9%02X",
                               (iRandom>>8)&0xffffff, iRandom&0xff);
      /* The antipenultimate character of the super-journal name must
      ** be "9" to avoid name collisions when using 8+3 filenames. */
      assert( zSuper[sqlite3Strlen30(zSuper)-3]=='9' );
      sqlite3FileSuffix3(zMainFile, zSuper);
      rc = sqlite3OsAccess(pVfs, zSuper, SQLITE_ACCESS_EXISTS, &res);
    }while( rc==SQLITE_OK && res );
    if( rc==SQLITE_OK ){
      /* Open the super-journal. */
      rc = sqlite3OsOpenMalloc(pVfs, zSuper, &pSuperJrnl,
          SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|
          SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_SUPER_JOURNAL, 0
      );
    }
    if( rc!=SQLITE_OK ){
      sqlite3DbFree(db, zSuper-4);
      return rc;
    }

    /* Write the name of each database file in the transaction into the new
    ** super-journal file. If an error occurs at this point close
    ** and delete the super-journal file. All the individual journal files
    ** still have 'null' as the super-journal pointer, so they will roll
    ** back independently if a failure occurs.
    */
    for(i=0; i<db->nDb; i++){
      Btree *pBt = db->aDb[i].pBt;
      if( sqlite3BtreeIsInTrans(pBt) ){
        char const *zFile = sqlite3BtreeGetJournalname(pBt);
        if( zFile==0 ){
          continue;  /* Ignore TEMP and :memory: databases */
        }
        assert( zFile[0]!=0 );
        rc = sqlite3OsWrite(pSuperJrnl, zFile, sqlite3Strlen30(zFile)+1,offset);
        offset += sqlite3Strlen30(zFile)+1;
        if( rc!=SQLITE_OK ){
          sqlite3OsCloseFree(pSuperJrnl);
          sqlite3OsDelete(pVfs, zSuper, 0);
          sqlite3DbFree(db, zSuper-4);
          return rc;
        }
      }
    }

    /* Sync the super-journal file. If the IOCAP_SEQUENTIAL device
    ** flag is set this is not required.
    */
    if( 0==(sqlite3OsDeviceCharacteristics(pSuperJrnl)&SQLITE_IOCAP_SEQUENTIAL)
     && SQLITE_OK!=(rc = sqlite3OsSync(pSuperJrnl, SQLITE_SYNC_NORMAL))
    ){
      sqlite3OsCloseFree(pSuperJrnl);
      sqlite3OsDelete(pVfs, zSuper, 0);
      sqlite3DbFree(db, zSuper-4);
      return rc;
    }

    /* Sync all the db files involved in the transaction. The same call
    ** sets the super-journal pointer in each individual journal. If
    ** an error occurs here, do not delete the super-journal file.
    **
    ** If the error occurs during the first call to
    ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the
    ** super-journal file will be orphaned. But we cannot delete it,
    ** in case the super-journal file name was written into the journal
    ** file before the failure occurred.
    */
    for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
      Btree *pBt = db->aDb[i].pBt;
      if( pBt ){
        rc = sqlite3BtreeCommitPhaseOne(pBt, zSuper);
      }
    }
    sqlite3OsCloseFree(pSuperJrnl);
    assert( rc!=SQLITE_BUSY );
    if( rc!=SQLITE_OK ){
      sqlite3DbFree(db, zSuper-4);
      return rc;
    }

    /* Delete the super-journal file. This commits the transaction. After
    ** doing this the directory is synced again before any individual
    ** transaction files are deleted.
    */
    rc = sqlite3OsDelete(pVfs, zSuper, 1);
    sqlite3DbFree(db, zSuper-4);
    zSuper = 0;
    if( rc ){
      return rc;
    }

    /* All files and directories have already been synced, so the following
    ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and
    ** deleting or truncating journals. If something goes wrong while
    ** this is happening we don't really care. The integrity of the
    ** transaction is already guaranteed, but some stray 'cold' journals
    ** may be lying around. Returning an error code won't help matters.
    */
    disable_simulated_io_errors();
    sqlite3BeginBenignMalloc();
    for(i=0; i<db->nDb; i++){
      Btree *pBt = db->aDb[i].pBt;
      if( pBt ){
        sqlite3BtreeCommitPhaseTwo(pBt, 1);
      }
    }
    sqlite3EndBenignMalloc();
    enable_simulated_io_errors();

    sqlite3VtabCommit(db);
  }
#endif

  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3ed8e0
movl %eax, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0xa1(%rbp)
jne 0x3ec350
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
setl %al
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x3ec35f
jmp 0x3ec410
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3d0900
cmpl $0x0, %eax
je 0x3ec400
movl $0x1, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3c5aa0
movq -0x30(%rbp), %rdi
callq 0x3bfda0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
je 0x3ec3f4
movq -0x38(%rbp), %rdi
callq 0x3c5fe0
movslq %eax, %rcx
leaq 0x1baf2c(%rip), %rax    # 0x5a7300
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3ec3f4
movq -0x38(%rbp), %rdi
callq 0x3e7dc0
cmpl $0x0, %eax
jne 0x3ec3f4
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3e03b0
movl %eax, -0x24(%rbp)
jmp 0x3ec402
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ec32f
cmpl $0x0, -0x24(%rbp)
je 0x3ec421
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3eca08
cmpl $0x0, -0x28(%rbp)
je 0x3ec464
movq -0x10(%rbp), %rax
cmpq $0x0, 0x108(%rax)
je 0x3ec464
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x100(%rcx), %rdi
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x3ec462
movl $0x213, -0x4(%rbp)      # imm = 0x213
jmp 0x3eca08
jmp 0x3ec464
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x3d5930
movq %rax, %rdi
callq 0x3c3400
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x3ec48f
cmpl $0x1, -0x20(%rbp)
jg 0x3ec587
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0xa2(%rbp)
jne 0x3ec4b7
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
setl %al
movb %al, -0xa2(%rbp)
movb -0xa2(%rbp), %al
testb $0x1, %al
jne 0x3ec4c3
jmp 0x3ec502
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x3ec4f5
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3c6b10
movl %eax, -0x24(%rbp)
jmp 0x3ec4f7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ec496
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0xa3(%rbp)
jne 0x3ec52a
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
setl %al
movb %al, -0xa3(%rbp)
movb -0xa3(%rbp), %al
testb $0x1, %al
jne 0x3ec536
jmp 0x3ec573
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x3ec566
movq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x3c6a60
movl %eax, -0x24(%rbp)
jmp 0x3ec568
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ec509
cmpl $0x0, -0x24(%rbp)
jne 0x3ec582
movq -0x10(%rbp), %rdi
callq 0x3ed9c0
jmp 0x3eca02
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x3d5930
movq %rax, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movl $0x0, -0x78(%rbp)
movq -0x60(%rbp), %rdi
callq 0x3c3400
movl %eax, -0x7c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rcx
leaq 0x1bec3f(%rip), %rsi    # 0x5ab220
xorl %r8d, %r8d
movl %r8d, %edx
movb $0x0, %al
callq 0x3cb7d0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x3ec605
movl $0x7, -0x4(%rbp)
jmp 0x3eca08
movq -0x58(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x58(%rbp)
cmpl $0x0, -0x78(%rbp)
je 0x3ec669
cmpl $0x64, -0x78(%rbp)
jle 0x3ec648
movq -0x58(%rbp), %rdx
movl $0xd, %edi
leaq 0x1bebff(%rip), %rsi    # 0x5ab22c
movb $0x0, %al
callq 0x3c3970
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
xorl %edx, %edx
callq 0x3e3c10
jmp 0x3ec6f4
cmpl $0x1, -0x78(%rbp)
jne 0x3ec665
movq -0x58(%rbp), %rdx
movl $0xd, %edi
leaq 0x1bebdc(%rip), %rsi    # 0x5ab23a
movb $0x0, %al
callq 0x3c3970
jmp 0x3ec667
jmp 0x3ec669
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
movl $0x4, %edi
leaq -0x80(%rbp), %rsi
callq 0x3c3b60
movq -0x58(%rbp), %rsi
movslq -0x7c(%rbp), %rax
addq %rax, %rsi
movl -0x80(%rbp), %ecx
shrl $0x8, %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
movl -0x80(%rbp), %r8d
andl $0xff, %r8d
movl $0xd, %edi
leaq 0x1beb9b(%rip), %rdx    # 0x5ab249
movb $0x0, %al
callq 0x3c38c0
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
xorl %edx, %edx
leaq -0x74(%rbp), %rcx
callq 0x3e36f0
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0xa4(%rbp)
jne 0x3ec6e6
cmpl $0x0, -0x74(%rbp)
setne %al
movb %al, -0xa4(%rbp)
movb -0xa4(%rbp), %al
testb $0x1, %al
jne 0x3ec611
cmpl $0x0, -0x24(%rbp)
jne 0x3ec718
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0x68(%rbp), %rdx
movl $0x4016, %ecx           # imm = 0x4016
xorl %eax, %eax
movl %eax, %r8d
callq 0x3ed9f0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x3ec73a
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
addq $-0x4, %rsi
callq 0x3c00a0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3eca08
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x3ec84f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0x3d0900
cmpl $0x0, %eax
je 0x3ec83f
movq -0x88(%rbp), %rdi
callq 0x3eda70
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x90(%rbp)
jne 0x3ec7a6
jmp 0x3ec841
movq -0x68(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x90(%rbp), %rdi
callq 0x3c3400
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movl %eax, %edx
addl $0x1, %edx
movq -0x70(%rbp), %rcx
callq 0x3c6930
movl %eax, -0x24(%rbp)
movq -0x90(%rbp), %rdi
callq 0x3c3400
addl $0x1, %eax
cltq
addq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x3ec83d
movq -0x68(%rbp), %rdi
callq 0x3ed630
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
xorl %edx, %edx
callq 0x3e3c10
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
addq $-0x4, %rsi
callq 0x3c00a0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3eca08
jmp 0x3ec83f
jmp 0x3ec841
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ec741
movq -0x68(%rbp), %rdi
callq 0x3dbbe0
movl %eax, %ecx
andl $0x400, %ecx            # imm = 0x400
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3ec8b3
movq -0x68(%rbp), %rdi
movl $0x2, %esi
callq 0x3ddf70
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x3ec8b3
movq -0x68(%rbp), %rdi
callq 0x3ed630
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
xorl %edx, %edx
callq 0x3e3c10
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
addq $-0x4, %rsi
callq 0x3c00a0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3eca08
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0xb9(%rbp)
jne 0x3ec8db
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
setl %al
movb %al, -0xb9(%rbp)
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x3ec8e7
jmp 0x3ec92f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
je 0x3ec922
movq -0x98(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x3c6b10
movl %eax, -0x24(%rbp)
jmp 0x3ec924
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ec8ba
movq -0x68(%rbp), %rdi
callq 0x3ed630
cmpl $0x0, -0x24(%rbp)
je 0x3ec95a
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
addq $-0x4, %rsi
callq 0x3c00a0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3eca08
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl $0x1, %edx
callq 0x3e3c10
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
addq $-0x4, %rsi
callq 0x3c00a0
movq $0x0, -0x58(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x3ec996
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3eca08
callq 0x3e01d0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x3ec9f4
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0xa0(%rbp)
je 0x3ec9e7
movq -0xa0(%rbp), %rdi
movl $0x1, %esi
callq 0x3c6a60
jmp 0x3ec9e9
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ec9a2
callq 0x3e0220
movq -0x10(%rbp), %rdi
callq 0x3ed9c0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)