// File: /workspace/github_c_makefile_star2_O1/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_FormatString
Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_Obj *const *objv)
{
    const char *span, *format, *formatEnd, *msg;
    int numBytes = 0, objIndex = 0, gotXpg = 0, gotSequential = 0;
    static const char * const mixedXPG =
            "cannot mix \"%\" and \"%n$\" conversion specifiers";
    static const char * const badIndex[2] = {
        "not enough arguments for all format specifiers",
        "\"%n$\" argument index out of range"
    };
    int formatLen;
    Jim_Obj *resultPtr;

    char *num_buffer = NULL;
    int num_buffer_size = 0;

    span = format = Jim_GetString(fmtObjPtr, &formatLen);
    formatEnd = format + formatLen;
    resultPtr = Jim_NewEmptyStringObj(interp);

    while (format != formatEnd) {
        char *end;
        int gotMinus, sawFlag;
        int gotPrecision, useShort;
        long width, precision;
        int newXpg;
        int ch;
        int step;
        int doubleType;
        char pad = ' ';
        char spec[2*JIM_INTEGER_SPACE + 12];
        char *p;

        int formatted_chars;
        int formatted_bytes;
        const char *formatted_buf;

        step = utf8_tounicode(format, &ch);
        format += step;
        if (ch != '%') {
            numBytes += step;
            continue;
        }
        if (numBytes) {
            Jim_AppendString(interp, resultPtr, span, numBytes);
            numBytes = 0;
        }


        step = utf8_tounicode(format, &ch);
        if (ch == '%') {
            span = format;
            numBytes = step;
            format += step;
            continue;
        }


        newXpg = 0;
        if (isdigit(ch)) {
            int position = strtoul(format, &end, 10);
            if (*end == '$') {
                newXpg = 1;
                objIndex = position - 1;
                format = end + 1;
                step = utf8_tounicode(format, &ch);
            }
        }
        if (newXpg) {
            if (gotSequential) {
                msg = mixedXPG;
                goto errorMsg;
            }
            gotXpg = 1;
        } else {
            if (gotXpg) {
                msg = mixedXPG;
                goto errorMsg;
            }
            gotSequential = 1;
        }
        if ((objIndex < 0) || (objIndex >= objc)) {
            msg = badIndex[gotXpg];
            goto errorMsg;
        }

        p = spec;
        *p++ = '%';

        gotMinus = 0;
        sawFlag = 1;
        do {
            switch (ch) {
            case '-':
                gotMinus = 1;
                break;
            case '0':
                pad = ch;
                break;
            case ' ':
            case '+':
            case '#':
                break;
            default:
                sawFlag = 0;
                continue;
            }
            *p++ = ch;
            format += step;
            step = utf8_tounicode(format, &ch);

        } while (sawFlag && (p - spec <= 5));


        width = 0;
        if (isdigit(ch)) {
            width = strtoul(format, &end, 10);
            format = end;
            step = utf8_tounicode(format, &ch);
        } else if (ch == '*') {
            if (objIndex >= objc - 1) {
                msg = badIndex[gotXpg];
                goto errorMsg;
            }
            if (Jim_GetLong(interp, objv[objIndex], &width) != JIM_OK) {
                goto error;
            }
            if (width < 0) {
                width = -width;
                if (!gotMinus) {
                    *p++ = '-';
                    gotMinus = 1;
                }
            }
            objIndex++;
            format += step;
            step = utf8_tounicode(format, &ch);
        }


        gotPrecision = precision = 0;
        if (ch == '.') {
            gotPrecision = 1;
            format += step;
            step = utf8_tounicode(format, &ch);
        }
        if (isdigit(ch)) {
            precision = strtoul(format, &end, 10);
            format = end;
            step = utf8_tounicode(format, &ch);
        } else if (ch == '*') {
            if (objIndex >= objc - 1) {
                msg = badIndex[gotXpg];
                goto errorMsg;
            }
            if (Jim_GetLong(interp, objv[objIndex], &precision) != JIM_OK) {
                goto error;
            }


            if (precision < 0) {
                precision = 0;
            }
            objIndex++;
            format += step;
            step = utf8_tounicode(format, &ch);
        }


        useShort = 0;
        if (ch == 'h') {
            useShort = 1;
            format += step;
            step = utf8_tounicode(format, &ch);
        } else if (ch == 'l') {

            format += step;
            step = utf8_tounicode(format, &ch);
            if (ch == 'l') {
                format += step;
                step = utf8_tounicode(format, &ch);
            }
        }

        format += step;
        span = format;


        if (ch == 'i') {
            ch = 'd';
        }

        doubleType = 0;

        switch (ch) {
        case '\0':
            msg = "format string ended in middle of field specifier";
            goto errorMsg;
        case 's': {
            formatted_buf = Jim_GetString(objv[objIndex], &formatted_bytes);
            formatted_chars = Jim_Utf8Length(interp, objv[objIndex]);
            if (gotPrecision && (precision < formatted_chars)) {

                formatted_chars = precision;
                formatted_bytes = utf8_index(formatted_buf, precision);
            }
            break;
        }
        case 'c': {
            jim_wide code;

            if (Jim_GetWide(interp, objv[objIndex], &code) != JIM_OK) {
                goto error;
            }

            formatted_bytes = utf8_getchars(spec, code);
            formatted_buf = spec;
            formatted_chars = 1;
            break;
        }
        case 'b': {
                unsigned jim_wide w;
                int length;
                int i;
                int j;

                if (Jim_GetWide(interp, objv[objIndex], (jim_wide *)&w) != JIM_OK) {
                    goto error;
                }
                length = sizeof(w) * 8;



                if (num_buffer_size < length + 1) {
                    num_buffer_size = length + 1;
                    num_buffer = Jim_Realloc(num_buffer, num_buffer_size);
                }

                j = 0;
                for (i = length; i > 0; ) {
                        i--;
                        if (w & ((unsigned jim_wide)1 << i)) {
                                num_buffer[j++] = '1';
                        }
                        else if (j || i == 0) {
                                num_buffer[j++] = '0';
                        }
                }
                num_buffer[j] = 0;
                formatted_chars = formatted_bytes = j;
                formatted_buf = num_buffer;
                break;
        }

        case 'e':
        case 'E':
        case 'f':
        case 'g':
        case 'G':
            doubleType = 1;

        case 'd':
        case 'u':
        case 'o':
        case 'x':
        case 'X': {
            jim_wide w;
            double d;
            int length;


            if (width) {
                p += sprintf(p, "%ld", width);
            }
            if (gotPrecision) {
                p += sprintf(p, ".%ld", precision);
            }


            if (doubleType) {
                if (Jim_GetDouble(interp, objv[objIndex], &d) != JIM_OK) {
                    goto error;
                }
                length = MAX_FLOAT_WIDTH;
            }
            else {
                if (Jim_GetWide(interp, objv[objIndex], &w) != JIM_OK) {
                    goto error;
                }
                length = JIM_INTEGER_SPACE;
                if (useShort) {
                    if (ch == 'd') {
                        w = (short)w;
                    }
                    else {
                        w = (unsigned short)w;
                    }
                }
                *p++ = 'l';
#ifdef HAVE_LONG_LONG
                if (sizeof(long long) == sizeof(jim_wide)) {
                    *p++ = 'l';
                }
#endif
            }

            *p++ = (char) ch;
            *p = '\0';


            if (width > 10000 || length > 10000 || precision > 10000) {
                Jim_SetResultString(interp, "format too long", -1);
                goto error;
            }



            if (width > length) {
                length = width;
            }
            if (gotPrecision) {
                length += precision;
            }


            if (num_buffer_size < length + 1) {
                num_buffer_size = length + 1;
                num_buffer = Jim_Realloc(num_buffer, num_buffer_size);
            }

            if (doubleType) {
                snprintf(num_buffer, length + 1, spec, d);
            }
            else {
                formatted_bytes = snprintf(num_buffer, length + 1, spec, w);
            }
            formatted_chars = formatted_bytes = strlen(num_buffer);
            formatted_buf = num_buffer;
            break;
        }

        default: {

            spec[0] = ch;
            spec[1] = '\0';
            Jim_SetResultFormatted(interp, "bad field specifier \"%s\"", spec);
            goto error;
        }
        }

        if (!gotMinus) {
            while (formatted_chars < width) {
                Jim_AppendString(interp, resultPtr, &pad, 1);
                formatted_chars++;
            }
        }

        Jim_AppendString(interp, resultPtr, formatted_buf, formatted_bytes);

        while (formatted_chars < width) {
            Jim_AppendString(interp, resultPtr, &pad, 1);
            formatted_chars++;
        }

        objIndex += gotSequential;
    }
    if (numBytes) {
        Jim_AppendString(interp, resultPtr, span, numBytes);
    }

    Jim_Free(num_buffer);
    return resultPtr;

  errorMsg:
    Jim_SetResultString(interp, msg, -1);
  error:
    Jim_FreeNewObj(interp, resultPtr);
    Jim_Free(num_buffer);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rcx, -0xa0(%rbp)
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, (%rsi)
jne 0x12194
movq 0x8(%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movslq 0x14(%rbx), %r13
movq (%rbx), %rbx
movq %r14, -0x48(%rbp)
movq %r14, %rdi
callq 0xae58
leaq 0x260ea(%rip), %rcx     # 0x38298
movq %rcx, (%rax)
movl $0x0, 0x14(%rax)
movq %rax, -0x58(%rbp)
movq $0x0, 0x8(%rax)
testq %r13, %r13
movq %rbx, -0x50(%rbp)
je 0x12cd0
addq %rbx, %r13
movq %r15, -0xe8(%rbp)
leal -0x1(%r15), %eax
movl %eax, -0xcc(%rbp)
movq %rbx, %r8
movq %rax, -0x98(%rbp)
movl $0x0, -0x84(%rbp)
movq $0x0, -0x40(%rbp)
xorl %r12d, %r12d
xorl %ebx, %ebx
xorl %r14d, %r14d
movl $0x0, -0x34(%rbp)
movq %rax, -0x78(%rbp)
movq %r13, %r15
movq %r13, -0x60(%rbp)
movb $0x20, -0x29(%rbp)
leaq 0x1(%r8), %r13
cmpb $0x25, (%r8)
jne 0x12271
testl %r12d, %r12d
je 0x12248
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl %r12d, %ecx
movq %r8, %r15
callq 0x8653
movq %r15, %r8
movzbl (%r13), %r15d
cmpq $0x25, %r15
jne 0x12287
addq $0x2, %r8
movl $0x2, %esi
movl $0x1, %r12d
movl %r14d, %edx
movl %ebx, %r9d
movq %r13, -0x50(%rbp)
jmp 0x12442
incl %r12d
movl $0x2, %esi
movl %r14d, %edx
movl %ebx, %r9d
movq %r13, %r8
jmp 0x12446
callq 0x64e0
movq %rax, %r10
movq (%rax), %rax
movb $0x1, %cl
testb $0x8, 0x1(%rax,%r15,2)
je 0x122d6
movq %r13, %rdi
leaq -0xc8(%rbp), %rsi
movl $0xa, %edx
movq %r10, %r12
callq 0x6460
movq %r12, %r10
movq -0xc8(%rbp), %rdx
cmpb $0x24, (%rdx)
setne %cl
jne 0x122d6
decl %eax
movb 0x1(%rdx), %r15b
incq %rdx
xorl %ecx, %ecx
movl %eax, -0x34(%rbp)
movq %rdx, %r13
movl $0x4, %esi
testb %cl, %cl
je 0x122fc
movl $0x1, %r9d
xorl %r12d, %r12d
movl $0x0, %edx
testl %r14d, %r14d
je 0x1232a
movl $0x1, %edx
movl %ebx, %r9d
jmp 0x12317
xorl %r12d, %r12d
movl $0x1, %edx
movl $0x0, %r9d
testl %ebx, %ebx
je 0x1232a
movl %r14d, %edx
movl $0x1, %r9d
leaq 0x19da1(%rip), %rcx     # 0x2c0bf
movq %rcx, -0xb8(%rbp)
jmp 0x1243f
movl -0x34(%rbp), %ecx
testl %ecx, %ecx
setns %al
cmpl -0xe8(%rbp), %ecx
setl %cl
testb %cl, %al
je 0x12428
movzbl %r15b, %ebx
movb $0x25, -0x130(%rbp)
xorl %esi, %esi
leaq -0x12f(%rbp), %r14
movq -0x48(%rbp), %rdi
leaq -0x130(%rbp), %rcx
xorl %eax, %eax
cmpl $0x2a, %ebx
jle 0x1237f
cmpl $0x2b, %ebx
je 0x1238f
cmpl $0x30, %ebx
je 0x1238b
cmpl $0x2d, %ebx
jne 0x1239f
movl $0x1, %esi
jmp 0x1238f
cmpl $0x20, %ebx
je 0x1238f
cmpl $0x23, %ebx
je 0x1238f
jmp 0x1239f
movb $0x30, -0x29(%rbp)
movb %bl, (%r14)
incq %r14
movzbl 0x1(%r13), %ebx
incq %r13
movb $0x1, %al
testb %al, %al
je 0x123af
movq %r14, %rax
subq %rcx, %rax
cmpq $0x6, %rax
jl 0x12362
movq (%r10), %rax
movl %ebx, %ecx
testb $0x8, 0x1(%rax,%rcx,2)
movl %edx, -0x38(%rbp)
movl %r9d, -0x30(%rbp)
jne 0x12475
cmpl $0x2a, %ebx
jne 0x124ab
movl -0x34(%rbp), %eax
cmpl -0xcc(%rbp), %eax
jge 0x1276c
movl %esi, -0x6c(%rbp)
movl %eax, %eax
movq -0xa0(%rbp), %rcx
movq (%rcx,%rax,8), %r15
leaq 0x23eeb(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r15)
je 0x127d7
movq %r15, %rsi
movl $0x1, %edx
movq %r10, %rbx
callq 0xd6d7
movq %rbx, %r10
movl -0x30(%rbp), %r9d
movl -0x38(%rbp), %edx
testl %eax, %eax
je 0x127d7
xorl %ecx, %ecx
jmp 0x127dd
movl %edx, %eax
leaq 0x244df(%rip), %rcx     # 0x36910
movq (%rcx,%rax,8), %rax
movq %rax, -0xb8(%rbp)
xorl %r12d, %r12d
movq %r13, %r8
movq -0x60(%rbp), %r15
cmpl $0x8, %esi
ja 0x12d69
movl %esi, %eax
leaq 0x15e00(%rip), %rcx     # 0x28258
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %r9d, %ebx
movl %edx, %r14d
cmpq %r15, %r8
jne 0x1221b
jmp 0x12cdb
movl %esi, -0x6c(%rbp)
movq %r13, %rdi
leaq -0xc8(%rbp), %rsi
movl $0xa, %edx
movq %r10, %rbx
callq 0x6460
movq %rbx, %r10
movl -0x30(%rbp), %r9d
movl -0x38(%rbp), %edx
movq -0xc8(%rbp), %r13
movq -0x60(%rbp), %r15
movzbl (%r13), %ebx
jmp 0x124b4
movl %esi, -0x6c(%rbp)
xorl %eax, %eax
movq -0x60(%rbp), %r15
movq %rax, -0x90(%rbp)
cmpl $0x2e, %ebx
jne 0x124ca
movzbl 0x1(%r13), %edi
incq %r13
jmp 0x124cc
movl %ebx, %edi
movq %r13, %r8
movq (%r10), %rax
movl %edi, %ecx
testb $0x8, 0x1(%rax,%rcx,2)
leaq -0x29(%rbp), %r13
jne 0x12545
cmpl $0x2a, %edi
jne 0x12570
movl -0x34(%rbp), %eax
cmpl -0xcc(%rbp), %eax
jge 0x1279d
movl %eax, %eax
movq -0xa0(%rbp), %rcx
movq (%rcx,%rax,8), %r12
leaq 0x23dd5(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r12)
je 0x1281c
movq -0x48(%rbp), %rdi
movq %r12, %rsi
movl $0x1, %edx
movq %r8, -0x68(%rbp)
callq 0xd6d7
movq -0x68(%rbp), %r8
movl -0x30(%rbp), %r9d
movl -0x38(%rbp), %edx
testl %eax, %eax
je 0x1281c
xorl %eax, %eax
jmp 0x12823
movq %r8, %rdi
leaq -0xc8(%rbp), %rsi
movl $0xa, %edx
callq 0x6460
movl -0x30(%rbp), %r9d
movl -0x38(%rbp), %edx
movq %rax, %rsi
movq -0xc8(%rbp), %r8
movzbl (%r8), %edi
jmp 0x12572
xorl %esi, %esi
movl $0x1, %eax
cmpl $0x68, %edi
jne 0x12586
movzbl (%r8,%rax), %r12d
addq %rax, %r8
jmp 0x125a3
cmpl $0x6c, %edi
jne 0x125a0
movzbl 0x1(%r8), %r12d
movl $0x2, %eax
cmpl $0x6c, %r12d
je 0x1257c
incq %r8
jmp 0x125a3
movl %edi, %r12d
incq %r8
cmpl $0x69, %r12d
movl $0x64, %eax
cmovel %eax, %r12d
cmpl $0x57, %r12d
movq %r8, -0x68(%rbp)
jle 0x12631
movb $0x1, %al
movl %eax, -0x50(%rbp)
leal -0x62(%r12), %eax
cmpl $0x16, %eax
ja 0x1286c
leaq 0x15c25(%rip), %rcx     # 0x281fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x34(%rbp), %eax
movq -0xa0(%rbp), %rcx
movq (%rcx,%rax,8), %rbx
leaq 0x23ceb(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%rbx)
movq -0x48(%rbp), %r12
je 0x12ba2
movq %r12, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xd6d7
movq -0x68(%rbp), %r8
testl %eax, %eax
je 0x12ba2
xorl %ebx, %ebx
movq -0x40(%rbp), %r14
movq -0xd8(%rbp), %rax
jmp 0x12bac
testl %r12d, %r12d
je 0x1283e
cmpl $0x45, %r12d
je 0x1264a
cmpl $0x47, %r12d
jne 0x12876
movl $0x0, -0x50(%rbp)
movl %edi, -0xa4(%rbp)
movq %rsi, -0xc0(%rbp)
movq -0x90(%rbp), %rdx
testq %rdx, %rdx
je 0x12680
movq %r14, %rdi
leaq 0x19afd(%rip), %rsi     # 0x2c171
xorl %eax, %eax
callq 0x6480
cltq
addq %rax, %r14
cmpl $0x2e, %ebx
movl -0x34(%rbp), %r15d
jne 0x126a6
movq %r14, %rdi
leaq 0x19add(%rip), %rsi     # 0x2c170
movq -0xc0(%rbp), %rdx
xorl %eax, %eax
callq 0x6480
cltq
addq %rax, %r14
movl -0xa4(%rbp), %edx
movl %r15d, %eax
movq -0xa0(%rbp), %rcx
movq (%rcx,%rax,8), %r13
cmpb $0x0, -0x50(%rbp)
je 0x126ec
leaq 0x23c19(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%r13)
je 0x1271e
movq -0x48(%rbp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0xd6d7
movl -0xa4(%rbp), %edx
testl %eax, %eax
je 0x1271e
xorl %eax, %eax
jmp 0x1272b
movq -0x48(%rbp), %rdi
movq %r13, %rsi
leaq -0xf0(%rbp), %rdx
callq 0xe057
testl %eax, %eax
je 0x127bb
xorl %edx, %edx
movq -0x58(%rbp), %r15
movq -0x48(%rbp), %r12
movq -0x40(%rbp), %r14
leaq -0x29(%rbp), %r13
jmp 0x12ac4
movq 0x18(%r13), %rax
movq %rax, -0xb0(%rbp)
movb $0x1, %al
leaq -0x29(%rbp), %r13
testb %al, %al
movl -0x30(%rbp), %r9d
movq -0x68(%rbp), %r8
movq -0xc0(%rbp), %rsi
je 0x1278a
cmpl $0x68, %edx
jne 0x12853
cmpl $0x64, %r12d
movq -0x90(%rbp), %rdx
jne 0x1299b
movq -0xb0(%rbp), %rax
movswq %ax, %rax
jmp 0x129a5
movl %edx, %eax
leaq 0x2419b(%rip), %rcx     # 0x36910
movq (%rcx,%rax,8), %rax
movq %rax, -0xb8(%rbp)
movl $0x4, %esi
jmp 0x1243c
xorl %edx, %edx
movq -0x58(%rbp), %r15
movq -0x48(%rbp), %r12
movq -0x40(%rbp), %r14
jmp 0x12acc
movl %edx, %eax
leaq 0x2416a(%rip), %rcx     # 0x36910
movq (%rcx,%rax,8), %rax
movq %rax, -0xb8(%rbp)
movl $0x4, %esi
jmp 0x12864
movl $0x140, %eax            # imm = 0x140
leaq -0x29(%rbp), %r13
movq -0x90(%rbp), %rdx
movq -0xc0(%rbp), %rsi
jmp 0x129b8
movq 0x18(%r15), %rax
movb $0x1, %cl
xorl %r12d, %r12d
movl $0x8, %esi
testb %cl, %cl
cmoveq %r12, %rax
movq -0x60(%rbp), %r15
je 0x1227f
testq %rax, %rax
jns 0x12811
negq %rax
cmpl $0x0, -0x6c(%rbp)
jne 0x12811
movb $0x2d, (%r14)
incq %r14
movl $0x1, -0x6c(%rbp)
incl -0x34(%rbp)
incq %r13
jmp 0x124a4
movq 0x18(%r12), %rsi
movb $0x1, %al
testb %al, %al
je 0x1285f
testq %rsi, %rsi
movl $0x0, %eax
cmovleq %rax, %rsi
incl -0x34(%rbp)
incq %r8
jmp 0x1256a
movl $0x4, %esi
leaq 0x198f5(%rip), %rcx     # 0x2c13f
movq %rcx, -0xb8(%rbp)
jmp 0x128b0
movq -0x90(%rbp), %rdx
jmp 0x129ac
movl $0x8, %esi
xorl %r12d, %r12d
jmp 0x12446
cmpl $0x58, %r12d
je 0x12651
movb %r12b, -0x130(%rbp)
movb $0x0, -0x12f(%rbp)
xorl %r12d, %r12d
movq -0x48(%rbp), %rdi
leaq 0x198f3(%rip), %rsi     # 0x2c185
leaq -0x130(%rbp), %rdx
xorl %eax, %eax
callq 0x692d
movq -0x68(%rbp), %r8
movl -0x30(%rbp), %r9d
movl -0x38(%rbp), %edx
movl $0x8, %esi
movq %r8, -0x50(%rbp)
jmp 0x12446
movl -0x34(%rbp), %eax
movq -0xa0(%rbp), %rcx
movq (%rcx,%rax,8), %rbx
leaq 0x23a12(%rip), %rax     # 0x362e0
cmpq %rax, 0x8(%rbx)
movq -0x48(%rbp), %r12
je 0x12c5c
movq %r12, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0xd6d7
movq -0x68(%rbp), %r8
movl -0x30(%rbp), %r9d
movl -0x38(%rbp), %edx
testl %eax, %eax
je 0x12c5c
xorl %eax, %eax
jmp 0x12c69
movl -0x34(%rbp), %r15d
movq -0xa0(%rbp), %rax
movq (%rax,%r15,8), %r14
cmpq $0x0, (%r14)
jne 0x12932
movq 0x8(%r14), %rax
movq %r14, %rdi
movq %rsi, %r12
callq *0x18(%rax)
movq %r12, %rsi
movq -0xa0(%rbp), %rax
movl 0x14(%r14), %edi
movq (%r14), %rdx
movq (%rax,%r15,8), %r14
cmpq $0x0, (%r14)
movq -0x58(%rbp), %r15
movq -0x48(%rbp), %r12
jne 0x12973
movq 0x8(%r14), %rax
movq %rdi, -0x78(%rbp)
movq %r14, %rdi
movq %rdx, -0x80(%rbp)
movq %rsi, -0xc0(%rbp)
callq *0x18(%rax)
movq -0x78(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0x80(%rbp), %rdx
cmpl $0x2e, %ebx
sete %al
movl 0x14(%r14), %ecx
movslq %ecx, %r8
cmpq %r8, %rsi
setl %cl
testb %cl, %al
cmovnel %esi, %edi
cmovnel %esi, %r8d
movq -0x40(%rbp), %r14
movq %rdi, %rcx
jmp 0x12ae3
movq -0xb0(%rbp), %rax
movzwl %ax, %eax
movq %rax, -0xb0(%rbp)
movb $0x6c, (%r14)
incq %r14
movl $0x18, %eax
movb %r12b, (%r14)
movb $0x0, 0x1(%r14)
cmpq $0x2710, %rdx           # imm = 0x2710
jg 0x12a43
cmpq $0x2711, %rsi           # imm = 0x2711
jge 0x12a43
movl %eax, %ecx
cmpq %rcx, %rdx
movl %edx, %ecx
cmovlel %eax, %ecx
cmpl $0x2e, %ebx
movl $0x0, %eax
cmovnel %eax, %esi
leal (%rcx,%rsi), %eax
leal (%rcx,%rsi), %r14d
incl %r14d
movslq %r14d, %rbx
cmpl %eax, -0x84(%rbp)
movq -0x58(%rbp), %r15
movq -0x48(%rbp), %r12
jg 0x12a1c
movq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq *0x25877(%rip)          # 0x38288
movq %rax, -0x40(%rbp)
movl %r14d, -0x84(%rbp)
movq -0xb0(%rbp), %rcx
cmpb $0x0, -0x50(%rbp)
je 0x12a8b
movq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
leaq -0x130(%rbp), %rdx
xorl %eax, %eax
callq 0x61e0
jmp 0x12aab
movq -0x48(%rbp), %r12
movq %r12, %rdi
leaq 0x19724(%rip), %rsi     # 0x2c175
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %rbx
incl 0x10(%rax)
movq (%r12), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
movq -0x58(%rbp), %r15
jg 0x12a7f
movq %r12, %rdi
callq 0x759a
movq %rbx, (%r12)
xorl %edx, %edx
movq -0x40(%rbp), %r14
jmp 0x12ac4
movsd -0xf0(%rbp), %xmm0
movq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
leaq -0x130(%rbp), %rdx
movb $0x1, %al
callq 0x61e0
movq %r14, %rdi
callq 0x6180
movb $0x1, %dl
movq %rax, -0x78(%rbp)
movq %rax, -0x98(%rbp)
movq %r14, -0x80(%rbp)
movl -0x30(%rbp), %r9d
movq -0x68(%rbp), %r8
testb %dl, %dl
je 0x12b86
movq -0x78(%rbp), %rcx
movq -0x80(%rbp), %rdx
movq -0x98(%rbp), %r8
cmpl $0x0, -0x6c(%rbp)
movq %r14, -0x40(%rbp)
movq %rcx, -0x78(%rbp)
movq %rdx, -0x80(%rbp)
jne 0x12b2e
movslq %r8d, %rbx
cmpq %rbx, -0x90(%rbp)
jle 0x12b2e
movq -0x90(%rbp), %r14
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x8653
incq %rbx
cmpq %rbx, %r14
jg 0x12b08
movl %ebx, %r8d
movq -0x78(%rbp), %rcx
movq -0x80(%rbp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r8, %rbx
callq 0x8653
movq %rbx, %rax
movslq %eax, %rbx
cmpq %rbx, -0x90(%rbp)
jle 0x12b6c
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x8653
incq %rbx
cmpq %rbx, -0x90(%rbp)
jg 0x12b4b
movl %ebx, %eax
movq %rax, -0x98(%rbp)
movl -0x30(%rbp), %r9d
addl %r9d, -0x34(%rbp)
xorl %r12d, %r12d
xorl %esi, %esi
movq -0x68(%rbp), %r8
jmp 0x12b92
movq %r14, -0x40(%rbp)
movl $0x8, %esi
xorl %r12d, %r12d
movq %r8, -0x50(%rbp)
movq -0x60(%rbp), %r15
movl -0x38(%rbp), %edx
jmp 0x12446
movq 0x18(%rbx), %rax
movb $0x1, %bl
movq -0x40(%rbp), %r14
testb %bl, %bl
movq -0x58(%rbp), %r15
movl -0x38(%rbp), %edx
movl -0x30(%rbp), %r9d
movq %rax, -0xd8(%rbp)
je 0x12cab
cmpl $0x40, -0x84(%rbp)
jg 0x12bee
movl $0x41, %esi
movq %r14, %rdi
callq *0x256ab(%rip)          # 0x38288
movl -0x30(%rbp), %r9d
movq %rax, %r14
movl $0x41, -0x84(%rbp)
xorl %ecx, %ecx
movl $0x3f, %eax
movb $0x31, %dl
movq -0xd8(%rbp), %rsi
btq %rax, %rsi
jb 0x12c1b
testl %ecx, %ecx
sete %sil
testq %rax, %rax
setne %dil
xorl %r8d, %r8d
movb $0x30, %dl
testb %dil, %sil
jne 0x12c27
movslq %ecx, %rsi
incl %ecx
movb %dl, (%r14,%rsi)
movl %ecx, %r8d
leaq -0x1(%rax), %rdx
incq %rax
movl %r8d, %ecx
cmpq $0x1, %rax
movq %rdx, %rax
ja 0x12bf5
movslq %r8d, %rax
movb $0x0, (%r14,%rax)
movl %r8d, %eax
movq %rax, -0x98(%rbp)
movq %r14, -0x80(%rbp)
movq %r8, %rcx
movl -0x38(%rbp), %edx
movq -0x68(%rbp), %r8
jmp 0x12caf
movq 0x18(%rbx), %rax
movq %rax, -0xe0(%rbp)
movb $0x1, %al
movq -0x58(%rbp), %r15
testb %al, %al
je 0x12c9e
movq -0xe0(%rbp), %rcx
movb %cl, -0x130(%rbp)
movl $0x1, %ecx
movq %rcx, -0x78(%rbp)
movl $0x1, %ecx
movq %rcx, -0x98(%rbp)
leaq -0x130(%rbp), %rcx
movq %rcx, -0x80(%rbp)
testb %al, %al
je 0x12cbf
movq -0x40(%rbp), %r14
jmp 0x12ad4
movq -0x78(%rbp), %rcx
testb %bl, %bl
jne 0x12ad8
movq %rcx, -0x78(%rbp)
movq %r14, -0x40(%rbp)
movl $0x8, %esi
xorl %r12d, %r12d
movq %r8, -0x50(%rbp)
jmp 0x12442
xorl %r12d, %r12d
movq $0x0, -0x40(%rbp)
testl %r12d, %r12d
je 0x12cf9
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rbx
movq %rbx, %rsi
movq -0x50(%rbp), %rdx
movl %r12d, %ecx
callq 0x8653
jmp 0x12d48
movq -0x58(%rbp), %rbx
jmp 0x12d48
movq -0x48(%rbp), %r14
movq %r14, %rdi
movq -0xb8(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %rbx
incl 0x10(%rax)
movq (%r14), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x12d36
movq %r14, %rdi
callq 0x759a
movq %rbx, (%r14)
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x759a
xorl %ebx, %ebx
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq *0x25534(%rip)          # 0x38288
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12d54