// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: MIME_decode_encoding
int MIME_decode_encoding( FFGET_FILE *f, char *unpackdir, struct MIMEH_header_info *hinfo, struct SS_object *ss )
{
    int keep = 1;
    int result = -1;

    if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Start:DEBUG: (%s)\n",FL, hinfo->filename);

    // If we have a valid filename, then put it through the process of
    //  cleaning and filtering
    if (isprint((int)hinfo->filename[0]))
    {
        if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Filename is valid, cleaning\n",FL);
        FNFILTER_filter(hinfo->filename, _MIMEH_FILENAMELEN_MAX);   /* check out thefilename for ISO filenames */
    }

    // If the filename is NOT valid [doesn't have a printable first char]
    //  then we must create a new file name for it.
    //
    if (hinfo->filename[0] == '\0')
    {
        if (glb.name_by_type == 1)
        {
            // If we're to name our nameless files based on the content-type
            //      then we need to get the content-type string from the hinfo
            //      and then strip it of any nasty characters (such as / and \)
            char *filename_prefix;
            filename_prefix = strdup( hinfo->content_type_string );
            if (filename_prefix != NULL)
            {
                char *pp;
                pp = filename_prefix;
                while (*pp) { if ((*pp == '/') || (*pp == '\\')) *pp = '-'; pp++; }
                snprintf( hinfo->filename, _MIMEH_FILENAMELEN_MAX, "%s%s%d", glb.blankfileprefix_expliticly_set?glb.blankfileprefix:"", filename_prefix, glb.filecount );
                free(filename_prefix);
            } else {
                snprintf( hinfo->filename, _MIMEH_FILENAMELEN_MAX, "%s%d", glb.blankfileprefix, glb.filecount );
            }
        } else {
            // If we don't care to rename our files based on the content-type
            //      then we'll simply use the blankfileprefix.
            snprintf( hinfo->filename, _MIMEH_FILENAMELEN_MAX, "%s%d", glb.blankfileprefix, glb.filecount );
        }
        if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Filename is empty, setting to default...(%s)\n",FL, hinfo->filename);
        if (glb.no_nameless) keep = 0;
        glb.filecount++;
    }
    else if (strncmp(hinfo->filename, glb.blankfileprefix, strlen(glb.blankfileprefix)) != 0)
    {
        // If the filename does not contain the blankfile prefix at the beginning, then we
        //  will consider it a normal attachment, thus, we
        // need to increment the attachment count
        glb.attachment_count++;
    }
    // If we are required to have "unique" filenames for everything, rather than
    //  allowing ripMIME to overwrite stuff, then we put the filename through
    //      its tests here
    if ((glb.unique_names)&&(keep))
    {
        MIME_test_uniquename( unpackdir, hinfo->filename, glb.rename_method );
    }
    // If the calling program requested verbosity, then indicate that we're decoding
    //      the file here
    if ((keep)&&(MIME_VERBOSE))
    {
        if (MIME_VERBOSE_12)
        {
            LOGGER_log("Decoding: %s\n", hinfo->filename);
        } else {
            // Now, please bare with me on this horrid little piece of tortured code,
            // ... basically, now that we're using LOGGER_log to generate our output, we
            // need to compose everything onto a single LOGGER_log() call, otherwise our
            // output will get split into several lines, not entirely the most plesant
            // thing we want to see when we've got another program most likely reading
            // the output.
            //
            // The %s%s pair is DELIBERATELY pressed up against the 'Decoding' word because
            // otherwise, if we are not outputting any data, we'll end up with a double
            // space between Decoding and filename, certainly not very good thing to do
            // if we're trying to present a consistant output.
            //
            // The parameters for the content-type output are decided on by the result
            // of the MIMEH_get_verbosity_contenttype() call.  If the call returns > 0
            // then the TRUE token is selected to be displayed, else the FALSE token
            // ( in this case, an empty string "" ) is selected.
            // The format of the evaluation is:
            //
            //      (logic-test?true-expression:false-expression)
            if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: About to execute callback [0x%p]",FL,glb.filename_decoded_reporter);
            if (glb.filename_decoded_reporter != NULL)
            {
                glb.filename_decoded_reporter( hinfo->filename, (MIMEH_get_verbosity_contenttype()?hinfo->content_type_string:NULL));
            }

        } // If we were using the new filename telling format
    } // If we were telling the filename (verbosity)
    if (1)
    {
        char *fp;
        /** Find the start of the filename. **/
        fp = strrchr(hinfo->filename, '/');
        if (fp) fp++; else fp = hinfo->filename;
        //LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Pushing filename %s to the stack",FL,fp);
        // 20040305-1419:PLD
        // Store the filename we're going to use to save the file to in the filename stack
        SS_push(ss, fp, strlen(fp));
    }
    // Select the decoding method based on the content transfer encoding
    //  method which we read from the headers

    if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: ENCODING = %d\n",FL, hinfo->content_transfer_encoding);
    switch (hinfo->content_transfer_encoding)
    {
        case _CTRANS_ENCODING_B64:
            if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Decoding BASE64 format\n",FL);
            result = MIME_decode_64(f, unpackdir, hinfo);
            switch (result) {
                case MIME_ERROR_B64_INPUT_STREAM_EOF:
                    break;
                case MIME_BASE64_STATUS_HIT_BOUNDARY:
                    result = 0;
                    break;
                case 0:
                    result = MIME_decode_64_cleanup(f, unpackdir, hinfo);
                    break;
                default:
                    break;
            }
            break;
        case _CTRANS_ENCODING_7BIT:
            if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Decoding 7BIT format\n",FL);
            result = MIME_decode_text(f, unpackdir, hinfo, keep);
            break;
        case _CTRANS_ENCODING_8BIT:
            if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Decoding 8BIT format\n",FL);
            result = MIME_decode_text(f, unpackdir, hinfo, keep);
            break;
        case _CTRANS_ENCODING_BINARY:
        case _CTRANS_ENCODING_RAW:
            if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Decoding RAW format\n",FL);
            result = MIME_decode_raw(f, unpackdir, hinfo, keep);
            break;
        case _CTRANS_ENCODING_QP:
            if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Decoding Quoted-Printable format\n",FL);
            result = MIME_decode_text(f, unpackdir, hinfo, keep);
            break;
        case _CTRANS_ENCODING_UUENCODE:
            if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Decoding UUENCODED format\n",FL);
            // Added as a test - remove if we can get this to work in a better way
            snprintf(hinfo->uudec_name,sizeof(hinfo->uudec_name),"%s",hinfo->filename);
            result = UUENCODE_decode_uu(f, unpackdir, hinfo->filename, hinfo->uudec_name, sizeof(hinfo->uudec_name), 0, keep );
            glb.attachment_count += result;
            // Because this is a file-count, it's not really an 'error result' as such, so, set the
            //      return code back to 0!
            result = 0;
            break;
        case _CTRANS_ENCODING_UNKNOWN:
            switch (hinfo->content_disposition) {
                case _CDISPOSITION_FORMDATA:
                    if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Decoding UNKNOWN format of FORMDATA disposition\n",FL);
                    result = MIME_decode_raw(f, unpackdir, hinfo, keep);
                    break;
                default:
                    if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Decoding UNKNOWN format\n",FL);
                    result = MIME_decode_text(f, unpackdir, hinfo, keep);
            }
            if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: UNKNOWN Decode completed, result = %d\n",FL,result);
            break;
        case _CTRANS_ENCODING_UNSPECIFIED:
            if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Decoding UNSPECIFIED format\n",FL);
            result = MIME_decode_text(f, unpackdir, hinfo, keep);
            if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Decoding result for UNSPECIFIED format = %d\n",FL, result);
            // 20040114-1236:PLD: Added nested mail checking
            //
            // Sometimes mailpacks have false headers at the start, resulting
            //      in ripMIME terminating the recursion process too early.  This
            //      little test here checks to see if the output of the file is
            //      a nested MIME email (or even an ordinary email
            //
            //  It should be noted, that the reason why the test occurs /here/ is
            //      because dud headers will always result in a UNSPECIFIED encoding
            //
            //  Original sample mailpack was sent by Farit - thanks.
            if (1)
            {
                snprintf(hinfo->scratch,sizeof(hinfo->scratch),"%s/%s",unpackdir,hinfo->filename);
                LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG:REMOVEME: Testing for RFC822 headers in file %s",FL,hinfo->scratch);
                if (MIME_is_file_RFC822(hinfo->scratch) > 0 )
                {
                    // 20040305-1304:PLD: unpack the file, propagate result upwards
                    result = MIME_unpack_single( unpackdir, hinfo->scratch, (hinfo->current_recursion_level+1),ss );
                }
            }
            break;
        default:
            if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Decoding format is not defined (%d)\n",FL, hinfo->content_transfer_encoding);
            result = MIME_decode_raw(f, unpackdir, hinfo, keep);
            break;
    }
    // Analyze our results
    switch (result) {
        case 0:
            break;
        case MIME_STATUS_ZERO_FILE:
            return MIME_STATUS_ZERO_FILE;
            break;
        case MIME_ERROR_FFGET_EMPTY:
            return result;
            break;
        case MIME_ERROR_RECURSION_LIMIT_REACHED:
            return result;
            break;
		  default: 
				return result;
    }

    if ((result != -1)&&(result != MIME_STATUS_ZERO_FILE))
    {
#ifdef RIPOLE
        // If we have OLE decoding active and compiled in, then
        //      do a quick attempt at decoding the file, fortunately
        //      because the ripOLE engine detects if the file is not an
        //      OLE file, it does not have a major impact on the
        //      performance of the ripMIME decoding engine
        if (glb.decode_ole > 0)
        {
            MIME_decode_OLE( unpackdir, hinfo, 0 );
        }
#endif

        // If our content-type was TNEF, then we need to decode it
        //      using an external decoding engine (see tnef/tnef.c)
        // Admittingly, this is not the most ideal way of picking out
        //      TNEF files from our decoded attachments, but, for now
        //      it'll have to do, besides, it does work fine, without any
        //      side-effects
        if (hinfo->content_type == _CTYPE_TNEF)
        {
            if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Decoding TNEF format\n",FL);
            glb.attachment_count++;
            MIME_decode_TNEF( unpackdir, hinfo, 0 );
        } // Decode TNEF

        // Look for Microsoft MHT files... and try decode them.
        //  MHT files are just embedded email files, except they're usually
        //  encoded as BASE64... so, you have to -unencode- them, to which
        //  you find out that lo, you have another email.

        if ((strstr(hinfo->filename,".mht"))||(strstr(hinfo->name,".mht")) )
        {
            if (glb.decode_mht != 0)
            {
                //  Patched 26-01-03: supplied by Chris Hine
                if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Microsoft MHT format email filename='%s'\n",FL, hinfo->filename);
                snprintf(hinfo->scratch,sizeof(hinfo->scratch),"%s/%s",unpackdir,hinfo->filename);

                // 20040305-1304:PLD: unpack the file, propagate result upwards
                result = MIME_unpack_single( unpackdir, hinfo->scratch, (hinfo->current_recursion_level+1),ss );
            }
        } // Decode MHT files
    } // If result != -1
    // End.

    MIME_generate_multiple_hardlink_filenames(hinfo,unpackdir);
    if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_encoding:DEBUG: Done for filename = '%s'",FL,hinfo->filename);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
cmpl $0x1, 0x20860(%rip)     # 0x276f0
jl 0x6eb7
movq -0x20(%rbp), %rcx
addq $0x5efd, %rcx           # imm = 0x5EFD
leaq 0x139f4(%rip), %rdi     # 0x1a898
leaq 0x12624(%rip), %rsi     # 0x194cf
movl $0x8b7, %edx            # imm = 0x8B7
movb $0x0, %al
callq 0x117c0
callq 0x23c0
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl 0x5efd(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x6f13
cmpl $0x1, 0x2080e(%rip)     # 0x276f0
jl 0x6efe
leaq 0x139e2(%rip), %rdi     # 0x1a8cd
leaq 0x125dd(%rip), %rsi     # 0x194cf
movl $0x8bd, %edx            # imm = 0x8BD
movb $0x0, %al
callq 0x117c0
movq -0x20(%rbp), %rdi
addq $0x5efd, %rdi           # imm = 0x5EFD
movl $0x1000, %esi           # imm = 0x1000
callq 0x144e0
movq -0x20(%rbp), %rax
movsbl 0x5efd(%rax), %eax
cmpl $0x0, %eax
jne 0x7095
cmpl $0x1, 0x20fea(%rip)     # 0x27f18
jne 0x7016
movq -0x20(%rbp), %rdi
addq $0x27fc, %rdi           # imm = 0x27FC
callq 0x2390
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x6fe4
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6f91
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x6f7c
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x6f83
movq -0x40(%rbp), %rax
movb $0x2d, (%rax)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x6f5b
movq -0x20(%rbp), %rdi
addq $0x5efd, %rdi           # imm = 0x5EFD
movl 0x20736(%rip), %edx     # 0x276d8
leaq 0x164b1(%rip), %rcx     # 0x1d45a
leaq 0x20320(%rip), %rax     # 0x272d0
addq $0x8, %rax
cmpl $0x0, %edx
cmovneq %rax, %rcx
movq -0x38(%rbp), %r8
movl 0x2030e(%rip), %r9d     # 0x272d4
movl $0x1000, %esi           # imm = 0x1000
leaq 0x1393a(%rip), %rdx     # 0x1a90c
movb $0x0, %al
callq 0x2130
movq -0x38(%rbp), %rdi
callq 0x2030
jmp 0x7014
movq -0x20(%rbp), %rdi
addq $0x5efd, %rdi           # imm = 0x5EFD
movl 0x202de(%rip), %r8d     # 0x272d4
movl $0x1000, %esi           # imm = 0x1000
leaq 0x1390c(%rip), %rdx     # 0x1a90e
leaq 0x202c7(%rip), %rcx     # 0x272d0
addq $0x8, %rcx
movb $0x0, %al
callq 0x2130
jmp 0x7046
movq -0x20(%rbp), %rdi
addq $0x5efd, %rdi           # imm = 0x5EFD
movl 0x202ac(%rip), %r8d     # 0x272d4
movl $0x1000, %esi           # imm = 0x1000
leaq 0x138da(%rip), %rdx     # 0x1a90e
leaq 0x20295(%rip), %rcx     # 0x272d0
addq $0x8, %rcx
movb $0x0, %al
callq 0x2130
cmpl $0x1, 0x206a3(%rip)     # 0x276f0
jl 0x7074
movq -0x20(%rbp), %rcx
addq $0x5efd, %rcx           # imm = 0x5EFD
leaq 0x138b2(%rip), %rdi     # 0x1a913
leaq 0x12467(%rip), %rsi     # 0x194cf
movl $0x8dc, %edx            # imm = 0x8DC
movb $0x0, %al
callq 0x117c0
cmpl $0x0, 0x20e99(%rip)     # 0x27f14
je 0x7084
movl $0x0, -0x2c(%rbp)
movl 0x2024a(%rip), %eax     # 0x272d4
addl $0x1, %eax
movl %eax, 0x20241(%rip)     # 0x272d4
jmp 0x70dc
movq -0x20(%rbp), %rax
addq $0x5efd, %rax           # imm = 0x5EFD
movq %rax, -0x50(%rbp)
leaq 0x2022e(%rip), %rdi     # 0x272d8
callq 0x2100
movq -0x50(%rbp), %rdi
movq %rax, %rdx
leaq 0x20213(%rip), %rsi     # 0x272d0
addq $0x8, %rsi
callq 0x2090
cmpl $0x0, %eax
je 0x70da
movl 0x20e3b(%rip), %eax     # 0x27f0c
addl $0x1, %eax
movl %eax, 0x20e32(%rip)     # 0x27f0c
jmp 0x70dc
cmpl $0x0, 0x2061d(%rip)     # 0x27700
je 0x7105
cmpl $0x0, -0x2c(%rbp)
je 0x7105
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x5efd, %rsi           # imm = 0x5EFD
movl 0x20604(%rip), %edx     # 0x27704
callq 0x41a0
cmpl $0x0, -0x2c(%rbp)
je 0x71c1
cmpl $0x0, 0x205c6(%rip)     # 0x276dc
jle 0x71c1
cmpl $0x0, 0x205bd(%rip)     # 0x276e0
jle 0x7140
movq -0x20(%rbp), %rsi
addq $0x5efd, %rsi           # imm = 0x5EFD
leaq 0x1382c(%rip), %rdi     # 0x1a963
movb $0x0, %al
callq 0x117c0
jmp 0x71bf
cmpl $0x1, 0x205a9(%rip)     # 0x276f0
jl 0x716a
movq 0x235f8(%rip), %rcx     # 0x2a748
leaq 0x1381a(%rip), %rdi     # 0x1a971
leaq 0x12371(%rip), %rsi     # 0x194cf
movl $0x909, %edx            # imm = 0x909
movb $0x0, %al
callq 0x117c0
cmpq $0x0, 0x235d6(%rip)     # 0x2a748
je 0x71bd
movq 0x235cd(%rip), %rax     # 0x2a748
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
addq $0x5efd, %rax           # imm = 0x5EFD
movq %rax, -0x58(%rbp)
callq 0xa500
cmpl $0x0, %eax
je 0x71a7
movq -0x20(%rbp), %rax
addq $0x27fc, %rax           # imm = 0x27FC
movq %rax, -0x68(%rbp)
jmp 0x71af
xorl %eax, %eax
movq %rax, -0x68(%rbp)
jmp 0x71af
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq *%rax
jmp 0x71bf
jmp 0x71c1
movq -0x20(%rbp), %rdi
addq $0x5efd, %rdi           # imm = 0x5EFD
movl $0x2f, %esi
callq 0x2140
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x71ef
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x71fd
movq -0x20(%rbp), %rax
addq $0x5efd, %rax           # imm = 0x5EFD
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x48(%rbp), %rdi
callq 0x2100
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq %rax, %rdx
callq 0x38e0
cmpl $0x1, 0x204c3(%rip)     # 0x276f0
jl 0x7253
movq -0x20(%rbp), %rax
movl 0x166f8(%rax), %ecx
leaq 0x13774(%rip), %rdi     # 0x1a9b4
leaq 0x12288(%rip), %rsi     # 0x194cf
movl $0x91f, %edx            # imm = 0x91F
movb $0x0, %al
callq 0x117c0
movq -0x20(%rbp), %rax
movl 0x166f8(%rax), %eax
movl %eax, -0x7c(%rbp)
subl $-0x1, %eax
je 0x759b
jmp 0x726b
movl -0x7c(%rbp), %eax
testl %eax, %eax
je 0x74e7
jmp 0x7278
movl -0x7c(%rbp), %eax
subl $0x64, %eax
je 0x72ce
jmp 0x7282
movl -0x7c(%rbp), %eax
subl $0x65, %eax
je 0x734f
jmp 0x7290
movl -0x7c(%rbp), %eax
subl $0x66, %eax
je 0x738e
jmp 0x729e
movl -0x7c(%rbp), %eax
subl $0x67, %eax
je 0x740c
jmp 0x72ac
movl -0x7c(%rbp), %eax
addl $-0x68, %eax
subl $0x2, %eax
jb 0x73cd
jmp 0x72bd
movl -0x7c(%rbp), %eax
subl $0x6a, %eax
je 0x744b
jmp 0x7670
cmpl $0x1, 0x2041b(%rip)     # 0x276f0
jl 0x72f1
leaq 0x13707(%rip), %rdi     # 0x1a9e5
leaq 0x121ea(%rip), %rsi     # 0x194cf
movl $0x923, %edx            # imm = 0x923
movb $0x0, %al
callq 0x117c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5800
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x80(%rbp)
testl %eax, %eax
je 0x7332
jmp 0x7311
movl -0x80(%rbp), %eax
subl $0x1, %eax
je 0x7329
jmp 0x731b
movl -0x80(%rbp), %eax
subl $0xf2, %eax
jne 0x7348
jmp 0x7327
jmp 0x734a
movl $0x0, -0x30(%rbp)
jmp 0x734a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x60a0
movl %eax, -0x30(%rbp)
jmp 0x734a
jmp 0x734a
jmp 0x76b4
cmpl $0x1, 0x2039a(%rip)     # 0x276f0
jl 0x7372
leaq 0x136c0(%rip), %rdi     # 0x1aa1f
leaq 0x12169(%rip), %rsi     # 0x194cf
movl $0x933, %edx            # imm = 0x933
movb $0x0, %al
callq 0x117c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x5110
movl %eax, -0x30(%rbp)
jmp 0x76b4
cmpl $0x1, 0x2035b(%rip)     # 0x276f0
jl 0x73b1
leaq 0x136b9(%rip), %rdi     # 0x1aa57
leaq 0x1212a(%rip), %rsi     # 0x194cf
movl $0x937, %edx            # imm = 0x937
movb $0x0, %al
callq 0x117c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x5110
movl %eax, -0x30(%rbp)
jmp 0x76b4
cmpl $0x1, 0x2031c(%rip)     # 0x276f0
jl 0x73f0
leaq 0x136b2(%rip), %rdi     # 0x1aa8f
leaq 0x120eb(%rip), %rsi     # 0x194cf
movl $0x93c, %edx            # imm = 0x93C
movb $0x0, %al
callq 0x117c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x4bc0
movl %eax, -0x30(%rbp)
jmp 0x76b4
cmpl $0x1, 0x202dd(%rip)     # 0x276f0
jl 0x742f
leaq 0x136aa(%rip), %rdi     # 0x1aac6
leaq 0x120ac(%rip), %rsi     # 0x194cf
movl $0x940, %edx            # imm = 0x940
movb $0x0, %al
callq 0x117c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x5110
movl %eax, -0x30(%rbp)
jmp 0x76b4
cmpl $0x1, 0x2029e(%rip)     # 0x276f0
jl 0x746e
leaq 0x136af(%rip), %rdi     # 0x1ab0a
leaq 0x1206d(%rip), %rsi     # 0x194cf
movl $0x944, %edx            # imm = 0x944
movb $0x0, %al
callq 0x117c0
movq -0x20(%rbp), %rdi
addq $0x17b90, %rdi          # imm = 0x17B90
movq -0x20(%rbp), %rcx
addq $0x5efd, %rcx           # imm = 0x5EFD
movl $0x1001, %esi           # imm = 0x1001
leaq 0x17b1a(%rip), %rdx     # 0x1efaa
movb $0x0, %al
callq 0x2130
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x5efd, %rdx           # imm = 0x5EFD
movq -0x20(%rbp), %rcx
addq $0x17b90, %rcx          # imm = 0x17B90
movl -0x2c(%rbp), %eax
movl $0x1001, %r8d           # imm = 0x1001
xorl %r9d, %r9d
movl %eax, (%rsp)
callq 0x134d0
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
addl 0x20a37(%rip), %eax     # 0x27f0c
movl %eax, 0x20a31(%rip)     # 0x27f0c
movl $0x0, -0x30(%rbp)
jmp 0x76b4
movq -0x20(%rbp), %rax
movl 0x17100(%rax), %eax
subl $0x12c, %eax            # imm = 0x12C
jne 0x7536
jmp 0x74fa
cmpl $0x1, 0x201ef(%rip)     # 0x276f0
jl 0x751d
leaq 0x1363d(%rip), %rdi     # 0x1ab47
leaq 0x11fbe(%rip), %rsi     # 0x194cf
movl $0x950, %edx            # imm = 0x950
movb $0x0, %al
callq 0x117c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x4bc0
movl %eax, -0x30(%rbp)
jmp 0x7570
cmpl $0x1, 0x201b3(%rip)     # 0x276f0
jl 0x7559
leaq 0x13654(%rip), %rdi     # 0x1ab9a
leaq 0x11f82(%rip), %rsi     # 0x194cf
movl $0x954, %edx            # imm = 0x954
movb $0x0, %al
callq 0x117c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x5110
movl %eax, -0x30(%rbp)
cmpl $0x1, 0x20179(%rip)     # 0x276f0
jl 0x7596
movl -0x30(%rbp), %ecx
leaq 0x13652(%rip), %rdi     # 0x1abd5
leaq 0x11f45(%rip), %rsi     # 0x194cf
movl $0x957, %edx            # imm = 0x957
movb $0x0, %al
callq 0x117c0
jmp 0x76b4
cmpl $0x1, 0x2014e(%rip)     # 0x276f0
jl 0x75be
leaq 0x13673(%rip), %rdi     # 0x1ac1e
leaq 0x11f1d(%rip), %rsi     # 0x194cf
movl $0x95a, %edx            # imm = 0x95A
movb $0x0, %al
callq 0x117c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x5110
movl %eax, -0x30(%rbp)
cmpl $0x1, 0x20114(%rip)     # 0x276f0
jl 0x75fb
movl -0x30(%rbp), %ecx
leaq 0x13675(%rip), %rdi     # 0x1ac5d
leaq 0x11ee0(%rip), %rsi     # 0x194cf
movl $0x95c, %edx            # imm = 0x95C
movb $0x0, %al
callq 0x117c0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
addq $0x5efd, %r8            # imm = 0x5EFD
movl $0x27f7, %esi           # imm = 0x27F7
leaq 0x11ee2(%rip), %rdx     # 0x194fc
movb $0x0, %al
callq 0x2130
movq -0x20(%rbp), %rcx
leaq 0x13680(%rip), %rdi     # 0x1acac
leaq 0x11e9c(%rip), %rsi     # 0x194cf
movl $0x96b, %edx            # imm = 0x96B
movb $0x0, %al
callq 0x117c0
movq -0x20(%rbp), %rdi
callq 0x4580
cmpl $0x0, %eax
jle 0x766e
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0x18b94(%rax), %edx
addl $0x1, %edx
movq -0x28(%rbp), %rcx
callq 0x78b0
movl %eax, -0x30(%rbp)
jmp 0x76b4
cmpl $0x1, 0x20079(%rip)     # 0x276f0
jl 0x769d
movq -0x20(%rbp), %rax
movl 0x166f8(%rax), %ecx
leaq 0x13673(%rip), %rdi     # 0x1acfd
leaq 0x11e3e(%rip), %rsi     # 0x194cf
movl $0x974, %edx            # imm = 0x974
movb $0x0, %al
callq 0x117c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x4bc0
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x84(%rbp)
testl %eax, %eax
je 0x76ee
jmp 0x76c3
movl -0x84(%rbp), %eax
subl $0x64, %eax
je 0x76f0
jmp 0x76d0
movl -0x84(%rbp), %eax
subl $0xf0, %eax
je 0x7707
jmp 0x76df
movl -0x84(%rbp), %eax
subl $0xf1, %eax
je 0x76fc
jmp 0x7712
jmp 0x771d
movl $0x64, -0x4(%rbp)
jmp 0x789b
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x789b
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x789b
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x789b
cmpl $-0x1, -0x30(%rbp)
je 0x785a
cmpl $0x64, -0x30(%rbp)
je 0x785a
cmpl $0x0, 0x207fc(%rip)     # 0x27f34
jle 0x7749
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x4a70
movq -0x20(%rbp), %rax
cmpl $0x258, 0x27f8(%rax)    # imm = 0x258
jne 0x779a
cmpl $0x1, 0x1ff90(%rip)     # 0x276f0
jl 0x777c
leaq 0x135db(%rip), %rdi     # 0x1ad44
leaq 0x11d5f(%rip), %rsi     # 0x194cf
movl $0x99f, %edx            # imm = 0x99F
movb $0x0, %al
callq 0x117c0
movl 0x2078a(%rip), %eax     # 0x27f0c
addl $0x1, %eax
movl %eax, 0x20781(%rip)     # 0x27f0c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x4970
movq -0x20(%rbp), %rdi
addq $0x5efd, %rdi           # imm = 0x5EFD
leaq 0x135d0(%rip), %rsi     # 0x1ad7c
callq 0x23b0
cmpq $0x0, %rax
jne 0x77d8
movq -0x20(%rbp), %rdi
addq $0x6efe, %rdi           # imm = 0x6EFE
leaq 0x135b3(%rip), %rsi     # 0x1ad7c
callq 0x23b0
cmpq $0x0, %rax
je 0x7858
cmpl $0x0, 0x20751(%rip)     # 0x27f30
je 0x7856
cmpl $0x1, 0x1ff08(%rip)     # 0x276f0
jl 0x780f
movq -0x20(%rbp), %rcx
addq $0x5efd, %rcx           # imm = 0x5EFD
leaq 0x13585(%rip), %rdi     # 0x1ad81
leaq 0x11ccc(%rip), %rsi     # 0x194cf
movl $0x9ae, %edx            # imm = 0x9AE
movb $0x0, %al
callq 0x117c0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
addq $0x5efd, %r8            # imm = 0x5EFD
movl $0x27f7, %esi           # imm = 0x27F7
leaq 0x11cce(%rip), %rdx     # 0x194fc
movb $0x0, %al
callq 0x2130
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0x18b94(%rax), %edx
addl $0x1, %edx
movq -0x28(%rbp), %rcx
callq 0x78b0
movl %eax, -0x30(%rbp)
jmp 0x7858
jmp 0x785a
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6b00
cmpl $0x1, 0x1fe82(%rip)     # 0x276f0
jl 0x7895
movq -0x20(%rbp), %rcx
addq $0x5efd, %rcx           # imm = 0x5EFD
leaq 0x1354b(%rip), %rdi     # 0x1adcd
leaq 0x11c46(%rip), %rsi     # 0x194cf
movl $0x9b9, %edx            # imm = 0x9B9
movb $0x0, %al
callq 0x117c0
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)