void linearint(int *zp, int minx, int maxx, float dz, float *interface) {
  int i;
  for (i = minx; i < maxx; i++) {
    zp[i] =
        ((((int)((interface[i] / dz) > 0.0 ? (interface[i] / dz) + 0.5
                                           : (interface[i] / dz) - 0.5))) > (0)
             ? (((int)((interface[i] / dz) > 0.0 ? (interface[i] / dz) + 0.5
                                                 : (interface[i] / dz) - 0.5)))
             : (0));
  }
  return;
}


x86 assembly (clang, -O0):
<linearint>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    125e <linearint+0x15e>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1178 <linearint+0x78>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe96(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
jmp    119f <linearint+0x9f>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe6a(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm0
cvttsd2si %xmm0,%eax
cmp    $0x0,%eax
jle    1238 <linearint+0x138>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1200 <linearint+0x100>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe0e(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    1227 <linearint+0x127>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xde2(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x3c(%rbp)
jmp    1242 <linearint+0x142>
xor    %eax,%eax
mov    %eax,-0x3c(%rbp)
jmp    1242 <linearint+0x142>
mov    -0x3c(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111d <linearint+0x1d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<linearint>:
cmp    %edx,%esi
jge    1230 <linearint+0x130>
movslq %esi,%rax
movslq %edx,%r10
mov    %r10,%r8
sub    %rax,%r8
cmp    $0x4,%r8
jae    1122 <linearint+0x22>
mov    %rax,%rdx
jmp    11f2 <linearint+0xf2>
mov    %r8,%rsi
and    $0xfffffffffffffffc,%rsi
lea    (%rsi,%rax,1),%rdx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    (%rcx,%rax,4),%r9
lea    (%rdi,%rax,4),%r11
xor    %eax,%eax
pxor   %xmm8,%xmm8
movdqa 0xeb4(%rip),%xmm9
movdqa 0xebc(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%r9,%rax,4),%xmm5
divps  %xmm1,%xmm5
cvtps2pd %xmm5,%xmm6
xorps  %xmm2,%xmm2
cmpltps %xmm5,%xmm2
movhlps %xmm5,%xmm5
cvtps2pd %xmm5,%xmm5
movaps %xmm2,%xmm7
unpckhpd %xmm2,%xmm7
pxor   %xmm3,%xmm3
pcmpgtd %xmm7,%xmm3
punpckldq %xmm3,%xmm7
pxor   %xmm3,%xmm3
pcmpgtd %xmm2,%xmm3
punpckldq %xmm3,%xmm2
movdqa %xmm4,%xmm3
pand   %xmm2,%xmm3
pandn  %xmm9,%xmm2
por    %xmm3,%xmm2
addpd  %xmm6,%xmm2
movdqa %xmm4,%xmm3
pand   %xmm7,%xmm3
pandn  %xmm9,%xmm7
por    %xmm3,%xmm7
addpd  %xmm5,%xmm7
cvttpd2dq %xmm2,%xmm2
cvttpd2dq %xmm7,%xmm3
unpcklpd %xmm3,%xmm2
movapd %xmm2,%xmm3
pcmpgtd %xmm8,%xmm3
pand   %xmm2,%xmm3
movdqu %xmm3,(%r11,%rax,4)
add    $0x4,%rax
cmp    %rax,%rsi
jne    1160 <linearint+0x60>
cmp    %rsi,%r8
je     1230 <linearint+0x130>
xorps  %xmm1,%xmm1
lea    0xe24(%rip),%r8
xor    %esi,%esi
xchg   %ax,%ax
movss  (%rcx,%rdx,4),%xmm2
divss  %xmm0,%xmm2
xor    %eax,%eax
ucomiss %xmm1,%xmm2
seta   %al
cvtss2sd %xmm2,%xmm2
addsd  (%r8,%rax,8),%xmm2
cvttsd2si %xmm2,%eax
test   %eax,%eax
cmovs  %esi,%eax
mov    %eax,(%rdi,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r10
jne    1200 <linearint+0x100>
ret

LLVM IR (-O0):
define void @linearint(i32* %0, i32 %1, i32 %2, float %3, float* %4) {
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
%9 = alloca float
%10 = alloca float*
%11 = alloca i32
store i32* %0, i32** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store float %3, float* %9
store float* %4, float** %10
%12 = load i32, i32* %7
store i32 %12, i32* %11
br label %13
13: ; preds = %91, %5
%14 = load i32, i32* %11
%15 = load i32, i32* %8
%16 = icmp slt i32 %14, %15
br i1 %16, label %17, label %94
17: ; preds = %13
%18 = load float*, float** %10
%19 = load i32, i32* %11
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds float, float* %18, i64 %20
%22 = load float, float* %21
%23 = load float, float* %9
%24 = fdiv float %22, %23
%25 = fpext float %24 to double
%26 = fcmp ogt double %25, 0.000000e+00
br i1 %26, label %27, label %37
27: ; preds = %17
%28 = load float*, float** %10
%29 = load i32, i32* %11
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds float, float* %28, i64 %30
%32 = load float, float* %31
%33 = load float, float* %9
%34 = fdiv float %32, %33
%35 = fpext float %34 to double
%36 = fadd double %35, 5.000000e-01
br label %47
37: ; preds = %17
%38 = load float*, float** %10
%39 = load i32, i32* %11
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds float, float* %38, i64 %40
%42 = load float, float* %41
%43 = load float, float* %9
%44 = fdiv float %42, %43
%45 = fpext float %44 to double
%46 = fsub double %45, 5.000000e-01
br label %47
47: ; preds = %37, %27
%48 = phi double [ %36, %27 ], [ %46, %37 ]
%49 = fptosi double %48 to i32
%50 = icmp sgt i32 %49, 0
br i1 %50, label %51, label %84
51: ; preds = %47
%52 = load float*, float** %10
%53 = load i32, i32* %11
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds float, float* %52, i64 %54
%56 = load float, float* %55
%57 = load float, float* %9
%58 = fdiv float %56, %57
%59 = fpext float %58 to double
%60 = fcmp ogt double %59, 0.000000e+00
br i1 %60, label %61, label %71
61: ; preds = %51
%62 = load float*, float** %10
%63 = load i32, i32* %11
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds float, float* %62, i64 %64
%66 = load float, float* %65
%67 = load float, float* %9
%68 = fdiv float %66, %67
%69 = fpext float %68 to double
%70 = fadd double %69, 5.000000e-01
br label %81
71: ; preds = %51
%72 = load float*, float** %10
%73 = load i32, i32* %11
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds float, float* %72, i64 %74
%76 = load float, float* %75
%77 = load float, float* %9
%78 = fdiv float %76, %77
%79 = fpext float %78 to double
%80 = fsub double %79, 5.000000e-01
br label %81
81: ; preds = %71, %61
%82 = phi double [ %70, %61 ], [ %80, %71 ]
%83 = fptosi double %82 to i32
br label %85
84: ; preds = %47
br label %85
85: ; preds = %84, %81
%86 = phi i32 [ %83, %81 ], [ 0, %84 ]
%87 = load i32*, i32** %6
%88 = load i32, i32* %11
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i32, i32* %87, i64 %89
store i32 %86, i32* %90
br label %91
91: ; preds = %85
%92 = load i32, i32* %11
%93 = add nsw i32 %92, 1
store i32 %93, i32* %11
br label %13
94: ; preds = %13
ret void
}

LLVM IR (-O2):
define void @linearint(i32* nocapture writeonly %0, i32 %1, i32 %2, float %3, float* nocapture %4) {
%6 = icmp slt i32 %1, %2
br i1 %6, label %7, label %54
7: ; preds = %5
%8 = sext i32 %1 to i64
%9 = sext i32 %2 to i64
%10 = sub nsw i64 %9, %8
%11 = icmp ult i64 %10, 4
br i1 %11, label %37, label %12
12: ; preds = %7
%13 = and i64 %10, -4
%14 = add nsw i64 %13, %8
%15 = insertelement <4 x float> poison, float %3, i64 0
%16 = shufflevector <4 x float> %15, <4 x float> poison, <4 x i32> zeroinitializer
br label %17
17: ; preds = %17, %12
%18 = phi i64 [ 0, %12 ], [ %33, %17 ]
%19 = add i64 %18, %8
%20 = getelementptr inbounds float, float* %4, i64 %19
%21 = bitcast float* %20 to <4 x float>*
%22 = load <4 x float>, <4 x float>* %21
%23 = fdiv <4 x float> %22, %16
%24 = fpext <4 x float> %23 to <4 x double>
%25 = fcmp ogt <4 x float> %23, zeroinitializer
%26 = select <4 x i1> %25, <4 x double> <double 5.000000e-01, double 5.000000e-01, double 5.000000e-01, double 5.000000e-01>, <4 x double> <double -5.000000e-01, double -5.000000e-01, double -5.000000e-01, double -5.000000e-01>
%27 = fadd <4 x double> %26, %24
%28 = fptosi <4 x double> %27 to <4 x i32>
%29 = icmp sgt <4 x i32> %28, zeroinitializer
%30 = select <4 x i1> %29, <4 x i32> %28, <4 x i32> zeroinitializer
%31 = getelementptr inbounds i32, i32* %0, i64 %19
%32 = bitcast i32* %31 to <4 x i32>*
store <4 x i32> %30, <4 x i32>* %32
%33 = add nuw i64 %18, 4
%34 = icmp eq i64 %33, %13
br i1 %34, label %35, label %17
35: ; preds = %17
%36 = icmp eq i64 %10, %13
br i1 %36, label %54, label %37
37: ; preds = %7, %35
%38 = phi i64 [ %8, %7 ], [ %14, %35 ]
br label %39
39: ; preds = %37, %39
%40 = phi i64 [ %52, %39 ], [ %38, %37 ]
%41 = getelementptr inbounds float, float* %4, i64 %40
%42 = load float, float* %41
%43 = fdiv float %42, %3
%44 = fpext float %43 to double
%45 = fcmp ogt float %43, 0.000000e+00
%46 = select i1 %45, double 5.000000e-01, double -5.000000e-01
%47 = fadd double %46, %44
%48 = fptosi double %47 to i32
%49 = icmp sgt i32 %48, 0
%50 = select i1 %49, i32 %48, i32 0
%51 = getelementptr inbounds i32, i32* %0, i64 %40
store i32 %50, i32* %51
%52 = add nsw i64 %40, 1
%53 = icmp eq i64 %52, %9
br i1 %53, label %54, label %39
54: ; preds = %39, %35, %5
ret void
}