#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 */
float bezier(float, float, float, float, float);
float fabs(float);
float bez2_time(float x0, float x1, float x2, float x3, float time, float *t0,
                float *t1) {
  float v, t;
  t = *t0 + (*t1 - *t0) * 0.5f;
  v = bezier(x0, x1, x2, x3, t);
  if (fabs(time - v) > .0001f) {
    if (v > time) {
      *t1 = t;
    } else {
      *t0 = t;
    }
    return bez2_time(x0, x1, x2, x3, time, t0, t1);
  } else {
    return t;
  }
}


x86 assembly (clang, -O0):
<bez2_time>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movss  %xmm0,-0x8(%rbp)
movss  %xmm1,-0xc(%rbp)
movss  %xmm2,-0x10(%rbp)
movss  %xmm3,-0x14(%rbp)
movss  %xmm4,-0x18(%rbp)
mov    %rdi,-0x20(%rbp)
mov    %rsi,-0x28(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subss  (%rax),%xmm0
movss  0xe8b(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x8(%rbp),%xmm0
movss  -0xc(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0x14(%rbp),%xmm3
movss  -0x30(%rbp),%xmm4
call   1030 <bezier@plt>
movss  %xmm0,-0x2c(%rbp)
movss  -0x18(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
call   1040 <fabs@plt>
movss  0xe40(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    1227 <bez2_time+0xf7>
movss  -0x2c(%rbp),%xmm0
ucomiss -0x18(%rbp),%xmm0
jbe    11ea <bez2_time+0xba>
movss  -0x30(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
jmp    11f7 <bez2_time+0xc7>
movss  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x8(%rbp),%xmm0
movss  -0xc(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0x14(%rbp),%xmm3
movss  -0x18(%rbp),%xmm4
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1050 <bez2_time@plt>
movss  %xmm0,-0x4(%rbp)
jmp    1231 <bez2_time+0x101>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bez2_time>:
push   %r14
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
movss  %xmm4,0x4(%rsp)
movss  (%rdi),%xmm5
movss  (%rsi),%xmm4
subss  %xmm5,%xmm4
mulss  0xec9(%rip),%xmm4
addss  %xmm5,%xmm4
movss  %xmm0,0x8(%rsp)
movss  %xmm1,0xc(%rsp)
movss  %xmm2,0x10(%rsp)
movss  %xmm3,0x14(%rsp)
jmp    1191 <bez2_time+0x81>
cs nopw 0x0(%rax,%rax,1)
nop
movss  %xmm4,(%rbx)
movss  (%r14),%xmm0
subss  %xmm4,%xmm0
mulss  0xe8b(%rip),%xmm0
addss  %xmm0,%xmm4
movss  0x8(%rsp),%xmm0
movss  0xc(%rsp),%xmm1
movss  0x10(%rsp),%xmm2
movss  0x14(%rsp),%xmm3
movss  %xmm4,(%rsp)
call   1030 <bezier@plt>
movss  0x4(%rsp),%xmm2
movaps %xmm2,%xmm1
subss  %xmm0,%xmm1
andps  0xe61(%rip),%xmm1
ucomiss 0xe4e(%rip),%xmm1
jbe    11d0 <bez2_time+0xc0>
ucomiss %xmm2,%xmm0
movss  (%rsp),%xmm4
jbe    1160 <bez2_time+0x50>
movss  %xmm4,(%r14)
movaps %xmm4,%xmm0
movss  (%rbx),%xmm4
jmp    1169 <bez2_time+0x59>
movss  (%rsp),%xmm0
add    $0x18,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define float @bez2_time(float %0, float %1, float %2, float %3, float %4, float* %5, float* %6) {
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float*
%15 = alloca float*
%16 = alloca float
%17 = alloca float
store float %0, float* %9
store float %1, float* %10
store float %2, float* %11
store float %3, float* %12
store float %4, float* %13
store float* %5, float** %14
store float* %6, float** %15
%18 = load float*, float** %14
%19 = load float, float* %18
%20 = load float*, float** %15
%21 = load float, float* %20
%22 = load float*, float** %14
%23 = load float, float* %22
%24 = fsub float %21, %23
%25 = call float @llvm.fmuladd.f32(float %24, float 5.000000e-01, float %19)
store float %25, float* %17
%26 = load float, float* %9
%27 = load float, float* %10
%28 = load float, float* %11
%29 = load float, float* %12
%30 = load float, float* %17
%31 = call float @bezier(float %26, float %27, float %28, float %29, float %30)
store float %31, float* %16
%32 = load float, float* %13
%33 = load float, float* %16
%34 = fsub float %32, %33
%35 = call float @fabs(float %34)
%36 = fcmp ogt float %35, 0x3F1A36E2E0000000
br i1 %36, label %37, label %56
37: ; preds = %7
%38 = load float, float* %16
%39 = load float, float* %13
%40 = fcmp ogt float %38, %39
br i1 %40, label %41, label %44
41: ; preds = %37
%42 = load float, float* %17
%43 = load float*, float** %15
store float %42, float* %43
br label %47
44: ; preds = %37
%45 = load float, float* %17
%46 = load float*, float** %14
store float %45, float* %46
br label %47
47: ; preds = %44, %41
%48 = load float, float* %9
%49 = load float, float* %10
%50 = load float, float* %11
%51 = load float, float* %12
%52 = load float, float* %13
%53 = load float*, float** %14
%54 = load float*, float** %15
%55 = call float @bez2_time(float %48, float %49, float %50, float %51, float %52, float* %53, float* %54)
store float %55, float* %8
br label %58
56: ; preds = %7
%57 = load float, float* %17
store float %57, float* %8
br label %58
58: ; preds = %56, %47
%59 = load float, float* %8
ret float %59
}

LLVM IR (-O2):
define float @bez2_time(float %0, float %1, float %2, float %3, float %4, float* nocapture %5, float* nocapture %6) {
%8 = load float, float* %5
%9 = load float, float* %6
%10 = fsub float %9, %8
%11 = tail call float @llvm.fmuladd.f32(float %10, float 5.000000e-01, float %8)
%12 = tail call float @bezier(float %0, float %1, float %2, float %3, float %11)
%13 = fsub float %4, %12
%14 = tail call float @llvm.fabs.f32(float %13)
%15 = fcmp ogt float %14, 0x3F1A36E2E0000000
br i1 %15, label %16, label %33
16: ; preds = %7, %24
%17 = phi float [ %29, %24 ], [ %12, %7 ]
%18 = phi float [ %28, %24 ], [ %11, %7 ]
%19 = fcmp ogt float %17, %4
br i1 %19, label %20, label %22
20: ; preds = %16
store float %18, float* %6
%21 = load float, float* %5
br label %24
22: ; preds = %16
store float %18, float* %5
%23 = load float, float* %6
br label %24
24: ; preds = %22, %20
%25 = phi float [ %23, %22 ], [ %18, %20 ]
%26 = phi float [ %18, %22 ], [ %21, %20 ]
%27 = fsub float %25, %26
%28 = tail call float @llvm.fmuladd.f32(float %27, float 5.000000e-01, float %26)
%29 = tail call float @bezier(float %0, float %1, float %2, float %3, float %28)
%30 = fsub float %4, %29
%31 = tail call float @llvm.fabs.f32(float %30)
%32 = fcmp ogt float %31, 0x3F1A36E2E0000000
br i1 %32, label %16, label %33
33: ; preds = %24, %7
%34 = phi float [ %11, %7 ], [ %28, %24 ]
ret float %34
}