void CellVol(int nVar, int nSpt, int **Spt, int *SptType, int *Cell, int *Vol) {
  int i, i1, j, j1, k, l, m, n, d, w, tmp;
  int iwork[nVar][nVar];
  d = -1;
  n = -1;
  for (i = 0; i < nSpt; i++) {
    l = Cell[++d];
    for (j = 0; j < SptType[i]; j++) {
      m = Cell[++d];
      ++n;
      for (k = 0; k < nVar; k++)
        iwork[n][k] = Spt[m][k] - Spt[l][k];
    }
  }
  for (i = 0; i < nVar - 1; i++) {
    j = i;
    while (j < nVar && iwork[j][i] == 0)
      ++j;
    if (j == nVar)
      printf("Error code V001\n");
    else {
      if (j != i)
        for (w = 0; w < nVar; w++) {
          tmp = iwork[i][w];
          iwork[i][w] = iwork[j][w];
          iwork[j][w] = tmp;
        }
      for (j = i + 1; j < nVar; ++j)
        if (iwork[j][i] != 0) {
          d = gcd(iwork[i][i], iwork[j][i], &k, &l);
          m = -iwork[j][i] / d;
          n = iwork[i][i] / d;
          for (j1 = i; j1 < nVar; j1++) {
            i1 = iwork[i][j1];
            iwork[i][j1] = (k)*i1 + l * iwork[j][j1];
            iwork[j][j1] = m * i1 + n * iwork[j][j1];
          }
        }
    }
  }
  d = iwork[nVar - 1][nVar - 1];
  for (i = 0; i < nVar - 1; i++)
    d *= iwork[i][i];
  if (d < 0)
    *Vol -= d;
  else
    *Vol += d;
}


x86 assembly (clang, -O0):
<CellVol>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,%ecx
mov    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x60(%rbp)
mov    %rcx,%rdx
imul   %rdx,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x78(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x68(%rbp)
mov    %rax,-0x70(%rbp)
movl   $0xffffffff,-0x4c(%rbp)
movl   $0xffffffff,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1278 <CellVol+0x158>
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1265 <CellVol+0x145>
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1252 <CellVol+0x132>
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rsi
mov    -0x10(%rbp),%rcx
movslq -0x44(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,4),%edx
mov    -0x10(%rbp),%rcx
movslq -0x40(%rbp),%rdi
mov    (%rcx,%rdi,8),%rcx
movslq -0x3c(%rbp),%rdi
sub    (%rcx,%rdi,4),%edx
movslq -0x48(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11f4 <CellVol+0xd4>
jmp    1257 <CellVol+0x137>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ba <CellVol+0x9a>
jmp    126a <CellVol+0x14a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1191 <CellVol+0x71>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1575 <CellVol+0x455>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%ecx
xor    %eax,%eax
cmp    -0x4(%rbp),%ecx
mov    %al,-0x81(%rbp)
jge    12d2 <CellVol+0x1b2>
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rdx
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
sete   %al
mov    %al,-0x81(%rbp)
mov    -0x81(%rbp),%al
test   $0x1,%al
jne    12e5 <CellVol+0x1c5>
jmp    12f3 <CellVol+0x1d3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1296 <CellVol+0x176>
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    1312 <CellVol+0x1f2>
lea    0xcfa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1562 <CellVol+0x442>
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     13b3 <CellVol+0x293>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13ae <CellVol+0x28e>
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rsi
movslq -0x2c(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movslq -0x50(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    %ecx,-0x54(%rbp)
movslq -0x34(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movslq -0x50(%rbp),%rdx
mov    (%rcx,%rdx,4),%edi
movslq -0x2c(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movslq -0x50(%rbp),%rdx
mov    %edi,(%rcx,%rdx,4)
mov    -0x54(%rbp),%edx
movslq -0x34(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1325 <CellVol+0x205>
jmp    13b3 <CellVol+0x293>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    155d <CellVol+0x43d>
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rdx
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     154a <CellVol+0x42a>
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x2,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x2c(%rbp),%rsi
mov    (%rcx,%rsi,4),%edi
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    -0x3c(%rbp),%rdx
lea    -0x40(%rbp),%rcx
mov    $0x0,%al
call   1040 <gcd@plt>
mov    -0x80(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    %eax,-0x4c(%rbp)
movslq -0x34(%rbp),%rax
imul   %rdx,%rax
shl    $0x2,%rax
add    %rax,%rcx
movslq -0x2c(%rbp),%rdx
xor    %eax,%eax
sub    (%rcx,%rdx,4),%eax
cltd
idivl  -0x4c(%rbp)
mov    -0x80(%rbp),%rdx
mov    %eax,%ecx
mov    -0x78(%rbp),%rax
mov    %ecx,-0x44(%rbp)
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cltd
idivl  -0x4c(%rbp)
mov    %eax,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1545 <CellVol+0x425>
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rsi
movslq -0x2c(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    %ecx,-0x30(%rbp)
mov    -0x3c(%rbp),%edi
imul   -0x30(%rbp),%edi
mov    -0x40(%rbp),%ecx
movslq -0x34(%rbp),%r8
imul   %rsi,%r8
shl    $0x2,%r8
mov    %rax,%rdx
add    %r8,%rdx
movslq -0x38(%rbp),%r8
imul   (%rdx,%r8,4),%ecx
add    %ecx,%edi
movslq -0x2c(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movslq -0x38(%rbp),%rdx
mov    %edi,(%rcx,%rdx,4)
mov    -0x44(%rbp),%edx
imul   -0x30(%rbp),%edx
mov    -0x48(%rbp),%ecx
movslq -0x34(%rbp),%r8
imul   %rsi,%r8
shl    $0x2,%r8
mov    %rax,%rdi
add    %r8,%rdi
movslq -0x38(%rbp),%r8
imul   (%rdi,%r8,4),%ecx
add    %ecx,%edx
movslq -0x34(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    148a <CellVol+0x36a>
jmp    154a <CellVol+0x42a>
jmp    154f <CellVol+0x42f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13bc <CellVol+0x29c>
jmp    1562 <CellVol+0x442>
jmp    1567 <CellVol+0x447>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    127f <CellVol+0x15f>
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rdx
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    15eb <CellVol+0x4cb>
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15a7 <CellVol+0x487>
cmpl   $0x0,-0x4c(%rbp)
jge    1607 <CellVol+0x4e7>
mov    -0x4c(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
sub    %edx,%ecx
mov    %ecx,(%rax)
jmp    1612 <CellVol+0x4f2>
mov    -0x4c(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x60(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CellVol>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r9,-0xb8(%rbp)
mov    %r8,-0x38(%rbp)
mov    %rcx,-0x70(%rbp)
mov    %rdx,-0xd0(%rbp)
mov    %edi,%ebx
mov    %rsp,-0xb0(%rbp)
mov    %edi,%r13d
mov    %r13,%rax
imul   %r13,%rax
mov    %rsp,%r10
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r10
mov    %r10,%rsp
test   %esi,%esi
mov    %r10,-0x48(%rbp)
mov    %rbx,-0xd8(%rbp)
jle    1498 <CellVol+0x378>
mov    %esi,%eax
mov    %rax,-0x68(%rbp)
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x98(%rbp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x90(%rbp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,-0x88(%rbp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rcx
mov    %rcx,-0x80(%rbp)
mov    %r13,%rax
neg    %rax
mov    %rax,-0xa0(%rbp)
lea    0x10(%r10),%rax
mov    %rax,-0xc8(%rbp)
lea    0x0(,%r13,4),%r8
lea    0x4(%r10),%rax
mov    %rax,-0xc0(%rbp)
mov    $0xffffffff,%eax
xor    %esi,%esi
mov    $0xffffffff,%r9d
jmp    1224 <CellVol+0x104>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,%eax
mov    -0x78(%rbp),%rsi
add    $0x1,%rsi
cmp    -0x68(%rbp),%rsi
je     1498 <CellVol+0x378>
movslq %eax,%rcx
mov    -0x38(%rbp),%rdx
movslq 0x4(%rdx,%rcx,4),%r11
mov    %r11d,-0x5c(%rbp)
mov    -0x70(%rbp),%rdx
mov    (%rdx,%rsi,4),%edx
mov    %edx,-0xa8(%rbp)
test   %edx,%edx
jle    1490 <CellVol+0x370>
mov    %rsi,-0x78(%rbp)
add    $0x1,%rcx
movslq %r9d,%r9
lea    0x1(%r9),%rax
imul   %r13,%rax
mov    -0xc8(%rbp),%rdx
lea    (%rdx,%rax,4),%r15
mov    -0xc0(%rbp),%rdx
lea    (%rdx,%rax,4),%rsi
xor    %edi,%edi
mov    %r11,-0x50(%rbp)
jmp    12a0 <CellVol+0x180>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x1,%edi
add    %r8,%r15
add    %r8,%rsi
cmp    -0xa8(%rbp),%edi
mov    -0xd8(%rbp),%rbx
je     1210 <CellVol+0xf0>
add    $0x1,%r9
mov    -0x38(%rbp),%rax
movslq 0x4(%rax,%rcx,4),%rax
movl   $0x0,-0x2c(%rbp)
test   %ebx,%ebx
jle    1280 <CellVol+0x160>
mov    %r9,%rdx
imul   %r13,%rdx
mov    -0xd0(%rbp),%rbx
mov    (%rbx,%rax,8),%r12
mov    (%rbx,%r11,8),%r14
lea    (%r10,%rdx,4),%rdx
cmpl   $0x4,-0xd8(%rbp)
jae    12f0 <CellVol+0x1d0>
xor    %ebx,%ebx
jmp    1410 <CellVol+0x2f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdx,-0x58(%rbp)
mov    %r9,-0x40(%rbp)
mov    %r8,%r9
lea    (%r12,%r13,4),%rax
lea    (%r14,%r13,4),%rdx
lea    -0x2c(%rbp),%r8
cmp    %rax,%r8
setb   %r10b
lea    -0x28(%rbp),%r11
cmp    %r11,%r12
setb   %bl
cmp    %rdx,%r8
setb   %al
cmp    %r11,%r14
setb   %dl
test   %bl,%r10b
jne    13ef <CellVol+0x2cf>
mov    $0x0,%ebx
and    %dl,%al
mov    -0x48(%rbp),%r10
mov    %r9,%r8
mov    -0x40(%rbp),%r9
mov    -0x50(%rbp),%r11
mov    -0x58(%rbp),%rdx
jne    1410 <CellVol+0x2f0>
cmpq   $0x0,-0x90(%rbp)
je     1470 <CellVol+0x350>
mov    -0x80(%rbp),%rax
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu (%r12,%r10,4),%xmm0
movdqu (%r14,%r10,4),%xmm1
psubd  %xmm1,%xmm0
movdqu %xmm0,-0x10(%r15,%r10,4)
movdqu 0x10(%r12,%r10,4),%xmm0
movdqu 0x10(%r14,%r10,4),%xmm1
psubd  %xmm1,%xmm0
movdqu %xmm0,(%r15,%r10,4)
add    $0x8,%r10
add    $0xfffffffffffffffe,%rax
jne    1370 <CellVol+0x250>
mov    %r10d,-0x2c(%rbp)
lea    0x3(%r10),%rax
testb  $0x1,-0x88(%rbp)
je     13d6 <CellVol+0x2b6>
movdqu (%r12,%r10,4),%xmm0
movdqu (%r14,%r10,4),%xmm1
psubd  %xmm1,%xmm0
movdqu %xmm0,(%rdx,%r10,4)
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,%rbx
cmp    %r13,%rax
mov    -0x48(%rbp),%r10
je     1280 <CellVol+0x160>
jmp    1410 <CellVol+0x2f0>
xor    %ebx,%ebx
mov    -0x48(%rbp),%r10
mov    %r9,%r8
mov    -0x40(%rbp),%r9
mov    -0x50(%rbp),%r11
mov    -0x58(%rbp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,%rax
test   $0x1,%r13b
je     142e <CellVol+0x30e>
mov    (%r12,%rbx,4),%eax
sub    (%r14,%rbx,4),%eax
mov    %eax,(%rdx,%rbx,4)
mov    %rbx,%rax
or     $0x1,%rax
mov    %eax,-0x2c(%rbp)
not    %rbx
cmp    -0xa0(%rbp),%rbx
je     1280 <CellVol+0x160>
xchg   %ax,%ax
mov    (%r12,%rax,4),%edx
sub    (%r14,%rax,4),%edx
mov    %edx,-0x4(%rsi,%rax,4)
lea    0x1(%rax),%edx
mov    %edx,-0x2c(%rbp)
mov    0x4(%r12,%rax,4),%edx
sub    0x4(%r14,%rax,4),%edx
mov    %edx,(%rsi,%rax,4)
add    $0x2,%rax
mov    %eax,-0x2c(%rbp)
cmp    %rax,%r13
jne    1440 <CellVol+0x320>
jmp    1280 <CellVol+0x160>
mov    $0x3,%eax
xor    %r10d,%r10d
testb  $0x1,-0x88(%rbp)
jne    13ba <CellVol+0x29a>
jmp    13d6 <CellVol+0x2b6>
nopw   0x0(%rax,%rax,1)
add    $0x1,%eax
jmp    1216 <CellVol+0xf6>
lea    -0x1(%rbx),%eax
cmp    $0x1,%ebx
jle    1cfb <CellVol+0xbdb>
mov    %eax,-0xdc(%rbp)
mov    %eax,%r15d
lea    0x4(%r10),%rax
mov    %rax,-0xe8(%rbp)
lea    0x0(,%r13,4),%r12
lea    0x4(,%r13,4),%r14
lea    0x1(%r13),%rax
mov    %rax,-0x130(%rbp)
mov    %r13,%rax
add    %r13,%rax
mov    %rax,-0x128(%rbp)
mov    %r13d,%eax
and    $0xfffffff8,%eax
mov    %rax,-0x110(%rbp)
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x108(%rbp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,-0x100(%rbp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0xf8(%rbp)
mov    %r13,%rax
neg    %rax
mov    %rax,-0x118(%rbp)
lea    0x30(%r10),%rax
mov    %rax,-0xf0(%rbp)
lea    (%r10,%r13,4),%rax
add    $0x14,%rax
mov    %rax,-0x80(%rbp)
lea    0x14(%r10),%rax
mov    %rax,-0x120(%rbp)
lea    (%r10,%r13,4),%rax
mov    %rax,-0x78(%rbp)
mov    $0x1,%eax
mov    %rax,-0x70(%rbp)
xor    %eax,%eax
mov    %rax,-0x68(%rbp)
xor    %ecx,%ecx
mov    %r14,-0x140(%rbp)
mov    %r15,-0x138(%rbp)
mov    %r12,-0x50(%rbp)
jmp    15b6 <CellVol+0x496>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0xa79(%rip),%rdi
call   1030 <puts@plt>
mov    -0x48(%rbp),%r10
mov    -0x38(%rbp),%rax
add    $0x1,%rax
addq   $0x1,-0x70(%rbp)
addq   $0x1,-0x68(%rbp)
add    %r12,-0x80(%rbp)
add    %r12,-0x78(%rbp)
mov    %rax,%rcx
cmp    %r15,%rax
je     1d0d <CellVol+0xbed>
mov    %rcx,%rax
mov    %rcx,%rdx
mov    %rcx,-0x38(%rbp)
cmp    %r13,%rcx
jge    1600 <CellVol+0x4e0>
mov    %r14,%rcx
mov    -0x38(%rbp),%rax
imul   %rax,%rcx
add    %r10,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpl   $0x0,(%rcx)
jne    1600 <CellVol+0x4e0>
add    $0x1,%rax
add    %r12,%rcx
cmp    %rax,%r13
jne    15e0 <CellVol+0x4c0>
jmp    1580 <CellVol+0x460>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    %ebx,%eax
je     1580 <CellVol+0x460>
mov    %eax,%edx
cmp    %rdx,-0x38(%rbp)
je     17b0 <CellVol+0x690>
mov    -0x38(%rbp),%r11
imul   %r13,%r11
mov    %rdx,%rcx
imul   %r13,%rcx
lea    (%r10,%r11,4),%r9
lea    (%r10,%rcx,4),%r8
cmp    $0x8,%ebx
jb     1660 <CellVol+0x540>
lea    0x4(,%rdx,4),%rdx
imul   %r13,%rdx
add    %r10,%rdx
cmp    %r9,%rdx
jbe    16da <CellVol+0x5ba>
mov    -0x38(%rbp),%rax
lea    0x4(,%rax,4),%rdx
imul   %r13,%rdx
add    %r10,%rdx
cmp    %r8,%rdx
jbe    16da <CellVol+0x5ba>
xor    %edx,%edx
mov    %rdx,%rdi
test   $0x1,%r13b
je     1682 <CellVol+0x562>
mov    (%r9,%rdx,4),%esi
mov    (%r8,%rdx,4),%edi
mov    %edi,(%r9,%rdx,4)
mov    %esi,(%r8,%rdx,4)
mov    %rdx,%rdi
or     $0x1,%rdi
not    %rdx
cmp    -0x118(%rbp),%rdx
je     17b0 <CellVol+0x690>
mov    -0xe8(%rbp),%rax
lea    (%rax,%rcx,4),%rcx
lea    (%rax,%r11,4),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x4(%rax,%rdi,4),%edx
mov    -0x4(%rcx,%rdi,4),%esi
mov    %esi,-0x4(%rax,%rdi,4)
mov    %edx,-0x4(%rcx,%rdi,4)
mov    (%rax,%rdi,4),%edx
mov    (%rcx,%rdi,4),%esi
mov    %esi,(%rax,%rdi,4)
mov    %edx,(%rcx,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%r13
jne    16b0 <CellVol+0x590>
jmp    17b0 <CellVol+0x690>
cmpq   $0x0,-0x108(%rbp)
je     1ce7 <CellVol+0xbc7>
mov    -0xf0(%rbp),%rdx
lea    (%rdx,%r11,4),%rax
lea    (%rdx,%rcx,4),%rsi
mov    -0xf8(%rbp),%rdx
xor    %edi,%edi
movups -0x30(%rax,%rdi,4),%xmm0
movups -0x20(%rax,%rdi,4),%xmm1
movups -0x30(%rsi,%rdi,4),%xmm2
movups -0x20(%rsi,%rdi,4),%xmm3
movups %xmm2,-0x30(%rax,%rdi,4)
movups %xmm3,-0x20(%rax,%rdi,4)
movups %xmm0,-0x30(%rsi,%rdi,4)
movups %xmm1,-0x20(%rsi,%rdi,4)
movdqu -0x10(%rax,%rdi,4),%xmm0
movdqu (%rax,%rdi,4),%xmm1
movdqu -0x10(%rsi,%rdi,4),%xmm2
movdqu (%rsi,%rdi,4),%xmm3
movdqu %xmm2,-0x10(%rax,%rdi,4)
movdqu %xmm3,(%rax,%rdi,4)
movdqu %xmm0,-0x10(%rsi,%rdi,4)
movdqu %xmm1,(%rsi,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rdx
jne    1700 <CellVol+0x5e0>
testb  $0x1,-0x100(%rbp)
je     179b <CellVol+0x67b>
movdqu (%r9,%rdi,4),%xmm0
movdqu 0x10(%r9,%rdi,4),%xmm1
movdqu (%r8,%rdi,4),%xmm2
movdqu 0x10(%r8,%rdi,4),%xmm3
movdqu %xmm2,(%r9,%rdi,4)
movdqu %xmm3,0x10(%r9,%rdi,4)
movdqu %xmm0,(%r8,%rdi,4)
movdqu %xmm1,0x10(%r8,%rdi,4)
mov    -0x110(%rbp),%rax
mov    %rax,%rdx
cmp    %r13,%rax
jne    1662 <CellVol+0x542>
xchg   %ax,%ax
mov    -0x38(%rbp),%rcx
lea    0x1(%rcx),%rax
cmp    %r13,%rax
jge    1598 <CellVol+0x478>
mov    %rax,-0x148(%rbp)
mov    -0x68(%rbp),%rdx
imul   %r13,%rdx
mov    -0x130(%rbp),%rax
lea    (%rax,%rdx,1),%rsi
add    -0x128(%rbp),%rdx
mov    %rdx,-0xc8(%rbp)
mov    %rcx,%rax
imul   %r13,%rax
lea    (%r10,%rax,4),%rbx
imul   %rcx,%r14
mov    -0xe8(%rbp),%rax
add    %r14,%rax
mov    %rax,-0x90(%rbp)
lea    0x4(,%rcx,4),%rax
imul   %r13,%rax
add    %r10,%rax
mov    %rax,-0x88(%rbp)
add    %rcx,%rsi
mov    %rsi,-0xc0(%rbp)
mov    %rcx,%rax
not    %rax
lea    (%rax,%r13,1),%rdx
add    $0xfffffffffffffffc,%rdx
add    %r13,%rax
mov    %rdx,-0x178(%rbp)
shr    $0x2,%rdx
add    $0x1,%rdx
lea    0x1(%rcx),%rsi
mov    %rsi,-0x40(%rbp)
mov    %rax,-0x98(%rbp)
and    $0xfffffffffffffffc,%rax
mov    %rax,-0x168(%rbp)
add    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
mov    %rdx,%rax
mov    %rdx,-0x170(%rbp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rdx
mov    %rdx,-0x150(%rbp)
add    -0x120(%rbp),%r14
mov    %r14,-0x158(%rbp)
mov    -0x80(%rbp),%rax
lea    (%rax,%rcx,4),%rdx
mov    -0x78(%rbp),%r12
xor    %eax,%eax
mov    %rax,-0xa0(%rbp)
mov    -0x70(%rbp),%rsi
mov    %rcx,%r14
jmp    18f1 <CellVol+0x7d1>
nopl   0x0(%rax,%rax,1)
mov    -0xd0(%rbp),%rsi
add    $0x1,%rsi
addq   $0x1,-0xa0(%rbp)
01
mov    -0x50(%rbp),%rax
mov    -0xa8(%rbp),%rdx
add    %rax,%rdx
add    %rax,%r12
cmp    %r13,%rsi
mov    -0x48(%rbp),%r10
je     1cc2 <CellVol+0xba2>
mov    %rdx,-0xa8(%rbp)
mov    %rsi,-0xd0(%rbp)
mov    %rsi,%rax
imul   %r13,%rax
lea    (%r10,%rax,4),%rax
mov    %rax,-0x58(%rbp)
mov    (%rax,%r14,4),%r15d
test   %r15d,%r15d
je     18c0 <CellVol+0x7a0>
mov    -0x38(%rbp),%rax
mov    (%rbx,%rax,4),%r14d
mov    %r14d,%edi
mov    %r15d,%esi
lea    -0x2c(%rbp),%rdx
lea    -0x5c(%rbp),%rcx
xor    %eax,%eax
call   1040 <gcd@plt>
mov    %eax,%esi
mov    %r15d,%eax
cltd
idiv   %esi
mov    %eax,%r8d
mov    %r14d,%eax
cltd
idiv   %esi
mov    -0x2c(%rbp),%r9d
mov    -0x5c(%rbp),%r11d
mov    %r9d,%ecx
imul   %r14d,%ecx
imul   %r11d,%r15d
add    %ecx,%r15d
mov    -0x38(%rbp),%rcx
mov    %r15d,(%rbx,%rcx,4)
imul   %r8d,%r14d
mov    -0x38(%rbp),%rcx
mov    -0x58(%rbp),%rdx
mov    (%rdx,%rcx,4),%ecx
imul   %eax,%ecx
sub    %r14d,%ecx
mov    -0x38(%rbp),%r14
mov    %ecx,(%rdx,%r14,4)
cmp    %r13,-0x40(%rbp)
je     18c0 <CellVol+0x7a0>
mov    -0x40(%rbp),%rcx
cmpq   $0x4,-0x98(%rbp)
04
jae    19d5 <CellVol+0x8b5>
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%edi
mov    %r9d,%edx
imul   %edi,%edx
mov    (%r12,%rcx,4),%esi
imul   %r11d,%esi
add    %edx,%esi
mov    %esi,(%rbx,%rcx,4)
imul   %r8d,%edi
mov    (%r12,%rcx,4),%edx
imul   %eax,%edx
sub    %edi,%edx
mov    %edx,(%r12,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r13
jne    19a0 <CellVol+0x880>
jmp    18c0 <CellVol+0x7a0>
mov    -0xa0(%rbp),%rcx
imul   %r13,%rcx
mov    -0xc0(%rbp),%rdx
lea    (%rdx,%rcx,1),%rdi
mov    -0x48(%rbp),%rdx
lea    (%rdx,%rdi,4),%rsi
add    -0xc8(%rbp),%rcx
lea    (%rdx,%rcx,4),%rdi
cmp    %rdi,-0x90(%rbp)
setb   %dl
cmp    %rsi,-0x88(%rbp)
seta   %r10b
mov    -0x40(%rbp),%rcx
and    %dl,%r10b
jne    19a0 <CellVol+0x880>
mov    -0x40(%rbp),%rcx
mov    -0x88(%rbp),%rdx
cmp    %rdx,-0x90(%rbp)
jb     19a0 <CellVol+0x880>
mov    -0x40(%rbp),%rcx
test   %r10b,%r10b
jne    19a0 <CellVol+0x880>
mov    -0x40(%rbp),%rcx
jne    19a0 <CellVol+0x880>
mov    -0x40(%rbp),%rcx
cmp    %rdi,%rsi
jb     19a0 <CellVol+0x880>
movd   %r9d,%xmm0
pshufd $0x0,%xmm0,%xmm3
movd   %r11d,%xmm0
pshufd $0x0,%xmm0,%xmm4
movd   %r8d,%xmm0
pshufd $0x0,%xmm0,%xmm11
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm9
pshufd $0xf5,%xmm3,%xmm5
pshufd $0xf5,%xmm4,%xmm12
pshufd $0xf5,%xmm11,%xmm10
pshufd $0xf5,%xmm9,%xmm8
cmpq   $0x4,-0x178(%rbp)
04
jae    1aa9 <CellVol+0x989>
xor    %edi,%edi
jmp    1bfd <CellVol+0xadd>
mov    -0x150(%rbp),%rcx
xor    %edi,%edi
mov    -0x158(%rbp),%rdx
mov    -0xa8(%rbp),%rsi
movdqu -0x10(%rdx,%rdi,4),%xmm1
movdqu -0x10(%rsi,%rdi,4),%xmm0
movdqa %xmm3,%xmm6
pmuludq %xmm1,%xmm6
pshufd $0xe8,%xmm6,%xmm6
pshufd $0xf5,%xmm1,%xmm2
movdqa %xmm5,%xmm7
pmuludq %xmm2,%xmm7
pshufd $0xe8,%xmm7,%xmm7
punpckldq %xmm7,%xmm6
pshufd $0xf5,%xmm0,%xmm7
pmuludq %xmm4,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm12,%xmm7
pshufd $0xe8,%xmm7,%xmm7
punpckldq %xmm7,%xmm0
paddd  %xmm6,%xmm0
movdqu %xmm0,-0x10(%rdx,%rdi,4)
pmuludq %xmm11,%xmm1
pshufd $0xe8,%xmm1,%xmm0
pmuludq %xmm10,%xmm2
pshufd $0xe8,%xmm2,%xmm1
punpckldq %xmm1,%xmm0
movdqu -0x10(%rsi,%rdi,4),%xmm1
movdqu (%rsi,%rdi,4),%xmm2
pshufd $0xf5,%xmm1,%xmm6
pmuludq %xmm9,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm8,%xmm6
pshufd $0xe8,%xmm6,%xmm6
punpckldq %xmm6,%xmm1
psubd  %xmm0,%xmm1
movdqu %xmm1,-0x10(%rsi,%rdi,4)
movdqu (%rdx,%rdi,4),%xmm0
movdqa %xmm3,%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xf5,%xmm0,%xmm6
movdqa %xmm5,%xmm7
pmuludq %xmm6,%xmm7
pshufd $0xe8,%xmm7,%xmm7
punpckldq %xmm7,%xmm1
pshufd $0xf5,%xmm2,%xmm7
pmuludq %xmm4,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm12,%xmm7
pshufd $0xe8,%xmm7,%xmm7
punpckldq %xmm7,%xmm2
paddd  %xmm1,%xmm2
movdqu %xmm2,(%rdx,%rdi,4)
pmuludq %xmm11,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm10,%xmm6
pshufd $0xe8,%xmm6,%xmm1
punpckldq %xmm1,%xmm0
movdqu (%rsi,%rdi,4),%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm9,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm8,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
psubd  %xmm0,%xmm1
movdqu %xmm1,(%rsi,%rdi,4)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rcx
jne    1ac0 <CellVol+0x9a0>
testb  $0x1,-0x170(%rbp)
je     1ca2 <CellVol+0xb82>
add    -0x40(%rbp),%rdi
movdqu (%rbx,%rdi,4),%xmm0
mov    -0x58(%rbp),%rcx
movdqu (%rcx,%rdi,4),%xmm1
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm2
pshufd $0xf5,%xmm0,%xmm3
pmuludq %xmm3,%xmm5
pshufd $0xe8,%xmm5,%xmm5
punpckldq %xmm5,%xmm2
pmuludq %xmm1,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pshufd $0xf5,%xmm1,%xmm1
pmuludq %xmm12,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu %xmm4,(%rbx,%rdi,4)
pmuludq %xmm0,%xmm11
pshufd $0xe8,%xmm11,%xmm0
pmuludq %xmm3,%xmm10
pshufd $0xe8,%xmm10,%xmm1
punpckldq %xmm1,%xmm0
movdqu (%rcx,%rdi,4),%xmm1
pmuludq %xmm1,%xmm9
pshufd $0xe8,%xmm9,%xmm2
pshufd $0xf5,%xmm1,%xmm1
pmuludq %xmm8,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm2
psubd  %xmm0,%xmm2
movdqu %xmm2,(%rcx,%rdi,4)
mov    -0x160(%rbp),%rcx
mov    -0x168(%rbp),%rdx
cmp    %rdx,-0x98(%rbp)
jne    19a0 <CellVol+0x880>
jmp    18c0 <CellVol+0x7a0>
mov    -0xd8(%rbp),%rbx
mov    -0x140(%rbp),%r14
mov    -0x138(%rbp),%r15
mov    -0x50(%rbp),%r12
mov    -0x148(%rbp),%rax
jmp    1598 <CellVol+0x478>
xor    %edi,%edi
testb  $0x1,-0x100(%rbp)
jne    1767 <CellVol+0x647>
jmp    179b <CellVol+0x67b>
cltq
mov    %rax,%rcx
imul   %r13,%rcx
lea    (%r10,%rcx,4),%rcx
mov    (%rcx,%rax,4),%eax
jmp    1d3e <CellVol+0xc1e>
movslq -0xdc(%rbp),%rax
mov    %rax,%rcx
imul   %r13,%rcx
lea    (%r10,%rcx,4),%rcx
mov    (%rcx,%rax,4),%eax
cmp    $0x2,%ebx
jl     1d3e <CellVol+0xc1e>
lea    -0x1(%r15),%rdx
mov    %r15d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    1d67 <CellVol+0xc47>
xor    %edx,%edx
jmp    1dbe <CellVol+0xc9e>
mov    -0xb8(%rbp),%rsi
mov    -0xb0(%rbp),%rdi
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
add    %ecx,(%rsi)
mov    %rdi,%rsp
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r13,%rsi
shl    $0x4,%rsi
add    $0x10,%rsi
lea    (%r12,%r12,2),%r8
and    $0xfffffffc,%r15d
neg    %r15
mov    $0x1,%edx
mov    %r10,%rbx
cs nopw 0x0(%rax,%rax,1)
nop
imul   (%rbx),%eax
imul   0x4(%rbx,%r13,4),%eax
imul   0x8(%rbx,%r13,8),%eax
imul   0xc(%rbx,%r8,1),%eax
add    %rsi,%rbx
lea    (%r15,%rdx,1),%rdi
add    $0x4,%rdi
add    $0x4,%rdx
cmp    $0x1,%rdi
jne    1d90 <CellVol+0xc70>
add    $0xffffffffffffffff,%rdx
test   %rcx,%rcx
mov    -0xb8(%rbp),%rsi
mov    -0xb0(%rbp),%rdi
je     1d4c <CellVol+0xc2c>
imul   %r14,%rdx
add    %rdx,%r10
nopl   0x0(%rax)
imul   (%r10),%eax
add    %r14,%r10
add    $0xffffffffffffffff,%rcx
jne    1de0 <CellVol+0xcc0>
jmp    1d4c <CellVol+0xc2c>

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

LLVM IR (-O2):
@str = [16 x i8] c"Error code V001\00"
define void @CellVol(i32 %0, i32 %1, i32** nocapture %2, i32* nocapture %3, i32* nocapture %4, i32* nocapture %5) {
%7 = alloca i32
%8 = alloca i32
%9 = bitcast i32* %7 to i8*
%10 = bitcast i32* %8 to i8*
%11 = zext i32 %0 to i64
%12 = tail call i8* @llvm.stacksave()
%13 = mul nuw i64 %11, %11
%14 = alloca i32, i64 %13
%15 = bitcast i32* %14 to i8*
%16 = icmp sgt i32 %1, 0
br i1 %16, label %17, label %35
17: ; preds = %6
%18 = icmp sgt i32 %0, 0
%19 = zext i32 %1 to i64
%20 = getelementptr inbounds i32, i32* %7, i64 1
%21 = and i64 %11, 4294967292
%22 = add nsw i64 %21, -4
%23 = lshr exact i64 %22, 2
%24 = add nuw nsw i64 %23, 1
%25 = icmp ult i32 %0, 4
%26 = and i64 %11, 4294967292
%27 = and i64 %24, 1
%28 = icmp eq i64 %22, 0
%29 = and i64 %24, 9223372036854775806
%30 = icmp eq i64 %27, 0
%31 = icmp eq i64 %26, %11
%32 = and i64 %11, 1
%33 = icmp eq i64 %32, 0
%34 = sub nsw i64 0, %11
br label %67
35: ; preds = %196, %6
%36 = add i32 %0, -1
%37 = icmp sgt i32 %0, 1
br i1 %37, label %44, label %38
38: ; preds = %35
%39 = sext i32 %36 to i64
%40 = mul nsw i64 %39, %11
%41 = getelementptr inbounds i32, i32* %14, i64 %40
%42 = getelementptr inbounds i32, i32* %41, i64 %39
%43 = load i32, i32* %42
br label %569
44: ; preds = %35
%45 = zext i32 %0 to i64
%46 = zext i32 %36 to i64
%47 = getelementptr inbounds i32, i32* %14, i64 1
%48 = bitcast i32* %47 to i8*
%49 = shl nuw nsw i64 %11, 2
%50 = add nuw nsw i64 %49, 4
%51 = add nuw nsw i64 %11, 1
%52 = shl nuw nsw i64 %11, 1
%53 = and i64 %11, 4294967288
%54 = add nsw i64 %53, -8
%55 = lshr exact i64 %54, 3
%56 = add nuw nsw i64 %55, 1
%57 = icmp ult i32 %0, 8
%58 = and i64 %11, 4294967288
%59 = and i64 %56, 1
%60 = icmp eq i64 %54, 0
%61 = and i64 %56, 4611686018427387902
%62 = icmp eq i64 %59, 0
%63 = icmp eq i64 %58, %11
%64 = and i64 %11, 1
%65 = icmp eq i64 %64, 0
%66 = sub nsw i64 0, %11
br label %201
67: ; preds = %17, %196
%68 = phi i64 [ 0, %17 ], [ %199, %196 ]
%69 = phi i32 [ -1, %17 ], [ %198, %196 ]
%70 = phi i32 [ -1, %17 ], [ %197, %196 ]
%71 = add nsw i32 %69, 1
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds i32, i32* %4, i64 %72
%74 = load i32, i32* %73
store i32 %74, i32* %8
%75 = getelementptr inbounds i32, i32* %3, i64 %68
%76 = load i32, i32* %75
%77 = icmp sgt i32 %76, 0
br i1 %77, label %78, label %196
78: ; preds = %67
%79 = sext i32 %74 to i64
%80 = getelementptr inbounds i32*, i32** %2, i64 %79
%81 = sext i32 %69 to i64
%82 = add nsw i64 %81, 1
%83 = sext i32 %70 to i64
br label %84
84: ; preds = %78, %190
%85 = phi i64 [ %83, %78 ], [ %91, %190 ]
%86 = phi i64 [ %82, %78 ], [ %88, %190 ]
%87 = phi i32 [ 0, %78 ], [ %191, %190 ]
%88 = add nsw i64 %86, 1
%89 = getelementptr inbounds i32, i32* %4, i64 %88
%90 = load i32, i32* %89
%91 = add nsw i64 %85, 1
store i32 0, i32* %7
br i1 %18, label %92, label %190
92: ; preds = %84
%93 = sext i32 %90 to i64
%94 = getelementptr inbounds i32*, i32** %2, i64 %93
%95 = load i32*, i32** %94
%96 = load i32*, i32** %80
%97 = mul nsw i64 %91, %11
%98 = getelementptr inbounds i32, i32* %14, i64 %97
br i1 %25, label %156, label %99
99: ; preds = %92
%100 = getelementptr i32, i32* %95, i64 %11
%101 = getelementptr i32, i32* %96, i64 %11
%102 = icmp ult i32* %7, %100
%103 = icmp ult i32* %95, %20
%104 = and i1 %102, %103
%105 = icmp ult i32* %7, %101
%106 = icmp ult i32* %96, %20
%107 = and i1 %105, %106
%108 = or i1 %104, %107
br i1 %108, label %156, label %109
109: ; preds = %99
br i1 %28, label %140, label %110
110: ; preds = %109, %110
%111 = phi i64 [ %135, %110 ], [ 0, %109 ]
%112 = phi i64 [ %136, %110 ], [ 3, %109 ]
%113 = phi i64 [ %137, %110 ], [ 0, %109 ]
%114 = getelementptr inbounds i32, i32* %95, i64 %111
%115 = bitcast i32* %114 to <4 x i32>*
%116 = load <4 x i32>, <4 x i32>* %115
%117 = getelementptr inbounds i32, i32* %96, i64 %111
%118 = bitcast i32* %117 to <4 x i32>*
%119 = load <4 x i32>, <4 x i32>* %118
%120 = sub nsw <4 x i32> %116, %119
%121 = getelementptr inbounds i32, i32* %98, i64 %111
%122 = bitcast i32* %121 to <4 x i32>*
store <4 x i32> %120, <4 x i32>* %122
%123 = or i64 %111, 4
%124 = getelementptr inbounds i32, i32* %95, i64 %123
%125 = bitcast i32* %124 to <4 x i32>*
%126 = load <4 x i32>, <4 x i32>* %125
%127 = getelementptr inbounds i32, i32* %96, i64 %123
%128 = bitcast i32* %127 to <4 x i32>*
%129 = load <4 x i32>, <4 x i32>* %128
%130 = sub nsw <4 x i32> %126, %129
%131 = getelementptr inbounds i32, i32* %98, i64 %123
%132 = bitcast i32* %131 to <4 x i32>*
store <4 x i32> %130, <4 x i32>* %132
%133 = trunc i64 %112 to i32
%134 = add i32 %133, 5
%135 = add nuw i64 %111, 8
%136 = add i64 %112, 8
%137 = add i64 %113, 2
%138 = icmp eq i64 %137, %29
br i1 %138, label %139, label %110
139: ; preds = %110
store i32 %134, i32* %7
br label %140
140: ; preds = %139, %109
%141 = phi i64 [ 0, %109 ], [ %135, %139 ]
%142 = phi i64 [ 3, %109 ], [ %136, %139 ]
br i1 %30, label %155, label %143
143: ; preds = %140
%144 = getelementptr inbounds i32, i32* %95, i64 %141
%145 = bitcast i32* %144 to <4 x i32>*
%146 = load <4 x i32>, <4 x i32>* %145
%147 = getelementptr inbounds i32, i32* %96, i64 %141
%148 = bitcast i32* %147 to <4 x i32>*
%149 = load <4 x i32>, <4 x i32>* %148
%150 = sub nsw <4 x i32> %146, %149
%151 = getelementptr inbounds i32, i32* %98, i64 %141
%152 = bitcast i32* %151 to <4 x i32>*
store <4 x i32> %150, <4 x i32>* %152
%153 = trunc i64 %142 to i32
%154 = add i32 %153, 1
store i32 %154, i32* %7
br label %155
155: ; preds = %140, %143
br i1 %31, label %190, label %156
156: ; preds = %99, %92, %155
%157 = phi i64 [ 0, %99 ], [ 0, %92 ], [ %26, %155 ]
%158 = xor i64 %157, -1
br i1 %33, label %168, label %159
159: ; preds = %156
%160 = getelementptr inbounds i32, i32* %95, i64 %157
%161 = load i32, i32* %160
%162 = getelementptr inbounds i32, i32* %96, i64 %157
%163 = load i32, i32* %162
%164 = sub nsw i32 %161, %163
%165 = getelementptr inbounds i32, i32* %98, i64 %157
store i32 %164, i32* %165
%166 = or i64 %157, 1
%167 = trunc i64 %166 to i32
store i32 %167, i32* %7
br label %168
168: ; preds = %159, %156
%169 = phi i64 [ %157, %156 ], [ %166, %159 ]
%170 = icmp eq i64 %158, %34
br i1 %170, label %190, label %171
171: ; preds = %168, %171
%172 = phi i64 [ %187, %171 ], [ %169, %168 ]
%173 = getelementptr inbounds i32, i32* %95, i64 %172
%174 = load i32, i32* %173
%175 = getelementptr inbounds i32, i32* %96, i64 %172
%176 = load i32, i32* %175
%177 = sub nsw i32 %174, %176
%178 = getelementptr inbounds i32, i32* %98, i64 %172
store i32 %177, i32* %178
%179 = add nuw nsw i64 %172, 1
%180 = trunc i64 %179 to i32
store i32 %180, i32* %7
%181 = getelementptr inbounds i32, i32* %95, i64 %179
%182 = load i32, i32* %181
%183 = getelementptr inbounds i32, i32* %96, i64 %179
%184 = load i32, i32* %183
%185 = sub nsw i32 %182, %184
%186 = getelementptr inbounds i32, i32* %98, i64 %179
store i32 %185, i32* %186
%187 = add nuw nsw i64 %172, 2
%188 = trunc i64 %187 to i32
store i32 %188, i32* %7
%189 = icmp eq i64 %187, %11
br i1 %189, label %190, label %171
190: ; preds = %168, %171, %155, %84
%191 = add nuw nsw i32 %87, 1
%192 = icmp eq i32 %191, %76
br i1 %192, label %193, label %84
193: ; preds = %190
%194 = trunc i64 %91 to i32
%195 = trunc i64 %88 to i32
br label %196
196: ; preds = %193, %67
%197 = phi i32 [ %70, %67 ], [ %194, %193 ]
%198 = phi i32 [ %71, %67 ], [ %195, %193 ]
%199 = add nuw nsw i64 %68, 1
%200 = icmp eq i64 %199, %19
br i1 %200, label %35, label %67
201: ; preds = %44, %505
%202 = phi i64 [ 0, %44 ], [ %509, %505 ]
%203 = phi i64 [ 1, %44 ], [ %507, %505 ]
%204 = phi i64 [ 0, %44 ], [ %506, %505 ]
%205 = mul i64 %202, %11
%206 = add i64 %51, %205
%207 = add i64 %52, %205
%208 = icmp slt i64 %204, %45
br i1 %208, label %209, label %220
209: ; preds = %201
%210 = getelementptr inbounds i32, i32* %14, i64 %204
br label %211
211: ; preds = %209, %217
%212 = phi i64 [ %204, %209 ], [ %218, %217 ]
%213 = mul nuw nsw i64 %212, %11
%214 = getelementptr inbounds i32, i32* %210, i64 %213
%215 = load i32, i32* %214
%216 = icmp eq i32 %215, 0
br i1 %216, label %217, label %220
217: ; preds = %211
%218 = add nuw nsw i64 %212, 1
%219 = icmp eq i64 %218, %11
br i1 %219, label %224, label %211
220: ; preds = %211, %201
%221 = phi i64 [ %204, %201 ], [ %212, %211 ]
%222 = trunc i64 %221 to i32
%223 = icmp eq i32 %222, %0
br i1 %223, label %224, label %227
224: ; preds = %217, %220
%225 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @str, i64 0, i64 0))
%226 = add nuw nsw i64 %204, 1
br label %505
227: ; preds = %220
%228 = and i64 %221, 4294967295
%229 = icmp eq i64 %204, %228
br i1 %229, label %334, label %230
230: ; preds = %227
%231 = mul nuw nsw i64 %204, %11
%232 = getelementptr inbounds i32, i32* %14, i64 %231
%233 = mul nuw nsw i64 %228, %11
%234 = getelementptr inbounds i32, i32* %14, i64 %233
br i1 %57, label %309, label %235
235: ; preds = %230
%236 = bitcast i32* %234 to i8*
%237 = bitcast i32* %232 to i8*
%238 = shl i64 %204, 2
%239 = add i64 %238, 4
%240 = mul i64 %239, %11
%241 = getelementptr i8, i8* %15, i64 %240
%242 = shl nuw nsw i64 %228, 2
%243 = add nuw nsw i64 %242, 4
%244 = mul i64 %243, %11
%245 = getelementptr i8, i8* %15, i64 %244
%246 = icmp ugt i8* %245, %237
%247 = icmp ugt i8* %241, %236
%248 = and i1 %246, %247
br i1 %248, label %309, label %249
249: ; preds = %235
br i1 %60, label %289, label %250
250: ; preds = %249, %250
%251 = phi i64 [ %286, %250 ], [ 0, %249 ]
%252 = phi i64 [ %287, %250 ], [ 0, %249 ]
%253 = getelementptr inbounds i32, i32* %232, i64 %251
%254 = bitcast i32* %253 to <4 x i32>*
%255 = load <4 x i32>, <4 x i32>* %254
%256 = getelementptr inbounds i32, i32* %253, i64 4
%257 = bitcast i32* %256 to <4 x i32>*
%258 = load <4 x i32>, <4 x i32>* %257
%259 = getelementptr inbounds i32, i32* %234, i64 %251
%260 = bitcast i32* %259 to <4 x i32>*
%261 = load <4 x i32>, <4 x i32>* %260
%262 = getelementptr inbounds i32, i32* %259, i64 4
%263 = bitcast i32* %262 to <4 x i32>*
%264 = load <4 x i32>, <4 x i32>* %263
%265 = bitcast i32* %253 to <4 x i32>*
store <4 x i32> %261, <4 x i32>* %265
%266 = bitcast i32* %256 to <4 x i32>*
store <4 x i32> %264, <4 x i32>* %266
%267 = bitcast i32* %259 to <4 x i32>*
store <4 x i32> %255, <4 x i32>* %267
%268 = bitcast i32* %262 to <4 x i32>*
store <4 x i32> %258, <4 x i32>* %268
%269 = or i64 %251, 8
%270 = getelementptr inbounds i32, i32* %232, i64 %269
%271 = bitcast i32* %270 to <4 x i32>*
%272 = load <4 x i32>, <4 x i32>* %271
%273 = getelementptr inbounds i32, i32* %270, i64 4
%274 = bitcast i32* %273 to <4 x i32>*
%275 = load <4 x i32>, <4 x i32>* %274
%276 = getelementptr inbounds i32, i32* %234, i64 %269
%277 = bitcast i32* %276 to <4 x i32>*
%278 = load <4 x i32>, <4 x i32>* %277
%279 = getelementptr inbounds i32, i32* %276, i64 4
%280 = bitcast i32* %279 to <4 x i32>*
%281 = load <4 x i32>, <4 x i32>* %280
%282 = bitcast i32* %270 to <4 x i32>*
store <4 x i32> %278, <4 x i32>* %282
%283 = bitcast i32* %273 to <4 x i32>*
store <4 x i32> %281, <4 x i32>* %283
%284 = bitcast i32* %276 to <4 x i32>*
store <4 x i32> %272, <4 x i32>* %284
%285 = bitcast i32* %279 to <4 x i32>*
store <4 x i32> %275, <4 x i32>* %285
%286 = add nuw i64 %251, 16
%287 = add i64 %252, 2
%288 = icmp eq i64 %287, %61
br i1 %288, label %289, label %250
289: ; preds = %250, %249
%290 = phi i64 [ 0, %249 ], [ %286, %250 ]
br i1 %62, label %308, label %291
291: ; preds = %289
%292 = getelementptr inbounds i32, i32* %232, i64 %290
%293 = bitcast i32* %292 to <4 x i32>*
%294 = load <4 x i32>, <4 x i32>* %293
%295 = getelementptr inbounds i32, i32* %292, i64 4
%296 = bitcast i32* %295 to <4 x i32>*
%297 = load <4 x i32>, <4 x i32>* %296
%298 = getelementptr inbounds i32, i32* %234, i64 %290
%299 = bitcast i32* %298 to <4 x i32>*
%300 = load <4 x i32>, <4 x i32>* %299
%301 = getelementptr inbounds i32, i32* %298, i64 4
%302 = bitcast i32* %301 to <4 x i32>*
%303 = load <4 x i32>, <4 x i32>* %302
%304 = bitcast i32* %292 to <4 x i32>*
store <4 x i32> %300, <4 x i32>* %304
%305 = bitcast i32* %295 to <4 x i32>*
store <4 x i32> %303, <4 x i32>* %305
%306 = bitcast i32* %298 to <4 x i32>*
store <4 x i32> %294, <4 x i32>* %306
%307 = bitcast i32* %301 to <4 x i32>*
store <4 x i32> %297, <4 x i32>* %307
br label %308
308: ; preds = %289, %291
br i1 %63, label %334, label %309
309: ; preds = %235, %230, %308
%310 = phi i64 [ 0, %235 ], [ 0, %230 ], [ %58, %308 ]
%311 = xor i64 %310, -1
br i1 %65, label %318, label %312
312: ; preds = %309
%313 = getelementptr inbounds i32, i32* %232, i64 %310
%314 = load i32, i32* %313
%315 = getelementptr inbounds i32, i32* %234, i64 %310
%316 = load i32, i32* %315
store i32 %316, i32* %313
store i32 %314, i32* %315
%317 = or i64 %310, 1
br label %318
318: ; preds = %312, %309
%319 = phi i64 [ %310, %309 ], [ %317, %312 ]
%320 = icmp eq i64 %311, %66
br i1 %320, label %334, label %321
321: ; preds = %318, %321
%322 = phi i64 [ %332, %321 ], [ %319, %318 ]
%323 = getelementptr inbounds i32, i32* %232, i64 %322
%324 = load i32, i32* %323
%325 = getelementptr inbounds i32, i32* %234, i64 %322
%326 = load i32, i32* %325
store i32 %326, i32* %323
store i32 %324, i32* %325
%327 = add nuw nsw i64 %322, 1
%328 = getelementptr inbounds i32, i32* %232, i64 %327
%329 = load i32, i32* %328
%330 = getelementptr inbounds i32, i32* %234, i64 %327
%331 = load i32, i32* %330
store i32 %331, i32* %328
store i32 %329, i32* %330
%332 = add nuw nsw i64 %322, 2
%333 = icmp eq i64 %332, %11
br i1 %333, label %334, label %321
334: ; preds = %318, %321, %308, %227
%335 = add nuw nsw i64 %204, 1
%336 = icmp slt i64 %335, %45
br i1 %336, label %337, label %505
337: ; preds = %334
%338 = mul nuw nsw i64 %204, %11
%339 = getelementptr inbounds i32, i32* %14, i64 %338
%340 = getelementptr inbounds i32, i32* %339, i64 %204
%341 = mul i64 %50, %204
%342 = getelementptr i8, i8* %48, i64 %341
%343 = shl i64 %204, 2
%344 = add i64 %343, 4
%345 = mul i64 %344, %11
%346 = getelementptr i8, i8* %15, i64 %345
%347 = add i64 %204, %206
%348 = xor i64 %204, -1
%349 = add i64 %348, %11
%350 = add i64 %349, -4
%351 = lshr i64 %350, 2
%352 = add nuw nsw i64 %351, 1
%353 = getelementptr inbounds i32, i32* %339, i64 %204
%354 = add nuw nsw i64 %204, 1
%355 = icmp eq i64 %354, %11
%356 = icmp ult i64 %349, 4
%357 = icmp ult i8* %342, %346
%358 = and i64 %349, -4
%359 = add i64 %354, %358
%360 = and i64 %352, 1
%361 = icmp ult i64 %350, 4
%362 = and i64 %352, 9223372036854775806
%363 = icmp eq i64 %360, 0
%364 = icmp eq i64 %349, %358
br label %365
365: ; preds = %337, %501
%366 = phi i64 [ 0, %337 ], [ %504, %501 ]
%367 = phi i64 [ %203, %337 ], [ %502, %501 ]
%368 = mul i64 %366, %11
%369 = add i64 %347, %368
%370 = getelementptr i32, i32* %14, i64 %369
%371 = bitcast i32* %370 to i8*
%372 = add i64 %207, %368
%373 = getelementptr i32, i32* %14, i64 %372
%374 = bitcast i32* %373 to i8*
%375 = mul nuw nsw i64 %367, %11
%376 = getelementptr inbounds i32, i32* %14, i64 %375
%377 = getelementptr inbounds i32, i32* %376, i64 %204
%378 = load i32, i32* %377
%379 = icmp eq i32 %378, 0
br i1 %379, label %501, label %380
380: ; preds = %365
%381 = load i32, i32* %340
%382 = call i32 (i32, i32, i32*, i32*, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, i32*, i32*, ...)*)(i32 %381, i32 %378, i32* %7, i32* %8)
%383 = sdiv i32 %378, %382
%384 = sdiv i32 %381, %382
%385 = load i32, i32* %7
%386 = load i32, i32* %8
%387 = mul nsw i32 %385, %381
%388 = getelementptr inbounds i32, i32* %376, i64 %204
%389 = mul nsw i32 %378, %386
%390 = add nsw i32 %389, %387
store i32 %390, i32* %353
%391 = mul i32 %381, %383
%392 = load i32, i32* %388
%393 = mul nsw i32 %392, %384
%394 = sub i32 %393, %391
store i32 %394, i32* %388
br i1 %355, label %501, label %395
395: ; preds = %380
br i1 %356, label %482, label %396
396: ; preds = %395
%397 = icmp ult i8* %342, %374
%398 = icmp ugt i8* %346, %371
%399 = and i1 %397, %398
%400 = or i1 %399, %357
%401 = icmp ult i8* %342, %374
%402 = icmp ugt i8* %346, %371
%403 = and i1 %401, %402
%404 = or i1 %400, %403
%405 = icmp ugt i8* %346, %371
%406 = icmp ult i8* %342, %374
%407 = and i1 %405, %406
%408 = or i1 %404, %407
%409 = icmp ult i32* %370, %373
%410 = or i1 %408, %409
br i1 %410, label %482, label %411
411: ; preds = %396
%412 = insertelement <4 x i32> poison, i32 %385, i64 0
%413 = shufflevector <4 x i32> %412, <4 x i32> poison, <4 x i32> zeroinitializer
%414 = insertelement <4 x i32> poison, i32 %386, i64 0
%415 = shufflevector <4 x i32> %414, <4 x i32> poison, <4 x i32> zeroinitializer
%416 = insertelement <4 x i32> poison, i32 %383, i64 0
%417 = shufflevector <4 x i32> %416, <4 x i32> poison, <4 x i32> zeroinitializer
%418 = insertelement <4 x i32> poison, i32 %384, i64 0
%419 = shufflevector <4 x i32> %418, <4 x i32> poison, <4 x i32> zeroinitializer
br i1 %361, label %461, label %420
420: ; preds = %411, %420
%421 = phi i64 [ %458, %420 ], [ 0, %411 ]
%422 = phi i64 [ %459, %420 ], [ 0, %411 ]
%423 = add i64 %354, %421
%424 = getelementptr inbounds i32, i32* %339, i64 %423
%425 = bitcast i32* %424 to <4 x i32>*
%426 = load <4 x i32>, <4 x i32>* %425
%427 = getelementptr inbounds i32, i32* %376, i64 %423
%428 = bitcast i32* %427 to <4 x i32>*
%429 = load <4 x i32>, <4 x i32>* %428
%430 = mul nsw <4 x i32> %413, %426
%431 = mul nsw <4 x i32> %429, %415
%432 = add nsw <4 x i32> %431, %430
%433 = bitcast i32* %424 to <4 x i32>*
store <4 x i32> %432, <4 x i32>* %433
%434 = mul <4 x i32> %426, %417
%435 = bitcast i32* %427 to <4 x i32>*
%436 = load <4 x i32>, <4 x i32>* %435
%437 = mul nsw <4 x i32> %436, %419
%438 = sub <4 x i32> %437, %434
%439 = bitcast i32* %427 to <4 x i32>*
store <4 x i32> %438, <4 x i32>* %439
%440 = or i64 %421, 4
%441 = add i64 %354, %440
%442 = getelementptr inbounds i32, i32* %339, i64 %441
%443 = bitcast i32* %442 to <4 x i32>*
%444 = load <4 x i32>, <4 x i32>* %443
%445 = getelementptr inbounds i32, i32* %376, i64 %441
%446 = bitcast i32* %445 to <4 x i32>*
%447 = load <4 x i32>, <4 x i32>* %446
%448 = mul nsw <4 x i32> %413, %444
%449 = mul nsw <4 x i32> %447, %415
%450 = add nsw <4 x i32> %449, %448
%451 = bitcast i32* %442 to <4 x i32>*
store <4 x i32> %450, <4 x i32>* %451
%452 = mul <4 x i32> %444, %417
%453 = bitcast i32* %445 to <4 x i32>*
%454 = load <4 x i32>, <4 x i32>* %453
%455 = mul nsw <4 x i32> %454, %419
%456 = sub <4 x i32> %455, %452
%457 = bitcast i32* %445 to <4 x i32>*
store <4 x i32> %456, <4 x i32>* %457
%458 = add nuw i64 %421, 8
%459 = add i64 %422, 2
%460 = icmp eq i64 %459, %362
br i1 %460, label %461, label %420
461: ; preds = %420, %411
%462 = phi i64 [ 0, %411 ], [ %458, %420 ]
br i1 %363, label %481, label %463
463: ; preds = %461
%464 = add i64 %354, %462
%465 = getelementptr inbounds i32, i32* %339, i64 %464
%466 = bitcast i32* %465 to <4 x i32>*
%467 = load <4 x i32>, <4 x i32>* %466
%468 = getelementptr inbounds i32, i32* %376, i64 %464
%469 = bitcast i32* %468 to <4 x i32>*
%470 = load <4 x i32>, <4 x i32>* %469
%471 = mul nsw <4 x i32> %413, %467
%472 = mul nsw <4 x i32> %470, %415
%473 = add nsw <4 x i32> %472, %471
%474 = bitcast i32* %465 to <4 x i32>*
store <4 x i32> %473, <4 x i32>* %474
%475 = mul <4 x i32> %467, %417
%476 = bitcast i32* %468 to <4 x i32>*
%477 = load <4 x i32>, <4 x i32>* %476
%478 = mul nsw <4 x i32> %477, %419
%479 = sub <4 x i32> %478, %475
%480 = bitcast i32* %468 to <4 x i32>*
store <4 x i32> %479, <4 x i32>* %480
br label %481
481: ; preds = %461, %463
br i1 %364, label %501, label %482
482: ; preds = %396, %395, %481
%483 = phi i64 [ %354, %396 ], [ %354, %395 ], [ %359, %481 ]
br label %484
484: ; preds = %482, %484
%485 = phi i64 [ %499, %484 ], [ %483, %482 ]
%486 = getelementptr inbounds i32, i32* %339, i64 %485
%487 = load i32, i32* %486
%488 = getelementptr inbounds i32, i32* %376, i64 %485
%489 = load i32, i32* %488
%490 = getelementptr inbounds i32, i32* %339, i64 %485
%491 = mul nsw i32 %385, %487
%492 = getelementptr inbounds i32, i32* %376, i64 %485
%493 = mul nsw i32 %489, %386
%494 = add nsw i32 %493, %491
store i32 %494, i32* %490
%495 = mul i32 %487, %383
%496 = load i32, i32* %492
%497 = mul nsw i32 %496, %384
%498 = sub i32 %497, %495
store i32 %498, i32* %492
%499 = add nuw nsw i64 %485, 1
%500 = icmp eq i64 %499, %11
br i1 %500, label %501, label %484
501: ; preds = %484, %380, %481, %365
%502 = add nuw nsw i64 %367, 1
%503 = icmp eq i64 %502, %11
%504 = add i64 %366, 1
br i1 %503, label %505, label %365
505: ; preds = %501, %334, %224
%506 = phi i64 [ %335, %334 ], [ %226, %224 ], [ %335, %501 ]
%507 = add nuw nsw i64 %203, 1
%508 = icmp eq i64 %506, %46
%509 = add i64 %202, 1
br i1 %508, label %510, label %201
510: ; preds = %505
%511 = sext i32 %36 to i64
%512 = mul nsw i64 %511, %11
%513 = getelementptr inbounds i32, i32* %14, i64 %512
%514 = getelementptr inbounds i32, i32* %513, i64 %511
%515 = load i32, i32* %514
br i1 %37, label %516, label %569
516: ; preds = %510
%517 = add nsw i64 %46, -1
%518 = and i64 %46, 3
%519 = icmp ult i64 %517, 3
br i1 %519, label %552, label %520
520: ; preds = %516
%521 = and i64 %46, 4294967292
br label %522
522: ; preds = %522, %520
%523 = phi i64 [ 0, %520 ], [ %549, %522 ]
%524 = phi i32 [ %515, %520 ], [ %548, %522 ]
%525 = phi i64 [ 0, %520 ], [ %550, %522 ]
%526 = mul nuw nsw i64 %523, %11
%527 = getelementptr inbounds i32, i32* %14, i64 %526
%528 = getelementptr inbounds i32, i32* %527, i64 %523
%529 = load i32, i32* %528
%530 = mul nsw i32 %529, %524
%531 = or i64 %523, 1
%532 = mul nuw nsw i64 %531, %11
%533 = getelementptr inbounds i32, i32* %14, i64 %532
%534 = getelementptr inbounds i32, i32* %533, i64 %531
%535 = load i32, i32* %534
%536 = mul nsw i32 %535, %530
%537 = or i64 %523, 2
%538 = mul nuw nsw i64 %537, %11
%539 = getelementptr inbounds i32, i32* %14, i64 %538
%540 = getelementptr inbounds i32, i32* %539, i64 %537
%541 = load i32, i32* %540
%542 = mul nsw i32 %541, %536
%543 = or i64 %523, 3
%544 = mul nuw nsw i64 %543, %11
%545 = getelementptr inbounds i32, i32* %14, i64 %544
%546 = getelementptr inbounds i32, i32* %545, i64 %543
%547 = load i32, i32* %546
%548 = mul nsw i32 %547, %542
%549 = add nuw nsw i64 %523, 4
%550 = add i64 %525, 4
%551 = icmp eq i64 %550, %521
br i1 %551, label %552, label %522
552: ; preds = %522, %516
%553 = phi i32 [ undef, %516 ], [ %548, %522 ]
%554 = phi i64 [ 0, %516 ], [ %549, %522 ]
%555 = phi i32 [ %515, %516 ], [ %548, %522 ]
%556 = icmp eq i64 %518, 0
br i1 %556, label %569, label %557
557: ; preds = %552, %557
%558 = phi i64 [ %566, %557 ], [ %554, %552 ]
%559 = phi i32 [ %565, %557 ], [ %555, %552 ]
%560 = phi i64 [ %567, %557 ], [ 0, %552 ]
%561 = mul nuw nsw i64 %558, %11
%562 = getelementptr inbounds i32, i32* %14, i64 %561
%563 = getelementptr inbounds i32, i32* %562, i64 %558
%564 = load i32, i32* %563
%565 = mul nsw i32 %564, %559
%566 = add nuw nsw i64 %558, 1
%567 = add i64 %560, 1
%568 = icmp eq i64 %567, %518
br i1 %568, label %569, label %557
569: ; preds = %552, %557, %38, %510
%570 = phi i32 [ %515, %510 ], [ %43, %38 ], [ %553, %552 ], [ %565, %557 ]
%571 = load i32, i32* %5
%572 = call i32 @llvm.abs.i32(i32 %570, i1 false)
%573 = add i32 %571, %572
store i32 %573, i32* %5
ret void
}