#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 */
double gridInqAngle(int);
double gridInqXpole(int);
double gridInqYpole(int);
double lamrot_to_lam(double, double, double, double, double);
double phirot_to_phi(double, double, double, double);
void gridGenRotBounds(int gridID, int nx, int ny, double *xbounds,
                      double *ybounds, double *xbounds2D, double *ybounds2D) {
  long i, j, index;
  double minlon, maxlon;
  double minlat, maxlat;
  double xpole, ypole, angle;
  xpole = gridInqXpole(gridID);
  ypole = gridInqYpole(gridID);
  angle = gridInqAngle(gridID);
  for (j = 0; j < ny; j++) {
    if (ybounds[0] > ybounds[1]) {
      maxlat = ybounds[2 * j];
      minlat = ybounds[2 * j + 1];
    } else {
      maxlat = ybounds[2 * j + 1];
      minlat = ybounds[2 * j];
    }
    for (i = 0; i < nx; i++) {
      minlon = xbounds[2 * i];
      maxlon = xbounds[2 * i + 1];
      index = j * 4 * nx + 4 * i;
      xbounds2D[index + 0] = lamrot_to_lam(minlat, minlon, ypole, xpole, angle);
      xbounds2D[index + 1] = lamrot_to_lam(minlat, maxlon, ypole, xpole, angle);
      xbounds2D[index + 2] = lamrot_to_lam(maxlat, maxlon, ypole, xpole, angle);
      xbounds2D[index + 3] = lamrot_to_lam(maxlat, minlon, ypole, xpole, angle);
      ybounds2D[index + 0] = phirot_to_phi(minlat, minlon, ypole, angle);
      ybounds2D[index + 1] = phirot_to_phi(minlat, maxlon, ypole, angle);
      ybounds2D[index + 2] = phirot_to_phi(maxlat, maxlon, ypole, angle);
      ybounds2D[index + 3] = phirot_to_phi(maxlat, minlon, ypole, angle);
    }
  }
}


x86 assembly (clang, -O0):
<gridGenRotBounds>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x4(%rbp),%edi
call   1040 <gridInqXpole@plt>
movsd  %xmm0,-0x68(%rbp)
mov    -0x4(%rbp),%edi
call   1070 <gridInqYpole@plt>
movsd  %xmm0,-0x70(%rbp)
mov    -0x4(%rbp),%edi
call   1060 <gridInqAngle@plt>
movsd  %xmm0,-0x78(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    1400 <gridGenRotBounds+0x2b0>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
ucomisd 0x8(%rax),%xmm0
jbe    11fd <gridGenRotBounds+0xad>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    122a <gridGenRotBounds+0xda>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    13ea <gridGenRotBounds+0x29a>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%rax
shl    $0x2,%rax
movslq -0x8(%rbp),%rcx
imul   %rcx,%rax
mov    -0x30(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm4
call   1050 <lamrot_to_lam@plt>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm4
call   1050 <lamrot_to_lam@plt>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm4
call   1050 <lamrot_to_lam@plt>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm4
call   1050 <lamrot_to_lam@plt>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,0x18(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm3
call   1030 <phirot_to_phi@plt>
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm3
call   1030 <phirot_to_phi@plt>
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm3
call   1030 <phirot_to_phi@plt>
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm3
call   1030 <phirot_to_phi@plt>
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,0x18(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1232 <gridGenRotBounds+0xe2>
jmp    13ef <gridGenRotBounds+0x29f>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    11a3 <gridGenRotBounds+0x53>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gridGenRotBounds>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9,%rbx
mov    %r8,0x48(%rsp)
mov    %rcx,%r15
mov    %edx,%r14d
mov    %esi,0x1c(%rsp)
mov    %edi,%r13d
call   1040 <gridInqXpole@plt>
movsd  %xmm0,0x20(%rsp)
mov    %r13d,%edi
call   1070 <gridInqYpole@plt>
movsd  %xmm0,0x8(%rsp)
mov    %r13d,%edi
call   1060 <gridInqAngle@plt>
test   %r14d,%r14d
jle    13ad <gridGenRotBounds+0x25d>
movapd %xmm0,%xmm1
mov    0xa0(%rsp),%rbp
movslq %r14d,%rax
mov    %rax,0x60(%rsp)
movslq 0x1c(%rsp),%rax
mov    %rax,0x50(%rsp)
shl    $0x5,%rax
mov    %rax,0x58(%rsp)
xor    %r13d,%r13d
movsd  %xmm0,0x10(%rsp)
jmp    11ea <gridGenRotBounds+0x9a>
nop
add    $0x1,%r13
mov    0x58(%rsp),%rax
add    %rax,%rbx
add    %rax,%rbp
cmp    0x60(%rsp),%r13
je     13ad <gridGenRotBounds+0x25d>
mov    0x48(%rsp),%rax
movsd  (%rax),%xmm0
mov    %r13,%rdx
add    %r13,%rdx
ucomisd 0x8(%rax),%xmm0
lea    0x1(%r13,%r13,1),%rcx
mov    %rcx,%rax
cmova  %rdx,%rax
cmovbe %rdx,%rcx
cmpl   $0x0,0x1c(%rsp)
movsd  0x8(%rsp),%xmm2
jle    11d0 <gridGenRotBounds+0x80>
mov    0x48(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    $0x8,%r12d
mov    0x50(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r15,%r12,1),%xmm1
movsd  %xmm1,0x40(%rsp)
movsd  (%r15,%r12,1),%xmm0
movsd  %xmm0,0x38(%rsp)
movsd  0x30(%rsp),%xmm0
movsd  0x20(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
call   1050 <lamrot_to_lam@plt>
movsd  %xmm0,-0x10(%rbx,%r12,2)
movsd  0x30(%rsp),%xmm0
movsd  0x38(%rsp),%xmm1
movsd  0x8(%rsp),%xmm2
movsd  0x20(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
call   1050 <lamrot_to_lam@plt>
movsd  %xmm0,-0x8(%rbx,%r12,2)
movsd  0x28(%rsp),%xmm0
movsd  0x38(%rsp),%xmm1
movsd  0x8(%rsp),%xmm2
movsd  0x20(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
call   1050 <lamrot_to_lam@plt>
movsd  %xmm0,(%rbx,%r12,2)
movsd  0x28(%rsp),%xmm0
movsd  0x40(%rsp),%xmm1
movsd  0x8(%rsp),%xmm2
movsd  0x20(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
call   1050 <lamrot_to_lam@plt>
movsd  %xmm0,0x8(%rbx,%r12,2)
movsd  0x30(%rsp),%xmm0
movsd  0x40(%rsp),%xmm1
movsd  0x8(%rsp),%xmm2
movsd  0x10(%rsp),%xmm3
call   1030 <phirot_to_phi@plt>
movsd  %xmm0,-0x10(%rbp,%r12,2)
movsd  0x30(%rsp),%xmm0
movsd  0x38(%rsp),%xmm1
movsd  0x8(%rsp),%xmm2
movsd  0x10(%rsp),%xmm3
call   1030 <phirot_to_phi@plt>
movsd  %xmm0,-0x8(%rbp,%r12,2)
movsd  0x28(%rsp),%xmm0
movsd  0x38(%rsp),%xmm1
movsd  0x8(%rsp),%xmm2
movsd  0x10(%rsp),%xmm3
call   1030 <phirot_to_phi@plt>
movsd  %xmm0,0x0(%rbp,%r12,2)
movsd  0x28(%rsp),%xmm0
movsd  0x40(%rsp),%xmm1
movsd  0x8(%rsp),%xmm2
movsd  0x10(%rsp),%xmm3
call   1030 <phirot_to_phi@plt>
movsd  0x8(%rsp),%xmm2
movsd  %xmm0,0x8(%rbp,%r12,2)
add    $0x10,%r12
add    $0xffffffffffffffff,%r14
jne    1250 <gridGenRotBounds+0x100>
jmp    11d0 <gridGenRotBounds+0x80>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @gridGenRotBounds(i32 %0, i32 %1, i32 %2, double* nocapture %3, double* nocapture %4, double* nocapture writeonly %5, double* nocapture writeonly %6) {
%8 = tail call double @gridInqXpole(i32 %0)
%9 = tail call double @gridInqYpole(i32 %0)
%10 = tail call double @gridInqAngle(i32 %0)
%11 = sext i32 %2 to i64
%12 = icmp sgt i32 %2, 0
br i1 %12, label %13, label %67
13: ; preds = %7
%14 = getelementptr inbounds double, double* %4, i64 1
%15 = sext i32 %1 to i64
%16 = icmp sgt i32 %1, 0
%17 = shl nsw i64 %15, 2
br label %18
18: ; preds = %13, %64
%19 = phi i64 [ 0, %13 ], [ %65, %64 ]
%20 = load double, double* %4
%21 = load double, double* %14
%22 = fcmp ogt double %20, %21
%23 = shl nuw nsw i64 %19, 1
%24 = or i64 %23, 1
%25 = select i1 %22, i64 %23, i64 %24
%26 = select i1 %22, i64 %24, i64 %23
%27 = getelementptr inbounds double, double* %4, i64 %26
%28 = load double, double* %27
%29 = getelementptr inbounds double, double* %4, i64 %25
%30 = load double, double* %29
br i1 %16, label %31, label %64
31: ; preds = %18
%32 = mul i64 %17, %19
br label %33
33: ; preds = %31, %33
%34 = phi i64 [ 0, %31 ], [ %62, %33 ]
%35 = shl nuw nsw i64 %34, 1
%36 = getelementptr inbounds double, double* %3, i64 %35
%37 = load double, double* %36
%38 = or i64 %35, 1
%39 = getelementptr inbounds double, double* %3, i64 %38
%40 = load double, double* %39
%41 = shl nsw i64 %34, 2
%42 = add nsw i64 %41, %32
%43 = tail call double @lamrot_to_lam(double %28, double %37, double %9, double %8, double %10)
%44 = getelementptr inbounds double, double* %5, i64 %42
store double %43, double* %44
%45 = tail call double @lamrot_to_lam(double %28, double %40, double %9, double %8, double %10)
%46 = or i64 %42, 1
%47 = getelementptr inbounds double, double* %5, i64 %46
store double %45, double* %47
%48 = tail call double @lamrot_to_lam(double %30, double %40, double %9, double %8, double %10)
%49 = or i64 %42, 2
%50 = getelementptr inbounds double, double* %5, i64 %49
store double %48, double* %50
%51 = tail call double @lamrot_to_lam(double %30, double %37, double %9, double %8, double %10)
%52 = or i64 %42, 3
%53 = getelementptr inbounds double, double* %5, i64 %52
store double %51, double* %53
%54 = tail call double @phirot_to_phi(double %28, double %37, double %9, double %10)
%55 = getelementptr inbounds double, double* %6, i64 %42
store double %54, double* %55
%56 = tail call double @phirot_to_phi(double %28, double %40, double %9, double %10)
%57 = getelementptr inbounds double, double* %6, i64 %46
store double %56, double* %57
%58 = tail call double @phirot_to_phi(double %30, double %40, double %9, double %10)
%59 = getelementptr inbounds double, double* %6, i64 %49
store double %58, double* %59
%60 = tail call double @phirot_to_phi(double %30, double %37, double %9, double %10)
%61 = getelementptr inbounds double, double* %6, i64 %52
store double %60, double* %61
%62 = add nuw nsw i64 %34, 1
%63 = icmp eq i64 %62, %15
br i1 %63, label %64, label %33
64: ; preds = %33, %18
%65 = add nuw nsw i64 %19, 1
%66 = icmp eq i64 %65, %11
br i1 %66, label %67, label %18
67: ; preds = %64, %7
ret void
}