#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int fread(void *, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ free(unsigned char *);
scalar_t__ malloc(int);
int /*<<< orphan*/ strncpy(char *, char *, int);
int read_geogrid(char *fname, int *len, float *rarray, int *nx, int *ny,
                 int *nz, int *isigned, int *endian, float *scalefactor,
                 int *wordsize, int *status) {
  int i, ival, cnt, narray;
  int A2, B2;
  int A3, B3, C3;
  int A4, B4, C4, D4;
  unsigned char *c;
  char local_fname[1024];
  FILE *bfile;
  *status = 0;
  narray = (*nx) * (*ny) * (*nz);
  strncpy(local_fname, fname, *len);
  local_fname[*len] = '\0';
  if (!(bfile = fopen(local_fname, "rb"))) {
    *status = 1;
    return 1;
  }
  c = (unsigned char *)malloc(sizeof(unsigned char) * (*wordsize) * narray);
  cnt = fread((void *)c, sizeof(unsigned char), narray * (*wordsize), bfile);
  fclose(bfile);
  if (cnt == 0) {
    *status = 1;
    return 1;
  }
  if (*endian == 0) {
    A2 = 0;
    B2 = 1;
    A3 = 0;
    B3 = 1;
    C3 = 2;
    A4 = 0;
    B4 = 1;
    C4 = 2;
    D4 = 3;
  } else {
    B2 = 0;
    A2 = 1;
    C3 = 0;
    B3 = 1;
    A3 = 2;
    D4 = 0;
    C4 = 1;
    B4 = 2;
    A4 = 3;
  }
  switch (*wordsize) {
  case 1:
    for (i = 0; i < narray; i++) {
      ival = (int)(c[i]);
      if ((*isigned) && (ival > (1 << 7)))
        ival -= (1 << 8);
      rarray[i] = (float)ival;
    }
    break;
  case 2:
    for (i = 0; i < narray; i++) {
      ival = (int)((c[2 * i + A2] << 8) | (c[2 * i + B2]));
      if ((*isigned) && (ival > (1 << 15)))
        ival -= (1 << 16);
      rarray[i] = (float)ival;
    }
    break;
  case 3:
    for (i = 0; i < narray; i++) {
      ival =
          (int)((c[3 * i + A3] << 16) | (c[3 * i + B3] << 8) | c[3 * i + C3]);
      if ((*isigned) * (ival > (1 << 23)))
        ival -= (1 << 24);
      rarray[i] = (float)ival;
    }
    break;
  case 4:
    for (i = 0; i < narray; i++) {
      ival = (int)((c[4 * i + A4] << 24) | (c[4 * i + B4] << 16) |
                   (c[4 * i + C4] << 8) | c[4 * i + D4]);
      if ((*isigned) && (ival > (1 << 31)))
        ival -= (1 << 32);
      rarray[i] = (float)ival;
    }
    break;
  }
  free(c);
  if (*scalefactor != 1.0) {
    for (i = 0; i < narray; i++)
      rarray[i] = rarray[i] * (*scalefactor);
  }
  return 0;
}


x86 assembly (clang, -O0):
<read_geogrid>:
push   %rbp
mov    %rsp,%rbp
sub    $0x490,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    0x30(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    -0x30(%rbp),%rcx
imul   (%rcx),%eax
mov    -0x38(%rbp),%rcx
imul   (%rcx),%eax
mov    %eax,-0x48(%rbp)
lea    -0x480(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rax
mov    (%rax),%edx
call   1040 <strncpy@plt>
mov    -0x18(%rbp),%rax
movslq (%rax),%rax
movb   $0x0,-0x480(%rbp,%rax,1)
lea    -0x480(%rbp),%rdi
lea    0xe2d(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0x488(%rbp)
cmp    $0x0,%rax
jne    1217 <read_geogrid+0xb7>
mov    0x30(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    1623 <read_geogrid+0x4c3>
mov    0x28(%rbp),%rax
movslq (%rax),%rax
shl    $0x0,%rax
movslq -0x48(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rdi
mov    -0x48(%rbp),%edx
mov    0x28(%rbp),%rax
imul   (%rax),%edx
mov    -0x488(%rbp),%rcx
mov    $0x1,%esi
call   1050 <fread@plt>
mov    %eax,-0x44(%rbp)
mov    -0x488(%rbp),%rdi
call   1060 <fclose@plt>
cmpl   $0x0,-0x44(%rbp)
jne    1283 <read_geogrid+0x123>
mov    0x30(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    1623 <read_geogrid+0x4c3>
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jne    12d4 <read_geogrid+0x174>
movl   $0x0,-0x4c(%rbp)
movl   $0x1,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x1,-0x58(%rbp)
movl   $0x2,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
movl   $0x1,-0x64(%rbp)
movl   $0x2,-0x68(%rbp)
movl   $0x3,-0x6c(%rbp)
jmp    1313 <read_geogrid+0x1b3>
movl   $0x0,-0x50(%rbp)
movl   $0x1,-0x4c(%rbp)
movl   $0x0,-0x5c(%rbp)
movl   $0x1,-0x58(%rbp)
movl   $0x2,-0x54(%rbp)
movl   $0x0,-0x6c(%rbp)
movl   $0x1,-0x68(%rbp)
movl   $0x2,-0x64(%rbp)
movl   $0x3,-0x60(%rbp)
mov    0x28(%rbp),%rax
mov    (%rax),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x490(%rbp)
sub    $0x3,%eax
ja     15a2 <read_geogrid+0x442>
mov    -0x490(%rbp),%rax
lea    0xccc(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    13ac <read_geogrid+0x24c>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x40(%rbp)
mov    0x10(%rbp),%rax
cmpl   $0x0,(%rax)
je     138c <read_geogrid+0x22c>
cmpl   $0x80,-0x40(%rbp)
jle    138c <read_geogrid+0x22c>
mov    -0x40(%rbp),%eax
sub    $0x100,%eax
mov    %eax,-0x40(%rbp)
cvtsi2ssl -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    134c <read_geogrid+0x1ec>
jmp    15a2 <read_geogrid+0x442>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1439 <read_geogrid+0x2d9>
mov    -0x78(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
mov    -0x78(%rbp),%rcx
mov    -0x3c(%rbp),%edx
shl    $0x1,%edx
add    -0x50(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    0x10(%rbp),%rax
cmpl   $0x0,(%rax)
je     1419 <read_geogrid+0x2b9>
cmpl   $0x8000,-0x40(%rbp)
jle    1419 <read_geogrid+0x2b9>
mov    -0x40(%rbp),%eax
sub    $0x10000,%eax
mov    %eax,-0x40(%rbp)
cvtsi2ssl -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13b8 <read_geogrid+0x258>
jmp    15a2 <read_geogrid+0x442>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    14e1 <read_geogrid+0x381>
mov    -0x78(%rbp),%rax
imul   $0x3,-0x3c(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x10,%eax
mov    -0x78(%rbp),%rcx
imul   $0x3,-0x3c(%rbp),%edx
add    -0x58(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x78(%rbp),%rcx
imul   $0x3,-0x3c(%rbp),%edx
add    -0x5c(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    0x10(%rbp),%rax
mov    (%rax),%eax
cmpl   $0x800000,-0x40(%rbp)
setg   %cl
and    $0x1,%cl
movzbl %cl,%ecx
imul   %ecx,%eax
cmp    $0x0,%eax
je     14c1 <read_geogrid+0x361>
mov    -0x40(%rbp),%eax
sub    $0x1000000,%eax
mov    %eax,-0x40(%rbp)
cvtsi2ssl -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1445 <read_geogrid+0x2e5>
jmp    15a2 <read_geogrid+0x442>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    159d <read_geogrid+0x43d>
mov    -0x78(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x18,%eax
mov    -0x78(%rbp),%rcx
mov    -0x3c(%rbp),%edx
shl    $0x2,%edx
add    -0x64(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x78(%rbp),%rcx
mov    -0x3c(%rbp),%edx
shl    $0x2,%edx
add    -0x68(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x78(%rbp),%rcx
mov    -0x3c(%rbp),%edx
shl    $0x2,%edx
add    -0x6c(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    0x10(%rbp),%rax
cmpl   $0x0,(%rax)
je     157d <read_geogrid+0x41d>
cmpl   $0x80000000,-0x40(%rbp)
jle    157d <read_geogrid+0x41d>
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
cvtsi2ssl -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14ed <read_geogrid+0x38d>
jmp    15a2 <read_geogrid+0x442>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa41(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    15d4 <read_geogrid+0x474>
jp     15d4 <read_geogrid+0x474>
jmp    161c <read_geogrid+0x4bc>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1617 <read_geogrid+0x4b7>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
mulss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15db <read_geogrid+0x47b>
jmp    161c <read_geogrid+0x4bc>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x490,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<read_geogrid>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x408,%rsp
mov    0x460(%rsp),%rbp
movl   $0x0,0x0(%rbp)
mov    (%r8),%r12d
imul   (%rcx),%r12d
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %rdi,%rsi
imul   (%r9),%r12d
mov    (%rbx),%edx
mov    %rsp,%r14
mov    %r14,%rdi
call   1040 <strncpy@plt>
movslq (%rbx),%rax
movb   $0x0,(%rsp,%rax,1)
lea    0xe85(%rip),%rsi
mov    %r14,%rdi
call   1080 <fopen@plt>
test   %rax,%rax
je     132c <read_geogrid+0x1cc>
mov    %rax,%rbx
mov    0x458(%rsp),%r13
mov    0x0(%r13),%edi
imul   %r12d,%edi
call   1070 <malloc@plt>
mov    %rax,%r14
mov    0x0(%r13),%edx
imul   %r12d,%edx
mov    %rax,%rdi
mov    $0x1,%esi
mov    %rbx,%rcx
call   1050 <fread@plt>
mov    %rbp,%r13
mov    %eax,%ebp
mov    %rbx,%rdi
call   1060 <fclose@plt>
test   %ebp,%ebp
mov    %r13,%rbp
je     132c <read_geogrid+0x1cc>
mov    0x448(%rsp),%rdx
xor    %ecx,%ecx
xor    %eax,%eax
cmpl   $0x0,(%rdx)
setne  %bl
sete   %dl
mov    0x458(%rsp),%rsi
mov    (%rsi),%esi
add    $0xffffffff,%esi
cmp    $0x3,%esi
ja     148c <read_geogrid+0x32c>
mov    0x440(%rsp),%rdi
mov    %bl,%cl
mov    %dl,%al
lea    0xddb(%rip),%rdx
movslq (%rdx,%rsi,4),%rsi
add    %rdx,%rsi
jmp    *%rsi
test   %r12d,%r12d
jle    148c <read_geogrid+0x32c>
mov    (%rdi),%eax
mov    %r12d,%ecx
cmp    $0x8,%r12d
jb     1282 <read_geogrid+0x122>
mov    %r14,%rdx
add    %rcx,%rdx
cmp    %r15,%rdx
jbe    1579 <read_geogrid+0x419>
lea    (%r15,%rcx,4),%rdx
cmp    %rdx,%r14
jae    1579 <read_geogrid+0x419>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
test   $0x1,%cl
je     12b9 <read_geogrid+0x159>
movzbl (%r14,%rdx,1),%edi
lea    -0x100(%rdi),%ebp
cmp    $0x81,%edi
cmovb  %edi,%ebp
test   %eax,%eax
cmove  %edi,%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
movss  %xmm0,(%r15,%rdx,4)
or     $0x1,%rdx
add    %rcx,%rsi
je     148c <read_geogrid+0x32c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r14,%rdx,1),%esi
lea    -0x100(%rsi),%edi
cmp    $0x81,%esi
cmovb  %esi,%edi
test   %eax,%eax
cmove  %esi,%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
movss  %xmm0,(%r15,%rdx,4)
movzbl 0x1(%r14,%rdx,1),%esi
lea    -0x100(%rsi),%edi
cmp    $0x81,%esi
cmovb  %esi,%edi
test   %eax,%eax
cmove  %esi,%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
movss  %xmm0,0x4(%r15,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    12d0 <read_geogrid+0x170>
jmp    148c <read_geogrid+0x32c>
movl   $0x1,0x0(%rbp)
mov    $0x1,%eax
add    $0x408,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %r12d,%r12d
jle    148c <read_geogrid+0x32c>
mov    (%rdi),%r8d
mov    %r12d,%esi
add    %rsi,%rsi
xor    %ebx,%ebx
xchg   %ax,%ax
mov    %ebx,%edi
or     %ecx,%edi
movzbl (%r14,%rdi,1),%edi
shl    $0x8,%edi
mov    %ebx,%ebp
or     %eax,%ebp
movzbl (%r14,%rbp,1),%ebp
lea    (%rdi,%rbp,1),%edx
cmp    $0x8001,%edx
lea    -0x10000(%rdi,%rbp,1),%edi
cmovb  %edx,%edi
test   %r8d,%r8d
cmove  %edx,%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
movss  %xmm0,(%r15,%rbx,2)
add    $0x2,%rbx
cmp    %rbx,%rsi
jne    1360 <read_geogrid+0x200>
jmp    148c <read_geogrid+0x32c>
test   %r12d,%r12d
jle    148c <read_geogrid+0x32c>
add    %rcx,%rcx
add    %rax,%rax
mov    (%rdi),%r8d
mov    %r12d,%esi
add    %r14,%rax
add    %r14,%rcx
lea    (%rsi,%rsi,2),%r9
xor    %edi,%edi
mov    %r15,%rbp
nopl   (%rax)
movzbl (%rcx,%rdi,1),%ebx
shl    $0x10,%ebx
movzbl 0x1(%r14,%rdi,1),%edx
shl    $0x8,%edx
or     %ebx,%edx
movzbl (%rax,%rdi,1),%ebx
lea    (%rdx,%rbx,1),%esi
test   %r8d,%r8d
lea    -0x1000000(%rbx,%rdx,1),%edx
cmove  %esi,%edx
cmp    $0x800001,%esi
cmovb  %esi,%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movss  %xmm0,0x0(%rbp)
add    $0x3,%rdi
add    $0x4,%rbp
cmp    %rdi,%r9
jne    13d0 <read_geogrid+0x270>
jmp    148c <read_geogrid+0x32c>
test   %r12d,%r12d
jle    148c <read_geogrid+0x32c>
lea    (%rcx,%rcx,2),%r8d
mov    $0x2,%r9d
sub    %eax,%r9d
mov    %eax,%esi
add    $0x1,%eax
lea    (%rsi,%rsi,2),%r10d
mov    %r12d,%edi
shl    $0x2,%rdi
xor    %esi,%esi
xchg   %ax,%ax
mov    %esi,%ebp
or     %r8d,%ebp
movzbl (%r14,%rbp,1),%ebp
shl    $0x18,%ebp
mov    %esi,%ebx
or     %r9d,%ebx
movzbl (%r14,%rbx,1),%ebx
shl    $0x10,%ebx
or     %ebp,%ebx
mov    %esi,%ecx
or     %eax,%ecx
movzbl (%r14,%rcx,1),%ecx
shl    $0x8,%ecx
or     %ebx,%ecx
mov    %esi,%edx
or     %r10d,%edx
movzbl (%r14,%rdx,1),%edx
or     %ecx,%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movss  %xmm0,(%r15,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1440 <read_geogrid+0x2e0>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x450(%rsp),%rbx
movss  (%rbx),%xmm0
xor    %eax,%eax
ucomiss 0xb77(%rip),%xmm0
jne    14b1 <read_geogrid+0x351>
jnp    1338 <read_geogrid+0x1d8>
test   %r12d,%r12d
jle    1338 <read_geogrid+0x1d8>
mulss  (%r15),%xmm0
movss  %xmm0,(%r15)
cmp    $0x1,%r12d
je     1338 <read_geogrid+0x1d8>
mov    %r12d,%ecx
lea    -0x1(%rcx),%rsi
mov    $0x1,%edx
cmp    $0x8,%rsi
jb     168e <read_geogrid+0x52e>
cmp    %rbx,%r15
jae    14f6 <read_geogrid+0x396>
lea    (%r15,%rcx,4),%rdi
cmp    %rbx,%rdi
ja     168e <read_geogrid+0x52e>
mov    %rsi,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rdi
mov    %rdi,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdi,%rdi
je     1652 <read_geogrid+0x4f2>
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbp
movss  (%rbx),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    $0x1,%edi
nopl   0x0(%rax)
movups (%r15,%rdi,4),%xmm1
movups 0x10(%r15,%rdi,4),%xmm2
movups 0x20(%r15,%rdi,4),%xmm3
movups 0x30(%r15,%rdi,4),%xmm4
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%r15,%rdi,4)
movups %xmm2,0x10(%r15,%rdi,4)
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm4
movups %xmm3,0x20(%r15,%rdi,4)
movups %xmm4,0x30(%r15,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1530 <read_geogrid+0x3d0>
jmp    1657 <read_geogrid+0x4f7>
mov    %ecx,%edx
and    $0xfffffff8,%edx
xor    %esi,%esi
movdqa 0xa78(%rip),%xmm0
pcmpeqd %xmm1,%xmm1
movdqa 0xa7c(%rip),%xmm2
jmp    15f0 <read_geogrid+0x490>
pxor   %xmm6,%xmm6
pxor   %xmm7,%xmm7
punpcklbw %xmm5,%xmm3
punpcklwd %xmm5,%xmm3
punpcklbw %xmm5,%xmm4
punpcklwd %xmm5,%xmm4
movdqa %xmm6,%xmm5
pandn  %xmm3,%xmm5
por    %xmm2,%xmm3
pand   %xmm6,%xmm3
por    %xmm5,%xmm3
movdqa %xmm7,%xmm5
pandn  %xmm4,%xmm5
por    %xmm2,%xmm4
pand   %xmm7,%xmm4
por    %xmm5,%xmm4
cvtdq2ps %xmm3,%xmm3
cvtdq2ps %xmm4,%xmm4
movups %xmm3,(%r15,%rsi,4)
movups %xmm4,0x10(%r15,%rsi,4)
add    $0x8,%rsi
cmp    %rsi,%rdx
je     1644 <read_geogrid+0x4e4>
movd   (%r14,%rsi,1),%xmm3
movd   0x4(%r14,%rsi,1),%xmm4
pxor   %xmm5,%xmm5
test   %eax,%eax
je     1596 <read_geogrid+0x436>
movdqa %xmm3,%xmm6
pminub %xmm0,%xmm6
pcmpeqb %xmm3,%xmm6
pxor   %xmm1,%xmm6
punpcklbw %xmm6,%xmm6
punpcklwd %xmm6,%xmm6
psrad  $0x18,%xmm6
movdqa %xmm4,%xmm7
pminub %xmm0,%xmm7
pcmpeqb %xmm4,%xmm7
pxor   %xmm1,%xmm7
punpcklbw %xmm7,%xmm7
punpcklwd %xmm7,%xmm7
psrad  $0x18,%xmm7
jmp    159e <read_geogrid+0x43e>
cmp    %rcx,%rdx
je     148c <read_geogrid+0x32c>
jmp    1284 <read_geogrid+0x124>
mov    $0x1,%edi
test   $0x1,%r8b
je     1681 <read_geogrid+0x521>
movss  (%rbx),%xmm0
shufps $0x0,%xmm0,%xmm0
movups (%r15,%rdi,4),%xmm1
movups 0x10(%r15,%rdi,4),%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%r15,%rdi,4)
movups %xmm2,0x10(%r15,%rdi,4)
cmp    %rdx,%rsi
je     1338 <read_geogrid+0x1d8>
or     $0x1,%rdx
mov    %ecx,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
and    $0x3,%rdi
je     16ca <read_geogrid+0x56a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%r15,%rdx,4),%xmm0
mulss  (%rbx),%xmm0
movss  %xmm0,(%r15,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    16b0 <read_geogrid+0x550>
cmp    $0x3,%rsi
jb     1338 <read_geogrid+0x1d8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r15,%rdx,4),%xmm0
mulss  (%rbx),%xmm0
movss  0x4(%r15,%rdx,4),%xmm1
movss  %xmm0,(%r15,%rdx,4)
mulss  (%rbx),%xmm1
movss  %xmm1,0x4(%r15,%rdx,4)
movss  0x8(%r15,%rdx,4),%xmm0
mulss  (%rbx),%xmm0
movss  %xmm0,0x8(%r15,%rdx,4)
movss  0xc(%r15,%rdx,4),%xmm0
mulss  (%rbx),%xmm0
movss  %xmm0,0xc(%r15,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    16e0 <read_geogrid+0x580>
jmp    1338 <read_geogrid+0x1d8>

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

LLVM IR (-O2):
@.str = [3 x i8] c"rb\00"
define i32 @read_geogrid(i8* %0, i32* nocapture %1, float* nocapture %2, i32* nocapture %3, i32* nocapture %4, i32* nocapture %5, i32* nocapture %6, i32* nocapture %7, float* nocapture %8, i32* nocapture %9, i32* nocapture writeonly %10) {
%12 = bitcast float* %2 to i8*
%13 = alloca [1024 x i8]
%14 = getelementptr inbounds [1024 x i8], [1024 x i8]* %13, i64 0, i64 0
store i32 0, i32* %10
%15 = load i32, i32* %3
%16 = load i32, i32* %4
%17 = mul nsw i32 %16, %15
%18 = load i32, i32* %5
%19 = mul i32 %17, %18
%20 = load i32, i32* %1
%21 = call i32 @strncpy(i8* %14, i8* %0, i32 %20)
%22 = load i32, i32* %1
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds [1024 x i8], [1024 x i8]* %13, i64 0, i64 %23
store i8 0, i8* %24
%25 = call i32* @fopen(i8* %14, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%26 = icmp eq i32* %25, null
br i1 %26, label %371, label %27
27: ; preds = %11
%28 = load i32, i32* %9
%29 = mul i32 %28, %19
%30 = call i64 @malloc(i32 %29)
%31 = inttoptr i64 %30 to i8*
%32 = load i32, i32* %9
%33 = mul nsw i32 %32, %19
%34 = call i32 @fread(i8* %31, i32 1, i32 %33, i32* %25)
%35 = call i32 @fclose(i32* %25)
%36 = icmp eq i32 %34, 0
br i1 %36, label %371, label %37
37: ; preds = %27
%38 = load i32, i32* %7
%39 = icmp eq i32 %38, 0
%40 = xor i1 %39, true
%41 = zext i1 %40 to i32
%42 = zext i1 %39 to i32
%43 = select i1 %39, i64 0, i64 2
%44 = select i1 %39, i64 2, i64 0
%45 = select i1 %39, i32 0, i32 3
%46 = select i1 %39, i32 1, i32 2
%47 = select i1 %39, i32 2, i32 1
%48 = select i1 %39, i32 3, i32 0
%49 = load i32, i32* %9
switch i32 %49, label %238 [
i32 1, label %66
i32 2, label %60
i32 3, label %54
i32 4, label %50
]
50: ; preds = %37
%51 = icmp sgt i32 %19, 0
br i1 %51, label %52, label %238
52: ; preds = %50
%53 = zext i32 %19 to i64
br label %204
54: ; preds = %37
%55 = icmp sgt i32 %19, 0
br i1 %55, label %56, label %238
56: ; preds = %54
%57 = load i32, i32* %6
%58 = icmp eq i32 %57, 0
%59 = zext i32 %19 to i64
br label %177
60: ; preds = %37
%61 = icmp sgt i32 %19, 0
br i1 %61, label %62, label %238
62: ; preds = %60
%63 = load i32, i32* %6
%64 = icmp ne i32 %63, 0
%65 = zext i32 %19 to i64
br label %153
66: ; preds = %37
%67 = icmp sgt i32 %19, 0
br i1 %67, label %68, label %238
68: ; preds = %66
%69 = load i32, i32* %6
%70 = icmp ne i32 %69, 0
%71 = zext i32 %19 to i64
%72 = icmp ult i32 %19, 8
br i1 %72, label %110, label %73
73: ; preds = %68
%74 = getelementptr float, float* %2, i64 %71
%75 = bitcast float* %74 to i8*
%76 = getelementptr i8, i8* %31, i64 %71
%77 = icmp ugt i8* %76, %12
%78 = icmp ult i8* %31, %75
%79 = and i1 %77, %78
br i1 %79, label %110, label %80
80: ; preds = %73
%81 = and i64 %71, 4294967288
br label %82
82: ; preds = %82, %80
%83 = phi i64 [ 0, %80 ], [ %106, %82 ]
%84 = getelementptr inbounds i8, i8* %31, i64 %83
%85 = bitcast i8* %84 to <4 x i8>*
%86 = load <4 x i8>, <4 x i8>* %85
%87 = getelementptr inbounds i8, i8* %84, i64 4
%88 = bitcast i8* %87 to <4 x i8>*
%89 = load <4 x i8>, <4 x i8>* %88
%90 = zext <4 x i8> %86 to <4 x i32>
%91 = zext <4 x i8> %89 to <4 x i32>
%92 = icmp ugt <4 x i8> %86, <i8 -128, i8 -128, i8 -128, i8 -128>
%93 = icmp ugt <4 x i8> %89, <i8 -128, i8 -128, i8 -128, i8 -128>
%94 = select i1 %70, <4 x i1> %92, <4 x i1> zeroinitializer
%95 = select i1 %70, <4 x i1> %93, <4 x i1> zeroinitializer
%96 = or <4 x i32> %90, <i32 -256, i32 -256, i32 -256, i32 -256>
%97 = or <4 x i32> %91, <i32 -256, i32 -256, i32 -256, i32 -256>
%98 = select <4 x i1> %94, <4 x i32> %96, <4 x i32> %90
%99 = select <4 x i1> %95, <4 x i32> %97, <4 x i32> %91
%100 = sitofp <4 x i32> %98 to <4 x float>
%101 = sitofp <4 x i32> %99 to <4 x float>
%102 = getelementptr inbounds float, float* %2, i64 %83
%103 = bitcast float* %102 to <4 x float>*
store <4 x float> %100, <4 x float>* %103
%104 = getelementptr inbounds float, float* %102, i64 4
%105 = bitcast float* %104 to <4 x float>*
store <4 x float> %101, <4 x float>* %105
%106 = add nuw i64 %83, 8
%107 = icmp eq i64 %106, %81
br i1 %107, label %108, label %82
108: ; preds = %82
%109 = icmp eq i64 %81, %71
br i1 %109, label %238, label %110
110: ; preds = %73, %68, %108
%111 = phi i64 [ 0, %73 ], [ 0, %68 ], [ %81, %108 ]
%112 = xor i64 %111, -1
%113 = and i64 %71, 1
%114 = icmp eq i64 %113, 0
br i1 %114, label %126, label %115
115: ; preds = %110
%116 = getelementptr inbounds i8, i8* %31, i64 %111
%117 = load i8, i8* %116
%118 = zext i8 %117 to i32
%119 = icmp ugt i8 %117, -128
%120 = select i1 %70, i1 %119, i1 false
%121 = or i32 %118, -256
%122 = select i1 %120, i32 %121, i32 %118
%123 = sitofp i32 %122 to float
%124 = getelementptr inbounds float, float* %2, i64 %111
store float %123, float* %124
%125 = or i64 %111, 1
br label %126
126: ; preds = %115, %110
%127 = phi i64 [ %111, %110 ], [ %125, %115 ]
%128 = sub nsw i64 0, %71
%129 = icmp eq i64 %112, %128
br i1 %129, label %238, label %130
130: ; preds = %126, %130
%131 = phi i64 [ %151, %130 ], [ %127, %126 ]
%132 = getelementptr inbounds i8, i8* %31, i64 %131
%133 = load i8, i8* %132
%134 = zext i8 %133 to i32
%135 = icmp ugt i8 %133, -128
%136 = select i1 %70, i1 %135, i1 false
%137 = or i32 %134, -256
%138 = select i1 %136, i32 %137, i32 %134
%139 = sitofp i32 %138 to float
%140 = getelementptr inbounds float, float* %2, i64 %131
store float %139, float* %140
%141 = add nuw nsw i64 %131, 1
%142 = getelementptr inbounds i8, i8* %31, i64 %141
%143 = load i8, i8* %142
%144 = zext i8 %143 to i32
%145 = icmp ugt i8 %143, -128
%146 = select i1 %70, i1 %145, i1 false
%147 = or i32 %144, -256
%148 = select i1 %146, i32 %147, i32 %144
%149 = sitofp i32 %148 to float
%150 = getelementptr inbounds float, float* %2, i64 %141
store float %149, float* %150
%151 = add nuw nsw i64 %131, 2
%152 = icmp eq i64 %151, %71
br i1 %152, label %238, label %130
153: ; preds = %62, %153
%154 = phi i64 [ 0, %62 ], [ %175, %153 ]
%155 = trunc i64 %154 to i32
%156 = shl i32 %155, 1
%157 = or i32 %156, %41
%158 = zext i32 %157 to i64
%159 = getelementptr inbounds i8, i8* %31, i64 %158
%160 = load i8, i8* %159
%161 = zext i8 %160 to i32
%162 = shl nuw nsw i32 %161, 8
%163 = or i32 %156, %42
%164 = zext i32 %163 to i64
%165 = getelementptr inbounds i8, i8* %31, i64 %164
%166 = load i8, i8* %165
%167 = zext i8 %166 to i32
%168 = or i32 %162, %167
%169 = icmp ugt i32 %168, 32768
%170 = select i1 %64, i1 %169, i1 false
%171 = or i32 %168, -65536
%172 = select i1 %170, i32 %171, i32 %168
%173 = sitofp i32 %172 to float
%174 = getelementptr inbounds float, float* %2, i64 %154
store float %173, float* %174
%175 = add nuw nsw i64 %154, 1
%176 = icmp eq i64 %175, %65
br i1 %176, label %238, label %153
177: ; preds = %56, %177
%178 = phi i64 [ 0, %56 ], [ %202, %177 ]
%179 = mul nuw nsw i64 %178, 3
%180 = add nuw nsw i64 %179, %43
%181 = getelementptr inbounds i8, i8* %31, i64 %180
%182 = load i8, i8* %181
%183 = zext i8 %182 to i32
%184 = shl nuw nsw i32 %183, 16
%185 = add nuw nsw i64 %179, 1
%186 = getelementptr inbounds i8, i8* %31, i64 %185
%187 = load i8, i8* %186
%188 = zext i8 %187 to i32
%189 = shl nuw nsw i32 %188, 8
%190 = or i32 %189, %184
%191 = add nuw nsw i64 %179, %44
%192 = getelementptr inbounds i8, i8* %31, i64 %191
%193 = load i8, i8* %192
%194 = zext i8 %193 to i32
%195 = or i32 %190, %194
%196 = icmp ult i32 %195, 8388609
%197 = select i1 %196, i1 true, i1 %58
%198 = or i32 %195, -16777216
%199 = select i1 %197, i32 %195, i32 %198
%200 = sitofp i32 %199 to float
%201 = getelementptr inbounds float, float* %2, i64 %178
store float %200, float* %201
%202 = add nuw nsw i64 %178, 1
%203 = icmp eq i64 %202, %59
br i1 %203, label %238, label %177
204: ; preds = %52, %204
%205 = phi i64 [ 0, %52 ], [ %236, %204 ]
%206 = trunc i64 %205 to i32
%207 = shl i32 %206, 2
%208 = or i32 %207, %45
%209 = zext i32 %208 to i64
%210 = getelementptr inbounds i8, i8* %31, i64 %209
%211 = load i8, i8* %210
%212 = zext i8 %211 to i32
%213 = shl nuw i32 %212, 24
%214 = or i32 %207, %46
%215 = zext i32 %214 to i64
%216 = getelementptr inbounds i8, i8* %31, i64 %215
%217 = load i8, i8* %216
%218 = zext i8 %217 to i32
%219 = shl nuw nsw i32 %218, 16
%220 = or i32 %219, %213
%221 = or i32 %207, %47
%222 = zext i32 %221 to i64
%223 = getelementptr inbounds i8, i8* %31, i64 %222
%224 = load i8, i8* %223
%225 = zext i8 %224 to i32
%226 = shl nuw nsw i32 %225, 8
%227 = or i32 %220, %226
%228 = or i32 %207, %48
%229 = zext i32 %228 to i64
%230 = getelementptr inbounds i8, i8* %31, i64 %229
%231 = load i8, i8* %230
%232 = zext i8 %231 to i32
%233 = or i32 %227, %232
%234 = sitofp i32 %233 to float
%235 = getelementptr inbounds float, float* %2, i64 %205
store float %234, float* %235
%236 = add nuw nsw i64 %205, 1
%237 = icmp eq i64 %236, %53
br i1 %237, label %238, label %204
238: ; preds = %204, %177, %153, %126, %130, %108, %50, %54, %60, %66, %37
%239 = call i32 @free(i8* %31)
%240 = load float, float* %8
%241 = fcmp une float %240, 1.000000e+00
%242 = icmp sgt i32 %19, 0
%243 = select i1 %241, i1 %242, i1 false
br i1 %243, label %244, label %372
244: ; preds = %238
%245 = zext i32 %19 to i64
%246 = load float, float* %2
%247 = fmul float %246, %240
store float %247, float* %2
%248 = icmp eq i32 %19, 1
br i1 %248, label %372, label %249
249: ; preds = %244
%250 = add nsw i64 %245, -1
%251 = icmp ult i64 %250, 8
br i1 %251, label %328, label %252
252: ; preds = %249
%253 = getelementptr float, float* %2, i64 %245
%254 = icmp ult float* %2, %8
%255 = icmp ugt float* %253, %8
%256 = and i1 %254, %255
br i1 %256, label %328, label %257
257: ; preds = %252
%258 = and i64 %250, -8
%259 = or i64 %258, 1
%260 = add nsw i64 %258, -8
%261 = lshr exact i64 %260, 3
%262 = add nuw nsw i64 %261, 1
%263 = and i64 %262, 1
%264 = icmp eq i64 %260, 0
br i1 %264, label %307, label %265
265: ; preds = %257
%266 = and i64 %262, 4611686018427387902
%267 = load float, float* %8
%268 = insertelement <4 x float> poison, float %267, i64 0
%269 = shufflevector <4 x float> %268, <4 x float> poison, <4 x i32> zeroinitializer
%270 = insertelement <4 x float> poison, float %267, i64 0
%271 = shufflevector <4 x float> %270, <4 x float> poison, <4 x i32> zeroinitializer
%272 = load float, float* %8
%273 = insertelement <4 x float> poison, float %272, i64 0
%274 = shufflevector <4 x float> %273, <4 x float> poison, <4 x i32> zeroinitializer
%275 = insertelement <4 x float> poison, float %272, i64 0
%276 = shufflevector <4 x float> %275, <4 x float> poison, <4 x i32> zeroinitializer
br label %277
277: ; preds = %277, %265
%278 = phi i64 [ 0, %265 ], [ %302, %277 ]
%279 = phi i64 [ 0, %265 ], [ %303, %277 ]
%280 = or i64 %278, 1
%281 = getelementptr inbounds float, float* %2, i64 %280
%282 = bitcast float* %281 to <4 x float>*
%283 = load <4 x float>, <4 x float>* %282
%284 = getelementptr inbounds float, float* %281, i64 4
%285 = bitcast float* %284 to <4 x float>*
%286 = load <4 x float>, <4 x float>* %285
%287 = fmul <4 x float> %283, %269
%288 = fmul <4 x float> %286, %271
%289 = bitcast float* %281 to <4 x float>*
store <4 x float> %287, <4 x float>* %289
%290 = bitcast float* %284 to <4 x float>*
store <4 x float> %288, <4 x float>* %290
%291 = or i64 %278, 9
%292 = getelementptr inbounds float, float* %2, i64 %291
%293 = bitcast float* %292 to <4 x float>*
%294 = load <4 x float>, <4 x float>* %293
%295 = getelementptr inbounds float, float* %292, i64 4
%296 = bitcast float* %295 to <4 x float>*
%297 = load <4 x float>, <4 x float>* %296
%298 = fmul <4 x float> %294, %274
%299 = fmul <4 x float> %297, %276
%300 = bitcast float* %292 to <4 x float>*
store <4 x float> %298, <4 x float>* %300
%301 = bitcast float* %295 to <4 x float>*
store <4 x float> %299, <4 x float>* %301
%302 = add nuw i64 %278, 16
%303 = add i64 %279, 2
%304 = icmp eq i64 %303, %266
br i1 %304, label %305, label %277
305: ; preds = %277
%306 = or i64 %302, 1
br label %307
307: ; preds = %305, %257
%308 = phi i64 [ 1, %257 ], [ %306, %305 ]
%309 = icmp eq i64 %263, 0
br i1 %309, label %326, label %310
310: ; preds = %307
%311 = load float, float* %8
%312 = insertelement <4 x float> poison, float %311, i64 0
%313 = shufflevector <4 x float> %312, <4 x float> poison, <4 x i32> zeroinitializer
%314 = insertelement <4 x float> poison, float %311, i64 0
%315 = shufflevector <4 x float> %314, <4 x float> poison, <4 x i32> zeroinitializer
%316 = getelementptr inbounds float, float* %2, i64 %308
%317 = bitcast float* %316 to <4 x float>*
%318 = load <4 x float>, <4 x float>* %317
%319 = getelementptr inbounds float, float* %316, i64 4
%320 = bitcast float* %319 to <4 x float>*
%321 = load <4 x float>, <4 x float>* %320
%322 = fmul <4 x float> %318, %313
%323 = fmul <4 x float> %321, %315
%324 = bitcast float* %316 to <4 x float>*
store <4 x float> %322, <4 x float>* %324
%325 = bitcast float* %319 to <4 x float>*
store <4 x float> %323, <4 x float>* %325
br label %326
326: ; preds = %307, %310
%327 = icmp eq i64 %250, %258
br i1 %327, label %372, label %328
328: ; preds = %252, %249, %326
%329 = phi i64 [ 1, %252 ], [ 1, %249 ], [ %259, %326 ]
%330 = sub nsw i64 %245, %329
%331 = xor i64 %329, -1
%332 = add nsw i64 %331, %245
%333 = and i64 %330, 3
%334 = icmp eq i64 %333, 0
br i1 %334, label %345, label %335
335: ; preds = %328, %335
%336 = phi i64 [ %342, %335 ], [ %329, %328 ]
%337 = phi i64 [ %343, %335 ], [ 0, %328 ]
%338 = load float, float* %8
%339 = getelementptr inbounds float, float* %2, i64 %336
%340 = load float, float* %339
%341 = fmul float %340, %338
store float %341, float* %339
%342 = add nuw nsw i64 %336, 1
%343 = add i64 %337, 1
%344 = icmp eq i64 %343, %333
br i1 %344, label %345, label %335
345: ; preds = %335, %328
%346 = phi i64 [ %329, %328 ], [ %342, %335 ]
%347 = icmp ult i64 %332, 3
br i1 %347, label %372, label %348
348: ; preds = %345, %348
%349 = phi i64 [ %369, %348 ], [ %346, %345 ]
%350 = load float, float* %8
%351 = getelementptr inbounds float, float* %2, i64 %349
%352 = load float, float* %351
%353 = fmul float %352, %350
store float %353, float* %351
%354 = add nuw nsw i64 %349, 1
%355 = load float, float* %8
%356 = getelementptr inbounds float, float* %2, i64 %354
%357 = load float, float* %356
%358 = fmul float %357, %355
store float %358, float* %356
%359 = add nuw nsw i64 %349, 2
%360 = load float, float* %8
%361 = getelementptr inbounds float, float* %2, i64 %359
%362 = load float, float* %361
%363 = fmul float %362, %360
store float %363, float* %361
%364 = add nuw nsw i64 %349, 3
%365 = load float, float* %8
%366 = getelementptr inbounds float, float* %2, i64 %364
%367 = load float, float* %366
%368 = fmul float %367, %365
store float %368, float* %366
%369 = add nuw nsw i64 %349, 4
%370 = icmp eq i64 %369, %245
br i1 %370, label %372, label %348
371: ; preds = %27, %11
store i32 1, i32* %10
br label %372
372: ; preds = %345, %348, %244, %326, %371, %238
%373 = phi i32 [ 0, %238 ], [ 1, %371 ], [ 0, %326 ], [ 0, %244 ], [ 0, %348 ], [ 0, %345 ]
ret i32 %373
}