#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 */
float fabs(float);
void set_timestep_interval(float *del_t, int imax, int jmax, float delx,
                           float dely, float **u, float **v, float Re,
                           float tau) {
  int i, j;
  float umax, vmax, deltu, deltv, deltRe;
  if (tau >= 1.0e-10) {
    umax = 1.0e-10;
    vmax = 1.0e-10;
    for (i = 0; i <= imax + 1; i++) {
      for (j = 1; j <= jmax + 1; j++) {
        umax = ((fabs(u[i][j])) > (umax) ? (fabs(u[i][j])) : (umax));
      }
    }
    for (i = 1; i <= imax + 1; i++) {
      for (j = 0; j <= jmax + 1; j++) {
        vmax = ((fabs(v[i][j])) > (vmax) ? (fabs(v[i][j])) : (vmax));
      }
    }
    deltu = delx / umax;
    deltv = dely / vmax;
    deltRe = 1 / (1 / (delx * delx) + 1 / (dely * dely)) * Re / 2.0;
    if (deltu < deltv) {
      *del_t = ((deltu) < (deltRe) ? (deltu) : (deltRe));
    } else {
      *del_t = ((deltv) < (deltRe) ? (deltv) : (deltRe));
    }
    *del_t = tau * (*del_t);
  }
}


x86 assembly (clang, -O0):
<set_timestep_interval>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  %xmm1,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movss  %xmm2,-0x2c(%rbp)
movss  %xmm3,-0x30(%rbp)
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xeb1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     13e4 <set_timestep_interval+0x2d4>
movss  0xeaf(%rip),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  0xea2(%rip),%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1220 <set_timestep_interval+0x110>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     120d <set_timestep_interval+0xfd>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
ucomiss -0x3c(%rbp),%xmm0
jbe    11eb <set_timestep_interval+0xdb>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x50(%rbp)
jmp    11f5 <set_timestep_interval+0xe5>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1192 <set_timestep_interval+0x82>
jmp    1212 <set_timestep_interval+0x102>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    117a <set_timestep_interval+0x6a>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     12cd <set_timestep_interval+0x1bd>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     12ba <set_timestep_interval+0x1aa>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
ucomiss -0x40(%rbp),%xmm0
jbe    1298 <set_timestep_interval+0x188>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x54(%rbp)
jmp    12a2 <set_timestep_interval+0x192>
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    123f <set_timestep_interval+0x12f>
jmp    12bf <set_timestep_interval+0x1af>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1227 <set_timestep_interval+0x117>
movss  -0x14(%rbp),%xmm0
divss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x18(%rbp),%xmm0
divss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x14(%rbp),%xmm0
mulss  -0x14(%rbp),%xmm0
movss  0xd17(%rip),%xmm1
divss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm2
mulss  -0x18(%rbp),%xmm2
movss  0xd01(%rip),%xmm0
divss  %xmm2,%xmm0
addss  %xmm0,%xmm1
movss  0xcf1(%rip),%xmm0
divss  %xmm1,%xmm0
mulss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcd0(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1396 <set_timestep_interval+0x286>
movss  -0x44(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    137a <set_timestep_interval+0x26a>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
jmp    1384 <set_timestep_interval+0x274>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
jmp    13cf <set_timestep_interval+0x2bf>
movss  -0x48(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    13b8 <set_timestep_interval+0x2a8>
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    13c2 <set_timestep_interval+0x2b2>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mulss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<set_timestep_interval>:
push   %r15
push   %r14
push   %rbx
cvtss2sd %xmm3,%xmm4
ucomisd 0xeef(%rip),%xmm4
jb     1362 <set_timestep_interval+0x262>
cmp    $0xffffffff,%esi
jge    1128 <set_timestep_interval+0x28>
movaps 0xeed(%rip),%xmm6
jmp    1312 <set_timestep_interval+0x212>
xor    %r11d,%r11d
test   %edx,%edx
mov    $0x0,%r10d
cmovg  %edx,%r10d
lea    0x2(%rsi),%r9d
lea    0x1(%r10),%r14d
mov    %r14d,%r15d
and    $0x3,%r15d
and    $0xfffffffc,%r14d
movss  0xefe(%rip),%xmm5
movaps 0xec6(%rip),%xmm8
jmp    116d <set_timestep_interval+0x6d>
nopl   0x0(%rax)
add    $0x1,%r11
cmp    %r9,%r11
je     120e <set_timestep_interval+0x10e>
test   %edx,%edx
js     1160 <set_timestep_interval+0x60>
mov    (%rcx,%r11,8),%rax
mov    $0x1,%ebx
cmp    $0x3,%r10d
jb     11d5 <set_timestep_interval+0xd5>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x4(%rax,%rbx,4),%xmm6
movss  0x8(%rax,%rbx,4),%xmm7
movss  0xc(%rax,%rbx,4),%xmm4
andps  %xmm8,%xmm6
maxss  %xmm5,%xmm6
movss  0x10(%rax,%rbx,4),%xmm5
andps  %xmm8,%xmm7
maxss  %xmm6,%xmm7
andps  %xmm8,%xmm4
maxss  %xmm7,%xmm4
andps  %xmm8,%xmm5
maxss  %xmm4,%xmm5
add    $0x4,%rbx
cmp    %rbx,%r14
jne    1190 <set_timestep_interval+0x90>
add    $0x1,%rbx
movaps %xmm5,%xmm6
test   %r15,%r15
je     1160 <set_timestep_interval+0x60>
lea    (%rax,%rbx,4),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rax,%rbx,4),%xmm5
andps  %xmm8,%xmm5
maxss  %xmm6,%xmm5
add    $0x1,%rbx
movaps %xmm5,%xmm6
cmp    %rbx,%r15
jne    11f0 <set_timestep_interval+0xf0>
jmp    1160 <set_timestep_interval+0x60>
test   %esi,%esi
js     1307 <set_timestep_interval+0x207>
test   %edx,%edx
mov    $0xffffffff,%r11d
cmovns %edx,%r11d
add    $0x2,%r11d
lea    -0x1(%r11),%r10
mov    %r11d,%esi
and    $0x3,%esi
and    $0xfffffffc,%r11d
movss  0xe14(%rip),%xmm6
mov    $0x1,%ebx
jmp    125d <set_timestep_interval+0x15d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbx
cmp    %r9,%rbx
je     12fe <set_timestep_interval+0x1fe>
cmp    $0xffffffff,%edx
jl     1250 <set_timestep_interval+0x150>
mov    (%r8,%rbx,8),%rcx
xor    %eax,%eax
cmp    $0x3,%r10
jb     12c8 <set_timestep_interval+0x1c8>
movaps %xmm6,%xmm9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rcx,%rax,4),%xmm4
movss  0x4(%rcx,%rax,4),%xmm7
movss  0x8(%rcx,%rax,4),%xmm10
movss  0xc(%rcx,%rax,4),%xmm6
andps  %xmm8,%xmm4
maxss  %xmm9,%xmm4
andps  %xmm8,%xmm7
maxss  %xmm4,%xmm7
andps  %xmm8,%xmm10
maxss  %xmm7,%xmm10
andps  %xmm8,%xmm6
maxss  %xmm10,%xmm6
add    $0x4,%rax
movaps %xmm6,%xmm9
cmp    %rax,%r11
jne    1280 <set_timestep_interval+0x180>
test   %rsi,%rsi
je     1250 <set_timestep_interval+0x150>
lea    (%rcx,%rax,4),%rax
movaps %xmm6,%xmm7
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm6
andps  %xmm8,%xmm6
maxss  %xmm7,%xmm6
add    $0x1,%rcx
movaps %xmm6,%xmm7
cmp    %rcx,%rsi
jne    12e0 <set_timestep_interval+0x1e0>
jmp    1250 <set_timestep_interval+0x150>
movlhps %xmm5,%xmm6
shufps $0xe2,%xmm5,%xmm6
jmp    1312 <set_timestep_interval+0x212>
movaps 0xd22(%rip),%xmm6
movss  %xmm5,%xmm6
unpcklps %xmm1,%xmm0
movaps %xmm0,%xmm1
divps  %xmm6,%xmm1
mulps  %xmm0,%xmm0
movaps 0xd1b(%rip),%xmm4
divps  %xmm0,%xmm4
movaps %xmm4,%xmm0
shufps $0x55,%xmm4,%xmm0
addss  %xmm4,%xmm0
movss  0xd19(%rip),%xmm4
divss  %xmm0,%xmm4
mulss  %xmm2,%xmm4
mulss  0xd0d(%rip),%xmm4
movaps %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm0
minss  %xmm0,%xmm1
minss  %xmm4,%xmm1
mulss  %xmm3,%xmm1
movss  %xmm1,(%rdi)
pop    %rbx
pop    %r14
pop    %r15
ret

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

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