#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 solveQuadratic(double **, int, int, double **, double);
void sweep(double **U, int ia, int ib, int ja, int jb, double **F, double h,
           double *maxerr) {
  int stepi = ib < ia ? -1 : 1;
  int stepj = jb < ja ? -1 : 1;
  for (int i = ia; stepi * i <= stepi * ib; i += stepi) {
    for (int j = ja; stepj * j <= stepj * jb; j += stepj) {
      double unew = solveQuadratic(U, i, j, F, h);
      if (unew < U[i][j]) {
        double err = fabs(U[i][j] - unew) / U[i][j];
        if (err > *maxerr)
          *maxerr = err;
        U[i][j] = unew;
      }
    }
  }
}


x86 assembly (clang, -O0):
<sweep>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%edx
mov    -0xc(%rbp),%esi
mov    $0x1,%eax
mov    $0xffffffff,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%edx
mov    -0x14(%rbp),%esi
mov    $0x1,%eax
mov    $0xffffffff,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x34(%rbp),%eax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
cmp    %ecx,%eax
jg     127e <sweep+0x16e>
mov    -0x14(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x38(%rbp),%eax
mov    -0x30(%rbp),%ecx
imul   -0x18(%rbp),%ecx
cmp    %ecx,%eax
jg     126b <sweep+0x15b>
mov    -0x8(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%edx
mov    -0x20(%rbp),%rcx
movsd  -0x28(%rbp),%xmm0
call   1030 <solveQuadratic@plt>
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1258 <sweep+0x148>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x40(%rbp),%xmm0
movaps 0xe00(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    0x10(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    123e <sweep+0x12e>
movsd  -0x48(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    125d <sweep+0x14d>
mov    -0x30(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1188 <sweep+0x78>
jmp    1270 <sweep+0x160>
mov    -0x2c(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    116c <sweep+0x5c>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sweep>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
movsd  %xmm0,0x40(%rsp)
mov    %r9,0x38(%rsp)
mov    %rdi,%r12
xor    %eax,%eax
cmp    %esi,%edx
setge  %al
lea    (%rax,%rax,1),%ebp
add    $0xffffffff,%ebp
xor    %edi,%edi
cmp    %ecx,%r8d
setge  %bl
imul   %ebp,%edx
mov    %ebp,%eax
imul   %esi,%eax
cmp    %edx,%eax
jle    115c <sweep+0x4c>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8d,%r9d
mov    %bl,%dil
lea    (%rdi,%rdi,1),%eax
add    $0xffffffff,%eax
imul   %eax,%r9d
movslq %eax,%r14
imul   %ecx,%eax
mov    %eax,0x8(%rsp)
movslq %ecx,%rax
mov    %r9d,0xc(%rsp)
movslq %r9d,%rcx
mov    %rcx,0x30(%rsp)
movslq %esi,%rbx
movslq %ebp,%rcx
mov    %rcx,0x28(%rsp)
movslq %edx,%rcx
mov    %rcx,0x20(%rsp)
mov    %r14,%rcx
mov    %rax,0x18(%rsp)
imul   %rax,%rcx
mov    %rcx,0x10(%rsp)
mov    %r14,%r13
imul   %r14,%r14
jmp    11da <sweep+0xca>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x28(%rsp),%rcx
add    %rcx,%rbx
mov    %rbx,%rax
imul   %rcx,%rax
cmp    0x20(%rsp),%rax
jg     114d <sweep+0x3d>
mov    0x8(%rsp),%eax
cmp    0xc(%rsp),%eax
jg     11c0 <sweep+0xb0>
mov    0x10(%rsp),%r15
mov    0x18(%rsp),%rbp
jmp    1202 <sweep+0xf2>
movsd  %xmm0,(%rax,%rbp,8)
add    %r13,%rbp
add    %r14,%r15
cmp    0x30(%rsp),%r15
jg     11c0 <sweep+0xb0>
mov    %r12,%rdi
mov    %ebx,%esi
mov    %ebp,%edx
mov    0x38(%rsp),%rcx
movsd  0x40(%rsp),%xmm0
call   1030 <solveQuadratic@plt>
mov    (%r12,%rbx,8),%rax
movsd  (%rax,%rbp,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    11f5 <sweep+0xe5>
movapd %xmm1,%xmm2
subsd  %xmm0,%xmm2
andpd  0xdc8(%rip),%xmm2
divsd  %xmm1,%xmm2
mov    0x80(%rsp),%rcx
ucomisd (%rcx),%xmm2
jbe    11f0 <sweep+0xe0>
mov    0x80(%rsp),%rcx
movsd  %xmm2,(%rcx)
jmp    11f0 <sweep+0xe0>

LLVM IR (-O0):
define void @sweep(double** %0, i32 %1, i32 %2, i32 %3, i32 %4, double** %5, double %6, double* %7) {
%9 = alloca double**
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca double**
%15 = alloca double
%16 = alloca double*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca double
%22 = alloca double
store double** %0, double*** %9
store i32 %1, i32* %10
store i32 %2, i32* %11
store i32 %3, i32* %12
store i32 %4, i32* %13
store double** %5, double*** %14
store double %6, double* %15
store double* %7, double** %16
%23 = load i32, i32* %11
%24 = load i32, i32* %10
%25 = icmp slt i32 %23, %24
%26 = zext i1 %25 to i64
%27 = select i1 %25, i32 -1, i32 1
store i32 %27, i32* %17
%28 = load i32, i32* %13
%29 = load i32, i32* %12
%30 = icmp slt i32 %28, %29
%31 = zext i1 %30 to i64
%32 = select i1 %30, i32 -1, i32 1
store i32 %32, i32* %18
%33 = load i32, i32* %10
store i32 %33, i32* %19
br label %34
34: ; preds = %116, %8
%35 = load i32, i32* %17
%36 = load i32, i32* %19
%37 = mul nsw i32 %35, %36
%38 = load i32, i32* %17
%39 = load i32, i32* %11
%40 = mul nsw i32 %38, %39
%41 = icmp sle i32 %37, %40
br i1 %41, label %42, label %120
42: ; preds = %34
%43 = load i32, i32* %12
store i32 %43, i32* %20
br label %44
44: ; preds = %111, %42
%45 = load i32, i32* %18
%46 = load i32, i32* %20
%47 = mul nsw i32 %45, %46
%48 = load i32, i32* %18
%49 = load i32, i32* %13
%50 = mul nsw i32 %48, %49
%51 = icmp sle i32 %47, %50
br i1 %51, label %52, label %115
52: ; preds = %44
%53 = load double**, double*** %9
%54 = load i32, i32* %19
%55 = load i32, i32* %20
%56 = load double**, double*** %14
%57 = load double, double* %15
%58 = call double @solveQuadratic(double** %53, i32 %54, i32 %55, double** %56, double %57)
store double %58, double* %21
%59 = load double, double* %21
%60 = load double**, double*** %9
%61 = load i32, i32* %19
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds double*, double** %60, i64 %62
%64 = load double*, double** %63
%65 = load i32, i32* %20
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds double, double* %64, i64 %66
%68 = load double, double* %67
%69 = fcmp olt double %59, %68
br i1 %69, label %70, label %110
70: ; preds = %52
%71 = load double**, double*** %9
%72 = load i32, i32* %19
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds double*, double** %71, i64 %73
%75 = load double*, double** %74
%76 = load i32, i32* %20
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double, double* %75, i64 %77
%79 = load double, double* %78
%80 = load double, double* %21
%81 = fsub double %79, %80
%82 = call double @llvm.fabs.f64(double %81)
%83 = load double**, double*** %9
%84 = load i32, i32* %19
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds double*, double** %83, i64 %85
%87 = load double*, double** %86
%88 = load i32, i32* %20
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double, double* %87, i64 %89
%91 = load double, double* %90
%92 = fdiv double %82, %91
store double %92, double* %22
%93 = load double, double* %22
%94 = load double*, double** %16
%95 = load double, double* %94
%96 = fcmp ogt double %93, %95
br i1 %96, label %97, label %100
97: ; preds = %70
%98 = load double, double* %22
%99 = load double*, double** %16
store double %98, double* %99
br label %100
100: ; preds = %97, %70
%101 = load double, double* %21
%102 = load double**, double*** %9
%103 = load i32, i32* %19
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds double*, double** %102, i64 %104
%106 = load double*, double** %105
%107 = load i32, i32* %20
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds double, double* %106, i64 %108
store double %101, double* %109
br label %110
110: ; preds = %100, %52
br label %111
111: ; preds = %110
%112 = load i32, i32* %18
%113 = load i32, i32* %20
%114 = add nsw i32 %113, %112
store i32 %114, i32* %20
br label %44
115: ; preds = %44
br label %116
116: ; preds = %115
%117 = load i32, i32* %17
%118 = load i32, i32* %19
%119 = add nsw i32 %118, %117
store i32 %119, i32* %19
br label %34
120: ; preds = %34
ret void
}

LLVM IR (-O2):
define void @sweep(double** %0, i32 %1, i32 %2, i32 %3, i32 %4, double** %5, double %6, double* nocapture %7) {
%9 = icmp slt i32 %2, %1
%10 = select i1 %9, i32 -1, i32 1
%11 = icmp slt i32 %4, %3
%12 = select i1 %11, i32 -1, i32 1
%13 = mul nsw i32 %10, %2
%14 = mul nsw i32 %10, %1
%15 = icmp sgt i32 %14, %13
br i1 %15, label %31, label %16
16: ; preds = %8
%17 = mul nsw i32 %12, %4
%18 = mul nsw i32 %12, %3
%19 = icmp sgt i32 %18, %17
%20 = sext i32 %3 to i64
%21 = sext i32 %12 to i64
%22 = sext i32 %17 to i64
%23 = sext i32 %1 to i64
%24 = sext i32 %10 to i64
%25 = sext i32 %13 to i64
br label %26
26: ; preds = %16, %32
%27 = phi i64 [ %23, %16 ], [ %33, %32 ]
br i1 %19, label %32, label %28
28: ; preds = %26
%29 = getelementptr inbounds double*, double** %0, i64 %27
%30 = trunc i64 %27 to i32
br label %36
31: ; preds = %32, %8
ret void
32: ; preds = %52, %26
%33 = add i64 %27, %24
%34 = mul nsw i64 %33, %24
%35 = icmp sgt i64 %34, %25
br i1 %35, label %31, label %26
36: ; preds = %28, %52
%37 = phi i64 [ %20, %28 ], [ %53, %52 ]
%38 = trunc i64 %37 to i32
%39 = tail call double @solveQuadratic(double** %0, i32 %30, i32 %38, double** %5, double %6)
%40 = load double*, double** %29
%41 = getelementptr inbounds double, double* %40, i64 %37
%42 = load double, double* %41
%43 = fcmp olt double %39, %42
br i1 %43, label %44, label %52
44: ; preds = %36
%45 = fsub double %42, %39
%46 = tail call double @llvm.fabs.f64(double %45)
%47 = fdiv double %46, %42
%48 = load double, double* %7
%49 = fcmp ogt double %47, %48
br i1 %49, label %50, label %51
50: ; preds = %44
store double %47, double* %7
br label %51
51: ; preds = %50, %44
store double %39, double* %41
br label %52
52: ; preds = %51, %36
%53 = add i64 %37, %21
%54 = mul nsw i64 %53, %21
%55 = icmp sgt i64 %54, %22
br i1 %55, label %32, label %36
}