// File: /workspace/github_c_makefile_star2_O3/jrrk[P]cbzone/c_explode.c
// Function: explodeobject
void explodeobject(g, pl)
     Genericp g, pl;
{
  static float vars0[] = { 0.996195,  0.087156,  0.996195,  0.087156};
  static float vars1[] = { 0.996195, -0.087156,  0.996195, -0.087156};
  static float vars2[] = { 0.819152,  0.573576,  0.996195,  0.087156};
  static Coord3d tank0[] = {
     30, -53, -15,    35, -60,  15,    35,  60,  -5,    30,  37, -15,
    -30,  37, -15,   -35,  60,  -5,   -35, -60,  15,   -30, -53, -15,
     30, -53, -15,    30,  37, -15,    35, -60,  15,   -35, -60,  15,
     35,  60,  -5,   -35,  60,  -5,   -30, -53, -15,   -30,  37, -15};
  static int tank0pnum[] = {10, 0};
  static int tank0mnum[] = {6, 0};
  static Method tank0methods[] = {16, calcpointsV, NULL,
                                    0, NULL, NULL};
  static Coord3d tank1[] = {
    -10, -50,  10,   -10, -18,  10,    10, -18,  10,    10, -50,  10,
     25, -55, -11,    25,  55, -20,    10, -18,  10,   -10, -18,  10,
    -25,  55, -20,   -25, -55, -11,   -10, -50,  10,    10, -50,  10};
  static int tank1pnum[] = {12, 0};
  static int tank1mnum[] = {0};
  static Method tank1methods[] = {12, calcpointsV, NULL,
                                    0, NULL, NULL};
  static Coord3d tank2[] = {
     -3,  28,  -3,     3,  28,  -3,     3,  28,   3,    -3,  28,   3,
     -3,  28,  -3,     3, -28,   3,     3,  28,   3,    -3, -28,   3,
     -3,  28,   3,    -3, -13,  -3,    -3,  28,  -3,     3, -13,  -3,
      3,  28,  -3};
  static int tank2pnum[] = {5, 0};
  static int tank2mnum[] = {8, 0};
  static Method tank2methods[] = {13, calcpointsV, NULL,
                                    0, NULL, NULL};
  static StaticDC tankstaticdcs[] = {
    tank0, tank0pnum, tank0mnum, tank0methods, COLOR_TANK,
    tank1, tank1pnum, tank1mnum, tank1methods, COLOR_TANK,
    tank2, tank2pnum, tank2mnum, tank2methods, COLOR_TANK};
  static float* tankvars[] = {vars0, vars0, vars1};
  static float tankyoffsets[] = {0.0, 5.0, 32.0};
  static float tankzoffsets[] = {-25.0, 0.0, 0.0};

  static Coord3d super0[] = {
     15,  60, -15,    30, -60, -15,    30, -60,  19,    15,  60, -15,
    -15,  60, -15,   -30, -60, -15,   -30, -60,  19,   -15,  60, -15,
    -30, -60,  19,    30, -60,  19,   -30, -60, -15,    30, -60, -15};
  static int super0pnum[] = {8, 0};
  static int super0mnum[] = {4, 0};
  static Method super0methods[] = {12, calcpointsV, NULL,
                                   0, NULL, NULL};
  static Coord3d super1[] = {
      0,  47, -18,    13, -48,   9,    11, -48,  19,    11, -13,  19,
      0,  47, -18,   -13, -48,   9,   -11, -48,  19,   -11, -13,  19,
      0,  47, -18,    11, -48,  19,   -11, -48,  19,    11, -13,  19,
    -11, -13,  19};
  static int super1pnum[] = {9, 0};
  static int super1mnum[] = {4, 0};
  static Method super1methods[] = {13, calcpointsV, NULL,
                                   0, NULL, NULL};
  static Coord3d super2[] = {
      3, -36,   0,     3,  36,   0,    -3, -36,   0,    -3,  36,   0,
      3, -27,  -6,     3,  36,  -6,    -3, -27,  -6,    -3,  36,  -6,
      3,  36,  -6,     3,  36,   0,    -3,  36,   0,    -3,  36,  -6,
      3,  36,  -6};
  static int super2pnum[] = {4, 0};
  static int super2mnum[] = {5, 0};
  static Method super2methods[] = {9, calcpointsV, NULL,
                                   0, NULL, NULL};

  static StaticDC superstaticdcs[] = {
    super0, super0pnum, super0mnum, super0methods, COLOR_SUPER,
    super1, super1pnum, super1mnum, super1methods, COLOR_SUPER,
    super2, super2pnum, super2mnum, super2methods, COLOR_SUPER};
  static float superyoffsets[] = {0.0, -12.0, 19.0};
  static float superzoffsets[] = {-25.0, -15.0, 0.0};

  static Coord3d missile0[] = {
     15, -30, -25,    25, -30,   0,     0, -45,   0,    15, -30, -25,
    -15, -30, -25,     0, -45,   0,    15, -30,  25,   -15, -30,  25,
      0, -45,   0,   -25, -30,   0,   -15, -30,  25};
  static int missile0pnum[] = {11, 0};
  static int missile0mnum[] = {0};
  static Method missile0methods[] = {11, calcpointsV, NULL,
                                     0, NULL, NULL};
  static Coord3d missile1[] = {
     15, -30, -25,     0,  50,   0,    25, -30,   0,    15, -30,  25,
      0,  50,   0,   -15, -30, -25,   -25, -30,   0,     0,  50,   0,
    -15, -30,  25};
  static int missile1pnum[] = {9, 0};
  static int missile1mnum[] = {0};
  static Method missile1methods[] = {9, calcpointsV, NULL,
                                     0, NULL, NULL};
  static Coord3d missile2[] = {
     13, -17, 11,    15, -30,   5,    23, -38, -10,    23,   0, -10,
     13, -17, 11};
  static int missile2pnum[] = {5, 0};
  static int missile2mnum[] = {0};
  static Method missile2methods[] = {5, calcpointsV, NULL,
                                     0, NULL, NULL};
  static Coord3d missile3[] = {
    -13, -17, 11,   -15, -30,   5,   -23, -38, -10,   -23,   0, -10,
    -13, -17, 11};
  static int missile3pnum[] = {5, 0};
  static int missile3mnum[] = {0};
  static Method missile3methods[] = {5, calcpointsV, NULL,
                                     0, NULL, NULL};

  static StaticDC missilestaticdcs[] = {
    missile0, missile0pnum, missile0mnum, missile0methods, COLOR_MISSILE,
    missile1, missile1pnum, missile1mnum, missile1methods, COLOR_MISSILE,
    missile2, missile2pnum, missile2mnum, missile2methods, COLOR_MISSILE,
    missile3, missile3pnum, missile3mnum, missile3methods, COLOR_MISSILE};
  static float* missilevars[] = {vars0, vars0, vars1, vars1};
  static float missileyoffsets[] = {0.0, 0.0, 0.0, 0.0};
  static float missilezoffsets[] = {0.0, 0.0, -30.0, -30.0};

  static Coord3d copter0[] = {
      6,  100,   0,     6,  100,   0,    -6, -100,   0,     6, -100,   0,
     -6,  100,   0,     6,  100,   0};
  static int copter0pnum[] = {6, 0};
  static int copter0mnum[] = {0};
  static Method copter0methods[] = {6, calcpointsVI, NULL,
                                    0, NULL, NULL};
  static Coord3d copter1[] = {
      0,  -32, -10,     7,   52, -34,    10,   48, -14,     0,  -34,   0,
      0,  -52,  28,     0,  -62,  28,     0,  -48, -10,     0,  -32, -10,
     -7,   52, -34,   -10,   48, -14,     0,  -34,   0};
  static int copter1pnum[] = {11, 0};
  static int copter1mnum[] = {0};
  static Method copter1methods[] = {11, calcpointsV, NULL,
                                    0, NULL, NULL};
  static Coord3d copter2[] = {
    -14,   34, -34,    14,   34, -34,     0,   60, -14,   -14,   34, -34,
     -7,  -30, -34,     7,  -30, -34,    14,   34, -34,    26,   34, -14,
      0,   60, -14,   -26,   34, -14,   -10,  -34, -14,    10,  -34, -14,
     26,   34, -14,     4,   20,  16,     0,   22,  16,    -4,   20,  16,
     -4,  -22,  16,     4,  -22,  16,     4,   20,  16,   -10,  -34, -14,
     -4,  -22,  16,    10,  -34, -14,     4,  -22,  16,     0,   22,  16,
      0,   60, -14,   -14,   34, -34,   -26,   34, -14,   -26,   34, -14,
     -4,   20,  16};
  static int copter2pnum[] = {19, 0};
  static int copter2mnum[] = {10, 0};
  static Method copter2methods[] = {29, calcpointsV, NULL,
                                    0, NULL, NULL};

  static StaticDC copterstaticdcs[] = {
    copter0, copter0pnum, copter0mnum, copter0methods, COLOR_COPTER,
    copter1, copter1pnum, copter1mnum, copter1methods, COLOR_COPTER,
    copter2, copter2pnum, copter2mnum, copter2methods, COLOR_COPTER};
  static float* coptervars[] = {vars2, vars0, vars1};
  static float copteryoffsets[] = {0.0, -82.0, 0.0};
  static float copterzoffsets[] = {30.0, 0.0, 0.0};

  static StaticDCp staticdcs[] = {
    NULL, NULL, tankstaticdcs, superstaticdcs,
    missilestaticdcs, copterstaticdcs};
  static float* yoffsets[] = {
    NULL, NULL, tankyoffsets, superyoffsets,
    missileyoffsets, copteryoffsets};
  static float* zoffsets[] = {
    NULL, NULL, tankzoffsets, superzoffsets,
    missilezoffsets, copterzoffsets};
  static float* *vars[] = {
    NULL, NULL, tankvars, tankvars,
    missilevars, coptervars};
  static int pieces[] = {0, 0, 3, 3, 4, 3};
  static float gravity = 1.0;

  int color, i, j, p;
  DCp dc;
  Methodp methods;
  float yoffset, dx, dy, temp;
  static int threshold = 0.8;
  Float2d pro;
  float* v;

  if (g->type == IS_LANDER) {
    if (g->attr & EXERASE || g->ecount >= 40) {
      g->dc[0].seen = False;
      drawobject(g, pl);
      g->attr = 0;
      return;
    }                                   /* lander just blinks on every */
    if (g->dc[0].seen && g->ccount%3)   /* 3rd cycle                   */
      g->dc[0].seen = False;
    else
      g->ccount = 0;
    drawobject(g, pl);
    g->ccount++;
    return;
  }

  p = pieces[g->lntype];
  gprsetdrawvalue(opt->cpi[COLOR_BG]);
  for (i=0; i<p; i++) {
    dc = &g->dc[i];
    if (dc->last)
      displayobject(dc);
  }
  if (g->attr & EXERASE || g->ecount >= 40) {
    g->attr = 0;
    return;
  }

  if (!(g->attr & HAS_DC)) {
    g->attr |= HAS_DC;
    for (i=0; i<p; i++) {
      dc = &g->dc[i];
      dc->s = staticdcs[g->lntype]+i;

      switch (g->type) {
      case IS_CUBE:
      case IS_PYRAMID:
      case IS_LANDER:
      case IS_MISSILE:
      case IS_COPTER:
      case IS_SUPER:
      case IS_TANK:
        dc->fades = opt->fading_colors - 1;
        dc->basecolor = dc->s->basecolor;
        break;
      case IS_SALVO:
        dc->fades = False;
        if (g->salvo == pl)
          dc->basecolor = COLOR_PSALVO;
        else
          dc->basecolor = COLOR_ESALVO;
        break;
      }

      dc->cta = g->ca;
      dc->sta = g->sa;
      dc->ctp = 1.0;
      dc->stp = 0.0;
      yoffset = *(yoffsets[g->lntype]+i);
      dc->pos.x = -yoffset * g->sa;
      dc->pos.y = yoffset * g->sa;
      dc->pos.z = g->z + *(zoffsets[g->lntype]+i);
      dc->vel.x = frand() * 20.0 - 10.0;
      dc->vel.y = frand() * 20.0 - 10.0;
      dc->vel.z = 12.5 + frand() * 7.5;
    }
    if (g->type == IS_COPTER)
      g->dc[0].vel.z += 6.0;
  }

  for (i=0; i<p; i++) {
    dc = &g->dc[i];
    dx = g->x + dc->pos.x - pl->x;
    dy = g->y + dc->pos.y - pl->y;
    if (sqrt(dx*dx + dy*dy) < 2000.0) {
      if (dc->fades) {
        color = g->range/OUT_OF_DRAWING_RANGE * opt->fading_colors;
        if (color >= opt->fading_colors)
          color = opt->fading_colors-1;
      }
      else
        color = 0;
      gprsetdrawvalue(color + opt->cpi[dc->basecolor]);

      pro.x = dx * pl->ca + dy * pl->sa;
      pro.y = -dx * pl->sa + dy * pl->ca;

      if (pro.y/fabs(pro.x+1) > threshold) {
        methods = dc->s->methods;
        for (j=0; methods->num; methods++) {
          methods->calc(dc, methods, j, g, pl);
          j += methods->num;
        }

        displayobject(dc);
        dc->last = True;
      }
      else
        dc->last = False;
    }
    else
        dc->last = False;

    dc->pos.x += dc->vel.x;
    dc->pos.y += dc->vel.y;
    dc->vel.z -= gravity;
    dc->pos.z += dc->vel.z;
    if (dc->pos.z < -40.0) {
      dc->pos.z = -40.0;
      dc->vel.z *= -0.2;
    }

    v = vars[g->lntype][i];
    temp = dc->cta;
    dc->cta = dc->cta*v[0] - dc->sta*v[1];
    dc->sta = dc->sta*v[0] + temp*v[1];
    temp = dc->ctp;
    dc->ctp = dc->ctp*v[2] - dc->stp*v[3];
    dc->stp = dc->stp*v[2] + temp*v[3];
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x40, (%rdi)
jne 0x5446
testb $0x10, 0x8(%rbx)
jne 0x5429
cmpl $0x28, 0x44(%rbx)
jl 0x54cd
xorl %ebp, %ebp
movl %ebp, 0x188(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4e1b
movl %ebp, 0x8(%rbx)
jmp 0x5a16
movslq 0x4(%rbx), %rbp
leaq 0xf12f(%rip), %rax      # 0x14580
movq (%rax), %rax
movl 0xf0(%rax), %edi
xorl %eax, %eax
callq 0x7660
leaq 0x8c58(%rip), %rax      # 0xe0c0
movl (%rax,%rbp,4), %eax
movl %eax, 0xc(%rsp)
cmpq $0x2, %rbp
jb 0x54b4
leaq 0x60(%rbx), %r15
movl 0xc(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
imulq $0x130, %rax, %r12      # imm = 0x130
xorl %r13d, %r13d
cmpl $0x0, 0x18c(%rbx,%r13)
je 0x54a8
leaq (%r15,%r13), %rdi
xorl %eax, %eax
callq 0x4da9
addq $0x130, %r13            # imm = 0x130
cmpq %r13, %r12
jne 0x5492
movl 0x8(%rbx), %eax
testb $0x10, %al
jne 0x54c1
cmpl $0x28, 0x44(%rbx)
jl 0x54fd
movl $0x0, 0x8(%rbx)
jmp 0x5a16
cmpl $0x0, 0x188(%rbx)
je 0x5701
imull $0xaaaaaaab, 0x48(%rbx), %eax # imm = 0xAAAAAAAB
addl $0x2aaaaaaa, %eax       # imm = 0x2AAAAAAA
cmpl $0x55555554, %eax       # imm = 0x55555554
jbe 0x5701
leaq 0x188(%rbx), %rax
jmp 0x5705
btl $0xc, %eax
jb 0x5742
orl $0x1000, %eax           # imm = 0x1000
movl %eax, 0x8(%rbx)
movq %rbp, 0x10(%rsp)
cmpl $0x2, %ebp
jb 0x5720
movl 0xc(%rsp), %eax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
movq %rcx, 0x18(%rsp)
leaq 0x180(%rbx), %r13
movl $0x20, %ebp
xorl %r12d, %r12d
movl $0xffff, %r15d          # imm = 0xFFFF
movslq 0x4(%rbx), %rax
leaq 0xc78f(%rip), %rcx      # 0x11ce0
movq (%rcx,%rax,8), %rcx
leaq (%rcx,%rbp), %rdx
addq $-0x20, %rdx
movq %rdx, -0x120(%r13)
movl (%rbx), %edx
leal -0x1(%rdx), %esi
cmpl $0x3f, %esi
ja 0x56c1
movabsq $-0x7fffffff7fff7f75, %rdi # imm = 0x800000008000808B
btq %rsi, %rdi
jae 0x56c1
leaq 0xeff3(%rip), %rdx      # 0x14580
movq (%rdx), %rdx
movl 0x148(%rdx), %edx
decl %edx
movl %edx, -0x114(%r13)
movl (%rcx,%rbp), %ecx
movl %ecx, -0x118(%r13)
movsd 0x24(%rbx), %xmm0
movaps %xmm0, %xmm1
movss 0x8aa7(%rip), %xmm2     # 0xe060
movlhps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0]
movups %xmm1, -0x8(%r13)
leaq 0xc748(%rip), %rcx      # 0x11d10
movq (%rcx,%rax,8), %rcx
movss (%rcx,%r12,4), %xmm1
movaps %xmm1, %xmm2
xorps 0x8a34(%rip), %xmm2     # 0xe010
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
mulps %xmm0, %xmm2
movlps %xmm2, -0x20(%r13)
movss 0x14(%rbx), %xmm0
leaq 0xc749(%rip), %rcx      # 0x11d40
movq (%rcx,%rax,8), %rax
addss (%rax,%r12,4), %xmm0
movss %xmm0, -0x18(%r13)
callq 0x4510
andl %r15d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x8a52(%rip), %xmm1     # 0xe070
divsd %xmm1, %xmm0
movsd 0x8a4e(%rip), %xmm1     # 0xe078
mulsd %xmm1, %xmm0
movsd 0x8a4a(%rip), %xmm1     # 0xe080
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%r13)
callq 0x4510
andl %r15d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x8a15(%rip), %xmm0     # 0xe070
mulsd 0x8a15(%rip), %xmm0     # 0xe078
addsd 0x8a15(%rip), %xmm0     # 0xe080
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x10(%r13)
callq 0x4510
andl %r15d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x89e4(%rip), %xmm0     # 0xe070
mulsd 0x89f4(%rip), %xmm0     # 0xe088
addsd 0x89f4(%rip), %xmm0     # 0xe090
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%r13)
incq %r12
addq $0x28, %rbp
addq $0x130, %r13            # imm = 0x130
cmpq %r12, 0x18(%rsp)
jne 0x5546
jmp 0x5720
cmpl $0x80, %edx
jne 0x55a9
movl $0x0, -0x114(%r13)
cmpq %r14, 0x650(%rbx)
je 0x56f1
movl $0x8, -0x118(%r13)
jmp 0x55a9
movl $0x4, -0x118(%r13)
jmp 0x55a9
leaq 0x48(%rbx), %rax
movl $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4e1b
incl 0x48(%rbx)
jmp 0x5a16
cmpl $0x20, (%rbx)
movq 0x10(%rsp), %rbp
jne 0x5742
movss 0x174(%rbx), %xmm0
addss 0x892a(%rip), %xmm0     # 0xe064
movss %xmm0, 0x174(%rbx)
cmpl $0x2, %ebp
jb 0x5a16
leaq 0x60(%rbx), %r12
movl 0xc(%rsp), %eax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
movq %rcx, 0x18(%rsp)
xorl %r13d, %r13d
movq %r12, 0x20(%rsp)
imulq $0x130, %r13, %rax      # imm = 0x130
leaq (%r12,%rax), %r15
movss 0xc(%rbx), %xmm2
movss 0x10(%rbx), %xmm3
addss 0x100(%r12,%rax), %xmm2
subss 0xc(%r14), %xmm2
addss 0x104(%r12,%rax), %xmm3
subss 0x10(%r14), %xmm3
movaps %xmm3, %xmm0
mulss %xmm3, %xmm0
movaps %xmm2, %xmm1
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd 0x887b(%rip), %xmm1     # 0xe040
ucomisd %xmm0, %xmm1
movl $0x0, %ebp
jbe 0x58e2
movss %xmm3, 0x10(%rsp)
movss %xmm2, 0xc(%rsp)
xorl %ebp, %ebp
cmpl $0x0, 0xc(%r15)
leaq 0xed92(%rip), %rax      # 0x14580
movq (%rax), %rax
movl $0x0, %edi
je 0x5825
xorps %xmm0, %xmm0
cvtss2sd 0x34(%rbx), %xmm0
movl 0x148(%rax), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
divsd 0x882b(%rip), %xmm0     # 0xe040
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
leal -0x1(%rcx), %edi
cmpl %edx, %ecx
cmovgl %edx, %edi
movslq 0x8(%r15), %rcx
addl 0xf0(%rax,%rcx,4), %edi
xorl %eax, %eax
callq 0x7660
movss 0x24(%r14), %xmm0
movss 0x28(%r14), %xmm1
movss 0x10(%rsp), %xmm5
movaps %xmm5, %xmm2
mulss %xmm1, %xmm2
movss 0xc(%rsp), %xmm4
movaps %xmm4, %xmm3
mulss %xmm0, %xmm3
addss %xmm2, %xmm3
mulss %xmm0, %xmm5
mulss %xmm1, %xmm4
subss %xmm4, %xmm5
xorps %xmm0, %xmm0
cvtss2sd %xmm5, %xmm0
addss 0x87e4(%rip), %xmm3     # 0xe060
andps 0x87cd(%rip), %xmm3     # 0xe050
xorps %xmm1, %xmm1
cvtss2sd %xmm3, %xmm1
divsd %xmm1, %xmm0
ucomisd 0x880a(%rip), %xmm0     # 0xe0a0
jbe 0x58e2
movq (%r15), %rax
movq 0x18(%rax), %r12
cmpl $0x0, (%r12)
je 0x58ce
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %rbx, %rcx
movq %r14, %r8
xorl %eax, %eax
callq *0x8(%r12)
addl (%r12), %ebp
cmpl $0x0, 0x18(%r12)
leaq 0x18(%r12), %r12
jne 0x58a8
movq %r15, %rdi
xorl %eax, %eax
callq 0x4da9
movl $0x1, %ebp
movq 0x20(%rsp), %r12
movl %ebp, 0x12c(%r15)
movsd 0x100(%r15), %xmm0
movsd 0x10c(%r15), %xmm1
addps %xmm0, %xmm1
movlps %xmm1, 0x100(%r15)
movss 0x114(%r15), %xmm0
addss 0x8751(%rip), %xmm0     # 0xe068
movss %xmm0, 0x114(%r15)
movss 0x108(%r15), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x108(%r15)
movss 0x872e(%rip), %xmm2     # 0xe06c
ucomiss %xmm1, %xmm2
jbe 0x5967
movl $0xc2200000, 0x108(%r15) # imm = 0xC2200000
cvtss2sd %xmm0, %xmm0
mulsd 0x873e(%rip), %xmm0     # 0xe098
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x114(%r15)
movslq 0x4(%rbx), %rax
leaq 0xc3fe(%rip), %rcx      # 0x11d70
movq (%rcx,%rax,8), %rax
movq (%rax,%r13,8), %rax
movss 0x118(%r15), %xmm0
movss 0x11c(%r15), %xmm1
movss 0x4(%rax), %xmm2
mulss %xmm1, %xmm2
movss (%rax), %xmm3
mulss %xmm0, %xmm3
subss %xmm2, %xmm3
movss %xmm3, 0x118(%r15)
mulss 0x4(%rax), %xmm0
mulss (%rax), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x11c(%r15)
movss 0x120(%r15), %xmm0
movss 0x124(%r15), %xmm1
movss 0xc(%rax), %xmm2
mulss %xmm1, %xmm2
movss 0x8(%rax), %xmm3
mulss %xmm0, %xmm3
subss %xmm2, %xmm3
movss %xmm3, 0x120(%r15)
mulss 0xc(%rax), %xmm0
mulss 0x8(%rax), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x124(%r15)
incq %r13
cmpq 0x18(%rsp), %r13
jne 0x576b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq