// File: /workspace/github_c_makefile_star2_O2/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 $0xf8, %rsp
movq %rcx, -0x78(%rbp)
movl %edx, %r15d
movq %rdi, %r14
leaq -0xe4(%rbp), %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x7fc7
movq %rax, %r12
movslq (%rbx), %rax
addq %r12, %rax
movq %rax, -0xd8(%rbp)
leaq 0x18956(%rip), %rsi     # 0x29641
movq %r14, %rdi
xorl %edx, %edx
callq 0x7363
movq %rax, %rbx
movq %r15, -0xd0(%rbp)
leal -0x1(%r15), %eax
movl %eax, -0x94(%rbp)
leaq 0x16427(%rip), %rax     # 0x27137
movq %rax, -0xa0(%rbp)
movl $0x0, -0x60(%rbp)
movl $0x0, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
xorl %ecx, %ecx
xorl %r13d, %r13d
movl $0x0, -0x4c(%rbp)
movq %r12, %rdx
movq %rbx, -0xc0(%rbp)
movq %r14, -0xc8(%rbp)
cmpq -0xd8(%rbp), %r12
je 0x113d1
movb $0x20, -0x29(%rbp)
leaq 0x1(%r12), %r15
cmpb $0x25, (%r12)
jne 0x10d8f
movq %r13, -0x48(%rbp)
testl %ecx, %ecx
je 0x10d79
movq %r14, %rdi
movq %rbx, %rsi
callq 0x823a
movzbl (%r15), %r13d
cmpq $0x25, %r13
jne 0x10d96
addq $0x2, %r12
pushq $0x1
popq %rcx
jmp 0x112c4
incl %ecx
movq %r15, %r12
jmp 0x10d49
callq 0x64e0
movq %rax, %rdi
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r13,2)
je 0x10df5
movq %rdi, %r12
movq %r15, %rdi
leaq -0x90(%rbp), %rsi
pushq $0xa
popq %rdx
callq 0x6460
movq %r12, %rdi
movq -0x90(%rbp), %rcx
cmpb $0x24, (%rcx)
jne 0x10df5
cmpl $0x0, -0x54(%rbp)
jne 0x113f9
decl %eax
movb 0x1(%rcx), %r13b
incq %rcx
movl $0x0, -0x54(%rbp)
movq %rcx, %r15
movl %eax, %r12d
pushq $0x1
popq %rax
movl %eax, -0x50(%rbp)
jmp 0x10e10
cmpl $0x0, -0x50(%rbp)
jne 0x113f9
movl $0x0, -0x50(%rbp)
pushq $0x1
popq %rax
movl %eax, -0x54(%rbp)
movl -0x60(%rbp), %r12d
testl %r12d, %r12d
js 0x113e6
cmpl -0xd0(%rbp), %r12d
jge 0x113e6
movzbl %r13b, %r13d
movb $0x25, -0x120(%rbp)
xorl %esi, %esi
movb $0x20, %al
pushq $0x1
popq %rcx
cmpb $0x20, %r13b
je 0x10e5d
movzbl %r13b, %edx
cmpl $0x23, %edx
je 0x10e5d
cmpl $0x2b, %edx
je 0x10e5d
cmpl $0x30, %edx
je 0x10e5b
cmpl $0x2d, %edx
jne 0x10e76
pushq $0x1
popq %rsi
jmp 0x10e5d
movb $0x30, %al
movb %r13b, -0x120(%rbp,%rcx)
incq %rcx
movzbl 0x1(%r15), %r13d
incq %r15
cmpq $0x6, %rcx
jne 0x10e38
addq %rbp, %rcx
addq $-0x120, %rcx           # imm = 0xFEE0
movq %rcx, -0x38(%rbp)
movb %al, -0x29(%rbp)
andq $0x0, -0x70(%rbp)
movq (%rdi), %rax
movl %r13d, %ecx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x10ee8
cmpl $0x2a, %r13d
jne 0x10f49
cmpl -0x94(%rbp), %r12d
jge 0x113e6
movq %rdi, -0x60(%rbp)
movl %esi, %r13d
movl %r12d, %eax
movq -0x78(%rbp), %rcx
movq (%rcx,%rax,8), %rsi
movq %r14, %rdi
leaq -0x70(%rbp), %rdx
callq 0xc8cb
testl %eax, %eax
jne 0x1144a
movq -0x70(%rbp), %rax
testq %rax, %rax
js 0x10f19
movl %r13d, %esi
movq -0x60(%rbp), %rdi
jmp 0x10f3f
movl %r12d, %r13d
movq %rdi, %r12
movq %r15, %rdi
movl %esi, %r15d
leaq -0x90(%rbp), %rsi
pushq $0xa
popq %rdx
callq 0x6460
movq %r12, %rdi
movl %r13d, %r12d
movl %r15d, %esi
movq %rax, -0x70(%rbp)
movq -0x90(%rbp), %r15
jmp 0x10f45
negq %rax
movq %rax, -0x70(%rbp)
testl %r13d, %r13d
movq -0x60(%rbp), %rdi
je 0x10f2e
movl %r13d, %esi
jmp 0x10f3f
movq -0x38(%rbp), %rax
movb $0x2d, (%rax)
incq %rax
movq %rax, -0x38(%rbp)
pushq $0x1
popq %rsi
incl %r12d
incq %r15
movzbl (%r15), %r13d
andq $0x0, -0x80(%rbp)
cmpl $0x2e, %r13d
jne 0x10f5e
movzbl 0x1(%r15), %edx
incq %r15
jmp 0x10f61
movl %r13d, %edx
movq (%rdi), %rax
movl %edx, %ecx
testb $0x8, 0x1(%rax,%rcx,2)
movl %esi, -0x40(%rbp)
jne 0x10fbd
cmpl $0x2a, %edx
jne 0x10fe7
cmpl -0x94(%rbp), %r12d
jge 0x113e6
movl %r12d, %eax
movq -0x78(%rbp), %rcx
movq (%rcx,%rax,8), %rsi
movq %r14, %rdi
leaq -0x80(%rbp), %rdx
callq 0xc8cb
testl %eax, %eax
jne 0x1144a
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
movl $0x0, %eax
cmovleq %rax, %rdi
movq %rdi, -0x80(%rbp)
incl %r12d
incq %r15
jmp 0x10fdd
movq %r15, %rdi
leaq -0x90(%rbp), %rsi
pushq $0xa
popq %rdx
callq 0x6460
movq %rax, %rdi
movq %rax, -0x80(%rbp)
movq -0x90(%rbp), %r15
movl %r12d, -0x60(%rbp)
movzbl (%r15), %edx
jmp 0x10fed
movl %r12d, -0x60(%rbp)
xorl %edi, %edi
pushq $0x1
popq %rax
cmpl $0x68, %edx
jne 0x10fff
movzbl (%r15,%rax), %esi
addq %rax, %r15
jmp 0x11018
cmpl $0x6c, %edx
jne 0x11016
movzbl 0x1(%r15), %esi
pushq $0x2
popq %rax
cmpl $0x6c, %esi
je 0x10ff5
incq %r15
jmp 0x11018
movl %edx, %esi
cmpl $0x69, %esi
pushq $0x64
popq %rax
cmovel %eax, %esi
movb $0x1, %al
movl %eax, -0x88(%rbp)
leal -0x62(%rsi), %eax
movl -0x60(%rbp), %r12d
cmpl $0x16, %eax
ja 0x11074
leaq 0x12160(%rip), %rcx     # 0x2319c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x78(%rbp), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdi
leaq -0x68(%rbp), %rdx
callq 0xc979
testl %eax, %eax
jne 0x1144a
cmpl $0x40, -0x4c(%rbp)
jle 0x11360
movq -0x48(%rbp), %rax
jmp 0x11373
cmpl $0x45, %esi
je 0x11088
cmpl $0x47, %esi
je 0x11088
cmpl $0x58, %esi
je 0x11092
jmp 0x1147b
movl $0x0, -0x88(%rbp)
movq %r12, -0xb0(%rbp)
movq %rsi, -0xb8(%rbp)
movl %edx, -0xa4(%rbp)
movq -0x70(%rbp), %rdx
testq %rdx, %rdx
je 0x110cd
movq -0x38(%rbp), %r12
movq %r12, %rdi
leaq 0x160ac(%rip), %rsi     # 0x27169
xorl %eax, %eax
callq 0x6480
cltq
addq %rax, %r12
movq %r12, -0x38(%rbp)
cmpl $0x2e, %r13d
jne 0x110f5
movq -0x80(%rbp), %rdx
movq -0x38(%rbp), %r12
movq %r12, %rdi
leaq 0x16083(%rip), %rsi     # 0x27168
xorl %eax, %eax
callq 0x6480
cltq
addq %rax, %r12
movq %r12, -0x38(%rbp)
movq -0xb0(%rbp), %rcx
movq -0x78(%rbp), %rax
movq (%rax,%rcx,8), %rsi
cmpb $0x0, -0x88(%rbp)
je 0x11155
movq %r14, %rdi
leaq -0x68(%rbp), %rdx
callq 0xc979
testl %eax, %eax
movq -0xb8(%rbp), %rdx
jne 0x1144a
cmpl $0x68, -0xa4(%rbp)
jne 0x11142
movzwl -0x68(%rbp), %eax
cmpl $0x64, %edx
jne 0x1113e
movswq %ax, %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rax
movb $0x6c, (%rax)
incq %rax
movq %rax, -0x38(%rbp)
pushq $0x18
popq %rcx
jmp 0x11178
movq %r14, %rdi
leaq -0xe0(%rbp), %rdx
callq 0xd267
movl $0x140, %ecx            # imm = 0x140
testl %eax, %eax
movq -0xb8(%rbp), %rdx
jne 0x1144a
movq -0x38(%rbp), %rax
movb %dl, (%rax)
movb $0x0, 0x1(%rax)
movq -0x70(%rbp), %rax
cmpq $0x2710, %rax           # imm = 0x2710
jg 0x11416
movq -0x80(%rbp), %rdx
cmpq $0x2711, %rdx           # imm = 0x2711
jge 0x11416
movl %ecx, %esi
cmpq %rsi, %rax
cmovlel %ecx, %eax
cmpl $0x2e, %r13d
movl $0x0, %ecx
cmovnel %ecx, %edx
movl %edx, %ecx
addl %eax, %ecx
leal (%rdx,%rax), %ebx
incl %ebx
movslq %ebx, %r12
cmpl %ecx, -0x4c(%rbp)
jle 0x111ce
movq -0x48(%rbp), %r13
jmp 0x111e1
movq -0x48(%rbp), %rdi
movq %r12, %rsi
callq *0x220ad(%rip)          # 0x33288
movq %rax, %r13
movl %ebx, -0x4c(%rbp)
cmpb $0x0, -0x88(%rbp)
je 0x11207
movq -0x68(%rbp), %rcx
movq %r13, %rdi
movq %r12, %rsi
leaq -0x120(%rbp), %rdx
xorl %eax, %eax
callq 0x61e0
movl %eax, -0x3c(%rbp)
jmp 0x11223
movsd -0xe0(%rbp), %xmm0
movq %r13, %rdi
movq %r12, %rsi
leaq -0x120(%rbp), %rdx
movb $0x1, %al
callq 0x61e0
movq %r13, %rdi
callq 0x6180
movq %rax, %rbx
movl %ebx, -0x3c(%rbp)
movq %r13, -0x48(%rbp)
movq %r13, %rdx
movl -0x40(%rbp), %eax
movq -0x70(%rbp), %r13
testl %eax, %eax
jne 0x11278
movq %rdx, -0x38(%rbp)
movslq %ebx, %rbx
movq %rbx, %r12
cmpq %r12, %r13
jle 0x1126d
movq %r14, %rdi
movq -0xc0(%rbp), %rsi
leaq -0x29(%rbp), %rdx
pushq $0x1
popq %rcx
callq 0x823a
incq %r12
jmp 0x1124d
cmpq %rbx, %r13
cmovgq %r13, %rbx
movq -0x38(%rbp), %rdx
incq %r15
movl -0x3c(%rbp), %ecx
movq %r14, %rdi
movq -0xc0(%rbp), %r14
movq %r14, %rsi
callq 0x823a
movslq %ebx, %r12
movq %r14, %rbx
movq -0xc8(%rbp), %r14
cmpq %r12, %r13
jle 0x112b9
movq %r14, %rdi
movq %rbx, %rsi
leaq -0x29(%rbp), %rdx
pushq $0x1
popq %rcx
callq 0x823a
incq %r12
jmp 0x1129d
movl -0x54(%rbp), %eax
addl %eax, -0x60(%rbp)
xorl %ecx, %ecx
movq %r15, %r12
movq %r15, %rdx
movq -0x48(%rbp), %r13
jmp 0x10d49
movq %rdi, -0x88(%rbp)
movq -0x78(%rbp), %rbx
movq (%rbx,%r12,8), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x7fc7
movq %rax, -0x38(%rbp)
movq (%rbx,%r12,8), %rdi
callq 0xa61a
movl %eax, %ebx
cmpl $0x2e, %r13d
jne 0x113c5
movslq %ebx, %rax
movq -0x88(%rbp), %r12
cmpq %rax, %r12
movl -0x40(%rbp), %eax
jge 0x113c8
movl %r12d, -0x3c(%rbp)
movl %r12d, %ebx
jmp 0x113c8
movq -0x78(%rbp), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdi
leaq -0x68(%rbp), %rdx
callq 0xc979
testl %eax, %eax
jne 0x1144a
movb -0x68(%rbp), %al
movb %al, -0x120(%rbp)
movl $0x1, -0x3c(%rbp)
pushq $0x1
popq %rax
movl %eax, %ebx
leaq -0x120(%rbp), %rdx
jmp 0x11238
movq -0x48(%rbp), %rdi
pushq $0x41
popq %rsi
callq *0x21f1b(%rip)          # 0x33288
pushq $0x41
popq %rcx
movl %ecx, -0x4c(%rbp)
xorl %ebx, %ebx
pushq $0x3f
popq %r9
movslq %ebx, %rcx
cmpq $-0x1, %r9
je 0x113b2
movq -0x68(%rbp), %rsi
movb $0x31, %dl
btq %r9, %rsi
jb 0x113a4
testl %ebx, %ebx
sete %dil
testq %r9, %r9
setne %r8b
xorl %esi, %esi
movb $0x30, %dl
testb %r8b, %dil
jne 0x113ab
incl %ebx
movb %dl, (%rax,%rcx)
movl %ebx, %esi
decq %r9
movl %esi, %ebx
jmp 0x11379
movb $0x0, (%rax,%rcx)
movl %ebx, -0x3c(%rbp)
movq %rax, -0x48(%rbp)
movq %rax, %rdx
jmp 0x11238
movl -0x40(%rbp), %eax
movq -0x38(%rbp), %rdx
jmp 0x1123b
testl %ecx, %ecx
je 0x1145b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x823a
jmp 0x1145b
movl -0x50(%rbp), %eax
leaq 0x122d8(%rip), %rcx     # 0x236c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmp 0x11400
leaq 0x15cb7(%rip), %rax     # 0x270b7
movq %rax, -0xa0(%rbp)
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq -0xa0(%rbp), %rsi
jmp 0x11423
leaq 0x15d50(%rip), %rsi     # 0x2716d
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x7363
movq %rax, %r15
incl 0x10(%rax)
movq (%r14), %rsi
movl 0x10(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x1, %eax
jg 0x11447
movq %r14, %rdi
callq 0x73bf
movq %r15, (%r14)
movq -0x48(%rbp), %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x73bf
xorl %ebx, %ebx
movq %r13, %rdi
xorl %esi, %esi
callq *0x21e22(%rip)          # 0x33288
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %esi, %esi
je 0x11407
leaq -0x120(%rbp), %rdx
movb %sil, (%rdx)
movb $0x0, 0x1(%rdx)
leaq 0x15ce9(%rip), %rsi     # 0x2717d
movq %r14, %rdi
xorl %eax, %eax
callq 0x68a7
jmp 0x1144a