// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_config
SQLITE_API int sqlite3_config(int op, ...){
  va_list ap;
  int rc = SQLITE_OK;

  /* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while
  ** the SQLite library is in use. */
  if( sqlite3GlobalConfig.isInit ) return SQLITE_MISUSE_BKPT;

  va_start(ap, op);
  switch( op ){

    /* Mutex configuration options are only available in a threadsafe
    ** compile. 
    */
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0
    case SQLITE_CONFIG_SINGLETHREAD: {
      /* Disable all mutexing */
      sqlite3GlobalConfig.bCoreMutex = 0;
      sqlite3GlobalConfig.bFullMutex = 0;
      break;
    }
    case SQLITE_CONFIG_MULTITHREAD: {
      /* Disable mutexing of database connections */
      /* Enable mutexing of core data structures */
      sqlite3GlobalConfig.bCoreMutex = 1;
      sqlite3GlobalConfig.bFullMutex = 0;
      break;
    }
    case SQLITE_CONFIG_SERIALIZED: {
      /* Enable all mutexing */
      sqlite3GlobalConfig.bCoreMutex = 1;
      sqlite3GlobalConfig.bFullMutex = 1;
      break;
    }
    case SQLITE_CONFIG_MUTEX: {
      /* Specify an alternative mutex implementation */
      sqlite3GlobalConfig.mutex = *va_arg(ap, sqlite3_mutex_methods*);
      break;
    }
    case SQLITE_CONFIG_GETMUTEX: {
      /* Retrieve the current mutex implementation */
      *va_arg(ap, sqlite3_mutex_methods*) = sqlite3GlobalConfig.mutex;
      break;
    }
#endif


    case SQLITE_CONFIG_MALLOC: {
      /* Specify an alternative malloc implementation */
      sqlite3GlobalConfig.m = *va_arg(ap, sqlite3_mem_methods*);
      break;
    }
    case SQLITE_CONFIG_GETMALLOC: {
      /* Retrieve the current malloc() implementation */
      if( sqlite3GlobalConfig.m.xMalloc==0 ) sqlite3MemSetDefault();
      *va_arg(ap, sqlite3_mem_methods*) = sqlite3GlobalConfig.m;
      break;
    }
    case SQLITE_CONFIG_MEMSTATUS: {
      /* Enable or disable the malloc status collection */
      sqlite3GlobalConfig.bMemstat = va_arg(ap, int);
      break;
    }
    case SQLITE_CONFIG_SCRATCH: {
      /* Designate a buffer for scratch memory space */
      sqlite3GlobalConfig.pScratch = va_arg(ap, void*);
      sqlite3GlobalConfig.szScratch = va_arg(ap, int);
      sqlite3GlobalConfig.nScratch = va_arg(ap, int);
      break;
    }
    case SQLITE_CONFIG_PAGECACHE: {
      /* Designate a buffer for page cache memory space */
      sqlite3GlobalConfig.pPage = va_arg(ap, void*);
      sqlite3GlobalConfig.szPage = va_arg(ap, int);
      sqlite3GlobalConfig.nPage = va_arg(ap, int);
      break;
    }

    case SQLITE_CONFIG_PCACHE: {
      /* no-op */
      break;
    }
    case SQLITE_CONFIG_GETPCACHE: {
      /* now an error */
      rc = SQLITE_ERROR;
      break;
    }

    case SQLITE_CONFIG_PCACHE2: {
      /* Specify an alternative page cache implementation */
      sqlite3GlobalConfig.pcache2 = *va_arg(ap, sqlite3_pcache_methods2*);
      break;
    }
    case SQLITE_CONFIG_GETPCACHE2: {
      if( sqlite3GlobalConfig.pcache2.xInit==0 ){
        sqlite3PCacheSetDefault();
      }
      *va_arg(ap, sqlite3_pcache_methods2*) = sqlite3GlobalConfig.pcache2;
      break;
    }

#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
    case SQLITE_CONFIG_HEAP: {
      /* Designate a buffer for heap memory space */
      sqlite3GlobalConfig.pHeap = va_arg(ap, void*);
      sqlite3GlobalConfig.nHeap = va_arg(ap, int);
      sqlite3GlobalConfig.mnReq = va_arg(ap, int);

      if( sqlite3GlobalConfig.mnReq<1 ){
        sqlite3GlobalConfig.mnReq = 1;
      }else if( sqlite3GlobalConfig.mnReq>(1<<12) ){
        /* cap min request size at 2^12 */
        sqlite3GlobalConfig.mnReq = (1<<12);
      }

      if( sqlite3GlobalConfig.pHeap==0 ){
        /* If the heap pointer is NULL, then restore the malloc implementation
        ** back to NULL pointers too.  This will cause the malloc to go
        ** back to its default implementation when sqlite3_initialize() is
        ** run.
        */
        memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m));
      }else{
        /* The heap pointer is not NULL, then install one of the
        ** mem5.c/mem3.c methods.  The enclosing #if guarantees at
        ** least one of these methods is currently enabled.
        */
#ifdef SQLITE_ENABLE_MEMSYS3
        sqlite3GlobalConfig.m = *sqlite3MemGetMemsys3();
#endif
#ifdef SQLITE_ENABLE_MEMSYS5
        sqlite3GlobalConfig.m = *sqlite3MemGetMemsys5();
#endif
      }
      break;
    }
#endif

    case SQLITE_CONFIG_LOOKASIDE: {
      sqlite3GlobalConfig.szLookaside = va_arg(ap, int);
      sqlite3GlobalConfig.nLookaside = va_arg(ap, int);
      break;
    }
    
    /* Record a pointer to the logger function and its first argument.
    ** The default is NULL.  Logging is disabled if the function pointer is
    ** NULL.
    */
    case SQLITE_CONFIG_LOG: {
      /* MSVC is picky about pulling func ptrs from va lists.
      ** http://support.microsoft.com/kb/47961
      ** sqlite3GlobalConfig.xLog = va_arg(ap, void(*)(void*,int,const char*));
      */
      typedef void(*LOGFUNC_t)(void*,int,const char*);
      sqlite3GlobalConfig.xLog = va_arg(ap, LOGFUNC_t);
      sqlite3GlobalConfig.pLogArg = va_arg(ap, void*);
      break;
    }

    case SQLITE_CONFIG_URI: {
      sqlite3GlobalConfig.bOpenUri = va_arg(ap, int);
      break;
    }

    case SQLITE_CONFIG_COVERING_INDEX_SCAN: {
      sqlite3GlobalConfig.bUseCis = va_arg(ap, int);
      break;
    }

#ifdef SQLITE_ENABLE_SQLLOG
    case SQLITE_CONFIG_SQLLOG: {
      typedef void(*SQLLOGFUNC_t)(void*, sqlite3*, const char*, int);
      sqlite3GlobalConfig.xSqllog = va_arg(ap, SQLLOGFUNC_t);
      sqlite3GlobalConfig.pSqllogArg = va_arg(ap, void *);
      break;
    }
#endif

    case SQLITE_CONFIG_MMAP_SIZE: {
      sqlite3_int64 szMmap = va_arg(ap, sqlite3_int64);
      sqlite3_int64 mxMmap = va_arg(ap, sqlite3_int64);
      if( mxMmap<0 || mxMmap>SQLITE_MAX_MMAP_SIZE ){
        mxMmap = SQLITE_MAX_MMAP_SIZE;
      }
      sqlite3GlobalConfig.mxMmap = mxMmap;
      if( szMmap<0 ) szMmap = SQLITE_DEFAULT_MMAP_SIZE;
      if( szMmap>mxMmap) szMmap = mxMmap;
      sqlite3GlobalConfig.szMmap = szMmap;
      break;
    }

    default: {
      rc = SQLITE_ERROR;
      break;
    }
  }
  va_end(ap);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp            # imm = 0x2C0
testb %al, %al
je 0x174eb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movl %edi, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x0, 0xb90d1(%rip)     # 0xd05f0
je 0x17533
movl $0x1c4d6, %edi          # imm = 0x1C4D6
callq 0x9420
movl %eax, -0x4(%rbp)
jmp 0x17e3d
leaq -0xf0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movl -0x8(%rbp), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0xf8(%rbp)
subl $0x12, %eax
ja 0x17e2c
movq -0xf8(%rbp), %rax
leaq 0x91cb6(%rip), %rcx     # 0xa9230
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x20(%rbp), %rax
movq %rax, -0x108(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xfc(%rbp)
cmpl $0x28, %eax
ja 0x175be
movq -0x108(%rbp), %rcx
movl -0xfc(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x110(%rbp)
jmp 0x175db
movq -0x108(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x110(%rbp)
movq -0x110(%rbp), %rax
movq (%rax), %rsi
leaq 0xb8ea4(%rip), %rdi     # 0xd0490
addq $0x20, %rdi
movl $0x40, %edx
callq 0x82f0
jmp 0x17e33
cmpq $0x0, 0xb8ea9(%rip)     # 0xd04b0
jne 0x1760e
callq 0x17e50
leaq -0x20(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x28, %eax
ja 0x17649
movq -0x120(%rbp), %rcx
movl -0x114(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x128(%rbp)
jmp 0x17666
movq -0x120(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movq (%rax), %rdi
leaq 0xb8e19(%rip), %rsi     # 0xd0490
addq $0x20, %rsi
movl $0x40, %edx
callq 0x82f0
jmp 0x17e33
leaq -0x20(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x12c(%rbp)
cmpl $0x28, %eax
ja 0x176c5
movq -0x138(%rbp), %rcx
movl -0x12c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x140(%rbp)
jmp 0x176e2
movq -0x138(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xb8d9f(%rip)     # 0xd0490
jmp 0x17e33
leaq -0x20(%rbp), %rax
movq %rax, -0x150(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x144(%rbp)
cmpl $0x28, %eax
ja 0x17731
movq -0x150(%rbp), %rcx
movl -0x144(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x158(%rbp)
jmp 0x1774e
movq -0x150(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x158(%rbp)
movq -0x158(%rbp), %rax
movq (%rax), %rax
movq %rax, 0xb8e69(%rip)     # 0xd05c8
leaq -0x20(%rbp), %rax
movq %rax, -0x168(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x15c(%rbp)
cmpl $0x28, %eax
ja 0x1779a
movq -0x168(%rbp), %rcx
movl -0x15c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x170(%rbp)
jmp 0x177b7
movq -0x168(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x170(%rbp)
movq -0x170(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xb8e0a(%rip)     # 0xd05d0
leaq -0x20(%rbp), %rax
movq %rax, -0x180(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x174(%rbp)
cmpl $0x28, %eax
ja 0x17801
movq -0x180(%rbp), %rcx
movl -0x174(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x188(%rbp)
jmp 0x1781e
movq -0x180(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x188(%rbp)
movq -0x188(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xb8da7(%rip)     # 0xd05d4
jmp 0x17e33
leaq -0x20(%rbp), %rax
movq %rax, -0x198(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x18c(%rbp)
cmpl $0x28, %eax
ja 0x1786d
movq -0x198(%rbp), %rcx
movl -0x18c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x1a0(%rbp)
jmp 0x1788a
movq -0x198(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x1a0(%rbp)
movq -0x1a0(%rbp), %rax
movq (%rax), %rax
movq %rax, 0xb8d3d(%rip)     # 0xd05d8
leaq -0x20(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1a4(%rbp)
cmpl $0x28, %eax
ja 0x178d6
movq -0x1b0(%rbp), %rcx
movl -0x1a4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x1b8(%rbp)
jmp 0x178f3
movq -0x1b0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x1b8(%rbp)
movq -0x1b8(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xb8cde(%rip)     # 0xd05e0
leaq -0x20(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1bc(%rbp)
cmpl $0x28, %eax
ja 0x1793d
movq -0x1c8(%rbp), %rcx
movl -0x1bc(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x1d0(%rbp)
jmp 0x1795a
movq -0x1c8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xb8c7b(%rip)     # 0xd05e4
jmp 0x17e33
jmp 0x17e33
movl $0x1, -0x24(%rbp)
jmp 0x17e33
leaq -0x20(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1d4(%rbp)
cmpl $0x28, %eax
ja 0x179ba
movq -0x1e0(%rbp), %rcx
movl -0x1d4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x1e8(%rbp)
jmp 0x179d7
movq -0x1e0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x1e8(%rbp)
movq -0x1e8(%rbp), %rax
movq (%rax), %rsi
leaq 0xb8aa8(%rip), %rdi     # 0xd0490
addq $0xa8, %rdi
movl $0x68, %edx
callq 0x82f0
jmp 0x17e33
cmpq $0x0, 0xb8b42(%rip)     # 0xd0548
jne 0x17a0d
callq 0x17e70
leaq -0x20(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1ec(%rbp)
cmpl $0x28, %eax
ja 0x17a48
movq -0x1f8(%rbp), %rcx
movl -0x1ec(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x200(%rbp)
jmp 0x17a65
movq -0x1f8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x200(%rbp)
movq -0x200(%rbp), %rax
movq (%rax), %rdi
leaq 0xb8a1a(%rip), %rsi     # 0xd0490
addq $0xa8, %rsi
movl $0x68, %edx
callq 0x82f0
jmp 0x17e33
leaq -0x20(%rbp), %rax
movq %rax, -0x210(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x204(%rbp)
cmpl $0x28, %eax
ja 0x17ac7
movq -0x210(%rbp), %rcx
movl -0x204(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x218(%rbp)
jmp 0x17ae4
movq -0x210(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x218(%rbp)
movq -0x218(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xb89b5(%rip)     # 0xd04a8
leaq -0x20(%rbp), %rax
movq %rax, -0x228(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x21c(%rbp)
cmpl $0x28, %eax
ja 0x17b2e
movq -0x228(%rbp), %rcx
movl -0x21c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x230(%rbp)
jmp 0x17b4b
movq -0x228(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xb8952(%rip)     # 0xd04ac
jmp 0x17e33
leaq -0x20(%rbp), %rax
movq %rax, -0x240(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x234(%rbp)
cmpl $0x28, %eax
ja 0x17b9a
movq -0x240(%rbp), %rcx
movl -0x234(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x248(%rbp)
jmp 0x17bb7
movq -0x240(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x248(%rbp)
movq -0x248(%rbp), %rax
movq (%rax), %rax
movq %rax, 0xb8a50(%rip)     # 0xd0618
leaq -0x20(%rbp), %rax
movq %rax, -0x258(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24c(%rbp)
cmpl $0x28, %eax
ja 0x17c03
movq -0x258(%rbp), %rcx
movl -0x24c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x260(%rbp)
jmp 0x17c20
movq -0x258(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x260(%rbp)
movq -0x260(%rbp), %rax
movq (%rax), %rax
movq %rax, 0xb89ef(%rip)     # 0xd0620
jmp 0x17e33
leaq -0x20(%rbp), %rax
movq %rax, -0x270(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x264(%rbp)
cmpl $0x28, %eax
ja 0x17c71
movq -0x270(%rbp), %rcx
movl -0x264(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x278(%rbp)
jmp 0x17c8e
movq -0x270(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x278(%rbp)
movq -0x278(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xb87ff(%rip)     # 0xd049c
jmp 0x17e33
leaq -0x20(%rbp), %rax
movq %rax, -0x288(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x27c(%rbp)
cmpl $0x28, %eax
ja 0x17cdd
movq -0x288(%rbp), %rcx
movl -0x27c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x290(%rbp)
jmp 0x17cfa
movq -0x288(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x290(%rbp)
movq -0x290(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xb8797(%rip)     # 0xd04a0
jmp 0x17e33
leaq -0x20(%rbp), %rax
movq %rax, -0x2a0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x294(%rbp)
cmpl $0x28, %eax
ja 0x17d49
movq -0x2a0(%rbp), %rcx
movl -0x294(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x2a8(%rbp)
jmp 0x17d66
movq -0x2a0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x2a8(%rbp)
movq -0x2a8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x2b8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2ac(%rbp)
cmpl $0x28, %eax
ja 0x17daf
movq -0x2b8(%rbp), %rcx
movl -0x2ac(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x2c0(%rbp)
jmp 0x17dcc
movq -0x2b8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x2c0(%rbp)
movq -0x2c0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jl 0x17deb
cmpq $0x7fff0000, -0x38(%rbp) # imm = 0x7FFF0000
jle 0x17df3
movq $0x7fff0000, -0x38(%rbp) # imm = 0x7FFF0000
movq -0x38(%rbp), %rax
movq %rax, 0xb87c2(%rip)     # 0xd05c0
cmpq $0x0, -0x30(%rbp)
jge 0x17e0d
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jle 0x17e1f
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0xb878e(%rip)     # 0xd05b8
jmp 0x17e33
movl $0x1, -0x24(%rbp)
leaq -0x20(%rbp), %rax
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbp
retq
nopl (%rax)