// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_test_control
SQLITE_API int sqlite3_test_control(int op, ...){
  int rc = 0;
#ifdef SQLITE_UNTESTABLE
  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;
    }

    /*  sqlite3_test_control(SQLITE_TESTCTRL_PRNG_SEED, int x, sqlite3 *db);
    **
    ** Control the seed for the pseudo-random number generator (PRNG) that
    ** is built into SQLite.  Cases:
    **
    **    x!=0 && db!=0       Seed the PRNG to the current value of the
    **                        schema cookie in the main database for db, or
    **                        x if the schema cookie is zero.  This case
    **                        is convenient to use with database fuzzers
    **                        as it allows the fuzzer some control over the
    **                        the PRNG seed.
    **
    **    x!=0 && db==0       Seed the PRNG to the value of x.
    **
    **    x==0 && db==0       Revert to default behavior of using the
    **                        xRandomness method on the primary VFS.
    **
    ** This test-control also resets the PRNG so that the new seed will
    ** be used for the next call to sqlite3_randomness().
    */
#ifndef SQLITE_OMIT_WSD
    case SQLITE_TESTCTRL_PRNG_SEED: {
      int x = va_arg(ap, int);
      int y;
      sqlite3 *db = va_arg(ap, sqlite3*);
      assert( db==0 || db->aDb[0].pSchema!=0 );
      if( db && (y = db->aDb[0].pSchema->schema_cookie)!=0 ){ x = y; }
      sqlite3Config.iPrngSeed = x;
      sqlite3_randomness(0,0);
      break;
    }
#endif

    /*
    **  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( /*side-effects-ok*/ (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) if X is true, or 0 if X is false.
    **
    ** 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 = x ? ALWAYS(x) : 0;
      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_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;
    }

    /*   sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff);
    **
    ** If parameter onoff is non-zero, subsequent calls to localtime()
    ** and its 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_INTERNAL_FUNCTIONS, sqlite3*);
    **
    ** Toggle the ability to use internal functions on or off for
    ** the database connection given in the argument.
    */
    case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      db->mDbFlags ^= DBFLAG_InternalFunc;
      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_EXTRA_SCHEMA_CHECKS, int);
    **
    ** Set or clear a flag that causes SQLite to verify that type, name,
    ** and tbl_name fields of the sqlite_schema table.  This is normally
    ** on, but it is sometimes useful to turn it off for testing.
    **
    ** 2020-07-22:  Disabling EXTRA_SCHEMA_CHECKS also disables the
    ** verification of rootpage numbers when parsing the schema.  This
    ** is useful to make it easier to reach strange internal error states
    ** during testing.  The EXTRA_SCHEMA_CHECKS setting is always enabled
    ** in production.
    */
    case SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS: {
      sqlite3GlobalConfig.bExtraSchemaChecks = va_arg(ap, int);
      break;
    }

    /* Set the threshold at which OP_Once counters reset back to zero.
    ** By default this is 0x7ffffffe (over 2 billion), but that value is
    ** too big to test in a reasonable amount of time, so this control is
    ** provided to set a small and easily reachable reset value.
    */
    case SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: {
      sqlite3GlobalConfig.iOnceResetThreshold = 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*,unsigned int,
                                      unsigned char,unsigned char);
      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;
    }

#if defined(YYCOVERAGE)
    /*  sqlite3_test_control(SQLITE_TESTCTRL_PARSER_COVERAGE, FILE *out)
    **
    ** This test control (only available when SQLite is compiled with
    ** -DYYCOVERAGE) writes a report onto "out" that shows all
    ** state/lookahead combinations in the parser state machine
    ** which are never exercised.  If any state is missed, make the
    ** return code SQLITE_ERROR.
    */
    case SQLITE_TESTCTRL_PARSER_COVERAGE: {
      FILE *out = va_arg(ap, FILE*);
      if( sqlite3ParserCoverage(out) ) rc = SQLITE_ERROR;
      break;
    }
#endif /* defined(YYCOVERAGE) */

    /*  sqlite3_test_control(SQLITE_TESTCTRL_RESULT_INTREAL, sqlite3_context*);
    **
    ** This test-control causes the most recent sqlite3_result_int64() value
    ** to be interpreted as a MEM_IntReal instead of as an MEM_Int.  Normally,
    ** MEM_IntReal values only arise during an INSERT operation of integer
    ** values into a REAL column, so they can be challenging to test.  This
    ** test-control enables us to write an intreal() SQL function that can
    ** inject an intreal() value at arbitrary places in an SQL statement,
    ** for testing purposes.
    */
    case SQLITE_TESTCTRL_RESULT_INTREAL: {
      sqlite3_context *pCtx = va_arg(ap, sqlite3_context*);
      sqlite3ResultIntReal(pCtx);
      break;
    }
  }
  va_end(ap);
#endif /* SQLITE_UNTESTABLE */
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
leaq 0x30(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x28b3b6
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %r10, 0x10(%rsp)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
xorl %r12d, %r12d
addl $-0x5, %edi
cmpl $0x18, %edi
ja 0x28bbf3
leaq 0x14e4e4(%rip), %rax    # 0x3d98d0
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x23eaa4(%rip), %rdi    # 0x4c9ea0
leaq 0x23e7bd(%rip), %rsi    # 0x4c9bc0
jmp 0x28b501
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b635
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b643
movl $0x1e212, %r12d         # imm = 0x1E212
jmp 0x28bbf3
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b6a2
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b6b0
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b6bd
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b6cb
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b6d8
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b6e6
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b6f3
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b701
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b795
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b7a3
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b7bf
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b7cd
leaq 0x23e6c6(%rip), %rdi    # 0x4c9bc0
leaq 0x23e99f(%rip), %rsi    # 0x4c9ea0
movl $0x103, %edx            # imm = 0x103
callq 0x17660
jmp 0x28bbf3
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %r12d
jmp 0x28bbf3
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b7da
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b7e8
xorl %r12d, %r12d
cmpl $0x0, 0x23b268(%rip)    # 0x4c67b4
sete %r12b
jmp 0x28bbf3
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b7f0
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b7fe
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b835
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b843
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b862
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b870
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b8b0
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b8be
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b8ca
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b8d8
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b90e
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b91c
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b93e
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b94c
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %eax
movl (%rsp), %edx
cmpq $0x28, %rdx
ja 0x28b65e
movq %rdx, %rcx
addq 0x10(%rsp), %rcx
addl $0x8, %edx
movl %edx, (%rsp)
jmp 0x28b66c
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x28b683
movq 0x20(%rcx), %rcx
movq 0x18(%rcx), %rcx
movl (%rcx), %ecx
testl %ecx, %ecx
cmovnel %ecx, %eax
movl %eax, 0x23b173(%rip)    # 0x4c67fc
callq 0x27bed9
testl %eax, %eax
jne 0x28bbf3
movb $0x0, 0x23e523(%rip)    # 0x4c9bc0
jmp 0x28bbf3
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %eax
movl %eax, 0x23b138(%rip)    # 0x4c67f0
jmp 0x28bbf3
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %eax
movl %eax, 0x23af9d(%rip)    # 0x4c6670
jmp 0x28bbf3
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb (%rax), %al
movb %al, 0x23af7b(%rip)     # 0x4c6669
jmp 0x28bbf3
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %ebp
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b71c
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b72a
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r13
movl $0x200, %edi            # imm = 0x200
callq 0x27c381
movq %rax, %r14
testq %rax, %rax
je 0x28b751
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
xorl %esi, %esi
callq 0x173a0
movl %ebp, (%r14)
leal 0x7(%rbp), %eax
leal 0xe(%rbp), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x3, %ecx
incl %ecx
movslq %ecx, %rbx
movq %rbx, %rdi
callq 0x27c381
movq %rax, %r15
testq %rax, %rax
je 0x28b781
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x173a0
callq 0x27bed9
testl %eax, %eax
je 0x28ba23
xorl %edi, %edi
jmp 0x28ba30
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x23b316(%rip), %r12d   # 0x4c6ac0
movl (%rax), %eax
testl %eax, %eax
je 0x28bbf3
movl %eax, 0x23b306(%rip)    # 0x4c6ac0
jmp 0x28bbf3
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %eax
movl %eax, 0x23b01f(%rip)    # 0x4c67f4
jmp 0x28bbf3
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %r12d
jmp 0x28bbf3
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
movl (%rsp), %edx
cmpq $0x28, %rdx
ja 0x28b81a
movq %rdx, %rcx
addq 0x10(%rsp), %rcx
addl $0x8, %edx
movl %edx, (%rsp)
jmp 0x28b828
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movl (%rcx), %ecx
movl %ecx, 0xac(%rax)
jmp 0x28bbf3
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x23af9b(%rip)    # 0x4c67e8
testq %rax, %rax
je 0x28bbf3
xorl %edi, %edi
callq *%rax
movl %eax, %r12d
jmp 0x28bbf3
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
movl (%rsp), %edx
cmpq $0x28, %rdx
ja 0x28b88c
movq %rdx, %rcx
addq 0x10(%rsp), %rcx
addl $0x8, %edx
movl %edx, (%rsp)
jmp 0x28b89a
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq (%rcx), %rcx
movq %rax, 0x23e5a4(%rip)    # 0x4c9e48
movq %rcx, 0x23e5a5(%rip)    # 0x4c9e50
jmp 0x28bbf3
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
xorl $0x20, 0x2c(%rax)
jmp 0x28bbf3
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
movl (%rsp), %edx
cmpq $0x28, %rdx
ja 0x28b8f4
movq %rdx, %rcx
addq 0x10(%rsp), %rcx
addl $0x8, %edx
movl %edx, (%rsp)
jmp 0x28b902
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movzwl (%rcx), %ecx
movw %cx, 0x5c(%rax)
jmp 0x28bbf3
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rax
movq (%rax), %rax
movzwl 0x8(%rax), %ecx
testb $0x4, %cl
je 0x28bbf3
andl $-0x25, %ecx
orl $0x20, %ecx
movw %cx, 0x8(%rax)
jmp 0x28bbf3
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b968
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b976
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rsi
movq %r14, %rdi
callq 0x289cd9
movb %al, 0xb4(%r14)
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b9a1
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b9af
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb (%rax), %al
movb 0xb6(%r14), %cl
andb $0x1, %al
leal (%rax,%rax), %edx
andb $-0x3, %cl
orb %dl, %cl
movb %cl, 0xb6(%r14)
movb %al, 0xb5(%r14)
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x28b9e9
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x28b9f7
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %eax
movl %eax, 0xb0(%r14)
cmpb $0x0, 0xb5(%r14)
jne 0x28bbf3
testl %eax, %eax
je 0x28bbf3
movq %r14, %rdi
callq 0x280d0f
jmp 0x28bbf3
movl $0x200, %edi            # imm = 0x200
callq 0x27c381
movq %rax, %rdi
testq %r15, %r15
sete %al
testq %r14, %r14
sete %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
orb %al, %dl
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jne 0x28bbde
movq %rdi, 0x20(%rsp)
movq %r14, 0x28(%rsp)
xorl %r14d, %r14d
movl %r14d, %r12d
movl (%r13,%r12,4), %ebx
leal -0x1(%rbx), %eax
cmpl $0x2, %eax
jb 0x28ba93
cmpl $0x5, %ebx
je 0x28ba93
testl %ebx, %ebx
je 0x28bb51
movl $0x4, %edi
leaq 0x1c(%rsp), %rsi
callq 0x27e7ad
movl $0x2, %r14d
jmp 0x28baaf
movl 0x8(%r13,%r12,4), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x1c(%rsp)
addl 0xc(%r13,%r12,4), %eax
movl %eax, 0x8(%r13,%r12,4)
movl $0x4, %r14d
movl 0x4(%r13,%r12,4), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %eax
movl $0x0, %eax
cmovgel %eax, %r14d
movl %ecx, 0x4(%r13,%r12,4)
movl 0x1c(%rsp), %eax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
andl %ecx, %eax
xorl %edx, %edx
idivl %ebp
movl %edx, 0x1c(%rsp)
incl %edx
movl %edx, %ecx
andb $0x7, %cl
movl $0x1, %eax
shll %cl, %eax
addl %r12d, %r14d
shrl $0x3, %edx
movb (%r15,%rdx), %cl
testb $0x1, %bl
jne 0x28bb1a
notb %al
andb %al, %cl
movb %cl, (%r15,%rdx)
movl 0x1c(%rsp), %esi
incl %esi
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
callq 0x299603
jmp 0x28ba5f
orb %al, %cl
movb %cl, (%r15,%rdx)
cmpl $0x5, %ebx
je 0x28ba5f
movl 0x1c(%rsp), %esi
incl %esi
movq 0x28(%rsp), %rdi
callq 0x290c97
testl %eax, %eax
je 0x28ba5f
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq 0x28(%rsp), %r14
jmp 0x28bbd9
leal 0x1(%rbp), %esi
movq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x290715
movl %eax, %r13d
movq %r14, %rdi
xorl %esi, %esi
callq 0x290715
movl (%r14), %r12d
subl %ebp, %r12d
cmpl $0x1, %r13d
sbbl $-0x1, %r12d
cmpl $0x1, %eax
sbbl $-0x1, %r12d
movl $0x1, 0x1c(%rsp)
testl %ebp, %ebp
jle 0x28bbd9
negl %ebp
movl $0x1, %r13d
movl %r13d, %eax
shrl $0x3, %eax
movzbl (%r15,%rax), %ebx
movq %r14, %rdi
movl %r13d, %esi
callq 0x290715
testl %eax, %eax
sete %al
movl %r13d, %ecx
andl $0x7, %ecx
btl %ecx, %ebx
sbbb $0x0, %al
je 0x28bbd6
leal 0x1(%rbp,%r13), %eax
leal 0x1(%r13), %ecx
movl %ecx, 0x1c(%rsp)
movl %ecx, %r13d
cmpl $0x1, %eax
jne 0x28bb97
jmp 0x28bbd9
movl %r13d, %r12d
movq 0x20(%rsp), %rdi
callq 0x27c490
movq %r15, %rdi
callq 0x27c490
movq %r14, %rdi
callq 0x294293
movl %r12d, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq