#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 */
char get_line_intersection(float p0_x, float p0_y, float p1_x, float p1_y,
                           float p2_x, float p2_y, float p3_x, float p3_y,
                           float *i_x, float *i_y) {
  float s1_x, s1_y, s2_x, s2_y;
  s1_x = p1_x - p0_x;
  s1_y = p1_y - p0_y;
  s2_x = p3_x - p2_x;
  s2_y = p3_y - p2_y;
  float s, t;
  s = (-s1_y * (p0_x - p2_x) + s1_x * (p0_y - p2_y)) /
      (-s2_x * s1_y + s1_x * s2_y);
  t = (s2_x * (p0_y - p2_y) - s2_y * (p0_x - p2_x)) /
      (-s2_x * s1_y + s1_x * s2_y);
  if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
    if (i_x != NULL) {
      *i_x = p0_x + (t * s1_x);
    }
    if (i_y != NULL) {
      *i_y = p0_y + (t * s1_y);
    }
    return 1;
  }
  return 0;
}


x86 assembly (clang, -O0):
<get_line_intersection>:
push   %rbp
mov    %rsp,%rbp
movss  %xmm0,-0x8(%rbp)
movss  %xmm1,-0xc(%rbp)
movss  %xmm2,-0x10(%rbp)
movss  %xmm3,-0x14(%rbp)
movss  %xmm4,-0x18(%rbp)
movss  %xmm5,-0x1c(%rbp)
movss  %xmm6,-0x20(%rbp)
movss  %xmm7,-0x24(%rbp)
mov    %rdi,-0x30(%rbp)
mov    %rsi,-0x38(%rbp)
movss  -0x10(%rbp),%xmm0
subss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x14(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x24(%rbp),%xmm0
subss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x8(%rbp),%xmm2
subss  -0x18(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
movss  -0xc(%rbp),%xmm3
subss  -0x1c(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x44(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x40(%rbp),%xmm3
movss  -0x3c(%rbp),%xmm2
mulss  -0x48(%rbp),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
subss  -0x1c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
movss  -0x8(%rbp),%xmm3
subss  -0x18(%rbp),%xmm3
mulss  %xmm3,%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x44(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x40(%rbp),%xmm3
movss  -0x3c(%rbp),%xmm2
mulss  -0x48(%rbp),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x4c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     12e5 <get_line_intersection+0x1e5>
movss  0xda5(%rip),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jb     12e5 <get_line_intersection+0x1e5>
movss  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     12e5 <get_line_intersection+0x1e5>
movss  0xd82(%rip),%xmm0
ucomiss -0x50(%rbp),%xmm0
jb     12e5 <get_line_intersection+0x1e5>
cmpq   $0x0,-0x30(%rbp)
je     12b2 <get_line_intersection+0x1b2>
movss  -0x8(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
cmpq   $0x0,-0x38(%rbp)
je     12dc <get_line_intersection+0x1dc>
movss  -0xc(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
movb   $0x1,-0x1(%rbp)
jmp    12e9 <get_line_intersection+0x1e9>
movb   $0x0,-0x1(%rbp)
movsbl -0x1(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_line_intersection>:
subss  %xmm4,%xmm6
subss  %xmm5,%xmm7
movaps %xmm1,%xmm8
unpcklps %xmm3,%xmm8
unpcklps %xmm1,%xmm5
subps  %xmm5,%xmm8
movaps %xmm0,%xmm5
unpcklps %xmm2,%xmm5
unpcklps %xmm0,%xmm4
subps  %xmm4,%xmm5
movaps %xmm5,%xmm9
shufps $0x55,%xmm5,%xmm9
movaps %xmm9,%xmm2
mulss  %xmm8,%xmm2
movaps 0xec4(%rip),%xmm4
movaps %xmm6,%xmm3
xorps  %xmm4,%xmm3
unpcklps %xmm3,%xmm6
mulps  %xmm8,%xmm6
shufps $0x55,%xmm8,%xmm8
movaps %xmm8,%xmm3
mulss  %xmm5,%xmm3
subss  %xmm3,%xmm2
xorps  %xmm7,%xmm4
unpcklps %xmm7,%xmm4
mulps  %xmm5,%xmm4
addps  %xmm4,%xmm6
movlhps %xmm6,%xmm2
shufps $0xe2,%xmm6,%xmm2
shufps $0x55,%xmm6,%xmm6
divps  %xmm6,%xmm2
xorps  %xmm3,%xmm3
cmpleps %xmm2,%xmm3
unpcklps %xmm3,%xmm3
movmskpd %xmm3,%ecx
xor    %eax,%eax
test   $0x2,%cl
je     11cf <get_line_intersection+0xcf>
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
movss  0xe78(%rip),%xmm5
ucomiss %xmm3,%xmm5
jb     11cf <get_line_intersection+0xcf>
test   $0x1,%cl
je     11cf <get_line_intersection+0xcf>
ucomiss %xmm2,%xmm5
jb     11cf <get_line_intersection+0xcf>
test   %rdi,%rdi
je     11bb <get_line_intersection+0xbb>
mulss  %xmm2,%xmm9
addss  %xmm0,%xmm9
movss  %xmm9,(%rdi)
mov    $0x1,%al
test   %rsi,%rsi
je     11cf <get_line_intersection+0xcf>
mulss  %xmm8,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rsi)
ret

LLVM IR (-O0):
define signext i8 @get_line_intersection(float %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float* %8, float* %9) {
%11 = alloca i8
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float*
%21 = alloca float*
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
store float %0, float* %12
store float %1, float* %13
store float %2, float* %14
store float %3, float* %15
store float %4, float* %16
store float %5, float* %17
store float %6, float* %18
store float %7, float* %19
store float* %8, float** %20
store float* %9, float** %21
%28 = load float, float* %14
%29 = load float, float* %12
%30 = fsub float %28, %29
store float %30, float* %22
%31 = load float, float* %15
%32 = load float, float* %13
%33 = fsub float %31, %32
store float %33, float* %23
%34 = load float, float* %18
%35 = load float, float* %16
%36 = fsub float %34, %35
store float %36, float* %24
%37 = load float, float* %19
%38 = load float, float* %17
%39 = fsub float %37, %38
store float %39, float* %25
%40 = load float, float* %23
%41 = fneg float %40
%42 = load float, float* %12
%43 = load float, float* %16
%44 = fsub float %42, %43
%45 = load float, float* %22
%46 = load float, float* %13
%47 = load float, float* %17
%48 = fsub float %46, %47
%49 = fmul float %45, %48
%50 = call float @llvm.fmuladd.f32(float %41, float %44, float %49)
%51 = load float, float* %24
%52 = fneg float %51
%53 = load float, float* %23
%54 = load float, float* %22
%55 = load float, float* %25
%56 = fmul float %54, %55
%57 = call float @llvm.fmuladd.f32(float %52, float %53, float %56)
%58 = fdiv float %50, %57
store float %58, float* %26
%59 = load float, float* %24
%60 = load float, float* %13
%61 = load float, float* %17
%62 = fsub float %60, %61
%63 = load float, float* %25
%64 = load float, float* %12
%65 = load float, float* %16
%66 = fsub float %64, %65
%67 = fmul float %63, %66
%68 = fneg float %67
%69 = call float @llvm.fmuladd.f32(float %59, float %62, float %68)
%70 = load float, float* %24
%71 = fneg float %70
%72 = load float, float* %23
%73 = load float, float* %22
%74 = load float, float* %25
%75 = fmul float %73, %74
%76 = call float @llvm.fmuladd.f32(float %71, float %72, float %75)
%77 = fdiv float %69, %76
store float %77, float* %27
%78 = load float, float* %26
%79 = fcmp oge float %78, 0.000000e+00
br i1 %79, label %80, label %108
80: ; preds = %10
%81 = load float, float* %26
%82 = fcmp ole float %81, 1.000000e+00
br i1 %82, label %83, label %108
83: ; preds = %80
%84 = load float, float* %27
%85 = fcmp oge float %84, 0.000000e+00
br i1 %85, label %86, label %108
86: ; preds = %83
%87 = load float, float* %27
%88 = fcmp ole float %87, 1.000000e+00
br i1 %88, label %89, label %108
89: ; preds = %86
%90 = load float*, float** %20
%91 = icmp ne float* %90, null
br i1 %91, label %92, label %98
92: ; preds = %89
%93 = load float, float* %12
%94 = load float, float* %27
%95 = load float, float* %22
%96 = call float @llvm.fmuladd.f32(float %94, float %95, float %93)
%97 = load float*, float** %20
store float %96, float* %97
br label %98
98: ; preds = %92, %89
%99 = load float*, float** %21
%100 = icmp ne float* %99, null
br i1 %100, label %101, label %107
101: ; preds = %98
%102 = load float, float* %13
%103 = load float, float* %27
%104 = load float, float* %23
%105 = call float @llvm.fmuladd.f32(float %103, float %104, float %102)
%106 = load float*, float** %21
store float %105, float* %106
br label %107
107: ; preds = %101, %98
store i8 1, i8* %11
br label %109
108: ; preds = %86, %83, %80, %10
store i8 0, i8* %11
br label %109
109: ; preds = %108, %107
%110 = load i8, i8* %11
ret i8 %110
}

LLVM IR (-O2):
define signext i8 @get_line_intersection(float %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float* writeonly %8, float* writeonly %9) {
%11 = fsub float %6, %4
%12 = fsub float %7, %5
%13 = insertelement <2 x float> poison, float %1, i64 0
%14 = insertelement <2 x float> %13, float %3, i64 1
%15 = insertelement <2 x float> poison, float %5, i64 0
%16 = insertelement <2 x float> %15, float %1, i64 1
%17 = fsub <2 x float> %14, %16
%18 = extractelement <2 x float> %17, i64 1
%19 = fneg float %18
%20 = insertelement <2 x float> poison, float %0, i64 0
%21 = insertelement <2 x float> %20, float %2, i64 1
%22 = insertelement <2 x float> poison, float %4, i64 0
%23 = insertelement <2 x float> %22, float %0, i64 1
%24 = fsub <2 x float> %21, %23
%25 = extractelement <2 x float> %17, i64 0
%26 = extractelement <2 x float> %24, i64 1
%27 = fmul float %26, %25
%28 = extractelement <2 x float> %24, i64 0
%29 = tail call float @llvm.fmuladd.f32(float %19, float %28, float %27)
%30 = fneg float %11
%31 = fneg float %12
%32 = insertelement <2 x float> poison, float %31, i64 0
%33 = insertelement <2 x float> %32, float %12, i64 1
%34 = fmul <2 x float> %24, %33
%35 = insertelement <2 x float> poison, float %11, i64 0
%36 = insertelement <2 x float> %35, float %30, i64 1
%37 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %36, <2 x float> %17, <2 x float> %34)
%38 = insertelement <2 x float> %37, float %29, i64 1
%39 = shufflevector <2 x float> %37, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%40 = fdiv <2 x float> %38, %39
%41 = extractelement <2 x float> %40, i64 1
%42 = fcmp ole float %41, 1.000000e+00
%43 = fcmp oge <2 x float> %40, zeroinitializer
%44 = extractelement <2 x i1> %43, i64 1
%45 = and i1 %44, %42
%46 = extractelement <2 x i1> %43, i64 0
%47 = select i1 %45, i1 %46, i1 false
%48 = extractelement <2 x float> %40, i64 0
%49 = fcmp ole float %48, 1.000000e+00
%50 = select i1 %47, i1 %49, i1 false
br i1 %50, label %51, label %59
51: ; preds = %10
%52 = icmp eq float* %8, null
br i1 %52, label %55, label %53
53: ; preds = %51
%54 = tail call float @llvm.fmuladd.f32(float %48, float %26, float %0)
store float %54, float* %8
br label %55
55: ; preds = %53, %51
%56 = icmp eq float* %9, null
br i1 %56, label %59, label %57
57: ; preds = %55
%58 = tail call float @llvm.fmuladd.f32(float %48, float %18, float %1)
store float %58, float* %9
br label %59
59: ; preds = %10, %55, %57
%60 = phi i8 [ 1, %57 ], [ 1, %55 ], [ 0, %10 ]
ret i8 %60
}