#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 fabs(double);
double duv_dy(double **U, double **V, int i, int j, double dy, double gamma) {
  return 1.0 / dy *
             ((V[i][j] + V[i + 1][j]) / 2.0 * (U[i][j] + U[i][j + 1]) / 2.0 -
              (V[i][j - 1] + V[i + 1][j - 1]) / 2.0 * (U[i][j - 1] + U[i][j]) /
                  2.0) +
         gamma / dy *
             (fabs(V[i][j] + V[i + 1][j]) / 2.0 * (U[i][j] - U[i][j + 1]) /
                  2.0 -
              fabs(V[i][j - 1] + V[i + 1][j - 1]) / 2.0 *
                  (U[i][j - 1] - U[i][j]) / 2.0);
}


x86 assembly (clang, -O0):
<duv_dy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
movsd  0xee4(%rip),%xmm0
divsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  0xea0(%rip),%xmm1
divsd  %xmm1,%xmm2
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm2
movsd  0xe61(%rip),%xmm1
divsd  %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xe1c(%rip),%xmm3
divsd  %xmm3,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
movsd  0xddd(%rip),%xmm3
divsd  %xmm3,%xmm1
subsd  %xmm1,%xmm2
movsd  -0x28(%rbp),%xmm1
divsd  -0x20(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm3
movaps 0xda5(%rip),%xmm4
pand   %xmm4,%xmm3
movsd  0xd89(%rip),%xmm4
divsd  %xmm4,%xmm3
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm3
movsd  0xd4a(%rip),%xmm4
divsd  %xmm4,%xmm3
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm4
movaps 0xd16(%rip),%xmm5
pand   %xmm5,%xmm4
movsd  0xcfa(%rip),%xmm5
divsd  %xmm5,%xmm4
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm5
mulsd  %xmm5,%xmm4
movsd  0xcbb(%rip),%xmm5
divsd  %xmm5,%xmm4
subsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<duv_dy>:
movsd  0xef8(%rip),%xmm2
divsd  %xmm0,%xmm2
movslq %edx,%rax
movslq %ecx,%rcx
mov    (%rsi,%rax,8),%rdx
mov    0x8(%rsi,%rax,8),%rsi
mov    (%rdi,%rax,8),%rax
movupd (%rax,%rcx,8),%xmm4
movupd -0x8(%rdx,%rcx,8),%xmm3
movupd -0x8(%rsi,%rcx,8),%xmm5
addpd  %xmm3,%xmm5
movapd 0xed3(%rip),%xmm8
movapd %xmm5,%xmm6
mulpd  %xmm8,%xmm6
movsd  -0x8(%rax,%rcx,8),%xmm7
unpcklpd %xmm4,%xmm7
movapd %xmm4,%xmm3
addpd  %xmm7,%xmm3
mulpd  %xmm6,%xmm3
mulpd  %xmm8,%xmm3
movapd %xmm3,%xmm6
unpckhpd %xmm3,%xmm6
subsd  %xmm3,%xmm6
mulsd  %xmm2,%xmm6
divsd  %xmm0,%xmm1
andpd  0xea3(%rip),%xmm5
mulpd  %xmm8,%xmm5
subpd  %xmm4,%xmm7
mulpd  %xmm5,%xmm7
mulpd  %xmm8,%xmm7
movapd %xmm7,%xmm0
unpckhpd %xmm7,%xmm0
subsd  %xmm7,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm6,%xmm0
ret

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

LLVM IR (-O2):
define double @duv_dy(double** nocapture %0, double** nocapture %1, i32 %2, i32 %3, double %4, double %5) {
%7 = fdiv double 1.000000e+00, %4
%8 = sext i32 %2 to i64
%9 = getelementptr inbounds double*, double** %1, i64 %8
%10 = load double*, double** %9
%11 = sext i32 %3 to i64
%12 = add nsw i32 %2, 1
%13 = sext i32 %12 to i64
%14 = getelementptr inbounds double*, double** %1, i64 %13
%15 = load double*, double** %14
%16 = getelementptr inbounds double*, double** %0, i64 %8
%17 = load double*, double** %16
%18 = getelementptr inbounds double, double* %17, i64 %11
%19 = bitcast double* %18 to <2 x double>*
%20 = load <2 x double>, <2 x double>* %19
%21 = add nsw i32 %3, -1
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds double, double* %10, i64 %22
%24 = bitcast double* %23 to <2 x double>*
%25 = load <2 x double>, <2 x double>* %24
%26 = getelementptr inbounds double, double* %15, i64 %22
%27 = bitcast double* %26 to <2 x double>*
%28 = load <2 x double>, <2 x double>* %27
%29 = fadd <2 x double> %25, %28
%30 = fmul <2 x double> %29, <double 5.000000e-01, double 5.000000e-01>
%31 = getelementptr inbounds double, double* %17, i64 %22
%32 = load double, double* %31
%33 = insertelement <2 x double> poison, double %32, i64 0
%34 = shufflevector <2 x double> %33, <2 x double> %20, <2 x i32> <i32 0, i32 2>
%35 = fadd <2 x double> %20, %34
%36 = fmul <2 x double> %30, %35
%37 = fmul <2 x double> %36, <double 5.000000e-01, double 5.000000e-01>
%38 = shufflevector <2 x double> %37, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%39 = fsub <2 x double> %38, %37
%40 = extractelement <2 x double> %39, i64 0
%41 = fdiv double %5, %4
%42 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %29)
%43 = fmul <2 x double> %42, <double 5.000000e-01, double 5.000000e-01>
%44 = fsub <2 x double> %34, %20
%45 = fmul <2 x double> %43, %44
%46 = fmul <2 x double> %45, <double 5.000000e-01, double 5.000000e-01>
%47 = shufflevector <2 x double> %46, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%48 = fsub <2 x double> %47, %46
%49 = extractelement <2 x double> %48, i64 0
%50 = fmul double %41, %49
%51 = tail call double @llvm.fmuladd.f64(double %7, double %40, double %50)
ret double %51
}