void creat_om(int lseg, int n_sphere, double rxyz_sphere[][3],
              double rcov_sphere[], double amp[], double **om) {
  int iat, jat, i, j;
  double xi, yi, zi, xj, yj, zj, xji, yji, zji;
  double d2, r, sji, stv;
  if (lseg == 1) {
    for (iat = 0; iat < n_sphere; iat++) {
      xi = rxyz_sphere[iat][0];
      yi = rxyz_sphere[iat][1];
      zi = rxyz_sphere[iat][2];
      for (jat = 0; jat < n_sphere; jat++) {
        xj = rxyz_sphere[jat][0];
        yj = rxyz_sphere[jat][1];
        zj = rxyz_sphere[jat][2];
        d2 = (xi - xj) * (xi - xj) + (yi - yj) * (yi - yj) +
             (zi - zj) * (zi - zj);
        r = 0.5 / (rcov_sphere[iat] * rcov_sphere[iat] +
                   rcov_sphere[jat] * rcov_sphere[jat]);
        om[iat][jat] =
            pow(sqrt(4.0 * r * (rcov_sphere[iat] * rcov_sphere[jat])), 3) *
            exp(-d2 * r) * amp[iat] * amp[jat];
      }
    }
  } else {
    for (iat = 0; iat < n_sphere; iat++) {
      xi = rxyz_sphere[iat][0];
      yi = rxyz_sphere[iat][1];
      zi = rxyz_sphere[iat][2];
      for (jat = 0; jat < n_sphere; jat++) {
        xj = rxyz_sphere[jat][0];
        yj = rxyz_sphere[jat][1];
        zj = rxyz_sphere[jat][2];
        xji = xj - xi;
        yji = yj - yi;
        zji = zj - zi;
        d2 = xji * xji + yji * yji + zji * zji;
        r = 0.5 / (rcov_sphere[iat] * rcov_sphere[iat] +
                   rcov_sphere[jat] * rcov_sphere[jat]);
        om[4 * iat][4 * jat] =
            pow(sqrt(4.0 * r * (rcov_sphere[iat] * rcov_sphere[jat])), 3) *
            exp(-d2 * r) * amp[iat] * amp[jat];
        sji = pow(sqrt(4.0 * r * rcov_sphere[iat] * rcov_sphere[jat]), 3) *
              exp(-d2 * r);
        stv = sqrt(8.0) * rcov_sphere[jat] * r * sji;
        om[4 * iat][4 * jat + 1] = stv * xji * amp[iat] * amp[jat];
        om[4 * iat][4 * jat + 2] = stv * yji * amp[iat] * amp[jat];
        om[4 * iat][4 * jat + 3] = stv * zji * amp[iat] * amp[jat];
        stv = sqrt(8.0) * rcov_sphere[iat] * r * sji * -1.0;
        om[4 * iat + 1][4 * jat] = stv * xji * amp[iat] * amp[jat];
        om[4 * iat + 2][4 * jat] = stv * yji * amp[iat] * amp[jat];
        om[4 * iat + 3][4 * jat] = stv * zji * amp[iat] * amp[jat];
        stv = -8.0 * rcov_sphere[iat] * rcov_sphere[jat] * r * r * sji;
        om[4 * iat + 1][4 * jat + 1] =
            stv * (xji * xji - 0.5 / r) * amp[iat] * amp[jat];
        om[4 * iat + 1][4 * jat + 2] = stv * (yji * xji) * amp[iat] * amp[jat];
        om[4 * iat + 1][4 * jat + 3] = stv * (zji * xji) * amp[iat] * amp[jat];
        om[4 * iat + 2][4 * jat + 1] = stv * (xji * yji) * amp[iat] * amp[jat];
        om[4 * iat + 2][4 * jat + 2] =
            stv * (yji * yji - 0.5 / r) * amp[iat] * amp[jat];
        om[4 * iat + 2][4 * jat + 3] = stv * (zji * yji) * amp[iat] * amp[jat];
        om[4 * iat + 3][4 * jat + 1] = stv * (xji * zji) * amp[iat] * amp[jat];
        om[4 * iat + 3][4 * jat + 2] = stv * (yji * zji) * amp[iat] * amp[jat];
        om[4 * iat + 3][4 * jat + 3] =
            stv * (zji * zji - 0.5 / r) * amp[iat] * amp[jat];
      }
    }
  }
  for (i = 0; i < lseg * n_sphere; i++) {
    for (j = 0; j < lseg * n_sphere; j++) {
      if (fabs(om[i][j] - om[j][i]) > 1e-6) {
        printf("OM SYMMETRY ERROR\n");
        printf("OM[%d][%d]=%g, OM[%d][%d]=%g\n", i, j, om[i][j], j, i,
               om[j][i]);
      }
    }
  }
}


x86 assembly (clang, -O0):
<creat_om>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
cmpl   $0x1,-0x4(%rbp)
jne    13a5 <creat_om+0x265>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13a0 <creat_om+0x260>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    138d <creat_om+0x24d>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x40(%rbp),%xmm1
subsd  -0x58(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm2
subsd  -0x58(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm3
subsd  -0x60(%rbp),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
subsd  -0x68(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
subsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xd3f(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xd53(%rip),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  0xd18(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
call   1040 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11cf <creat_om+0x8f>
jmp    1392 <creat_om+0x252>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1172 <creat_om+0x32>
jmp    1c6d <creat_om+0xb2d>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1c68 <creat_om+0xb28>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1c55 <creat_om+0xb15>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xafa(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xb0e(%rip),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  0xad3(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
call   1040 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xa52(%rip),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
call   1060 <sqrt@plt>
movsd  0xa1b(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
call   1040 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x9bb(%rip),%xmm0
call   1060 <sqrt@plt>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8ae(%rip),%xmm0
call   1060 <sqrt@plt>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
movsd  0x87c(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  0x77d(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm3
movsd  0x729(%rip),%xmm2
divsd  -0x90(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm3
movsd  0x5a6(%rip),%xmm2
divsd  -0x90(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm3
movsd  0x423(%rip),%xmm2
divsd  -0x90(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1409 <creat_om+0x2c9>
jmp    1c5a <creat_om+0xb1a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13ac <creat_om+0x26c>
jmp    1c6d <creat_om+0xb2d>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    1d5f <creat_om+0xc1f>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    1d4c <creat_om+0xc0c>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x370(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x354(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1d39 <creat_om+0xbf9>
lea    0x363(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%ecx
mov    -0x34(%rbp),%r8d
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rdi
mov    (%rax,%rdi,8),%rax
movslq -0x34(%rbp),%rdi
movsd  (%rax,%rdi,8),%xmm1
lea    0x331(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
jmp    1d3e <creat_om+0xbfe>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c8d <creat_om+0xb4d>
jmp    1d51 <creat_om+0xc11>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c74 <creat_om+0xb34>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<creat_om>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r9,%r12
mov    %r8,%rbp
mov    %rdx,0x28(%rsp)
cmp    $0x1,%edi
mov    %rcx,0x70(%rsp)
mov    %esi,0x14(%rsp)
mov    %edi,0x7c(%rsp)
jne    131c <creat_om+0x1cc>
test   %esi,%esi
jle    17ef <creat_om+0x69f>
mov    0x14(%rsp),%r13d
mov    0x28(%rsp),%rax
add    $0x10,%rax
mov    %rax,0x60(%rsp)
xor    %r15d,%r15d
jmp    11bd <creat_om+0x6d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r15
cmp    %r13,%r15
je     17ef <creat_om+0x69f>
lea    (%r15,%r15,2),%rax
mov    0x28(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x10(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    0x60(%rsp),%rbx
xor    %r14d,%r14d
jmp    12a3 <creat_om+0x153>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm3,0x40(%rsp)
movsd  %xmm4,0x8(%rsp)
movsd  %xmm5,0x68(%rsp)
call   1070 <sqrt@plt>
movsd  0x68(%rsp),%xmm5
movsd  0x8(%rsp),%xmm4
movapd 0x40(%rsp),%xmm3
mulsd  %xmm5,%xmm5
mulsd  %xmm4,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm3,%xmm3
addsd  %xmm4,%xmm3
xorpd  0xe0b(%rip),%xmm3
movapd %xmm3,0x40(%rsp)
movsd  0xdbd(%rip),%xmm1
call   1060 <pow@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x38(%rsp),%xmm0
mulsd  0x40(%rsp),%xmm0
call   1050 <exp@plt>
mulsd  0x8(%rsp),%xmm0
mulsd  0x0(%rbp,%r15,8),%xmm0
mulsd  0x0(%rbp,%r14,8),%xmm0
mov    (%r12,%r15,8),%rax
movsd  %xmm0,(%rax,%r14,8)
add    $0x1,%r14
add    $0x18,%rbx
cmp    %r14,%r13
mov    0x70(%rsp),%rcx
je     11b0 <creat_om+0x60>
movsd  0x20(%rsp),%xmm4
subsd  -0x10(%rbx),%xmm4
movsd  0x18(%rsp),%xmm5
subsd  -0x8(%rbx),%xmm5
movsd  0x30(%rsp),%xmm3
subsd  (%rbx),%xmm3
movsd  (%rcx,%r15,8),%xmm0
movsd  (%rcx,%r14,8),%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm1,%xmm0
mulsd  %xmm1,%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  0xd15(%rip),%xmm6
divsd  %xmm2,%xmm6
movapd %xmm6,%xmm1
mulsd  0xd0d(%rip),%xmm1
mulsd  %xmm1,%xmm0
ucomisd 0xd39(%rip),%xmm0
movsd  %xmm6,0x38(%rsp)
jb     1200 <creat_om+0xb0>
sqrtsd %xmm0,%xmm0
jmp    1229 <creat_om+0xd9>
test   %esi,%esi
jle    17ef <creat_om+0x69f>
mov    0x14(%rsp),%edx
mov    0x28(%rsp),%rax
add    $0x10,%rax
mov    %rax,0x80(%rsp)
mov    %rdx,0x88(%rsp)
lea    0x0(,%rdx,4),%rax
mov    %rax,0x90(%rsp)
xor    %ebx,%ebx
jmp    1372 <creat_om+0x222>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
cmp    0x88(%rsp),%rbx
je     17ef <creat_om+0x69f>
lea    (%rbx,%rbx,2),%rax
mov    0x28(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,0xc0(%rsp)
movsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0xb8(%rsp)
movsd  0x10(%rdx,%rax,8),%xmm0
movsd  %xmm0,0xb0(%rsp)
lea    0x0(,%rbx,4),%eax
mov    %rax,0x30(%rsp)
lea    0x1(,%rbx,4),%eax
mov    %rax,0xa8(%rsp)
lea    0x2(,%rbx,4),%eax
mov    %rax,0xa0(%rsp)
lea    0x3(,%rbx,4),%eax
mov    %rax,0x98(%rsp)
mov    0x80(%rsp),%r14
xor    %r13d,%r13d
jmp    1671 <creat_om+0x521>
call   1070 <sqrt@plt>
movsd  0xc13(%rip),%xmm1
call   1060 <pow@plt>
movsd  %xmm0,0x58(%rsp)
movapd 0x40(%rsp),%xmm0
call   1050 <exp@plt>
mulsd  0x58(%rsp),%xmm0
mov    0x70(%rsp),%rcx
movsd  (%rcx,%r13,2),%xmm1
mulsd  0xbec(%rip),%xmm1
movsd  0x38(%rsp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm1
movsd  0x20(%rsp),%xmm5
movapd %xmm5,%xmm2
mulsd  %xmm1,%xmm2
mulsd  0x0(%rbp,%rbx,8),%xmm2
mulsd  0x0(%rbp,%r13,2),%xmm2
mov    0x30(%rsp),%rax
mov    (%r12,%rax,8),%rax
lea    0x1(%r13),%r8d
movsd  %xmm2,(%rax,%r8,8)
movsd  0x8(%rsp),%xmm4
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
mulsd  0x0(%rbp,%rbx,8),%xmm2
mulsd  0x0(%rbp,%r13,2),%xmm2
lea    0x2(%r13),%r9d
movsd  %xmm2,(%rax,%r9,8)
movsd  0x18(%rsp),%xmm6
mulsd  %xmm6,%xmm1
mulsd  0x0(%rbp,%rbx,8),%xmm1
mulsd  0x0(%rbp,%r13,2),%xmm1
lea    0x3(%r13),%edx
movsd  %xmm1,(%rax,%rdx,8)
movsd  (%rcx,%rbx,8),%xmm1
mulsd  0xb66(%rip),%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm5,%xmm2
mulsd  %xmm1,%xmm2
mulsd  0x0(%rbp,%rbx,8),%xmm2
mulsd  0x0(%rbp,%r13,2),%xmm2
mov    0xa8(%rsp),%rax
mov    (%r12,%rax,8),%rax
movsd  %xmm2,(%rax,%r15,8)
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
mulsd  0x0(%rbp,%rbx,8),%xmm2
mulsd  0x0(%rbp,%r13,2),%xmm2
mov    0xa0(%rsp),%rsi
mov    (%r12,%rsi,8),%rdi
movsd  %xmm2,(%rdi,%r15,8)
mulsd  %xmm6,%xmm1
mulsd  0x0(%rbp,%rbx,8),%xmm1
mulsd  0x0(%rbp,%r13,2),%xmm1
mov    0x98(%rsp),%rsi
mov    (%r12,%rsi,8),%rsi
movsd  %xmm1,(%rsi,%r15,8)
movsd  (%rcx,%rbx,8),%xmm1
mulsd  0xae8(%rip),%xmm1
mulsd  (%rcx,%r13,2),%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm1
movsd  0xad6(%rip),%xmm0
divsd  %xmm3,%xmm0
movsd  0xd0(%rsp),%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
mulsd  0x0(%rbp,%rbx,8),%xmm2
mulsd  0x0(%rbp,%r13,2),%xmm2
movsd  %xmm2,(%rax,%r8,8)
movapd %xmm5,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm1,%xmm2
movsd  0x0(%rbp,%rbx,8),%xmm3
mulsd  %xmm2,%xmm3
mulsd  0x0(%rbp,%r13,2),%xmm3
movsd  %xmm3,(%rax,%r9,8)
mulsd  %xmm6,%xmm5
mulsd  %xmm1,%xmm5
movsd  0x0(%rbp,%rbx,8),%xmm3
mulsd  %xmm5,%xmm3
mulsd  0x0(%rbp,%r13,2),%xmm3
movsd  %xmm3,(%rax,%rdx,8)
mulsd  0x0(%rbp,%rbx,8),%xmm2
mulsd  0x0(%rbp,%r13,2),%xmm2
movsd  %xmm2,(%rdi,%r8,8)
movsd  0x60(%rsp),%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
mulsd  0x0(%rbp,%rbx,8),%xmm2
mulsd  0x0(%rbp,%r13,2),%xmm2
movsd  %xmm2,(%rdi,%r9,8)
mulsd  %xmm6,%xmm4
mulsd  %xmm1,%xmm4
movsd  0x0(%rbp,%rbx,8),%xmm2
mulsd  %xmm4,%xmm2
mulsd  0x0(%rbp,%r13,2),%xmm2
movsd  %xmm2,(%rdi,%rdx,8)
mulsd  0x0(%rbp,%rbx,8),%xmm5
mulsd  0x0(%rbp,%r13,2),%xmm5
movsd  %xmm5,(%rsi,%r8,8)
mulsd  0x0(%rbp,%rbx,8),%xmm4
mulsd  0x0(%rbp,%r13,2),%xmm4
movsd  %xmm4,(%rsi,%r9,8)
movsd  0x68(%rsp),%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
mulsd  0x0(%rbp,%rbx,8),%xmm2
mulsd  0x0(%rbp,%r13,2),%xmm2
movsd  %xmm2,(%rsi,%rdx,8)
add    $0x4,%r13
add    $0x18,%r14
cmp    %r13,0x90(%rsp)
je     1360 <creat_om+0x210>
movsd  -0x10(%r14),%xmm4
movsd  -0x8(%r14),%xmm3
movsd  (%r14),%xmm5
movsd  (%rcx,%rbx,8),%xmm0
movsd  (%rcx,%r13,2),%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm1,%xmm0
mulsd  %xmm1,%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  0x957(%rip),%xmm1
divsd  %xmm2,%xmm1
movsd  %xmm1,0x38(%rsp)
mulsd  0x94d(%rip),%xmm1
mulsd  %xmm1,%xmm0
ucomisd 0x979(%rip),%xmm0
movsd  %xmm1,0x58(%rsp)
jb     16e0 <creat_om+0x590>
sqrtsd %xmm0,%xmm0
jmp    1709 <creat_om+0x5b9>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm3,0x8(%rsp)
movsd  %xmm4,0x20(%rsp)
movsd  %xmm5,0x18(%rsp)
call   1070 <sqrt@plt>
movsd  0x18(%rsp),%xmm5
movsd  0x20(%rsp),%xmm4
movsd  0x8(%rsp),%xmm3
subsd  0xc0(%rsp),%xmm4
subsd  0xb8(%rsp),%xmm3
subsd  0xb0(%rsp),%xmm5
movsd  %xmm3,0x8(%rsp)
mulsd  %xmm3,%xmm3
movsd  %xmm4,0x20(%rsp)
mulsd  %xmm4,%xmm4
movsd  %xmm4,0xd0(%rsp)
movsd  %xmm3,0x60(%rsp)
addsd  %xmm3,%xmm4
movsd  %xmm5,0x18(%rsp)
mulsd  %xmm5,%xmm5
movsd  %xmm5,0x68(%rsp)
addsd  %xmm5,%xmm4
xorpd  0x8e9(%rip),%xmm4
movapd %xmm4,0x40(%rsp)
movsd  0x89b(%rip),%xmm1
call   1060 <pow@plt>
movsd  %xmm0,0xc8(%rsp)
movapd 0x40(%rsp),%xmm0
mulsd  0x38(%rsp),%xmm0
movapd %xmm0,0x40(%rsp)
call   1050 <exp@plt>
mulsd  0xc8(%rsp),%xmm0
mulsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  0x0(%rbp,%r13,2),%xmm0
mov    0x30(%rsp),%rax
mov    (%r12,%rax,8),%rax
mov    %r13d,%r15d
movsd  %xmm0,(%rax,%r15,8)
mov    0x70(%rsp),%rax
movsd  0x58(%rsp),%xmm0
mulsd  (%rax,%rbx,8),%xmm0
mulsd  (%rax,%r13,2),%xmm0
ucomisd 0x860(%rip),%xmm0
jb     13f0 <creat_om+0x2a0>
sqrtsd %xmm0,%xmm0
jmp    13f5 <creat_om+0x2a5>
mov    0x14(%rsp),%eax
imul   0x7c(%rsp),%eax
test   %eax,%eax
jle    18a4 <creat_om+0x754>
mov    %eax,%r13d
xor    %ebp,%ebp
movapd 0x853(%rip),%xmm1
movsd  0x823(%rip),%xmm2
lea    0x872(%rip),%r14
lea    0x84d(%rip),%r15
jmp    1839 <creat_om+0x6e9>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
cmp    %r13,%rbp
je     18a4 <creat_om+0x754>
xor    %ebx,%ebx
jmp    1849 <creat_om+0x6f9>
nopl   (%rax)
add    $0x1,%rbx
cmp    %rbx,%r13
je     1830 <creat_om+0x6e0>
mov    (%r12,%rbp,8),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    (%r12,%rbx,8),%rax
subsd  (%rax,%rbp,8),%xmm0
andpd  %xmm1,%xmm0
ucomisd %xmm2,%xmm0
jbe    1840 <creat_om+0x6f0>
mov    %r14,%rdi
call   1030 <puts@plt>
mov    (%r12,%rbp,8),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    (%r12,%rbx,8),%rax
movsd  (%rax,%rbp,8),%xmm1
mov    %r15,%rdi
mov    %ebp,%esi
mov    %ebx,%edx
mov    %ebx,%ecx
mov    %ebp,%r8d
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x79e(%rip),%xmm2
movapd 0x7be(%rip),%xmm1
jmp    1840 <creat_om+0x6f0>
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [19 x i8] c"OM SYMMETRY ERROR\0A\00"
@.str.1 = [30 x i8] c"OM[%d][%d]=%g, OM[%d][%d]=%g\0A\00"
define void @creat_om(i32 %0, i32 %1, [3 x double]* %2, double* %3, double* %4, double** %5) {
%7 = alloca i32
%8 = alloca i32
%9 = alloca [3 x double]*
%10 = alloca double*
%11 = alloca double*
%12 = alloca double**
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
store i32 %0, i32* %7
store i32 %1, i32* %8
store [3 x double]* %2, [3 x double]** %9
store double* %3, double** %10
store double* %4, double** %11
store double** %5, double*** %12
%30 = load i32, i32* %7
%31 = icmp eq i32 %30, 1
br i1 %31, label %32, label %173
32: ; preds = %6
store i32 0, i32* %13
br label %33
33: ; preds = %169, %32
%34 = load i32, i32* %13
%35 = load i32, i32* %8
%36 = icmp slt i32 %34, %35
br i1 %36, label %37, label %172
37: ; preds = %33
%38 = load [3 x double]*, [3 x double]** %9
%39 = load i32, i32* %13
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [3 x double], [3 x double]* %38, i64 %40
%42 = getelementptr inbounds [3 x double], [3 x double]* %41, i64 0, i64 0
%43 = load double, double* %42
store double %43, double* %17
%44 = load [3 x double]*, [3 x double]** %9
%45 = load i32, i32* %13
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [3 x double], [3 x double]* %44, i64 %46
%48 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 1
%49 = load double, double* %48
store double %49, double* %18
%50 = load [3 x double]*, [3 x double]** %9
%51 = load i32, i32* %13
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 %52
%54 = getelementptr inbounds [3 x double], [3 x double]* %53, i64 0, i64 2
%55 = load double, double* %54
store double %55, double* %19
store i32 0, i32* %14
br label %56
56: ; preds = %165, %37
%57 = load i32, i32* %14
%58 = load i32, i32* %8
%59 = icmp slt i32 %57, %58
br i1 %59, label %60, label %168
60: ; preds = %56
%61 = load [3 x double]*, [3 x double]** %9
%62 = load i32, i32* %14
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [3 x double], [3 x double]* %61, i64 %63
%65 = getelementptr inbounds [3 x double], [3 x double]* %64, i64 0, i64 0
%66 = load double, double* %65
store double %66, double* %20
%67 = load [3 x double]*, [3 x double]** %9
%68 = load i32, i32* %14
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [3 x double], [3 x double]* %67, i64 %69
%71 = getelementptr inbounds [3 x double], [3 x double]* %70, i64 0, i64 1
%72 = load double, double* %71
store double %72, double* %21
%73 = load [3 x double]*, [3 x double]** %9
%74 = load i32, i32* %14
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [3 x double], [3 x double]* %73, i64 %75
%77 = getelementptr inbounds [3 x double], [3 x double]* %76, i64 0, i64 2
%78 = load double, double* %77
store double %78, double* %22
%79 = load double, double* %17
%80 = load double, double* %20
%81 = fsub double %79, %80
%82 = load double, double* %17
%83 = load double, double* %20
%84 = fsub double %82, %83
%85 = load double, double* %18
%86 = load double, double* %21
%87 = fsub double %85, %86
%88 = load double, double* %18
%89 = load double, double* %21
%90 = fsub double %88, %89
%91 = fmul double %87, %90
%92 = call double @llvm.fmuladd.f64(double %81, double %84, double %91)
%93 = load double, double* %19
%94 = load double, double* %22
%95 = fsub double %93, %94
%96 = load double, double* %19
%97 = load double, double* %22
%98 = fsub double %96, %97
%99 = call double @llvm.fmuladd.f64(double %95, double %98, double %92)
store double %99, double* %26
%100 = load double*, double** %10
%101 = load i32, i32* %13
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %100, i64 %102
%104 = load double, double* %103
%105 = load double*, double** %10
%106 = load i32, i32* %13
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds double, double* %105, i64 %107
%109 = load double, double* %108
%110 = load double*, double** %10
%111 = load i32, i32* %14
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double, double* %110, i64 %112
%114 = load double, double* %113
%115 = load double*, double** %10
%116 = load i32, i32* %14
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds double, double* %115, i64 %117
%119 = load double, double* %118
%120 = fmul double %114, %119
%121 = call double @llvm.fmuladd.f64(double %104, double %109, double %120)
%122 = fdiv double 5.000000e-01, %121
store double %122, double* %27
%123 = load double, double* %27
%124 = fmul double 4.000000e+00, %123
%125 = load double*, double** %10
%126 = load i32, i32* %13
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds double, double* %125, i64 %127
%129 = load double, double* %128
%130 = load double*, double** %10
%131 = load i32, i32* %14
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds double, double* %130, i64 %132
%134 = load double, double* %133
%135 = fmul double %129, %134
%136 = fmul double %124, %135
%137 = call double @sqrt(double %136)
%138 = call double @pow(double %137, double 3.000000e+00)
%139 = load double, double* %26
%140 = fneg double %139
%141 = load double, double* %27
%142 = fmul double %140, %141
%143 = call double @exp(double %142)
%144 = fmul double %138, %143
%145 = load double*, double** %11
%146 = load i32, i32* %13
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds double, double* %145, i64 %147
%149 = load double, double* %148
%150 = fmul double %144, %149
%151 = load double*, double** %11
%152 = load i32, i32* %14
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double, double* %151, i64 %153
%155 = load double, double* %154
%156 = fmul double %150, %155
%157 = load double**, double*** %12
%158 = load i32, i32* %13
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds double*, double** %157, i64 %159
%161 = load double*, double** %160
%162 = load i32, i32* %14
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds double, double* %161, i64 %163
store double %156, double* %164
br label %165
165: ; preds = %60
%166 = load i32, i32* %14
%167 = add nsw i32 %166, 1
store i32 %167, i32* %14
br label %56
168: ; preds = %56
br label %169
169: ; preds = %168
%170 = load i32, i32* %13
%171 = add nsw i32 %170, 1
store i32 %171, i32* %13
br label %33
172: ; preds = %33
br label %802
173: ; preds = %6
store i32 0, i32* %13
br label %174
174: ; preds = %798, %173
%175 = load i32, i32* %13
%176 = load i32, i32* %8
%177 = icmp slt i32 %175, %176
br i1 %177, label %178, label %801
178: ; preds = %174
%179 = load [3 x double]*, [3 x double]** %9
%180 = load i32, i32* %13
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [3 x double], [3 x double]* %179, i64 %181
%183 = getelementptr inbounds [3 x double], [3 x double]* %182, i64 0, i64 0
%184 = load double, double* %183
store double %184, double* %17
%185 = load [3 x double]*, [3 x double]** %9
%186 = load i32, i32* %13
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds [3 x double], [3 x double]* %185, i64 %187
%189 = getelementptr inbounds [3 x double], [3 x double]* %188, i64 0, i64 1
%190 = load double, double* %189
store double %190, double* %18
%191 = load [3 x double]*, [3 x double]** %9
%192 = load i32, i32* %13
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [3 x double], [3 x double]* %191, i64 %193
%195 = getelementptr inbounds [3 x double], [3 x double]* %194, i64 0, i64 2
%196 = load double, double* %195
store double %196, double* %19
store i32 0, i32* %14
br label %197
197: ; preds = %794, %178
%198 = load i32, i32* %14
%199 = load i32, i32* %8
%200 = icmp slt i32 %198, %199
br i1 %200, label %201, label %797
201: ; preds = %197
%202 = load [3 x double]*, [3 x double]** %9
%203 = load i32, i32* %14
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds [3 x double], [3 x double]* %202, i64 %204
%206 = getelementptr inbounds [3 x double], [3 x double]* %205, i64 0, i64 0
%207 = load double, double* %206
store double %207, double* %20
%208 = load [3 x double]*, [3 x double]** %9
%209 = load i32, i32* %14
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds [3 x double], [3 x double]* %208, i64 %210
%212 = getelementptr inbounds [3 x double], [3 x double]* %211, i64 0, i64 1
%213 = load double, double* %212
store double %213, double* %21
%214 = load [3 x double]*, [3 x double]** %9
%215 = load i32, i32* %14
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds [3 x double], [3 x double]* %214, i64 %216
%218 = getelementptr inbounds [3 x double], [3 x double]* %217, i64 0, i64 2
%219 = load double, double* %218
store double %219, double* %22
%220 = load double, double* %20
%221 = load double, double* %17
%222 = fsub double %220, %221
store double %222, double* %23
%223 = load double, double* %21
%224 = load double, double* %18
%225 = fsub double %223, %224
store double %225, double* %24
%226 = load double, double* %22
%227 = load double, double* %19
%228 = fsub double %226, %227
store double %228, double* %25
%229 = load double, double* %23
%230 = load double, double* %23
%231 = load double, double* %24
%232 = load double, double* %24
%233 = fmul double %231, %232
%234 = call double @llvm.fmuladd.f64(double %229, double %230, double %233)
%235 = load double, double* %25
%236 = load double, double* %25
%237 = call double @llvm.fmuladd.f64(double %235, double %236, double %234)
store double %237, double* %26
%238 = load double*, double** %10
%239 = load i32, i32* %13
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double, double* %238, i64 %240
%242 = load double, double* %241
%243 = load double*, double** %10
%244 = load i32, i32* %13
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double, double* %243, i64 %245
%247 = load double, double* %246
%248 = load double*, double** %10
%249 = load i32, i32* %14
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds double, double* %248, i64 %250
%252 = load double, double* %251
%253 = load double*, double** %10
%254 = load i32, i32* %14
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds double, double* %253, i64 %255
%257 = load double, double* %256
%258 = fmul double %252, %257
%259 = call double @llvm.fmuladd.f64(double %242, double %247, double %258)
%260 = fdiv double 5.000000e-01, %259
store double %260, double* %27
%261 = load double, double* %27
%262 = fmul double 4.000000e+00, %261
%263 = load double*, double** %10
%264 = load i32, i32* %13
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds double, double* %263, i64 %265
%267 = load double, double* %266
%268 = load double*, double** %10
%269 = load i32, i32* %14
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds double, double* %268, i64 %270
%272 = load double, double* %271
%273 = fmul double %267, %272
%274 = fmul double %262, %273
%275 = call double @sqrt(double %274)
%276 = call double @pow(double %275, double 3.000000e+00)
%277 = load double, double* %26
%278 = fneg double %277
%279 = load double, double* %27
%280 = fmul double %278, %279
%281 = call double @exp(double %280)
%282 = fmul double %276, %281
%283 = load double*, double** %11
%284 = load i32, i32* %13
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %283, i64 %285
%287 = load double, double* %286
%288 = fmul double %282, %287
%289 = load double*, double** %11
%290 = load i32, i32* %14
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds double, double* %289, i64 %291
%293 = load double, double* %292
%294 = fmul double %288, %293
%295 = load double**, double*** %12
%296 = load i32, i32* %13
%297 = mul nsw i32 4, %296
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double*, double** %295, i64 %298
%300 = load double*, double** %299
%301 = load i32, i32* %14
%302 = mul nsw i32 4, %301
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds double, double* %300, i64 %303
store double %294, double* %304
%305 = load double, double* %27
%306 = fmul double 4.000000e+00, %305
%307 = load double*, double** %10
%308 = load i32, i32* %13
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds double, double* %307, i64 %309
%311 = load double, double* %310
%312 = fmul double %306, %311
%313 = load double*, double** %10
%314 = load i32, i32* %14
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds double, double* %313, i64 %315
%317 = load double, double* %316
%318 = fmul double %312, %317
%319 = call double @sqrt(double %318)
%320 = call double @pow(double %319, double 3.000000e+00)
%321 = load double, double* %26
%322 = fneg double %321
%323 = load double, double* %27
%324 = fmul double %322, %323
%325 = call double @exp(double %324)
%326 = fmul double %320, %325
store double %326, double* %28
%327 = call double @sqrt(double 8.000000e+00)
%328 = load double*, double** %10
%329 = load i32, i32* %14
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds double, double* %328, i64 %330
%332 = load double, double* %331
%333 = fmul double %327, %332
%334 = load double, double* %27
%335 = fmul double %333, %334
%336 = load double, double* %28
%337 = fmul double %335, %336
store double %337, double* %29
%338 = load double, double* %29
%339 = load double, double* %23
%340 = fmul double %338, %339
%341 = load double*, double** %11
%342 = load i32, i32* %13
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds double, double* %341, i64 %343
%345 = load double, double* %344
%346 = fmul double %340, %345
%347 = load double*, double** %11
%348 = load i32, i32* %14
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds double, double* %347, i64 %349
%351 = load double, double* %350
%352 = fmul double %346, %351
%353 = load double**, double*** %12
%354 = load i32, i32* %13
%355 = mul nsw i32 4, %354
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds double*, double** %353, i64 %356
%358 = load double*, double** %357
%359 = load i32, i32* %14
%360 = mul nsw i32 4, %359
%361 = add nsw i32 %360, 1
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds double, double* %358, i64 %362
store double %352, double* %363
%364 = load double, double* %29
%365 = load double, double* %24
%366 = fmul double %364, %365
%367 = load double*, double** %11
%368 = load i32, i32* %13
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds double, double* %367, i64 %369
%371 = load double, double* %370
%372 = fmul double %366, %371
%373 = load double*, double** %11
%374 = load i32, i32* %14
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds double, double* %373, i64 %375
%377 = load double, double* %376
%378 = fmul double %372, %377
%379 = load double**, double*** %12
%380 = load i32, i32* %13
%381 = mul nsw i32 4, %380
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds double*, double** %379, i64 %382
%384 = load double*, double** %383
%385 = load i32, i32* %14
%386 = mul nsw i32 4, %385
%387 = add nsw i32 %386, 2
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds double, double* %384, i64 %388
store double %378, double* %389
%390 = load double, double* %29
%391 = load double, double* %25
%392 = fmul double %390, %391
%393 = load double*, double** %11
%394 = load i32, i32* %13
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds double, double* %393, i64 %395
%397 = load double, double* %396
%398 = fmul double %392, %397
%399 = load double*, double** %11
%400 = load i32, i32* %14
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds double, double* %399, i64 %401
%403 = load double, double* %402
%404 = fmul double %398, %403
%405 = load double**, double*** %12
%406 = load i32, i32* %13
%407 = mul nsw i32 4, %406
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds double*, double** %405, i64 %408
%410 = load double*, double** %409
%411 = load i32, i32* %14
%412 = mul nsw i32 4, %411
%413 = add nsw i32 %412, 3
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds double, double* %410, i64 %414
store double %404, double* %415
%416 = call double @sqrt(double 8.000000e+00)
%417 = load double*, double** %10
%418 = load i32, i32* %13
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds double, double* %417, i64 %419
%421 = load double, double* %420
%422 = fmul double %416, %421
%423 = load double, double* %27
%424 = fmul double %422, %423
%425 = load double, double* %28
%426 = fmul double %424, %425
%427 = fmul double %426, -1.000000e+00
store double %427, double* %29
%428 = load double, double* %29
%429 = load double, double* %23
%430 = fmul double %428, %429
%431 = load double*, double** %11
%432 = load i32, i32* %13
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %431, i64 %433
%435 = load double, double* %434
%436 = fmul double %430, %435
%437 = load double*, double** %11
%438 = load i32, i32* %14
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds double, double* %437, i64 %439
%441 = load double, double* %440
%442 = fmul double %436, %441
%443 = load double**, double*** %12
%444 = load i32, i32* %13
%445 = mul nsw i32 4, %444
%446 = add nsw i32 %445, 1
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds double*, double** %443, i64 %447
%449 = load double*, double** %448
%450 = load i32, i32* %14
%451 = mul nsw i32 4, %450
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds double, double* %449, i64 %452
store double %442, double* %453
%454 = load double, double* %29
%455 = load double, double* %24
%456 = fmul double %454, %455
%457 = load double*, double** %11
%458 = load i32, i32* %13
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds double, double* %457, i64 %459
%461 = load double, double* %460
%462 = fmul double %456, %461
%463 = load double*, double** %11
%464 = load i32, i32* %14
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds double, double* %463, i64 %465
%467 = load double, double* %466
%468 = fmul double %462, %467
%469 = load double**, double*** %12
%470 = load i32, i32* %13
%471 = mul nsw i32 4, %470
%472 = add nsw i32 %471, 2
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds double*, double** %469, i64 %473
%475 = load double*, double** %474
%476 = load i32, i32* %14
%477 = mul nsw i32 4, %476
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds double, double* %475, i64 %478
store double %468, double* %479
%480 = load double, double* %29
%481 = load double, double* %25
%482 = fmul double %480, %481
%483 = load double*, double** %11
%484 = load i32, i32* %13
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds double, double* %483, i64 %485
%487 = load double, double* %486
%488 = fmul double %482, %487
%489 = load double*, double** %11
%490 = load i32, i32* %14
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds double, double* %489, i64 %491
%493 = load double, double* %492
%494 = fmul double %488, %493
%495 = load double**, double*** %12
%496 = load i32, i32* %13
%497 = mul nsw i32 4, %496
%498 = add nsw i32 %497, 3
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds double*, double** %495, i64 %499
%501 = load double*, double** %500
%502 = load i32, i32* %14
%503 = mul nsw i32 4, %502
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds double, double* %501, i64 %504
store double %494, double* %505
%506 = load double*, double** %10
%507 = load i32, i32* %13
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds double, double* %506, i64 %508
%510 = load double, double* %509
%511 = fmul double -8.000000e+00, %510
%512 = load double*, double** %10
%513 = load i32, i32* %14
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds double, double* %512, i64 %514
%516 = load double, double* %515
%517 = fmul double %511, %516
%518 = load double, double* %27
%519 = fmul double %517, %518
%520 = load double, double* %27
%521 = fmul double %519, %520
%522 = load double, double* %28
%523 = fmul double %521, %522
store double %523, double* %29
%524 = load double, double* %29
%525 = load double, double* %23
%526 = load double, double* %23
%527 = load double, double* %27
%528 = fdiv double 5.000000e-01, %527
%529 = fneg double %528
%530 = call double @llvm.fmuladd.f64(double %525, double %526, double %529)
%531 = fmul double %524, %530
%532 = load double*, double** %11
%533 = load i32, i32* %13
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds double, double* %532, i64 %534
%536 = load double, double* %535
%537 = fmul double %531, %536
%538 = load double*, double** %11
%539 = load i32, i32* %14
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds double, double* %538, i64 %540
%542 = load double, double* %541
%543 = fmul double %537, %542
%544 = load double**, double*** %12
%545 = load i32, i32* %13
%546 = mul nsw i32 4, %545
%547 = add nsw i32 %546, 1
%548 = sext i32 %547 to i64
%549 = getelementptr inbounds double*, double** %544, i64 %548
%550 = load double*, double** %549
%551 = load i32, i32* %14
%552 = mul nsw i32 4, %551
%553 = add nsw i32 %552, 1
%554 = sext i32 %553 to i64
%555 = getelementptr inbounds double, double* %550, i64 %554
store double %543, double* %555
%556 = load double, double* %29
%557 = load double, double* %24
%558 = load double, double* %23
%559 = fmul double %557, %558
%560 = fmul double %556, %559
%561 = load double*, double** %11
%562 = load i32, i32* %13
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds double, double* %561, i64 %563
%565 = load double, double* %564
%566 = fmul double %560, %565
%567 = load double*, double** %11
%568 = load i32, i32* %14
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds double, double* %567, i64 %569
%571 = load double, double* %570
%572 = fmul double %566, %571
%573 = load double**, double*** %12
%574 = load i32, i32* %13
%575 = mul nsw i32 4, %574
%576 = add nsw i32 %575, 1
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds double*, double** %573, i64 %577
%579 = load double*, double** %578
%580 = load i32, i32* %14
%581 = mul nsw i32 4, %580
%582 = add nsw i32 %581, 2
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds double, double* %579, i64 %583
store double %572, double* %584
%585 = load double, double* %29
%586 = load double, double* %25
%587 = load double, double* %23
%588 = fmul double %586, %587
%589 = fmul double %585, %588
%590 = load double*, double** %11
%591 = load i32, i32* %13
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds double, double* %590, i64 %592
%594 = load double, double* %593
%595 = fmul double %589, %594
%596 = load double*, double** %11
%597 = load i32, i32* %14
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds double, double* %596, i64 %598
%600 = load double, double* %599
%601 = fmul double %595, %600
%602 = load double**, double*** %12
%603 = load i32, i32* %13
%604 = mul nsw i32 4, %603
%605 = add nsw i32 %604, 1
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds double*, double** %602, i64 %606
%608 = load double*, double** %607
%609 = load i32, i32* %14
%610 = mul nsw i32 4, %609
%611 = add nsw i32 %610, 3
%612 = sext i32 %611 to i64
%613 = getelementptr inbounds double, double* %608, i64 %612
store double %601, double* %613
%614 = load double, double* %29
%615 = load double, double* %23
%616 = load double, double* %24
%617 = fmul double %615, %616
%618 = fmul double %614, %617
%619 = load double*, double** %11
%620 = load i32, i32* %13
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds double, double* %619, i64 %621
%623 = load double, double* %622
%624 = fmul double %618, %623
%625 = load double*, double** %11
%626 = load i32, i32* %14
%627 = sext i32 %626 to i64
%628 = getelementptr inbounds double, double* %625, i64 %627
%629 = load double, double* %628
%630 = fmul double %624, %629
%631 = load double**, double*** %12
%632 = load i32, i32* %13
%633 = mul nsw i32 4, %632
%634 = add nsw i32 %633, 2
%635 = sext i32 %634 to i64
%636 = getelementptr inbounds double*, double** %631, i64 %635
%637 = load double*, double** %636
%638 = load i32, i32* %14
%639 = mul nsw i32 4, %638
%640 = add nsw i32 %639, 1
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds double, double* %637, i64 %641
store double %630, double* %642
%643 = load double, double* %29
%644 = load double, double* %24
%645 = load double, double* %24
%646 = load double, double* %27
%647 = fdiv double 5.000000e-01, %646
%648 = fneg double %647
%649 = call double @llvm.fmuladd.f64(double %644, double %645, double %648)
%650 = fmul double %643, %649
%651 = load double*, double** %11
%652 = load i32, i32* %13
%653 = sext i32 %652 to i64
%654 = getelementptr inbounds double, double* %651, i64 %653
%655 = load double, double* %654
%656 = fmul double %650, %655
%657 = load double*, double** %11
%658 = load i32, i32* %14
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds double, double* %657, i64 %659
%661 = load double, double* %660
%662 = fmul double %656, %661
%663 = load double**, double*** %12
%664 = load i32, i32* %13
%665 = mul nsw i32 4, %664
%666 = add nsw i32 %665, 2
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds double*, double** %663, i64 %667
%669 = load double*, double** %668
%670 = load i32, i32* %14
%671 = mul nsw i32 4, %670
%672 = add nsw i32 %671, 2
%673 = sext i32 %672 to i64
%674 = getelementptr inbounds double, double* %669, i64 %673
store double %662, double* %674
%675 = load double, double* %29
%676 = load double, double* %25
%677 = load double, double* %24
%678 = fmul double %676, %677
%679 = fmul double %675, %678
%680 = load double*, double** %11
%681 = load i32, i32* %13
%682 = sext i32 %681 to i64
%683 = getelementptr inbounds double, double* %680, i64 %682
%684 = load double, double* %683
%685 = fmul double %679, %684
%686 = load double*, double** %11
%687 = load i32, i32* %14
%688 = sext i32 %687 to i64
%689 = getelementptr inbounds double, double* %686, i64 %688
%690 = load double, double* %689
%691 = fmul double %685, %690
%692 = load double**, double*** %12
%693 = load i32, i32* %13
%694 = mul nsw i32 4, %693
%695 = add nsw i32 %694, 2
%696 = sext i32 %695 to i64
%697 = getelementptr inbounds double*, double** %692, i64 %696
%698 = load double*, double** %697
%699 = load i32, i32* %14
%700 = mul nsw i32 4, %699
%701 = add nsw i32 %700, 3
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds double, double* %698, i64 %702
store double %691, double* %703
%704 = load double, double* %29
%705 = load double, double* %23
%706 = load double, double* %25
%707 = fmul double %705, %706
%708 = fmul double %704, %707
%709 = load double*, double** %11
%710 = load i32, i32* %13
%711 = sext i32 %710 to i64
%712 = getelementptr inbounds double, double* %709, i64 %711
%713 = load double, double* %712
%714 = fmul double %708, %713
%715 = load double*, double** %11
%716 = load i32, i32* %14
%717 = sext i32 %716 to i64
%718 = getelementptr inbounds double, double* %715, i64 %717
%719 = load double, double* %718
%720 = fmul double %714, %719
%721 = load double**, double*** %12
%722 = load i32, i32* %13
%723 = mul nsw i32 4, %722
%724 = add nsw i32 %723, 3
%725 = sext i32 %724 to i64
%726 = getelementptr inbounds double*, double** %721, i64 %725
%727 = load double*, double** %726
%728 = load i32, i32* %14
%729 = mul nsw i32 4, %728
%730 = add nsw i32 %729, 1
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds double, double* %727, i64 %731
store double %720, double* %732
%733 = load double, double* %29
%734 = load double, double* %24
%735 = load double, double* %25
%736 = fmul double %734, %735
%737 = fmul double %733, %736
%738 = load double*, double** %11
%739 = load i32, i32* %13
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds double, double* %738, i64 %740
%742 = load double, double* %741
%743 = fmul double %737, %742
%744 = load double*, double** %11
%745 = load i32, i32* %14
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds double, double* %744, i64 %746
%748 = load double, double* %747
%749 = fmul double %743, %748
%750 = load double**, double*** %12
%751 = load i32, i32* %13
%752 = mul nsw i32 4, %751
%753 = add nsw i32 %752, 3
%754 = sext i32 %753 to i64
%755 = getelementptr inbounds double*, double** %750, i64 %754
%756 = load double*, double** %755
%757 = load i32, i32* %14
%758 = mul nsw i32 4, %757
%759 = add nsw i32 %758, 2
%760 = sext i32 %759 to i64
%761 = getelementptr inbounds double, double* %756, i64 %760
store double %749, double* %761
%762 = load double, double* %29
%763 = load double, double* %25
%764 = load double, double* %25
%765 = load double, double* %27
%766 = fdiv double 5.000000e-01, %765
%767 = fneg double %766
%768 = call double @llvm.fmuladd.f64(double %763, double %764, double %767)
%769 = fmul double %762, %768
%770 = load double*, double** %11
%771 = load i32, i32* %13
%772 = sext i32 %771 to i64
%773 = getelementptr inbounds double, double* %770, i64 %772
%774 = load double, double* %773
%775 = fmul double %769, %774
%776 = load double*, double** %11
%777 = load i32, i32* %14
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds double, double* %776, i64 %778
%780 = load double, double* %779
%781 = fmul double %775, %780
%782 = load double**, double*** %12
%783 = load i32, i32* %13
%784 = mul nsw i32 4, %783
%785 = add nsw i32 %784, 3
%786 = sext i32 %785 to i64
%787 = getelementptr inbounds double*, double** %782, i64 %786
%788 = load double*, double** %787
%789 = load i32, i32* %14
%790 = mul nsw i32 4, %789
%791 = add nsw i32 %790, 3
%792 = sext i32 %791 to i64
%793 = getelementptr inbounds double, double* %788, i64 %792
store double %781, double* %793
br label %794
794: ; preds = %201
%795 = load i32, i32* %14
%796 = add nsw i32 %795, 1
store i32 %796, i32* %14
br label %197
797: ; preds = %197
br label %798
798: ; preds = %797
%799 = load i32, i32* %13
%800 = add nsw i32 %799, 1
store i32 %800, i32* %13
br label %174
801: ; preds = %174
br label %802
802: ; preds = %801, %172
store i32 0, i32* %15
br label %803
803: ; preds = %868, %802
%804 = load i32, i32* %15
%805 = load i32, i32* %7
%806 = load i32, i32* %8
%807 = mul nsw i32 %805, %806
%808 = icmp slt i32 %804, %807
br i1 %808, label %809, label %871
809: ; preds = %803
store i32 0, i32* %16
br label %810
810: ; preds = %864, %809
%811 = load i32, i32* %16
%812 = load i32, i32* %7
%813 = load i32, i32* %8
%814 = mul nsw i32 %812, %813
%815 = icmp slt i32 %811, %814
br i1 %815, label %816, label %867
816: ; preds = %810
%817 = load double**, double*** %12
%818 = load i32, i32* %15
%819 = sext i32 %818 to i64
%820 = getelementptr inbounds double*, double** %817, i64 %819
%821 = load double*, double** %820
%822 = load i32, i32* %16
%823 = sext i32 %822 to i64
%824 = getelementptr inbounds double, double* %821, i64 %823
%825 = load double, double* %824
%826 = load double**, double*** %12
%827 = load i32, i32* %16
%828 = sext i32 %827 to i64
%829 = getelementptr inbounds double*, double** %826, i64 %828
%830 = load double*, double** %829
%831 = load i32, i32* %15
%832 = sext i32 %831 to i64
%833 = getelementptr inbounds double, double* %830, i64 %832
%834 = load double, double* %833
%835 = fsub double %825, %834
%836 = call double @llvm.fabs.f64(double %835)
%837 = fcmp ogt double %836, 0x3EB0C6F7A0B5ED8D
br i1 %837, label %838, label %863
838: ; preds = %816
%839 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0))
%840 = load i32, i32* %15
%841 = load i32, i32* %16
%842 = load double**, double*** %12
%843 = load i32, i32* %15
%844 = sext i32 %843 to i64
%845 = getelementptr inbounds double*, double** %842, i64 %844
%846 = load double*, double** %845
%847 = load i32, i32* %16
%848 = sext i32 %847 to i64
%849 = getelementptr inbounds double, double* %846, i64 %848
%850 = load double, double* %849
%851 = load i32, i32* %16
%852 = load i32, i32* %15
%853 = load double**, double*** %12
%854 = load i32, i32* %16
%855 = sext i32 %854 to i64
%856 = getelementptr inbounds double*, double** %853, i64 %855
%857 = load double*, double** %856
%858 = load i32, i32* %15
%859 = sext i32 %858 to i64
%860 = getelementptr inbounds double, double* %857, i64 %859
%861 = load double, double* %860
%862 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.1, i64 0, i64 0), i32 %840, i32 %841, double %850, i32 %851, i32 %852, double %861)
br label %863
863: ; preds = %838, %816
br label %864
864: ; preds = %863
%865 = load i32, i32* %16
%866 = add nsw i32 %865, 1
store i32 %866, i32* %16
br label %810
867: ; preds = %810
br label %868
868: ; preds = %867
%869 = load i32, i32* %15
%870 = add nsw i32 %869, 1
store i32 %870, i32* %15
br label %803
871: ; preds = %803
ret void
}

LLVM IR (-O2):
@.str.1 = [30 x i8] c"OM[%d][%d]=%g, OM[%d][%d]=%g\0A\00"
@str = [18 x i8] c"OM SYMMETRY ERROR\00"
define void @creat_om(i32 %0, i32 %1, [3 x double]* nocapture %2, double* nocapture %3, double* nocapture %4, double** nocapture %5) {
%7 = icmp eq i32 %0, 1
%8 = icmp sgt i32 %1, 0
br i1 %7, label %12, label %9
9: ; preds = %6
br i1 %8, label %10, label %261
10: ; preds = %9
%11 = zext i32 %1 to i64
br label %67
12: ; preds = %6
br i1 %8, label %13, label %261
13: ; preds = %12
%14 = zext i32 %1 to i64
br label %15
15: ; preds = %64, %13
%16 = phi i64 [ 0, %13 ], [ %65, %64 ]
%17 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %16, i64 0
%18 = load double, double* %17
%19 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %16, i64 1
%20 = load double, double* %19
%21 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %16, i64 2
%22 = load double, double* %21
%23 = getelementptr inbounds double, double* %3, i64 %16
%24 = getelementptr inbounds double, double* %4, i64 %16
%25 = getelementptr inbounds double*, double** %5, i64 %16
br label %26
26: ; preds = %15, %26
%27 = phi i64 [ 0, %15 ], [ %62, %26 ]
%28 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %27, i64 0
%29 = load double, double* %28
%30 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %27, i64 1
%31 = load double, double* %30
%32 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %27, i64 2
%33 = load double, double* %32
%34 = fsub double %18, %29
%35 = fsub double %20, %31
%36 = fmul double %35, %35
%37 = tail call double @llvm.fmuladd.f64(double %34, double %34, double %36)
%38 = fsub double %22, %33
%39 = tail call double @llvm.fmuladd.f64(double %38, double %38, double %37)
%40 = load double, double* %23
%41 = getelementptr inbounds double, double* %3, i64 %27
%42 = load double, double* %41
%43 = fmul double %42, %42
%44 = tail call double @llvm.fmuladd.f64(double %40, double %40, double %43)
%45 = fdiv double 5.000000e-01, %44
%46 = fmul double %45, 4.000000e+00
%47 = fmul double %40, %42
%48 = fmul double %47, %46
%49 = tail call double @sqrt(double %48)
%50 = tail call double @pow(double %49, double 3.000000e+00)
%51 = fneg double %39
%52 = fmul double %45, %51
%53 = tail call double @exp(double %52)
%54 = fmul double %50, %53
%55 = load double, double* %24
%56 = fmul double %54, %55
%57 = getelementptr inbounds double, double* %4, i64 %27
%58 = load double, double* %57
%59 = fmul double %56, %58
%60 = load double*, double** %25
%61 = getelementptr inbounds double, double* %60, i64 %27
store double %59, double* %61
%62 = add nuw nsw i64 %27, 1
%63 = icmp eq i64 %62, %14
br i1 %63, label %64, label %26
64: ; preds = %26
%65 = add nuw nsw i64 %16, 1
%66 = icmp eq i64 %65, %14
br i1 %66, label %261, label %15
67: ; preds = %258, %10
%68 = phi i64 [ 0, %10 ], [ %259, %258 ]
%69 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %68, i64 0
%70 = load double, double* %69
%71 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %68, i64 1
%72 = load double, double* %71
%73 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %68, i64 2
%74 = load double, double* %73
%75 = getelementptr inbounds double, double* %3, i64 %68
%76 = getelementptr inbounds double, double* %4, i64 %68
%77 = trunc i64 %68 to i32
%78 = shl nsw i32 %77, 2
%79 = zext i32 %78 to i64
%80 = getelementptr inbounds double*, double** %5, i64 %79
%81 = or i32 %78, 1
%82 = zext i32 %81 to i64
%83 = getelementptr inbounds double*, double** %5, i64 %82
%84 = or i32 %78, 2
%85 = zext i32 %84 to i64
%86 = getelementptr inbounds double*, double** %5, i64 %85
%87 = or i32 %78, 3
%88 = zext i32 %87 to i64
%89 = getelementptr inbounds double*, double** %5, i64 %88
br label %90
90: ; preds = %67, %90
%91 = phi i64 [ 0, %67 ], [ %256, %90 ]
%92 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %91, i64 0
%93 = load double, double* %92
%94 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %91, i64 1
%95 = load double, double* %94
%96 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %91, i64 2
%97 = load double, double* %96
%98 = fsub double %93, %70
%99 = fsub double %95, %72
%100 = fsub double %97, %74
%101 = fmul double %99, %99
%102 = tail call double @llvm.fmuladd.f64(double %98, double %98, double %101)
%103 = tail call double @llvm.fmuladd.f64(double %100, double %100, double %102)
%104 = load double, double* %75
%105 = getelementptr inbounds double, double* %3, i64 %91
%106 = load double, double* %105
%107 = fmul double %106, %106
%108 = tail call double @llvm.fmuladd.f64(double %104, double %104, double %107)
%109 = fdiv double 5.000000e-01, %108
%110 = fmul double %109, 4.000000e+00
%111 = fmul double %104, %106
%112 = fmul double %111, %110
%113 = tail call double @sqrt(double %112)
%114 = tail call double @pow(double %113, double 3.000000e+00)
%115 = fneg double %103
%116 = fmul double %109, %115
%117 = tail call double @exp(double %116)
%118 = fmul double %114, %117
%119 = load double, double* %76
%120 = fmul double %118, %119
%121 = getelementptr inbounds double, double* %4, i64 %91
%122 = load double, double* %121
%123 = fmul double %120, %122
%124 = load double*, double** %80
%125 = trunc i64 %91 to i32
%126 = shl nsw i32 %125, 2
%127 = zext i32 %126 to i64
%128 = getelementptr inbounds double, double* %124, i64 %127
store double %123, double* %128
%129 = load double, double* %75
%130 = fmul double %110, %129
%131 = load double, double* %105
%132 = fmul double %130, %131
%133 = tail call double @sqrt(double %132)
%134 = tail call double @pow(double %133, double 3.000000e+00)
%135 = tail call double @exp(double %116)
%136 = fmul double %134, %135
%137 = load double, double* %105
%138 = fmul double %137, 0x4006A09E667F3BCD
%139 = fmul double %109, %138
%140 = fmul double %136, %139
%141 = fmul double %98, %140
%142 = load double, double* %76
%143 = fmul double %142, %141
%144 = load double, double* %121
%145 = fmul double %144, %143
%146 = load double*, double** %80
%147 = or i32 %126, 1
%148 = zext i32 %147 to i64
%149 = getelementptr inbounds double, double* %146, i64 %148
store double %145, double* %149
%150 = fmul double %99, %140
%151 = load double, double* %76
%152 = fmul double %150, %151
%153 = load double, double* %121
%154 = fmul double %152, %153
%155 = or i32 %126, 2
%156 = zext i32 %155 to i64
%157 = getelementptr inbounds double, double* %146, i64 %156
store double %154, double* %157
%158 = fmul double %100, %140
%159 = load double, double* %76
%160 = fmul double %158, %159
%161 = load double, double* %121
%162 = fmul double %160, %161
%163 = or i32 %126, 3
%164 = zext i32 %163 to i64
%165 = getelementptr inbounds double, double* %146, i64 %164
store double %162, double* %165
%166 = load double, double* %75
%167 = fmul double %166, 0xC006A09E667F3BCD
%168 = fmul double %109, %167
%169 = fmul double %136, %168
%170 = fmul double %98, %169
%171 = load double, double* %76
%172 = fmul double %171, %170
%173 = load double, double* %121
%174 = fmul double %173, %172
%175 = load double*, double** %83
%176 = getelementptr inbounds double, double* %175, i64 %127
store double %174, double* %176
%177 = fmul double %99, %169
%178 = load double, double* %76
%179 = fmul double %177, %178
%180 = load double, double* %121
%181 = fmul double %179, %180
%182 = load double*, double** %86
%183 = getelementptr inbounds double, double* %182, i64 %127
store double %181, double* %183
%184 = fmul double %100, %169
%185 = load double, double* %76
%186 = fmul double %184, %185
%187 = load double, double* %121
%188 = fmul double %186, %187
%189 = load double*, double** %89
%190 = getelementptr inbounds double, double* %189, i64 %127
store double %188, double* %190
%191 = load double, double* %75
%192 = fmul double %191, -8.000000e+00
%193 = load double, double* %105
%194 = fmul double %192, %193
%195 = fmul double %109, %194
%196 = fmul double %109, %195
%197 = fmul double %136, %196
%198 = fdiv double -5.000000e-01, %109
%199 = tail call double @llvm.fmuladd.f64(double %98, double %98, double %198)
%200 = fmul double %199, %197
%201 = load double, double* %76
%202 = fmul double %201, %200
%203 = load double, double* %121
%204 = fmul double %203, %202
%205 = getelementptr inbounds double, double* %175, i64 %148
store double %204, double* %205
%206 = fmul double %98, %99
%207 = fmul double %206, %197
%208 = load double, double* %76
%209 = fmul double %208, %207
%210 = load double, double* %121
%211 = fmul double %210, %209
%212 = getelementptr inbounds double, double* %175, i64 %156
store double %211, double* %212
%213 = fmul double %98, %100
%214 = fmul double %213, %197
%215 = load double, double* %76
%216 = fmul double %214, %215
%217 = load double, double* %121
%218 = fmul double %216, %217
%219 = getelementptr inbounds double, double* %175, i64 %164
store double %218, double* %219
%220 = load double, double* %76
%221 = fmul double %207, %220
%222 = load double, double* %121
%223 = fmul double %221, %222
%224 = getelementptr inbounds double, double* %182, i64 %148
store double %223, double* %224
%225 = tail call double @llvm.fmuladd.f64(double %99, double %99, double %198)
%226 = fmul double %225, %197
%227 = load double, double* %76
%228 = fmul double %226, %227
%229 = load double, double* %121
%230 = fmul double %228, %229
%231 = getelementptr inbounds double, double* %182, i64 %156
store double %230, double* %231
%232 = fmul double %99, %100
%233 = fmul double %232, %197
%234 = load double, double* %76
%235 = fmul double %233, %234
%236 = load double, double* %121
%237 = fmul double %235, %236
%238 = getelementptr inbounds double, double* %182, i64 %164
store double %237, double* %238
%239 = load double, double* %76
%240 = fmul double %214, %239
%241 = load double, double* %121
%242 = fmul double %240, %241
%243 = getelementptr inbounds double, double* %189, i64 %148
store double %242, double* %243
%244 = load double, double* %76
%245 = fmul double %233, %244
%246 = load double, double* %121
%247 = fmul double %245, %246
%248 = getelementptr inbounds double, double* %189, i64 %156
store double %247, double* %248
%249 = tail call double @llvm.fmuladd.f64(double %100, double %100, double %198)
%250 = fmul double %249, %197
%251 = load double, double* %76
%252 = fmul double %250, %251
%253 = load double, double* %121
%254 = fmul double %252, %253
%255 = getelementptr inbounds double, double* %189, i64 %164
store double %254, double* %255
%256 = add nuw nsw i64 %91, 1
%257 = icmp eq i64 %256, %11
br i1 %257, label %258, label %90
258: ; preds = %90
%259 = add nuw nsw i64 %68, 1
%260 = icmp eq i64 %259, %11
br i1 %260, label %261, label %67
261: ; preds = %258, %64, %9, %12
%262 = mul i32 %1, %0
%263 = icmp sgt i32 %262, 0
br i1 %263, label %264, label %298
264: ; preds = %261
%265 = zext i32 %262 to i64
br label %266
266: ; preds = %295, %264
%267 = phi i64 [ 0, %264 ], [ %296, %295 ]
%268 = getelementptr inbounds double*, double** %5, i64 %267
%269 = trunc i64 %267 to i32
br label %270
270: ; preds = %266, %292
%271 = phi i64 [ 0, %266 ], [ %293, %292 ]
%272 = load double*, double** %268
%273 = getelementptr inbounds double, double* %272, i64 %271
%274 = load double, double* %273
%275 = getelementptr inbounds double*, double** %5, i64 %271
%276 = load double*, double** %275
%277 = getelementptr inbounds double, double* %276, i64 %267
%278 = load double, double* %277
%279 = fsub double %274, %278
%280 = tail call double @llvm.fabs.f64(double %279)
%281 = fcmp ogt double %280, 0x3EB0C6F7A0B5ED8D
br i1 %281, label %282, label %292
282: ; preds = %270
%283 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str, i64 0, i64 0))
%284 = load double*, double** %268
%285 = getelementptr inbounds double, double* %284, i64 %271
%286 = load double, double* %285
%287 = load double*, double** %275
%288 = getelementptr inbounds double, double* %287, i64 %267
%289 = load double, double* %288
%290 = trunc i64 %271 to i32
%291 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.1, i64 0, i64 0), i32 %269, i32 %290, double %286, i32 %290, i32 %269, double %289)
br label %292
292: ; preds = %270, %282
%293 = add nuw nsw i64 %271, 1
%294 = icmp eq i64 %293, %265
br i1 %294, label %295, label %270
295: ; preds = %292
%296 = add nuw nsw i64 %267, 1
%297 = icmp eq i64 %296, %265
br i1 %297, label %298, label %266
298: ; preds = %295, %261
ret void
}