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


x86 assembly (clang, -O0):
<duv_dx>:
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    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
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),%xmm2
movsd  0xea0(%rip),%xmm1
divsd  %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%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
movslq -0x18(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm2
movsd  0xe61(%rip),%xmm1
divsd  %xmm1,%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xe1c(%rip),%xmm3
divsd  %xmm3,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%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    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
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),%xmm3
movaps 0xda5(%rip),%xmm4
pand   %xmm4,%xmm3
movsd  0xd89(%rip),%xmm4
divsd  %xmm4,%xmm3
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%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
movslq -0x18(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm3
movsd  0xd4a(%rip),%xmm4
divsd  %xmm4,%xmm3
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
add    $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    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x10(%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_dx>:
movsd  0xef7(%rip),%xmm9
divsd  %xmm0,%xmm9
movslq %edx,%rax
mov    -0x8(%rdi,%rax,8),%rdx
mov    (%rdi,%rax,8),%rdi
movslq %ecx,%rcx
mov    -0x8(%rsi,%rax,8),%r8
mov    (%rsi,%rax,8),%r9
movsd  (%rdi,%rcx,8),%xmm2
movsd  0x8(%rdi,%rcx,8),%xmm3
movhpd (%rdx,%rcx,8),%xmm2
movhpd 0x8(%rdx,%rcx,8),%xmm3
mov    0x8(%rsi,%rax,8),%rax
addpd  %xmm2,%xmm3
movapd 0xec2(%rip),%xmm8
movapd %xmm3,%xmm7
mulpd  %xmm8,%xmm7
movsd  (%r9,%rcx,8),%xmm2
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
movsd  (%rax,%rcx,8),%xmm4
movsd  (%r8,%rcx,8),%xmm10
movapd %xmm4,%xmm6
unpcklpd %xmm10,%xmm6
addpd  %xmm5,%xmm6
mulpd  %xmm7,%xmm6
mulpd  %xmm8,%xmm6
movapd %xmm6,%xmm5
unpckhpd %xmm6,%xmm5
subsd  %xmm5,%xmm6
mulsd  %xmm9,%xmm6
divsd  %xmm0,%xmm1
andpd  0xe7d(%rip),%xmm3
mulpd  %xmm8,%xmm3
unpcklpd %xmm2,%xmm4
unpcklpd %xmm10,%xmm2
subpd  %xmm4,%xmm2
mulpd  %xmm3,%xmm2
mulpd  %xmm8,%xmm2
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
subsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm6,%xmm2
movapd %xmm2,%xmm0
ret

LLVM IR (-O0):
define double @duv_dx(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*** %7
%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*** %7
%25 = load i32, i32* %9
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds double*, double** %24, i64 %26
%28 = load double*, double** %27
%29 = load i32, i32* %10
%30 = add nsw i32 %29, 1
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %28, i64 %31
%33 = load double, double* %32
%34 = fadd double %23, %33
%35 = fdiv double %34, 2.000000e+00
%36 = load double**, double*** %8
%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*** %8
%46 = load i32, i32* %9
%47 = add nsw i32 %46, 1
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds double*, double** %45, i64 %48
%50 = load double*, double** %49
%51 = load i32, i32* %10
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds double, double* %50, 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*** %7
%59 = load i32, i32* %9
%60 = sub nsw i32 %59, 1
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double*, double** %58, i64 %61
%63 = load double*, double** %62
%64 = load i32, i32* %10
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds double, double* %63, i64 %65
%67 = load double, double* %66
%68 = load double**, double*** %7
%69 = load i32, i32* %9
%70 = sub 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 = add 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*** %8
%82 = load i32, i32* %9
%83 = sub nsw i32 %82, 1
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds double*, double** %81, i64 %84
%86 = load double*, double** %85
%87 = load i32, i32* %10
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double, double* %86, i64 %88
%90 = load double, double* %89
%91 = load double**, double*** %8
%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*** %7
%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*** %7
%117 = load i32, i32* %9
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds double*, double** %116, i64 %118
%120 = load double*, double** %119
%121 = load i32, i32* %10
%122 = add nsw i32 %121, 1
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %120, 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*** %8
%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*** %8
%139 = load i32, i32* %9
%140 = add nsw i32 %139, 1
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds double*, double** %138, i64 %141
%143 = load double*, double** %142
%144 = load i32, i32* %10
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds double, double* %143, 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*** %7
%152 = load i32, i32* %9
%153 = sub nsw i32 %152, 1
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds double*, double** %151, i64 %154
%156 = load double*, double** %155
%157 = load i32, i32* %10
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double, double* %156, i64 %158
%160 = load double, double* %159
%161 = load double**, double*** %7
%162 = load i32, i32* %9
%163 = sub 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 = add 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*** %8
%176 = load i32, i32* %9
%177 = sub nsw i32 %176, 1
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds double*, double** %175, i64 %178
%180 = load double*, double** %179
%181 = load i32, i32* %10
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds double, double* %180, i64 %182
%184 = load double, double* %183
%185 = load double**, double*** %8
%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_dx(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** %0, i64 %8
%10 = load double*, double** %9
%11 = sext i32 %3 to i64
%12 = getelementptr inbounds double, double* %10, i64 %11
%13 = load double, double* %12
%14 = add nsw i32 %3, 1
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds double, double* %10, i64 %15
%17 = load double, double* %16
%18 = getelementptr inbounds double*, double** %1, i64 %8
%19 = load double*, double** %18
%20 = getelementptr inbounds double, double* %19, i64 %11
%21 = load double, double* %20
%22 = add nsw i32 %2, 1
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds double*, double** %1, i64 %23
%25 = load double*, double** %24
%26 = getelementptr inbounds double, double* %25, i64 %11
%27 = load double, double* %26
%28 = add nsw i32 %2, -1
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds double*, double** %0, i64 %29
%31 = load double*, double** %30
%32 = getelementptr inbounds double, double* %31, i64 %11
%33 = load double, double* %32
%34 = getelementptr inbounds double, double* %31, i64 %15
%35 = load double, double* %34
%36 = insertelement <2 x double> poison, double %13, i64 0
%37 = insertelement <2 x double> %36, double %33, i64 1
%38 = insertelement <2 x double> poison, double %17, i64 0
%39 = insertelement <2 x double> %38, double %35, i64 1
%40 = fadd <2 x double> %37, %39
%41 = fmul <2 x double> %40, <double 5.000000e-01, double 5.000000e-01>
%42 = getelementptr inbounds double*, double** %1, i64 %29
%43 = load double*, double** %42
%44 = getelementptr inbounds double, double* %43, i64 %11
%45 = load double, double* %44
%46 = insertelement <2 x double> poison, double %21, i64 0
%47 = shufflevector <2 x double> %46, <2 x double> poison, <2 x i32> zeroinitializer
%48 = insertelement <2 x double> poison, double %27, i64 0
%49 = insertelement <2 x double> %48, double %45, i64 1
%50 = fadd <2 x double> %47, %49
%51 = fmul <2 x double> %41, %50
%52 = fmul <2 x double> %51, <double 5.000000e-01, double 5.000000e-01>
%53 = shufflevector <2 x double> %52, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%54 = fsub <2 x double> %52, %53
%55 = extractelement <2 x double> %54, i64 0
%56 = fdiv double %5, %4
%57 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %40)
%58 = fmul <2 x double> %57, <double 5.000000e-01, double 5.000000e-01>
%59 = insertelement <2 x double> %46, double %45, i64 1
%60 = insertelement <2 x double> %48, double %21, i64 1
%61 = fsub <2 x double> %59, %60
%62 = fmul <2 x double> %58, %61
%63 = fmul <2 x double> %62, <double 5.000000e-01, double 5.000000e-01>
%64 = shufflevector <2 x double> %63, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%65 = fsub <2 x double> %63, %64
%66 = extractelement <2 x double> %65, i64 0
%67 = fmul double %56, %66
%68 = tail call double @llvm.fmuladd.f64(double %7, double %55, double %67)
ret double %68
}