// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ParseUri
SQLITE_PRIVATE int sqlite3ParseUri(
  const char *zDefaultVfs,        /* VFS to use if no "vfs=xxx" query option */
  const char *zUri,               /* Nul-terminated URI to parse */
  unsigned int *pFlags,           /* IN/OUT: SQLITE_OPEN_XXX flags */
  sqlite3_vfs **ppVfs,            /* OUT: VFS to use */
  char **pzFile,                  /* OUT: Filename component of URI */
  char **pzErrMsg                 /* OUT: Error message (if rc!=SQLITE_OK) */
){
  int rc = SQLITE_OK;
  unsigned int flags = *pFlags;
  const char *zVfs = zDefaultVfs;
  char *zFile;
  char c;
  int nUri = sqlite3Strlen30(zUri);

  assert( *pzErrMsg==0 );

  if( ((flags & SQLITE_OPEN_URI)             /* IMP: R-48725-32206 */
            || sqlite3GlobalConfig.bOpenUri) /* IMP: R-51689-46548 */
   && nUri>=5 && memcmp(zUri, "file:", 5)==0 /* IMP: R-57884-37496 */
  ){
    char *zOpt;
    int eState;                   /* Parser state when parsing URI */
    int iIn;                      /* Input character index */
    int iOut = 0;                 /* Output character index */
    u64 nByte = nUri+8;           /* Bytes of space to allocate */

    /* Make sure the SQLITE_OPEN_URI flag is set to indicate to the VFS xOpen
    ** method that there may be extra parameters following the file-name.  */
    flags |= SQLITE_OPEN_URI;

    for(iIn=0; iIn<nUri; iIn++) nByte += (zUri[iIn]=='&');
    zFile = sqlite3_malloc64(nByte);
    if( !zFile ) return SQLITE_NOMEM_BKPT;

    memset(zFile, 0, 4);  /* 4-byte of 0x00 is the start of DB name marker */
    zFile += 4;

    iIn = 5;
#ifdef SQLITE_ALLOW_URI_AUTHORITY
    if( strncmp(zUri+5, "///", 3)==0 ){
      iIn = 7;
      /* The following condition causes URIs with five leading / characters
      ** like file://///host/path to be converted into UNCs like //host/path.
      ** The correct URI for that UNC has only two or four leading / characters
      ** file://host/path or file:////host/path.  But 5 leading slashes is a
      ** common error, we are told, so we handle it as a special case. */
      if( strncmp(zUri+7, "///", 3)==0 ){ iIn++; }
    }else if( strncmp(zUri+5, "//localhost/", 12)==0 ){
      iIn = 16;
    }
#else
    /* Discard the scheme and authority segments of the URI. */
    if( zUri[5]=='/' && zUri[6]=='/' ){
      iIn = 7;
      while( zUri[iIn] && zUri[iIn]!='/' ) iIn++;
      if( iIn!=7 && (iIn!=16 || memcmp("localhost", &zUri[7], 9)) ){
        *pzErrMsg = sqlite3_mprintf("invalid uri authority: %.*s",
            iIn-7, &zUri[7]);
        rc = SQLITE_ERROR;
        goto parse_uri_out;
      }
    }
#endif

    /* Copy the filename and any query parameters into the zFile buffer.
    ** Decode %HH escape codes along the way.
    **
    ** Within this loop, variable eState may be set to 0, 1 or 2, depending
    ** on the parsing context. As follows:
    **
    **   0: Parsing file-name.
    **   1: Parsing name section of a name=value query parameter.
    **   2: Parsing value section of a name=value query parameter.
    */
    eState = 0;
    while( (c = zUri[iIn])!=0 && c!='#' ){
      iIn++;
      if( c=='%'
       && sqlite3Isxdigit(zUri[iIn])
       && sqlite3Isxdigit(zUri[iIn+1])
      ){
        int octet = (sqlite3HexToInt(zUri[iIn++]) << 4);
        octet += sqlite3HexToInt(zUri[iIn++]);

        assert( octet>=0 && octet<256 );
        if( octet==0 ){
#ifndef SQLITE_ENABLE_URI_00_ERROR
          /* This branch is taken when "%00" appears within the URI. In this
          ** case we ignore all text in the remainder of the path, name or
          ** value currently being parsed. So ignore the current character
          ** and skip to the next "?", "=" or "&", as appropriate. */
          while( (c = zUri[iIn])!=0 && c!='#'
              && (eState!=0 || c!='?')
              && (eState!=1 || (c!='=' && c!='&'))
              && (eState!=2 || c!='&')
          ){
            iIn++;
          }
          continue;
#else
          /* If ENABLE_URI_00_ERROR is defined, "%00" in a URI is an error. */
          *pzErrMsg = sqlite3_mprintf("unexpected %%00 in uri");
          rc = SQLITE_ERROR;
          goto parse_uri_out;
#endif
        }
        c = octet;
      }else if( eState==1 && (c=='&' || c=='=') ){
        if( zFile[iOut-1]==0 ){
          /* An empty option name. Ignore this option altogether. */
          while( zUri[iIn] && zUri[iIn]!='#' && zUri[iIn-1]!='&' ) iIn++;
          continue;
        }
        if( c=='&' ){
          zFile[iOut++] = '\0';
        }else{
          eState = 2;
        }
        c = 0;
      }else if( (eState==0 && c=='?') || (eState==2 && c=='&') ){
        c = 0;
        eState = 1;
      }
      zFile[iOut++] = c;
    }
    if( eState==1 ) zFile[iOut++] = '\0';
    memset(zFile+iOut, 0, 4); /* end-of-options + empty journal filenames */

    /* Check if there were any options specified that should be interpreted
    ** here. Options that are interpreted here include "vfs" and those that
    ** correspond to flags that may be passed to the sqlite3_open_v2()
    ** method. */
    zOpt = &zFile[sqlite3Strlen30(zFile)+1];
    while( zOpt[0] ){
      int nOpt = sqlite3Strlen30(zOpt);
      char *zVal = &zOpt[nOpt+1];
      int nVal = sqlite3Strlen30(zVal);

      if( nOpt==3 && memcmp("vfs", zOpt, 3)==0 ){
        zVfs = zVal;
      }else{
        struct OpenMode {
          const char *z;
          int mode;
        } *aMode = 0;
        char *zModeType = 0;
        int mask = 0;
        int limit = 0;

        if( nOpt==5 && memcmp("cache", zOpt, 5)==0 ){
          static struct OpenMode aCacheMode[] = {
            { "shared",  SQLITE_OPEN_SHAREDCACHE },
            { "private", SQLITE_OPEN_PRIVATECACHE },
            { 0, 0 }
          };

          mask = SQLITE_OPEN_SHAREDCACHE|SQLITE_OPEN_PRIVATECACHE;
          aMode = aCacheMode;
          limit = mask;
          zModeType = "cache";
        }
        if( nOpt==4 && memcmp("mode", zOpt, 4)==0 ){
          static struct OpenMode aOpenMode[] = {
            { "ro",  SQLITE_OPEN_READONLY },
            { "rw",  SQLITE_OPEN_READWRITE },
            { "rwc", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE },
            { "memory", SQLITE_OPEN_MEMORY },
            { 0, 0 }
          };

          mask = SQLITE_OPEN_READONLY | SQLITE_OPEN_READWRITE
                   | SQLITE_OPEN_CREATE | SQLITE_OPEN_MEMORY;
          aMode = aOpenMode;
          limit = mask & flags;
          zModeType = "access";
        }

        if( aMode ){
          int i;
          int mode = 0;
          for(i=0; aMode[i].z; i++){
            const char *z = aMode[i].z;
            if( nVal==sqlite3Strlen30(z) && 0==memcmp(zVal, z, nVal) ){
              mode = aMode[i].mode;
              break;
            }
          }
          if( mode==0 ){
            *pzErrMsg = sqlite3_mprintf("no such %s mode: %s", zModeType, zVal);
            rc = SQLITE_ERROR;
            goto parse_uri_out;
          }
          if( (mode & ~SQLITE_OPEN_MEMORY)>limit ){
            *pzErrMsg = sqlite3_mprintf("%s mode not allowed: %s",
                                        zModeType, zVal);
            rc = SQLITE_PERM;
            goto parse_uri_out;
          }
          flags = (flags & ~mask) | mode;
        }
      }

      zOpt = &zVal[nVal+1];
    }

  }else{
    zFile = sqlite3_malloc64(nUri+8);
    if( !zFile ) return SQLITE_NOMEM_BKPT;
    memset(zFile, 0, 4);
    zFile += 4;
    if( nUri ){
      memcpy(zFile, zUri, nUri);
    }
    memset(zFile+nUri, 0, 4);
    flags &= ~SQLITE_OPEN_URI;
  }

  *ppVfs = sqlite3_vfs_find(zVfs);
  if( *ppVfs==0 ){
    *pzErrMsg = sqlite3_mprintf("no such vfs: %s", zVfs);
    rc = SQLITE_ERROR;
  }
 parse_uri_out:
  if( rc!=SQLITE_OK ){
    sqlite3_free_filename(zFile);
    zFile = 0;
  }
  *pFlags = flags;
  *pzFile = zFile;
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3c3400
movl %eax, -0x58(%rbp)
movl -0x40(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x4639e2
movzbl 0x1dbe7d(%rip), %eax    # 0x63f856
cmpl $0x0, %eax
je 0x46417f
cmpl $0x5, -0x58(%rbp)
jl 0x46417f
movq -0x18(%rbp), %rdi
leaq 0x14af3b(%rip), %rsi    # 0x5ae932
movl $0x5, %edx
callq 0x192c0
cmpl $0x0, %eax
jne 0x46417f
movl $0x0, -0x6c(%rbp)
movl -0x58(%rbp), %eax
addl $0x8, %eax
cltq
movq %rax, -0x78(%rbp)
movl -0x40(%rbp), %eax
orl $0x40, %eax
movl %eax, -0x40(%rbp)
movl $0x0, -0x68(%rbp)
movl -0x68(%rbp), %eax
cmpl -0x58(%rbp), %eax
jge 0x463a61
movq -0x18(%rbp), %rax
movslq -0x68(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x26, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq -0x78(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x463a2d
movq -0x78(%rbp), %rdi
callq 0x3c07c0
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x463a81
movl $0x7, -0x4(%rbp)
jmp 0x46426a
movq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x19360
movq -0x50(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x50(%rbp)
movl $0x5, -0x68(%rbp)
movq -0x18(%rbp), %rax
movsbl 0x5(%rax), %eax
cmpl $0x2f, %eax
jne 0x463b73
movq -0x18(%rbp), %rax
movsbl 0x6(%rax), %eax
cmpl $0x2f, %eax
jne 0x463b73
movl $0x7, -0x68(%rbp)
movq -0x18(%rbp), %rax
movslq -0x68(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xb9(%rbp)
je 0x463afe
movq -0x18(%rbp), %rax
movslq -0x68(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0xb9(%rbp)
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x463b0a
jmp 0x463b15
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x463acd
cmpl $0x7, -0x68(%rbp)
je 0x463b71
cmpl $0x10, -0x68(%rbp)
jne 0x463b3f
movq -0x18(%rbp), %rsi
addq $0x7, %rsi
leaq 0x14ae08(%rip), %rdi    # 0x5ae938
movl $0x9, %edx
callq 0x192c0
cmpl $0x0, %eax
je 0x463b71
movl -0x68(%rbp), %esi
subl $0x7, %esi
movq -0x18(%rbp), %rdx
addq $0x7, %rdx
leaq 0x14adee(%rip), %rdi    # 0x5ae942
movb $0x0, %al
callq 0x3c3780
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x3c(%rbp)
jmp 0x464239
jmp 0x463b73
movl $0x0, -0x64(%rbp)
movq -0x18(%rbp), %rax
movslq -0x68(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x51(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xba(%rbp)
je 0x463ba8
movsbl -0x51(%rbp), %eax
cmpl $0x23, %eax
setne %al
movb %al, -0xba(%rbp)
movb -0xba(%rbp), %al
testb $0x1, %al
jne 0x463bb7
jmp 0x463e4d
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
movsbl -0x51(%rbp), %eax
cmpl $0x25, %eax
jne 0x463d32
movq -0x18(%rbp), %rax
movslq -0x68(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x142fee(%rip), %rax    # 0x5a6bd0
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x463d32
movq -0x18(%rbp), %rax
movl -0x68(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x142fc4(%rip), %rax    # 0x5a6bd0
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x463d32
movq -0x18(%rbp), %rax
movl -0x68(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x68(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0x40c5a0
movzbl %al, %eax
shll $0x4, %eax
movl %eax, -0x7c(%rbp)
movq -0x18(%rbp), %rax
movl -0x68(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x68(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0x40c5a0
movzbl %al, %eax
addl -0x7c(%rbp), %eax
movl %eax, -0x7c(%rbp)
cmpl $0x0, -0x7c(%rbp)
jne 0x463d27
jmp 0x463c70
movq -0x18(%rbp), %rax
movslq -0x68(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x51(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xbb(%rbp)
je 0x463d08
movsbl -0x51(%rbp), %ecx
xorl %eax, %eax
cmpl $0x23, %ecx
movb %al, -0xbb(%rbp)
je 0x463d08
cmpl $0x0, -0x64(%rbp)
jne 0x463cb6
movsbl -0x51(%rbp), %ecx
xorl %eax, %eax
cmpl $0x3f, %ecx
movb %al, -0xbb(%rbp)
je 0x463d08
cmpl $0x1, -0x64(%rbp)
jne 0x463cde
movsbl -0x51(%rbp), %ecx
xorl %eax, %eax
cmpl $0x3d, %ecx
movb %al, -0xbb(%rbp)
je 0x463d08
movsbl -0x51(%rbp), %ecx
xorl %eax, %eax
cmpl $0x26, %ecx
movb %al, -0xbb(%rbp)
je 0x463d08
movb $0x1, %al
cmpl $0x2, -0x64(%rbp)
movb %al, -0xbc(%rbp)
jne 0x463cfc
movsbl -0x51(%rbp), %eax
cmpl $0x26, %eax
setne %al
movb %al, -0xbc(%rbp)
movb -0xbc(%rbp), %al
movb %al, -0xbb(%rbp)
movb -0xbb(%rbp), %al
testb $0x1, %al
jne 0x463d14
jmp 0x463d22
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x463c70
jmp 0x463b7a
movl -0x7c(%rbp), %eax
movb %al, -0x51(%rbp)
jmp 0x463e30
cmpl $0x1, -0x64(%rbp)
jne 0x463e03
movsbl -0x51(%rbp), %eax
cmpl $0x26, %eax
je 0x463d52
movsbl -0x51(%rbp), %eax
cmpl $0x3d, %eax
jne 0x463e03
movq -0x50(%rbp), %rax
movl -0x6c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x463dd5
jmp 0x463d6a
movq -0x18(%rbp), %rax
movslq -0x68(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xbd(%rbp)
je 0x463db9
movq -0x18(%rbp), %rax
movslq -0x68(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x23, %ecx
movb %al, -0xbd(%rbp)
je 0x463db9
movq -0x18(%rbp), %rax
movl -0x68(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x26, %eax
setne %al
movb %al, -0xbd(%rbp)
movb -0xbd(%rbp), %al
testb $0x1, %al
jne 0x463dc5
jmp 0x463dd0
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x463d6a
jmp 0x463b7a
movsbl -0x51(%rbp), %eax
cmpl $0x26, %eax
jne 0x463df6
movq -0x50(%rbp), %rax
movl -0x6c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x6c(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x463dfd
movl $0x2, -0x64(%rbp)
movb $0x0, -0x51(%rbp)
jmp 0x463e2e
cmpl $0x0, -0x64(%rbp)
jne 0x463e12
movsbl -0x51(%rbp), %eax
cmpl $0x3f, %eax
je 0x463e21
cmpl $0x2, -0x64(%rbp)
jne 0x463e2c
movsbl -0x51(%rbp), %eax
cmpl $0x26, %eax
jne 0x463e2c
movb $0x0, -0x51(%rbp)
movl $0x1, -0x64(%rbp)
jmp 0x463e2e
jmp 0x463e30
movb -0x51(%rbp), %dl
movq -0x50(%rbp), %rax
movl -0x6c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x6c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x463b7a
cmpl $0x1, -0x64(%rbp)
jne 0x463e69
movq -0x50(%rbp), %rax
movl -0x6c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x6c(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x50(%rbp), %rdi
movslq -0x6c(%rbp), %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x19360
movq -0x50(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3c3400
movl %eax, %ecx
movq -0xc8(%rbp), %rax
addl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpb $0x0, (%rax)
je 0x46417d
movq -0x60(%rbp), %rdi
callq 0x3c3400
movl %eax, -0x80(%rbp)
movq -0x60(%rbp), %rax
movl -0x80(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0x3c3400
movl %eax, -0x8c(%rbp)
cmpl $0x3, -0x80(%rbp)
jne 0x463f1c
movq -0x60(%rbp), %rsi
leaq 0x14aa61(%rip), %rdi    # 0x5ae95e
movl $0x3, %edx
callq 0x192c0
cmpl $0x0, %eax
jne 0x463f1c
movq -0x88(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x46415e
movq $0x0, -0x98(%rbp)
movq $0x0, -0xa0(%rbp)
movl $0x0, -0xa4(%rbp)
movl $0x0, -0xa8(%rbp)
cmpl $0x5, -0x80(%rbp)
jne 0x463f98
movq -0x60(%rbp), %rsi
leaq 0xc0239(%rip), %rdi     # 0x524190
movl $0x5, %edx
callq 0x192c0
cmpl $0x0, %eax
jne 0x463f98
movl $0x60000, -0xa4(%rbp)   # imm = 0x60000
leaq 0x1dc0c9(%rip), %rax    # 0x640040
movq %rax, -0x98(%rbp)
movl -0xa4(%rbp), %eax
movl %eax, -0xa8(%rbp)
leaq 0xc01ff(%rip), %rax     # 0x524190
movq %rax, -0xa0(%rbp)
cmpl $0x4, -0x80(%rbp)
jne 0x463fe9
movq -0x60(%rbp), %rax
movl (%rax), %eax
subl $0x65646f6d, %eax       # imm = 0x65646F6D
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x463fe9
movl $0x87, -0xa4(%rbp)
leaq 0x1dc0ab(%rip), %rax    # 0x640070
movq %rax, -0x98(%rbp)
movl -0xa4(%rbp), %eax
andl -0x40(%rbp), %eax
movl %eax, -0xa8(%rbp)
leaq 0xd531c(%rip), %rax     # 0x5392fe
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0x98(%rbp)
je 0x46415c
movl $0x0, -0xb0(%rbp)
movl $0x0, -0xac(%rbp)
movq -0x98(%rbp), %rax
movslq -0xac(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x4640c5
movq -0x98(%rbp), %rax
movslq -0xac(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
movl -0x8c(%rbp), %eax
movl %eax, -0xcc(%rbp)
movq -0xb8(%rbp), %rdi
callq 0x3c3400
movl %eax, %ecx
movl -0xcc(%rbp), %eax
cmpl %ecx, %eax
jne 0x4640af
movq -0x88(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movslq -0x8c(%rbp), %rdx
callq 0x192c0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x4640af
movq -0x98(%rbp), %rax
movslq -0xac(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0xb0(%rbp)
jmp 0x4640c5
jmp 0x4640b1
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x46400b
cmpl $0x0, -0xb0(%rbp)
jne 0x464100
movq -0xa0(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq 0x14a88b(%rip), %rdi    # 0x5ae96e
movb $0x0, %al
callq 0x3c3780
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x3c(%rbp)
jmp 0x464239
movl -0xb0(%rbp), %eax
andl $0xffffff7f, %eax       # imm = 0xFFFFFF7F
cmpl -0xa8(%rbp), %eax
jle 0x464145
movq -0xa0(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq 0x14a85a(%rip), %rdi    # 0x5ae982
movb $0x0, %al
callq 0x3c3780
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl $0x3, -0x3c(%rbp)
jmp 0x464239
movl -0x40(%rbp), %eax
movl -0xa4(%rbp), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
orl -0xb0(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x46415e
movq -0x88(%rbp), %rax
movl -0x8c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
jmp 0x463eaa
jmp 0x4641f7
movl -0x58(%rbp), %eax
addl $0x8, %eax
movslq %eax, %rdi
callq 0x3c07c0
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x4641a4
movl $0x7, -0x4(%rbp)
jmp 0x46426a
movq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x19360
movq -0x50(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x58(%rbp)
je 0x4641d7
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x58(%rbp), %rdx
callq 0x19610
movq -0x50(%rbp), %rdi
movslq -0x58(%rbp), %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x19360
movl -0x40(%rbp), %eax
andl $-0x41, %eax
movl %eax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3c0120
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x464237
movq -0x48(%rbp), %rsi
leaq 0x14a77b(%rip), %rdi    # 0x5ae99a
movb $0x0, %al
callq 0x3c3780
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x3c(%rbp)
jmp 0x464239
cmpl $0x0, -0x3c(%rbp)
je 0x464250
movq -0x50(%rbp), %rdi
callq 0x3d5310
movq $0x0, -0x50(%rbp)
movl -0x40(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)