#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 */
int Boundaries(char *, int, char, int **);
int Sov(char *Asn1, int L1, char *Asn2, int L2, char SecStr, float Threshold,
        float *Q2) {
  int Bound1[500][2], Bound2[500][2], Length1[500], Length2[500], NSeg1, NSeg2;
  int Overlap, MaxOverlap, TP = 0, FN = 0;
  register int i, j;
  NSeg1 = Boundaries(Asn1, L1, SecStr, Bound1);
  NSeg2 = Boundaries(Asn2, L2, SecStr, Bound2);
  for (i = 0; i < NSeg1; i++)
    Length1[i] = Bound1[i][1] - Bound1[i][0] + 1;
  for (j = 0; j < NSeg2; j++)
    Length2[j] = Bound2[j][1] - Bound2[j][0] + 1;
  for (i = 0; i < NSeg1; i++) {
    MaxOverlap = 0;
    for (j = 0; j < NSeg2; j++) {
      if (Bound1[i][0] > Bound2[j][1] || Bound1[i][1] < Bound2[j][0])
        Overlap = 0;
      else if (Bound2[j][0] >= Bound1[i][0] && Bound2[j][1] <= Bound1[i][1])
        Overlap = Length2[j];
      else if (Bound1[i][0] <= Bound2[j][0])
        Overlap = ((Bound2[j][1] - Bound2[j][0]) < (Bound1[i][1] - Bound2[j][0])
                       ? Bound2[j][1] - Bound2[j][0]
                       : Bound1[i][1] - Bound2[j][0]) +
                  1;
      else if (Bound1[i][0] >= Bound2[j][0])
        Overlap = ((Bound2[j][1] - Bound2[j][0]) < (Bound2[j][1] - Bound1[i][0])
                       ? Bound2[j][1] - Bound2[j][0]
                       : Bound2[j][1] - Bound1[i][0]) +
                  1;
      else
        Overlap = Length1[i];
      if (Overlap > MaxOverlap)
        MaxOverlap = Overlap;
    }
    if ((float)MaxOverlap / (float)Length1[i] >= Threshold)
      TP++;
    else
      FN++;
  }
  if (TP + FN != 0)
    *Q2 = (float)TP / ((float)TP + (float)FN);
  else
    *Q2 = -1.0;
  return (1);
}


x86 assembly (clang, -O0):
<Sov>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2f40,%rsp
mov    %r8b,%al
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %al,-0x1d(%rbp)
movss  %xmm0,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x2f24(%rbp)
movl   $0x0,-0x2f28(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x1d(%rbp),%al
lea    -0xfd0(%rbp),%rcx
movsbl %al,%edx
call   1030 <Boundaries@plt>
mov    %eax,-0x2f14(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x1d(%rbp),%al
lea    -0x1f70(%rbp),%rcx
movsbl %al,%edx
call   1030 <Boundaries@plt>
mov    %eax,-0x2f18(%rbp)
movl   $0x0,-0x2f2c(%rbp)
mov    -0x2f2c(%rbp),%eax
cmp    -0x2f14(%rbp),%eax
jge    11e7 <Sov+0xd7>
movslq -0x2f2c(%rbp),%rax
mov    -0xfcc(%rbp,%rax,8),%ecx
movslq -0x2f2c(%rbp),%rax
sub    -0xfd0(%rbp,%rax,8),%ecx
add    $0x1,%ecx
movslq -0x2f2c(%rbp),%rax
mov    %ecx,-0x2740(%rbp,%rax,4)
mov    -0x2f2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f2c(%rbp)
jmp    1194 <Sov+0x84>
movl   $0x0,-0x2f30(%rbp)
mov    -0x2f30(%rbp),%eax
cmp    -0x2f18(%rbp),%eax
jge    1244 <Sov+0x134>
movslq -0x2f30(%rbp),%rax
mov    -0x1f6c(%rbp,%rax,8),%ecx
movslq -0x2f30(%rbp),%rax
sub    -0x1f70(%rbp,%rax,8),%ecx
add    $0x1,%ecx
movslq -0x2f30(%rbp),%rax
mov    %ecx,-0x2f10(%rbp,%rax,4)
mov    -0x2f30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f30(%rbp)
jmp    11f1 <Sov+0xe1>
movl   $0x0,-0x2f2c(%rbp)
mov    -0x2f2c(%rbp),%eax
cmp    -0x2f14(%rbp),%eax
jge    1570 <Sov+0x460>
movl   $0x0,-0x2f20(%rbp)
movl   $0x0,-0x2f30(%rbp)
mov    -0x2f30(%rbp),%eax
cmp    -0x2f18(%rbp),%eax
jge    150e <Sov+0x3fe>
movslq -0x2f2c(%rbp),%rax
mov    -0xfd0(%rbp,%rax,8),%eax
movslq -0x2f30(%rbp),%rcx
cmp    -0x1f6c(%rbp,%rcx,8),%eax
jg     12ca <Sov+0x1ba>
movslq -0x2f2c(%rbp),%rax
mov    -0xfcc(%rbp,%rax,8),%eax
movslq -0x2f30(%rbp),%rcx
cmp    -0x1f70(%rbp,%rcx,8),%eax
jge    12d9 <Sov+0x1c9>
movl   $0x0,-0x2f1c(%rbp)
jmp    14d7 <Sov+0x3c7>
movslq -0x2f30(%rbp),%rax
mov    -0x1f70(%rbp,%rax,8),%eax
movslq -0x2f2c(%rbp),%rcx
cmp    -0xfd0(%rbp,%rcx,8),%eax
jl     1336 <Sov+0x226>
movslq -0x2f30(%rbp),%rax
mov    -0x1f6c(%rbp,%rax,8),%eax
movslq -0x2f2c(%rbp),%rcx
cmp    -0xfcc(%rbp,%rcx,8),%eax
jg     1336 <Sov+0x226>
movslq -0x2f30(%rbp),%rax
mov    -0x2f10(%rbp,%rax,4),%eax
mov    %eax,-0x2f1c(%rbp)
jmp    14d2 <Sov+0x3c2>
movslq -0x2f2c(%rbp),%rax
mov    -0xfd0(%rbp,%rax,8),%eax
movslq -0x2f30(%rbp),%rcx
cmp    -0x1f70(%rbp,%rcx,8),%eax
jg     13f5 <Sov+0x2e5>
movslq -0x2f30(%rbp),%rax
mov    -0x1f6c(%rbp,%rax,8),%eax
movslq -0x2f30(%rbp),%rcx
sub    -0x1f70(%rbp,%rcx,8),%eax
movslq -0x2f2c(%rbp),%rcx
mov    -0xfcc(%rbp,%rcx,8),%ecx
movslq -0x2f30(%rbp),%rdx
sub    -0x1f70(%rbp,%rdx,8),%ecx
cmp    %ecx,%eax
jge    13bf <Sov+0x2af>
movslq -0x2f30(%rbp),%rax
mov    -0x1f6c(%rbp,%rax,8),%eax
movslq -0x2f30(%rbp),%rcx
sub    -0x1f70(%rbp,%rcx,8),%eax
mov    %eax,-0x2f34(%rbp)
jmp    13e1 <Sov+0x2d1>
movslq -0x2f2c(%rbp),%rax
mov    -0xfcc(%rbp,%rax,8),%eax
movslq -0x2f30(%rbp),%rcx
sub    -0x1f70(%rbp,%rcx,8),%eax
mov    %eax,-0x2f34(%rbp)
mov    -0x2f34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f1c(%rbp)
jmp    14cd <Sov+0x3bd>
movslq -0x2f2c(%rbp),%rax
mov    -0xfd0(%rbp,%rax,8),%eax
movslq -0x2f30(%rbp),%rcx
cmp    -0x1f70(%rbp,%rcx,8),%eax
jl     14b4 <Sov+0x3a4>
movslq -0x2f30(%rbp),%rax
mov    -0x1f6c(%rbp,%rax,8),%eax
movslq -0x2f30(%rbp),%rcx
sub    -0x1f70(%rbp,%rcx,8),%eax
movslq -0x2f30(%rbp),%rcx
mov    -0x1f6c(%rbp,%rcx,8),%ecx
movslq -0x2f2c(%rbp),%rdx
sub    -0xfd0(%rbp,%rdx,8),%ecx
cmp    %ecx,%eax
jge    147e <Sov+0x36e>
movslq -0x2f30(%rbp),%rax
mov    -0x1f6c(%rbp,%rax,8),%eax
movslq -0x2f30(%rbp),%rcx
sub    -0x1f70(%rbp,%rcx,8),%eax
mov    %eax,-0x2f38(%rbp)
jmp    14a0 <Sov+0x390>
movslq -0x2f30(%rbp),%rax
mov    -0x1f6c(%rbp,%rax,8),%eax
movslq -0x2f2c(%rbp),%rcx
sub    -0xfd0(%rbp,%rcx,8),%eax
mov    %eax,-0x2f38(%rbp)
mov    -0x2f38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f1c(%rbp)
jmp    14c8 <Sov+0x3b8>
movslq -0x2f2c(%rbp),%rax
mov    -0x2740(%rbp,%rax,4),%eax
mov    %eax,-0x2f1c(%rbp)
jmp    14cd <Sov+0x3bd>
jmp    14d2 <Sov+0x3c2>
jmp    14d7 <Sov+0x3c7>
mov    -0x2f1c(%rbp),%eax
cmp    -0x2f20(%rbp),%eax
jle    14f5 <Sov+0x3e5>
mov    -0x2f1c(%rbp),%eax
mov    %eax,-0x2f20(%rbp)
jmp    14fa <Sov+0x3ea>
mov    -0x2f30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f30(%rbp)
jmp    1274 <Sov+0x164>
cvtsi2ssl -0x2f20(%rbp),%xmm0
ff
movslq -0x2f2c(%rbp),%rax
cvtsi2ssl -0x2740(%rbp,%rax,4),%xmm1
ff ff
divss  %xmm1,%xmm0
ucomiss -0x24(%rbp),%xmm0
jb     1548 <Sov+0x438>
mov    -0x2f24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f24(%rbp)
jmp    1557 <Sov+0x447>
mov    -0x2f28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f28(%rbp)
jmp    155c <Sov+0x44c>
mov    -0x2f2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f2c(%rbp)
jmp    124e <Sov+0x13e>
mov    -0x2f24(%rbp),%eax
add    -0x2f28(%rbp),%eax
cmp    $0x0,%eax
je     15b2 <Sov+0x4a2>
cvtsi2ssl -0x2f24(%rbp),%xmm0
ff
cvtsi2ssl -0x2f24(%rbp),%xmm1
ff
cvtsi2ssl -0x2f28(%rbp),%xmm2
ff
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
jmp    15c2 <Sov+0x4b2>
mov    -0x30(%rbp),%rax
movss  0xa42(%rip),%xmm0
movss  %xmm0,(%rax)
mov    $0x1,%eax
add    $0x2f40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Sov>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2ef8,%rsp
mov    %r9,%r14
movd   %xmm0,0xc(%rsp)
mov    %r8d,%ebx
mov    %ecx,%r12d
mov    %rdx,%rbp
lea    0xfb0(%rsp),%rcx
mov    %r8d,%edx
call   1030 <Boundaries@plt>
mov    %eax,%r15d
lea    0x10(%rsp),%rcx
mov    %rbp,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
call   1030 <Boundaries@plt>
mov    %r15d,%r8d
test   %r15d,%r15d
jle    1221 <Sov+0x111>
cmp    $0x8,%r15d
jae    1171 <Sov+0x61>
xor    %edx,%edx
jmp    1200 <Sov+0xf0>
mov    %r8d,%edx
and    $0xfffffff8,%edx
lea    0x0(,%r8,4),%rcx
and    $0xffffffffffffffe0,%rcx
xor    %esi,%esi
pcmpeqd %xmm0,%xmm0
nopl   0x0(%rax)
movaps 0xfb0(%rsp,%rsi,2),%xmm1
movaps 0xfc0(%rsp,%rsi,2),%xmm2
movaps 0xfd0(%rsp,%rsi,2),%xmm3
movaps 0xfe0(%rsp,%rsi,2),%xmm4
movaps %xmm1,%xmm5
shufps $0x88,%xmm2,%xmm5
movaps %xmm3,%xmm6
shufps $0x88,%xmm4,%xmm6
shufps $0xdd,%xmm2,%xmm1
psubd  %xmm5,%xmm1
shufps $0xdd,%xmm4,%xmm3
psubd  %xmm6,%xmm3
psubd  %xmm0,%xmm1
psubd  %xmm0,%xmm3
movdqa %xmm1,0x2720(%rsp,%rsi,1)
movdqa %xmm3,0x2730(%rsp,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1190 <Sov+0x80>
cmp    %r8,%rdx
je     1221 <Sov+0x111>
cs nopw 0x0(%rax,%rax,1)
mov    0xfb4(%rsp,%rdx,8),%ecx
sub    0xfb0(%rsp,%rdx,8),%ecx
add    $0x1,%ecx
mov    %ecx,0x2720(%rsp,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1200 <Sov+0xf0>
mov    %eax,%r12d
test   %eax,%eax
movss  0xc(%rsp),%xmm7
jle    12db <Sov+0x1cb>
cmp    $0x8,%eax
jae    123e <Sov+0x12e>
xor    %esi,%esi
jmp    12c0 <Sov+0x1b0>
mov    %r12d,%esi
and    $0xfffffff8,%esi
lea    0x0(,%r12,4),%rcx
and    $0xffffffffffffffe0,%rcx
xor    %edi,%edi
pcmpeqd %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movaps 0x10(%rsp,%rdi,2),%xmm1
movaps 0x20(%rsp,%rdi,2),%xmm2
movaps 0x30(%rsp,%rdi,2),%xmm3
movaps 0x40(%rsp,%rdi,2),%xmm4
movaps %xmm1,%xmm5
shufps $0x88,%xmm2,%xmm5
movaps %xmm3,%xmm6
shufps $0x88,%xmm4,%xmm6
shufps $0xdd,%xmm2,%xmm1
psubd  %xmm5,%xmm1
shufps $0xdd,%xmm4,%xmm3
psubd  %xmm6,%xmm3
psubd  %xmm0,%xmm1
psubd  %xmm0,%xmm3
movdqa %xmm1,0x1f50(%rsp,%rdi,1)
movdqa %xmm3,0x1f60(%rsp,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1260 <Sov+0x150>
cmp    %r12,%rsi
je     12db <Sov+0x1cb>
nopw   0x0(%rax,%rax,1)
mov    0x14(%rsp,%rsi,8),%ecx
sub    0x10(%rsp,%rsi,8),%ecx
add    $0x1,%ecx
mov    %ecx,0x1f50(%rsp,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%r12
jne    12c0 <Sov+0x1b0>
test   %r15d,%r15d
jle    13a6 <Sov+0x296>
xor    %r15d,%r15d
xor    %r10d,%r10d
xor    %r11d,%r11d
jmp    1323 <Sov+0x213>
nop
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ssl 0x2720(%rsp,%r15,4),%xmm1
divss  %xmm1,%xmm0
ucomiss %xmm7,%xmm0
sbb    $0xffffffff,%r11d
ucomiss %xmm7,%xmm0
adc    $0x0,%r10d
add    $0x1,%r15
cmp    %r8,%r15
je     13ac <Sov+0x29c>
mov    $0x0,%ecx
test   %eax,%eax
jle    12f0 <Sov+0x1e0>
mov    0xfb0(%rsp,%r15,8),%r13d
mov    $0x1,%r9d
sub    %r13d,%r9d
xor    %edi,%edi
xor    %ecx,%ecx
jmp    135e <Sov+0x24e>
add    %r9d,%ebx
mov    %ebx,%esi
nopl   0x0(%rax,%rax,1)
cmp    %ecx,%esi
cmovg  %esi,%ecx
add    $0x1,%rdi
cmp    %rdi,%r12
je     12f0 <Sov+0x1e0>
mov    0x14(%rsp,%rdi,8),%ebx
mov    $0x0,%esi
cmp    %r13d,%ebx
jl     1350 <Sov+0x240>
mov    0xfb4(%rsp,%r15,8),%edx
mov    0x10(%rsp,%rdi,8),%ebp
mov    $0x0,%esi
cmp    %ebp,%edx
jl     1350 <Sov+0x240>
cmp    %r13d,%ebp
jl     1393 <Sov+0x283>
cmp    %edx,%ebx
jg     1393 <Sov+0x283>
mov    0x1f50(%rsp,%rdi,4),%esi
jmp    1350 <Sov+0x240>
cmp    %r13d,%ebp
jl     1343 <Sov+0x233>
cmp    %edx,%ebx
cmovl  %ebx,%edx
sub    %ebp,%edx
add    $0x1,%edx
mov    %edx,%esi
jmp    1350 <Sov+0x240>
xor    %r11d,%r11d
xor    %r10d,%r10d
mov    %r11d,%eax
add    %r10d,%eax
jne    13be <Sov+0x2ae>
movss  0xc44(%rip),%xmm0
jmp    13d6 <Sov+0x2c6>
xorps  %xmm0,%xmm0
cvtsi2ss %r11d,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %r10d,%xmm1
addss  %xmm0,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,(%r14)
mov    $0x1,%eax
add    $0x2ef8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @Sov(i8* %0, i32 %1, i8* %2, i32 %3, i8 signext %4, float %5, float* nocapture writeonly %6) {
%8 = alloca [500 x [2 x i32]]
%9 = alloca [500 x [2 x i32]]
%10 = alloca [500 x i32]
%11 = alloca [500 x i32]
%12 = bitcast [500 x [2 x i32]]* %8 to i8*
%13 = bitcast [500 x [2 x i32]]* %9 to i8*
%14 = bitcast [500 x i32]* %10 to i8*
%15 = bitcast [500 x i32]* %11 to i8*
%16 = bitcast [500 x [2 x i32]]* %8 to i32**
%17 = call i32 @Boundaries(i8* %0, i32 %1, i8 signext %4, i32** %16)
%18 = bitcast [500 x [2 x i32]]* %9 to i32**
%19 = call i32 @Boundaries(i8* %2, i32 %3, i8 signext %4, i32** %18)
%20 = icmp sgt i32 %17, 0
br i1 %20, label %21, label %53
21: ; preds = %7
%22 = zext i32 %17 to i64
%23 = icmp ult i32 %17, 8
br i1 %23, label %51, label %24
24: ; preds = %21
%25 = and i64 %22, 4294967288
br label %26
26: ; preds = %26, %24
%27 = phi i64 [ 0, %24 ], [ %47, %26 ]
%28 = or i64 %27, 4
%29 = getelementptr inbounds [500 x [2 x i32]], [500 x [2 x i32]]* %8, i64 0, i64 %27, i64 0
%30 = bitcast i32* %29 to <8 x i32>*
%31 = getelementptr inbounds [500 x [2 x i32]], [500 x [2 x i32]]* %8, i64 0, i64 %28, i64 0
%32 = bitcast i32* %31 to <8 x i32>*
%33 = load <8 x i32>, <8 x i32>* %30
%34 = load <8 x i32>, <8 x i32>* %32
%35 = shufflevector <8 x i32> %33, <8 x i32> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%36 = shufflevector <8 x i32> %34, <8 x i32> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%37 = shufflevector <8 x i32> %33, <8 x i32> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%38 = shufflevector <8 x i32> %34, <8 x i32> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%39 = add <4 x i32> %37, <i32 1, i32 1, i32 1, i32 1>
%40 = add <4 x i32> %38, <i32 1, i32 1, i32 1, i32 1>
%41 = sub <4 x i32> %39, %35
%42 = sub <4 x i32> %40, %36
%43 = getelementptr inbounds [500 x i32], [500 x i32]* %10, i64 0, i64 %27
%44 = bitcast i32* %43 to <4 x i32>*
store <4 x i32> %41, <4 x i32>* %44
%45 = getelementptr inbounds i32, i32* %43, i64 4
%46 = bitcast i32* %45 to <4 x i32>*
store <4 x i32> %42, <4 x i32>* %46
%47 = add nuw i64 %27, 8
%48 = icmp eq i64 %47, %25
br i1 %48, label %49, label %26
49: ; preds = %26
%50 = icmp eq i64 %25, %22
br i1 %50, label %53, label %51
51: ; preds = %21, %49
%52 = phi i64 [ 0, %21 ], [ %25, %49 ]
br label %87
53: ; preds = %87, %49, %7
%54 = icmp sgt i32 %19, 0
br i1 %54, label %55, label %98
55: ; preds = %53
%56 = zext i32 %19 to i64
%57 = icmp ult i32 %19, 8
br i1 %57, label %85, label %58
58: ; preds = %55
%59 = and i64 %56, 4294967288
br label %60
60: ; preds = %60, %58
%61 = phi i64 [ 0, %58 ], [ %81, %60 ]
%62 = or i64 %61, 4
%63 = getelementptr inbounds [500 x [2 x i32]], [500 x [2 x i32]]* %9, i64 0, i64 %61, i64 0
%64 = bitcast i32* %63 to <8 x i32>*
%65 = getelementptr inbounds [500 x [2 x i32]], [500 x [2 x i32]]* %9, i64 0, i64 %62, i64 0
%66 = bitcast i32* %65 to <8 x i32>*
%67 = load <8 x i32>, <8 x i32>* %64
%68 = load <8 x i32>, <8 x i32>* %66
%69 = shufflevector <8 x i32> %67, <8 x i32> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%70 = shufflevector <8 x i32> %68, <8 x i32> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%71 = shufflevector <8 x i32> %67, <8 x i32> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%72 = shufflevector <8 x i32> %68, <8 x i32> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%73 = add <4 x i32> %71, <i32 1, i32 1, i32 1, i32 1>
%74 = add <4 x i32> %72, <i32 1, i32 1, i32 1, i32 1>
%75 = sub <4 x i32> %73, %69
%76 = sub <4 x i32> %74, %70
%77 = getelementptr inbounds [500 x i32], [500 x i32]* %11, i64 0, i64 %61
%78 = bitcast i32* %77 to <4 x i32>*
store <4 x i32> %75, <4 x i32>* %78
%79 = getelementptr inbounds i32, i32* %77, i64 4
%80 = bitcast i32* %79 to <4 x i32>*
store <4 x i32> %76, <4 x i32>* %80
%81 = add nuw i64 %61, 8
%82 = icmp eq i64 %81, %59
br i1 %82, label %83, label %60
83: ; preds = %60
%84 = icmp eq i64 %59, %56
br i1 %84, label %98, label %85
85: ; preds = %55, %83
%86 = phi i64 [ 0, %55 ], [ %59, %83 ]
br label %102
87: ; preds = %51, %87
%88 = phi i64 [ %96, %87 ], [ %52, %51 ]
%89 = getelementptr inbounds [500 x [2 x i32]], [500 x [2 x i32]]* %8, i64 0, i64 %88, i64 1
%90 = load i32, i32* %89
%91 = getelementptr inbounds [500 x [2 x i32]], [500 x [2 x i32]]* %8, i64 0, i64 %88, i64 0
%92 = load i32, i32* %91
%93 = add i32 %90, 1
%94 = sub i32 %93, %92
%95 = getelementptr inbounds [500 x i32], [500 x i32]* %10, i64 0, i64 %88
store i32 %94, i32* %95
%96 = add nuw nsw i64 %88, 1
%97 = icmp eq i64 %96, %22
br i1 %97, label %53, label %87
98: ; preds = %102, %83, %53
br i1 %20, label %99, label %169
99: ; preds = %98
%100 = zext i32 %17 to i64
%101 = zext i32 %19 to i64
br label %113
102: ; preds = %85, %102
%103 = phi i64 [ %111, %102 ], [ %86, %85 ]
%104 = getelementptr inbounds [500 x [2 x i32]], [500 x [2 x i32]]* %9, i64 0, i64 %103, i64 1
%105 = load i32, i32* %104
%106 = getelementptr inbounds [500 x [2 x i32]], [500 x [2 x i32]]* %9, i64 0, i64 %103, i64 0
%107 = load i32, i32* %106
%108 = add i32 %105, 1
%109 = sub i32 %108, %107
%110 = getelementptr inbounds [500 x i32], [500 x i32]* %11, i64 0, i64 %103
store i32 %109, i32* %110
%111 = add nuw nsw i64 %103, 1
%112 = icmp eq i64 %111, %56
br i1 %112, label %98, label %102
113: ; preds = %99, %154
%114 = phi i64 [ 0, %99 ], [ %167, %154 ]
%115 = phi i32 [ 0, %99 ], [ %166, %154 ]
%116 = phi i32 [ 0, %99 ], [ %164, %154 ]
br i1 %54, label %117, label %154
117: ; preds = %113
%118 = getelementptr inbounds [500 x [2 x i32]], [500 x [2 x i32]]* %8, i64 0, i64 %114, i64 0
%119 = load i32, i32* %118
%120 = getelementptr inbounds [500 x [2 x i32]], [500 x [2 x i32]]* %8, i64 0, i64 %114, i64 1
%121 = sub i32 1, %119
br label %122
122: ; preds = %117, %148
%123 = phi i64 [ 0, %117 ], [ %152, %148 ]
%124 = phi i32 [ 0, %117 ], [ %151, %148 ]
%125 = getelementptr inbounds [500 x [2 x i32]], [500 x [2 x i32]]* %9, i64 0, i64 %123, i64 1
%126 = load i32, i32* %125
%127 = icmp slt i32 %126, %119
br i1 %127, label %148, label %128
128: ; preds = %122
%129 = load i32, i32* %120
%130 = getelementptr inbounds [500 x [2 x i32]], [500 x [2 x i32]]* %9, i64 0, i64 %123, i64 0
%131 = load i32, i32* %130
%132 = icmp slt i32 %129, %131
br i1 %132, label %148, label %133
133: ; preds = %128
%134 = icmp slt i32 %131, %119
%135 = icmp sgt i32 %126, %129
%136 = select i1 %134, i1 true, i1 %135
br i1 %136, label %140, label %137
137: ; preds = %133
%138 = getelementptr inbounds [500 x i32], [500 x i32]* %11, i64 0, i64 %123
%139 = load i32, i32* %138
br label %148
140: ; preds = %133
br i1 %134, label %146, label %141
141: ; preds = %140
%142 = icmp slt i32 %126, %129
%143 = select i1 %142, i32 %126, i32 %129
%144 = sub i32 1, %131
%145 = add i32 %144, %143
br label %148
146: ; preds = %140
%147 = add i32 %121, %126
br label %148
148: ; preds = %122, %128, %137, %146, %141
%149 = phi i32 [ %139, %137 ], [ %145, %141 ], [ %147, %146 ], [ 0, %128 ], [ 0, %122 ]
%150 = icmp sgt i32 %149, %124
%151 = select i1 %150, i32 %149, i32 %124
%152 = add nuw nsw i64 %123, 1
%153 = icmp eq i64 %152, %101
br i1 %153, label %154, label %122
154: ; preds = %148, %113
%155 = phi i32 [ 0, %113 ], [ %151, %148 ]
%156 = sitofp i32 %155 to float
%157 = getelementptr inbounds [500 x i32], [500 x i32]* %10, i64 0, i64 %114
%158 = load i32, i32* %157
%159 = sitofp i32 %158 to float
%160 = fdiv float %156, %159
%161 = fcmp ult float %160, %5
%162 = xor i1 %161, true
%163 = zext i1 %162 to i32
%164 = add nuw nsw i32 %116, %163
%165 = zext i1 %161 to i32
%166 = add nuw nsw i32 %115, %165
%167 = add nuw nsw i64 %114, 1
%168 = icmp eq i64 %167, %100
br i1 %168, label %169, label %113
169: ; preds = %154, %98
%170 = phi i32 [ 0, %98 ], [ %164, %154 ]
%171 = phi i32 [ 0, %98 ], [ %166, %154 ]
%172 = sub nsw i32 0, %171
%173 = icmp eq i32 %170, %172
br i1 %173, label %179, label %174
174: ; preds = %169
%175 = sitofp i32 %170 to float
%176 = sitofp i32 %171 to float
%177 = fadd float %175, %176
%178 = fdiv float %175, %177
br label %179
179: ; preds = %169, %174
%180 = phi float [ %178, %174 ], [ -1.000000e+00, %169 ]
store float %180, float* %6
ret i32 1
}