#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 *lambert_getval(char *, char *, long, float *, float *, int, int, int);
void fort_lambert_getval_(char *pFileN, char *pFileS, void *pNGal, float *pGall,
                          float *pGalb, void *pQInterp, void *pQNoloop,
                          void *pQVerbose, float *pOutput) {
  int iChar;
  int qInterp;
  int qNoloop;
  int qVerbose;
  long iGal;
  long nGal;
  float *pTemp;
  for (iChar = 0; iChar < 80; iChar++)
    if (pFileN[iChar] == ' ')
      pFileN[iChar] = '\0';
  for (iChar = 0; iChar < 80; iChar++)
    if (pFileS[iChar] == ' ')
      pFileS[iChar] = '\0';
  if (sizeof(short) == 4) {
    nGal = *((short *)pNGal);
    qInterp = *((short *)pQInterp);
    qNoloop = *((short *)pQNoloop);
    qVerbose = *((short *)pQVerbose);
  } else if (sizeof(int) == 4) {
    nGal = *((int *)pNGal);
    qInterp = *((int *)pQInterp);
    qNoloop = *((int *)pQNoloop);
    qVerbose = *((int *)pQVerbose);
  } else if (sizeof(long) == 4) {
    nGal = *((long *)pNGal);
    qInterp = *((long *)pQInterp);
    qNoloop = *((long *)pQNoloop);
    qVerbose = *((long *)pQVerbose);
  }
  pTemp = lambert_getval(pFileN, pFileS, nGal, pGall, pGalb, qInterp, qNoloop,
                         qVerbose);
  for (iGal = 0; iGal < nGal; iGal++)
    pOutput[iGal] = pTemp[iGal];
}


x86 assembly (clang, -O0):
<fort_lambert_getval_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
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)
movl   $0x0,-0x34(%rbp)
cmpl   $0x50,-0x34(%rbp)
jge    1181 <fort_lambert_getval_+0x71>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    116e <fort_lambert_getval_+0x5e>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1173 <fort_lambert_getval_+0x63>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1143 <fort_lambert_getval_+0x33>
movl   $0x0,-0x34(%rbp)
cmpl   $0x50,-0x34(%rbp)
jge    11c6 <fort_lambert_getval_+0xb6>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    11b3 <fort_lambert_getval_+0xa3>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    11b8 <fort_lambert_getval_+0xa8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1188 <fort_lambert_getval_+0x78>
mov    -0x18(%rbp),%rax
movslq (%rax),%rax
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x40(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    -0x38(%rbp),%r9d
mov    -0x3c(%rbp),%r10d
mov    -0x40(%rbp),%eax
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1030 <lambert_getval@plt>
mov    %rax,-0x58(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jge    125d <fort_lambert_getval_+0x14d>
mov    -0x58(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1224 <fort_lambert_getval_+0x114>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fort_lambert_getval_>:
push   %rbp
push   %r14
push   %rbx
mov    0x30(%rsp),%rbx
mov    0x28(%rsp),%r10
mov    0x20(%rsp),%r11
xor    %eax,%eax
movdqa 0xed3(%rip),%xmm0
movdqa 0xedb(%rip),%xmm1
jmp    114e <fort_lambert_getval_+0x3e>
nopw   0x0(%rax,%rax,1)
add    $0x8,%rax
cmp    $0x50,%rax
je     1216 <fort_lambert_getval_+0x106>
movq   (%rdi,%rax,1),%xmm3
movdqa %xmm3,%xmm2
pcmpeqb %xmm0,%xmm2
movd   %xmm2,%ebp
test   $0x1,%bpl
je     1169 <fort_lambert_getval_+0x59>
movb   $0x0,(%rdi,%rax,1)
movdqa %xmm2,%xmm4
pslld  $0x8,%xmm4
movd   %xmm4,%ebp
shr    $0x10,%ebp
test   $0x1,%bpl
je     1184 <fort_lambert_getval_+0x74>
movb   $0x0,0x1(%rdi,%rax,1)
pshuflw $0x55,%xmm3,%xmm4
pcmpeqb %xmm0,%xmm4
pextrw $0x2,%xmm4,%ebp
test   $0x1,%bpl
je     119d <fort_lambert_getval_+0x8d>
movb   $0x0,0x2(%rdi,%rax,1)
movdqa %xmm2,%xmm4
psllq  $0x18,%xmm4
pextrw $0x3,%xmm4,%ebp
test   $0x1,%bpl
je     11b6 <fort_lambert_getval_+0xa6>
movb   $0x0,0x3(%rdi,%rax,1)
pshufd $0x55,%xmm3,%xmm3
pcmpeqb %xmm1,%xmm3
pextrw $0x4,%xmm3,%ebp
test   $0x1,%bpl
je     11cf <fort_lambert_getval_+0xbf>
movb   $0x0,0x4(%rdi,%rax,1)
movdqa %xmm2,%xmm3
pslldq $0x5,%xmm3
pextrw $0x5,%xmm3,%ebp
test   $0x1,%bpl
je     11e8 <fort_lambert_getval_+0xd8>
movb   $0x0,0x5(%rdi,%rax,1)
pextrw $0x3,%xmm2,%ebp
test   $0x1,%bpl
je     11f8 <fort_lambert_getval_+0xe8>
movb   $0x0,0x6(%rdi,%rax,1)
pslldq $0x7,%xmm2
pextrw $0x7,%xmm2,%ebp
test   $0x1,%bpl
je     1140 <fort_lambert_getval_+0x30>
movb   $0x0,0x7(%rdi,%rax,1)
jmp    1140 <fort_lambert_getval_+0x30>
xor    %eax,%eax
jmp    122e <fort_lambert_getval_+0x11e>
nopw   0x0(%rax,%rax,1)
add    $0x8,%rax
cmp    $0x50,%rax
je     12f6 <fort_lambert_getval_+0x1e6>
movq   (%rsi,%rax,1),%xmm3
movdqa %xmm3,%xmm2
pcmpeqb %xmm0,%xmm2
movd   %xmm2,%ebp
test   $0x1,%bpl
je     1249 <fort_lambert_getval_+0x139>
movb   $0x0,(%rsi,%rax,1)
movdqa %xmm2,%xmm4
pslld  $0x8,%xmm4
movd   %xmm4,%ebp
shr    $0x10,%ebp
test   $0x1,%bpl
je     1264 <fort_lambert_getval_+0x154>
movb   $0x0,0x1(%rsi,%rax,1)
pshuflw $0x55,%xmm3,%xmm4
pcmpeqb %xmm0,%xmm4
pextrw $0x2,%xmm4,%ebp
test   $0x1,%bpl
je     127d <fort_lambert_getval_+0x16d>
movb   $0x0,0x2(%rsi,%rax,1)
movdqa %xmm2,%xmm4
psllq  $0x18,%xmm4
pextrw $0x3,%xmm4,%ebp
test   $0x1,%bpl
je     1296 <fort_lambert_getval_+0x186>
movb   $0x0,0x3(%rsi,%rax,1)
pshufd $0x55,%xmm3,%xmm3
pcmpeqb %xmm1,%xmm3
pextrw $0x4,%xmm3,%ebp
test   $0x1,%bpl
je     12af <fort_lambert_getval_+0x19f>
movb   $0x0,0x4(%rsi,%rax,1)
movdqa %xmm2,%xmm3
pslldq $0x5,%xmm3
pextrw $0x5,%xmm3,%ebp
test   $0x1,%bpl
je     12c8 <fort_lambert_getval_+0x1b8>
movb   $0x0,0x5(%rsi,%rax,1)
pextrw $0x3,%xmm2,%ebp
test   $0x1,%bpl
je     12d8 <fort_lambert_getval_+0x1c8>
movb   $0x0,0x6(%rsi,%rax,1)
pslldq $0x7,%xmm2
pextrw $0x7,%xmm2,%ebp
test   $0x1,%bpl
je     1220 <fort_lambert_getval_+0x110>
movb   $0x0,0x7(%rsi,%rax,1)
jmp    1220 <fort_lambert_getval_+0x110>
movslq (%rdx),%r14
mov    (%r9),%r9d
mov    (%r11),%eax
mov    (%r10),%ebp
mov    %r14,%rdx
push   %rbp
push   %rax
call   1030 <lambert_getval@plt>
add    $0x10,%rsp
test   %r14,%r14
jle    1488 <fort_lambert_getval_+0x378>
cmp    $0x8,%r14d
jb     1335 <fort_lambert_getval_+0x225>
lea    (%rax,%r14,4),%rcx
cmp    %rbx,%rcx
jbe    13ac <fort_lambert_getval_+0x29c>
lea    (%rbx,%r14,4),%rcx
cmp    %rcx,%rax
jae    13ac <fort_lambert_getval_+0x29c>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r14,%rdx
mov    %r14,%rsi
and    $0x3,%rsi
je     1364 <fort_lambert_getval_+0x254>
nopl   0x0(%rax)
movd   (%rax,%rcx,4),%xmm0
movd   %xmm0,(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1350 <fort_lambert_getval_+0x240>
cmp    $0x3,%rdx
jb     1488 <fort_lambert_getval_+0x378>
xchg   %ax,%ax
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,0x4(%rbx,%rcx,4)
movss  0x8(%rax,%rcx,4),%xmm0
movss  %xmm0,0x8(%rbx,%rcx,4)
movd   0xc(%rax,%rcx,4),%xmm0
movd   %xmm0,0xc(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r14
jne    1370 <fort_lambert_getval_+0x260>
jmp    1488 <fort_lambert_getval_+0x378>
mov    %r14,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rdx
jae    13d3 <fort_lambert_getval_+0x2c3>
xor    %edi,%edi
jmp    143c <fort_lambert_getval_+0x32c>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
movups %xmm0,(%rbx,%rdi,4)
movups %xmm1,0x10(%rbx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm0
movups 0x30(%rax,%rdi,4),%xmm1
movups %xmm0,0x20(%rbx,%rdi,4)
movups %xmm1,0x30(%rbx,%rdi,4)
movups 0x40(%rax,%rdi,4),%xmm0
movups 0x50(%rax,%rdi,4),%xmm1
movups %xmm0,0x40(%rbx,%rdi,4)
movups %xmm1,0x50(%rbx,%rdi,4)
movdqu 0x60(%rax,%rdi,4),%xmm0
movdqu 0x70(%rax,%rdi,4),%xmm1
movdqu %xmm0,0x60(%rbx,%rdi,4)
movdqu %xmm1,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    13e0 <fort_lambert_getval_+0x2d0>
test   %r8,%r8
je     147f <fort_lambert_getval_+0x36f>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rax,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rdi,%rdx,1),%xmm0
movdqu (%rdi,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rsi,%rdx,1)
movdqu %xmm1,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    1460 <fort_lambert_getval_+0x350>
cmp    %r14,%rcx
jne    1337 <fort_lambert_getval_+0x227>
pop    %rbx
pop    %r14
pop    %rbp
ret

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

LLVM IR (-O2):
define void @fort_lambert_getval_(i8* %0, i8* %1, i8* nocapture %2, float* %3, float* %4, i8* nocapture %5, i8* nocapture %6, i8* nocapture %7, float* nocapture writeonly %8) {
br label %10
10: ; preds = %54, %9
%11 = phi i64 [ 0, %9 ], [ %55, %54 ]
%12 = getelementptr inbounds i8, i8* %0, i64 %11
%13 = bitcast i8* %12 to <8 x i8>*
%14 = load <8 x i8>, <8 x i8>* %13
%15 = icmp eq <8 x i8> %14, <i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32>
%16 = extractelement <8 x i1> %15, i64 0
br i1 %16, label %17, label %19
17: ; preds = %10
%18 = getelementptr inbounds i8, i8* %0, i64 %11
store i8 0, i8* %18
br label %19
19: ; preds = %17, %10
%20 = extractelement <8 x i1> %15, i64 1
br i1 %20, label %21, label %24
21: ; preds = %19
%22 = or i64 %11, 1
%23 = getelementptr inbounds i8, i8* %0, i64 %22
store i8 0, i8* %23
br label %24
24: ; preds = %21, %19
%25 = extractelement <8 x i1> %15, i64 2
br i1 %25, label %26, label %29
26: ; preds = %24
%27 = or i64 %11, 2
%28 = getelementptr inbounds i8, i8* %0, i64 %27
store i8 0, i8* %28
br label %29
29: ; preds = %26, %24
%30 = extractelement <8 x i1> %15, i64 3
br i1 %30, label %31, label %34
31: ; preds = %29
%32 = or i64 %11, 3
%33 = getelementptr inbounds i8, i8* %0, i64 %32
store i8 0, i8* %33
br label %34
34: ; preds = %31, %29
%35 = extractelement <8 x i1> %15, i64 4
br i1 %35, label %36, label %39
36: ; preds = %34
%37 = or i64 %11, 4
%38 = getelementptr inbounds i8, i8* %0, i64 %37
store i8 0, i8* %38
br label %39
39: ; preds = %36, %34
%40 = extractelement <8 x i1> %15, i64 5
br i1 %40, label %41, label %44
41: ; preds = %39
%42 = or i64 %11, 5
%43 = getelementptr inbounds i8, i8* %0, i64 %42
store i8 0, i8* %43
br label %44
44: ; preds = %41, %39
%45 = extractelement <8 x i1> %15, i64 6
br i1 %45, label %46, label %49
46: ; preds = %44
%47 = or i64 %11, 6
%48 = getelementptr inbounds i8, i8* %0, i64 %47
store i8 0, i8* %48
br label %49
49: ; preds = %46, %44
%50 = extractelement <8 x i1> %15, i64 7
br i1 %50, label %51, label %54
51: ; preds = %49
%52 = or i64 %11, 7
%53 = getelementptr inbounds i8, i8* %0, i64 %52
store i8 0, i8* %53
br label %54
54: ; preds = %51, %49
%55 = add nuw i64 %11, 8
%56 = icmp eq i64 %55, 80
br i1 %56, label %57, label %10
57: ; preds = %54, %101
%58 = phi i64 [ %102, %101 ], [ 0, %54 ]
%59 = getelementptr inbounds i8, i8* %1, i64 %58
%60 = bitcast i8* %59 to <8 x i8>*
%61 = load <8 x i8>, <8 x i8>* %60
%62 = icmp eq <8 x i8> %61, <i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32>
%63 = extractelement <8 x i1> %62, i64 0
br i1 %63, label %64, label %66
64: ; preds = %57
%65 = getelementptr inbounds i8, i8* %1, i64 %58
store i8 0, i8* %65
br label %66
66: ; preds = %64, %57
%67 = extractelement <8 x i1> %62, i64 1
br i1 %67, label %68, label %71
68: ; preds = %66
%69 = or i64 %58, 1
%70 = getelementptr inbounds i8, i8* %1, i64 %69
store i8 0, i8* %70
br label %71
71: ; preds = %68, %66
%72 = extractelement <8 x i1> %62, i64 2
br i1 %72, label %73, label %76
73: ; preds = %71
%74 = or i64 %58, 2
%75 = getelementptr inbounds i8, i8* %1, i64 %74
store i8 0, i8* %75
br label %76
76: ; preds = %73, %71
%77 = extractelement <8 x i1> %62, i64 3
br i1 %77, label %78, label %81
78: ; preds = %76
%79 = or i64 %58, 3
%80 = getelementptr inbounds i8, i8* %1, i64 %79
store i8 0, i8* %80
br label %81
81: ; preds = %78, %76
%82 = extractelement <8 x i1> %62, i64 4
br i1 %82, label %83, label %86
83: ; preds = %81
%84 = or i64 %58, 4
%85 = getelementptr inbounds i8, i8* %1, i64 %84
store i8 0, i8* %85
br label %86
86: ; preds = %83, %81
%87 = extractelement <8 x i1> %62, i64 5
br i1 %87, label %88, label %91
88: ; preds = %86
%89 = or i64 %58, 5
%90 = getelementptr inbounds i8, i8* %1, i64 %89
store i8 0, i8* %90
br label %91
91: ; preds = %88, %86
%92 = extractelement <8 x i1> %62, i64 6
br i1 %92, label %93, label %96
93: ; preds = %91
%94 = or i64 %58, 6
%95 = getelementptr inbounds i8, i8* %1, i64 %94
store i8 0, i8* %95
br label %96
96: ; preds = %93, %91
%97 = extractelement <8 x i1> %62, i64 7
br i1 %97, label %98, label %101
98: ; preds = %96
%99 = or i64 %58, 7
%100 = getelementptr inbounds i8, i8* %1, i64 %99
store i8 0, i8* %100
br label %101
101: ; preds = %98, %96
%102 = add nuw i64 %58, 8
%103 = icmp eq i64 %102, 80
br i1 %103, label %104, label %57
104: ; preds = %101
%105 = bitcast i8* %2 to i32*
%106 = load i32, i32* %105
%107 = sext i32 %106 to i64
%108 = bitcast i8* %5 to i32*
%109 = load i32, i32* %108
%110 = bitcast i8* %6 to i32*
%111 = load i32, i32* %110
%112 = bitcast i8* %7 to i32*
%113 = load i32, i32* %112
%114 = tail call float* @lambert_getval(i8* %0, i8* %1, i64 %107, float* %3, float* %4, i32 %109, i32 %111, i32 %113)
%115 = icmp sgt i32 %106, 0
br i1 %115, label %116, label %240
116: ; preds = %104
%117 = icmp ult i32 %106, 8
br i1 %117, label %203, label %118
118: ; preds = %116
%119 = getelementptr float, float* %8, i64 %107
%120 = getelementptr float, float* %114, i64 %107
%121 = icmp ugt float* %120, %8
%122 = icmp ult float* %114, %119
%123 = and i1 %121, %122
br i1 %123, label %203, label %124
124: ; preds = %118
%125 = and i64 %107, -8
%126 = add nsw i64 %125, -8
%127 = lshr exact i64 %126, 3
%128 = add nuw nsw i64 %127, 1
%129 = and i64 %128, 3
%130 = icmp ult i64 %126, 24
br i1 %130, label %182, label %131
131: ; preds = %124
%132 = and i64 %128, 4611686018427387900
br label %133
133: ; preds = %133, %131
%134 = phi i64 [ 0, %131 ], [ %179, %133 ]
%135 = phi i64 [ 0, %131 ], [ %180, %133 ]
%136 = getelementptr inbounds float, float* %114, i64 %134
%137 = bitcast float* %136 to <4 x float>*
%138 = load <4 x float>, <4 x float>* %137
%139 = getelementptr inbounds float, float* %136, i64 4
%140 = bitcast float* %139 to <4 x float>*
%141 = load <4 x float>, <4 x float>* %140
%142 = getelementptr inbounds float, float* %8, i64 %134
%143 = bitcast float* %142 to <4 x float>*
store <4 x float> %138, <4 x float>* %143
%144 = getelementptr inbounds float, float* %142, i64 4
%145 = bitcast float* %144 to <4 x float>*
store <4 x float> %141, <4 x float>* %145
%146 = or i64 %134, 8
%147 = getelementptr inbounds float, float* %114, i64 %146
%148 = bitcast float* %147 to <4 x float>*
%149 = load <4 x float>, <4 x float>* %148
%150 = getelementptr inbounds float, float* %147, i64 4
%151 = bitcast float* %150 to <4 x float>*
%152 = load <4 x float>, <4 x float>* %151
%153 = getelementptr inbounds float, float* %8, i64 %146
%154 = bitcast float* %153 to <4 x float>*
store <4 x float> %149, <4 x float>* %154
%155 = getelementptr inbounds float, float* %153, i64 4
%156 = bitcast float* %155 to <4 x float>*
store <4 x float> %152, <4 x float>* %156
%157 = or i64 %134, 16
%158 = getelementptr inbounds float, float* %114, i64 %157
%159 = bitcast float* %158 to <4 x float>*
%160 = load <4 x float>, <4 x float>* %159
%161 = getelementptr inbounds float, float* %158, i64 4
%162 = bitcast float* %161 to <4 x float>*
%163 = load <4 x float>, <4 x float>* %162
%164 = getelementptr inbounds float, float* %8, i64 %157
%165 = bitcast float* %164 to <4 x float>*
store <4 x float> %160, <4 x float>* %165
%166 = getelementptr inbounds float, float* %164, i64 4
%167 = bitcast float* %166 to <4 x float>*
store <4 x float> %163, <4 x float>* %167
%168 = or i64 %134, 24
%169 = getelementptr inbounds float, float* %114, i64 %168
%170 = bitcast float* %169 to <4 x float>*
%171 = load <4 x float>, <4 x float>* %170
%172 = getelementptr inbounds float, float* %169, i64 4
%173 = bitcast float* %172 to <4 x float>*
%174 = load <4 x float>, <4 x float>* %173
%175 = getelementptr inbounds float, float* %8, i64 %168
%176 = bitcast float* %175 to <4 x float>*
store <4 x float> %171, <4 x float>* %176
%177 = getelementptr inbounds float, float* %175, i64 4
%178 = bitcast float* %177 to <4 x float>*
store <4 x float> %174, <4 x float>* %178
%179 = add nuw i64 %134, 32
%180 = add i64 %135, 4
%181 = icmp eq i64 %180, %132
br i1 %181, label %182, label %133
182: ; preds = %133, %124
%183 = phi i64 [ 0, %124 ], [ %179, %133 ]
%184 = icmp eq i64 %129, 0
br i1 %184, label %201, label %185
185: ; preds = %182, %185
%186 = phi i64 [ %198, %185 ], [ %183, %182 ]
%187 = phi i64 [ %199, %185 ], [ 0, %182 ]
%188 = getelementptr inbounds float, float* %114, i64 %186
%189 = bitcast float* %188 to <4 x float>*
%190 = load <4 x float>, <4 x float>* %189
%191 = getelementptr inbounds float, float* %188, i64 4
%192 = bitcast float* %191 to <4 x float>*
%193 = load <4 x float>, <4 x float>* %192
%194 = getelementptr inbounds float, float* %8, i64 %186
%195 = bitcast float* %194 to <4 x float>*
store <4 x float> %190, <4 x float>* %195
%196 = getelementptr inbounds float, float* %194, i64 4
%197 = bitcast float* %196 to <4 x float>*
store <4 x float> %193, <4 x float>* %197
%198 = add nuw i64 %186, 8
%199 = add i64 %187, 1
%200 = icmp eq i64 %199, %129
br i1 %200, label %201, label %185
201: ; preds = %185, %182
%202 = icmp eq i64 %125, %107
br i1 %202, label %240, label %203
203: ; preds = %118, %116, %201
%204 = phi i64 [ 0, %118 ], [ 0, %116 ], [ %125, %201 ]
%205 = xor i64 %204, -1
%206 = add nsw i64 %205, %107
%207 = and i64 %107, 3
%208 = icmp eq i64 %207, 0
br i1 %208, label %218, label %209
209: ; preds = %203, %209
%210 = phi i64 [ %215, %209 ], [ %204, %203 ]
%211 = phi i64 [ %216, %209 ], [ 0, %203 ]
%212 = getelementptr inbounds float, float* %114, i64 %210
%213 = load float, float* %212
%214 = getelementptr inbounds float, float* %8, i64 %210
store float %213, float* %214
%215 = add nuw nsw i64 %210, 1
%216 = add i64 %211, 1
%217 = icmp eq i64 %216, %207
br i1 %217, label %218, label %209
218: ; preds = %209, %203
%219 = phi i64 [ %204, %203 ], [ %215, %209 ]
%220 = icmp ult i64 %206, 3
br i1 %220, label %240, label %221
221: ; preds = %218, %221
%222 = phi i64 [ %238, %221 ], [ %219, %218 ]
%223 = getelementptr inbounds float, float* %114, i64 %222
%224 = load float, float* %223
%225 = getelementptr inbounds float, float* %8, i64 %222
store float %224, float* %225
%226 = add nuw nsw i64 %222, 1
%227 = getelementptr inbounds float, float* %114, i64 %226
%228 = load float, float* %227
%229 = getelementptr inbounds float, float* %8, i64 %226
store float %228, float* %229
%230 = add nuw nsw i64 %222, 2
%231 = getelementptr inbounds float, float* %114, i64 %230
%232 = load float, float* %231
%233 = getelementptr inbounds float, float* %8, i64 %230
store float %232, float* %233
%234 = add nuw nsw i64 %222, 3
%235 = getelementptr inbounds float, float* %114, i64 %234
%236 = load float, float* %235
%237 = getelementptr inbounds float, float* %8, i64 %234
store float %236, float* %237
%238 = add nuw nsw i64 %222, 4
%239 = icmp eq i64 %238, %107
br i1 %239, label %240, label %221
240: ; preds = %218, %221, %201, %104
ret void
}