float ***neuro(const int *const L, const int in, const float *const *const X) {
  const int rozDanych = sizeof(float);
  const int rozWskaz = sizeof(void *);
  const int liczWar = 2;
  int l;
  int *const I = malloc(sizeof(int) * liczWar);
  *(I + 0) = in + 1;
  for (l = 1; l < liczWar; ++l) {
    *(I + l) = *(L + l - 1) + 1;
  }
  srand(time(0));
  float ***const w = malloc(rozWskaz * liczWar);
  for (l = 0; l < liczWar; ++l) {
    const int liczNer = *(L + l);
    *(w + l) = malloc(rozWskaz * liczNer);
    const int liczWejs = *(I + l);
    int n;
    for (n = 0; n < liczNer; ++n) {
      *(*(w + l) + n) = malloc(rozDanych * *(I + l));
      int i;
      for (i = 0; i < liczWejs; ++i) {
        *(*(*(w + l) + n) + i) = los(0.1, 0.9);
      }
    }
  }
  float **const S = malloc(rozWskaz * liczWar);
  float **const Y = malloc(rozWskaz * liczWar);
  float **const FP = malloc(rozWskaz * liczWar);
  float **const D = malloc(rozWskaz * liczWar);
  for (l = 0; l < liczWar; ++l) {
    *(S + l) = malloc(sizeof(float) * *(L + l));
    *(Y + l) = malloc(sizeof(float) * *(L + l));
    *(FP + l) = malloc(sizeof(float) * *(L + l));
    *(D + l) = malloc(sizeof(float) * *(L + l));
  }
  const int liczEpok = 10000;
  const int liczProbek = 150;
  const float a = 0.2f;
  const int liczWejsc = *(I + 0) - 1;
  int e;
  for (e = 0; e < liczEpok; ++e) {
    int p;
    for (p = 0; p < liczProbek; ++p) {
      int n;
      for (n = 0; n < *(L + 0); ++n) {
        *(*(S + 0) + n) = *(*(*(w + 0) + n) + liczWejsc);
        int i;
        for (i = 0; i < liczWejsc; ++i) {
          *(*(S + 0) + n) =
              *(*(S + 0) + n) + *(*(*(w + 0) + n) + i) * *(*(X + p) + i);
        }
        *(*(Y + 0) + n) = (1.0f / (1.0f + exp(-*(*(S + 0) + n))));
      }
      int l;
      for (l = 1; l < liczWar; ++l) {
        const int popWar = l - 1;
        const int liczWejsc = *(I + l) - 1;
        int n;
        for (n = 0; n < *(L + l); ++n) {
          *(*(S + l) + n) = *(*(*(w + l) + n) + liczWejsc);
          int i;
          for (i = 0; i < liczWejsc; ++i) {
            *(*(S + l) + n) =
                *(*(S + l) + n) + *(*(*(w + l) + n) + i) * *(*(Y + popWar) + i);
          }
          *(*(Y + l) + n) = (1.0f / (1.0f + exp(-*(*(S + l) + n))));
        }
      }
      for (n = 0; n < *(L + liczWar - 1); ++n) {
        *(*(FP + liczWar - 1) + n) =
            *(*(Y + liczWar - 1) + n) * (1.0f - *(*(Y + liczWar - 1) + n));
        const float ggg =
            *(*(X + p) + liczWejsc + n) - *(*(Y + liczWar - 1) + n);
        *(*(D + liczWar - 1) + n) = ggg * *(*(FP + liczWar - 1) + n);
      }
      for (l = liczWar - 2; l > -1; --l) {
        int n;
        const int nasWar = l + 1;
        float SD = 0.0f;
        for (n = 0; n < *(L + nasWar); ++n) {
          int i;
          for (i = 0; i < *(I + nasWar); ++i) {
            SD = SD + *(*(D + nasWar) + n) * *(*(*(w + nasWar) + n) + i);
          }
        }
        for (n = 0; n < *(L + l); ++n) {
          *(*(FP + l) + n) = *(*(Y + l) + n) * (1.0f - *(*(Y + l) + n));
          *(*(D + l) + n) = SD * *(*(FP + l) + n);
        }
      }
      for (l = liczWar - 1; l > 0; --l) {
        const int popWar = l - 1;
        const int liczWejsc = *(I + l) - 1;
        int n;
        for (n = 0; n < *(L + l); ++n) {
          int i;
          for (i = 0; i < liczWejsc; ++i) {
            *(*(*(w + l) + n) + i) = *(*(*(w + l) + n) + i) +
                                     a * *(*(D + l) + n) * *(*(Y + popWar) + i);
          }
          *(*(*(w + l) + n) + liczWejsc) =
              *(*(*(w + l) + n) + liczWejsc) + a * *(*(D + l) + n);
        }
      }
      const int tem = *(I + 0) - 1;
      for (n = 0; n < *(L + 0); ++n) {
        *(*(*(w + 0) + n) + tem) =
            *(*(*(w + 0) + n) + liczWejsc) + a * *(*(D + 0) + n);
        int i;
        for (i = 0; i < tem; ++i) {
          *(*(*(w + 0) + n) + i) =
              *(*(*(w + 0) + n) + i) + a * *(*(D + 0) + n) * *(*(X + p) + i);
        }
      }
    }
  }
  for (l = 0; l < liczWar; ++l) {
    free(*(S + l));
    free(*(Y + l));
    free(*(FP + l));
    free(*(D + l));
  }
  free(D);
  free(FP);
  free(Y);
  free(S);
  free(I);
  return w;
}


x86 assembly (clang, -O0):
<neuro>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x4,-0x1c(%rbp)
movl   $0x8,-0x20(%rbp)
movl   $0x2,-0x24(%rbp)
mov    $0x8,%edi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x28(%rbp)
cmpl   $0x2,-0x28(%rbp)
jge    11de <neuro+0x7e>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    -0x4(%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x30(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11ac <neuro+0x4c>
xor    %edi,%edi
mov    $0x0,%al
call   1050 <time@plt>
mov    %eax,%edi
mov    $0x0,%al
call   1040 <srand@plt>
mov    $0x10,%edi
call   1060 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x2,-0x28(%rbp)
jge    1307 <neuro+0x1a7>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x3,%eax
movslq %eax,%rdi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    12f4 <neuro+0x194>
mov    -0x30(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x2,%eax
movslq %eax,%rdi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    12e1 <neuro+0x181>
movsd  0xd6d(%rip),%xmm0
movsd  0xd6d(%rip),%xmm1
mov    $0x2,%al
call   1080 <los@plt>
cvtsi2ss %eax,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    128f <neuro+0x12f>
jmp    12e6 <neuro+0x186>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    124f <neuro+0xef>
jmp    12f9 <neuro+0x199>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1205 <neuro+0xa5>
mov    $0x10,%edi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    $0x10,%edi
call   1060 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    $0x10,%edi
call   1060 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    $0x10,%edi
call   1060 <malloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x2,-0x28(%rbp)
jge    13ee <neuro+0x28e>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movslq (%rax,%rcx,4),%rdi
shl    $0x2,%rdi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movslq (%rax,%rcx,4),%rdi
shl    $0x2,%rdi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movslq (%rax,%rcx,4),%rdi
shl    $0x2,%rdi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x60(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movslq (%rax,%rcx,4),%rdi
shl    $0x2,%rdi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x68(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1346 <neuro+0x1e6>
movl   $0x2710,-0x6c(%rbp)
movl   $0x96,-0x70(%rbp)
movss  0xbfc(%rip),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
cmpl   $0x2710,-0x7c(%rbp)
jge    1d71 <neuro+0xc11>
movl   $0x0,-0x80(%rbp)
cmpl   $0x96,-0x80(%rbp)
jge    1d5e <neuro+0xbfe>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    -0x8(%rbp),%rcx
cmp    (%rcx),%eax
jge    1584 <neuro+0x424>
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
mov    (%rax),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1518 <neuro+0x3b8>
mov    -0x50(%rbp),%rax
mov    (%rax),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    (%rax),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1491 <neuro+0x331>
mov    -0x50(%rbp),%rax
mov    (%rax),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
call   1070 <exp@plt>
movsd  0xabf(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xab3(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1447 <neuro+0x2e7>
movl   $0x1,-0x8c(%rbp)
cmpl   $0x2,-0x8c(%rbp)
jge    176a <neuro+0x60a>
mov    -0x8c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1751 <neuro+0x5f1>
mov    -0x38(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x94(%rbp),%eax
jge    16d5 <neuro+0x575>
mov    -0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1630 <neuro+0x4d0>
mov    -0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
call   1070 <exp@plt>
movsd  0x8fa(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x8ee(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x98(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    15cb <neuro+0x46b>
jmp    1756 <neuro+0x5f6>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    158e <neuro+0x42e>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    -0x8(%rbp),%rcx
cmp    0x4(%rcx),%eax
jge    1852 <neuro+0x6f2>
mov    -0x58(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x84(%rbp),%rcx
movss  0x852(%rip),%xmm1
subss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x78(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x84(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x84(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x84(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1774 <neuro+0x614>
movl   $0x0,-0x8c(%rbp)
cmpl   $0xffffffff,-0x8c(%rbp)
jle    1a3d <neuro+0x8dd>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0xa8(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1951 <neuro+0x7f1>
movl   $0x0,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
mov    -0x30(%rbp),%rcx
movslq -0xa8(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1938 <neuro+0x7d8>
movss  -0xac(%rbp),%xmm1
ff
mov    -0x68(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    18b1 <neuro+0x751>
jmp    193d <neuro+0x7dd>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    188d <neuro+0x72d>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1a24 <neuro+0x8c4>
mov    -0x58(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movss  0x656(%rip),%xmm1
subss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xac(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    195b <neuro+0x7fb>
jmp    1a29 <neuro+0x8c9>
mov    -0x8c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8c(%rbp)
jmp    185c <neuro+0x6fc>
movl   $0x1,-0x8c(%rbp)
cmpl   $0x0,-0x8c(%rbp)
jle    1c04 <neuro+0xaa4>
mov    -0x8c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0xb8(%rbp)
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1beb <neuro+0xa8b>
movl   $0x0,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
cmp    -0xb8(%rbp),%eax
jge    1b60 <neuro+0xa00>
mov    -0x38(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xbc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xbc(%rbp),%rcx
movss  0x502(%rip),%xmm0
mulss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xbc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    1aa8 <neuro+0x948>
mov    -0x38(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xbc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0x457(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xbc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    1a84 <neuro+0x924>
jmp    1bf0 <neuro+0xa90>
mov    -0x8c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8c(%rbp)
jmp    1a47 <neuro+0x8e7>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0xc4(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    -0x8(%rbp),%rcx
cmp    (%rcx),%eax
jge    1d4b <neuro+0xbeb>
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x68(%rbp),%rax
mov    (%rax),%rax
movslq -0x84(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0x39b(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0xc4(%rbp),%eax
jge    1d32 <neuro+0xbd2>
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x68(%rbp),%rax
mov    (%rax),%rax
movslq -0x84(%rbp),%rcx
movss  0x325(%rip),%xmm0
mulss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    1c95 <neuro+0xb35>
jmp    1d37 <neuro+0xbd7>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1c1d <neuro+0xabd>
jmp    1d50 <neuro+0xbf0>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1430 <neuro+0x2d0>
jmp    1d63 <neuro+0xc03>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    141c <neuro+0x2bc>
movl   $0x0,-0x28(%rbp)
cmpl   $0x2,-0x28(%rbp)
jge    1dd4 <neuro+0xc74>
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1d78 <neuro+0xc18>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<neuro>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %rdx,0x58(%rsp)
mov    %rsi,0x10(%rsp)
mov    %rdi,%rbx
movslq (%rdi),%rax
mov    %eax,%ecx
mov    %rcx,0x18(%rsp)
mov    %rax,0x60(%rsp)
lea    0x1(%rax),%r14d
xor    %edi,%edi
xor    %eax,%eax
call   1050 <time@plt>
mov    %eax,%edi
xor    %eax,%eax
call   1040 <srand@plt>
mov    $0x10,%edi
call   1060 <malloc@plt>
mov    %rax,%rbp
mov    %rbx,0x20(%rsp)
movslq (%rbx),%rbx
lea    0x0(,%rbx,8),%rdi
call   1060 <malloc@plt>
mov    %rbp,0x78(%rsp)
mov    %rax,0x68(%rsp)
mov    %rax,0x0(%rbp)
test   %rbx,%rbx
jle    1279 <neuro+0x119>
mov    0x10(%rsp),%rax
add    $0x1,%eax
mov    %ebx,%ecx
mov    %rcx,0x8(%rsp)
lea    0x0(,%rax,4),%ecx
movslq %ecx,%r13
mov    %eax,%ebp
xor    %ebx,%ebx
mov    0x68(%rsp),%r12
jmp    120b <neuro+0xab>
add    $0x1,%rbx
cmp    0x8(%rsp),%rbx
je     1279 <neuro+0x119>
mov    %r13,%rdi
call   1060 <malloc@plt>
mov    %rax,(%r12,%rbx,8)
cmpl   $0x0,0x10(%rsp)
movsd  0xddc(%rip),%xmm1
movsd  0xddc(%rip),%xmm2
js     1200 <neuro+0xa0>
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movaps %xmm1,%xmm0
movaps %xmm2,%xmm1
mov    $0x2,%al
call   1080 <los@plt>
movsd  0xdb3(%rip),%xmm2
movsd  0xda3(%rip),%xmm1
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    (%r12,%rbx,8),%rax
movss  %xmm0,(%rax,%r15,4)
add    $0x1,%r15
cmp    %r15,%rbp
jne    1240 <neuro+0xe0>
jmp    1200 <neuro+0xa0>
mov    0x20(%rsp),%rax
movslq 0x4(%rax),%rbx
lea    0x0(,%rbx,8),%rdi
call   1060 <malloc@plt>
mov    %rbx,%rdx
mov    %rax,%rcx
mov    0x78(%rsp),%rax
mov    %rcx,0x50(%rsp)
mov    %rcx,0x8(%rax)
mov    %r14d,%eax
mov    %rax,0x38(%rsp)
test   %rbx,%rbx
jle    1363 <neuro+0x203>
mov    %edx,%r13d
shl    $0x2,%r14d
movslq %r14d,%rax
mov    %rax,0x8(%rsp)
xor    %ebp,%ebp
mov    0x10(%rsp),%r14
mov    0x50(%rsp),%r12
mov    0x38(%rsp),%r15
jmp    12e9 <neuro+0x189>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %r13,%rbp
je     1358 <neuro+0x1f8>
mov    0x8(%rsp),%rdi
call   1060 <malloc@plt>
mov    %rax,(%r12,%rbp,8)
cmpl   $0x7ffffffe,0x60(%rsp)
7f
movsd  0xcf9(%rip),%xmm1
movsd  0xcf9(%rip),%xmm2
ja     12e0 <neuro+0x180>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movaps %xmm1,%xmm0
movaps %xmm2,%xmm1
mov    $0x2,%al
call   1080 <los@plt>
movsd  0xcd3(%rip),%xmm2
movsd  0xcc3(%rip),%xmm1
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    (%r12,%rbp,8),%rax
movss  %xmm0,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1320 <neuro+0x1c0>
jmp    12e0 <neuro+0x180>
mov    0x20(%rsp),%rax
mov    0x4(%rax),%r13d
jmp    1370 <neuro+0x210>
mov    0x10(%rsp),%r14
mov    0x20(%rsp),%rax
mov    %rdx,%r13
movslq (%rax),%rbx
mov    %rbx,(%rsp)
shl    $0x2,%rbx
mov    %rbx,%rdi
call   1060 <malloc@plt>
mov    %rax,%r12
mov    %rbx,%rdi
call   1060 <malloc@plt>
mov    %rax,%rbx
movslq %r13d,%r15
shl    $0x2,%r15
mov    %r15,%rdi
call   1060 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %r15,%rdi
call   1060 <malloc@plt>
mov    %rbx,%r10
mov    0x20(%rsp),%r8
mov    %rax,0x28(%rsp)
mov    %r14d,%ebx
mov    0x38(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0x88(%rsp)
mov    0x18(%rsp),%rbp
mov    %ebp,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0xd8(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0xd0(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ebx,%edx
and    $0xfffffff8,%edx
mov    %rdx,0xc0(%rsp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0xb8(%rsp)
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %ebx,%r15d
and    $0x3,%r15d
mov    %ebx,%esi
and    $0xfffffffc,%esi
mov    %rsi,0xe8(%rsp)
mov    %r14,%rdi
mov    %ebp,%r14d
and    $0x3,%r14d
mov    %ebp,%esi
and    $0xfffffffc,%esi
mov    %rsi,0xe0(%rsp)
mov    %eax,%esi
and    $0x3,%esi
mov    %rsi,0x90(%rsp)
and    $0xfffffffc,%eax
mov    %rax,0x38(%rsp)
mov    %rcx,%rax
mov    %rcx,0xc8(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xa8(%rsp)
mov    %rdx,%rax
mov    %rdx,0xb0(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0xa0(%rsp)
mov    (%rsp),%rdx
mov    %rbx,%rax
neg    %rax
mov    %rax,0xf0(%rsp)
movslq %edi,%rcx
lea    -0x1(%rbx),%rax
mov    %rax,0x100(%rsp)
lea    -0x1(%rbp),%rax
mov    %rax,0xf8(%rsp)
mov    %rcx,%rax
mov    %rcx,0x8(%rsp)
lea    0x4(%rcx),%rax
mov    %rax,0x98(%rsp)
xor    %eax,%eax
mov    %rax,0x80(%rsp)
mov    0x50(%rsp),%r9
mov    %r10,0x48(%rsp)
mov    %rbx,0x70(%rsp)
mov    %r13,%r11
jmp    150e <neuro+0x3ae>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x80(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x80(%rsp)
cmp    $0x2710,%eax
je     1e74 <neuro+0xd14>
xor    %eax,%eax
mov    %rax,(%rsp)
jmp    1538 <neuro+0x3d8>
cs nopw 0x0(%rax,%rax,1)
mov    (%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,(%rsp)
cmp    $0x96,%rcx
je     14f0 <neuro+0x390>
test   %edx,%edx
jle    1674 <neuro+0x514>
xor    %r13d,%r13d
jmp    15a6 <neuro+0x446>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  0xac9(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
call   1070 <exp@plt>
movsd  0xaa8(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%r12,%r13,4)
add    $0x1,%r13
mov    0x20(%rsp),%r8
movslq (%r8),%rax
cmp    %rax,%r13
mov    0x50(%rsp),%r9
mov    0x48(%rsp),%r10
mov    0x70(%rsp),%rbx
mov    0x18(%rsp),%rbp
jge    1670 <neuro+0x510>
mov    0x68(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    0x8(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm0
cmpl   $0x0,0x10(%rsp)
jle    1550 <neuro+0x3f0>
mov    (%rsp),%rcx
mov    0x58(%rsp),%rdx
mov    (%rdx,%rcx,8),%rcx
cmpq   $0x3,0x100(%rsp)
jae    15e0 <neuro+0x480>
xor    %edx,%edx
jmp    1637 <neuro+0x4d7>
nopl   0x0(%rax)
xor    %edx,%edx
mov    0xe8(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm1
movss  0x4(%rax,%rdx,4),%xmm2
mulss  (%rcx,%rdx,4),%xmm1
mulss  0x4(%rcx,%rdx,4),%xmm2
addss  %xmm0,%xmm1
movss  0x8(%rax,%rdx,4),%xmm3
mulss  0x8(%rcx,%rdx,4),%xmm3
addss  %xmm1,%xmm2
movss  0xc(%rax,%rdx,4),%xmm0
mulss  0xc(%rcx,%rdx,4),%xmm0
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    15f0 <neuro+0x490>
test   %r15,%r15
je     1550 <neuro+0x3f0>
lea    (%rcx,%rdx,4),%rcx
lea    (%rax,%rdx,4),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm1
mulss  (%rcx,%rdx,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%r15
jne    1650 <neuro+0x4f0>
jmp    1550 <neuro+0x3f0>
nopl   0x0(%rax)
mov    0x4(%r8),%r11d
xorps  %xmm7,%xmm7
test   %r11d,%r11d
jle    1800 <neuro+0x6a0>
xor    %ebp,%ebp
jmp    16f1 <neuro+0x591>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorps  0x989(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
call   1070 <exp@plt>
movsd  0x968(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
mov    0x40(%rsp),%rax
movss  %xmm0,(%rax,%rbp,4)
add    $0x1,%rbp
mov    0x20(%rsp),%r8
movslq 0x4(%r8),%r11
cmp    %r11,%rbp
mov    0x50(%rsp),%r9
mov    0x38(%rsp),%rax
mov    0x70(%rsp),%rbx
mov    0x90(%rsp),%rdi
xorps  %xmm7,%xmm7
jge    17b0 <neuro+0x650>
mov    (%r9,%rbp,8),%rax
mov    0x60(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm0
test   %ecx,%ecx
jle    1690 <neuro+0x530>
cmpq   $0x3,0xf8(%rsp)
jae    1720 <neuro+0x5c0>
xor    %ecx,%ecx
jmp    177b <neuro+0x61b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ecx,%ecx
mov    0xe0(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm1
movss  0x4(%rax,%rcx,4),%xmm2
mulss  (%r12,%rcx,4),%xmm1
mulss  0x4(%r12,%rcx,4),%xmm2
addss  %xmm0,%xmm1
movss  0x8(%rax,%rcx,4),%xmm3
mulss  0x8(%r12,%rcx,4),%xmm3
addss  %xmm1,%xmm2
movss  0xc(%rax,%rcx,4),%xmm0
mulss  0xc(%r12,%rcx,4),%xmm0
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1730 <neuro+0x5d0>
test   %r14,%r14
je     1690 <neuro+0x530>
lea    (%r12,%rcx,4),%rdx
lea    (%rax,%rcx,4),%rax
xor    %ecx,%ecx
xchg   %ax,%ax
movss  (%rax,%rcx,4),%xmm1
mulss  (%rdx,%rcx,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1790 <neuro+0x630>
jmp    1690 <neuro+0x530>
nopl   0x0(%rax)
test   %r11d,%r11d
jle    1810 <neuro+0x6b0>
mov    %r11d,%r10d
mov    0x58(%rsp),%rdx
mov    (%rsp),%rcx
mov    (%rdx,%rcx,8),%r13
cmp    $0x8,%r11d
jae    1821 <neuro+0x6c1>
mov    %r11,0x30(%rsp)
xor    %ecx,%ecx
mov    0x40(%rsp),%rsi
mov    0x28(%rsp),%rbp
mov    0x88(%rsp),%r11
movss  0x854(%rip),%xmm3
jmp    18ca <neuro+0x76a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
jmp    19d5 <neuro+0x875>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x48(%rsp),%r10
mov    0x18(%rsp),%rbp
jmp    19d5 <neuro+0x875>
mov    %r11,0x30(%rsp)
mov    %r10d,%ecx
and    $0xfffffff8,%ecx
mov    0x98(%rsp),%rdx
lea    0x0(,%rdx,4),%rsi
add    %r13,%rsi
lea    0x0(,%r10,4),%r11
and    $0xffffffffffffffe0,%r11
xor    %ebp,%ebp
mov    0x40(%rsp),%rdx
mov    0x28(%rsp),%rdi
movaps 0x7d2(%rip),%xmm6
xchg   %ax,%ax
movups (%rdx,%rbp,1),%xmm0
movups 0x10(%rdx,%rbp,1),%xmm1
movaps %xmm6,%xmm2
subps  %xmm0,%xmm2
movaps %xmm6,%xmm3
subps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movups -0x10(%rsi,%rbp,1),%xmm4
movups (%rsi,%rbp,1),%xmm5
subps  %xmm0,%xmm4
mulps  %xmm2,%xmm4
subps  %xmm1,%xmm5
mulps  %xmm3,%xmm5
movups %xmm4,(%rdi,%rbp,1)
movups %xmm5,0x10(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r11
jne    1860 <neuro+0x700>
cmp    %r10,%rcx
mov    %rdx,%rsi
mov    %rdi,%rbp
mov    0x70(%rsp),%rbx
mov    0x88(%rsp),%r11
mov    0x90(%rsp),%rdi
movss  0x778(%rip),%xmm3
je     190c <neuro+0x7ac>
mov    0x8(%rsp),%rdx
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rcx,4),%xmm0
movaps %xmm3,%xmm1
subss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  (%rdx,%rcx,4),%xmm2
subss  %xmm0,%xmm2
mulss  %xmm1,%xmm2
movss  %xmm2,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r10
jne    18e0 <neuro+0x780>
cmpl   $0x0,0x30(%rsp)
jle    19c4 <neuro+0x864>
xorps  %xmm7,%xmm7
xor    %ecx,%ecx
jmp    192d <neuro+0x7cd>
xchg   %ax,%ax
add    $0x1,%rcx
cmp    %r10,%rcx
je     19c0 <neuro+0x860>
cmpl   $0x0,0x18(%rsp)
js     1920 <neuro+0x7c0>
movss  0x0(%rbp,%rcx,4),%xmm0
mov    (%r9,%rcx,8),%rdx
xor    %esi,%esi
cmp    $0x3,%r11
jb     1990 <neuro+0x830>
cs nopw 0x0(%rax,%rax,1)
movss  (%rdx,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
addss  %xmm7,%xmm1
movss  0x4(%rdx,%rsi,4),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  0x8(%rdx,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
addss  %xmm2,%xmm1
movss  0xc(%rdx,%rsi,4),%xmm7
mulss  %xmm0,%xmm7
addss  %xmm1,%xmm7
add    $0x4,%rsi
cmp    %rsi,%rax
jne    1950 <neuro+0x7f0>
test   %rdi,%rdi
je     1920 <neuro+0x7c0>
lea    (%rdx,%rsi,4),%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
addss  %xmm1,%xmm7
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    19a0 <neuro+0x840>
jmp    1920 <neuro+0x7c0>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%al
jmp    19c6 <neuro+0x866>
xor    %eax,%eax
mov    0x48(%rsp),%r10
mov    0x18(%rsp),%rbp
mov    0x30(%rsp),%r11
mov    (%r8),%edx
test   %edx,%edx
mov    %rdx,%r13
jle    1b14 <neuro+0x9b4>
cmp    $0x8,%edx
jae    1a00 <neuro+0x8a0>
xor    %ecx,%ecx
movss  0x64e(%rip),%xmm2
jmp    1af0 <neuro+0x990>
nopw   0x0(%rax,%rax,1)
mov    %edx,%ecx
and    $0xfffffff8,%ecx
movaps %xmm7,%xmm0
shufps $0x0,%xmm7,%xmm0
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1e63 <neuro+0xd03>
mov    %rsi,%rdi
movabs $0x3ffffffffffffffe,%rdx
ff ff 3f
and    %rdx,%rdi
xor    %edx,%edx
movaps 0x5f3(%rip),%xmm5
nopl   (%rax)
movups (%r12,%rdx,4),%xmm1
movups 0x10(%r12,%rdx,4),%xmm2
movaps %xmm5,%xmm3
subps  %xmm1,%xmm3
movaps %xmm5,%xmm4
subps  %xmm2,%xmm4
mulps  %xmm1,%xmm3
mulps  %xmm2,%xmm4
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm4
movups %xmm3,(%r10,%rdx,4)
movups %xmm4,0x10(%r10,%rdx,4)
movups 0x20(%r12,%rdx,4),%xmm1
movups 0x30(%r12,%rdx,4),%xmm2
movaps %xmm5,%xmm3
subps  %xmm1,%xmm3
movaps %xmm5,%xmm4
subps  %xmm2,%xmm4
mulps  %xmm1,%xmm3
mulps  %xmm2,%xmm4
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm4
movups %xmm3,0x20(%r10,%rdx,4)
movups %xmm4,0x30(%r10,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1a40 <neuro+0x8e0>
test   $0x1,%sil
je     1ae0 <neuro+0x980>
movups (%r12,%rdx,4),%xmm1
movups 0x10(%r12,%rdx,4),%xmm2
movaps 0x570(%rip),%xmm4
movaps %xmm4,%xmm3
subps  %xmm1,%xmm3
subps  %xmm2,%xmm4
mulps  %xmm1,%xmm3
mulps  %xmm2,%xmm4
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm4
movups %xmm3,(%r10,%rdx,4)
movups %xmm4,0x10(%r10,%rdx,4)
mov    %r13,%rdx
cmp    %r13,%rcx
movss  0x552(%rip),%xmm2
je     1b14 <neuro+0x9b4>
movss  (%r12,%rcx,4),%xmm0
movaps %xmm2,%xmm1
subss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm7,%xmm1
movss  %xmm1,(%r10,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1af0 <neuro+0x990>
test   %al,%al
je     1c90 <neuro+0xb30>
mov    %r11d,%eax
xor    %ecx,%ecx
jmp    1b62 <neuro+0xa02>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r9,%rcx,8),%rdx
mov    0x28(%rsp),%rsi
movss  (%rsi,%rcx,4),%xmm0
mulss  0x4fe(%rip),%xmm0
mov    0x60(%rsp),%rsi
addss  (%rdx,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rcx
cmp    %rax,%rcx
je     1c90 <neuro+0xb30>
test   %ebp,%ebp
jle    1b30 <neuro+0x9d0>
mov    (%r9,%rcx,8),%rdx
mov    0x28(%rsp),%rsi
movss  (%rsi,%rcx,4),%xmm0
mulss  0x4c8(%rip),%xmm0
cmp    $0x8,%ebp
jae    1b90 <neuro+0xa30>
xor    %esi,%esi
jmp    1c60 <neuro+0xb00>
nopl   0x0(%rax,%rax,1)
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x0,0xd0(%rsp)
je     1c82 <neuro+0xb22>
mov    0xa8(%rsp),%rdi
xor    %esi,%esi
movups (%r12,%rsi,4),%xmm2
movups 0x10(%r12,%rsi,4),%xmm3
mulps  %xmm1,%xmm2
movups (%rdx,%rsi,4),%xmm4
addps  %xmm2,%xmm4
movups 0x10(%rdx,%rsi,4),%xmm2
movups 0x20(%rdx,%rsi,4),%xmm5
movups 0x30(%rdx,%rsi,4),%xmm6
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm4,(%rdx,%rsi,4)
movups %xmm3,0x10(%rdx,%rsi,4)
movups 0x20(%r12,%rsi,4),%xmm2
movups 0x30(%r12,%rsi,4),%xmm3
mulps  %xmm1,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm6,%xmm3
movups %xmm2,0x20(%rdx,%rsi,4)
movups %xmm3,0x30(%rdx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1bb0 <neuro+0xa50>
testb  $0x1,0xc8(%rsp)
01
je     1c42 <neuro+0xae2>
movups (%rdx,%rsi,4),%xmm2
movups 0x10(%rdx,%rsi,4),%xmm3
movups (%r12,%rsi,4),%xmm4
movups 0x10(%r12,%rsi,4),%xmm5
mulps  %xmm1,%xmm4
addps  %xmm2,%xmm4
mulps  %xmm1,%xmm5
addps  %xmm3,%xmm5
movups %xmm4,(%rdx,%rsi,4)
movups %xmm5,0x10(%rdx,%rsi,4)
mov    0xd8(%rsp),%rdi
mov    %rdi,%rsi
cmp    %rbp,%rdi
je     1b30 <neuro+0x9d0>
cs nopw 0x0(%rax,%rax,1)
movss  (%r12,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rdx,%rsi,4),%xmm1
movss  %xmm1,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1c60 <neuro+0xb00>
jmp    1b30 <neuro+0x9d0>
xor    %esi,%esi
testb  $0x1,0xc8(%rsp)
01
jne    1c19 <neuro+0xab9>
jmp    1c42 <neuro+0xae2>
mov    %r13,%rdx
test   %edx,%edx
jle    1520 <neuro+0x3c0>
xor    %eax,%eax
jmp    1cb0 <neuro+0xb50>
nop
add    $0x1,%rax
mov    %r13,%rdx
cmp    %r13,%rax
je     1520 <neuro+0x3c0>
mov    0x68(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
movss  (%r10,%rax,4),%xmm0
mulss  0x37d(%rip),%xmm0
mov    0x8(%rsp),%rdx
addss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,(%rcx,%rdx,4)
cmpl   $0x0,0x10(%rsp)
jle    1ca0 <neuro+0xb40>
mov    (%rsp),%rdx
mov    0x58(%rsp),%rsi
mov    (%rsi,%rdx,8),%rdx
movss  (%r10,%rax,4),%xmm0
mulss  0x34c(%rip),%xmm0
cmpl   $0x8,0x10(%rsp)
jb     1d11 <neuro+0xbb1>
lea    (%rdx,%rbx,4),%rsi
cmp    %rsi,%rcx
jae    1d87 <neuro+0xc27>
lea    (%rcx,%rbx,4),%rsi
cmp    %rsi,%rdx
jae    1d87 <neuro+0xc27>
xor    %edi,%edi
mov    %rdi,%rsi
test   $0x1,%bl
je     1d35 <neuro+0xbd5>
movss  (%rdx,%rdi,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx,%rdi,4),%xmm1
movss  %xmm1,(%rcx,%rdi,4)
mov    %rdi,%rsi
or     $0x1,%rsi
not    %rdi
cmp    0xf0(%rsp),%rdi
je     1ca0 <neuro+0xb40>
cs nopw 0x0(%rax,%rax,1)
movss  (%rdx,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx,%rsi,4),%xmm1
movss  %xmm1,(%rcx,%rsi,4)
movss  0x4(%rdx,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x4(%rcx,%rsi,4),%xmm1
movss  %xmm1,0x4(%rcx,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%rbx
jne    1d50 <neuro+0xbf0>
jmp    1ca0 <neuro+0xb40>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x0,0xb8(%rsp)
je     1e55 <neuro+0xcf5>
mov    0xa0(%rsp),%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%rdx,%rsi,4),%xmm2
movups 0x10(%rdx,%rsi,4),%xmm3
mulps  %xmm1,%xmm2
movups (%rcx,%rsi,4),%xmm4
addps  %xmm2,%xmm4
movups 0x10(%rcx,%rsi,4),%xmm2
movups 0x20(%rcx,%rsi,4),%xmm5
movups 0x30(%rcx,%rsi,4),%xmm6
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm4,(%rcx,%rsi,4)
movups %xmm3,0x10(%rcx,%rsi,4)
movups 0x20(%rdx,%rsi,4),%xmm2
movups 0x30(%rdx,%rsi,4),%xmm3
mulps  %xmm1,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm6,%xmm3
movups %xmm2,0x20(%rcx,%rsi,4)
movups %xmm3,0x30(%rcx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1db0 <neuro+0xc50>
testb  $0x1,0xb0(%rsp)
01
je     1e3c <neuro+0xcdc>
movups (%rcx,%rsi,4),%xmm2
movups 0x10(%rcx,%rsi,4),%xmm3
movups (%rdx,%rsi,4),%xmm4
movups 0x10(%rdx,%rsi,4),%xmm5
mulps  %xmm1,%xmm4
addps  %xmm2,%xmm4
mulps  %xmm1,%xmm5
addps  %xmm3,%xmm5
movups %xmm4,(%rcx,%rsi,4)
movups %xmm5,0x10(%rcx,%rsi,4)
mov    0xc0(%rsp),%rsi
mov    %rsi,%rdi
cmp    %rbx,%rsi
je     1ca0 <neuro+0xb40>
jmp    1d13 <neuro+0xbb3>
xor    %esi,%esi
testb  $0x1,0xb0(%rsp)
01
jne    1e15 <neuro+0xcb5>
jmp    1e3c <neuro+0xcdc>
xor    %edx,%edx
test   $0x1,%sil
jne    1aae <neuro+0x94e>
jmp    1ae0 <neuro+0x980>
mov    %r12,%rdi
mov    %r10,%rbx
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define float*** @neuro(i32* nocapture %0, i32 %1, float** nocapture %2) {
%4 = add nsw i32 %1, 1
%5 = load i32, i32* %0
%6 = add i32 %5, 1
%7 = tail call i32 (i32, ...) bitcast (i32 (...)* @time to i32 (i32, ...)*)(i32 0)
%8 = tail call i32 (i32, ...) bitcast (i32 (...)* @srand to i32 (i32, ...)*)(i32 %7)
%9 = tail call dereferenceable_or_null(16) i8* @malloc(i64 16)
%10 = bitcast i8* %9 to float***
%11 = load i32, i32* %0
%12 = shl nsw i32 %11, 3
%13 = sext i32 %12 to i64
%14 = tail call i8* @malloc(i64 %13)
%15 = bitcast i8* %9 to i8**
store i8* %14, i8** %15
%16 = icmp sgt i32 %11, 0
%17 = bitcast i8* %14 to float**
br i1 %16, label %18, label %40
18: ; preds = %3
%19 = shl nsw i32 %4, 2
%20 = sext i32 %19 to i64
%21 = icmp sgt i32 %1, -1
%22 = zext i32 %11 to i64
%23 = zext i32 %4 to i64
br label %24
24: ; preds = %18, %37
%25 = phi i64 [ 0, %18 ], [ %38, %37 ]
%26 = tail call i8* @malloc(i64 %20)
%27 = getelementptr inbounds float*, float** %17, i64 %25
%28 = bitcast float** %27 to i8**
store i8* %26, i8** %28
br i1 %21, label %29, label %37
29: ; preds = %24, %29
%30 = phi i64 [ %35, %29 ], [ 0, %24 ]
%31 = tail call i32 (double, double, ...) bitcast (i32 (...)* @los to i32 (double, double, ...)*)(double 1.000000e-01, double 9.000000e-01)
%32 = sitofp i32 %31 to float
%33 = load float*, float** %27
%34 = getelementptr inbounds float, float* %33, i64 %30
store float %32, float* %34
%35 = add nuw nsw i64 %30, 1
%36 = icmp eq i64 %35, %23
br i1 %36, label %37, label %29
37: ; preds = %29, %24
%38 = add nuw nsw i64 %25, 1
%39 = icmp eq i64 %38, %22
br i1 %39, label %40, label %24
40: ; preds = %37, %3
%41 = getelementptr inbounds i32, i32* %0, i64 1
%42 = load i32, i32* %41
%43 = shl nsw i32 %42, 3
%44 = sext i32 %43 to i64
%45 = tail call i8* @malloc(i64 %44)
%46 = getelementptr inbounds float**, float*** %10, i64 1
%47 = bitcast float*** %46 to i8**
store i8* %45, i8** %47
%48 = icmp sgt i32 %42, 0
%49 = bitcast i8* %45 to float**
br i1 %48, label %50, label %74
50: ; preds = %40
%51 = shl nsw i32 %6, 2
%52 = sext i32 %51 to i64
%53 = icmp ult i32 %5, 2147483647
%54 = zext i32 %42 to i64
%55 = zext i32 %6 to i64
br label %56
56: ; preds = %69, %50
%57 = phi i64 [ 0, %50 ], [ %70, %69 ]
%58 = tail call i8* @malloc(i64 %52)
%59 = getelementptr inbounds float*, float** %49, i64 %57
%60 = bitcast float** %59 to i8**
store i8* %58, i8** %60
br i1 %53, label %61, label %69
61: ; preds = %56, %61
%62 = phi i64 [ %67, %61 ], [ 0, %56 ]
%63 = tail call i32 (double, double, ...) bitcast (i32 (...)* @los to i32 (double, double, ...)*)(double 1.000000e-01, double 9.000000e-01)
%64 = sitofp i32 %63 to float
%65 = load float*, float** %59
%66 = getelementptr inbounds float, float* %65, i64 %62
store float %64, float* %66
%67 = add nuw nsw i64 %62, 1
%68 = icmp eq i64 %67, %55
br i1 %68, label %69, label %61
69: ; preds = %61, %56
%70 = add nuw nsw i64 %57, 1
%71 = icmp eq i64 %70, %54
br i1 %71, label %72, label %56
72: ; preds = %69
%73 = load i32, i32* %41
br label %74
74: ; preds = %72, %40
%75 = phi i32 [ %73, %72 ], [ %42, %40 ]
%76 = load i32, i32* %0
%77 = sext i32 %76 to i64
%78 = shl nsw i64 %77, 2
%79 = tail call i8* @malloc(i64 %78)
%80 = tail call i8* @malloc(i64 %78)
%81 = sext i32 %75 to i64
%82 = shl nsw i64 %81, 2
%83 = tail call i8* @malloc(i64 %82)
%84 = tail call i8* @malloc(i64 %82)
%85 = sext i32 %1 to i64
%86 = icmp sgt i32 %1, 0
%87 = sext i32 %5 to i64
%88 = icmp sgt i32 %5, 0
%89 = icmp slt i32 %5, 0
%90 = bitcast i8* %79 to float*
%91 = bitcast i8* %83 to float*
%92 = bitcast i8* %84 to float*
%93 = bitcast i8* %80 to float*
%94 = zext i32 %1 to i64
%95 = zext i32 %5 to i64
%96 = zext i32 %6 to i64
%97 = zext i32 %5 to i64
%98 = zext i32 %1 to i64
%99 = add nsw i64 %94, -1
%100 = add nsw i64 %95, -1
%101 = add nsw i64 %96, -1
%102 = and i64 %95, 4294967288
%103 = add nsw i64 %102, -8
%104 = lshr exact i64 %103, 3
%105 = add nuw nsw i64 %104, 1
%106 = and i64 %94, 4294967288
%107 = add nsw i64 %106, -8
%108 = lshr exact i64 %107, 3
%109 = add nuw nsw i64 %108, 1
%110 = and i64 %94, 3
%111 = icmp ult i64 %99, 3
%112 = and i64 %94, 4294967292
%113 = icmp eq i64 %110, 0
%114 = and i64 %95, 3
%115 = icmp ult i64 %100, 3
%116 = and i64 %95, 4294967292
%117 = icmp eq i64 %114, 0
%118 = and i64 %96, 3
%119 = icmp ult i64 %101, 3
%120 = and i64 %96, 4294967292
%121 = icmp eq i64 %118, 0
%122 = icmp ult i32 %5, 8
%123 = and i64 %95, 4294967288
%124 = and i64 %105, 1
%125 = icmp eq i64 %103, 0
%126 = and i64 %105, 4611686018427387902
%127 = icmp eq i64 %124, 0
%128 = icmp eq i64 %123, %95
%129 = icmp ult i32 %1, 8
%130 = and i64 %94, 4294967288
%131 = and i64 %109, 1
%132 = icmp eq i64 %107, 0
%133 = and i64 %109, 4611686018427387902
%134 = icmp eq i64 %131, 0
%135 = icmp eq i64 %130, %94
%136 = and i64 %94, 1
%137 = icmp eq i64 %136, 0
%138 = sub nsw i64 0, %94
br label %139
139: ; preds = %74, %706
%140 = phi i32 [ %75, %74 ], [ %347, %706 ]
%141 = phi i32 [ %76, %74 ], [ %350, %706 ]
%142 = phi i32 [ 0, %74 ], [ %707, %706 ]
br label %143
143: ; preds = %139, %703
%144 = phi i32 [ %140, %139 ], [ %347, %703 ]
%145 = phi i32 [ %141, %139 ], [ %350, %703 ]
%146 = phi i64 [ 0, %139 ], [ %704, %703 ]
%147 = icmp sgt i32 %145, 0
br i1 %147, label %148, label %152
148: ; preds = %143
%149 = getelementptr inbounds float*, float** %2, i64 %146
br label %155
150: ; preds = %209
%151 = load i32, i32* %41
br label %152
152: ; preds = %150, %143
%153 = phi i32 [ %151, %150 ], [ %144, %143 ]
%154 = icmp sgt i32 %153, 0
br i1 %154, label %264, label %346
155: ; preds = %148, %209
%156 = phi i64 [ 0, %148 ], [ %218, %209 ]
%157 = getelementptr inbounds float*, float** %17, i64 %156
%158 = load float*, float** %157
%159 = getelementptr inbounds float, float* %158, i64 %85
%160 = load float, float* %159
br i1 %86, label %161, label %209
161: ; preds = %155
%162 = load float*, float** %149
br i1 %111, label %193, label %163
163: ; preds = %161, %163
%164 = phi float [ %189, %163 ], [ %160, %161 ]
%165 = phi i64 [ %190, %163 ], [ 0, %161 ]
%166 = phi i64 [ %191, %163 ], [ 0, %161 ]
%167 = getelementptr inbounds float, float* %158, i64 %165
%168 = load float, float* %167
%169 = getelementptr inbounds float, float* %162, i64 %165
%170 = load float, float* %169
%171 = tail call float @llvm.fmuladd.f32(float %168, float %170, float %164)
%172 = or i64 %165, 1
%173 = getelementptr inbounds float, float* %158, i64 %172
%174 = load float, float* %173
%175 = getelementptr inbounds float, float* %162, i64 %172
%176 = load float, float* %175
%177 = tail call float @llvm.fmuladd.f32(float %174, float %176, float %171)
%178 = or i64 %165, 2
%179 = getelementptr inbounds float, float* %158, i64 %178
%180 = load float, float* %179
%181 = getelementptr inbounds float, float* %162, i64 %178
%182 = load float, float* %181
%183 = tail call float @llvm.fmuladd.f32(float %180, float %182, float %177)
%184 = or i64 %165, 3
%185 = getelementptr inbounds float, float* %158, i64 %184
%186 = load float, float* %185
%187 = getelementptr inbounds float, float* %162, i64 %184
%188 = load float, float* %187
%189 = tail call float @llvm.fmuladd.f32(float %186, float %188, float %183)
%190 = add nuw nsw i64 %165, 4
%191 = add i64 %166, 4
%192 = icmp eq i64 %191, %112
br i1 %192, label %193, label %163
193: ; preds = %163, %161
%194 = phi float [ undef, %161 ], [ %189, %163 ]
%195 = phi float [ %160, %161 ], [ %189, %163 ]
%196 = phi i64 [ 0, %161 ], [ %190, %163 ]
br i1 %113, label %209, label %197
197: ; preds = %193, %197
%198 = phi float [ %205, %197 ], [ %195, %193 ]
%199 = phi i64 [ %206, %197 ], [ %196, %193 ]
%200 = phi i64 [ %207, %197 ], [ 0, %193 ]
%201 = getelementptr inbounds float, float* %158, i64 %199
%202 = load float, float* %201
%203 = getelementptr inbounds float, float* %162, i64 %199
%204 = load float, float* %203
%205 = tail call float @llvm.fmuladd.f32(float %202, float %204, float %198)
%206 = add nuw nsw i64 %199, 1
%207 = add i64 %200, 1
%208 = icmp eq i64 %207, %110
br i1 %208, label %209, label %197
209: ; preds = %193, %197, %155
%210 = phi float [ %160, %155 ], [ %194, %193 ], [ %205, %197 ]
%211 = fneg float %210
%212 = fpext float %211 to double
%213 = tail call double @exp(double %212)
%214 = fadd double %213, 1.000000e+00
%215 = fdiv double 1.000000e+00, %214
%216 = fptrunc double %215 to float
%217 = getelementptr inbounds float, float* %90, i64 %156
store float %216, float* %217
%218 = add nuw nsw i64 %156, 1
%219 = load i32, i32* %0
%220 = sext i32 %219 to i64
%221 = icmp slt i64 %218, %220
br i1 %221, label %155, label %150
222: ; preds = %317
%223 = icmp sgt i32 %327, 0
br i1 %223, label %224, label %346
224: ; preds = %222
%225 = getelementptr inbounds float*, float** %2, i64 %146
%226 = load float*, float** %225
%227 = getelementptr inbounds float, float* %226, i64 %85
%228 = zext i32 %327 to i64
%229 = icmp ult i32 %327, 8
br i1 %229, label %262, label %230
230: ; preds = %224
%231 = and i64 %228, 4294967288
br label %232
232: ; preds = %232, %230
%233 = phi i64 [ 0, %230 ], [ %258, %232 ]
%234 = getelementptr inbounds float, float* %91, i64 %233
%235 = bitcast float* %234 to <4 x float>*
%236 = load <4 x float>, <4 x float>* %235
%237 = getelementptr inbounds float, float* %234, i64 4
%238 = bitcast float* %237 to <4 x float>*
%239 = load <4 x float>, <4 x float>* %238
%240 = fsub <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>, %236
%241 = fsub <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>, %239
%242 = fmul <4 x float> %236, %240
%243 = fmul <4 x float> %239, %241
%244 = getelementptr inbounds float, float* %227, i64 %233
%245 = bitcast float* %244 to <4 x float>*
%246 = load <4 x float>, <4 x float>* %245
%247 = getelementptr inbounds float, float* %244, i64 4
%248 = bitcast float* %247 to <4 x float>*
%249 = load <4 x float>, <4 x float>* %248
%250 = fsub <4 x float> %246, %236
%251 = fsub <4 x float> %249, %239
%252 = fmul <4 x float> %242, %250
%253 = fmul <4 x float> %243, %251
%254 = getelementptr inbounds float, float* %92, i64 %233
%255 = bitcast float* %254 to <4 x float>*
store <4 x float> %252, <4 x float>* %255
%256 = getelementptr inbounds float, float* %254, i64 4
%257 = bitcast float* %256 to <4 x float>*
store <4 x float> %253, <4 x float>* %257
%258 = add nuw i64 %233, 8
%259 = icmp eq i64 %258, %231
br i1 %259, label %260, label %232
260: ; preds = %232
%261 = icmp eq i64 %231, %228
br i1 %261, label %330, label %262
262: ; preds = %224, %260
%263 = phi i64 [ 0, %224 ], [ %231, %260 ]
br label %333
264: ; preds = %152, %317
%265 = phi i64 [ %326, %317 ], [ 0, %152 ]
%266 = getelementptr inbounds float*, float** %49, i64 %265
%267 = load float*, float** %266
%268 = getelementptr inbounds float, float* %267, i64 %87
%269 = load float, float* %268
br i1 %88, label %270, label %317
270: ; preds = %264
br i1 %115, label %301, label %271
271: ; preds = %270, %271
%272 = phi float [ %297, %271 ], [ %269, %270 ]
%273 = phi i64 [ %298, %271 ], [ 0, %270 ]
%274 = phi i64 [ %299, %271 ], [ 0, %270 ]
%275 = getelementptr inbounds float, float* %267, i64 %273
%276 = load float, float* %275
%277 = getelementptr inbounds float, float* %90, i64 %273
%278 = load float, float* %277
%279 = tail call float @llvm.fmuladd.f32(float %276, float %278, float %272)
%280 = or i64 %273, 1
%281 = getelementptr inbounds float, float* %267, i64 %280
%282 = load float, float* %281
%283 = getelementptr inbounds float, float* %90, i64 %280
%284 = load float, float* %283
%285 = tail call float @llvm.fmuladd.f32(float %282, float %284, float %279)
%286 = or i64 %273, 2
%287 = getelementptr inbounds float, float* %267, i64 %286
%288 = load float, float* %287
%289 = getelementptr inbounds float, float* %90, i64 %286
%290 = load float, float* %289
%291 = tail call float @llvm.fmuladd.f32(float %288, float %290, float %285)
%292 = or i64 %273, 3
%293 = getelementptr inbounds float, float* %267, i64 %292
%294 = load float, float* %293
%295 = getelementptr inbounds float, float* %90, i64 %292
%296 = load float, float* %295
%297 = tail call float @llvm.fmuladd.f32(float %294, float %296, float %291)
%298 = add nuw nsw i64 %273, 4
%299 = add i64 %274, 4
%300 = icmp eq i64 %299, %116
br i1 %300, label %301, label %271
301: ; preds = %271, %270
%302 = phi float [ undef, %270 ], [ %297, %271 ]
%303 = phi float [ %269, %270 ], [ %297, %271 ]
%304 = phi i64 [ 0, %270 ], [ %298, %271 ]
br i1 %117, label %317, label %305
305: ; preds = %301, %305
%306 = phi float [ %313, %305 ], [ %303, %301 ]
%307 = phi i64 [ %314, %305 ], [ %304, %301 ]
%308 = phi i64 [ %315, %305 ], [ 0, %301 ]
%309 = getelementptr inbounds float, float* %267, i64 %307
%310 = load float, float* %309
%311 = getelementptr inbounds float, float* %90, i64 %307
%312 = load float, float* %311
%313 = tail call float @llvm.fmuladd.f32(float %310, float %312, float %306)
%314 = add nuw nsw i64 %307, 1
%315 = add i64 %308, 1
%316 = icmp eq i64 %315, %114
br i1 %316, label %317, label %305
317: ; preds = %301, %305, %264
%318 = phi float [ %269, %264 ], [ %302, %301 ], [ %313, %305 ]
%319 = fneg float %318
%320 = fpext float %319 to double
%321 = tail call double @exp(double %320)
%322 = fadd double %321, 1.000000e+00
%323 = fdiv double 1.000000e+00, %322
%324 = fptrunc double %323 to float
%325 = getelementptr inbounds float, float* %91, i64 %265
store float %324, float* %325
%326 = add nuw nsw i64 %265, 1
%327 = load i32, i32* %41
%328 = sext i32 %327 to i64
%329 = icmp slt i64 %326, %328
br i1 %329, label %264, label %222
330: ; preds = %333, %260
br i1 %223, label %331, label %346
331: ; preds = %330
%332 = zext i32 %327 to i64
br label %431
333: ; preds = %262, %333
%334 = phi i64 [ %344, %333 ], [ %263, %262 ]
%335 = getelementptr inbounds float, float* %91, i64 %334
%336 = load float, float* %335
%337 = fsub float 1.000000e+00, %336
%338 = fmul float %336, %337
%339 = getelementptr inbounds float, float* %227, i64 %334
%340 = load float, float* %339
%341 = fsub float %340, %336
%342 = fmul float %338, %341
%343 = getelementptr inbounds float, float* %92, i64 %334
store float %342, float* %343
%344 = add nuw nsw i64 %334, 1
%345 = icmp eq i64 %344, %228
br i1 %345, label %330, label %333
346: ; preds = %475, %222, %152, %330
%347 = phi i32 [ %327, %330 ], [ %153, %152 ], [ %327, %222 ], [ %327, %475 ]
%348 = phi i1 [ false, %330 ], [ false, %152 ], [ false, %222 ], [ true, %475 ]
%349 = phi float [ 0.000000e+00, %330 ], [ 0.000000e+00, %152 ], [ 0.000000e+00, %222 ], [ %476, %475 ]
%350 = load i32, i32* %0
%351 = icmp sgt i32 %350, 0
br i1 %351, label %352, label %479
352: ; preds = %346
%353 = zext i32 %350 to i64
%354 = icmp ult i32 %350, 8
br i1 %354, label %429, label %355
355: ; preds = %352
%356 = and i64 %353, 4294967288
%357 = insertelement <4 x float> poison, float %349, i64 0
%358 = shufflevector <4 x float> %357, <4 x float> poison, <4 x i32> zeroinitializer
%359 = insertelement <4 x float> poison, float %349, i64 0
%360 = shufflevector <4 x float> %359, <4 x float> poison, <4 x i32> zeroinitializer
%361 = add nsw i64 %356, -8
%362 = lshr exact i64 %361, 3
%363 = add nuw nsw i64 %362, 1
%364 = and i64 %363, 1
%365 = icmp eq i64 %361, 0
br i1 %365, label %407, label %366
366: ; preds = %355
%367 = and i64 %363, 4611686018427387902
br label %368
368: ; preds = %368, %366
%369 = phi i64 [ 0, %366 ], [ %404, %368 ]
%370 = phi i64 [ 0, %366 ], [ %405, %368 ]
%371 = getelementptr inbounds float, float* %90, i64 %369
%372 = bitcast float* %371 to <4 x float>*
%373 = load <4 x float>, <4 x float>* %372
%374 = getelementptr inbounds float, float* %371, i64 4
%375 = bitcast float* %374 to <4 x float>*
%376 = load <4 x float>, <4 x float>* %375
%377 = fsub <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>, %373
%378 = fsub <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>, %376
%379 = fmul <4 x float> %373, %377
%380 = fmul <4 x float> %376, %378
%381 = fmul <4 x float> %358, %379
%382 = fmul <4 x float> %360, %380
%383 = getelementptr inbounds float, float* %93, i64 %369
%384 = bitcast float* %383 to <4 x float>*
store <4 x float> %381, <4 x float>* %384
%385 = getelementptr inbounds float, float* %383, i64 4
%386 = bitcast float* %385 to <4 x float>*
store <4 x float> %382, <4 x float>* %386
%387 = or i64 %369, 8
%388 = getelementptr inbounds float, float* %90, i64 %387
%389 = bitcast float* %388 to <4 x float>*
%390 = load <4 x float>, <4 x float>* %389
%391 = getelementptr inbounds float, float* %388, i64 4
%392 = bitcast float* %391 to <4 x float>*
%393 = load <4 x float>, <4 x float>* %392
%394 = fsub <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>, %390
%395 = fsub <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>, %393
%396 = fmul <4 x float> %390, %394
%397 = fmul <4 x float> %393, %395
%398 = fmul <4 x float> %358, %396
%399 = fmul <4 x float> %360, %397
%400 = getelementptr inbounds float, float* %93, i64 %387
%401 = bitcast float* %400 to <4 x float>*
store <4 x float> %398, <4 x float>* %401
%402 = getelementptr inbounds float, float* %400, i64 4
%403 = bitcast float* %402 to <4 x float>*
store <4 x float> %399, <4 x float>* %403
%404 = add nuw i64 %369, 16
%405 = add i64 %370, 2
%406 = icmp eq i64 %405, %367
br i1 %406, label %407, label %368
407: ; preds = %368, %355
%408 = phi i64 [ 0, %355 ], [ %404, %368 ]
%409 = icmp eq i64 %364, 0
br i1 %409, label %427, label %410
410: ; preds = %407
%411 = getelementptr inbounds float, float* %90, i64 %408
%412 = bitcast float* %411 to <4 x float>*
%413 = load <4 x float>, <4 x float>* %412
%414 = getelementptr inbounds float, float* %411, i64 4
%415 = bitcast float* %414 to <4 x float>*
%416 = load <4 x float>, <4 x float>* %415
%417 = fsub <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>, %413
%418 = fsub <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>, %416
%419 = fmul <4 x float> %413, %417
%420 = fmul <4 x float> %416, %418
%421 = fmul <4 x float> %358, %419
%422 = fmul <4 x float> %360, %420
%423 = getelementptr inbounds float, float* %93, i64 %408
%424 = bitcast float* %423 to <4 x float>*
store <4 x float> %421, <4 x float>* %424
%425 = getelementptr inbounds float, float* %423, i64 4
%426 = bitcast float* %425 to <4 x float>*
store <4 x float> %422, <4 x float>* %426
br label %427
427: ; preds = %407, %410
%428 = icmp eq i64 %356, %353
br i1 %428, label %479, label %429
429: ; preds = %352, %427
%430 = phi i64 [ 0, %352 ], [ %356, %427 ]
br label %482
431: ; preds = %331, %475
%432 = phi i64 [ 0, %331 ], [ %477, %475 ]
%433 = phi float [ 0.000000e+00, %331 ], [ %476, %475 ]
br i1 %89, label %475, label %434
434: ; preds = %431
%435 = getelementptr inbounds float, float* %92, i64 %432
%436 = load float, float* %435
%437 = getelementptr inbounds float*, float** %49, i64 %432
%438 = load float*, float** %437
br i1 %119, label %461, label %439
439: ; preds = %434, %439
%440 = phi i64 [ %458, %439 ], [ 0, %434 ]
%441 = phi float [ %457, %439 ], [ %433, %434 ]
%442 = phi i64 [ %459, %439 ], [ 0, %434 ]
%443 = getelementptr inbounds float, float* %438, i64 %440
%444 = load float, float* %443
%445 = tail call float @llvm.fmuladd.f32(float %436, float %444, float %441)
%446 = or i64 %440, 1
%447 = getelementptr inbounds float, float* %438, i64 %446
%448 = load float, float* %447
%449 = tail call float @llvm.fmuladd.f32(float %436, float %448, float %445)
%450 = or i64 %440, 2
%451 = getelementptr inbounds float, float* %438, i64 %450
%452 = load float, float* %451
%453 = tail call float @llvm.fmuladd.f32(float %436, float %452, float %449)
%454 = or i64 %440, 3
%455 = getelementptr inbounds float, float* %438, i64 %454
%456 = load float, float* %455
%457 = tail call float @llvm.fmuladd.f32(float %436, float %456, float %453)
%458 = add nuw nsw i64 %440, 4
%459 = add i64 %442, 4
%460 = icmp eq i64 %459, %120
br i1 %460, label %461, label %439
461: ; preds = %439, %434
%462 = phi float [ undef, %434 ], [ %457, %439 ]
%463 = phi i64 [ 0, %434 ], [ %458, %439 ]
%464 = phi float [ %433, %434 ], [ %457, %439 ]
br i1 %121, label %475, label %465
465: ; preds = %461, %465
%466 = phi i64 [ %472, %465 ], [ %463, %461 ]
%467 = phi float [ %471, %465 ], [ %464, %461 ]
%468 = phi i64 [ %473, %465 ], [ 0, %461 ]
%469 = getelementptr inbounds float, float* %438, i64 %466
%470 = load float, float* %469
%471 = tail call float @llvm.fmuladd.f32(float %436, float %470, float %467)
%472 = add nuw nsw i64 %466, 1
%473 = add i64 %468, 1
%474 = icmp eq i64 %473, %118
br i1 %474, label %475, label %465
475: ; preds = %461, %465, %431
%476 = phi float [ %433, %431 ], [ %462, %461 ], [ %471, %465 ]
%477 = add nuw nsw i64 %432, 1
%478 = icmp eq i64 %477, %332
br i1 %478, label %346, label %431
479: ; preds = %482, %427, %346
br i1 %348, label %480, label %492
480: ; preds = %479
%481 = zext i32 %347 to i64
br label %496
482: ; preds = %429, %482
%483 = phi i64 [ %490, %482 ], [ %430, %429 ]
%484 = getelementptr inbounds float, float* %90, i64 %483
%485 = load float, float* %484
%486 = fsub float 1.000000e+00, %485
%487 = fmul float %485, %486
%488 = fmul float %349, %487
%489 = getelementptr inbounds float, float* %93, i64 %483
store float %488, float* %489
%490 = add nuw nsw i64 %483, 1
%491 = icmp eq i64 %490, %353
br i1 %491, label %479, label %482
492: ; preds = %579, %479
br i1 %351, label %493, label %703
493: ; preds = %492
%494 = getelementptr inbounds float*, float** %2, i64 %146
%495 = zext i32 %350 to i64
br label %589
496: ; preds = %480, %579
%497 = phi i64 [ 0, %480 ], [ %587, %579 ]
br i1 %88, label %498, label %579
498: ; preds = %496
%499 = getelementptr inbounds float*, float** %49, i64 %497
%500 = load float*, float** %499
%501 = getelementptr inbounds float, float* %92, i64 %497
%502 = load float, float* %501
%503 = fmul float %502, 0x3FC99999A0000000
br i1 %122, label %568, label %504
504: ; preds = %498
%505 = insertelement <4 x float> poison, float %503, i64 0
%506 = shufflevector <4 x float> %505, <4 x float> poison, <4 x i32> zeroinitializer
%507 = insertelement <4 x float> poison, float %503, i64 0
%508 = shufflevector <4 x float> %507, <4 x float> poison, <4 x i32> zeroinitializer
br i1 %125, label %548, label %509
509: ; preds = %504, %509
%510 = phi i64 [ %545, %509 ], [ 0, %504 ]
%511 = phi i64 [ %546, %509 ], [ 0, %504 ]
%512 = getelementptr inbounds float, float* %500, i64 %510
%513 = bitcast float* %512 to <4 x float>*
%514 = load <4 x float>, <4 x float>* %513
%515 = getelementptr inbounds float, float* %512, i64 4
%516 = bitcast float* %515 to <4 x float>*
%517 = load <4 x float>, <4 x float>* %516
%518 = getelementptr inbounds float, float* %90, i64 %510
%519 = bitcast float* %518 to <4 x float>*
%520 = load <4 x float>, <4 x float>* %519
%521 = getelementptr inbounds float, float* %518, i64 4
%522 = bitcast float* %521 to <4 x float>*
%523 = load <4 x float>, <4 x float>* %522
%524 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %506, <4 x float> %520, <4 x float> %514)
%525 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %508, <4 x float> %523, <4 x float> %517)
%526 = bitcast float* %512 to <4 x float>*
store <4 x float> %524, <4 x float>* %526
%527 = bitcast float* %515 to <4 x float>*
store <4 x float> %525, <4 x float>* %527
%528 = or i64 %510, 8
%529 = getelementptr inbounds float, float* %500, i64 %528
%530 = bitcast float* %529 to <4 x float>*
%531 = load <4 x float>, <4 x float>* %530
%532 = getelementptr inbounds float, float* %529, i64 4
%533 = bitcast float* %532 to <4 x float>*
%534 = load <4 x float>, <4 x float>* %533
%535 = getelementptr inbounds float, float* %90, i64 %528
%536 = bitcast float* %535 to <4 x float>*
%537 = load <4 x float>, <4 x float>* %536
%538 = getelementptr inbounds float, float* %535, i64 4
%539 = bitcast float* %538 to <4 x float>*
%540 = load <4 x float>, <4 x float>* %539
%541 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %506, <4 x float> %537, <4 x float> %531)
%542 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %508, <4 x float> %540, <4 x float> %534)
%543 = bitcast float* %529 to <4 x float>*
store <4 x float> %541, <4 x float>* %543
%544 = bitcast float* %532 to <4 x float>*
store <4 x float> %542, <4 x float>* %544
%545 = add nuw i64 %510, 16
%546 = add i64 %511, 2
%547 = icmp eq i64 %546, %126
br i1 %547, label %548, label %509
548: ; preds = %509, %504
%549 = phi i64 [ 0, %504 ], [ %545, %509 ]
br i1 %127, label %567, label %550
550: ; preds = %548
%551 = getelementptr inbounds float, float* %500, i64 %549
%552 = bitcast float* %551 to <4 x float>*
%553 = load <4 x float>, <4 x float>* %552
%554 = getelementptr inbounds float, float* %551, i64 4
%555 = bitcast float* %554 to <4 x float>*
%556 = load <4 x float>, <4 x float>* %555
%557 = getelementptr inbounds float, float* %90, i64 %549
%558 = bitcast float* %557 to <4 x float>*
%559 = load <4 x float>, <4 x float>* %558
%560 = getelementptr inbounds float, float* %557, i64 4
%561 = bitcast float* %560 to <4 x float>*
%562 = load <4 x float>, <4 x float>* %561
%563 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %506, <4 x float> %559, <4 x float> %553)
%564 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %508, <4 x float> %562, <4 x float> %556)
%565 = bitcast float* %551 to <4 x float>*
store <4 x float> %563, <4 x float>* %565
%566 = bitcast float* %554 to <4 x float>*
store <4 x float> %564, <4 x float>* %566
br label %567
567: ; preds = %548, %550
br i1 %128, label %579, label %568
568: ; preds = %498, %567
%569 = phi i64 [ 0, %498 ], [ %123, %567 ]
br label %570
570: ; preds = %568, %570
%571 = phi i64 [ %577, %570 ], [ %569, %568 ]
%572 = getelementptr inbounds float, float* %500, i64 %571
%573 = load float, float* %572
%574 = getelementptr inbounds float, float* %90, i64 %571
%575 = load float, float* %574
%576 = tail call float @llvm.fmuladd.f32(float %503, float %575, float %573)
store float %576, float* %572
%577 = add nuw nsw i64 %571, 1
%578 = icmp eq i64 %577, %97
br i1 %578, label %579, label %570
579: ; preds = %570, %567, %496
%580 = getelementptr inbounds float*, float** %49, i64 %497
%581 = load float*, float** %580
%582 = getelementptr inbounds float, float* %581, i64 %87
%583 = load float, float* %582
%584 = getelementptr inbounds float, float* %92, i64 %497
%585 = load float, float* %584
%586 = tail call float @llvm.fmuladd.f32(float %585, float 0x3FC99999A0000000, float %583)
store float %586, float* %582
%587 = add nuw nsw i64 %497, 1
%588 = icmp eq i64 %587, %481
br i1 %588, label %492, label %496
589: ; preds = %493, %700
%590 = phi i64 [ 0, %493 ], [ %701, %700 ]
%591 = getelementptr inbounds float*, float** %17, i64 %590
%592 = load float*, float** %591
%593 = getelementptr inbounds float, float* %592, i64 %85
%594 = load float, float* %593
%595 = getelementptr inbounds float, float* %93, i64 %590
%596 = load float, float* %595
%597 = tail call float @llvm.fmuladd.f32(float %596, float 0x3FC99999A0000000, float %594)
store float %597, float* %593
br i1 %86, label %598, label %700
598: ; preds = %589
%599 = load float*, float** %494
%600 = load float, float* %595
%601 = fmul float %600, 0x3FC99999A0000000
br i1 %129, label %672, label %602
602: ; preds = %598
%603 = getelementptr float, float* %592, i64 %94
%604 = getelementptr float, float* %599, i64 %94
%605 = icmp ult float* %592, %604
%606 = icmp ult float* %599, %603
%607 = and i1 %605, %606
br i1 %607, label %672, label %608
608: ; preds = %602
%609 = insertelement <4 x float> poison, float %601, i64 0
%610 = shufflevector <4 x float> %609, <4 x float> poison, <4 x i32> zeroinitializer
%611 = insertelement <4 x float> poison, float %601, i64 0
%612 = shufflevector <4 x float> %611, <4 x float> poison, <4 x i32> zeroinitializer
br i1 %132, label %652, label %613
613: ; preds = %608, %613
%614 = phi i64 [ %649, %613 ], [ 0, %608 ]
%615 = phi i64 [ %650, %613 ], [ 0, %608 ]
%616 = getelementptr inbounds float, float* %592, i64 %614
%617 = bitcast float* %616 to <4 x float>*
%618 = load <4 x float>, <4 x float>* %617
%619 = getelementptr inbounds float, float* %616, i64 4
%620 = bitcast float* %619 to <4 x float>*
%621 = load <4 x float>, <4 x float>* %620
%622 = getelementptr inbounds float, float* %599, i64 %614
%623 = bitcast float* %622 to <4 x float>*
%624 = load <4 x float>, <4 x float>* %623
%625 = getelementptr inbounds float, float* %622, i64 4
%626 = bitcast float* %625 to <4 x float>*
%627 = load <4 x float>, <4 x float>* %626
%628 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %610, <4 x float> %624, <4 x float> %618)
%629 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %612, <4 x float> %627, <4 x float> %621)
%630 = bitcast float* %616 to <4 x float>*
store <4 x float> %628, <4 x float>* %630
%631 = bitcast float* %619 to <4 x float>*
store <4 x float> %629, <4 x float>* %631
%632 = or i64 %614, 8
%633 = getelementptr inbounds float, float* %592, i64 %632
%634 = bitcast float* %633 to <4 x float>*
%635 = load <4 x float>, <4 x float>* %634
%636 = getelementptr inbounds float, float* %633, i64 4
%637 = bitcast float* %636 to <4 x float>*
%638 = load <4 x float>, <4 x float>* %637
%639 = getelementptr inbounds float, float* %599, i64 %632
%640 = bitcast float* %639 to <4 x float>*
%641 = load <4 x float>, <4 x float>* %640
%642 = getelementptr inbounds float, float* %639, i64 4
%643 = bitcast float* %642 to <4 x float>*
%644 = load <4 x float>, <4 x float>* %643
%645 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %610, <4 x float> %641, <4 x float> %635)
%646 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %612, <4 x float> %644, <4 x float> %638)
%647 = bitcast float* %633 to <4 x float>*
store <4 x float> %645, <4 x float>* %647
%648 = bitcast float* %636 to <4 x float>*
store <4 x float> %646, <4 x float>* %648
%649 = add nuw i64 %614, 16
%650 = add i64 %615, 2
%651 = icmp eq i64 %650, %133
br i1 %651, label %652, label %613
652: ; preds = %613, %608
%653 = phi i64 [ 0, %608 ], [ %649, %613 ]
br i1 %134, label %671, label %654
654: ; preds = %652
%655 = getelementptr inbounds float, float* %592, i64 %653
%656 = bitcast float* %655 to <4 x float>*
%657 = load <4 x float>, <4 x float>* %656
%658 = getelementptr inbounds float, float* %655, i64 4
%659 = bitcast float* %658 to <4 x float>*
%660 = load <4 x float>, <4 x float>* %659
%661 = getelementptr inbounds float, float* %599, i64 %653
%662 = bitcast float* %661 to <4 x float>*
%663 = load <4 x float>, <4 x float>* %662
%664 = getelementptr inbounds float, float* %661, i64 4
%665 = bitcast float* %664 to <4 x float>*
%666 = load <4 x float>, <4 x float>* %665
%667 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %610, <4 x float> %663, <4 x float> %657)
%668 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %612, <4 x float> %666, <4 x float> %660)
%669 = bitcast float* %655 to <4 x float>*
store <4 x float> %667, <4 x float>* %669
%670 = bitcast float* %658 to <4 x float>*
store <4 x float> %668, <4 x float>* %670
br label %671
671: ; preds = %652, %654
br i1 %135, label %700, label %672
672: ; preds = %602, %598, %671
%673 = phi i64 [ 0, %602 ], [ 0, %598 ], [ %130, %671 ]
%674 = xor i64 %673, -1
br i1 %137, label %682, label %675
675: ; preds = %672
%676 = getelementptr inbounds float, float* %592, i64 %673
%677 = load float, float* %676
%678 = getelementptr inbounds float, float* %599, i64 %673
%679 = load float, float* %678
%680 = tail call float @llvm.fmuladd.f32(float %601, float %679, float %677)
store float %680, float* %676
%681 = or i64 %673, 1
br label %682
682: ; preds = %675, %672
%683 = phi i64 [ %673, %672 ], [ %681, %675 ]
%684 = icmp eq i64 %674, %138
br i1 %684, label %700, label %685
685: ; preds = %682, %685
%686 = phi i64 [ %698, %685 ], [ %683, %682 ]
%687 = getelementptr inbounds float, float* %592, i64 %686
%688 = load float, float* %687
%689 = getelementptr inbounds float, float* %599, i64 %686
%690 = load float, float* %689
%691 = tail call float @llvm.fmuladd.f32(float %601, float %690, float %688)
store float %691, float* %687
%692 = add nuw nsw i64 %686, 1
%693 = getelementptr inbounds float, float* %592, i64 %692
%694 = load float, float* %693
%695 = getelementptr inbounds float, float* %599, i64 %692
%696 = load float, float* %695
%697 = tail call float @llvm.fmuladd.f32(float %601, float %696, float %694)
store float %697, float* %693
%698 = add nuw nsw i64 %686, 2
%699 = icmp eq i64 %698, %98
br i1 %699, label %700, label %685
700: ; preds = %682, %685, %671, %589
%701 = add nuw nsw i64 %590, 1
%702 = icmp eq i64 %701, %495
br i1 %702, label %703, label %589
703: ; preds = %700, %492
%704 = add nuw nsw i64 %146, 1
%705 = icmp eq i64 %704, 150
br i1 %705, label %706, label %143
706: ; preds = %703
%707 = add nuw nsw i32 %142, 1
%708 = icmp eq i32 %707, 10000
br i1 %708, label %709, label %139
709: ; preds = %706
tail call void @free(i8* %79)
tail call void @free(i8* %80)
tail call void @free(i8* %83)
tail call void @free(i8* %84)
ret float*** %10
}