// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_config
SQLITE_CDECL 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  /* IMP: R-54466-46756 */
    case SQLITE_CONFIG_SINGLETHREAD: {
      /* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to
      ** Single-thread. */
      sqlite3GlobalConfig.bCoreMutex = 0;  /* Disable mutex on core */
      sqlite3GlobalConfig.bFullMutex = 0;  /* Disable mutex on connections */
      break;
    }
#endif
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-20520-54086 */
    case SQLITE_CONFIG_MULTITHREAD: {
      /* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to
      ** Multi-thread. */
      sqlite3GlobalConfig.bCoreMutex = 1;  /* Enable mutex on core */
      sqlite3GlobalConfig.bFullMutex = 0;  /* Disable mutex on connections */
      break;
    }
#endif
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-59593-21810 */
    case SQLITE_CONFIG_SERIALIZED: {
      /* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to
      ** Serialized. */
      sqlite3GlobalConfig.bCoreMutex = 1;  /* Enable mutex on core */
      sqlite3GlobalConfig.bFullMutex = 1;  /* Enable mutex on connections */
      break;
    }
#endif
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-63666-48755 */
    case SQLITE_CONFIG_MUTEX: {
      /* Specify an alternative mutex implementation */
      sqlite3GlobalConfig.mutex = *va_arg(ap, sqlite3_mutex_methods*);
      break;
    }
#endif
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-14450-37597 */
    case SQLITE_CONFIG_GETMUTEX: {
      /* Retrieve the current mutex implementation */
      *va_arg(ap, sqlite3_mutex_methods*) = sqlite3GlobalConfig.mutex;
      break;
    }
#endif

    case SQLITE_CONFIG_MALLOC: {
      /* EVIDENCE-OF: R-55594-21030 The SQLITE_CONFIG_MALLOC option takes a
      ** single argument which is a pointer to an instance of the
      ** sqlite3_mem_methods structure. The argument specifies alternative
      ** low-level memory allocation routines to be used in place of the memory
      ** allocation routines built into SQLite. */
      sqlite3GlobalConfig.m = *va_arg(ap, sqlite3_mem_methods*);
      break;
    }
    case SQLITE_CONFIG_GETMALLOC: {
      /* EVIDENCE-OF: R-51213-46414 The SQLITE_CONFIG_GETMALLOC option takes a
      ** single argument which is a pointer to an instance of the
      ** sqlite3_mem_methods structure. The sqlite3_mem_methods structure is
      ** filled with the currently defined memory allocation routines. */
      if( sqlite3GlobalConfig.m.xMalloc==0 ) sqlite3MemSetDefault();
      *va_arg(ap, sqlite3_mem_methods*) = sqlite3GlobalConfig.m;
      break;
    }
    case SQLITE_CONFIG_MEMSTATUS: {
      /* EVIDENCE-OF: R-61275-35157 The SQLITE_CONFIG_MEMSTATUS option takes
      ** single argument of type int, interpreted as a boolean, which enables
      ** or disables the collection of memory allocation statistics. */
      sqlite3GlobalConfig.bMemstat = va_arg(ap, int);
      break;
    }
    case SQLITE_CONFIG_SCRATCH: {
      /* EVIDENCE-OF: R-08404-60887 There are three arguments to
      ** SQLITE_CONFIG_SCRATCH: A pointer an 8-byte aligned memory buffer from
      ** which the scratch allocations will be drawn, the size of each scratch
      ** allocation (sz), and the maximum number of scratch allocations (N). */
      sqlite3GlobalConfig.pScratch = va_arg(ap, void*);
      sqlite3GlobalConfig.szScratch = va_arg(ap, int);
      sqlite3GlobalConfig.nScratch = va_arg(ap, int);
      break;
    }
    case SQLITE_CONFIG_PAGECACHE: {
      /* EVIDENCE-OF: R-18761-36601 There are three arguments to
      ** SQLITE_CONFIG_PAGECACHE: A pointer to 8-byte aligned memory (pMem),
      ** the size of each page cache line (sz), and the number of cache lines
      ** (N). */
      sqlite3GlobalConfig.pPage = va_arg(ap, void*);
      sqlite3GlobalConfig.szPage = va_arg(ap, int);
      sqlite3GlobalConfig.nPage = va_arg(ap, int);
      break;
    }
    case SQLITE_CONFIG_PCACHE_HDRSZ: {
      /* EVIDENCE-OF: R-39100-27317 The SQLITE_CONFIG_PCACHE_HDRSZ option takes
      ** a single parameter which is a pointer to an integer and writes into
      ** that integer the number of extra bytes per page required for each page
      ** in SQLITE_CONFIG_PAGECACHE. */
      *va_arg(ap, int*) = 
          sqlite3HeaderSizeBtree() +
          sqlite3HeaderSizePcache() +
          sqlite3HeaderSizePcache1();
      break;
    }

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

    case SQLITE_CONFIG_PCACHE2: {
      /* EVIDENCE-OF: R-63325-48378 The SQLITE_CONFIG_PCACHE2 option takes a
      ** single argument which is a pointer to an sqlite3_pcache_methods2
      ** object. This object specifies the interface to a custom page cache
      ** implementation. */
      sqlite3GlobalConfig.pcache2 = *va_arg(ap, sqlite3_pcache_methods2*);
      break;
    }
    case SQLITE_CONFIG_GETPCACHE2: {
      /* EVIDENCE-OF: R-22035-46182 The SQLITE_CONFIG_GETPCACHE2 option takes a
      ** single argument which is a pointer to an sqlite3_pcache_methods2
      ** object. SQLite copies of the current page cache implementation into
      ** that object. */
      if( sqlite3GlobalConfig.pcache2.xInit==0 ){
        sqlite3PCacheSetDefault();
      }
      *va_arg(ap, sqlite3_pcache_methods2*) = sqlite3GlobalConfig.pcache2;
      break;
    }

/* EVIDENCE-OF: R-06626-12911 The SQLITE_CONFIG_HEAP option is only
** available if SQLite is compiled with either SQLITE_ENABLE_MEMSYS3 or
** SQLITE_ENABLE_MEMSYS5 and returns SQLITE_ERROR if invoked otherwise. */
#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
    case SQLITE_CONFIG_HEAP: {
      /* EVIDENCE-OF: R-19854-42126 There are three arguments to
      ** SQLITE_CONFIG_HEAP: An 8-byte aligned pointer to the memory, the
      ** number of bytes in the memory buffer, and the minimum allocation size.
      */
      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 ){
        /* EVIDENCE-OF: R-49920-60189 If the first pointer (the memory pointer)
        ** is NULL, then SQLite reverts to using its default memory allocator
        ** (the system malloc() implementation), undoing any prior invocation of
        ** SQLITE_CONFIG_MALLOC.
        **
        ** Setting sqlite3GlobalConfig.m to all zeros will cause malloc to
        ** revert to its default implementation when sqlite3_initialize() is run
        */
        memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m));
      }else{
        /* EVIDENCE-OF: R-61006-08918 If the memory pointer is not NULL then the
        ** alternative memory allocator is engaged to handle all of SQLites
        ** memory allocation needs. */
#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;
    }

    /* EVIDENCE-OF: R-55548-33817 The compile-time setting for URI filenames
    ** can be changed at start-time using the
    ** sqlite3_config(SQLITE_CONFIG_URI,1) or
    ** sqlite3_config(SQLITE_CONFIG_URI,0) configuration calls.
    */
    case SQLITE_CONFIG_URI: {
      /* EVIDENCE-OF: R-25451-61125 The SQLITE_CONFIG_URI option takes a single
      ** argument of type int. If non-zero, then URI handling is globally
      ** enabled. If the parameter is zero, then URI handling is globally
      ** disabled. */
      sqlite3GlobalConfig.bOpenUri = va_arg(ap, int);
      break;
    }

    case SQLITE_CONFIG_COVERING_INDEX_SCAN: {
      /* EVIDENCE-OF: R-36592-02772 The SQLITE_CONFIG_COVERING_INDEX_SCAN
      ** option takes a single integer argument which is interpreted as a
      ** boolean in order to enable or disable the use of covering indices for
      ** full table scans in the query optimizer. */
      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: {
      /* EVIDENCE-OF: R-58063-38258 SQLITE_CONFIG_MMAP_SIZE takes two 64-bit
      ** integer (sqlite3_int64) values that are the default mmap size limit
      ** (the default setting for PRAGMA mmap_size) and the maximum allowed
      ** mmap size limit. */
      sqlite3_int64 szMmap = va_arg(ap, sqlite3_int64);
      sqlite3_int64 mxMmap = va_arg(ap, sqlite3_int64);
      /* EVIDENCE-OF: R-53367-43190 If either argument to this option is
      ** negative, then that argument is changed to its compile-time default.
      **
      ** EVIDENCE-OF: R-34993-45031 The maximum allowed mmap size will be
      ** silently truncated if necessary so that it does not exceed the
      ** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE
      ** compile-time option.
      */
      if( mxMmap<0 || mxMmap>SQLITE_MAX_MMAP_SIZE ){
        mxMmap = SQLITE_MAX_MMAP_SIZE;
      }
      if( szMmap<0 ) szMmap = SQLITE_DEFAULT_MMAP_SIZE;
      if( szMmap>mxMmap) szMmap = mxMmap;
      sqlite3GlobalConfig.mxMmap = mxMmap;
      sqlite3GlobalConfig.szMmap = szMmap;
      break;
    }

#if SQLITE_OS_WIN && defined(SQLITE_WIN32_MALLOC) /* IMP: R-04780-55815 */
    case SQLITE_CONFIG_WIN32_HEAPSIZE: {
      /* EVIDENCE-OF: R-34926-03360 SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit
      ** unsigned integer value that specifies the maximum size of the created
      ** heap. */
      sqlite3GlobalConfig.nHeap = va_arg(ap, int);
      break;
    }
#endif

    case SQLITE_CONFIG_PMASZ: {
      sqlite3GlobalConfig.szPma = va_arg(ap, unsigned int);
      break;
    }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp            # imm = 0x330
testb %al, %al
je 0x1bdbb
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, 0xa383d(%rip)     # 0xbf62c
je 0x1be03
movl $0x20546, %edi          # imm = 0x20546
callq 0xc850
movl %eax, -0x4(%rbp)
jmp 0x1c95c
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
decl %eax
movl %eax, %ecx
movq %rcx, -0xf8(%rbp)
subl $0x18, %eax
ja 0x1c94b
movq -0xf8(%rbp), %rax
leaq 0x855f7(%rip), %rcx     # 0xa1440
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, 0xa3668(%rip)     # 0xbf4c4
movl $0x0, 0xa3662(%rip)     # 0xbf4c8
jmp 0x1c952
movl $0x1, 0xa364f(%rip)     # 0xbf4c4
movl $0x0, 0xa3649(%rip)     # 0xbf4c8
jmp 0x1c952
movl $0x1, 0xa3636(%rip)     # 0xbf4c4
movl $0x1, 0xa3630(%rip)     # 0xbf4c8
jmp 0x1c952
leaq -0x20(%rbp), %rax
movq %rax, -0x108(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xfc(%rbp)
cmpl $0x28, %eax
ja 0x1bed8
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 0x1bef5
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 0xa35ba(%rip), %rdi     # 0xbf4c0
addq $0x68, %rdi
movl $0x48, %edx
callq 0xb420
jmp 0x1c952
leaq -0x20(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x28, %eax
ja 0x1bf54
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 0x1bf71
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 0xa353e(%rip), %rsi     # 0xbf4c0
addq $0x68, %rsi
movl $0x48, %edx
callq 0xb420
jmp 0x1c952
leaq -0x20(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x12c(%rbp)
cmpl $0x28, %eax
ja 0x1bfd0
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 0x1bfed
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
movq (%rax), %rsi
leaq 0xa34c2(%rip), %rdi     # 0xbf4c0
addq $0x28, %rdi
movl $0x40, %edx
callq 0xb420
jmp 0x1c952
cmpq $0x0, 0xa34cf(%rip)     # 0xbf4e8
jne 0x1c020
callq 0x1c970
leaq -0x20(%rbp), %rax
movq %rax, -0x150(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x144(%rbp)
cmpl $0x28, %eax
ja 0x1c05b
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 0x1c078
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), %rdi
leaq 0xa3437(%rip), %rsi     # 0xbf4c0
addq $0x28, %rsi
movl $0x40, %edx
callq 0xb420
jmp 0x1c952
leaq -0x20(%rbp), %rax
movq %rax, -0x168(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x15c(%rbp)
cmpl $0x28, %eax
ja 0x1c0d7
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 0x1c0f4
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, 0xa33bd(%rip)     # 0xbf4c0
jmp 0x1c952
leaq -0x20(%rbp), %rax
movq %rax, -0x180(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x174(%rbp)
cmpl $0x28, %eax
ja 0x1c143
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 0x1c160
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
movq (%rax), %rax
movq %rax, 0xa348f(%rip)     # 0xbf600
leaq -0x20(%rbp), %rax
movq %rax, -0x198(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x18c(%rbp)
cmpl $0x28, %eax
ja 0x1c1ac
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 0x1c1c9
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
movl (%rax), %eax
movl %eax, 0xa3430(%rip)     # 0xbf608
leaq -0x20(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1a4(%rbp)
cmpl $0x28, %eax
ja 0x1c213
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 0x1c230
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, 0xa33cd(%rip)     # 0xbf60c
jmp 0x1c952
leaq -0x20(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1bc(%rbp)
cmpl $0x28, %eax
ja 0x1c27f
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 0x1c29c
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
movq (%rax), %rax
movq %rax, 0xa3363(%rip)     # 0xbf610
leaq -0x20(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1d4(%rbp)
cmpl $0x28, %eax
ja 0x1c2e8
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 0x1c305
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
movl (%rax), %eax
movl %eax, 0xa3304(%rip)     # 0xbf618
leaq -0x20(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1ec(%rbp)
cmpl $0x28, %eax
ja 0x1c34f
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 0x1c36c
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
movl (%rax), %eax
movl %eax, 0xa32a1(%rip)     # 0xbf61c
jmp 0x1c952
callq 0x1c990
movl %eax, -0x21c(%rbp)
callq 0x1c9a0
movl %eax, %ecx
movl -0x21c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x218(%rbp)
callq 0x1c9b0
movl %eax, %ecx
movl -0x218(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x214(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x210(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x204(%rbp)
cmpl $0x28, %eax
ja 0x1c3f0
movq -0x210(%rbp), %rcx
movl -0x204(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x228(%rbp)
jmp 0x1c40d
movq -0x210(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x228(%rbp)
movl -0x214(%rbp), %ecx
movq -0x228(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
jmp 0x1c952
jmp 0x1c952
movl $0x1, -0x24(%rbp)
jmp 0x1c952
leaq -0x20(%rbp), %rax
movq %rax, -0x238(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x22c(%rbp)
cmpl $0x28, %eax
ja 0x1c470
movq -0x238(%rbp), %rcx
movl -0x22c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x240(%rbp)
jmp 0x1c48d
movq -0x238(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x240(%rbp)
movq -0x240(%rbp), %rax
movq (%rax), %rsi
leaq 0xa3022(%rip), %rdi     # 0xbf4c0
addq $0xb0, %rdi
movl $0x68, %edx
callq 0xb420
jmp 0x1c952
cmpq $0x0, 0xa30c4(%rip)     # 0xbf580
jne 0x1c4c3
callq 0x1c9c0
leaq -0x20(%rbp), %rax
movq %rax, -0x250(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x244(%rbp)
cmpl $0x28, %eax
ja 0x1c4fe
movq -0x250(%rbp), %rcx
movl -0x244(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x258(%rbp)
jmp 0x1c51b
movq -0x250(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x258(%rbp)
movq -0x258(%rbp), %rax
movq (%rax), %rdi
leaq 0xa2f94(%rip), %rsi     # 0xbf4c0
addq $0xb0, %rsi
movl $0x68, %edx
callq 0xb420
jmp 0x1c952
leaq -0x20(%rbp), %rax
movq %rax, -0x268(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x25c(%rbp)
cmpl $0x28, %eax
ja 0x1c57d
movq -0x268(%rbp), %rcx
movl -0x25c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x270(%rbp)
jmp 0x1c59a
movq -0x268(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x270(%rbp)
movq -0x270(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xa2f33(%rip)     # 0xbf4dc
leaq -0x20(%rbp), %rax
movq %rax, -0x280(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x274(%rbp)
cmpl $0x28, %eax
ja 0x1c5e4
movq -0x280(%rbp), %rcx
movl -0x274(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x288(%rbp)
jmp 0x1c601
movq -0x280(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x288(%rbp)
movq -0x288(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xa2ed0(%rip)     # 0xbf4e0
jmp 0x1c952
leaq -0x20(%rbp), %rax
movq %rax, -0x298(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x28c(%rbp)
cmpl $0x28, %eax
ja 0x1c650
movq -0x298(%rbp), %rcx
movl -0x28c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x2a0(%rbp)
jmp 0x1c66d
movq -0x298(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x2a0(%rbp)
movq -0x2a0(%rbp), %rax
movq (%rax), %rax
movq %rax, 0xa2fd2(%rip)     # 0xbf650
leaq -0x20(%rbp), %rax
movq %rax, -0x2b0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2a4(%rbp)
cmpl $0x28, %eax
ja 0x1c6b9
movq -0x2b0(%rbp), %rcx
movl -0x2a4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x2b8(%rbp)
jmp 0x1c6d6
movq -0x2b0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x2b8(%rbp)
movq -0x2b8(%rbp), %rax
movq (%rax), %rax
movq %rax, 0xa2f71(%rip)     # 0xbf658
jmp 0x1c952
leaq -0x20(%rbp), %rax
movq %rax, -0x2c8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2bc(%rbp)
cmpl $0x28, %eax
ja 0x1c727
movq -0x2c8(%rbp), %rcx
movl -0x2bc(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x2d0(%rbp)
jmp 0x1c744
movq -0x2c8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x2d0(%rbp)
movq -0x2d0(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xa2d79(%rip)     # 0xbf4cc
jmp 0x1c952
leaq -0x20(%rbp), %rax
movq %rax, -0x2e0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2d4(%rbp)
cmpl $0x28, %eax
ja 0x1c793
movq -0x2e0(%rbp), %rcx
movl -0x2d4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x2e8(%rbp)
jmp 0x1c7b0
movq -0x2e0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x2e8(%rbp)
movq -0x2e8(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xa2d11(%rip)     # 0xbf4d0
jmp 0x1c952
leaq -0x20(%rbp), %rax
movq %rax, -0x2f8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2ec(%rbp)
cmpl $0x28, %eax
ja 0x1c7ff
movq -0x2f8(%rbp), %rcx
movl -0x2ec(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x300(%rbp)
jmp 0x1c81c
movq -0x2f8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x300(%rbp)
movq -0x300(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x310(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x304(%rbp)
cmpl $0x28, %eax
ja 0x1c865
movq -0x310(%rbp), %rcx
movl -0x304(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x318(%rbp)
jmp 0x1c882
movq -0x310(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x318(%rbp)
movq -0x318(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jl 0x1c8a1
cmpq $0x7fff0000, -0x38(%rbp) # imm = 0x7FFF0000
jle 0x1c8a9
movq $0x7fff0000, -0x38(%rbp) # imm = 0x7FFF0000
cmpq $0x0, -0x30(%rbp)
jge 0x1c8b8
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jle 0x1c8ca
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, 0xa2d23(%rip)     # 0xbf5f8
movq -0x30(%rbp), %rax
movq %rax, 0xa2d10(%rip)     # 0xbf5f0
jmp 0x1c952
leaq -0x20(%rbp), %rax
movq %rax, -0x328(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x31c(%rbp)
cmpl $0x28, %eax
ja 0x1c91d
movq -0x328(%rbp), %rcx
movl -0x31c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x330(%rbp)
jmp 0x1c93a
movq -0x328(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x330(%rbp)
movq -0x330(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xa2cdf(%rip)     # 0xbf628
jmp 0x1c952
movl $0x1, -0x24(%rbp)
leaq -0x20(%rbp), %rax
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x330, %rsp            # imm = 0x330
popq %rbp
retq
nopl (%rax,%rax)