#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 */
char *cvector(int, int);
int /*<<< orphan*/ free_cvector(char *, int, int);
int /*<<< orphan*/ revcomp(char *, char *, int);
int scan_motif(float **weight_matrix, char *sequence, int motif_length,
               int seq_length, float threshold, int *pos, int rc) {
  int i, j, k;
  int i_stop;
  char c;
  float p;
  int n;
  float current_score;
  char *revcomp_seq;
  i_stop = seq_length - motif_length;
  n = 0;
  for (i = 1; i <= i_stop; i++) {
    current_score = 0.0;
    for (j = 1; j <= motif_length; j++) {
      c = sequence[i + j - 1];
      if ((c > 0) & (c < 5)) {
        p = weight_matrix[c][j];
        current_score += p;
      } else {
        current_score += -7.6;
      }
    }
    if (current_score >= threshold) {
      n++;
      pos[n] = seq_length - i;
    }
  }
  if (rc == 1) {
    revcomp_seq = cvector(1, seq_length);
    revcomp(sequence, revcomp_seq, seq_length);
    for (i = 1; i <= i_stop; i++) {
      current_score = 0;
      for (j = 1; j <= motif_length; j++) {
        c = revcomp_seq[i + j - 1];
        if ((c > 0) & (c < 5)) {
          p = weight_matrix[c][j];
          current_score += p;
        } else {
          current_score += -7.6;
        }
      }
      if (current_score >= threshold) {
        n++;
        pos[n] = -i;
      }
    }
    free_cvector(revcomp_seq, 1, seq_length);
  }
  return n;
}


x86 assembly (clang, -O0):
<scan_motif>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     126d <scan_motif+0x13d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1231 <scan_motif+0x101>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x3d(%rbp)
movsbl -0x3d(%rbp),%eax
cmp    $0x0,%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
movsbl -0x3d(%rbp),%ecx
cmp    $0x5,%ecx
setl   %cl
and    $0x1,%cl
movzbl %cl,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1200 <scan_motif+0xd0>
mov    -0x8(%rbp),%rax
movsbq -0x3d(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    121e <scan_motif+0xee>
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdef(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1223 <scan_motif+0xf3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1185 <scan_motif+0x55>
movss  -0x4c(%rbp),%xmm0
ucomiss -0x1c(%rbp),%xmm0
jb     125a <scan_motif+0x12a>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x18(%rbp),%edx
sub    -0x30(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    125f <scan_motif+0x12f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    116a <scan_motif+0x3a>
cmpl   $0x1,-0x2c(%rbp)
jne    13b2 <scan_motif+0x282>
mov    -0x18(%rbp),%esi
mov    $0x1,%edi
call   1030 <cvector@plt>
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x18(%rbp),%edx
call   1050 <revcomp@plt>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     13a1 <scan_motif+0x271>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1366 <scan_motif+0x236>
mov    -0x58(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x3d(%rbp)
movsbl -0x3d(%rbp),%eax
cmp    $0x0,%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
movsbl -0x3d(%rbp),%ecx
cmp    $0x5,%ecx
setl   %cl
and    $0x1,%cl
movzbl %cl,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1335 <scan_motif+0x205>
mov    -0x8(%rbp),%rax
movsbq -0x3d(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1353 <scan_motif+0x223>
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcba(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1358 <scan_motif+0x228>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12ba <scan_motif+0x18a>
movss  -0x4c(%rbp),%xmm0
ucomiss -0x1c(%rbp),%xmm0
jb     138e <scan_motif+0x25e>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
xor    %edx,%edx
sub    -0x30(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1393 <scan_motif+0x263>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    129f <scan_motif+0x16f>
mov    -0x58(%rbp),%rdi
mov    -0x18(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_cvector@plt>
mov    -0x48(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<scan_motif>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r8,0x10(%rsp)
mov    %ecx,%r14d
mov    %edx,%r12d
mov    %rsi,%rbp
mov    %rdi,%r15
xor    %r13d,%r13d
mov    %ecx,%r8d
sub    %edx,%r8d
jle    120d <scan_motif+0xdd>
movabs $0x100000000,%rcx
lea    0x1(%r12),%edx
add    $0x1,%r8d
xor    %r13d,%r13d
mov    $0x1,%r11d
movsd  0xe7e(%rip),%xmm2
mov    %rcx,%r10
jmp    119c <scan_motif+0x6c>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
add    %rcx,%r10
cmp    %r8,%r11
je     120d <scan_motif+0xdd>
xorps  %xmm1,%xmm1
test   %r12d,%r12d
jle    11f0 <scan_motif+0xc0>
mov    $0x1,%eax
mov    %r10,%rsi
jmp    11c8 <scan_motif+0x98>
xchg   %ax,%ax
cvtss2sd %xmm1,%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
add    $0x1,%rax
add    %rcx,%rsi
cmp    %rax,%rdx
je     11f0 <scan_motif+0xc0>
mov    %rsi,%rdi
sar    $0x20,%rdi
movzbl 0x0(%rbp,%rdi,1),%ebx
lea    -0x1(%rbx),%edi
cmp    $0x3,%dil
ja     11b0 <scan_motif+0x80>
mov    (%r15,%rbx,8),%rdi
addss  (%rdi,%rax,4),%xmm1
jmp    11bc <scan_motif+0x8c>
nopl   0x0(%rax,%rax,1)
ucomiss %xmm0,%xmm1
jb     1190 <scan_motif+0x60>
movslq %r13d,%rax
add    $0x1,%r13d
mov    %r14d,%esi
sub    %r11d,%esi
mov    0x10(%rsp),%rdi
mov    %esi,0x4(%rdi,%rax,4)
jmp    1190 <scan_motif+0x60>
cmp    $0x1,%r9d
jne    1309 <scan_motif+0x1d9>
movss  %xmm0,0xc(%rsp)
mov    $0x1,%edi
mov    %r14d,%esi
call   1030 <cvector@plt>
mov    %r14d,%ebx
mov    %rax,%r14
mov    %rbp,%rdi
mov    %rax,%rsi
mov    %ebx,%edx
call   1050 <revcomp@plt>
mov    %ebx,%edx
mov    %ebx,%r8d
sub    %r12d,%r8d
jle    12fc <scan_motif+0x1cc>
movabs $0x100000000,%rcx
lea    0x1(%r12),%esi
add    $0x1,%r8d
mov    $0x1,%r10d
movsd  0xd94(%rip),%xmm0
mov    %rcx,%r9
movss  0xc(%rsp),%xmm2
jmp    128c <scan_motif+0x15c>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
add    %rcx,%r9
cmp    %r8,%r10
je     12fc <scan_motif+0x1cc>
xorps  %xmm1,%xmm1
test   %r12d,%r12d
jle    12e0 <scan_motif+0x1b0>
mov    $0x1,%ebp
mov    %r9,%rax
jmp    12b8 <scan_motif+0x188>
xchg   %ax,%ax
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
add    $0x1,%rbp
add    %rcx,%rax
cmp    %rbp,%rsi
je     12e0 <scan_motif+0x1b0>
mov    %rax,%rdi
sar    $0x20,%rdi
movzbl (%r14,%rdi,1),%ebx
lea    -0x1(%rbx),%edi
cmp    $0x3,%dil
ja     12a0 <scan_motif+0x170>
mov    (%r15,%rbx,8),%rdi
addss  (%rdi,%rbp,4),%xmm1
jmp    12ac <scan_motif+0x17c>
nopl   0x0(%rax,%rax,1)
ucomiss %xmm2,%xmm1
jb     1280 <scan_motif+0x150>
movslq %r13d,%rax
add    $0x1,%r13d
mov    %r10d,%edi
neg    %edi
mov    0x10(%rsp),%rbp
mov    %edi,0x4(%rbp,%rax,4)
jmp    1280 <scan_motif+0x150>
mov    %r14,%rdi
mov    $0x1,%esi
call   1040 <free_cvector@plt>
mov    %r13d,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @scan_motif(float** nocapture %0, i8* %1, i32 %2, i32 %3, float %4, i32* nocapture writeonly %5, i32 %6) {
%8 = icmp sgt i32 %3, %2
br i1 %8, label %9, label %59
9: ; preds = %7
%10 = icmp slt i32 %2, 1
%11 = add nsw i32 %2, 1
%12 = add i32 %3, 1
%13 = sub i32 %12, %2
%14 = zext i32 %13 to i64
%15 = zext i32 %11 to i64
br label %16
16: ; preds = %9, %55
%17 = phi i64 [ 1, %9 ], [ %57, %55 ]
%18 = phi i32 [ 0, %9 ], [ %56, %55 ]
br i1 %10, label %46, label %19
19: ; preds = %16
%20 = add nuw i64 %17, 4294967295
br label %21
21: ; preds = %19, %42
%22 = phi i64 [ 1, %19 ], [ %44, %42 ]
%23 = phi float [ 0.000000e+00, %19 ], [ %43, %42 ]
%24 = add i64 %20, %22
%25 = shl i64 %24, 32
%26 = ashr exact i64 %25, 32
%27 = getelementptr inbounds i8, i8* %1, i64 %26
%28 = load i8, i8* %27
%29 = add i8 %28, -1
%30 = icmp ult i8 %29, 4
br i1 %30, label %31, label %38
31: ; preds = %21
%32 = zext i8 %28 to i64
%33 = getelementptr inbounds float*, float** %0, i64 %32
%34 = load float*, float** %33
%35 = getelementptr inbounds float, float* %34, i64 %22
%36 = load float, float* %35
%37 = fadd float %23, %36
br label %42
38: ; preds = %21
%39 = fpext float %23 to double
%40 = fadd double %39, -7.600000e+00
%41 = fptrunc double %40 to float
br label %42
42: ; preds = %31, %38
%43 = phi float [ %37, %31 ], [ %41, %38 ]
%44 = add nuw nsw i64 %22, 1
%45 = icmp eq i64 %44, %15
br i1 %45, label %46, label %21
46: ; preds = %42, %16
%47 = phi float [ 0.000000e+00, %16 ], [ %43, %42 ]
%48 = fcmp ult float %47, %4
br i1 %48, label %55, label %49
49: ; preds = %46
%50 = add nsw i32 %18, 1
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i32, i32* %5, i64 %51
%53 = trunc i64 %17 to i32
%54 = sub i32 %3, %53
store i32 %54, i32* %52
br label %55
55: ; preds = %46, %49
%56 = phi i32 [ %50, %49 ], [ %18, %46 ]
%57 = add nuw nsw i64 %17, 1
%58 = icmp eq i64 %57, %14
br i1 %58, label %59, label %16
59: ; preds = %55, %7
%60 = phi i32 [ 0, %7 ], [ %56, %55 ]
%61 = icmp eq i32 %6, 1
br i1 %61, label %62, label %118
62: ; preds = %59
%63 = tail call i8* @cvector(i32 1, i32 %3)
%64 = tail call i32 @revcomp(i8* %1, i8* %63, i32 %3)
br i1 %8, label %65, label %115
65: ; preds = %62
%66 = icmp slt i32 %2, 1
%67 = add nsw i32 %2, 1
%68 = add i32 %3, 1
%69 = sub i32 %68, %2
%70 = zext i32 %69 to i64
%71 = zext i32 %67 to i64
br label %72
72: ; preds = %65, %111
%73 = phi i64 [ 1, %65 ], [ %113, %111 ]
%74 = phi i32 [ %60, %65 ], [ %112, %111 ]
br i1 %66, label %102, label %75
75: ; preds = %72
%76 = add nuw i64 %73, 4294967295
br label %77
77: ; preds = %75, %98
%78 = phi i64 [ 1, %75 ], [ %100, %98 ]
%79 = phi float [ 0.000000e+00, %75 ], [ %99, %98 ]
%80 = add i64 %76, %78
%81 = shl i64 %80, 32
%82 = ashr exact i64 %81, 32
%83 = getelementptr inbounds i8, i8* %63, i64 %82
%84 = load i8, i8* %83
%85 = add i8 %84, -1
%86 = icmp ult i8 %85, 4
br i1 %86, label %87, label %94
87: ; preds = %77
%88 = zext i8 %84 to i64
%89 = getelementptr inbounds float*, float** %0, i64 %88
%90 = load float*, float** %89
%91 = getelementptr inbounds float, float* %90, i64 %78
%92 = load float, float* %91
%93 = fadd float %79, %92
br label %98
94: ; preds = %77
%95 = fpext float %79 to double
%96 = fadd double %95, -7.600000e+00
%97 = fptrunc double %96 to float
br label %98
98: ; preds = %87, %94
%99 = phi float [ %93, %87 ], [ %97, %94 ]
%100 = add nuw nsw i64 %78, 1
%101 = icmp eq i64 %100, %71
br i1 %101, label %102, label %77
102: ; preds = %98, %72
%103 = phi float [ 0.000000e+00, %72 ], [ %99, %98 ]
%104 = fcmp ult float %103, %4
br i1 %104, label %111, label %105
105: ; preds = %102
%106 = add nsw i32 %74, 1
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds i32, i32* %5, i64 %107
%109 = trunc i64 %73 to i32
%110 = sub i32 0, %109
store i32 %110, i32* %108
br label %111
111: ; preds = %102, %105
%112 = phi i32 [ %106, %105 ], [ %74, %102 ]
%113 = add nuw nsw i64 %73, 1
%114 = icmp eq i64 %113, %70
br i1 %114, label %115, label %72
115: ; preds = %111, %62
%116 = phi i32 [ %60, %62 ], [ %112, %111 ]
%117 = tail call i32 @free_cvector(i8* %63, i32 1, i32 %3)
br label %118
118: ; preds = %115, %59
%119 = phi i32 [ %116, %115 ], [ %60, %59 ]
ret i32 %119
}