float **ssn_sprawdz(const int liczbaWarstw, const int *const warstwy,
                    const int in, const float *const *const *const ssn,
                    const int liczbaProbek, const float *const *const probki) {
  int *const I = malloc(liczbaWarstw * sizeof(int));
  *(I + 0) = in + 1;
  for (int w = 1; w < liczbaWarstw; ++w) {
    *(I + w) = *(warstwy + w - 1) + 1;
  }
  float **const Y = malloc(liczbaWarstw * sizeof(float *));
  for (int w = 0; w < liczbaWarstw; ++w) {
    *(Y + w) = malloc(*(warstwy + w) * sizeof(float));
  }
  float **const E = malloc(liczbaProbek * sizeof(float *));
  const int liczWejsc = *(I + 0) - 1;
  const int liczWyjsc = *(warstwy + liczbaWarstw - 1);
  for (int p = 0; p < liczbaProbek; ++p) {
    for (int n = 0; n < *(warstwy + 0); ++n) {
      float s = *(*(*(ssn + 0) + n) + liczWejsc);
      for (int i = 0; i < liczWejsc; ++i) {
        s = s + *(*(*(ssn + 0) + n) + i) * *(*(probki + p) + i);
      }
      *(*(Y + 0) + n) = (1.0f / (1.0f + exp(-s)));
    }
    for (int w = 1; w < liczbaWarstw; ++w) {
      const int popWar = w - 1;
      const int liczWejsc = *(I + w) - 1;
      for (int n = 0; n < *(warstwy + w); ++n) {
        float s = *(*(*(ssn + w) + n) + liczWejsc);
        for (int i = 0; i < liczWejsc; ++i) {
          s = s + *(*(*(ssn + w) + n) + i) * *(*(Y + popWar) + i);
        }
        *(*(Y + w) + n) = (1.0f / (1.0f + exp(-s)));
      }
    }
    *(E + p) = malloc(liczWyjsc * sizeof(float));
    printf("%d.", p + 1);
    for (int n = 0; n < liczWyjsc; ++n) {
      *(*(E + p) + n) = *(*(Y + liczbaWarstw - 1) + n);
      printf("  %f", *(*(E + p) + n));
    }
    printf("\n");
  }
  for (int w = 0; w < liczbaWarstw; ++w) {
    free(*(Y + w));
  }
  free(I);
  return E;
}


x86 assembly (clang, -O0):
<ssn_sprawdz>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
movslq -0x4(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11b9 <ssn_sprawdz+0x79>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    -0x4(%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1185 <ssn_sprawdz+0x45>
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    120f <ssn_sprawdz+0xcf>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movslq (%rax,%rcx,4),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x48(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11d1 <ssn_sprawdz+0x91>
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    -0x4(%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1564 <ssn_sprawdz+0x424>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1336 <ssn_sprawdz+0x1f6>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    12e1 <ssn_sprawdz+0x1a1>
movss  -0x6c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1288 <ssn_sprawdz+0x148>
movss  -0x6c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <exp@plt>
movsd  0xcfc(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xcf0(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1255 <ssn_sprawdz+0x115>
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1490 <ssn_sprawdz+0x350>
mov    -0x74(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x7c(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x74(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    147d <ssn_sprawdz+0x33d>
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x7c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1420 <ssn_sprawdz+0x2e0>
movss  -0x84(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    13ad <ssn_sprawdz+0x26d>
movss  -0x84(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <exp@plt>
movsd  0xbba(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0xbae(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x80(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    136a <ssn_sprawdz+0x22a>
jmp    1482 <ssn_sprawdz+0x342>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    133d <ssn_sprawdz+0x1fd>
movslq -0x60(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x64(%rbp),%esi
add    $0x1,%esi
lea    0xb4f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1548 <ssn_sprawdz+0x408>
mov    -0x48(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    -0x8(%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xadf(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    14ca <ssn_sprawdz+0x38a>
lea    0xac2(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1242 <ssn_sprawdz+0x102>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15a5 <ssn_sprawdz+0x465>
mov    -0x48(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    156e <ssn_sprawdz+0x42e>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ssn_sprawdz>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9,%r14
mov    %r8d,0x20(%rsp)
mov    %rcx,0x58(%rsp)
mov    %edx,%r12d
mov    %rsi,%r13
mov    %edi,%ebp
movslq %edi,%rbx
lea    0x0(,%rbx,4),%rdi
call   1060 <malloc@plt>
lea    0x1(%r12),%ecx
mov    %ecx,(%rax)
mov    %ebp,0xc(%rsp)
mov    %ebp,%r15d
mov    %rbx,0x18(%rsp)
cmp    $0x2,%ebx
jl     1294 <ssn_sprawdz+0x144>
lea    -0x1(%r15),%rcx
mov    $0x1,%ebp
cmp    $0x8,%rcx
jb     1280 <ssn_sprawdz+0x130>
mov    %rcx,%rbp
and    $0xfffffffffffffff8,%rbp
lea    -0x8(%rbp),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1752 <ssn_sprawdz+0x602>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
mov    $0xc,%edx
pcmpeqd %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x30(%r13,%rdx,4),%xmm1
movdqu -0x20(%r13,%rdx,4),%xmm2
psubd  %xmm0,%xmm1
psubd  %xmm0,%xmm2
movdqu %xmm1,-0x2c(%rax,%rdx,4)
movdqu %xmm2,-0x1c(%rax,%rdx,4)
movdqu -0x10(%r13,%rdx,4),%xmm1
movdqu 0x0(%r13,%rdx,4),%xmm2
psubd  %xmm0,%xmm1
psubd  %xmm0,%xmm2
movdqu %xmm1,-0xc(%rax,%rdx,4)
movdqu %xmm2,0x4(%rax,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    11f0 <ssn_sprawdz+0xa0>
add    $0xfffffffffffffff5,%rdx
test   $0x1,%sil
je     126d <ssn_sprawdz+0x11d>
movdqu -0x4(%r13,%rdx,4),%xmm0
movdqu 0xc(%r13,%rdx,4),%xmm1
pcmpeqd %xmm2,%xmm2
psubd  %xmm2,%xmm0
psubd  %xmm2,%xmm1
movdqu %xmm0,(%rax,%rdx,4)
movdqu %xmm1,0x10(%rax,%rdx,4)
cmp    %rbp,%rcx
je     1294 <ssn_sprawdz+0x144>
or     $0x1,%rbp
cs nopw 0x0(%rax,%rax,1)
mov    -0x4(%r13,%rbp,4),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r15
jne    1280 <ssn_sprawdz+0x130>
mov    %rax,0x30(%rsp)
mov    0x18(%rsp),%rbp
lea    0x0(,%rbp,8),%rdi
call   1060 <malloc@plt>
mov    %rax,%rbx
test   %ebp,%ebp
jle    12db <ssn_sprawdz+0x18b>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq 0x0(%r13,%rbp,4),%rdi
shl    $0x2,%rdi
call   1060 <malloc@plt>
mov    %rax,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r15
jne    12c0 <ssn_sprawdz+0x170>
mov    %rbx,(%rsp)
mov    0x20(%rsp),%ebx
movslq %ebx,%rbp
lea    0x0(,%rbp,8),%rdi
call   1060 <malloc@plt>
mov    %rax,0x28(%rsp)
test   %ebp,%ebp
jle    1708 <ssn_sprawdz+0x5b8>
mov    0x18(%rsp),%rax
movslq -0x4(%r13,%rax,4),%rax
movslq %r12d,%rcx
mov    %rcx,0x98(%rsp)
lea    0x0(,%rax,4),%rcx
mov    %rcx,0x70(%rsp)
mov    %ebx,%ecx
mov    %rcx,0x68(%rsp)
mov    %r12d,%esi
mov    %rax,0x78(%rsp)
mov    %eax,%eax
mov    %rax,0x60(%rsp)
lea    -0x1(%rsi),%rax
mov    %rax,0x90(%rsp)
mov    %esi,%eax
and    $0x3,%eax
mov    %rax,0x38(%rsp)
and    $0xfffffffc,%esi
lea    0xcc4(%rip),%rax
xor    %ecx,%ecx
mov    %rcx,0x10(%rsp)
mov    %rsi,0x48(%rsp)
mov    %r15,0x40(%rsp)
mov    %r14,0x88(%rsp)
mov    %r12,0x80(%rsp)
mov    %r13,0x50(%rsp)
jmp    13b7 <ssn_sprawdz+0x267>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0x10(%rsp),%rax
cmp    0x68(%rsp),%rax
mov    0x88(%rsp),%r14
mov    0x80(%rsp),%r12
mov    0x48(%rsp),%rsi
mov    %r15,%rax
mov    0x40(%rsp),%r15
je     1708 <ssn_sprawdz+0x5b8>
cmpl   $0x0,0x0(%r13)
jle    14f0 <ssn_sprawdz+0x3a0>
mov    (%rsp),%rax
mov    (%rax),%rbx
xor    %ebp,%ebp
jmp    1419 <ssn_sprawdz+0x2c9>
nopl   (%rax)
xorps  0xc29(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
call   1070 <exp@plt>
movsd  0xc28(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rbx,%rbp,4)
add    $0x1,%rbp
movslq 0x0(%r13),%rax
cmp    %rax,%rbp
mov    0x48(%rsp),%rsi
lea    0xc09(%rip),%rax
jge    14f0 <ssn_sprawdz+0x3a0>
mov    0x58(%rsp),%rax
mov    (%rax),%rax
mov    (%rax,%rbp,8),%rax
mov    0x98(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm0
test   %r12d,%r12d
jle    13d0 <ssn_sprawdz+0x280>
mov    0x10(%rsp),%rcx
mov    (%r14,%rcx,8),%rcx
cmpq   $0x3,0x90(%rsp)
jae    1460 <ssn_sprawdz+0x310>
xor    %edx,%edx
mov    0x38(%rsp),%rdi
jmp    14b7 <ssn_sprawdz+0x367>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %edx,%edx
mov    0x38(%rsp),%rdi
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    1470 <ssn_sprawdz+0x320>
test   %rdi,%rdi
je     13d0 <ssn_sprawdz+0x280>
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,%rdi
jne    14d0 <ssn_sprawdz+0x380>
jmp    13d0 <ssn_sprawdz+0x280>
nopl   0x0(%rax)
cmpl   $0x2,0xc(%rsp)
jl     1680 <ssn_sprawdz+0x530>
mov    $0x1,%ebx
jmp    1527 <ssn_sprawdz+0x3d7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbx
mov    0x40(%rsp),%r15
cmp    %r15,%rbx
mov    0x50(%rsp),%r13
je     1680 <ssn_sprawdz+0x530>
cmpl   $0x0,0x0(%r13,%rbx,4)
jle    1510 <ssn_sprawdz+0x3c0>
mov    0x30(%rsp),%rax
mov    (%rax,%rbx,4),%r13d
lea    -0x1(%r13),%eax
movslq %eax,%r12
mov    (%rsp),%rax
mov    (%rax,%rbx,8),%rax
mov    %rax,0x20(%rsp)
mov    %r12d,%r15d
lea    -0x1(%r15),%rax
mov    %rax,0xa0(%rsp)
mov    %r15d,%ebp
and    $0x3,%ebp
and    $0xfffffffc,%r15d
xor    %r14d,%r14d
jmp    15bf <ssn_sprawdz+0x46f>
nopw   0x0(%rax,%rax,1)
xorps  0xa89(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
call   1070 <exp@plt>
movsd  0xa88(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
mov    0x20(%rsp),%rax
movss  %xmm0,(%rax,%r14,4)
add    $0x1,%r14
mov    0x50(%rsp),%rax
movslq (%rax,%rbx,4),%rax
cmp    %rax,%r14
lea    0xa63(%rip),%rax
jge    1510 <ssn_sprawdz+0x3c0>
mov    0x58(%rsp),%rax
mov    (%rax,%rbx,8),%rax
mov    (%rax,%r14,8),%rax
movss  (%rax,%r12,4),%xmm0
cmp    $0x2,%r13d
jl     1570 <ssn_sprawdz+0x420>
mov    (%rsp),%rcx
mov    -0x8(%rcx,%rbx,8),%rcx
cmpq   $0x3,0xa0(%rsp)
jae    15f0 <ssn_sprawdz+0x4a0>
xor    %edx,%edx
jmp    1647 <ssn_sprawdz+0x4f7>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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,%r15
jne    1600 <ssn_sprawdz+0x4b0>
test   %rbp,%rbp
je     1570 <ssn_sprawdz+0x420>
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,%rbp
jne    1660 <ssn_sprawdz+0x510>
jmp    1570 <ssn_sprawdz+0x420>
nopl   0x0(%rax)
mov    %rax,%r15
mov    0x70(%rsp),%rdi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    0x28(%rsp),%rax
mov    0x10(%rsp),%rsi
mov    %r14,(%rax,%rsi,8)
add    $0x1,%rsi
lea    0x96f(%rip),%rdi
mov    %rsi,0x10(%rsp)
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x0,0x78(%rsp)
mov    0x60(%rsp),%r12
jle    1380 <ssn_sprawdz+0x230>
mov    0x18(%rsp),%rax
mov    (%rsp),%rcx
mov    -0x8(%rcx,%rax,8),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x0(%rbp,%rbx,4),%xmm0
movss  %xmm0,(%r14,%rbx,4)
cvtss2sd %xmm0,%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r12
jne    16e0 <ssn_sprawdz+0x590>
jmp    1380 <ssn_sprawdz+0x230>
cmpl   $0x0,0xc(%rsp)
mov    0x30(%rsp),%r14
mov    (%rsp),%rbp
jle    1733 <ssn_sprawdz+0x5e3>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1720 <ssn_sprawdz+0x5d0>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%edx
test   $0x1,%sil
jne    1248 <ssn_sprawdz+0xf8>
jmp    126d <ssn_sprawdz+0x11d>

LLVM IR (-O0):
@.str = [4 x i8] c"%d.\00"
@.str.1 = [5 x i8] c" %f\00"
@.str.2 = [2 x i8] c"\0A\00"
define float** @ssn_sprawdz(i32 %0, i32* %1, i32 %2, float*** %3, i32 %4, float** %5) {
%7 = alloca i32
%8 = alloca i32*
%9 = alloca i32
%10 = alloca float***
%11 = alloca i32
%12 = alloca float**
%13 = alloca i32*
%14 = alloca i32
%15 = alloca float**
%16 = alloca i32
%17 = alloca float**
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca float
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca float
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
store i32 %0, i32* %7
store i32* %1, i32** %8
store i32 %2, i32* %9
store float*** %3, float**** %10
store i32 %4, i32* %11
store float** %5, float*** %12
%32 = load i32, i32* %7
%33 = sext i32 %32 to i64
%34 = mul i64 %33, 4
%35 = call i8* @malloc(i64 %34)
%36 = bitcast i8* %35 to i32*
store i32* %36, i32** %13
%37 = load i32, i32* %9
%38 = add nsw i32 %37, 1
%39 = load i32*, i32** %13
%40 = getelementptr inbounds i32, i32* %39, i64 0
store i32 %38, i32* %40
store i32 1, i32* %14
br label %41
41: ; preds = %57, %6
%42 = load i32, i32* %14
%43 = load i32, i32* %7
%44 = icmp slt i32 %42, %43
br i1 %44, label %45, label %60
45: ; preds = %41
%46 = load i32*, i32** %8
%47 = load i32, i32* %14
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i32, i32* %46, i64 %48
%50 = getelementptr inbounds i32, i32* %49, i64 -1
%51 = load i32, i32* %50
%52 = add nsw i32 %51, 1
%53 = load i32*, i32** %13
%54 = load i32, i32* %14
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i32, i32* %53, i64 %55
store i32 %52, i32* %56
br label %57
57: ; preds = %45
%58 = load i32, i32* %14
%59 = add nsw i32 %58, 1
store i32 %59, i32* %14
br label %41
60: ; preds = %41
%61 = load i32, i32* %7
%62 = sext i32 %61 to i64
%63 = mul i64 %62, 8
%64 = call i8* @malloc(i64 %63)
%65 = bitcast i8* %64 to float**
store float** %65, float*** %15
store i32 0, i32* %16
br label %66
66: ; preds = %84, %60
%67 = load i32, i32* %16
%68 = load i32, i32* %7
%69 = icmp slt i32 %67, %68
br i1 %69, label %70, label %87
70: ; preds = %66
%71 = load i32*, i32** %8
%72 = load i32, i32* %16
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i32, i32* %71, i64 %73
%75 = load i32, i32* %74
%76 = sext i32 %75 to i64
%77 = mul i64 %76, 4
%78 = call i8* @malloc(i64 %77)
%79 = bitcast i8* %78 to float*
%80 = load float**, float*** %15
%81 = load i32, i32* %16
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds float*, float** %80, i64 %82
store float* %79, float** %83
br label %84
84: ; preds = %70
%85 = load i32, i32* %16
%86 = add nsw i32 %85, 1
store i32 %86, i32* %16
br label %66
87: ; preds = %66
%88 = load i32, i32* %11
%89 = sext i32 %88 to i64
%90 = mul i64 %89, 8
%91 = call i8* @malloc(i64 %90)
%92 = bitcast i8* %91 to float**
store float** %92, float*** %17
%93 = load i32*, i32** %13
%94 = getelementptr inbounds i32, i32* %93, i64 0
%95 = load i32, i32* %94
%96 = sub nsw i32 %95, 1
store i32 %96, i32* %18
%97 = load i32*, i32** %8
%98 = load i32, i32* %7
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i32, i32* %97, i64 %99
%101 = getelementptr inbounds i32, i32* %100, i64 -1
%102 = load i32, i32* %101
store i32 %102, i32* %19
store i32 0, i32* %20
br label %103
103: ; preds = %316, %87
%104 = load i32, i32* %20
%105 = load i32, i32* %11
%106 = icmp slt i32 %104, %105
br i1 %106, label %107, label %319
107: ; preds = %103
store i32 0, i32* %21
br label %108
108: ; preds = %170, %107
%109 = load i32, i32* %21
%110 = load i32*, i32** %8
%111 = getelementptr inbounds i32, i32* %110, i64 0
%112 = load i32, i32* %111
%113 = icmp slt i32 %109, %112
br i1 %113, label %114, label %173
114: ; preds = %108
%115 = load float***, float**** %10
%116 = getelementptr inbounds float**, float*** %115, i64 0
%117 = load float**, float*** %116
%118 = load i32, i32* %21
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds float*, float** %117, i64 %119
%121 = load float*, float** %120
%122 = load i32, i32* %18
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds float, float* %121, i64 %123
%125 = load float, float* %124
store float %125, float* %22
store i32 0, i32* %23
br label %126
126: ; preds = %153, %114
%127 = load i32, i32* %23
%128 = load i32, i32* %18
%129 = icmp slt i32 %127, %128
br i1 %129, label %130, label %156
130: ; preds = %126
%131 = load float, float* %22
%132 = load float***, float**** %10
%133 = getelementptr inbounds float**, float*** %132, i64 0
%134 = load float**, float*** %133
%135 = load i32, i32* %21
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds float*, float** %134, i64 %136
%138 = load float*, float** %137
%139 = load i32, i32* %23
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds float, float* %138, i64 %140
%142 = load float, float* %141
%143 = load float**, float*** %12
%144 = load i32, i32* %20
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds float*, float** %143, i64 %145
%147 = load float*, float** %146
%148 = load i32, i32* %23
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds float, float* %147, i64 %149
%151 = load float, float* %150
%152 = call float @llvm.fmuladd.f32(float %142, float %151, float %131)
store float %152, float* %22
br label %153
153: ; preds = %130
%154 = load i32, i32* %23
%155 = add nsw i32 %154, 1
store i32 %155, i32* %23
br label %126
156: ; preds = %126
%157 = load float, float* %22
%158 = fneg float %157
%159 = fpext float %158 to double
%160 = call double @exp(double %159)
%161 = fadd double 1.000000e+00, %160
%162 = fdiv double 1.000000e+00, %161
%163 = fptrunc double %162 to float
%164 = load float**, float*** %15
%165 = getelementptr inbounds float*, float** %164, i64 0
%166 = load float*, float** %165
%167 = load i32, i32* %21
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds float, float* %166, i64 %168
store float %163, float* %169
br label %170
170: ; preds = %156
%171 = load i32, i32* %21
%172 = add nsw i32 %171, 1
store i32 %172, i32* %21
br label %108
173: ; preds = %108
store i32 1, i32* %24
br label %174
174: ; preds = %261, %173
%175 = load i32, i32* %24
%176 = load i32, i32* %7
%177 = icmp slt i32 %175, %176
br i1 %177, label %178, label %264
178: ; preds = %174
%179 = load i32, i32* %24
%180 = sub nsw i32 %179, 1
store i32 %180, i32* %25
%181 = load i32*, i32** %13
%182 = load i32, i32* %24
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds i32, i32* %181, i64 %183
%185 = load i32, i32* %184
%186 = sub nsw i32 %185, 1
store i32 %186, i32* %26
store i32 0, i32* %27
br label %187
187: ; preds = %257, %178
%188 = load i32, i32* %27
%189 = load i32*, i32** %8
%190 = load i32, i32* %24
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i32, i32* %189, i64 %191
%193 = load i32, i32* %192
%194 = icmp slt i32 %188, %193
br i1 %194, label %195, label %260
195: ; preds = %187
%196 = load float***, float**** %10
%197 = load i32, i32* %24
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds float**, float*** %196, i64 %198
%200 = load float**, float*** %199
%201 = load i32, i32* %27
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds float*, float** %200, i64 %202
%204 = load float*, float** %203
%205 = load i32, i32* %26
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %204, i64 %206
%208 = load float, float* %207
store float %208, float* %28
store i32 0, i32* %29
br label %209
209: ; preds = %238, %195
%210 = load i32, i32* %29
%211 = load i32, i32* %26
%212 = icmp slt i32 %210, %211
br i1 %212, label %213, label %241
213: ; preds = %209
%214 = load float, float* %28
%215 = load float***, float**** %10
%216 = load i32, i32* %24
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds float**, float*** %215, i64 %217
%219 = load float**, float*** %218
%220 = load i32, i32* %27
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds float*, float** %219, i64 %221
%223 = load float*, float** %222
%224 = load i32, i32* %29
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds float, float* %223, i64 %225
%227 = load float, float* %226
%228 = load float**, float*** %15
%229 = load i32, i32* %25
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds float*, float** %228, i64 %230
%232 = load float*, float** %231
%233 = load i32, i32* %29
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds float, float* %232, i64 %234
%236 = load float, float* %235
%237 = call float @llvm.fmuladd.f32(float %227, float %236, float %214)
store float %237, float* %28
br label %238
238: ; preds = %213
%239 = load i32, i32* %29
%240 = add nsw i32 %239, 1
store i32 %240, i32* %29
br label %209
241: ; preds = %209
%242 = load float, float* %28
%243 = fneg float %242
%244 = fpext float %243 to double
%245 = call double @exp(double %244)
%246 = fadd double 1.000000e+00, %245
%247 = fdiv double 1.000000e+00, %246
%248 = fptrunc double %247 to float
%249 = load float**, float*** %15
%250 = load i32, i32* %24
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds float*, float** %249, i64 %251
%253 = load float*, float** %252
%254 = load i32, i32* %27
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds float, float* %253, i64 %255
store float %248, float* %256
br label %257
257: ; preds = %241
%258 = load i32, i32* %27
%259 = add nsw i32 %258, 1
store i32 %259, i32* %27
br label %187
260: ; preds = %187
br label %261
261: ; preds = %260
%262 = load i32, i32* %24
%263 = add nsw i32 %262, 1
store i32 %263, i32* %24
br label %174
264: ; preds = %174
%265 = load i32, i32* %19
%266 = sext i32 %265 to i64
%267 = mul i64 %266, 4
%268 = call i8* @malloc(i64 %267)
%269 = bitcast i8* %268 to float*
%270 = load float**, float*** %17
%271 = load i32, i32* %20
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds float*, float** %270, i64 %272
store float* %269, float** %273
%274 = load i32, i32* %20
%275 = add nsw i32 %274, 1
%276 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %275)
store i32 0, i32* %30
br label %277
277: ; preds = %311, %264
%278 = load i32, i32* %30
%279 = load i32, i32* %19
%280 = icmp slt i32 %278, %279
br i1 %280, label %281, label %314
281: ; preds = %277
%282 = load float**, float*** %15
%283 = load i32, i32* %7
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds float*, float** %282, i64 %284
%286 = getelementptr inbounds float*, float** %285, i64 -1
%287 = load float*, float** %286
%288 = load i32, i32* %30
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds float, float* %287, i64 %289
%291 = load float, float* %290
%292 = load float**, float*** %17
%293 = load i32, i32* %20
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds float*, float** %292, i64 %294
%296 = load float*, float** %295
%297 = load i32, i32* %30
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds float, float* %296, i64 %298
store float %291, float* %299
%300 = load float**, float*** %17
%301 = load i32, i32* %20
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds float*, float** %300, i64 %302
%304 = load float*, float** %303
%305 = load i32, i32* %30
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds float, float* %304, i64 %306
%308 = load float, float* %307
%309 = fpext float %308 to double
%310 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), double %309)
br label %311
311: ; preds = %281
%312 = load i32, i32* %30
%313 = add nsw i32 %312, 1
store i32 %313, i32* %30
br label %277
314: ; preds = %277
%315 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %316
316: ; preds = %314
%317 = load i32, i32* %20
%318 = add nsw i32 %317, 1
store i32 %318, i32* %20
br label %103
319: ; preds = %103
store i32 0, i32* %31
br label %320
320: ; preds = %331, %319
%321 = load i32, i32* %31
%322 = load i32, i32* %7
%323 = icmp slt i32 %321, %322
br i1 %323, label %324, label %334
324: ; preds = %320
%325 = load float**, float*** %15
%326 = load i32, i32* %31
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds float*, float** %325, i64 %327
%329 = load float*, float** %328
%330 = bitcast float* %329 to i8*
br label %331
331: ; preds = %324
%332 = load i32, i32* %31
%333 = add nsw i32 %332, 1
store i32 %333, i32* %31
br label %320
334: ; preds = %320
%335 = load i32*, i32** %13
%336 = bitcast i32* %335 to i8*
%337 = load float**, float*** %17
ret float** %337
}

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