#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 /*<<< orphan*/ bcopy(float *, unsigned char *, int);
int perturb_real_(float *field, int ds[], int de[], int ms[], int me[],
                  int ps[], int pe[]) {
  int i, j, k;
  int le;
  float x = 2.0;
  unsigned int y;
  unsigned char a[4], *p;
  if (sizeof(float) != 4)
    return (-1);
  bcopy(&x, a, 4);
  le = 0;
  if (a[0] == 0x40)
    le = 3;
  for (k = ps[2] - ms[2]; k <= pe[2] - ms[2]; k++)
    for (j = ps[1] - ms[1]; j <= pe[1] - ms[1]; j++)
      for (i = ps[0] - ms[0]; i <= pe[0] - ms[0]; i++) {
        if (field[(((((i)) + ((j)) * ((me[1] - ms[1] + 1)))) +
                   ((k)) * ((me[1] - ms[1] + 1) * (me[0] - ms[0] + 1)))] !=
            0.0) {
          p = (unsigned char *)&(
              field[(((((i)) + ((j)) * ((me[1] - ms[1] + 1)))) +
                     ((k)) * ((me[1] - ms[1] + 1) * (me[0] - ms[0] + 1)))]);
          if (*(p + le) & 1) {
            *(p + le) &= 0x7e;
          } else {
            *(p + le) |= 1;
          }
        }
      }
  return (0);
}


x86 assembly (clang, -O0):
<perturb_real_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  0xec4(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
lea    -0x4c(%rbp),%rsi
lea    -0x44(%rbp),%rdi
mov    $0x4,%edx
call   1030 <bcopy@plt>
movl   $0x0,-0x40(%rbp)
movzbl -0x4c(%rbp),%eax
cmp    $0x40,%eax
jne    116e <perturb_real_+0x5e>
movl   $0x3,-0x40(%rbp)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%eax
mov    -0x20(%rbp),%rcx
sub    0x8(%rcx),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x10(%rbp),%rcx
mov    0x8(%rcx),%ecx
mov    -0x20(%rbp),%rdx
sub    0x8(%rdx),%ecx
cmp    %ecx,%eax
jg     1331 <perturb_real_+0x221>
mov    -0x30(%rbp),%rax
mov    0x4(%rax),%eax
mov    -0x20(%rbp),%rcx
sub    0x4(%rcx),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x20(%rbp),%rdx
sub    0x4(%rdx),%ecx
cmp    %ecx,%eax
jg     131e <perturb_real_+0x20e>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    -0x20(%rbp),%rcx
sub    (%rcx),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x20(%rbp),%rdx
sub    (%rdx),%ecx
cmp    %ecx,%eax
jg     130b <perturb_real_+0x1fb>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
mov    -0x28(%rbp),%rsi
mov    0x4(%rsi),%esi
mov    -0x20(%rbp),%rdi
sub    0x4(%rdi),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x28(%rbp),%rsi
mov    0x4(%rsi),%esi
mov    -0x20(%rbp),%rdi
sub    0x4(%rdi),%esi
add    $0x1,%esi
mov    -0x28(%rbp),%rdi
mov    (%rdi),%edi
mov    -0x20(%rbp),%r8
sub    (%r8),%edi
add    $0x1,%edi
imul   %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1258 <perturb_real_+0x148>
jp     1258 <perturb_real_+0x148>
jmp    12f8 <perturb_real_+0x1e8>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
mov    -0x28(%rbp),%rsi
mov    0x4(%rsi),%esi
mov    -0x20(%rbp),%rdi
sub    0x4(%rdi),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x28(%rbp),%rsi
mov    0x4(%rsi),%esi
mov    -0x20(%rbp),%rdi
sub    0x4(%rdi),%esi
add    $0x1,%esi
mov    -0x28(%rbp),%rdi
mov    (%rdi),%edi
mov    -0x20(%rbp),%r8
sub    (%r8),%edi
add    $0x1,%edi
imul   %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     12e1 <perturb_real_+0x1d1>
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
and    $0x7e,%edx
mov    %dl,(%rax,%rcx,1)
jmp    12f3 <perturb_real_+0x1e3>
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
or     $0x1,%edx
mov    %dl,(%rax,%rcx,1)
jmp    12f8 <perturb_real_+0x1e8>
jmp    12fd <perturb_real_+0x1ed>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11d1 <perturb_real_+0xc1>
jmp    1310 <perturb_real_+0x200>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11a9 <perturb_real_+0x99>
jmp    1323 <perturb_real_+0x213>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    117f <perturb_real_+0x6f>
xor    %eax,%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<perturb_real_>:
push   %rbp
push   %r15
push   %r14
push   %rbx
mov    0x28(%rsp),%r10
mov    0x8(%r9),%r14d
mov    0x8(%r10),%ebx
cmp    %ebx,%r14d
jle    1121 <perturb_real_+0x21>
xor    %eax,%eax
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x4(%rcx),%esi
mov    0x8(%rcx),%ebp
sub    %ebp,%r14d
mov    0x4(%r10),%r11d
xorps  %xmm0,%xmm0
jmp    1157 <perturb_real_+0x57>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x8(%r10),%ebx
mov    0x8(%rcx),%ebp
lea    0x1(%r14),%eax
mov    %ebx,%edx
sub    %ebp,%edx
cmp    %edx,%r14d
mov    %eax,%r14d
jge    1118 <perturb_real_+0x18>
mov    0x4(%r9),%r15d
cmp    %r11d,%r15d
jg     1147 <perturb_real_+0x47>
sub    %esi,%r15d
mov    (%rcx),%ebx
mov    (%r10),%edx
jmp    1188 <perturb_real_+0x88>
nopw   0x0(%rax,%rax,1)
mov    0x4(%r10),%r11d
mov    0x4(%rcx),%esi
lea    0x1(%r15),%eax
mov    %r11d,%ebp
sub    %esi,%ebp
cmp    %ebp,%r15d
mov    %eax,%r15d
jge    1140 <perturb_real_+0x40>
mov    (%r9),%ebp
cmp    %edx,%ebp
jg     1177 <perturb_real_+0x77>
sub    %ebx,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r8),%edx
sub    %ebx,%edx
mov    0x4(%r8),%ebx
sub    %esi,%ebx
add    $0x1,%ebx
add    $0x1,%edx
imul   %r14d,%edx
add    %r15d,%edx
imul   %ebx,%edx
add    %ebp,%edx
movslq %edx,%rdx
movss  (%rdi,%rdx,4),%xmm1
ucomiss %xmm0,%xmm1
jne    11cc <perturb_real_+0xcc>
jnp    11e9 <perturb_real_+0xe9>
movd   %xmm1,%esi
mov    %esi,%ebx
or     $0x1,%bl
mov    %esi,%eax
and    $0x7e,%al
test   $0x1,%sil
movzbl %bl,%esi
movzbl %al,%eax
cmove  %esi,%eax
mov    %al,(%rdi,%rdx,4)
mov    (%r10),%edx
mov    (%rcx),%ebx
mov    %edx,%eax
sub    %ebx,%eax
cmp    %eax,%ebp
jge    1170 <perturb_real_+0x70>
add    $0x1,%ebp
mov    0x4(%rcx),%esi
jmp    11a0 <perturb_real_+0xa0>

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

LLVM IR (-O2):
define i32 @perturb_real_(float* nocapture %0, i32* nocapture readnone %1, i32* nocapture readnone %2, i32* nocapture %3, i32* nocapture %4, i32* nocapture %5, i32* nocapture %6) {
%8 = getelementptr inbounds i32, i32* %5, i64 2
%9 = load i32, i32* %8
%10 = getelementptr inbounds i32, i32* %3, i64 2
%11 = getelementptr inbounds i32, i32* %6, i64 2
%12 = load i32, i32* %11
%13 = icmp sgt i32 %9, %12
br i1 %13, label %107, label %14
14: ; preds = %7
%15 = load i32, i32* %10
%16 = sub nsw i32 %9, %15
%17 = getelementptr inbounds i32, i32* %5, i64 1
%18 = getelementptr inbounds i32, i32* %3, i64 1
%19 = getelementptr inbounds i32, i32* %6, i64 1
%20 = getelementptr inbounds i32, i32* %4, i64 1
%21 = load i32, i32* %18
%22 = load i32, i32* %19
br label %23
23: ; preds = %14, %97
%24 = phi i32 [ %15, %14 ], [ %98, %97 ]
%25 = phi i32 [ %12, %14 ], [ %99, %97 ]
%26 = phi i32 [ %21, %14 ], [ %100, %97 ]
%27 = phi i32 [ %22, %14 ], [ %101, %97 ]
%28 = phi i32 [ %22, %14 ], [ %102, %97 ]
%29 = phi i32 [ %21, %14 ], [ %103, %97 ]
%30 = phi i32 [ %16, %14 ], [ %104, %97 ]
%31 = load i32, i32* %17
%32 = icmp sgt i32 %31, %28
br i1 %32, label %97, label %33
33: ; preds = %23
%34 = sub nsw i32 %31, %29
%35 = load i32, i32* %3
%36 = load i32, i32* %6
br label %37
37: ; preds = %33, %86
%38 = phi i32 [ %87, %86 ], [ %26, %33 ]
%39 = phi i32 [ %88, %86 ], [ %27, %33 ]
%40 = phi i32 [ %87, %86 ], [ %29, %33 ]
%41 = phi i32 [ %89, %86 ], [ %36, %33 ]
%42 = phi i32 [ %90, %86 ], [ %35, %33 ]
%43 = phi i32 [ %91, %86 ], [ %34, %33 ]
%44 = load i32, i32* %5
%45 = icmp sgt i32 %44, %41
br i1 %45, label %86, label %46
46: ; preds = %37
%47 = sub nsw i32 %44, %42
br label %48
48: ; preds = %80, %46
%49 = phi i32 [ %82, %80 ], [ %40, %46 ]
%50 = phi i32 [ %77, %80 ], [ %42, %46 ]
%51 = phi i32 [ %81, %80 ], [ %47, %46 ]
%52 = load i32, i32* %20
%53 = sub nsw i32 %52, %49
%54 = add nsw i32 %53, 1
%55 = load i32, i32* %4
%56 = sub i32 1, %50
%57 = add i32 %56, %55
%58 = mul i32 %57, %30
%59 = add i32 %58, %43
%60 = mul i32 %59, %54
%61 = add i32 %60, %51
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds float, float* %0, i64 %62
%64 = load float, float* %63
%65 = fcmp une float %64, 0.000000e+00
%66 = bitcast float %64 to i32
%67 = trunc i32 %66 to i8
br i1 %65, label %68, label %75
68: ; preds = %48
%69 = bitcast float* %63 to i8*
%70 = and i8 %67, 1
%71 = icmp eq i8 %70, 0
%72 = or i8 %67, 1
%73 = and i8 %67, 126
%74 = select i1 %71, i8 %72, i8 %73
store i8 %74, i8* %69
br label %75
75: ; preds = %68, %48
%76 = load i32, i32* %6
%77 = load i32, i32* %3
%78 = sub nsw i32 %76, %77
%79 = icmp slt i32 %51, %78
br i1 %79, label %80, label %83
80: ; preds = %75
%81 = add nsw i32 %51, 1
%82 = load i32, i32* %18
br label %48
83: ; preds = %75
%84 = load i32, i32* %19
%85 = load i32, i32* %18
br label %86
86: ; preds = %83, %37
%87 = phi i32 [ %85, %83 ], [ %38, %37 ]
%88 = phi i32 [ %84, %83 ], [ %39, %37 ]
%89 = phi i32 [ %76, %83 ], [ %41, %37 ]
%90 = phi i32 [ %77, %83 ], [ %42, %37 ]
%91 = add nsw i32 %43, 1
%92 = sub nsw i32 %88, %87
%93 = icmp slt i32 %43, %92
br i1 %93, label %37, label %94
94: ; preds = %86
%95 = load i32, i32* %11
%96 = load i32, i32* %10
br label %97
97: ; preds = %94, %23
%98 = phi i32 [ %96, %94 ], [ %24, %23 ]
%99 = phi i32 [ %95, %94 ], [ %25, %23 ]
%100 = phi i32 [ %87, %94 ], [ %26, %23 ]
%101 = phi i32 [ %88, %94 ], [ %27, %23 ]
%102 = phi i32 [ %88, %94 ], [ %28, %23 ]
%103 = phi i32 [ %87, %94 ], [ %29, %23 ]
%104 = add nsw i32 %30, 1
%105 = sub nsw i32 %99, %98
%106 = icmp slt i32 %30, %105
br i1 %106, label %23, label %107
107: ; preds = %97, %7
ret i32 0
}