#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 cos(double);
double euclidian_norm(double, double);
double gridcell_wdir(int, int, int const, int const, double, double, double,
                     double);
double gridcell_wspd(double, double, double, double);
double sin(double);
double *speed_correction(double, double, double, double);
double xdistance_from_center(int, double const, int const);
double ydistance_from_center(int, double const, int const);
int compute_wind(double **wdir, double **wspd, double **windx, double **windy,
                 int shape[2], double spacing[2], int center[2], double sspd,
                 double sdir, double pcent, double pedge, double rmaxw,
                 double srad) {
  int i, j;
  const int nx = shape[0];
  const int ny = shape[1];
  const double dx = spacing[0];
  const double dy = spacing[1];
  const int xc = center[0];
  const int yc = center[1];
  double dxc, dyc, wdir_ij, wspd_ij;
  double r = 0.0;
  double *sspd_corr;
  for (i = 0; i < nx; i++) {
    for (j = 0; j < ny; j++) {
      if (i == xc && j == yc) {
        wspd_ij = sspd;
        wdir_ij = sdir;
      } else {
        dxc = xdistance_from_center(i, dx, xc);
        dyc = ydistance_from_center(j, dy, yc);
        r = euclidian_norm(dxc, dyc);
        wdir_ij = gridcell_wdir(i, j, xc, yc, dxc, dyc, r, rmaxw);
        wspd_ij = gridcell_wspd(r, pcent, pedge, rmaxw);
      }
      sspd_corr = speed_correction(sspd, sdir, r, rmaxw);
      windx[i][j] = (wspd_ij * cos(wdir_ij)) + sspd_corr[0];
      windy[i][j] = (wspd_ij * sin(wdir_ij)) + sspd_corr[1];
      wdir[i][j] = (wdir_ij * 180.0 / 3.14159265358979323846264338327) - 0.0;
      wspd[i][j] = euclidian_norm(windx[i][j], windy[i][j]);
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<compute_wind>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movsd  %xmm2,-0x48(%rbp)
movsd  %xmm3,-0x50(%rbp)
movsd  %xmm4,-0x58(%rbp)
movsd  %xmm5,-0x60(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x28(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x70(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x30(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x84(%rbp)
mov    0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x88(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    148e <compute_wind+0x30e>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    147b <compute_wind+0x2fb>
mov    -0x64(%rbp),%eax
cmp    -0x84(%rbp),%eax
jne    127a <compute_wind+0xfa>
mov    -0x68(%rbp),%eax
cmp    -0x88(%rbp),%eax
jne    127a <compute_wind+0xfa>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    132d <compute_wind+0x1ad>
mov    -0x64(%rbp),%edi
movsd  -0x78(%rbp),%xmm0
mov    -0x84(%rbp),%esi
call   1040 <xdistance_from_center@plt>
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x68(%rbp),%edi
movsd  -0x80(%rbp),%xmm0
mov    -0x88(%rbp),%esi
call   1090 <ydistance_from_center@plt>
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm1
ff
call   1030 <euclidian_norm@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x64(%rbp),%edi
mov    -0x68(%rbp),%esi
mov    -0x84(%rbp),%edx
mov    -0x88(%rbp),%ecx
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm3
call   1080 <gridcell_wdir@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm3
call   1050 <gridcell_wspd@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm3
call   10a0 <speed_correction@plt>
mov    %rax,-0xb8(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1070 <cos@plt>
movaps %xmm0,%xmm2
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1060 <sin@plt>
movaps %xmm0,%xmm2
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xc0f(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
movsd  0xbf7(%rip),%xmm1
divsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
call   1030 <euclidian_norm@plt>
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1231 <compute_wind+0xb1>
jmp    1480 <compute_wind+0x300>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    121e <compute_wind+0x9e>
xor    %eax,%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_wind>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
movsd  %xmm4,0x18(%rsp)
movsd  %xmm3,0x58(%rsp)
movsd  %xmm2,0x50(%rsp)
movsd  %xmm1,0x30(%rsp)
movsd  %xmm0,0x28(%rsp)
mov    %rcx,0x70(%rsp)
mov    %rsi,0x68(%rsp)
mov    %rdi,0x60(%rsp)
mov    (%r8),%eax
mov    %rax,0x38(%rsp)
test   %eax,%eax
jle    13a0 <compute_wind+0x220>
mov    %rdx,%r13
mov    0xb0(%rsp),%rax
mov    0x4(%r8),%ecx
mov    %rcx,0x20(%rsp)
movsd  (%r9),%xmm0
movsd  %xmm0,0x48(%rsp)
movsd  0x8(%r9),%xmm0
movsd  %xmm0,0x40(%rsp)
mov    (%rax),%ebx
mov    0x4(%rax),%ebp
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
xor    %r14d,%r14d
jmp    121f <compute_wind+0x9f>
nopl   0x0(%rax)
add    $0x1,%r14
cmp    0x38(%rsp),%r14
je     13a0 <compute_wind+0x220>
cmpl   $0x0,0x20(%rsp)
jle    1210 <compute_wind+0x90>
xor    %r15d,%r15d
jmp    1378 <compute_wind+0x1f8>
xchg   %ax,%ax
mov    %r14d,%edi
movsd  0x48(%rsp),%xmm0
mov    %ebx,%esi
call   1040 <xdistance_from_center@plt>
movsd  %xmm0,(%rsp)
mov    %r15d,%edi
movsd  0x40(%rsp),%xmm0
mov    %ebp,%esi
call   1090 <ydistance_from_center@plt>
movaps %xmm0,%xmm1
movsd  %xmm0,0x8(%rsp)
movsd  (%rsp),%xmm0
call   1030 <euclidian_norm@plt>
movaps %xmm0,%xmm2
movsd  %xmm0,0x10(%rsp)
mov    %r14d,%edi
mov    %r15d,%esi
mov    %ebx,%edx
mov    %ebp,%ecx
movsd  (%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
movsd  0x18(%rsp),%xmm3
call   1080 <gridcell_wdir@plt>
movsd  %xmm0,(%rsp)
movsd  0x10(%rsp),%xmm0
movsd  0x50(%rsp),%xmm1
movsd  0x58(%rsp),%xmm2
movsd  0x18(%rsp),%xmm3
call   1050 <gridcell_wspd@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x28(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
movsd  0x10(%rsp),%xmm2
movsd  0x18(%rsp),%xmm3
call   10a0 <speed_correction@plt>
mov    %rax,%r12
movsd  (%rsp),%xmm0
call   1070 <cos@plt>
mulsd  0x8(%rsp),%xmm0
addsd  (%r12),%xmm0
mov    0x0(%r13,%r14,8),%rax
movsd  %xmm0,(%rax,%r15,8)
movsd  (%rsp),%xmm0
call   1060 <sin@plt>
mulsd  0x8(%rsp),%xmm0
addsd  0x8(%r12),%xmm0
mov    0x70(%rsp),%rax
mov    (%rax,%r14,8),%rax
movsd  %xmm0,(%rax,%r15,8)
movsd  (%rsp),%xmm0
mulsd  0xcd3(%rip),%xmm0
divsd  0xcd3(%rip),%xmm0
mov    0x60(%rsp),%rcx
mov    (%rcx,%r14,8),%rcx
movsd  %xmm0,(%rcx,%r15,8)
mov    0x0(%r13,%r14,8),%rcx
movsd  (%rcx,%r15,8),%xmm0
movsd  (%rax,%r15,8),%xmm1
call   1030 <euclidian_norm@plt>
mov    0x68(%rsp),%rax
mov    (%rax,%r14,8),%rax
movsd  %xmm0,(%rax,%r15,8)
add    $0x1,%r15
cmp    %r15,0x20(%rsp)
je     1210 <compute_wind+0x90>
cmp    %rbx,%r14
jne    1230 <compute_wind+0xb0>
movsd  0x30(%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x28(%rsp),%xmm0
cmp    %r15,%rbp
je     12b3 <compute_wind+0x133>
jmp    1230 <compute_wind+0xb0>
xor    %eax,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @compute_wind(double** nocapture %0, double** nocapture %1, double** nocapture %2, double** nocapture %3, i32* nocapture %4, double* nocapture %5, i32* nocapture %6, double %7, double %8, double %9, double %10, double %11, double %12) {
%14 = load i32, i32* %4
%15 = getelementptr inbounds i32, i32* %4, i64 1
%16 = load i32, i32* %15
%17 = load double, double* %5
%18 = getelementptr inbounds double, double* %5, i64 1
%19 = load double, double* %18
%20 = load i32, i32* %6
%21 = getelementptr inbounds i32, i32* %6, i64 1
%22 = load i32, i32* %21
%23 = icmp sgt i32 %14, 0
br i1 %23, label %24, label %85
24: ; preds = %13
%25 = icmp sgt i32 %16, 0
%26 = zext i32 %22 to i64
%27 = zext i32 %20 to i64
%28 = zext i32 %14 to i64
%29 = zext i32 %16 to i64
br label %30
30: ; preds = %24, %81
%31 = phi i64 [ 0, %24 ], [ %83, %81 ]
%32 = phi double [ 0.000000e+00, %24 ], [ %82, %81 ]
br i1 %25, label %33, label %81
33: ; preds = %30
%34 = icmp eq i64 %31, %27
%35 = getelementptr inbounds double*, double** %2, i64 %31
%36 = getelementptr inbounds double*, double** %3, i64 %31
%37 = getelementptr inbounds double*, double** %0, i64 %31
%38 = getelementptr inbounds double*, double** %1, i64 %31
%39 = trunc i64 %31 to i32
br label %40
40: ; preds = %33, %52
%41 = phi i64 [ 0, %33 ], [ %79, %52 ]
%42 = phi double [ %32, %33 ], [ %55, %52 ]
%43 = icmp eq i64 %41, %26
%44 = select i1 %34, i1 %43, i1 false
br i1 %44, label %52, label %45
45: ; preds = %40
%46 = tail call double @xdistance_from_center(i32 %39, double %17, i32 %20)
%47 = trunc i64 %41 to i32
%48 = tail call double @ydistance_from_center(i32 %47, double %19, i32 %22)
%49 = tail call double @euclidian_norm(double %46, double %48)
%50 = tail call double @gridcell_wdir(i32 %39, i32 %47, i32 %20, i32 %22, double %46, double %48, double %49, double %11)
%51 = tail call double @gridcell_wspd(double %49, double %9, double %10, double %11)
br label %52
52: ; preds = %40, %45
%53 = phi double [ %50, %45 ], [ %8, %40 ]
%54 = phi double [ %51, %45 ], [ %7, %40 ]
%55 = phi double [ %49, %45 ], [ %42, %40 ]
%56 = tail call double* @speed_correction(double %7, double %8, double %55, double %11)
%57 = tail call double @cos(double %53)
%58 = load double, double* %56
%59 = tail call double @llvm.fmuladd.f64(double %54, double %57, double %58)
%60 = load double*, double** %35
%61 = getelementptr inbounds double, double* %60, i64 %41
store double %59, double* %61
%62 = tail call double @sin(double %53)
%63 = getelementptr inbounds double, double* %56, i64 1
%64 = load double, double* %63
%65 = tail call double @llvm.fmuladd.f64(double %54, double %62, double %64)
%66 = load double*, double** %36
%67 = getelementptr inbounds double, double* %66, i64 %41
store double %65, double* %67
%68 = fmul double %53, 1.800000e+02
%69 = fdiv double %68, 0x400921FB54442D18
%70 = load double*, double** %37
%71 = getelementptr inbounds double, double* %70, i64 %41
store double %69, double* %71
%72 = load double*, double** %35
%73 = getelementptr inbounds double, double* %72, i64 %41
%74 = load double, double* %73
%75 = load double, double* %67
%76 = tail call double @euclidian_norm(double %74, double %75)
%77 = load double*, double** %38
%78 = getelementptr inbounds double, double* %77, i64 %41
store double %76, double* %78
%79 = add nuw nsw i64 %41, 1
%80 = icmp eq i64 %79, %29
br i1 %80, label %81, label %40
81: ; preds = %52, %30
%82 = phi double [ %32, %30 ], [ %55, %52 ]
%83 = add nuw nsw i64 %31, 1
%84 = icmp eq i64 %83, %28
br i1 %84, label %85, label %30
85: ; preds = %81, %13
ret i32 0
}