#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ EOF;
double pow(double, double);
int /*<<< orphan*/ printf(char *, ...);
scalar_t__ scanf(char *, ...);
int main() {
  int m, n, i, j, u, k, r, count, set[105];
  double ar[105][3], d, sa[105][3], S, key1, key2, key3;
  while (scanf("%d", &m) != EOF) {
    for (i = 1; i <= m; i++) {
      scanf("%d", &n);
      for (u = 1; u <= 102; u++)
        set[u] = u;
      for (u = 1; u <= n; u++) {
        scanf("%d %d", &ar[u][0], &ar[u][1]);
      }
      r = 1;
      for (u = 1; u <= n; u++) {
        for (j = u; j <= n; j++) {
          d = pow(pow(ar[u][0] - ar[j][0], 2.0) + pow(ar[u][1] - ar[j][1], 2.0),
                  1.0 / 2.0);
          sa[r][0] = u;
          sa[r][1] = j;
          sa[r][2] = d;
          key1 = u;
          key2 = j;
          key3 = d;
          k = r - 1;
          while (k > 0 && key3 < sa[k][2]) {
            sa[k + 1][2] = sa[k][2];
            sa[k + 1][1] = sa[k][1];
            sa[k + 1][0] = sa[k][0];
            k--;
          }
          sa[k + 1][2] = key3;
          sa[k + 1][1] = key2;
          sa[k + 1][0] = key1;
          r++;
        }
      }
      count = 0;
      S = 0.0;
      for (k = 1; k < r; k++) {
        if (sa[k][2] < 10 || sa[k][2] > 1000)
          continue;
        while (set[(int)sa[k][0]] != (int)sa[k][0])
          sa[k][0] = set[(int)sa[k][0]];
        while (set[(int)sa[k][1]] != (int)sa[k][1])
          sa[k][1] = set[(int)sa[k][0]];
        if ((int)sa[k][0] != (int)sa[k][1]) {
          set[(int)sa[k][1]] = (int)sa[k][0];
          count++;
          S += sa[k][2];
          if (count == (n - 1))
            break;
        }
      }
      if (count == (n - 1))
        printf("%.1lf\n", S * 100.0);
      else
        printf("oh!\n");
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x15c0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xee2(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    0x2e8d(%rip),%rcx
cmp    (%rcx),%rax
je     1787 <main+0x657>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1782 <main+0x652>
lea    0xead(%rip),%rdi
lea    -0xc(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
movl   $0x1,-0x18(%rbp)
cmpl   $0x66,-0x18(%rbp)
jg     11b6 <main+0x86>
mov    -0x18(%rbp),%ecx
movslq -0x18(%rbp),%rax
mov    %ecx,-0x1d0(%rbp,%rax,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1190 <main+0x60>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     120d <main+0xdd>
movslq -0x18(%rbp),%rax
lea    -0xbb0(%rbp),%rsi
imul   $0x18,%rax,%rax
add    %rax,%rsi
movslq -0x18(%rbp),%rax
lea    -0xbb0(%rbp),%rdx
imul   $0x18,%rax,%rax
add    %rax,%rdx
add    $0x8,%rdx
lea    0xe30(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11bd <main+0x8d>
movl   $0x1,-0x20(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     14ed <main+0x3bd>
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     14da <main+0x3aa>
movslq -0x18(%rbp),%rcx
lea    -0xbb0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movslq -0x14(%rbp),%rcx
lea    -0xbb0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
subsd  (%rax),%xmm0
movsd  0xdb3(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0x15b8(%rbp)
ff
movslq -0x18(%rbp),%rcx
lea    -0xbb0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movslq -0x14(%rbp),%rcx
lea    -0xbb0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
subsd  0x8(%rax),%xmm0
movsd  0xd70(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x15b8(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  0xd4c(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0xbb8(%rbp)
ff
cvtsi2sdl -0x18(%rbp),%xmm0
movslq -0x20(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
cvtsi2sdl -0x14(%rbp),%xmm0
movslq -0x20(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xbb8(%rbp),%xmm0
ff
movslq -0x20(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
cvtsi2sdl -0x18(%rbp),%xmm0
movsd  %xmm0,-0x15a0(%rbp)
ff
cvtsi2sdl -0x14(%rbp),%xmm0
movsd  %xmm0,-0x15a8(%rbp)
ff
movsd  -0xbb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x15b0(%rbp)
ff
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x1c(%rbp)
mov    %al,-0x15b9(%rbp)
jle    13a0 <main+0x270>
movsd  -0x15b0(%rbp),%xmm1
ff
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x15b9(%rbp)
mov    -0x15b9(%rbp),%al
test   $0x1,%al
jne    13b3 <main+0x283>
jmp    1458 <main+0x328>
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1362 <main+0x232>
movsd  -0x15b0(%rbp),%xmm0
ff
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x15a8(%rbp),%xmm0
ff
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x15a0(%rbp),%xmm0
ff
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    122d <main+0xfd>
jmp    14df <main+0x3af>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    121b <main+0xeb>
movl   $0x0,-0x24(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1598(%rbp)
ff
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    172d <main+0x5fd>
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0xad4(%rip),%xmm0
ucomisd 0x10(%rax),%xmm0
ja     1560 <main+0x430>
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movsd  0xab2(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1565 <main+0x435>
jmp    171f <main+0x5ef>
jmp    156a <main+0x43a>
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cvttsd2si (%rax),%eax
cltq
mov    -0x1d0(%rbp,%rax,4),%eax
movslq -0x1c(%rbp),%rdx
lea    -0x1590(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
cvttsd2si (%rcx),%ecx
cmp    %ecx,%eax
je     15e3 <main+0x4b3>
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cvttsd2si (%rax),%eax
cltq
cvtsi2sdl -0x1d0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
jmp    156a <main+0x43a>
jmp    15e8 <main+0x4b8>
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cvttsd2si 0x8(%rax),%eax
cltq
mov    -0x1d0(%rbp,%rax,4),%eax
movslq -0x1c(%rbp),%rdx
lea    -0x1590(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
cvttsd2si 0x8(%rcx),%ecx
cmp    %ecx,%eax
je     1664 <main+0x534>
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cvttsd2si (%rax),%eax
cltq
cvtsi2sdl -0x1d0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
jmp    15e8 <main+0x4b8>
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cvttsd2si (%rax),%eax
movslq -0x1c(%rbp),%rdx
lea    -0x1590(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
cvttsd2si 0x8(%rcx),%ecx
cmp    %ecx,%eax
je     171a <main+0x5ea>
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cvttsd2si (%rax),%ecx
movslq -0x1c(%rbp),%rdx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
cvttsd2si 0x8(%rax),%eax
cltq
mov    %ecx,-0x1d0(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movslq -0x1c(%rbp),%rcx
lea    -0x1590(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
addsd  -0x1598(%rbp),%xmm0
ff
movsd  %xmm0,-0x1598(%rbp)
ff
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1715 <main+0x5e5>
jmp    172d <main+0x5fd>
jmp    171a <main+0x5ea>
jmp    171f <main+0x5ef>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1506 <main+0x3d6>
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1761 <main+0x631>
movsd  0x8ca(%rip),%xmm0
mulsd  -0x1598(%rbp),%xmm0
ff
lea    0x8d9(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
jmp    176f <main+0x63f>
lea    0x8cd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1774 <main+0x644>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    116b <main+0x3b>
jmp    1142 <main+0x12>
xor    %eax,%eax
add    $0x15c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1588,%rsp
lea    0x105b(%rip),%rdi
lea    0xc(%rsp),%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
mov    0x2e7d(%rip),%rcx
cmp    (%rcx),%rax
jne    1184 <main+0x44>
xor    %eax,%eax
add    $0x1588,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x1e0(%rsp),%r13
lea    0x1020(%rip),%r15
lea    0x1016(%rip),%r12
jmp    11bb <main+0x7b>
nopl   0x0(%rax)
mov    %r15,%rdi
lea    0xc(%rsp),%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
mov    0x2e32(%rip),%rcx
cmp    (%rcx),%rax
je     1170 <main+0x30>
cmpl   $0x0,0xc(%rsp)
jle    11a0 <main+0x60>
mov    $0x1,%r14d
jmp    11f4 <main+0xb4>
nopw   0x0(%rax,%rax,1)
mulsd  0xfd0(%rip),%xmm0
lea    0xfd7(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
lea    0x1(%r14),%eax
cmp    0xc(%rsp),%r14d
mov    %eax,%r14d
jge    11a0 <main+0x60>
mov    %r15,%rdi
lea    0x8(%rsp),%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
movaps 0xdf6(%rip),%xmm0
movups %xmm0,0x24(%rsp)
movaps 0xdfa(%rip),%xmm0
movups %xmm0,0x34(%rsp)
movaps 0xdfe(%rip),%xmm0
movups %xmm0,0x44(%rsp)
movaps 0xe02(%rip),%xmm0
movups %xmm0,0x54(%rsp)
movaps 0xe06(%rip),%xmm0
movups %xmm0,0x64(%rsp)
movaps 0xe0a(%rip),%xmm0
movups %xmm0,0x74(%rsp)
movaps 0xe0e(%rip),%xmm0
movups %xmm0,0x84(%rsp)
movaps 0xe0f(%rip),%xmm0
movups %xmm0,0x94(%rsp)
movaps 0xe10(%rip),%xmm0
movups %xmm0,0xa4(%rsp)
movaps 0xe11(%rip),%xmm0
movups %xmm0,0xb4(%rsp)
movaps 0xe12(%rip),%xmm0
movups %xmm0,0xc4(%rsp)
movaps 0xe13(%rip),%xmm0
movups %xmm0,0xd4(%rsp)
movaps 0xe14(%rip),%xmm0
movups %xmm0,0xe4(%rsp)
movaps 0xe15(%rip),%xmm0
movups %xmm0,0xf4(%rsp)
movaps 0xe16(%rip),%xmm0
movups %xmm0,0x104(%rsp)
movaps 0xe17(%rip),%xmm0
movups %xmm0,0x114(%rsp)
movaps 0xe18(%rip),%xmm0
movups %xmm0,0x124(%rsp)
movaps 0xe19(%rip),%xmm0
movups %xmm0,0x134(%rsp)
movaps 0xe1a(%rip),%xmm0
movups %xmm0,0x144(%rsp)
movaps 0xe1b(%rip),%xmm0
movups %xmm0,0x154(%rsp)
movaps 0xe1c(%rip),%xmm0
movups %xmm0,0x164(%rsp)
movaps 0xe1d(%rip),%xmm0
movups %xmm0,0x174(%rsp)
movaps 0xe1e(%rip),%xmm0
movups %xmm0,0x184(%rsp)
movaps 0xe1f(%rip),%xmm0
movups %xmm0,0x194(%rsp)
movapd 0xe1f(%rip),%xmm0
movupd %xmm0,0x1a4(%rsp)
movabs $0x6600000065,%rax
mov    %rax,0x1b4(%rsp)
mov    0x8(%rsp),%eax
test   %eax,%eax
jle    1635 <main+0x4f5>
mov    %r14,0x10(%rsp)
lea    0xbd0(%rsp),%r14
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
lea    -0x8(%r14),%rsi
mov    %r12,%rdi
mov    %r14,%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
movslq 0x8(%rsp),%rax
add    $0x1,%rbx
add    $0x18,%r14
cmp    %rax,%rbx
jl     13a0 <main+0x260>
test   %eax,%eax
jle    1630 <main+0x4f0>
mov    $0x1,%ebx
mov    $0x1,%r15d
jmp    13f0 <main+0x2b0>
nopl   0x0(%rax,%rax,1)
lea    0x1(%r15),%rdx
cmp    %rcx,%r15
mov    %rdx,%r15
jge    1530 <main+0x3f0>
movslq %eax,%rcx
cmp    %rcx,%r15
jg     13e0 <main+0x2a0>
lea    (%r15,%r15,2),%rax
lea    (%rsp,%rax,8),%rbp
add    $0xbb0,%rbp
xorps  %xmm3,%xmm3
cvtsi2sd %r15d,%xmm3
movslq %ebx,%rbx
mov    %r15,%r14
movsd  %xmm3,0x18(%rsp)
jmp    1459 <main+0x319>
nopl   (%rax)
movslq %edx,%rax
lea    (%rax,%rax,2),%rax
movsd  %xmm0,0x1e0(%rsp,%rax,8)
movsd  %xmm1,0x1d8(%rsp,%rax,8)
movsd  %xmm3,0x1d0(%rsp,%rax,8)
add    $0x1,%rbx
lea    0x1(%r14),%rdx
mov    0x8(%rsp),%eax
movslq %eax,%rcx
cmp    %rcx,%r14
mov    %rdx,%r14
jge    13e0 <main+0x2a0>
movsd  0x0(%rbp),%xmm1
lea    (%r14,%r14,2),%rax
subsd  0xbb0(%rsp,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
movsd  0x8(%rbp),%xmm0
subsd  0xbb8(%rsp,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0xd03(%rip),%xmm1
call   1060 <pow@plt>
movsd  0x18(%rsp),%xmm3
lea    (%rbx,%rbx,2),%rax
xorps  %xmm1,%xmm1
cvtsi2sd %r14d,%xmm1
movsd  %xmm3,0x1d0(%rsp,%rax,8)
movsd  %xmm1,0x1d8(%rsp,%rax,8)
movsd  %xmm0,0x1e0(%rsp,%rax,8)
mov    %rbx,%rdx
cmp    $0x2,%rbx
jl     1420 <main+0x2e0>
mov    %ebx,%eax
lea    (%rax,%rax,2),%rax
lea    0x0(,%rax,8),%rax
add    %r13,%rax
mov    %ebx,%ecx
nop
mov    %rcx,%rdx
add    $0xffffffffffffffff,%rcx
mov    %ecx,%esi
lea    (%rsi,%rsi,2),%rsi
movsd  0x1e0(%rsp,%rsi,8),%xmm2
ucomisd %xmm0,%xmm2
jbe    1420 <main+0x2e0>
movsd  %xmm2,(%rax)
movupd 0x1d0(%rsp,%rsi,8),%xmm2
movupd %xmm2,-0x10(%rax)
lea    0x1(%rcx),%edx
add    $0xffffffffffffffe8,%rax
cmp    $0x2,%edx
jg     14e0 <main+0x3a0>
mov    $0x1,%edx
jmp    1420 <main+0x2e0>
nopl   0x0(%rax,%rax,1)
cmp    $0x1,%ebx
lea    0xc79(%rip),%r15
mov    0x10(%rsp),%r14
jle    1635 <main+0x4f5>
add    $0xffffffff,%eax
mov    %ebx,%r8d
xor    %ecx,%ecx
xorpd  %xmm0,%xmm0
mov    $0x1,%esi
jmp    156d <main+0x42d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    %r8,%rsi
je     163e <main+0x4fe>
lea    (%rsi,%rsi,2),%rdi
movsd  0x1e0(%rsp,%rdi,8),%xmm1
movsd  0xc16(%rip),%xmm2
ucomisd %xmm1,%xmm2
ja     1560 <main+0x420>
ucomisd 0xc10(%rip),%xmm1
ja     1560 <main+0x420>
movsd  0x1d0(%rsp,%rdi,8),%xmm2
cvttsd2si %xmm2,%edx
movslq %edx,%rbp
mov    0x20(%rsp,%rbp,4),%edx
cmp    %ebp,%edx
je     15c4 <main+0x484>
nopw   0x0(%rax,%rax,1)
mov    %edx,%ebp
movslq %edx,%rbx
mov    0x20(%rsp,%rbx,4),%edx
cmp    %ebx,%edx
jne    15b0 <main+0x470>
xorps  %xmm2,%xmm2
cvtsi2sd %ebp,%xmm2
lea    (%rsp,%rdi,8),%rdx
add    $0x1d0,%rdx
movsd  %xmm2,(%rdx)
cvttsd2si 0x1d8(%rsp,%rdi,8),%ebx
movslq %ebx,%rdx
cvttsd2si %xmm2,%ebp
cmp    %edx,0x20(%rsp,%rdx,4)
je     1609 <main+0x4c9>
lea    (%rsp,%rdi,8),%rdx
add    $0x1d8,%rdx
movslq %ebp,%rdi
mov    0x20(%rsp,%rdi,4),%ebx
xorps  %xmm2,%xmm2
cvtsi2sd %ebx,%xmm2
movsd  %xmm2,(%rdx)
movslq %ebx,%rdx
cmp    %ebp,%ebx
je     1560 <main+0x420>
mov    %ebp,0x20(%rsp,%rdx,4)
add    $0x1,%ecx
addsd  %xmm1,%xmm0
cmp    %eax,%ecx
jne    1560 <main+0x420>
jmp    11d0 <main+0x90>
nopl   0x0(%rax)
mov    0x10(%rsp),%r14
add    $0xffffffff,%eax
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
cmp    %eax,%ecx
je     11d0 <main+0x90>
lea    0xb70(%rip),%rdi
call   1030 <puts@plt>
jmp    11e6 <main+0xa6>

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

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@EOF = global i64 0
@.str.1 = [6 x i8] c"%d %d\00"
@.str.2 = [7 x i8] c"%.1lf\0A\00"
@str = [4 x i8] c"oh!\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca [105 x i32]
%4 = alloca [105 x [3 x double]]
%5 = alloca [105 x [3 x double]]
%6 = bitcast i32* %1 to i8*
%7 = bitcast i32* %2 to i8*
%8 = bitcast [105 x i32]* %3 to i8*
%9 = bitcast [105 x [3 x double]]* %4 to i8*
%10 = bitcast [105 x [3 x double]]* %5 to i8*
%11 = call i64 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%12 = load i64, i64* @EOF
%13 = icmp eq i64 %11, %12
br i1 %13, label %240, label %14
14: ; preds = %0
%15 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 1
%16 = bitcast i32* %15 to <4 x i32>*
%17 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 5
%18 = bitcast i32* %17 to <4 x i32>*
%19 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 9
%20 = bitcast i32* %19 to <4 x i32>*
%21 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 13
%22 = bitcast i32* %21 to <4 x i32>*
%23 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 17
%24 = bitcast i32* %23 to <4 x i32>*
%25 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 21
%26 = bitcast i32* %25 to <4 x i32>*
%27 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 25
%28 = bitcast i32* %27 to <4 x i32>*
%29 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 29
%30 = bitcast i32* %29 to <4 x i32>*
%31 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 33
%32 = bitcast i32* %31 to <4 x i32>*
%33 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 37
%34 = bitcast i32* %33 to <4 x i32>*
%35 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 41
%36 = bitcast i32* %35 to <4 x i32>*
%37 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 45
%38 = bitcast i32* %37 to <4 x i32>*
%39 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 49
%40 = bitcast i32* %39 to <4 x i32>*
%41 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 53
%42 = bitcast i32* %41 to <4 x i32>*
%43 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 57
%44 = bitcast i32* %43 to <4 x i32>*
%45 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 61
%46 = bitcast i32* %45 to <4 x i32>*
%47 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 65
%48 = bitcast i32* %47 to <4 x i32>*
%49 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 69
%50 = bitcast i32* %49 to <4 x i32>*
%51 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 73
%52 = bitcast i32* %51 to <4 x i32>*
%53 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 77
%54 = bitcast i32* %53 to <4 x i32>*
%55 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 81
%56 = bitcast i32* %55 to <4 x i32>*
%57 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 85
%58 = bitcast i32* %57 to <4 x i32>*
%59 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 89
%60 = bitcast i32* %59 to <4 x i32>*
%61 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 93
%62 = bitcast i32* %61 to <4 x i32>*
%63 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 97
%64 = bitcast i32* %63 to <4 x i32>*
%65 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 101
%66 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 102
br label %71
67: ; preds = %236, %71
%68 = call i64 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%69 = load i64, i64* @EOF
%70 = icmp eq i64 %68, %69
br i1 %70, label %240, label %71
71: ; preds = %14, %67
%72 = load i32, i32* %1
%73 = icmp slt i32 %72, 1
br i1 %73, label %67, label %74
74: ; preds = %71, %236
%75 = phi i32 [ %237, %236 ], [ 1, %71 ]
%76 = call i64 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %2)
store <4 x i32> <i32 1, i32 2, i32 3, i32 4>, <4 x i32>* %16
store <4 x i32> <i32 5, i32 6, i32 7, i32 8>, <4 x i32>* %18
store <4 x i32> <i32 9, i32 10, i32 11, i32 12>, <4 x i32>* %20
store <4 x i32> <i32 13, i32 14, i32 15, i32 16>, <4 x i32>* %22
store <4 x i32> <i32 17, i32 18, i32 19, i32 20>, <4 x i32>* %24
store <4 x i32> <i32 21, i32 22, i32 23, i32 24>, <4 x i32>* %26
store <4 x i32> <i32 25, i32 26, i32 27, i32 28>, <4 x i32>* %28
store <4 x i32> <i32 29, i32 30, i32 31, i32 32>, <4 x i32>* %30
store <4 x i32> <i32 33, i32 34, i32 35, i32 36>, <4 x i32>* %32
store <4 x i32> <i32 37, i32 38, i32 39, i32 40>, <4 x i32>* %34
store <4 x i32> <i32 41, i32 42, i32 43, i32 44>, <4 x i32>* %36
store <4 x i32> <i32 45, i32 46, i32 47, i32 48>, <4 x i32>* %38
store <4 x i32> <i32 49, i32 50, i32 51, i32 52>, <4 x i32>* %40
store <4 x i32> <i32 53, i32 54, i32 55, i32 56>, <4 x i32>* %42
store <4 x i32> <i32 57, i32 58, i32 59, i32 60>, <4 x i32>* %44
store <4 x i32> <i32 61, i32 62, i32 63, i32 64>, <4 x i32>* %46
store <4 x i32> <i32 65, i32 66, i32 67, i32 68>, <4 x i32>* %48
store <4 x i32> <i32 69, i32 70, i32 71, i32 72>, <4 x i32>* %50
store <4 x i32> <i32 73, i32 74, i32 75, i32 76>, <4 x i32>* %52
store <4 x i32> <i32 77, i32 78, i32 79, i32 80>, <4 x i32>* %54
store <4 x i32> <i32 81, i32 82, i32 83, i32 84>, <4 x i32>* %56
store <4 x i32> <i32 85, i32 86, i32 87, i32 88>, <4 x i32>* %58
store <4 x i32> <i32 89, i32 90, i32 91, i32 92>, <4 x i32>* %60
store <4 x i32> <i32 93, i32 94, i32 95, i32 96>, <4 x i32>* %62
store <4 x i32> <i32 97, i32 98, i32 99, i32 100>, <4 x i32>* %64
store i32 101, i32* %65
store i32 102, i32* %66
%77 = load i32, i32* %2
%78 = icmp slt i32 %77, 1
br i1 %78, label %92, label %81
79: ; preds = %81
%80 = icmp slt i32 %87, 1
br i1 %80, label %92, label %98
81: ; preds = %74, %81
%82 = phi i64 [ %86, %81 ], [ 1, %74 ]
%83 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %4, i64 0, i64 %82, i64 0
%84 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %4, i64 0, i64 %82, i64 1
%85 = call i64 (i8*, ...) @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), double* %83, double* %84)
%86 = add nuw nsw i64 %82, 1
%87 = load i32, i32* %2
%88 = sext i32 %87 to i64
%89 = icmp slt i64 %82, %88
br i1 %89, label %81, label %79
90: ; preds = %164
%91 = icmp sgt i32 %167, 1
br i1 %91, label %95, label %92
92: ; preds = %74, %79, %90
%93 = phi i32 [ %166, %90 ], [ %87, %79 ], [ %77, %74 ]
%94 = add nsw i32 %93, -1
br label %225
95: ; preds = %90
%96 = add nsw i32 %166, -1
%97 = zext i32 %167 to i64
br label %170
98: ; preds = %79, %164
%99 = phi i32 [ %166, %164 ], [ %87, %79 ]
%100 = phi i64 [ %168, %164 ], [ 1, %79 ]
%101 = phi i32 [ %167, %164 ], [ 1, %79 ]
%102 = sext i32 %99 to i64
%103 = icmp sgt i64 %100, %102
br i1 %103, label %164, label %104
104: ; preds = %98
%105 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %4, i64 0, i64 %100, i64 0
%106 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %4, i64 0, i64 %100, i64 1
%107 = trunc i64 %100 to i32
%108 = sitofp i32 %107 to double
%109 = sext i32 %101 to i64
br label %110
110: ; preds = %104, %149
%111 = phi i64 [ %109, %104 ], [ %156, %149 ]
%112 = phi i64 [ %100, %104 ], [ %157, %149 ]
%113 = load double, double* %105
%114 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %4, i64 0, i64 %112, i64 0
%115 = load double, double* %114
%116 = fsub double %113, %115
%117 = fmul double %116, %116
%118 = load double, double* %106
%119 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %4, i64 0, i64 %112, i64 1
%120 = load double, double* %119
%121 = fsub double %118, %120
%122 = fmul double %121, %121
%123 = fadd double %117, %122
%124 = call double @pow(double %123, double 5.000000e-01)
%125 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %5, i64 0, i64 %111, i64 0
store double %108, double* %125
%126 = trunc i64 %112 to i32
%127 = sitofp i32 %126 to double
%128 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %5, i64 0, i64 %111, i64 1
store double %127, double* %128
%129 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %5, i64 0, i64 %111, i64 2
store double %124, double* %129
%130 = icmp sgt i64 %111, 1
br i1 %130, label %131, label %149
131: ; preds = %110
%132 = and i64 %111, 4294967295
br label %133
133: ; preds = %131, %140
%134 = phi i64 [ %132, %131 ], [ %135, %140 ]
%135 = add nsw i64 %134, -1
%136 = and i64 %135, 4294967295
%137 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %5, i64 0, i64 %136, i64 2
%138 = load double, double* %137
%139 = fcmp olt double %124, %138
br i1 %139, label %140, label %149
140: ; preds = %133
%141 = trunc i64 %134 to i32
%142 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %5, i64 0, i64 %134, i64 2
store double %138, double* %142
%143 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %5, i64 0, i64 %136, i64 0
%144 = bitcast double* %143 to <2 x double>*
%145 = load <2 x double>, <2 x double>* %144
%146 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %5, i64 0, i64 %134, i64 0
%147 = bitcast double* %146 to <2 x double>*
store <2 x double> %145, <2 x double>* %147
%148 = icmp sgt i32 %141, 2
br i1 %148, label %133, label %149
149: ; preds = %133, %140, %110
%150 = phi i64 [ %111, %110 ], [ 1, %140 ], [ %134, %133 ]
%151 = shl i64 %150, 32
%152 = ashr exact i64 %151, 32
%153 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %5, i64 0, i64 %152, i64 2
store double %124, double* %153
%154 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %5, i64 0, i64 %152, i64 1
store double %127, double* %154
%155 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %5, i64 0, i64 %152, i64 0
store double %108, double* %155
%156 = add nsw i64 %111, 1
%157 = add nuw nsw i64 %112, 1
%158 = load i32, i32* %2
%159 = sext i32 %158 to i64
%160 = icmp slt i64 %112, %159
br i1 %160, label %110, label %161
161: ; preds = %149
%162 = sext i32 %158 to i64
%163 = trunc i64 %156 to i32
br label %164
164: ; preds = %161, %98
%165 = phi i64 [ %162, %161 ], [ %102, %98 ]
%166 = phi i32 [ %158, %161 ], [ %99, %98 ]
%167 = phi i32 [ %163, %161 ], [ %101, %98 ]
%168 = add nuw nsw i64 %100, 1
%169 = icmp slt i64 %100, %165
br i1 %169, label %98, label %90
170: ; preds = %95, %220
%171 = phi i64 [ 1, %95 ], [ %223, %220 ]
%172 = phi double [ 0.000000e+00, %95 ], [ %222, %220 ]
%173 = phi i32 [ 0, %95 ], [ %221, %220 ]
%174 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %5, i64 0, i64 %171, i64 2
%175 = load double, double* %174
%176 = fcmp olt double %175, 1.000000e+01
%177 = fcmp ogt double %175, 1.000000e+03
%178 = or i1 %176, %177
br i1 %178, label %220, label %179
179: ; preds = %170
%180 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %5, i64 0, i64 %171, i64 0
%181 = load double, double* %180
%182 = fptosi double %181 to i32
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 %183
%185 = load i32, i32* %184
%186 = icmp eq i32 %185, %182
br i1 %186, label %189, label %205
187: ; preds = %205
%188 = sitofp i32 %206 to double
br label %189
189: ; preds = %187, %179
%190 = phi double [ %181, %179 ], [ %188, %187 ]
store double %190, double* %180
%191 = getelementptr inbounds [105 x [3 x double]], [105 x [3 x double]]* %5, i64 0, i64 %171, i64 1
%192 = load double, double* %191
%193 = fptosi double %192 to i32
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 %194
%196 = load i32, i32* %195
%197 = icmp eq i32 %196, %193
%198 = fptosi double %190 to i32
br i1 %197, label %211, label %199
199: ; preds = %189
%200 = sext i32 %198 to i64
%201 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 %200
%202 = load i32, i32* %201
%203 = sitofp i32 %202 to double
store double %203, double* %191
%204 = sext i32 %202 to i64
br label %211
205: ; preds = %179, %205
%206 = phi i32 [ %209, %205 ], [ %185, %179 ]
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 %207
%209 = load i32, i32* %208
%210 = icmp eq i32 %209, %206
br i1 %210, label %187, label %205
211: ; preds = %199, %189
%212 = phi i64 [ %194, %189 ], [ %204, %199 ]
%213 = phi i32 [ %193, %189 ], [ %202, %199 ]
%214 = icmp eq i32 %213, %198
br i1 %214, label %220, label %215
215: ; preds = %211
%216 = getelementptr inbounds [105 x i32], [105 x i32]* %3, i64 0, i64 %212
store i32 %198, i32* %216
%217 = add nsw i32 %173, 1
%218 = fadd double %172, %175
%219 = icmp eq i32 %217, %96
br i1 %219, label %230, label %220
220: ; preds = %211, %215, %170
%221 = phi i32 [ %173, %170 ], [ %217, %215 ], [ %173, %211 ]
%222 = phi double [ %172, %170 ], [ %218, %215 ], [ %172, %211 ]
%223 = add nuw nsw i64 %171, 1
%224 = icmp eq i64 %223, %97
br i1 %224, label %225, label %170
225: ; preds = %220, %92
%226 = phi i32 [ %94, %92 ], [ %96, %220 ]
%227 = phi i32 [ 0, %92 ], [ %221, %220 ]
%228 = phi double [ 0.000000e+00, %92 ], [ %222, %220 ]
%229 = icmp eq i32 %227, %226
br i1 %229, label %230, label %234
230: ; preds = %215, %225
%231 = phi double [ %228, %225 ], [ %218, %215 ]
%232 = fmul double %231, 1.000000e+02
%233 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0), double %232)
br label %236
234: ; preds = %225
%235 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str, i64 0, i64 0))
br label %236
236: ; preds = %230, %234
%237 = add nuw nsw i32 %75, 1
%238 = load i32, i32* %1
%239 = icmp slt i32 %75, %238
br i1 %239, label %74, label %67
240: ; preds = %67, %0
ret i32 0
}