// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__run_charstring(stbtt_fontinfo const*, int, stbtt__csctx*)
static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, stbtt__csctx *c)
{
   int in_header = 1, maskbits = 0, subr_stack_height = 0, sp = 0, v, i, b0;
   int has_subrs = 0, clear_stack;
   float s[48];
   stbtt__buf subr_stack[10], subrs = info->subrs, b;
   float f;

#define STBTT__CSERR(s) (0)

   // this currently ignores the initial width value, which isn't needed if we have hmtx
   b = stbtt__cff_index_get(info->charstrings, glyph_index);
   while (b.cursor < b.size) {
      i = 0;
      clear_stack = 1;
      b0 = stbtt__buf_get8(&b);
      switch (b0) {
      // @TODO implement hinting
      case 0x13: // hintmask
      case 0x14: // cntrmask
         if (in_header)
            maskbits += (sp / 2); // implicit "vstem"
         in_header = 0;
         stbtt__buf_skip(&b, (maskbits + 7) / 8);
         break;

      case 0x01: // hstem
      case 0x03: // vstem
      case 0x12: // hstemhm
      case 0x17: // vstemhm
         maskbits += (sp / 2);
         break;

      case 0x15: // rmoveto
         in_header = 0;
         if (sp < 2) return STBTT__CSERR("rmoveto stack");
         stbtt__csctx_rmove_to(c, s[sp-2], s[sp-1]);
         break;
      case 0x04: // vmoveto
         in_header = 0;
         if (sp < 1) return STBTT__CSERR("vmoveto stack");
         stbtt__csctx_rmove_to(c, 0, s[sp-1]);
         break;
      case 0x16: // hmoveto
         in_header = 0;
         if (sp < 1) return STBTT__CSERR("hmoveto stack");
         stbtt__csctx_rmove_to(c, s[sp-1], 0);
         break;

      case 0x05: // rlineto
         if (sp < 2) return STBTT__CSERR("rlineto stack");
         for (; i + 1 < sp; i += 2)
            stbtt__csctx_rline_to(c, s[i], s[i+1]);
         break;

      // hlineto/vlineto and vhcurveto/hvcurveto alternate horizontal and vertical
      // starting from a different place.

      case 0x07: // vlineto
         if (sp < 1) return STBTT__CSERR("vlineto stack");
         goto vlineto;
      case 0x06: // hlineto
         if (sp < 1) return STBTT__CSERR("hlineto stack");
         for (;;) {
            if (i >= sp) break;
            stbtt__csctx_rline_to(c, s[i], 0);
            i++;
      vlineto:
            if (i >= sp) break;
            stbtt__csctx_rline_to(c, 0, s[i]);
            i++;
         }
         break;

      case 0x1F: // hvcurveto
         if (sp < 4) return STBTT__CSERR("hvcurveto stack");
         goto hvcurveto;
      case 0x1E: // vhcurveto
         if (sp < 4) return STBTT__CSERR("vhcurveto stack");
         for (;;) {
            if (i + 3 >= sp) break;
            stbtt__csctx_rccurve_to(c, 0, s[i], s[i+1], s[i+2], s[i+3], (sp - i == 5) ? s[i + 4] : 0.0f);
            i += 4;
      hvcurveto:
            if (i + 3 >= sp) break;
            stbtt__csctx_rccurve_to(c, s[i], 0, s[i+1], s[i+2], (sp - i == 5) ? s[i+4] : 0.0f, s[i+3]);
            i += 4;
         }
         break;

      case 0x08: // rrcurveto
         if (sp < 6) return STBTT__CSERR("rcurveline stack");
         for (; i + 5 < sp; i += 6)
            stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]);
         break;

      case 0x18: // rcurveline
         if (sp < 8) return STBTT__CSERR("rcurveline stack");
         for (; i + 5 < sp - 2; i += 6)
            stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]);
         if (i + 1 >= sp) return STBTT__CSERR("rcurveline stack");
         stbtt__csctx_rline_to(c, s[i], s[i+1]);
         break;

      case 0x19: // rlinecurve
         if (sp < 8) return STBTT__CSERR("rlinecurve stack");
         for (; i + 1 < sp - 6; i += 2)
            stbtt__csctx_rline_to(c, s[i], s[i+1]);
         if (i + 5 >= sp) return STBTT__CSERR("rlinecurve stack");
         stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]);
         break;

      case 0x1A: // vvcurveto
      case 0x1B: // hhcurveto
         if (sp < 4) return STBTT__CSERR("(vv|hh)curveto stack");
         f = 0.0;
         if (sp & 1) { f = s[i]; i++; }
         for (; i + 3 < sp; i += 4) {
            if (b0 == 0x1B)
               stbtt__csctx_rccurve_to(c, s[i], f, s[i+1], s[i+2], s[i+3], 0.0);
            else
               stbtt__csctx_rccurve_to(c, f, s[i], s[i+1], s[i+2], 0.0, s[i+3]);
            f = 0.0;
         }
         break;

      case 0x0A: // callsubr
         if (!has_subrs) {
            if (info->fdselect.size)
               subrs = stbtt__cid_get_glyph_subrs(info, glyph_index);
            has_subrs = 1;
         }
         // fallthrough
      case 0x1D: // callgsubr
         if (sp < 1) return STBTT__CSERR("call(g|)subr stack");
         v = (int) s[--sp];
         if (subr_stack_height >= 10) return STBTT__CSERR("recursion limit");
         subr_stack[subr_stack_height++] = b;
         b = stbtt__get_subr(b0 == 0x0A ? subrs : info->gsubrs, v);
         if (b.size == 0) return STBTT__CSERR("subr not found");
         b.cursor = 0;
         clear_stack = 0;
         break;

      case 0x0B: // return
         if (subr_stack_height <= 0) return STBTT__CSERR("return outside subr");
         b = subr_stack[--subr_stack_height];
         clear_stack = 0;
         break;

      case 0x0E: // endchar
         stbtt__csctx_close_shape(c);
         return 1;

      case 0x0C: { // two-byte escape
         float dx1, dx2, dx3, dx4, dx5, dx6, dy1, dy2, dy3, dy4, dy5, dy6;
         float dx, dy;
         int b1 = stbtt__buf_get8(&b);
         switch (b1) {
         // @TODO These "flex" implementations ignore the flex-depth and resolution,
         // and always draw beziers.
         case 0x22: // hflex
            if (sp < 7) return STBTT__CSERR("hflex stack");
            dx1 = s[0];
            dx2 = s[1];
            dy2 = s[2];
            dx3 = s[3];
            dx4 = s[4];
            dx5 = s[5];
            dx6 = s[6];
            stbtt__csctx_rccurve_to(c, dx1, 0, dx2, dy2, dx3, 0);
            stbtt__csctx_rccurve_to(c, dx4, 0, dx5, -dy2, dx6, 0);
            break;

         case 0x23: // flex
            if (sp < 13) return STBTT__CSERR("flex stack");
            dx1 = s[0];
            dy1 = s[1];
            dx2 = s[2];
            dy2 = s[3];
            dx3 = s[4];
            dy3 = s[5];
            dx4 = s[6];
            dy4 = s[7];
            dx5 = s[8];
            dy5 = s[9];
            dx6 = s[10];
            dy6 = s[11];
            //fd is s[12]
            stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3);
            stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6);
            break;

         case 0x24: // hflex1
            if (sp < 9) return STBTT__CSERR("hflex1 stack");
            dx1 = s[0];
            dy1 = s[1];
            dx2 = s[2];
            dy2 = s[3];
            dx3 = s[4];
            dx4 = s[5];
            dx5 = s[6];
            dy5 = s[7];
            dx6 = s[8];
            stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, 0);
            stbtt__csctx_rccurve_to(c, dx4, 0, dx5, dy5, dx6, -(dy1+dy2+dy5));
            break;

         case 0x25: // flex1
            if (sp < 11) return STBTT__CSERR("flex1 stack");
            dx1 = s[0];
            dy1 = s[1];
            dx2 = s[2];
            dy2 = s[3];
            dx3 = s[4];
            dy3 = s[5];
            dx4 = s[6];
            dy4 = s[7];
            dx5 = s[8];
            dy5 = s[9];
            dx6 = dy6 = s[10];
            dx = dx1+dx2+dx3+dx4+dx5;
            dy = dy1+dy2+dy3+dy4+dy5;
            if (STBTT_fabs(dx) > STBTT_fabs(dy))
               dy6 = -dy;
            else
               dx6 = -dx;
            stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3);
            stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6);
            break;

         default:
            return STBTT__CSERR("unimplemented");
         }
      } break;

      default:
         if (b0 != 255 && b0 != 28 && (b0 < 32 || b0 > 254)) //-V560
            return STBTT__CSERR("reserved operator");

         // push immediate
         if (b0 == 255) {
            f = (float)(stbtt_int32)stbtt__buf_get32(&b) / 0x10000;
         } else {
            stbtt__buf_skip(&b, -1);
            f = (float)(stbtt_int16)stbtt__cff_int(&b);
         }
         if (sp >= 48) return STBTT__CSERR("push stack overflow");
         s[sp++] = f;
         clear_stack = 0;
         break;
      }
      if (clear_stack) sp = 0;
   }
   return STBTT__CSERR("no endchar");

#undef STBTT__CSERR
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movq 0x70(%rdi), %r12
movq 0x78(%rdi), %rax
movq %rax, -0x190(%rbp)
movq 0x50(%rdi), %rdi
movq 0x58(%r15), %rsi
movl %r14d, %edx
callq 0x8514b
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movl -0x44(%rbp), %eax
cmpl %eax, %edx
jge 0x864ef
movq %r12, -0x188(%rbp)
movl %r14d, -0x94(%rbp)
movslq %r14d, %r14
incq %r14
movq %r15, -0x78(%rbp)
leaq 0x68(%r15), %rcx
movq %rcx, -0x198(%rbp)
movl $0x1, -0x54(%rbp)
leaq 0x4324d(%rip), %r12     # 0xc8a34
movq $0x0, -0x70(%rbp)
movq $0x0, -0x68(%rbp)
xorl %r15d, %r15d
movl $0x0, -0x60(%rbp)
movq %r14, -0x80(%rbp)
movq -0x50(%rbp), %rcx
leal 0x1(%rdx), %esi
movl %esi, -0x48(%rbp)
movslq %edx, %rdx
movb (%rcx,%rdx), %r13b
movzbl %r13b, %ecx
leal -0x1(%rcx), %edx
cmpl $0x1e, %edx
ja 0x85901
movslq (%r12,%rdx,4), %rcx
addq %r12, %rcx
jmpq *%rcx
movl %r15d, %eax
shrl $0x1f, %eax
addl %r15d, %eax
sarl %eax
movq -0x70(%rbp), %rcx
addl %eax, %ecx
movq %rcx, -0x70(%rbp)
jmp 0x864de
cmpl $0x0, -0x54(%rbp)
je 0x85ed3
movl %r15d, %ecx
shrl $0x1f, %ecx
addl %r15d, %ecx
sarl %ecx
movq -0x70(%rbp), %rsi
addl %ecx, %esi
jmp 0x85ed7
cmpl $0x4, %r15d
jl 0x864ef
movl %r15d, %r12d
andl $0x1, %r12d
leal 0x3(%r12), %eax
cmpl %r15d, %eax
jge 0x858f9
xorps %xmm1, %xmm1
testl %r12d, %r12d
je 0x85894
movss -0x160(%rbp), %xmm1
leal 0x3(%r12), %eax
movss -0x160(%rbp,%r12,4), %xmm7
movss -0x15c(%rbp,%r12,4), %xmm2
movss -0x158(%rbp,%r12,4), %xmm3
movss -0x160(%rbp,%rax,4), %xmm6
cmpb $0x1b, %r13b
jne 0x858d4
xorps %xmm5, %xmm5
movq %rbx, %rdi
movaps %xmm7, %xmm0
movaps %xmm6, %xmm4
jmp 0x858e3
xorps %xmm4, %xmm4
movq %rbx, %rdi
movaps %xmm1, %xmm0
movaps %xmm7, %xmm1
movaps %xmm6, %xmm5
callq 0x8659c
addq $0x4, %r12
leal 0x3(%r12), %eax
xorps %xmm1, %xmm1
cmpl %eax, %r15d
jg 0x85894
xorl %r15d, %r15d
jmp 0x85cdb
cmpl $0xff, %ecx
je 0x85944
cmpb $0x20, %r13b
jb 0x864ef
cmpb $-0x1, %r13b
je 0x85944
movl -0x48(%rbp), %ecx
testl %ecx, %ecx
jle 0x86514
decl %ecx
cmpl %ecx, %eax
jl 0x86514
movl %ecx, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x855c4
cwtl
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
jmp 0x85981
movl -0x48(%rbp), %ecx
xorl %edx, %edx
movl $0x4, %esi
movq -0x50(%rbp), %rdi
cmpl %eax, %ecx
jge 0x85962
movslq %ecx, %r8
incl %ecx
movzbl (%rdi,%r8), %r8d
jmp 0x85965
xorl %r8d, %r8d
shll $0x8, %edx
orl %r8d, %edx
decl %esi
jne 0x85952
movl %ecx, -0x48(%rbp)
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
mulss 0x4302b(%rip), %xmm0    # 0xc89ac
cmpl $0x2f, %r15d
jg 0x864ef
movslq %r15d, %rax
incl %r15d
movss %xmm0, -0x160(%rbp,%rax,4)
jmp 0x864e1
movl -0x60(%rbp), %r11d
jmp 0x86246
movl $0x1, %r11d
cmpl $0x0, -0x60(%rbp)
jne 0x86246
movq -0x78(%rbp), %rax
movl 0x9c(%rax), %eax
testl %eax, %eax
je 0x86246
js 0x86514
movq -0x78(%rbp), %rcx
movq 0x90(%rcx), %rcx
movzbl (%rcx), %edx
testl %edx, %edx
je 0x861e1
cmpl $0x3, %edx
jne 0x85aab
xorl %esi, %esi
movl $0x1, %edi
movl $0x2, %edx
cmpl %eax, %edi
jge 0x85a0b
movslq %edi, %r8
incl %edi
movzbl (%rcx,%r8), %r8d
jmp 0x85a0e
xorl %r8d, %r8d
shll $0x8, %esi
orl %r8d, %esi
decl %edx
jne 0x859fb
xorl %r8d, %r8d
movl $0x2, %edx
cmpl %eax, %edi
jge 0x85a30
movslq %edi, %r9
incl %edi
movzbl (%rcx,%r9), %r9d
jmp 0x85a33
xorl %r9d, %r9d
shll $0x8, %r8d
orl %r9d, %r8d
decl %edx
jne 0x85a20
testl %esi, %esi
jle 0x85aab
xorl %r9d, %r9d
cmpl %eax, %edi
jge 0x85a54
movslq %edi, %rdx
incl %edi
movzbl (%rcx,%rdx), %edx
jmp 0x85a56
xorl %edx, %edx
xorl %r10d, %r10d
movl $0x2, %r11d
cmpl %eax, %edi
jge 0x85a6f
movslq %edi, %r14
incl %edi
movzbl (%rcx,%r14), %r14d
jmp 0x85a72
xorl %r14d, %r14d
shll $0x8, %r10d
orl %r14d, %r10d
decl %r11d
jne 0x85a5f
movl -0x94(%rbp), %r11d
cmpl %r11d, %r8d
setg %r8b
cmpl %r11d, %r10d
setle %r11b
orb %r8b, %r11b
movq -0x80(%rbp), %r14
je 0x861f6
incl %r9d
movl %r10d, %r8d
cmpl %esi, %r9d
jne 0x85a45
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
jmp 0x861f6
xorl %esi, %esi
cmpl $0x8, %r15d
jl 0x864f1
leal -0x6(%r15), %eax
movslq %eax, %r13
movl $0x5, %eax
xorl %r12d, %r12d
movq %rax, %r14
movss -0x174(%rbp,%rax,4), %xmm0
movss -0x170(%rbp,%rax,4), %xmm1
addss 0x10(%rbx), %xmm0
movss %xmm0, 0x10(%rbx)
addss 0x14(%rbx), %xmm1
movss %xmm1, 0x14(%rbx)
cvttss2si %xmm0, %edx
cvttss2si %xmm1, %ecx
movq %rbx, %rdi
movl $0x2, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r12
pushq %r12
callq 0x86633
addq $0x10, %rsp
leaq 0x2(%r14), %rax
addq $-0x2, %r14
cmpq %r13, %r14
jl 0x85ad0
cmpl %r15d, %eax
movq -0x80(%rbp), %r14
leaq 0x42efd(%rip), %r12     # 0xc8a34
movl $0x0, %esi
jge 0x864f1
movss -0x174(%rbp,%rax,4), %xmm0
movss -0x170(%rbp,%rax,4), %xmm1
movss -0x16c(%rbp,%rax,4), %xmm2
movss -0x168(%rbp,%rax,4), %xmm3
movss -0x164(%rbp,%rax,4), %xmm4
movss -0x160(%rbp,%rax,4), %xmm5
movq %rbx, %rdi
callq 0x8659c
jmp 0x864de
xorl %esi, %esi
testl %r15d, %r15d
jg 0x86425
jmp 0x864f1
movslq -0x48(%rbp), %rcx
xorl %esi, %esi
movl $0x0, %edx
cmpl %eax, %ecx
jge 0x85bb1
movq -0x50(%rbp), %rax
leal 0x1(%rcx), %edx
movl %edx, -0x48(%rbp)
movb (%rax,%rcx), %dl
movzbl %dl, %eax
addl $-0x22, %eax
cmpl $0x3, %eax
ja 0x864f1
leaq 0x42ee9(%rip), %rcx     # 0xc8ab0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x7, %r15d
jl 0x864f1
movss -0x160(%rbp), %xmm0
movss -0x15c(%rbp), %xmm2
movss -0x158(%rbp), %xmm3
movaps %xmm3, -0x90(%rbp)
movss -0x154(%rbp), %xmm4
movss -0x150(%rbp), %xmm1
movss %xmm1, -0x30(%rbp)
movss -0x14c(%rbp), %xmm1
movss %xmm1, -0x2c(%rbp)
movss -0x148(%rbp), %xmm1
movss %xmm1, -0x34(%rbp)
xorps %xmm1, %xmm1
xorps %xmm5, %xmm5
movq %rbx, %rdi
callq 0x8659c
movaps -0x90(%rbp), %xmm3
xorps 0x3137c(%rip), %xmm3    # 0xb6fc0
xorps %xmm1, %xmm1
xorps %xmm5, %xmm5
movq %rbx, %rdi
movss -0x30(%rbp), %xmm0
movss -0x2c(%rbp), %xmm2
movss -0x34(%rbp), %xmm4
jmp 0x85b7b
xorl %esi, %esi
testl %r15d, %r15d
jg 0x86481
jmp 0x864f1
cmpl $0x2, %r15d
jl 0x864ef
movl %r15d, %r12d
movl $0x1, %r13d
movss -0x164(%rbp,%r13,4), %xmm0
movss -0x160(%rbp,%r13,4), %xmm1
addss 0x10(%rbx), %xmm0
movss %xmm0, 0x10(%rbx)
addss 0x14(%rbx), %xmm1
movss %xmm1, 0x14(%rbx)
cvttss2si %xmm0, %edx
cvttss2si %xmm1, %ecx
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x2, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r15
pushq %r15
callq 0x86633
addq $0x10, %rsp
addq $0x2, %r13
cmpq %r12, %r13
jb 0x85c84
leaq 0x42d52(%rip), %r12     # 0xc8a34
jmp 0x864e1
testl %r15d, %r15d
jle 0x864ef
decl %r15d
movss -0x160(%rbp,%r15,4), %xmm1
xorps %xmm0, %xmm0
jmp 0x85ec9
movq -0x68(%rbp), %rax
testl %eax, %eax
jle 0x864ef
decl %eax
movq %rax, -0x68(%rbp)
shlq $0x4, %rax
movups -0x240(%rbp,%rax), %xmm0
movaps %xmm0, -0x50(%rbp)
jmp 0x864e1
xorl %esi, %esi
cmpl $0x8, %r15d
jl 0x864f1
movslq %r15d, %r14
addq $-0xd, %r14
movq $-0x6, %r13
movss -0x148(%rbp,%r13,4), %xmm0
movss -0x144(%rbp,%r13,4), %xmm1
movss -0x140(%rbp,%r13,4), %xmm2
movss -0x13c(%rbp,%r13,4), %xmm3
movss -0x138(%rbp,%r13,4), %xmm4
movss -0x134(%rbp,%r13,4), %xmm5
movq %rbx, %rdi
callq 0x8659c
addq $0x6, %r13
cmpq %r14, %r13
jl 0x85d46
leal 0x7(%r13), %eax
cmpl %r15d, %eax
movq -0x80(%rbp), %r14
movl $0x0, %esi
jge 0x864f1
movss -0x148(%rbp,%r13,4), %xmm0
movss -0x144(%rbp,%r13,4), %xmm1
addss 0x10(%rbx), %xmm0
movss %xmm0, 0x10(%rbx)
addss 0x14(%rbx), %xmm1
movss %xmm1, 0x14(%rbx)
cvttss2si %xmm0, %edx
cvttss2si %xmm1, %ecx
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x2, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r15
pushq %r15
callq 0x86633
addq $0x10, %rsp
jmp 0x864e1
cmpl $0x6, %r15d
jl 0x864ef
movl %r15d, %r14d
movl $0x5, %r15d
movss -0x174(%rbp,%r15,4), %xmm0
movss -0x170(%rbp,%r15,4), %xmm1
movss -0x16c(%rbp,%r15,4), %xmm2
movss -0x168(%rbp,%r15,4), %xmm3
movss -0x164(%rbp,%r15,4), %xmm4
movss -0x160(%rbp,%r15,4), %xmm5
movq %rbx, %rdi
callq 0x8659c
addq $0x6, %r15
cmpq %r14, %r15
jb 0x85e0f
xorl %r15d, %r15d
movq -0x80(%rbp), %r14
jmp 0x864e1
cmpl $0x2, %r15d
jl 0x864ef
leal -0x2(%r15), %eax
movss -0x160(%rbp,%rax,4), %xmm0
decl %r15d
movss -0x160(%rbp,%r15,4), %xmm1
jmp 0x85ec9
xorl %esi, %esi
cmpl $0x4, %r15d
jge 0x863c1
jmp 0x864f1
xorl %esi, %esi
cmpl $0x4, %r15d
jge 0x86361
jmp 0x864f1
testl %r15d, %r15d
jle 0x864ef
decl %r15d
movss -0x160(%rbp,%r15,4), %xmm0
xorps %xmm1, %xmm1
movq %rbx, %rdi
callq 0x86533
jmp 0x85efd
movq -0x70(%rbp), %rsi
leal 0x7(%rsi), %edx
movq %rsi, -0x70(%rbp)
leal 0xe(%rsi), %ecx
testl %edx, %edx
cmovnsl %edx, %ecx
sarl $0x3, %ecx
addl -0x48(%rbp), %ecx
js 0x86514
cmpl %ecx, %eax
jl 0x86514
movl %ecx, -0x48(%rbp)
xorl %r15d, %r15d
movl $0x0, -0x54(%rbp)
jmp 0x864e1
cmpl $0x9, %r15d
jl 0x864f1
movss -0x160(%rbp), %xmm0
movss -0x15c(%rbp), %xmm6
movaps %xmm6, -0x170(%rbp)
movss -0x158(%rbp), %xmm2
movss -0x154(%rbp), %xmm3
movss %xmm3, -0x180(%rbp)
movss -0x150(%rbp), %xmm4
movss -0x14c(%rbp), %xmm1
movss %xmm1, -0x34(%rbp)
movss -0x148(%rbp), %xmm1
movss %xmm1, -0x30(%rbp)
movss -0x144(%rbp), %xmm1
movss %xmm1, -0x90(%rbp)
movss -0x140(%rbp), %xmm1
movss %xmm1, -0x2c(%rbp)
xorps %xmm5, %xmm5
movq %rbx, %rdi
movaps %xmm6, %xmm1
callq 0x8659c
movaps -0x170(%rbp), %xmm5
addss -0x180(%rbp), %xmm5
movss -0x90(%rbp), %xmm3
addss %xmm3, %xmm5
xorps 0x3100c(%rip), %xmm5    # 0xb6fc0
xorps %xmm1, %xmm1
movq %rbx, %rdi
movss -0x34(%rbp), %xmm0
movss -0x30(%rbp), %xmm2
movss -0x2c(%rbp), %xmm4
jmp 0x85b7b
cmpl $0xb, %r15d
jl 0x864f1
movss -0x160(%rbp), %xmm0
movss -0x15c(%rbp), %xmm1
movss -0x158(%rbp), %xmm2
movss -0x154(%rbp), %xmm3
movss -0x150(%rbp), %xmm4
movss -0x14c(%rbp), %xmm5
movss -0x148(%rbp), %xmm10
movss -0x144(%rbp), %xmm11
movss -0x140(%rbp), %xmm12
movss -0x13c(%rbp), %xmm13
movss -0x138(%rbp), %xmm6
movaps %xmm0, %xmm7
addss %xmm2, %xmm7
addss %xmm4, %xmm7
addss %xmm10, %xmm7
addss %xmm12, %xmm7
movaps %xmm1, %xmm14
addss %xmm3, %xmm14
addss %xmm5, %xmm14
addss %xmm11, %xmm14
addss %xmm13, %xmm14
movaps %xmm7, %xmm8
movaps 0x31763(%rip), %xmm9    # 0xb77d0
andps %xmm9, %xmm8
movaps %xmm14, %xmm15
andps %xmm9, %xmm15
ucomiss %xmm15, %xmm8
movss %xmm10, -0x34(%rbp)
movss %xmm11, -0x30(%rbp)
movss %xmm12, -0x2c(%rbp)
movss %xmm13, -0x90(%rbp)
ja 0x8617a
movaps %xmm6, -0x170(%rbp)
movaps 0x30f13(%rip), %xmm9    # 0xb6fc0
jmp 0x8618e
cmpl $0xd, %r15d
jl 0x864f1
movss -0x160(%rbp), %xmm0
movss -0x15c(%rbp), %xmm1
movss -0x158(%rbp), %xmm2
movss -0x154(%rbp), %xmm3
movss -0x150(%rbp), %xmm4
movss -0x14c(%rbp), %xmm5
movss -0x148(%rbp), %xmm6
movss %xmm6, -0x34(%rbp)
movss -0x144(%rbp), %xmm6
movss %xmm6, -0x30(%rbp)
movss -0x140(%rbp), %xmm6
movss %xmm6, -0x2c(%rbp)
movss -0x13c(%rbp), %xmm6
movss %xmm6, -0x90(%rbp)
movss -0x138(%rbp), %xmm6
movss %xmm6, -0x170(%rbp)
movss -0x134(%rbp), %xmm6
movss %xmm6, -0x180(%rbp)
movq %rbx, %rdi
callq 0x8659c
movq %rbx, %rdi
movss -0x34(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
movss -0x2c(%rbp), %xmm2
movss -0x90(%rbp), %xmm3
movss -0x170(%rbp), %xmm4
movss -0x180(%rbp), %xmm5
jmp 0x85b7b
movaps 0x30e3e(%rip), %xmm9    # 0xb6fc0
xorps %xmm9, %xmm14
movaps %xmm14, -0x170(%rbp)
xorps %xmm9, %xmm7
cmpltss %xmm8, %xmm15
andps %xmm15, %xmm6
andnps %xmm7, %xmm15
orps %xmm6, %xmm15
movaps %xmm15, -0x180(%rbp)
movq %rbx, %rdi
callq 0x8659c
movq %rbx, %rdi
movss -0x34(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
movss -0x2c(%rbp), %xmm2
movss -0x90(%rbp), %xmm3
movaps -0x180(%rbp), %xmm4
movaps -0x170(%rbp), %xmm5
jmp 0x85b7b
cmpl %eax, %r14d
ja 0x86514
xorl %edx, %edx
cmpl %eax, %r14d
jge 0x861f6
movzbl (%rcx,%r14), %edx
movq -0x78(%rbp), %rax
movq 0x40(%rax), %r12
movq 0x48(%rax), %rcx
movq %rcx, -0x60(%rbp)
movq 0x80(%rax), %rdi
movq 0x88(%rax), %rsi
callq 0x8514b
movq %rdx, %rcx
movq %r12, %rdi
leaq 0x4280e(%rip), %r12     # 0xc8a34
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x854ba
movq %rax, -0x188(%rbp)
movq %rdx, -0x190(%rbp)
movl $0x1, %r11d
xorl %esi, %esi
testl %r15d, %r15d
movq -0x68(%rbp), %rax
jle 0x864f1
cmpl $0x9, %eax
jg 0x864f1
decl %r15d
cvttss2si -0x160(%rbp,%r15,4), %eax
movq -0x68(%rbp), %rdx
movslq %edx, %rcx
shlq $0x4, %rcx
movaps -0x50(%rbp), %xmm0
movups %xmm0, -0x240(%rbp,%rcx)
leaq -0x190(%rbp), %rcx
movq -0x188(%rbp), %rdi
cmpb $0xa, %r13b
je 0x862a5
movq -0x78(%rbp), %rcx
movq 0x60(%rcx), %rdi
movq -0x198(%rbp), %rcx
movq (%rcx), %r8
testq %r8, %r8
js 0x86514
incl %edx
movq %rdx, -0x68(%rbp)
movq %r8, %rdx
shrq $0x20, %rdx
xorl %esi, %esi
movl $0x2, %r9d
xorl %ecx, %ecx
cmpl %edx, %esi
jge 0x862d8
movslq %esi, %r10
incl %esi
movzbl (%rdi,%r10), %r10d
jmp 0x862db
xorl %r10d, %r10d
shll $0x8, %ecx
orl %r10d, %ecx
decl %r9d
jne 0x862c8
xorl %edx, %edx
cmpl $0x4d8, %ecx            # imm = 0x4D8
setge %dl
shll $0xa, %edx
orl $0x6b, %edx
cmpl $0x846c, %ecx           # imm = 0x846C
movl $0x8000, %r9d           # imm = 0x8000
cmovgel %r9d, %edx
addl %eax, %edx
sets %al
cmpl %ecx, %edx
setge %cl
orb %al, %cl
movl $0x0, %eax
movl $0x0, %ecx
jne 0x8633f
movabsq $0x7fffffff00000000, %rax # imm = 0x7FFFFFFF00000000
andq %rax, %r8
movl %esi, %esi
orq %r8, %rsi
movl %r11d, %r13d
callq 0x8514b
movl %r13d, %r11d
movq %rdx, %rcx
movq %rax, -0x50(%rbp)
movq %rcx, -0x48(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x864ef
movl $0x0, -0x48(%rbp)
movl %r11d, -0x60(%rbp)
jmp 0x864e1
leal 0x3(%rsi), %ecx
cmpl %r15d, %ecx
jge 0x864de
movslq %esi, %rax
movss -0x160(%rbp,%rax,4), %xmm1
movss -0x15c(%rbp,%rax,4), %xmm2
movss -0x158(%rbp,%rax,4), %xmm3
movslq %ecx, %rcx
movss -0x160(%rbp,%rcx,4), %xmm4
movl %r15d, %ecx
movq %rsi, %r13
subl %esi, %ecx
xorps %xmm5, %xmm5
cmpl $0x5, %ecx
jne 0x863b0
movss -0x150(%rbp,%rax,4), %xmm5
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x8659c
movq %r13, %rsi
addl $0x4, %esi
leal 0x3(%rsi), %eax
cmpl %r15d, %eax
jge 0x864de
movslq %esi, %rcx
movss -0x160(%rbp,%rcx,4), %xmm0
movss -0x15c(%rbp,%rcx,4), %xmm2
movss -0x158(%rbp,%rcx,4), %xmm3
movl %r15d, %edx
movq %rsi, %r13
subl %esi, %edx
xorps %xmm4, %xmm4
cmpl $0x5, %edx
jne 0x86404
movss -0x150(%rbp,%rcx,4), %xmm4
cltq
movss -0x160(%rbp,%rax,4), %xmm5
xorps %xmm1, %xmm1
movq %rbx, %rdi
callq 0x8659c
movq %r13, %rsi
addl $0x4, %esi
jmp 0x86361
cmpl %r15d, %esi
jge 0x864de
movslq %esi, %rax
movss -0x160(%rbp,%rax,4), %xmm0
addss 0x10(%rbx), %xmm0
movss %xmm0, 0x10(%rbx)
movss 0x14(%rbx), %xmm1
addss 0x313f3(%rip), %xmm1    # 0xb7844
movss %xmm1, 0x14(%rbx)
cvttss2si %xmm0, %edx
cvttss2si %xmm1, %ecx
movq %rbx, %rdi
movq %rsi, %r13
movl $0x2, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
pushq %rax
pushq %rax
callq 0x86633
movq %r13, %rsi
addq $0x10, %rsp
incl %esi
cmpl %r15d, %esi
jge 0x864de
movslq %esi, %rax
movss -0x160(%rbp,%rax,4), %xmm0
movss 0x10(%rbx), %xmm1
addss 0x313a5(%rip), %xmm1    # 0xb7844
movss %xmm1, 0x10(%rbx)
addss 0x14(%rbx), %xmm0
movss %xmm0, 0x14(%rbx)
cvttss2si %xmm1, %edx
cvttss2si %xmm0, %ecx
movq %rbx, %rdi
movq %rsi, %r13
movl $0x2, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
pushq %rax
pushq %rax
callq 0x86633
movq %r13, %rsi
addq $0x10, %rsp
incl %esi
jmp 0x86425
xorl %r15d, %r15d
movl -0x48(%rbp), %edx
movl -0x44(%rbp), %eax
cmpl %eax, %edx
jl 0x85805
xorl %esi, %esi
movl %esi, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x865f2
movl $0x1, %esi
jmp 0x864f1
leaq 0x49a26(%rip), %rdi     # 0xcff41
leaq 0x49a00(%rip), %rsi     # 0xcff22
leaq 0x49a30(%rip), %rcx     # 0xcff59
movl $0x46c, %edx            # imm = 0x46C
callq 0xc140