#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 fmax(double, double);
void calculateNumericalDiffusionResGradJuanes(
    int nElements_global, int nQuadraturePoints_element, int nSpace,
    double shockCapturingDiffusion, double uSC, double *elementDiameter,
    double *strong_residual, double *grad_u, double *numDiff) {
  int eN, k;
  double h, n_R_eN, num, den, maxNumDiff;
  for (eN = 0; eN < nElements_global; eN++) {
    h = elementDiameter[eN];
    n_R_eN = 0.0;
    for (k = 0; k < nQuadraturePoints_element; k++) {
      num = shockCapturingDiffusion * 0.5 * h *
            fabs(strong_residual[eN * nQuadraturePoints_element + k]);
      den = fabs(uSC) / h;
      if (den > num * 1.0e-8)
        numDiff[eN * nQuadraturePoints_element + k] = num / den;
      else
        numDiff[eN * nQuadraturePoints_element + k] = 0.0;
      n_R_eN = fmax(n_R_eN,
                    fabs(strong_residual[eN * nQuadraturePoints_element + k]));
    }
    maxNumDiff = 0.0;
    for (k = 0; k < nQuadraturePoints_element; k++) {
      num = shockCapturingDiffusion * 0.5 * h * n_R_eN;
      den = fabs(uSC) / h;
      if (den > num * 1.0e-8)
        numDiff[eN * nQuadraturePoints_element + k] = num / den;
      else
        numDiff[eN * nQuadraturePoints_element + k] = 0.0;
      maxNumDiff =
          fmax(maxNumDiff, numDiff[eN * nQuadraturePoints_element + k]);
    }
    for (k = 0; k < nQuadraturePoints_element; k++)
      numDiff[eN * nQuadraturePoints_element + k] = maxNumDiff;
  }
}


x86 assembly (clang, -O0):
<calculateNumericalDiffusionResGradJuanes>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13b4 <calculateNumericalDiffusionResGradJuanes+0x2b4>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    126e <calculateNumericalDiffusionResGradJuanes+0x16e>
movsd  0xe99(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xe7a(%rip),%xmm2
pand   %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x20(%rbp),%xmm0
movaps 0xe61(%rip),%xmm1
pand   %xmm1,%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  0xe36(%rip),%xmm1
mulsd  -0x58(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    11fe <calculateNumericalDiffusionResGradJuanes+0xfe>
movsd  -0x58(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1217 <calculateNumericalDiffusionResGradJuanes+0x117>
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm3
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0xdd7(%rip),%xmm0
pand   %xmm0,%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    115b <calculateNumericalDiffusionResGradJuanes+0x5b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1365 <calculateNumericalDiffusionResGradJuanes+0x265>
movsd  0xd77(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x20(%rbp),%xmm0
movaps 0xd5f(%rip),%xmm1
pand   %xmm1,%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  0xd34(%rip),%xmm1
mulsd  -0x58(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    1300 <calculateNumericalDiffusionResGradJuanes+0x200>
movsd  -0x58(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1319 <calculateNumericalDiffusionResGradJuanes+0x219>
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm3
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    127d <calculateNumericalDiffusionResGradJuanes+0x17d>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13a1 <calculateNumericalDiffusionResGradJuanes+0x2a1>
movsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    136c <calculateNumericalDiffusionResGradJuanes+0x26c>
jmp    13a6 <calculateNumericalDiffusionResGradJuanes+0x2a6>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    112e <calculateNumericalDiffusionResGradJuanes+0x2e>
pop    %rbp
ret

x86 assembly (clang, -O2):
<calculateNumericalDiffusionResGradJuanes>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edi,%edi
jle    13d4 <calculateNumericalDiffusionResGradJuanes+0x2d4>
mov    0x38(%rsp),%r11
mulsd  0xee1(%rip),%xmm0
andpd  0xee9(%rip),%xmm1
movslq %esi,%rdx
mov    %edi,%r13d
mov    %edx,%eax
mov    %eax,%r12d
and    $0xfffffffc,%r12d
lea    -0x4(%r12),%rdi
mov    %rdi,-0x10(%rsp)
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %eax,%ebx
and    $0xfffffffe,%ebx
mov    %edi,%r10d
and    $0x3,%r10d
and    $0xfffffffffffffffc,%rdi
mov    %rdi,-0x20(%rsp)
mov    %rdx,-0x8(%rsp)
lea    0x0(,%rdx,8),%r14
lea    0x10(%r11),%rdi
mov    %r10,-0x18(%rsp)
shl    $0x5,%r10
xor    %r9d,%r9d
movapd 0xe8d(%rip),%xmm10
movsd  0xe7c(%rip),%xmm9
jmp    11a6 <calculateNumericalDiffusionResGradJuanes+0xa6>
xchg   %ax,%ax
add    $0x1,%r9
add    %r14,%r11
add    %r14,%r8
add    %r14,%rdi
cmp    %r13,%r9
je     13d4 <calculateNumericalDiffusionResGradJuanes+0x2d4>
test   %esi,%esi
jle    1190 <calculateNumericalDiffusionResGradJuanes+0x90>
movsd  (%rcx,%r9,8),%xmm3
movapd %xmm0,%xmm5
mulsd  %xmm3,%xmm5
movapd %xmm1,%xmm6
divsd  %xmm3,%xmm6
xorpd  %xmm4,%xmm4
xor    %ebp,%ebp
jmp    120b <calculateNumericalDiffusionResGradJuanes+0x10b>
nopl   0x0(%rax,%rax,1)
movsd  %xmm3,(%r11,%rbp,8)
movsd  (%r8,%rbp,8),%xmm3
andpd  %xmm10,%xmm3
movapd %xmm4,%xmm7
cmpunordsd %xmm4,%xmm7
movapd %xmm7,%xmm2
andpd  %xmm3,%xmm2
maxsd  %xmm4,%xmm3
andnpd %xmm3,%xmm7
orpd   %xmm2,%xmm7
add    $0x1,%rbp
movapd %xmm7,%xmm4
cmp    %rbp,%rax
je     1240 <calculateNumericalDiffusionResGradJuanes+0x140>
movsd  (%r8,%rbp,8),%xmm7
andpd  %xmm10,%xmm7
mulsd  %xmm5,%xmm7
movapd %xmm7,%xmm3
mulsd  %xmm9,%xmm3
ucomisd %xmm3,%xmm6
xorpd  %xmm3,%xmm3
jbe    11d0 <calculateNumericalDiffusionResGradJuanes+0xd0>
divsd  %xmm6,%xmm7
movapd %xmm7,%xmm3
jmp    11d0 <calculateNumericalDiffusionResGradJuanes+0xd0>
nopw   0x0(%rax,%rax,1)
test   %esi,%esi
jle    1190 <calculateNumericalDiffusionResGradJuanes+0x90>
mulsd  %xmm7,%xmm5
movapd %xmm5,%xmm8
mulsd  %xmm9,%xmm8
divsd  %xmm6,%xmm5
cmp    $0x1,%esi
jne    1268 <calculateNumericalDiffusionResGradJuanes+0x168>
xorpd  %xmm4,%xmm4
xor    %r15d,%r15d
jmp    12d0 <calculateNumericalDiffusionResGradJuanes+0x1d0>
movapd %xmm8,%xmm7
cmpltsd %xmm6,%xmm7
andpd  %xmm5,%xmm7
xorpd  %xmm4,%xmm4
xor    %r15d,%r15d
nopl   (%rax)
movsd  %xmm7,(%r11,%r15,8)
movapd %xmm7,%xmm2
maxsd  %xmm4,%xmm2
cmpunordsd %xmm4,%xmm4
movapd %xmm4,%xmm3
andpd  %xmm7,%xmm3
andnpd %xmm2,%xmm4
orpd   %xmm3,%xmm4
movsd  %xmm7,0x8(%r11,%r15,8)
movapd %xmm7,%xmm2
maxsd  %xmm4,%xmm2
cmpunordsd %xmm4,%xmm4
movapd %xmm4,%xmm3
andnpd %xmm2,%xmm3
andpd  %xmm7,%xmm4
orpd   %xmm3,%xmm4
add    $0x2,%r15
cmp    %r15,%rbx
jne    1280 <calculateNumericalDiffusionResGradJuanes+0x180>
test   $0x1,%al
je     1315 <calculateNumericalDiffusionResGradJuanes+0x215>
mov    %r9,%rdx
imul   -0x8(%rsp),%rdx
add    %rdx,%r15
cmpltsd %xmm6,%xmm8
andpd  %xmm5,%xmm8
mov    0x38(%rsp),%rdx
movlpd %xmm8,(%rdx,%r15,8)
movapd %xmm8,%xmm2
maxsd  %xmm4,%xmm2
cmpunordsd %xmm4,%xmm4
movapd %xmm4,%xmm3
andpd  %xmm8,%xmm3
andnpd %xmm2,%xmm4
orpd   %xmm3,%xmm4
test   %esi,%esi
jle    1190 <calculateNumericalDiffusionResGradJuanes+0x90>
cmp    $0x4,%esi
jae    1329 <calculateNumericalDiffusionResGradJuanes+0x229>
xor    %edx,%edx
jmp    13c0 <calculateNumericalDiffusionResGradJuanes+0x2c0>
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
cmpq   $0xc,-0x10(%rsp)
jae    133d <calculateNumericalDiffusionResGradJuanes+0x23d>
xor    %ebp,%ebp
jmp    1391 <calculateNumericalDiffusionResGradJuanes+0x291>
mov    -0x20(%rsp),%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd %xmm5,(%r11,%rbp,8)
movupd %xmm5,0x10(%r11,%rbp,8)
movupd %xmm5,0x20(%r11,%rbp,8)
movupd %xmm5,0x30(%r11,%rbp,8)
movupd %xmm5,0x40(%r11,%rbp,8)
movupd %xmm5,0x50(%r11,%rbp,8)
movupd %xmm5,0x60(%r11,%rbp,8)
movupd %xmm5,0x70(%r11,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdx
jne    1350 <calculateNumericalDiffusionResGradJuanes+0x250>
cmpq   $0x0,-0x18(%rsp)
je     13b4 <calculateNumericalDiffusionResGradJuanes+0x2b4>
lea    (%rdi,%rbp,8),%rdx
xor    %ebp,%ebp
nop
movupd %xmm5,-0x10(%rdx,%rbp,1)
movupd %xmm5,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r10
jne    13a0 <calculateNumericalDiffusionResGradJuanes+0x2a0>
mov    %r12,%rdx
cmp    %rax,%r12
je     1190 <calculateNumericalDiffusionResGradJuanes+0x90>
movsd  %xmm4,(%r11,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    13c0 <calculateNumericalDiffusionResGradJuanes+0x2c0>
jmp    1190 <calculateNumericalDiffusionResGradJuanes+0x90>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @calculateNumericalDiffusionResGradJuanes(i32 %0, i32 %1, i32 %2, double %3, double %4, double* nocapture %5, double* nocapture %6, double* nocapture readnone %7, double* nocapture %8) {
%10 = icmp sgt i32 %0, 0
br i1 %10, label %11, label %158
11: ; preds = %9
%12 = icmp sgt i32 %1, 0
%13 = fmul double %3, 5.000000e-01
%14 = tail call double @llvm.fabs.f64(double %4)
%15 = sext i32 %1 to i64
%16 = zext i32 %0 to i64
%17 = zext i32 %1 to i64
%18 = zext i32 %1 to i64
%19 = and i64 %17, 4294967292
%20 = add nsw i64 %19, -4
%21 = lshr exact i64 %20, 2
%22 = add nuw nsw i64 %21, 1
%23 = and i64 %17, 1
%24 = icmp eq i32 %1, 1
%25 = and i64 %17, 4294967294
%26 = icmp eq i64 %23, 0
%27 = icmp ult i32 %1, 4
%28 = and i64 %17, 4294967292
%29 = and i64 %22, 3
%30 = icmp ult i64 %20, 12
%31 = and i64 %22, 9223372036854775804
%32 = icmp eq i64 %29, 0
%33 = icmp eq i64 %28, %17
br label %34
34: ; preds = %11, %155
%35 = phi i64 [ 0, %11 ], [ %156, %155 ]
%36 = getelementptr inbounds double, double* %5, i64 %35
%37 = load double, double* %36
br i1 %12, label %38, label %155
38: ; preds = %34
%39 = fmul double %13, %37
%40 = mul nsw i64 %35, %15
%41 = fdiv double %14, %37
br label %54
42: ; preds = %54
br i1 %12, label %43, label %155
43: ; preds = %42
%44 = fmul double %13, %37
%45 = fmul double %44, %69
%46 = fdiv double %14, %37
%47 = fmul double %45, 1.000000e-08
%48 = fcmp ogt double %46, %47
%49 = mul nsw i64 %35, %15
%50 = fdiv double %45, %46
br i1 %24, label %72, label %51
51: ; preds = %43
%52 = select i1 %48, double %50, double 0.000000e+00
%53 = select i1 %48, double %50, double 0.000000e+00
br label %135
54: ; preds = %38, %54
%55 = phi i64 [ 0, %38 ], [ %70, %54 ]
%56 = phi double [ 0.000000e+00, %38 ], [ %69, %54 ]
%57 = add nsw i64 %55, %40
%58 = getelementptr inbounds double, double* %6, i64 %57
%59 = load double, double* %58
%60 = tail call double @llvm.fabs.f64(double %59)
%61 = fmul double %39, %60
%62 = fmul double %61, 1.000000e-08
%63 = fcmp ogt double %41, %62
%64 = fdiv double %61, %41
%65 = select i1 %63, double %64, double 0.000000e+00
%66 = getelementptr inbounds double, double* %8, i64 %57
store double %65, double* %66
%67 = load double, double* %58
%68 = tail call double @llvm.fabs.f64(double %67)
%69 = tail call double @llvm.maxnum.f64(double %56, double %68)
%70 = add nuw nsw i64 %55, 1
%71 = icmp eq i64 %70, %17
br i1 %71, label %42, label %54
72: ; preds = %135, %43
%73 = phi double [ undef, %43 ], [ %145, %135 ]
%74 = phi i64 [ 0, %43 ], [ %146, %135 ]
%75 = phi double [ 0.000000e+00, %43 ], [ %145, %135 ]
br i1 %26, label %81, label %76
76: ; preds = %72
%77 = add nsw i64 %74, %49
%78 = getelementptr inbounds double, double* %8, i64 %77
%79 = select i1 %48, double %50, double 0.000000e+00
store double %79, double* %78
%80 = tail call double @llvm.maxnum.f64(double %75, double %79)
br label %81
81: ; preds = %72, %76
%82 = phi double [ %73, %72 ], [ %80, %76 ]
br i1 %12, label %83, label %155
83: ; preds = %81
%84 = mul nsw i64 %35, %15
br i1 %27, label %133, label %85
85: ; preds = %83
%86 = insertelement <2 x double> poison, double %82, i64 0
%87 = shufflevector <2 x double> %86, <2 x double> poison, <2 x i32> zeroinitializer
%88 = insertelement <2 x double> poison, double %82, i64 0
%89 = shufflevector <2 x double> %88, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %30, label %119, label %90
90: ; preds = %85, %90
%91 = phi i64 [ %116, %90 ], [ 0, %85 ]
%92 = phi i64 [ %117, %90 ], [ 0, %85 ]
%93 = add nsw i64 %91, %84
%94 = getelementptr inbounds double, double* %8, i64 %93
%95 = bitcast double* %94 to <2 x double>*
store <2 x double> %87, <2 x double>* %95
%96 = getelementptr inbounds double, double* %94, i64 2
%97 = bitcast double* %96 to <2 x double>*
store <2 x double> %89, <2 x double>* %97
%98 = or i64 %91, 4
%99 = add nsw i64 %98, %84
%100 = getelementptr inbounds double, double* %8, i64 %99
%101 = bitcast double* %100 to <2 x double>*
store <2 x double> %87, <2 x double>* %101
%102 = getelementptr inbounds double, double* %100, i64 2
%103 = bitcast double* %102 to <2 x double>*
store <2 x double> %89, <2 x double>* %103
%104 = or i64 %91, 8
%105 = add nsw i64 %104, %84
%106 = getelementptr inbounds double, double* %8, i64 %105
%107 = bitcast double* %106 to <2 x double>*
store <2 x double> %87, <2 x double>* %107
%108 = getelementptr inbounds double, double* %106, i64 2
%109 = bitcast double* %108 to <2 x double>*
store <2 x double> %89, <2 x double>* %109
%110 = or i64 %91, 12
%111 = add nsw i64 %110, %84
%112 = getelementptr inbounds double, double* %8, i64 %111
%113 = bitcast double* %112 to <2 x double>*
store <2 x double> %87, <2 x double>* %113
%114 = getelementptr inbounds double, double* %112, i64 2
%115 = bitcast double* %114 to <2 x double>*
store <2 x double> %89, <2 x double>* %115
%116 = add nuw i64 %91, 16
%117 = add nuw i64 %92, 4
%118 = icmp eq i64 %117, %31
br i1 %118, label %119, label %90
119: ; preds = %90, %85
%120 = phi i64 [ 0, %85 ], [ %116, %90 ]
br i1 %32, label %132, label %121
121: ; preds = %119, %121
%122 = phi i64 [ %129, %121 ], [ %120, %119 ]
%123 = phi i64 [ %130, %121 ], [ 0, %119 ]
%124 = add nsw i64 %122, %84
%125 = getelementptr inbounds double, double* %8, i64 %124
%126 = bitcast double* %125 to <2 x double>*
store <2 x double> %87, <2 x double>* %126
%127 = getelementptr inbounds double, double* %125, i64 2
%128 = bitcast double* %127 to <2 x double>*
store <2 x double> %89, <2 x double>* %128
%129 = add nuw i64 %122, 4
%130 = add i64 %123, 1
%131 = icmp eq i64 %130, %29
br i1 %131, label %132, label %121
132: ; preds = %121, %119
br i1 %33, label %155, label %133
133: ; preds = %83, %132
%134 = phi i64 [ 0, %83 ], [ %28, %132 ]
br label %149
135: ; preds = %135, %51
%136 = phi i64 [ 0, %51 ], [ %146, %135 ]
%137 = phi double [ 0.000000e+00, %51 ], [ %145, %135 ]
%138 = phi i64 [ 0, %51 ], [ %147, %135 ]
%139 = add nsw i64 %136, %49
%140 = getelementptr inbounds double, double* %8, i64 %139
store double %52, double* %140
%141 = tail call double @llvm.maxnum.f64(double %137, double %52)
%142 = or i64 %136, 1
%143 = add nsw i64 %142, %49
%144 = getelementptr inbounds double, double* %8, i64 %143
store double %53, double* %144
%145 = tail call double @llvm.maxnum.f64(double %141, double %53)
%146 = add nuw nsw i64 %136, 2
%147 = add i64 %138, 2
%148 = icmp eq i64 %147, %25
br i1 %148, label %72, label %135
149: ; preds = %133, %149
%150 = phi i64 [ %153, %149 ], [ %134, %133 ]
%151 = add nsw i64 %150, %84
%152 = getelementptr inbounds double, double* %8, i64 %151
store double %82, double* %152
%153 = add nuw nsw i64 %150, 1
%154 = icmp eq i64 %153, %18
br i1 %154, label %155, label %149
155: ; preds = %149, %132, %34, %42, %81
%156 = add nuw nsw i64 %35, 1
%157 = icmp eq i64 %156, %16
br i1 %157, label %158, label %34
158: ; preds = %155, %9
ret void
}