#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 */
int /*<<< orphan*/ printf(char *, int, double, double);
int sweep(double *wvl, double *dat, int n, int verbose, unsigned char *hull) {
  int i, l = 0, r = 1, nu = 0;
  double slope, datpr;
  while (r < n) {
    if (hull[r]) {
      slope = (dat[r] - dat[l]) / (wvl[r] - wvl[l]);
      for (i = l; i < r; i++) {
        datpr = dat[l] + ((wvl[i] - wvl[l]) * slope);
        if (dat[i] - datpr > 10e-10) {
          hull[i] = 1;
          if (verbose)
            printf("under: %d (%f vs. %f)\n", i, dat[i], datpr);
          nu += 1;
        }
      }
      l = r;
    }
    r++;
  }
  return nu;
}


x86 assembly (clang, -O0):
<sweep>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x1,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1270 <sweep+0x160>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     1262 <sweep+0x152>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    125c <sweep+0x14c>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  0xe01(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1249 <sweep+0x139>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
cmpl   $0x0,-0x18(%rbp)
je     1240 <sweep+0x130>
mov    -0x24(%rbp),%esi
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm1
lea    0xdcd(%rip),%rdi
call   1030 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    124e <sweep+0x13e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11a0 <sweep+0x90>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    113f <sweep+0x2f>
mov    -0x30(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sweep>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8,0x8(%rsp)
mov    %ecx,0x4(%rsp)
xor    %ebx,%ebx
cmp    $0x2,%edx
jl     1268 <sweep+0x158>
mov    %rsi,%r13
mov    %edx,%r8d
xor    %r15d,%r15d
mov    $0x1,%ebp
movsd  0xeb8(%rip),%xmm4
xor    %ebx,%ebx
mov    %r8,0x10(%rsp)
mov    %rdi,0x18(%rsp)
jmp    1175 <sweep+0x65>
cs nopw 0x0(%rax,%rax,1)
mov    %ebp,%r15d
mov    0x10(%rsp),%r8
add    $0x1,%rbp
cmp    %r8,%rbp
je     1268 <sweep+0x158>
mov    0x8(%rsp),%rax
cmpb   $0x0,(%rax,%rbp,1)
je     1168 <sweep+0x58>
movslq %r15d,%r14
cmp    %r14,%rbp
jle    1260 <sweep+0x150>
movsd  0x0(%r13,%rbp,8),%xmm5
movsd  0x0(%r13,%r14,8),%xmm0
subsd  %xmm0,%xmm5
movsd  (%rdi,%rbp,8),%xmm1
movsd  (%rdi,%r14,8),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm5
lea    0x1(%r14),%r12
movapd %xmm2,%xmm1
movapd %xmm0,%xmm3
movsd  %xmm5,0x20(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
subsd  %xmm2,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm3,%xmm1
subsd  %xmm1,%xmm0
ucomisd %xmm4,%xmm0
jbe    1224 <sweep+0x114>
mov    0x8(%rsp),%rax
movb   $0x1,-0x1(%rax,%r12,1)
cmpl   $0x0,0x4(%rsp)
je     1221 <sweep+0x111>
movsd  -0x8(%r13,%r12,8),%xmm0
lea    0xe02(%rip),%rdi
mov    %r15d,%esi
call   1030 <printf@plt>
movsd  0x20(%rsp),%xmm5
movsd  0xde4(%rip),%xmm4
mov    0x18(%rsp),%rdi
add    $0x1,%ebx
mov    %r12d,%eax
cmp    %rbp,%rax
je     1160 <sweep+0x50>
movsd  0x0(%r13,%r14,8),%xmm3
movsd  (%rdi,%r12,8),%xmm1
movsd  (%rdi,%r14,8),%xmm2
movsd  0x0(%r13,%r12,8),%xmm0
add    $0x1,%r15d
add    $0x1,%r12
jmp    11d0 <sweep+0xc0>
nopw   0x0(%rax,%rax,1)
mov    %ebp,%r15d
jmp    1168 <sweep+0x58>
mov    %ebx,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [23 x i8] c"under: %d (%f vs. %f)\0A\00"
define i32 @sweep(double* nocapture %0, double* nocapture %1, i32 %2, i32 %3, i8* nocapture %4) {
%6 = icmp sgt i32 %2, 1
br i1 %6, label %7, label %69
7: ; preds = %5
%8 = icmp eq i32 %3, 0
%9 = zext i32 %2 to i64
br label %10
10: ; preds = %7, %64
%11 = phi i64 [ 1, %7 ], [ %67, %64 ]
%12 = phi i32 [ 0, %7 ], [ %66, %64 ]
%13 = phi i32 [ 0, %7 ], [ %65, %64 ]
%14 = getelementptr inbounds i8, i8* %4, i64 %11
%15 = load i8, i8* %14
%16 = icmp eq i8 %15, 0
br i1 %16, label %64, label %17
17: ; preds = %10
%18 = getelementptr inbounds double, double* %1, i64 %11
%19 = load double, double* %18
%20 = sext i32 %12 to i64
%21 = getelementptr inbounds double, double* %1, i64 %20
%22 = load double, double* %21
%23 = fsub double %19, %22
%24 = getelementptr inbounds double, double* %0, i64 %11
%25 = load double, double* %24
%26 = getelementptr inbounds double, double* %0, i64 %20
%27 = load double, double* %26
%28 = fsub double %25, %27
%29 = fdiv double %23, %28
%30 = icmp sgt i64 %11, %20
%31 = trunc i64 %11 to i32
br i1 %30, label %32, label %64
32: ; preds = %17, %57
%33 = phi double [ %63, %57 ], [ %22, %17 ]
%34 = phi double [ %61, %57 ], [ %27, %17 ]
%35 = phi double [ %60, %57 ], [ %27, %17 ]
%36 = phi double [ %58, %57 ], [ %22, %17 ]
%37 = phi i64 [ %54, %57 ], [ %20, %17 ]
%38 = phi i32 [ %53, %57 ], [ %13, %17 ]
%39 = fsub double %35, %34
%40 = tail call double @llvm.fmuladd.f64(double %39, double %29, double %36)
%41 = getelementptr inbounds double, double* %1, i64 %37
%42 = fsub double %33, %40
%43 = fcmp ogt double %42, 1.000000e-09
br i1 %43, label %44, label %52
44: ; preds = %32
%45 = getelementptr inbounds i8, i8* %4, i64 %37
store i8 1, i8* %45
br i1 %8, label %50, label %46
46: ; preds = %44
%47 = load double, double* %41
%48 = trunc i64 %37 to i32
%49 = tail call i32 @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i32 %48, double %47, double %40)
br label %50
50: ; preds = %46, %44
%51 = add nsw i32 %38, 1
br label %52
52: ; preds = %32, %50
%53 = phi i32 [ %51, %50 ], [ %38, %32 ]
%54 = add nsw i64 %37, 1
%55 = and i64 %54, 4294967295
%56 = icmp eq i64 %55, %11
br i1 %56, label %64, label %57
57: ; preds = %52
%58 = load double, double* %21
%59 = getelementptr inbounds double, double* %0, i64 %54
%60 = load double, double* %59
%61 = load double, double* %26
%62 = getelementptr inbounds double, double* %1, i64 %54
%63 = load double, double* %62
br label %32
64: ; preds = %52, %17, %10
%65 = phi i32 [ %13, %10 ], [ %13, %17 ], [ %53, %52 ]
%66 = phi i32 [ %12, %10 ], [ %31, %17 ], [ %31, %52 ]
%67 = add nuw nsw i64 %11, 1
%68 = icmp eq i64 %67, %9
br i1 %68, label %69, label %10
69: ; preds = %64, %5
%70 = phi i32 [ 0, %5 ], [ %65, %64 ]
ret i32 %70
}