void boundary_condition(int N, float *value, int flag) {
  int count_a;
  int count_b;
  for (count_a = 1; count_a <= N; count_a++) {
    for (count_b = 1; count_b <= N; count_b++) {
      if (flag == 1) {
        value[((0) + (N + 2) * (count_a) + (N + 2) * (N + 2) * (count_b))] =
            -value[((1) + (N + 2) * (count_a) + (N + 2) * (N + 2) * (count_b))];
        value[((N + 1) + (N + 2) * (count_a) + (N + 2) * (N + 2) * (count_b))] =
            -value[((N) + (N + 2) * (count_a) + (N + 2) * (N + 2) * (count_b))];
      } else {
        value[((0) + (N + 2) * (count_a) + (N + 2) * (N + 2) * (count_b))] =
            value[((1) + (N + 2) * (count_a) + (N + 2) * (N + 2) * (count_b))];
        value[((N + 1) + (N + 2) * (count_a) + (N + 2) * (N + 2) * (count_b))] =
            value[((N) + (N + 2) * (count_a) + (N + 2) * (N + 2) * (count_b))];
      }
      if (flag == 2) {
        value[((count_a) + (N + 2) * (0) + (N + 2) * (N + 2) * (count_b))] =
            -value[((count_a) + (N + 2) * (1) + (N + 2) * (N + 2) * (count_b))];
        value[((count_a) + (N + 2) * (N + 1) + (N + 2) * (N + 2) * (count_b))] =
            -value[((count_a) + (N + 2) * (N) + (N + 2) * (N + 2) * (count_b))];
      } else {
        value[((count_a) + (N + 2) * (0) + (N + 2) * (N + 2) * (count_b))] =
            value[((count_a) + (N + 2) * (1) + (N + 2) * (N + 2) * (count_b))];
        value[((count_a) + (N + 2) * (N + 1) + (N + 2) * (N + 2) * (count_b))] =
            value[((count_a) + (N + 2) * (N) + (N + 2) * (N + 2) * (count_b))];
      }
      if (flag == 3) {
        value[((count_a) + (N + 2) * (count_b) + (N + 2) * (N + 2) * (0))] =
            -value[((count_a) + (N + 2) * (count_b) + (N + 2) * (N + 2) * (1))];
        value[((count_a) + (N + 2) * (count_b) + (N + 2) * (N + 2) * (N + 1))] =
            -value[((count_a) + (N + 2) * (count_b) + (N + 2) * (N + 2) * (N))];
      } else {
        value[((count_a) + (N + 2) * (count_b) + (N + 2) * (N + 2) * (0))] =
            value[((count_a) + (N + 2) * (count_b) + (N + 2) * (N + 2) * (1))];
        value[((count_a) + (N + 2) * (count_b) + (N + 2) * (N + 2) * (N + 1))] =
            value[((count_a) + (N + 2) * (count_b) + (N + 2) * (N + 2) * (N))];
      }
    }
  }
  value[((0) + (N + 2) * (0) + (N + 2) * (N + 2) * (0))] =
      (float)(1.0 / 3.0 *
              (value[((1) + (N + 2) * (0) + (N + 2) * (N + 2) * (0))] +
               value[((0) + (N + 2) * (1) + (N + 2) * (N + 2) * (0))] +
               value[((0) + (N + 2) * (0) + (N + 2) * (N + 2) * (1))]));
  value[((0) + (N + 2) * (N + 1) + (N + 2) * (N + 2) * (0))] =
      (float)(1.0 / 3.0 *
              (value[((1) + (N + 2) * (N + 1) + (N + 2) * (N + 2) * (0))] +
               value[((0) + (N + 2) * (N) + (N + 2) * (N + 2) * (0))] +
               value[((0) + (N + 2) * (N + 1) + (N + 2) * (N + 2) * (1))]));
  value[((N + 1) + (N + 2) * (0) + (N + 2) * (N + 2) * (0))] =
      (float)(1.0 / 3.0 *
              (value[((N) + (N + 2) * (0) + (N + 2) * (N + 2) * (0))] +
               value[((N + 1) + (N + 2) * (1) + (N + 2) * (N + 2) * (0))] +
               value[((N + 1) + (N + 2) * (0) + (N + 2) * (N + 2) * (1))]));
  value[((N + 1) + (N + 2) * (N + 1) + (N + 2) * (N + 2) * (0))] =
      (float)(1.0 / 3.0 *
              (value[((N) + (N + 2) * (N + 1) + (N + 2) * (N + 2) * (0))] +
               value[((N + 1) + (N + 2) * (N) + (N + 2) * (N + 2) * (0))] +
               value[((N + 1) + (N + 2) * (N + 1) + (N + 2) * (N + 2) * (1))]));
  value[((0) + (N + 2) * (0) + (N + 2) * (N + 2) * (N + 1))] =
      (float)(1.0 / 3.0 *
              (value[((1) + (N + 2) * (0) + (N + 2) * (N + 2) * (N + 1))] +
               value[((0) + (N + 2) * (1) + (N + 2) * (N + 2) * (N + 1))] +
               value[((0) + (N + 2) * (0) + (N + 2) * (N + 2) * (N))]));
  value[((0) + (N + 2) * (N + 1) + (N + 2) * (N + 2) * (N + 1))] =
      (float)(1.0 / 3.0 *
              (value[((1) + (N + 2) * (N + 1) + (N + 2) * (N + 2) * (N + 1))] +
               value[((0) + (N + 2) * (N) + (N + 2) * (N + 2) * (N + 1))] +
               value[((0) + (N + 2) * (N + 1) + (N + 2) * (N + 2) * (N))]));
  value[((N + 1) + (N + 2) * (0) + (N + 2) * (N + 2) * (N + 1))] =
      (float)(1.0 / 3.0 *
              (value[((N) + (N + 2) * (0) + (N + 2) * (N + 2) * (N + 1))] +
               value[((N + 1) + (N + 2) * (1) + (N + 2) * (N + 2) * (N + 1))] +
               value[((N + 1) + (N + 2) * (0) + (N + 2) * (N + 2) * (N))]));
  value[((N + 1) + (N + 2) * (N + 1) + (N + 2) * (N + 2) * (N + 1))] =
      (float)(1.0 / 3.0 *
              (value[((N) + (N + 2) * (N + 1) + (N + 2) * (N + 2) * (N + 1))] +
               value[((N + 1) + (N + 2) * (N) + (N + 2) * (N + 2) * (N + 1))] +
               value[((N + 1) + (N + 2) * (N + 1) + (N + 2) * (N + 2) * (N))]));
}


x86 assembly (clang, -O0):
<boundary_condition>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     165f <boundary_condition+0x55f>
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     164c <boundary_condition+0x54c>
cmpl   $0x1,-0x14(%rbp)
jne    121c <boundary_condition+0x11c>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
imul   -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
imul   -0x18(%rbp),%ecx
add    $0x0,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    12db <boundary_condition+0x1db>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
imul   -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
imul   -0x18(%rbp),%ecx
add    $0x0,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x2,-0x14(%rbp)
jne    13c7 <boundary_condition+0x2c7>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
shl    $0x0,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    148a <boundary_condition+0x38a>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
shl    $0x0,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x3,-0x14(%rbp)
jne    1576 <boundary_condition+0x476>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
shl    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1639 <boundary_condition+0x539>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
shl    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    163e <boundary_condition+0x53e>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1128 <boundary_condition+0x28>
jmp    1651 <boundary_condition+0x551>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1115 <boundary_condition+0x15>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
imul   $0x0,%ecx,%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
shl    $0x0,%ecx
add    $0x0,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
imul   $0x0,%ecx,%ecx
add    $0x0,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
shl    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x911(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
imul   $0x0,%ecx,%ecx
add    $0x0,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
mov    -0x4(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
imul   -0x4(%rbp),%ecx
add    $0x0,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
mov    -0x4(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
add    $0x0,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
shl    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x840(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
mov    -0x4(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
add    $0x0,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
shl    $0x0,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
shl    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x76a(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
shl    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x688(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
imul   $0x0,%ecx,%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
shl    $0x0,%ecx
add    $0x0,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
imul   $0x0,%ecx,%ecx
add    $0x0,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x5ac(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
imul   $0x0,%ecx,%ecx
add    $0x0,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
mov    -0x4(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
imul   -0x4(%rbp),%ecx
add    $0x0,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
mov    -0x4(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
add    $0x0,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x4c8(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
mov    -0x4(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
add    $0x0,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
shl    $0x0,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x3df(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   $0x0,%edx,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x2ea(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
mov    -0x4(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
mov    -0x4(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
pop    %rbp
ret

x86 assembly (clang, -O2):
<boundary_condition>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
test   %edi,%edi
jle    1449 <boundary_condition+0x349>
lea    0x2(%rdi),%ebp
mov    %ebp,%ebx
imul   %ebx,%ebx
mov    %edi,%r9d
lea    0x1(%rdi),%ecx
mov    %ebp,%eax
imul   %edi,%eax
mov    %eax,-0x50(%rsp)
mov    %ebp,%eax
imul   %ecx,%eax
mov    %eax,-0x54(%rsp)
mov    %ebx,%eax
imul   %edi,%eax
mov    %ebx,%r8d
imul   %ecx,%r8d
mov    %rax,-0x8(%rsp)
cltq
mov    %rcx,-0x18(%rsp)
movslq %ecx,%rcx
mov    %rax,-0x20(%rsp)
add    %rbp,%rax
lea    0x4(%rsi,%rax,4),%rax
mov    %rax,-0x38(%rsp)
lea    (%rbx,%rbp,1),%rax
lea    (%rsi,%rax,4),%r10
mov    %rcx,-0x28(%rsp)
lea    (%rcx,%rbx,1),%rax
mov    %rbp,-0x30(%rsp)
add    %rbp,%rax
lea    (%rsi,%rax,4),%rax
mov    %rax,-0x80(%rsp)
lea    (%rdi,%rdi,1),%eax
add    $0x3,%eax
imul   %ebp,%eax
add    $0x1,%eax
mov    %rax,-0x68(%rsp)
lea    (%rdi,%rdi,1),%eax
add    $0x2,%eax
imul   %ebp,%eax
or     $0x1,%rax
mov    %rax,-0x70(%rsp)
movaps 0xe51(%rip),%xmm0
mov    %r9,0x10(%rsp)
lea    0x1(%r9),%rax
mov    %rax,0x8(%rsp)
mov    %r8d,-0x4c(%rsp)
movslq %r8d,%rax
lea    0x1(%rbp),%rcx
mov    %rcx,0x20(%rsp)
lea    (%rsi,%rbp,4),%rcx
mov    %rcx,-0x48(%rsp)
lea    0x0(,%rbp,4),%rcx
mov    %rcx,(%rsp)
lea    0x3(%rdi,%rbx,1),%r15d
mov    %rdi,-0x10(%rsp)
lea    0x2(%rbx,%rdi,2),%ecx
mov    %rcx,-0x60(%rsp)
mov    $0x1,%ecx
mov    %rcx,-0x78(%rsp)
xor    %r13d,%r13d
mov    %r15,%r11
mov    %r10,-0x40(%rsp)
mov    %r10,%r9
mov    %rbx,%r8
jmp    126a <boundary_condition+0x16a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x78(%rsp),%rbp
add    $0x1,%rbp
mov    0x18(%rsp),%r13
add    $0x1,%r13
add    $0x1,%r8
mov    (%rsp),%rdi
add    %rdi,%r9
add    %rdi,-0x80(%rsp)
addq   $0x1,-0x68(%rsp)
addq   $0x1,-0x70(%rsp)
add    $0x1,%r11
add    %rcx,-0x60(%rsp)
add    %rcx,%r15
mov    %rbp,-0x78(%rsp)
cmp    0x8(%rsp),%rbp
je     1419 <boundary_condition+0x319>
mov    0x10(%rsp),%r12
xor    %ebp,%ebp
mov    %r13,0x18(%rsp)
mov    $0x1,%r10d
jmp    131a <boundary_condition+0x21a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%r11,%rbp,1),%ecx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
lea    (%r8,%rbp,1),%ecx
add    $0x1,%ecx
movss  %xmm1,(%rsi,%rcx,4)
mov    -0x70(%rsp),%rcx
add    %ebp,%ecx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x68(%rsp),%rcx
add    %ebp,%ecx
movslq %ecx,%rcx
movss  %xmm1,(%rsi,%rcx,4)
mov    0x20(%rsp),%rcx
lea    (%rcx,%r13,1),%r14
mov    -0x40(%rsp),%rcx
movss  0x4(%rcx,%r13,4),%xmm1
mov    -0x48(%rsp),%rcx
movss  %xmm1,0x4(%rcx,%r13,4)
mov    -0x38(%rsp),%rcx
movss  (%rcx,%r13,4),%xmm1
mov    -0x30(%rsp),%rcx
add    %rax,%r14
movss  %xmm1,(%rsi,%r14,4)
add    $0x1,%r10
add    %rcx,%r13
add    %rbx,%rbp
add    $0xffffffffffffffff,%r12
je     1220 <boundary_condition+0x120>
lea    (%r15,%rbp,1),%ecx
cmp    $0x1,%edx
jne    1360 <boundary_condition+0x260>
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r9,%rbp,4)
mov    -0x60(%rsp),%rcx
add    %ebp,%ecx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x80(%rsp),%rcx
movss  %xmm1,(%rcx,%rbp,4)
jmp    1390 <boundary_condition+0x290>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x60(%rsp),%rdi
add    %ebp,%edi
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm1
movss  %xmm1,(%r9,%rbp,4)
movslq %edi,%rcx
movss  (%rsi,%rcx,4),%xmm1
mov    -0x80(%rsp),%rcx
movss  %xmm1,(%rcx,%rbp,4)
cmp    $0x2,%edx
je     1290 <boundary_condition+0x190>
lea    (%r11,%rbp,1),%ecx
mov    -0x70(%rsp),%rdi
add    %ebp,%edi
mov    %rax,%r14
mov    %rbx,%rax
mov    -0x68(%rsp),%rbx
lea    (%rbx,%rbp,1),%ebx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm1
lea    0x1(%r8,%rbp,1),%ecx
movss  %xmm1,(%rsi,%rcx,4)
movslq %edi,%rcx
movss  (%rsi,%rcx,4),%xmm1
movslq %ebx,%rcx
mov    %rax,%rbx
mov    %r14,%rax
movss  %xmm1,(%rsi,%rcx,4)
cmp    $0x3,%edx
jne    12cc <boundary_condition+0x1cc>
mov    %r10,%r14
mov    -0x30(%rsp),%rcx
imul   %rcx,%r14
add    -0x78(%rsp),%r14
mov    -0x40(%rsp),%rdi
movss  0x4(%rdi,%r13,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x48(%rsp),%rdi
movss  %xmm1,0x4(%rdi,%r13,4)
mov    -0x38(%rsp),%rdi
movss  (%rdi,%r13,4),%xmm1
xorps  %xmm0,%xmm1
jmp    12fd <boundary_condition+0x1fd>
mov    %ecx,%r8d
mov    -0x8(%rsp),%r11
mov    -0x10(%rsp),%rdi
mov    -0x18(%rsp),%r15
mov    -0x20(%rsp),%r12
mov    -0x4c(%rsp),%r13d
mov    -0x28(%rsp),%r9
mov    %rax,-0x80(%rsp)
mov    -0x50(%rsp),%edx
mov    -0x54(%rsp),%ebp
jmp    1481 <boundary_condition+0x381>
lea    0x2(%rdi),%r8d
mov    %r8d,%ebx
imul   %ebx,%ebx
movslq %r8d,%rcx
lea    0x1(%rdi),%r15d
mov    %ecx,%ebp
imul   %r15d,%ebp
mov    %ecx,%edx
imul   %edi,%edx
movslq %r15d,%r9
mov    %r9d,%r13d
imul   %ebx,%r13d
mov    %ebx,%r11d
imul   %edi,%r11d
movslq %r11d,%r12
movslq %r13d,%rax
mov    %rax,-0x80(%rsp)
movss  0x4(%rsi),%xmm0
addss  (%rsi,%rcx,4),%xmm0
mov    %ebx,%eax
addss  (%rsi,%rax,4),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0xb6f(%rip),%xmm0
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rsi)
movslq %ebp,%rax
movss  0x4(%rsi,%rax,4),%xmm1
movslq %edx,%rdx
addss  (%rsi,%rdx,4),%xmm1
lea    (%rax,%rbx,1),%ecx
movslq %ecx,%rcx
addss  (%rsi,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rsi,%rax,4)
movslq %edi,%rcx
movss  (%rsi,%rcx,4),%xmm1
lea    (%r15,%r8,1),%ecx
movslq %ecx,%r14
addss  (%rsi,%r14,4),%xmm1
lea    (%rbx,%r15,1),%ecx
movslq %ecx,%rcx
addss  (%rsi,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rsi,%r9,4)
lea    (%rax,%rdi,1),%ecx
movslq %ecx,%r9
movss  (%rsi,%r9,4),%xmm1
lea    (%rdx,%r15,1),%ecx
movslq %ecx,%r10
addss  (%rsi,%r10,4),%xmm1
lea    (%rax,%r15,1),%ecx
add    %ecx,%ebx
movslq %ebx,%rbp
addss  (%rsi,%rbp,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movslq %ecx,%rbp
movss  %xmm1,(%rsi,%rbp,4)
movslq %r13d,%rcx
movss  0x4(%rsi,%rcx,4),%xmm1
add    %ecx,%r8d
movslq %r8d,%rbx
addss  (%rsi,%rbx,4),%xmm1
addss  (%rsi,%r12,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
mov    -0x80(%rsp),%rbx
movss  %xmm1,(%rsi,%rbx,4)
lea    (%rcx,%rax,1),%ebx
add    $0x1,%ebx
movslq %ebx,%rbx
movss  (%rsi,%rbx,4),%xmm1
add    %ecx,%edx
movslq %edx,%rdx
addss  (%rsi,%rdx,4),%xmm1
lea    (%r11,%rax,1),%edx
movslq %edx,%rdx
addss  (%rsi,%rdx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
add    %ecx,%eax
cltq
movss  %xmm1,(%rsi,%rax,4)
add    %ecx,%edi
movslq %edi,%rax
movss  (%rsi,%rax,4),%xmm1
add    %ecx,%r14d
movslq %r14d,%rax
addss  (%rsi,%rax,4),%xmm1
lea    (%r11,%r15,1),%eax
cltq
addss  (%rsi,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
add    %ecx,%r15d
movslq %r15d,%rax
movss  %xmm1,(%rsi,%rax,4)
add    %ecx,%r9d
movslq %r9d,%rax
movss  (%rsi,%rax,4),%xmm1
add    %ecx,%r10d
movslq %r10d,%rax
addss  (%rsi,%rax,4),%xmm1
add    %ebp,%r11d
movslq %r11d,%rax
addss  (%rsi,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm0
add    %ecx,%ebp
movslq %ebp,%rax
movss  %xmm0,(%rsi,%rax,4)
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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