// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_test_control
SQLITE_CDECL sqlite3_test_control(int op, ...){
  int rc = 0;
#ifdef SQLITE_OMIT_BUILTIN_TEST
  UNUSED_PARAMETER(op);
#else
  va_list ap;
  va_start(ap, op);
  switch( op ){

    /*
    ** Save the current state of the PRNG.
    */
    case SQLITE_TESTCTRL_PRNG_SAVE: {
      sqlite3PrngSaveState();
      break;
    }

    /*
    ** Restore the state of the PRNG to the last state saved using
    ** PRNG_SAVE.  If PRNG_SAVE has never before been called, then
    ** this verb acts like PRNG_RESET.
    */
    case SQLITE_TESTCTRL_PRNG_RESTORE: {
      sqlite3PrngRestoreState();
      break;
    }

    /*
    ** Reset the PRNG back to its uninitialized state.  The next call
    ** to sqlite3_randomness() will reseed the PRNG using a single call
    ** to the xRandomness method of the default VFS.
    */
    case SQLITE_TESTCTRL_PRNG_RESET: {
      sqlite3_randomness(0,0);
      break;
    }

    /*
    **  sqlite3_test_control(BITVEC_TEST, size, program)
    **
    ** Run a test against a Bitvec object of size.  The program argument
    ** is an array of integers that defines the test.  Return -1 on a
    ** memory allocation error, 0 on success, or non-zero for an error.
    ** See the sqlite3BitvecBuiltinTest() for additional information.
    */
    case SQLITE_TESTCTRL_BITVEC_TEST: {
      int sz = va_arg(ap, int);
      int *aProg = va_arg(ap, int*);
      rc = sqlite3BitvecBuiltinTest(sz, aProg);
      break;
    }

    /*
    **  sqlite3_test_control(FAULT_INSTALL, xCallback)
    **
    ** Arrange to invoke xCallback() whenever sqlite3FaultSim() is called,
    ** if xCallback is not NULL.
    **
    ** As a test of the fault simulator mechanism itself, sqlite3FaultSim(0)
    ** is called immediately after installing the new callback and the return
    ** value from sqlite3FaultSim(0) becomes the return from
    ** sqlite3_test_control().
    */
    case SQLITE_TESTCTRL_FAULT_INSTALL: {
      /* MSVC is picky about pulling func ptrs from va lists.
      ** http://support.microsoft.com/kb/47961
      ** sqlite3GlobalConfig.xTestCallback = va_arg(ap, int(*)(int));
      */
      typedef int(*TESTCALLBACKFUNC_t)(int);
      sqlite3GlobalConfig.xTestCallback = va_arg(ap, TESTCALLBACKFUNC_t);
      rc = sqlite3FaultSim(0);
      break;
    }

    /*
    **  sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd)
    **
    ** Register hooks to call to indicate which malloc() failures 
    ** are benign.
    */
    case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: {
      typedef void (*void_function)(void);
      void_function xBenignBegin;
      void_function xBenignEnd;
      xBenignBegin = va_arg(ap, void_function);
      xBenignEnd = va_arg(ap, void_function);
      sqlite3BenignMallocHooks(xBenignBegin, xBenignEnd);
      break;
    }

    /*
    **  sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, unsigned int X)
    **
    ** Set the PENDING byte to the value in the argument, if X>0.
    ** Make no changes if X==0.  Return the value of the pending byte
    ** as it existing before this routine was called.
    **
    ** IMPORTANT:  Changing the PENDING byte from 0x40000000 results in
    ** an incompatible database file format.  Changing the PENDING byte
    ** while any database connection is open results in undefined and
    ** deleterious behavior.
    */
    case SQLITE_TESTCTRL_PENDING_BYTE: {
      rc = PENDING_BYTE;
#ifndef SQLITE_OMIT_WSD
      {
        unsigned int newVal = va_arg(ap, unsigned int);
        if( newVal ) sqlite3PendingByte = newVal;
      }
#endif
      break;
    }

    /*
    **  sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, int X)
    **
    ** This action provides a run-time test to see whether or not
    ** assert() was enabled at compile-time.  If X is true and assert()
    ** is enabled, then the return value is true.  If X is true and
    ** assert() is disabled, then the return value is zero.  If X is
    ** false and assert() is enabled, then the assertion fires and the
    ** process aborts.  If X is false and assert() is disabled, then the
    ** return value is zero.
    */
    case SQLITE_TESTCTRL_ASSERT: {
      volatile int x = 0;
      assert( (x = va_arg(ap,int))!=0 );
      rc = x;
      break;
    }


    /*
    **  sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, int X)
    **
    ** This action provides a run-time test to see how the ALWAYS and
    ** NEVER macros were defined at compile-time.
    **
    ** The return value is ALWAYS(X).  
    **
    ** The recommended test is X==2.  If the return value is 2, that means
    ** ALWAYS() and NEVER() are both no-op pass-through macros, which is the
    ** default setting.  If the return value is 1, then ALWAYS() is either
    ** hard-coded to true or else it asserts if its argument is false.
    ** The first behavior (hard-coded to true) is the case if
    ** SQLITE_TESTCTRL_ASSERT shows that assert() is disabled and the second
    ** behavior (assert if the argument to ALWAYS() is false) is the case if
    ** SQLITE_TESTCTRL_ASSERT shows that assert() is enabled.
    **
    ** The run-time test procedure might look something like this:
    **
    **    if( sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, 2)==2 ){
    **      // ALWAYS() and NEVER() are no-op pass-through macros
    **    }else if( sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, 1) ){
    **      // ALWAYS(x) asserts that x is true. NEVER(x) asserts x is false.
    **    }else{
    **      // ALWAYS(x) is a constant 1.  NEVER(x) is a constant 0.
    **    }
    */
    case SQLITE_TESTCTRL_ALWAYS: {
      int x = va_arg(ap,int);
      rc = ALWAYS(x);
      break;
    }

    /*
    **   sqlite3_test_control(SQLITE_TESTCTRL_BYTEORDER);
    **
    ** The integer returned reveals the byte-order of the computer on which
    ** SQLite is running:
    **
    **       1     big-endian,    determined at run-time
    **      10     little-endian, determined at run-time
    **  432101     big-endian,    determined at compile-time
    **  123410     little-endian, determined at compile-time
    */ 
    case SQLITE_TESTCTRL_BYTEORDER: {
      rc = SQLITE_BYTEORDER*100 + SQLITE_LITTLEENDIAN*10 + SQLITE_BIGENDIAN;
      break;
    }

    /*   sqlite3_test_control(SQLITE_TESTCTRL_RESERVE, sqlite3 *db, int N)
    **
    ** Set the nReserve size to N for the main database on the database
    ** connection db.
    */
    case SQLITE_TESTCTRL_RESERVE: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      int x = va_arg(ap,int);
      sqlite3_mutex_enter(db->mutex);
      sqlite3BtreeSetPageSize(db->aDb[0].pBt, 0, x, 0);
      sqlite3_mutex_leave(db->mutex);
      break;
    }

    /*  sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, sqlite3 *db, int N)
    **
    ** Enable or disable various optimizations for testing purposes.  The 
    ** argument N is a bitmask of optimizations to be disabled.  For normal
    ** operation N should be 0.  The idea is that a test program (like the
    ** SQL Logic Test or SLT test module) can run the same SQL multiple times
    ** with various optimizations disabled to verify that the same answer
    ** is obtained in every case.
    */
    case SQLITE_TESTCTRL_OPTIMIZATIONS: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      db->dbOptFlags = (u16)(va_arg(ap, int) & 0xffff);
      break;
    }

#ifdef SQLITE_N_KEYWORD
    /* sqlite3_test_control(SQLITE_TESTCTRL_ISKEYWORD, const char *zWord)
    **
    ** If zWord is a keyword recognized by the parser, then return the
    ** number of keywords.  Or if zWord is not a keyword, return 0.
    ** 
    ** This test feature is only available in the amalgamation since
    ** the SQLITE_N_KEYWORD macro is not defined in this file if SQLite
    ** is built using separate source files.
    */
    case SQLITE_TESTCTRL_ISKEYWORD: {
      const char *zWord = va_arg(ap, const char*);
      int n = sqlite3Strlen30(zWord);
      rc = (sqlite3KeywordCode((u8*)zWord, n)!=TK_ID) ? SQLITE_N_KEYWORD : 0;
      break;
    }
#endif 

    /* sqlite3_test_control(SQLITE_TESTCTRL_SCRATCHMALLOC, sz, &pNew, pFree);
    **
    ** Pass pFree into sqlite3ScratchFree(). 
    ** If sz>0 then allocate a scratch buffer into pNew.  
    */
    case SQLITE_TESTCTRL_SCRATCHMALLOC: {
      void *pFree, **ppNew;
      int sz;
      sz = va_arg(ap, int);
      ppNew = va_arg(ap, void**);
      pFree = va_arg(ap, void*);
      if( sz ) *ppNew = sqlite3ScratchMalloc(sz);
      sqlite3ScratchFree(pFree);
      break;
    }

    /*   sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff);
    **
    ** If parameter onoff is non-zero, configure the wrappers so that all
    ** subsequent calls to localtime() and variants fail. If onoff is zero,
    ** undo this setting.
    */
    case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
      sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
      break;
    }

    /*   sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, int);
    **
    ** Set or clear a flag that indicates that the database file is always well-
    ** formed and never corrupt.  This flag is clear by default, indicating that
    ** database files might have arbitrary corruption.  Setting the flag during
    ** testing causes certain assert() statements in the code to be activated
    ** that demonstrat invariants on well-formed database files.
    */
    case SQLITE_TESTCTRL_NEVER_CORRUPT: {
      sqlite3GlobalConfig.neverCorrupt = va_arg(ap, int);
      break;
    }


    /*   sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE, xCallback, ptr);
    **
    ** Set the VDBE coverage callback function to xCallback with context 
    ** pointer ptr.
    */
    case SQLITE_TESTCTRL_VDBE_COVERAGE: {
#ifdef SQLITE_VDBE_COVERAGE
      typedef void (*branch_callback)(void*,int,u8,u8);
      sqlite3GlobalConfig.xVdbeBranch = va_arg(ap,branch_callback);
      sqlite3GlobalConfig.pVdbeBranchArg = va_arg(ap,void*);
#endif
      break;
    }

    /*   sqlite3_test_control(SQLITE_TESTCTRL_SORTER_MMAP, db, nMax); */
    case SQLITE_TESTCTRL_SORTER_MMAP: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      db->nMaxSorterMmap = va_arg(ap, int);
      break;
    }

    /*   sqlite3_test_control(SQLITE_TESTCTRL_ISINIT);
    **
    ** Return SQLITE_OK if SQLite has been initialized and SQLITE_ERROR if
    ** not.
    */
    case SQLITE_TESTCTRL_ISINIT: {
      if( sqlite3GlobalConfig.isInit==0 ) rc = SQLITE_ERROR;
      break;
    }

    /*  sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, dbName, onOff, tnum);
    **
    ** This test control is used to create imposter tables.  "db" is a pointer
    ** to the database connection.  dbName is the database name (ex: "main" or
    ** "temp") which will receive the imposter.  "onOff" turns imposter mode on
    ** or off.  "tnum" is the root page of the b-tree to which the imposter
    ** table should connect.
    **
    ** Enable imposter mode only when the schema has already been parsed.  Then
    ** run a single CREATE TABLE statement to construct the imposter table in
    ** the parsed schema.  Then turn imposter mode back off again.
    **
    ** If onOff==0 and tnum>0 then reset the schema for all databases, causing
    ** the schema to be reparsed the next time it is needed.  This has the
    ** effect of erasing all imposter tables.
    */
    case SQLITE_TESTCTRL_IMPOSTER: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      sqlite3_mutex_enter(db->mutex);
      db->init.iDb = sqlite3FindDbName(db, va_arg(ap,const char*));
      db->init.busy = db->init.imposterTable = va_arg(ap,int);
      db->init.newTnum = va_arg(ap,int);
      if( db->init.busy==0 && db->init.newTnum>0 ){
        sqlite3ResetAllSchemasOfConnection(db);
      }
      sqlite3_mutex_leave(db->mutex);
      break;
    }
  }
  va_end(ap);
#endif /* SQLITE_OMIT_BUILTIN_TEST */
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x390, %rsp            # imm = 0x390
testb %al, %al
je 0x1fca7
movaps %xmm0, -0x120(%rbp)
movaps %xmm1, -0x110(%rbp)
movaps %xmm2, -0x100(%rbp)
movaps %xmm3, -0xf0(%rbp)
movaps %xmm4, -0xe0(%rbp)
movaps %xmm5, -0xd0(%rbp)
movaps %xmm6, -0xc0(%rbp)
movaps %xmm7, -0xb0(%rbp)
movq %r9, -0x128(%rbp)
movq %r8, -0x130(%rbp)
movq %rcx, -0x138(%rbp)
movq %rdx, -0x140(%rbp)
movq %rsi, -0x148(%rbp)
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
leaq -0x150(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movl -0x4(%rbp), %eax
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, -0x158(%rbp)
subl $0x14, %eax
ja 0x2085d
movq -0x158(%rbp), %rax
leaq 0x81789(%rip), %rcx     # 0xa14a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x20870
jmp 0x2085d
callq 0x20890
jmp 0x2085d
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xb4b0
jmp 0x2085d
leaq -0x20(%rbp), %rax
movq %rax, -0x168(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x15c(%rbp)
cmpl $0x28, %eax
ja 0x1fd83
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 0x1fda0
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, -0x24(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x180(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x174(%rbp)
cmpl $0x28, %eax
ja 0x1fde7
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 0x1fe04
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, -0x30(%rbp)
movl -0x24(%rbp), %edi
movq -0x30(%rbp), %rsi
callq 0x208b0
movl %eax, -0x8(%rbp)
jmp 0x2085d
leaq -0x20(%rbp), %rax
movq %rax, -0x198(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x18c(%rbp)
cmpl $0x28, %eax
ja 0x1fe61
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 0x1fe7e
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, 0x9f7d1(%rip)     # 0xbf660
xorl %edi, %edi
callq 0x20ba0
movl %eax, -0x8(%rbp)
jmp 0x2085d
leaq -0x20(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1a4(%rbp)
cmpl $0x28, %eax
ja 0x1fed9
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 0x1fef6
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
movq (%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1bc(%rbp)
cmpl $0x28, %eax
ja 0x1ff3f
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 0x1ff5c
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, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x20be0
jmp 0x2085d
movl 0x9f98e(%rip), %eax     # 0xbf910
movl %eax, -0x8(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1d4(%rbp)
cmpl $0x28, %eax
ja 0x1ffc0
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 0x1ffdd
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, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x1fff8
movl -0x44(%rbp), %eax
movl %eax, 0x9f918(%rip)     # 0xbf910
jmp 0x2085d
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x2085d
leaq -0x20(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1ec(%rbp)
cmpl $0x28, %eax
ja 0x2004a
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 0x20067
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, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x2085d
movl $0x1e212, -0x8(%rbp)    # imm = 0x1E212
jmp 0x2085d
leaq -0x20(%rbp), %rax
movq %rax, -0x210(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x204(%rbp)
cmpl $0x28, %eax
ja 0x200c5
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 0x200e2
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
movq (%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x228(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x21c(%rbp)
cmpl $0x28, %eax
ja 0x2012b
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 0x20148
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, -0x5c(%rbp)
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xb550
movq -0x58(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdi
movl -0x5c(%rbp), %edx
xorl %ecx, %ecx
movl %ecx, %esi
callq 0x20c10
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xb4f0
jmp 0x2085d
leaq -0x20(%rbp), %rax
movq %rax, -0x240(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x234(%rbp)
cmpl $0x28, %eax
ja 0x201c6
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 0x201e3
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, -0x68(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x258(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24c(%rbp)
cmpl $0x28, %eax
ja 0x2022c
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 0x20249
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
movl (%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, %cx
movq -0x68(%rbp), %rax
movw %cx, 0x4c(%rax)
jmp 0x2085d
leaq -0x20(%rbp), %rax
movq %rax, -0x270(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x264(%rbp)
cmpl $0x28, %eax
ja 0x202a2
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 0x202bf
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
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0xc6c0
movl %eax, -0x74(%rbp)
movq -0x70(%rbp), %rdi
movl -0x74(%rbp), %esi
callq 0x20d10
movl %eax, %edx
xorl %eax, %eax
movl $0x7c, %ecx
cmpl $0x1b, %edx
cmovnel %ecx, %eax
movl %eax, -0x8(%rbp)
jmp 0x2085d
leaq -0x20(%rbp), %rax
movq %rax, -0x288(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x27c(%rbp)
cmpl $0x28, %eax
ja 0x20337
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 0x20354
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, -0x8c(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x2a0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x294(%rbp)
cmpl $0x28, %eax
ja 0x2039e
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 0x203bb
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, -0x88(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x2b8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2ac(%rbp)
cmpl $0x28, %eax
ja 0x20407
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 0x20424
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, -0x80(%rbp)
cmpl $0x0, -0x8c(%rbp)
je 0x20453
movl -0x8c(%rbp), %edi
callq 0x20d40
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, (%rax)
movq -0x80(%rbp), %rdi
callq 0x20e30
jmp 0x2085d
leaq -0x20(%rbp), %rax
movq %rax, -0x2d0(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2c4(%rbp)
cmpl $0x28, %eax
ja 0x2049c
movq -0x2d0(%rbp), %rcx
movl -0x2c4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x2d8(%rbp)
jmp 0x204b9
movq -0x2d0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x2d8(%rbp)
movq -0x2d8(%rbp), %rax
movl (%rax), %eax
movl %eax, 0x9f1a0(%rip)     # 0xbf668
jmp 0x2085d
leaq -0x20(%rbp), %rax
movq %rax, -0x2e8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2dc(%rbp)
cmpl $0x28, %eax
ja 0x20508
movq -0x2e8(%rbp), %rcx
movl -0x2dc(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x2f0(%rbp)
jmp 0x20525
movq -0x2e8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x2f0(%rbp)
movq -0x2f0(%rbp), %rax
movl (%rax), %eax
movl %eax, 0x9efa4(%rip)     # 0xbf4d8
jmp 0x2085d
jmp 0x2085d
leaq -0x20(%rbp), %rax
movq %rax, -0x300(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2f4(%rbp)
cmpl $0x28, %eax
ja 0x20579
movq -0x300(%rbp), %rcx
movl -0x2f4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x308(%rbp)
jmp 0x20596
movq -0x300(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x308(%rbp)
movq -0x308(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x98(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x318(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x30c(%rbp)
cmpl $0x28, %eax
ja 0x205e2
movq -0x318(%rbp), %rcx
movl -0x30c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x320(%rbp)
jmp 0x205ff
movq -0x318(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x320(%rbp)
movq -0x320(%rbp), %rax
movl (%rax), %ecx
movq -0x98(%rbp), %rax
movl %ecx, 0x98(%rax)
jmp 0x2085d
cmpl $0x0, 0x9f00b(%rip)     # 0xbf62c
jne 0x2062a
movl $0x1, -0x8(%rbp)
jmp 0x2085d
leaq -0x20(%rbp), %rax
movq %rax, -0x330(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x324(%rbp)
cmpl $0x28, %eax
ja 0x2066a
movq -0x330(%rbp), %rcx
movl -0x324(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x338(%rbp)
jmp 0x20687
movq -0x330(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x338(%rbp)
movq -0x338(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xb550
movq -0xa0(%rbp), %rax
movq %rax, -0x350(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x348(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x33c(%rbp)
cmpl $0x28, %eax
ja 0x206f1
movq -0x348(%rbp), %rcx
movl -0x33c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x358(%rbp)
jmp 0x2070e
movq -0x348(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x358(%rbp)
movq -0x350(%rbp), %rdi
movq -0x358(%rbp), %rax
movq (%rax), %rsi
callq 0x1e2c0
movb %al, %cl
movq -0xa0(%rbp), %rax
movb %cl, 0xa0(%rax)
leaq -0x20(%rbp), %rax
movq %rax, -0x368(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x35c(%rbp)
cmpl $0x28, %eax
ja 0x2076e
movq -0x368(%rbp), %rcx
movl -0x35c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x370(%rbp)
jmp 0x2078b
movq -0x368(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x370(%rbp)
movq -0x370(%rbp), %rax
movl (%rax), %eax
movb %al, %cl
movq -0xa0(%rbp), %rax
movb %cl, 0xa3(%rax)
movq -0xa0(%rbp), %rax
movb %cl, 0xa1(%rax)
leaq -0x20(%rbp), %rax
movq %rax, -0x380(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x374(%rbp)
cmpl $0x28, %eax
ja 0x207eb
movq -0x380(%rbp), %rcx
movl -0x374(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x388(%rbp)
jmp 0x20808
movq -0x380(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x388(%rbp)
movq -0x388(%rbp), %rax
movl (%rax), %ecx
movq -0xa0(%rbp), %rax
movl %ecx, 0x9c(%rax)
movq -0xa0(%rbp), %rax
movzbl 0xa1(%rax), %eax
cmpl $0x0, %eax
jne 0x2084d
movq -0xa0(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
jle 0x2084d
movq -0xa0(%rbp), %rdi
callq 0x12b90
movq -0xa0(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xb4f0
movl -0x8(%rbp), %eax
addq $0x390, %rsp            # imm = 0x390
popq %rbp
retq
nopl (%rax)