int main(void) {
  int n, err, tmp;
  err = scanf("%d", &n);
  int ring[n];
  int ans[n];
  for (int i = 0; i < n; i++) {
    err = scanf("%d", &ring[i]);
  }
  if (err < 0) {
    return -1;
  }
  if (n == 1) {
    ans[0] = ring[0];
  }
  if (n == 2) {
    ans[0] = (int)ceil((double)ring[0] / 2);
    ans[1] = (int)floor((double)ring[0] / 2);
  }
  if (n == 3) {
    ans[0] = (int)ceil((double)ring[0] / 2);
    tmp = (int)floor((double)ring[0] / 2);
    ans[1] = (int)floor((double)tmp / 2);
    ans[2] = (int)ceil((double)tmp / 2);
  }
  if (n < 4) {
    for (int i = 0; i < n; i++) {
      printf("%d\n", ans[i]);
    }
  } else {
    double matrix[n][n + 1];
    for (int i = 0; i < n; i++) {
      matrix[i][i] = 1;
      if (i == 0) {
        matrix[i][n - 1] = 1;
      } else {
        matrix[i][i - 1] = 1;
      }
      if (i == n - 1) {
        matrix[i][0] = 1;
      } else {
        matrix[i][i + 1] = 1;
      }
      matrix[i][n] = ring[i];
    }
    int lead = 0;
    int rowCount = n;
    int colCount = n + 1;
    int i;
    int quit = 0;
    for (int row = 0; row < rowCount && !quit; row++) {
      if (colCount <= lead) {
        quit = 1;
        break;
      }
      i = row;
      while (!quit && matrix[i][lead] == 0) {
        i++;
        if (rowCount == i) {
          i = row;
          lead++;
          if (colCount == lead) {
            quit = 1;
            break;
          }
        }
        for (int i = 0; i < n; i++) {
          for (int j = 0; j < n + 1; j++) {
            printf("%.0f ", matrix[i][j]);
          }
          printf("\n");
        }
        printf("%d, %d, %.0f\n", i, row, matrix[i][lead]);
        printf("\n");
      }
      printf("\n");
      if (!quit) {
        double swap[colCount];
        for (int c1 = 0; c1 < colCount; c1++) {
          swap[c1] = matrix[i][c1];
        }
        for (int c1 = 0; c1 < colCount; c1++) {
          matrix[i][c1] = matrix[row][c1];
          matrix[row][c1] = swap[c1];
        }
        if (matrix[row][lead] != 0) {
          for (int c1 = 0; c1 < colCount; c1++) {
            matrix[row][c1] *= (1.0f / matrix[row][lead]);
          }
        }
        for (i = 0; i < rowCount; i++) {
          if (i != row) {
            for (int c1 = 0; c1 < colCount; c1++) {
              matrix[i][c1] -= (matrix[i][lead]) * matrix[row][c1];
            }
          }
        }
      }
    }
    printf("\n");
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n + 1; j++) {
        printf("%.0f ", matrix[i][j]);
      }
      printf("\n");
    }
    for (int i = 0; i < n; i++) {
      printf("%.0f\n", matrix[i][n]);
    }
    return 0;
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeb7(%rip),%rdi
xor    %eax,%eax
lea    -0x8(%rbp),%rsi
call   1050 <scanf@plt>
mov    %eax,-0xc(%rbp)
mov    -0x8(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x18(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xb8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xb0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11f8 <main+0xb8>
mov    -0xb8(%rbp),%rsi
movslq -0x2c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe30(%rip),%rdi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    %eax,-0xc(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11bb <main+0x7b>
cmpl   $0x0,-0xc(%rbp)
jge    1215 <main+0xd5>
movl   $0xffffffff,-0x4(%rbp)
movl   $0x1,-0x30(%rbp)
jmp    1b62 <main+0xa22>
cmpl   $0x1,-0x8(%rbp)
jne    1231 <main+0xf1>
mov    -0xb0(%rbp),%rax
mov    -0xb8(%rbp),%rcx
mov    (%rcx),%ecx
mov    %ecx,(%rax)
cmpl   $0x2,-0x8(%rbp)
jne    128e <main+0x14e>
mov    -0xb8(%rbp),%rax
cvtsi2sdl (%rax),%xmm0
movsd  0xdb2(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <ceil@plt>
mov    -0xb8(%rbp),%rax
mov    -0xb0(%rbp),%rcx
cvttsd2si %xmm0,%edx
mov    %edx,(%rcx)
cvtsi2sdl (%rax),%xmm0
movsd  0xd89(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1060 <floor@plt>
mov    -0xb0(%rbp),%rax
cvttsd2si %xmm0,%ecx
mov    %ecx,0x4(%rax)
cmpl   $0x3,-0x8(%rbp)
jne    132c <main+0x1ec>
mov    -0xb8(%rbp),%rax
cvtsi2sdl (%rax),%xmm0
movsd  0xd55(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <ceil@plt>
mov    -0xb8(%rbp),%rax
mov    -0xb0(%rbp),%rcx
cvttsd2si %xmm0,%edx
mov    %edx,(%rcx)
cvtsi2sdl (%rax),%xmm0
movsd  0xd2c(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1060 <floor@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x10(%rbp)
cvtsi2sdl -0x10(%rbp),%xmm0
movsd  0xd0f(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1060 <floor@plt>
mov    -0xb0(%rbp),%rax
cvttsd2si %xmm0,%ecx
mov    %ecx,0x4(%rax)
cvtsi2sdl -0x10(%rbp),%xmm0
movsd  0xceb(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <ceil@plt>
mov    -0xb0(%rbp),%rax
cvttsd2si %xmm0,%ecx
mov    %ecx,0x8(%rax)
cmpl   $0x4,-0x8(%rbp)
jge    1378 <main+0x238>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1373 <main+0x233>
mov    -0xb0(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xcb5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    133d <main+0x1fd>
jmp    1b5b <main+0xa1b>
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
mov    %ecx,%eax
add    $0x1,%eax
mov    %rax,-0xc8(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x40(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0xc0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x48(%rbp)
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1521 <main+0x3e1>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
movslq -0x54(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x54(%rbp),%rcx
movsd  0xc11(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x54(%rbp)
jne    143e <main+0x2fe>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
movslq -0x54(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xbd4(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1471 <main+0x331>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
movslq -0x54(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xb9c(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    14aa <main+0x36a>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
movslq -0x54(%rbp),%rcx
imul   %rdx,%rcx
movsd  0xb68(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    14dd <main+0x39d>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
movslq -0x54(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xb30(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
mov    -0xb8(%rbp),%rcx
movslq -0x54(%rbp),%rsi
cvtsi2sdl (%rcx,%rsi,4),%xmm0
movslq -0x54(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    13c2 <main+0x282>
movl   $0x0,-0x58(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x5c(%rbp),%ecx
mov    %al,-0xc9(%rbp)
jge    1568 <main+0x428>
cmpl   $0x0,-0x68(%rbp)
setne  %al
xor    $0xff,%al
mov    %al,-0xc9(%rbp)
mov    -0xc9(%rbp),%al
test   $0x1,%al
jne    157b <main+0x43b>
jmp    1a28 <main+0x8e8>
mov    -0x60(%rbp),%eax
cmp    -0x58(%rbp),%eax
jg     1593 <main+0x453>
movl   $0x1,-0x68(%rbp)
jmp    1a28 <main+0x8e8>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x64(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x68(%rbp)
mov    %al,-0xca(%rbp)
jne    15e6 <main+0x4a6>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
movslq -0x64(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
sete   %al
setnp  %cl
and    %cl,%al
mov    %al,-0xca(%rbp)
mov    -0xca(%rbp),%al
test   $0x1,%al
jne    15f9 <main+0x4b9>
jmp    1710 <main+0x5d0>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x64(%rbp),%eax
jne    163a <main+0x4fa>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x58(%rbp),%eax
jne    1635 <main+0x4f5>
movl   $0x1,-0x68(%rbp)
jmp    1710 <main+0x5d0>
jmp    163a <main+0x4fa>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16c3 <main+0x583>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    16a7 <main+0x567>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
movslq -0x70(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x985(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1654 <main+0x514>
lea    0x967(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1641 <main+0x501>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdi
mov    -0x64(%rbp),%esi
mov    -0x6c(%rbp),%edx
movslq -0x64(%rbp),%rcx
imul   %rdi,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x927(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
lea    0x911(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1599 <main+0x459>
lea    0x8fe(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmpl   $0x0,-0x68(%rbp)
jne    1a15 <main+0x8d5>
mov    -0x60(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x80(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xd8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    17be <main+0x67e>
mov    -0xd8(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    -0xc8(%rbp),%rsi
movslq -0x64(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
movslq -0x8c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    175f <main+0x61f>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1863 <main+0x723>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
mov    -0xd8(%rbp),%rcx
movslq -0x6c(%rbp),%rdi
imul   %rdx,%rdi
shl    $0x3,%rdi
mov    %rax,%rsi
add    %rdi,%rsi
movslq -0x90(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm0
movslq -0x64(%rbp),%rdi
imul   %rdx,%rdi
shl    $0x3,%rdi
mov    %rax,%rsi
add    %rdi,%rsi
movslq -0x90(%rbp),%rdi
movsd  %xmm0,(%rsi,%rdi,8)
movslq -0x90(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x6c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    17c8 <main+0x688>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
movslq -0x6c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    18a1 <main+0x761>
jp     18a1 <main+0x761>
jmp    1924 <main+0x7e4>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    191f <main+0x7df>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
movslq -0x6c(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x58(%rbp),%rsi
movsd  0x722(%rip),%xmm0
divsd  (%rcx,%rsi,8),%xmm0
movslq -0x6c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x94(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    18ab <main+0x76b>
jmp    1924 <main+0x7e4>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    1a0e <main+0x8ce>
mov    -0x64(%rbp),%eax
cmp    -0x6c(%rbp),%eax
je     19fb <main+0x8bb>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    19f6 <main+0x8b6>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
movslq -0x64(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x58(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x6c(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x98(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm2
movslq -0x64(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    194d <main+0x80d>
jmp    19fb <main+0x8bb>
jmp    1a00 <main+0x8c0>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    192b <main+0x7eb>
mov    -0x80(%rbp),%rax
mov    %rax,%rsp
jmp    1a1a <main+0x8da>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1545 <main+0x405>
lea    0x5e6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1add <main+0x99d>
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1abb <main+0x97b>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
movslq -0x9c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x577(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1a59 <main+0x919>
lea    0x553(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1a40 <main+0x900>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1b41 <main+0xa01>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
movslq -0xa4(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x4ff(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1ae7 <main+0x9a7>
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rsp
jmp    1b62 <main+0xa22>
movl   $0x0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
lea    0xec5(%rip),%rdi
lea    -0x2c(%rbp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
mov    %rsp,%r13
mov    -0x2c(%rbp),%ecx
mov    %rsp,%rbx
lea    0xf(,%rcx,4),%rcx
and    $0xfffffffffffffff0,%rcx
sub    %rcx,%rbx
mov    %rbx,%rsp
mov    -0x2c(%rbp),%r15d
mov    %rsp,%r12
lea    0xf(,%r15,4),%rcx
and    $0xfffffffffffffff0,%rcx
sub    %rcx,%r12
mov    %r12,%rsp
test   %r15d,%r15d
jle    1209 <main+0xa9>
mov    %r13,-0x88(%rbp)
lea    0xe73(%rip),%r14
mov    %rbx,-0x60(%rbp)
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
add    $0x1,%r13
movslq -0x2c(%rbp),%r15
add    $0x4,%rbx
cmp    %r15,%r13
jl     11e0 <main+0x80>
mov    -0x88(%rbp),%r13
mov    -0x60(%rbp),%rbx
test   %eax,%eax
js     1232 <main+0xd2>
cmp    $0x3,%r15d
je     123d <main+0xdd>
cmp    $0x2,%r15d
je     129d <main+0x13d>
cmp    $0x1,%r15d
jne    1320 <main+0x1c0>
mov    (%rbx),%ebx
mov    %ebx,(%r12)
jmp    12ce <main+0x16e>
mov    $0xffffffff,%r15d
jmp    1bf3 <main+0xa93>
cvtsi2sdl (%rbx),%xmm0
mulsd  0xdb7(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
call   1040 <ceil@plt>
cvttsd2si %xmm0,%ebx
mov    %ebx,(%r12)
movsd  -0x60(%rbp),%xmm0
call   1080 <floor@plt>
cvttpd2dq %xmm0,%xmm0
cvtdq2pd %xmm0,%xmm0
mulsd  0xd8b(%rip),%xmm0
movapd %xmm0,-0x60(%rbp)
call   1080 <floor@plt>
cvttsd2si %xmm0,%eax
mov    %eax,0x4(%r12)
movapd -0x60(%rbp),%xmm0
call   1040 <ceil@plt>
cvttsd2si %xmm0,%eax
mov    %eax,0x8(%r12)
jmp    12ce <main+0x16e>
cvtsi2sdl (%rbx),%xmm0
mulsd  0xd57(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
call   1040 <ceil@plt>
cvttsd2si %xmm0,%ebx
mov    %ebx,(%r12)
movsd  -0x60(%rbp),%xmm0
call   1080 <floor@plt>
cvttsd2si %xmm0,%eax
mov    %eax,0x4(%r12)
lea    0xd6e(%rip),%rdi
xor    %r15d,%r15d
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x2,-0x2c(%rbp)
jl     1bf3 <main+0xa93>
mov    $0x1,%ebx
lea    0xd4c(%rip),%r14
xor    %r15d,%r15d
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbx
movslq -0x2c(%rbp),%rax
cmp    %rax,%rbx
jl     1300 <main+0x1a0>
jmp    1bf3 <main+0xa93>
cmp    $0x4,%r15d
jl     1bf0 <main+0xa90>
mov    %r13,-0x88(%rbp)
mov    %rsp,-0xd8(%rbp)
mov    %r15d,%eax
add    $0x1,%r15d
imul   %r15,%rax
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
mov    -0x2c(%rbp),%r11d
test   %r11d,%r11d
mov    %r12,-0x48(%rbp)
jle    1b25 <main+0x9c5>
mov    %r11d,%eax
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%r12)
add    $0xffffffff,%eax
mov    %rcx,(%r12,%rax,8)
je     13f8 <main+0x298>
cvtsi2sdl (%rbx),%xmm0
mov    %rcx,0x8(%r12)
movsd  %xmm0,(%r12,%r11,8)
mov    $0x1,%edx
movapd 0xc81(%rip),%xmm0
jmp    13cf <main+0x26f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1(%rdx),%rdi
mov    %rcx,0x8(%rsi,%rdx,8)
xorps  %xmm1,%xmm1
cvtsi2sdl (%rbx,%rdx,4),%xmm1
movsd  %xmm1,(%rsi,%r11,8)
mov    %rdi,%rdx
cmp    %r11,%rdi
je     13ee <main+0x28e>
mov    %rdx,%rsi
imul   %r15,%rsi
lea    (%r12,%rsi,8),%rsi
movupd %xmm0,-0x8(%rsi,%rdx,8)
cmp    %rax,%rdx
jne    13b0 <main+0x250>
mov    %rcx,(%rsi)
lea    0x1(%rdx),%rdi
jmp    13b9 <main+0x259>
test   %r11d,%r11d
jg     1406 <main+0x2a6>
jmp    1b25 <main+0x9c5>
mov    %rcx,(%r12)
cvtsi2sdl (%rbx),%xmm0
movsd  %xmm0,(%r12,%r11,8)
lea    0x1(%r11),%r9
lea    0x8(,%r11,8),%rax
mov    %rax,-0xf0(%rbp)
mov    %r9d,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x98(%rbp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0xc8(%rbp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,-0xc0(%rbp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0xb8(%rbp)
mov    %r11,%rax
not    %rax
mov    %rax,-0x100(%rbp)
lea    0x0(,%r15,8),%rax
mov    %rax,-0x60(%rbp)
lea    0x30(%r12),%rcx
lea    0x8(%r12),%rax
mov    %r11d,%edx
and    $0xfffffffe,%edx
neg    %rdx
mov    %rdx,-0xd0(%rbp)
lea    0x10(%r12),%rdx
xor    %r10d,%r10d
lea    0xbb4(%rip),%r13
mov    %r12,%rsi
mov    %rdx,-0xe0(%rbp)
mov    %rax,-0xe8(%rbp)
mov    %rax,-0x80(%rbp)
xor    %ebx,%ebx
mov    %r11,-0xb0(%rbp)
mov    %r9,-0x40(%rbp)
mov    %r15,-0x108(%rbp)
mov    %rdx,-0xa0(%rbp)
mov    %rsi,-0xa8(%rbp)
mov    %rcx,-0x90(%rbp)
movslq %r10d,%rax
imul   %r15,%rax
lea    (%r12,%rax,8),%r12
movslq %ebx,%r14
movsd  (%r12,%r14,8),%xmm0
ucomisd 0xb23(%rip),%xmm0
mov    %r10,-0x38(%rbp)
jne    1610 <main+0x4b0>
jp     1610 <main+0x4b0>
mov    %r10d,%eax
jmp    157a <main+0x41a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq -0x50(%rbp),%rsi
mov    %rsi,%rax
mov    -0x108(%rbp),%r15
imul   %r15,%rax
mov    -0x48(%rbp),%rcx
lea    (%rcx,%rax,8),%r12
mov    -0x30(%rbp),%ebx
movslq %ebx,%r14
movsd  (%r12,%r14,8),%xmm0
lea    0xb10(%rip),%rdi
mov    -0x38(%rbp),%rdx
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    -0x50(%rbp),%eax
movsd  (%r12,%r14,8),%xmm0
ucomisd 0xaad(%rip),%xmm0
mov    -0xb0(%rbp),%r11
mov    -0x40(%rbp),%r9
jne    1610 <main+0x4b0>
jp     1610 <main+0x4b0>
add    $0x1,%eax
cmp    %eax,%r11d
jne    15a0 <main+0x440>
cmp    %ebx,%r11d
je     1b17 <main+0x9b7>
add    $0x1,%ebx
mov    %ebx,-0x30(%rbp)
mov    -0x38(%rbp),%rax
mov    %eax,-0x50(%rbp)
jmp    15a6 <main+0x446>
nopw   0x0(%rax,%rax,1)
mov    %eax,-0x50(%rbp)
mov    %ebx,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
test   %eax,%eax
jle    1510 <main+0x3b0>
mov    -0x48(%rbp),%rbx
xor    %r14d,%r14d
jmp    15df <main+0x47f>
nopw   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r14
movslq -0x2c(%rbp),%rax
add    -0x60(%rbp),%rbx
cmp    %rax,%r14
jge    1510 <main+0x3b0>
test   %eax,%eax
js     15c0 <main+0x460>
mov    $0xffffffffffffffff,%r12
nopw   0x0(%rax,%rax,1)
movsd  0x8(%rbx,%r12,8),%xmm0
mov    %r13,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movslq -0x2c(%rbp),%rax
add    $0x1,%r12
cmp    %rax,%r12
jl     15f0 <main+0x490>
jmp    15c0 <main+0x460>
mov    %ebx,-0x30(%rbp)
mov    -0x38(%rbp),%rax
imul   %r15,%rax
mov    -0x48(%rbp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    %rdx,-0x68(%rbp)
add    %r9,%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,-0x50(%rbp)
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %rsp,-0xf8(%rbp)
mov    %rsp,%rbx
mov    -0x40(%rbp),%rax
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rbx
mov    %rbx,%rsp
mov    %rbx,%rdi
mov    %r12,%rsi
mov    -0xf0(%rbp),%rdx
call   1060 <memcpy@plt>
mov    -0x68(%rbp),%r8
mov    -0xb0(%rbp),%r11
cmp    $0x3,%r11d
jae    1696 <main+0x536>
xor    %eax,%eax
mov    -0x40(%rbp),%r9
mov    -0x38(%rbp),%r10
movsd  0x977(%rip),%xmm2
jmp    17ec <main+0x68c>
mov    -0x40(%rbp),%r9
lea    (%r12,%r9,8),%rcx
lea    (%rbx,%r9,8),%rdx
mov    -0x50(%rbp),%r10
cmp    %r10,%r12
setb   %dil
cmp    %rcx,%r8
mov    %r8,%rsi
setb   %r8b
mov    %r12,-0x70(%rbp)
cmp    %rdx,%r12
setb   %al
cmp    %rcx,%rbx
setb   %r12b
cmp    %rdx,%rsi
setb   %cl
mov    %rbx,-0x78(%rbp)
cmp    %r10,%rbx
setb   %dl
test   %r8b,%dil
movsd  0x925(%rip),%xmm2
jne    17d6 <main+0x676>
and    %r12b,%al
mov    -0x98(%rbp),%rsi
mov    -0x38(%rbp),%r10
jne    17de <main+0x67e>
mov    $0x0,%eax
and    %dl,%cl
mov    -0x90(%rbp),%rdx
mov    -0x68(%rbp),%r8
mov    -0x70(%rbp),%r12
mov    -0x78(%rbp),%rbx
jne    17ec <main+0x68c>
cmpq   $0x0,-0xc8(%rbp)
je     1790 <main+0x630>
mov    -0xb8(%rbp),%rcx
xor    %eax,%eax
movups -0x30(%rdx,%rax,8),%xmm0
movups -0x20(%rdx,%rax,8),%xmm1
movups %xmm0,(%r12,%rax,8)
movups %xmm1,0x10(%r12,%rax,8)
movaps (%rbx,%rax,8),%xmm0
movaps 0x10(%rbx,%rax,8),%xmm1
movups %xmm0,-0x30(%rdx,%rax,8)
movups %xmm1,-0x20(%rdx,%rax,8)
movups -0x10(%rdx,%rax,8),%xmm0
movups (%rdx,%rax,8),%xmm1
movups %xmm0,0x20(%r12,%rax,8)
movups %xmm1,0x30(%r12,%rax,8)
movapd 0x20(%rbx,%rax,8),%xmm0
movapd 0x30(%rbx,%rax,8),%xmm1
movupd %xmm0,-0x10(%rdx,%rax,8)
movupd %xmm1,(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1730 <main+0x5d0>
jmp    1792 <main+0x632>
xor    %eax,%eax
testb  $0x1,-0xc0(%rbp)
je     17c9 <main+0x669>
movups (%r8,%rax,8),%xmm0
movups 0x10(%r8,%rax,8),%xmm1
movups %xmm0,(%r12,%rax,8)
movups %xmm1,0x10(%r12,%rax,8)
movapd (%rbx,%rax,8),%xmm0
movapd 0x10(%rbx,%rax,8),%xmm1
movupd %xmm0,(%r8,%rax,8)
movupd %xmm1,0x10(%r8,%rax,8)
mov    %rsi,%rax
cmp    %r9,%rsi
jne    17ec <main+0x68c>
jmp    1857 <main+0x6f7>
xor    %eax,%eax
mov    -0x38(%rbp),%r10
jmp    17e0 <main+0x680>
xor    %eax,%eax
mov    -0x68(%rbp),%r8
mov    -0x70(%rbp),%r12
mov    -0x78(%rbp),%rbx
mov    %rax,%rcx
test   $0x1,%r9b
je     1813 <main+0x6b3>
movsd  (%r8,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r8,%rax,8)
mov    %rax,%rcx
or     $0x1,%rcx
cmp    %rax,%r11
mov    -0x80(%rbp),%rax
je     1857 <main+0x6f7>
nopl   0x0(%rax)
movsd  -0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r12,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1820 <main+0x6c0>
movsd  (%r8,%r14,8),%xmm0
ucomisd 0x7ab(%rip),%xmm0
mov    -0x48(%rbp),%r12
jne    1871 <main+0x711>
jnp    18f8 <main+0x798>
movapd %xmm2,%xmm1
divsd  %xmm0,%xmm1
mulsd  (%r8),%xmm1
movsd  %xmm1,(%r8)
mov    $0x1,%eax
cmp    $0x2,%r9d
mov    -0xd0(%rbp),%rdx
mov    -0x80(%rbp),%rsi
je     18dc <main+0x77c>
mov    $0x1,%eax
xchg   %ax,%ax
movapd %xmm2,%xmm0
divsd  (%r8,%r14,8),%xmm0
mulsd  -0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rax,8)
movapd %xmm2,%xmm0
divsd  (%r8,%r14,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
lea    (%rdx,%rax,1),%rcx
add    $0x2,%rcx
add    $0x2,%rax
cmp    $0x1,%rcx
jne    18a0 <main+0x740>
test   $0x1,%r11b
je     18f8 <main+0x798>
movapd %xmm2,%xmm0
divsd  (%r8,%r14,8),%xmm0
mulsd  (%r8,%rax,8),%xmm0
movsd  %xmm0,(%r8,%rax,8)
lea    0x1(%r14),%rax
mov    %rax,-0x70(%rbp)
mov    -0xe8(%rbp),%rcx
mov    -0xe0(%rbp),%rdx
xor    %esi,%esi
jmp    1937 <main+0x7d7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rsi
mov    -0x60(%rbp),%rax
add    %rax,%rdx
add    %rax,%rcx
cmp    %r11,%rsi
je     1ad3 <main+0x973>
cmp    %r10,%rsi
je     1920 <main+0x7c0>
mov    %rsi,%rax
imul   %r15,%rax
lea    (%r12,%rax,8),%rdi
cmp    $0x3,%r11d
jae    1960 <main+0x800>
xor    %eax,%eax
jmp    1a40 <main+0x8e0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rax,%r9,1),%rbx
lea    (%r12,%rbx,8),%r9
lea    (%r14,%rax,1),%rbx
lea    (%r12,%rbx,8),%rbx
add    -0x70(%rbp),%rax
lea    (%r12,%rax,8),%rax
cmp    %rax,%rdi
setb   %al
cmp    %r9,%rbx
setb   %bl
cmp    -0x50(%rbp),%rdi
setb   %r10b
cmp    %r9,%r8
setb   %r9b
test   %bl,%al
jne    1a2e <main+0x8ce>
mov    $0x0,%eax
and    %r9b,%r10b
mov    -0x40(%rbp),%r9
mov    -0x38(%rbp),%r10
jne    1a40 <main+0x8e0>
movsd  (%rdi,%r14,8),%xmm0
unpcklpd %xmm0,%xmm0
xorpd  0x66d(%rip),%xmm0
xor    %eax,%eax
mov    -0x98(%rbp),%rbx
mov    -0xa0(%rbp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%r8,%rax,8),%xmm1
movupd (%r8,%rax,8),%xmm2
movupd -0x10(%rdx,%rax,8),%xmm3
movupd (%rdx,%rax,8),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,-0x10(%rdx,%rax,8)
movupd %xmm2,(%rdx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbx
jne    19e0 <main+0x880>
mov    %rbx,%rax
cmp    %r9,%rbx
mov    -0x68(%rbp),%r8
je     1920 <main+0x7c0>
jmp    1a40 <main+0x8e0>
xor    %eax,%eax
mov    -0x40(%rbp),%r9
mov    -0x38(%rbp),%r10
nopl   0x0(%rax,%rax,1)
mov    %rax,%rbx
test   $0x1,%r9b
je     1a6a <main+0x90a>
movsd  (%rdi,%r14,8),%xmm0
mulsd  (%r8,%rax,8),%xmm0
movsd  (%rdi,%rax,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
mov    %rax,%rbx
or     $0x1,%rbx
not    %rax
cmp    -0x100(%rbp),%rax
mov    -0xa8(%rbp),%rax
je     1920 <main+0x7c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%r14,8),%xmm0
mulsd  (%rax,%rbx,8),%xmm0
movsd  -0x8(%rcx,%rbx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm1,-0x8(%rcx,%rbx,8)
movsd  (%rdi,%r14,8),%xmm1
mulsd  0x8(%rax,%rbx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r9
jne    1a90 <main+0x930>
jmp    1920 <main+0x7c0>
mov    -0xf8(%rbp),%rsp
add    $0x1,%r10
cmp    %r10d,%r11d
mov    -0x90(%rbp),%rcx
mov    -0xa8(%rbp),%rsi
mov    -0xa0(%rbp),%rdx
mov    -0x30(%rbp),%ebx
jle    1b25 <main+0x9c5>
mov    -0x60(%rbp),%rax
add    %rax,%rcx
add    %rax,-0x80(%rbp)
add    %rax,%rdx
add    %rax,%rsi
cmp    %ebx,%r11d
jge    14bc <main+0x35c>
jmp    1b25 <main+0x9c5>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    -0x48(%rbp),%r12
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    -0x2c(%rbp),%eax
test   %eax,%eax
jle    1be2 <main+0xa82>
shl    $0x3,%r15
xor    %r14d,%r14d
mov    %r12,%r13
lea    0x4fc(%rip),%r12
jmp    1b6a <main+0xa0a>
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r14
movslq -0x2c(%rbp),%rax
add    %r15,%r13
cmp    %rax,%r14
jge    1ba0 <main+0xa40>
test   %eax,%eax
js     1b50 <main+0x9f0>
mov    $0xffffffffffffffff,%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x8(%r13,%rbx,8),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movslq -0x2c(%rbp),%rax
add    $0x1,%rbx
cmp    %rax,%rbx
jl     1b80 <main+0xa20>
jmp    1b50 <main+0x9f0>
test   %eax,%eax
mov    -0x48(%rbp),%r12
jle    1be2 <main+0xa82>
xor    %ebx,%ebx
lea    0x4a4(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cltq
movsd  (%r12,%rax,8),%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbx
movslq -0x2c(%rbp),%rax
add    %r15,%r12
cmp    %rax,%rbx
jl     1bc0 <main+0xa60>
mov    -0xd8(%rbp),%rsp
mov    -0x88(%rbp),%r13
xor    %r15d,%r15d
mov    %r13,%rsp
mov    %r15d,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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