float dscf_line(search, where, params, n, what, whom)
int n;
float search[], params[], *where[];
float (*what)();
void *whom;
{
  float beststep, step, dstep, myval, bestval;
  float steps[100], vals[100];
  int inbuf;
  int nfunc;
  int i, irun, itry;
  inbuf = 1;
  steps[0] = 0.;
  vals[0] = (*what)(whom);
  bestval = vals[0];
  nfunc = 1;
  step = 0.;
  beststep = step;
  dstep = 1.;
  dstep = .1;
  for (itry = 0; itry < 10; itry++) {
    for (irun = 0; irun < 10; irun++) {
      step += dstep;
      for (i = 0; i < inbuf; i++) {
        if (step == steps[i]) {
          myval = vals[i];
          goto STEP_FOUND;
        }
      }
      for (i = 0; i < n; i++) {
        *where[i] = params[i] + search[i] * step;
      }
      myval = (*what)(whom);
      nfunc++;
      if (inbuf == 100)
        return beststep;
      assert(inbuf < 100);
      if (inbuf < 100) {
        vals[inbuf] = myval;
        steps[inbuf++] = step;
      } else {
        inbuf -= 10;
      }
    STEP_FOUND:
      if (myval >= bestval) {
        step -= dstep;
        dstep = -dstep * .5;
        break;
      } else {
        bestval = myval;
        beststep = step;
      }
    }
  }
  for (i = 0; i < n; i++) {
    *where[i] = params[i] + search[i] * beststep;
  }
  printf("%d function calls \n", nfunc);
  return beststep;
}


x86 assembly (clang, -O0):
<dscf_line>:
push   %rbp
mov    %rsp,%rbp
sub    $0x390,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movl   $0x1,-0x374(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1e0(%rbp)
ff
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
movss  %xmm0,-0x370(%rbp)
ff
movss  -0x370(%rbp),%xmm0
ff
movss  %xmm0,-0x4c(%rbp)
movl   $0x1,-0x378(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  0xe68(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0xe57(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x0,-0x384(%rbp)
cmpl   $0xa,-0x384(%rbp)
jge    140d <dscf_line+0x2ed>
movl   $0x0,-0x380(%rbp)
cmpl   $0xa,-0x380(%rbp)
jge    13f4 <dscf_line+0x2d4>
movss  -0x44(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x0,-0x37c(%rbp)
mov    -0x37c(%rbp),%eax
cmp    -0x374(%rbp),%eax
jge    125a <dscf_line+0x13a>
movss  -0x40(%rbp),%xmm0
movslq -0x37c(%rbp),%rax
ucomiss -0x1e0(%rbp,%rax,4),%xmm0
ff
jne    1241 <dscf_line+0x121>
jp     1241 <dscf_line+0x121>
movslq -0x37c(%rbp),%rax
movss  -0x370(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x48(%rbp)
jmp    1375 <dscf_line+0x255>
jmp    1246 <dscf_line+0x126>
mov    -0x37c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x37c(%rbp)
jmp    11f5 <dscf_line+0xd5>
movl   $0x0,-0x37c(%rbp)
mov    -0x37c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12c7 <dscf_line+0x1a7>
mov    -0x20(%rbp),%rax
movslq -0x37c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x37c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x37c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,(%rax)
mov    -0x37c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x37c(%rbp)
jmp    1264 <dscf_line+0x144>
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
movss  %xmm0,-0x48(%rbp)
mov    -0x378(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x378(%rbp)
cmpl   $0x64,-0x374(%rbp)
jne    1303 <dscf_line+0x1e3>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    1498 <dscf_line+0x378>
cmpl   $0x64,-0x374(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
cmpl   $0x64,-0x374(%rbp)
jge    1361 <dscf_line+0x241>
movss  -0x48(%rbp),%xmm0
movslq -0x374(%rbp),%rax
movss  %xmm0,-0x370(%rbp,%rax,4)
ff ff
movss  -0x40(%rbp),%xmm0
mov    -0x374(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x374(%rbp)
cltq
movss  %xmm0,-0x1e0(%rbp,%rax,4)
ff ff
jmp    1370 <dscf_line+0x250>
mov    -0x374(%rbp),%eax
sub    $0xa,%eax
mov    %eax,-0x374(%rbp)
jmp    1375 <dscf_line+0x255>
movss  -0x48(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jb     13c7 <dscf_line+0x2a7>
movss  -0x44(%rbp),%xmm1
movss  -0x40(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc53(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
jmp    13f4 <dscf_line+0x2d4>
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    13e0 <dscf_line+0x2c0>
mov    -0x380(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x380(%rbp)
jmp    11cf <dscf_line+0xaf>
jmp    13f9 <dscf_line+0x2d9>
mov    -0x384(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x384(%rbp)
jmp    11b8 <dscf_line+0x98>
movl   $0x0,-0x37c(%rbp)
mov    -0x37c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    147a <dscf_line+0x35a>
mov    -0x20(%rbp),%rax
movslq -0x37c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x37c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x37c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,(%rax)
mov    -0x37c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x37c(%rbp)
jmp    1417 <dscf_line+0x2f7>
mov    -0x378(%rbp),%esi
lea    0xb89(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0x390,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dscf_line>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x368,%rsp
mov    %ecx,%ebp
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%rbx
movl   $0x0,0x1d0(%rsp)
mov    %r9,0x38(%rsp)
mov    %r9,%rdi
xor    %eax,%eax
mov    %r8,0x30(%rsp)
call   *%r8
movss  %xmm0,0x40(%rsp)
mov    %ebp,0xc(%rsp)
mov    %ebp,%r12d
lea    -0x1(%r12),%rax
mov    %rax,0x28(%rsp)
mov    %r12,0x20(%rsp)
and    $0xfffffffe,%r12d
xorps  %xmm2,%xmm2
movss  0xe7c(%rip),%xmm1
movss  %xmm1,0x4(%rsp)
movl   $0x1,0x10(%rsp)
xor    %eax,%eax
mov    $0x1,%r13d
xorps  %xmm1,%xmm1
jmp    11c8 <dscf_line+0xa8>
nop
movss  0x4(%rsp),%xmm3
subss  %xmm3,%xmm2
mulss  0xe52(%rip),%xmm3
movss  %xmm3,0x4(%rsp)
mov    0x8(%rsp),%eax
add    $0x1,%eax
cmp    $0xa,%eax
je     136b <dscf_line+0x24b>
mov    %eax,0x8(%rsp)
xor    %ebp,%ebp
xchg   %ax,%ax
addss  0x4(%rsp),%xmm2
test   %r13d,%r13d
jle    11f9 <dscf_line+0xd9>
mov    %r13d,%eax
xor    %ecx,%ecx
ucomiss 0x1d0(%rsp,%rcx,4),%xmm2
jne    11f0 <dscf_line+0xd0>
jnp    1320 <dscf_line+0x200>
add    $0x1,%rcx
cmp    %rcx,%rax
jne    11e0 <dscf_line+0xc0>
movss  %xmm0,0x1c(%rsp)
movss  %xmm1,(%rsp)
cmpl   $0x0,0xc(%rsp)
jle    1278 <dscf_line+0x158>
cmpq   $0x0,0x28(%rsp)
je     1343 <dscf_line+0x223>
xor    %eax,%eax
nopl   0x0(%rax)
movss  (%rbx,%rax,4),%xmm0
mulss  %xmm2,%xmm0
addss  (%r14,%rax,4),%xmm0
mov    (%r15,%rax,8),%rcx
movss  %xmm0,(%rcx)
movss  0x4(%rbx,%rax,4),%xmm0
mulss  %xmm2,%xmm0
addss  0x4(%r14,%rax,4),%xmm0
mov    0x8(%r15,%rax,8),%rcx
movss  %xmm0,(%rcx)
add    $0x2,%rax
cmp    %rax,%r12
jne    1220 <dscf_line+0x100>
testb  $0x1,0x20(%rsp)
je     1278 <dscf_line+0x158>
movss  (%rbx,%rax,4),%xmm0
mulss  %xmm2,%xmm0
addss  (%r14,%rax,4),%xmm0
mov    (%r15,%rax,8),%rax
movss  %xmm0,(%rax)
movss  %xmm2,0x18(%rsp)
mov    0x38(%rsp),%rdi
xor    %eax,%eax
call   *0x30(%rsp)
addl   $0x1,0x10(%rsp)
cmp    $0x64,%r13d
je     13ff <dscf_line+0x2df>
movss  %xmm0,0x14(%rsp)
setl   %al
movzbl %al,%edi
xor    %eax,%eax
call   1040 <assert@plt>
cmp    $0x63,%r13d
jg     12f0 <dscf_line+0x1d0>
movslq %r13d,%rax
movss  0x14(%rsp),%xmm3
movss  %xmm3,0x40(%rsp,%rax,4)
add    $0x1,%r13d
movss  0x18(%rsp),%xmm2
movss  %xmm2,0x1d0(%rsp,%rax,4)
movss  (%rsp),%xmm1
movss  0x1c(%rsp),%xmm0
ucomiss %xmm0,%xmm3
jb     132f <dscf_line+0x20f>
jmp    11a0 <dscf_line+0x80>
nopl   0x0(%rax,%rax,1)
add    $0xfffffff6,%r13d
movss  (%rsp),%xmm1
movss  0x1c(%rsp),%xmm0
movss  0x18(%rsp),%xmm2
movss  0x14(%rsp),%xmm3
ucomiss %xmm0,%xmm3
jb     132f <dscf_line+0x20f>
jmp    11a0 <dscf_line+0x80>
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x40(%rsp,%rcx,4),%xmm3
ucomiss %xmm0,%xmm3
jae    11a0 <dscf_line+0x80>
add    $0x1,%ebp
movaps %xmm3,%xmm0
movaps %xmm2,%xmm1
cmp    $0xa,%ebp
jne    11d0 <dscf_line+0xb0>
jmp    1360 <dscf_line+0x240>
xor    %eax,%eax
testb  $0x1,0x20(%rsp)
jne    1261 <dscf_line+0x141>
jmp    1278 <dscf_line+0x158>
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm2,%xmm1
movaps %xmm3,%xmm0
jmp    11b8 <dscf_line+0x98>
cmpl   $0x0,0xc(%rsp)
jle    13e8 <dscf_line+0x2c8>
cmpq   $0x0,0x28(%rsp)
je     1416 <dscf_line+0x2f6>
mov    0x20(%rsp),%rcx
and    $0xfffffffe,%ecx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rax,4),%xmm0
mulss  %xmm1,%xmm0
addss  (%r14,%rax,4),%xmm0
mov    (%r15,%rax,8),%rdx
movss  %xmm0,(%rdx)
movss  0x4(%rbx,%rax,4),%xmm0
mulss  %xmm1,%xmm0
addss  0x4(%r14,%rax,4),%xmm0
mov    0x8(%r15,%rax,8),%rdx
movss  %xmm0,(%rdx)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1390 <dscf_line+0x270>
testb  $0x1,0x20(%rsp)
je     13e8 <dscf_line+0x2c8>
movss  (%rbx,%rax,4),%xmm0
mulss  %xmm1,%xmm0
addss  (%r14,%rax,4),%xmm0
mov    (%r15,%rax,8),%rax
movss  %xmm0,(%rax)
lea    0xc19(%rip),%rdi
mov    0x10(%rsp),%esi
xor    %eax,%eax
movss  %xmm1,(%rsp)
call   1030 <printf@plt>
movss  (%rsp),%xmm0
add    $0x368,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
testb  $0x1,0x20(%rsp)
jne    13d1 <dscf_line+0x2b1>
jmp    13e8 <dscf_line+0x2c8>

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

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