; LLVM IR from erincatto/box2d :: src (geometry)

; Unoptimized IR (clang -disable-llvm-passes):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%struct.b2CastOutput = type { %struct.b2Vec2, %struct.b2Vec2, float, i32, i8 }
%struct.b2Vec2 = type { float, float }
%struct.b2Circle = type { %struct.b2Vec2, float }
%struct.b2Capsule = type { %struct.b2Vec2, %struct.b2Vec2, float }
%struct.b2RayCastInput = type { %struct.b2Vec2, %struct.b2Vec2, float }

@.str.1 = external hidden unnamed_addr constant [64 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [22 x i8], align 1

; Function Attrs: nounwind uwtable
declare dso_local zeroext i1 @b2IsValidRay(ptr noundef) #0

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #1

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #1

declare i32 @b2InternalAssertFcn(ptr noundef, ptr noundef, i32 noundef) #2

; Function Attrs: cold noreturn nounwind memory(inaccessiblemem: write)
declare void @llvm.trap() #3

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #4

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #5

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2Sub(<2 x float>, <2 x float>) #6

; Function Attrs: inlinehint nounwind uwtable
declare hidden float @b2Dot(<2 x float>, <2 x float>) #6

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #7

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2Add(<2 x float>, <2 x float>) #6

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2MulAdd(<2 x float>, float noundef, <2 x float>) #6

; Function Attrs: nounwind uwtable
declare dso_local void @b2RayCastCircle(ptr dead_on_unwind noalias writable sret(%struct.b2CastOutput) align 4, ptr noundef, ptr noundef) #0

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2GetLengthAndNormalize(ptr noundef, <2 x float>) #6

; Function Attrs: nounwind uwtable
define dso_local void @b2RayCastCapsule(ptr dead_on_unwind noalias writable sret(%struct.b2CastOutput) align 4 %0, ptr noundef %1, ptr noundef %2) #0 {
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  %6 = alloca %struct.b2CastOutput, align 4
  %7 = alloca %struct.b2Vec2, align 4
  %8 = alloca %struct.b2Vec2, align 4
  %9 = alloca %struct.b2Vec2, align 4
  %10 = alloca float, align 4
  %11 = alloca %struct.b2Vec2, align 4
  %12 = alloca %struct.b2Circle, align 4
  %13 = alloca i32, align 4
  %14 = alloca %struct.b2Vec2, align 4
  %15 = alloca %struct.b2Vec2, align 4
  %16 = alloca %struct.b2Vec2, align 4
  %17 = alloca float, align 4
  %18 = alloca %struct.b2Vec2, align 4
  %19 = alloca float, align 4
  %20 = alloca %struct.b2Circle, align 4
  %21 = alloca %struct.b2Circle, align 4
  %22 = alloca %struct.b2Vec2, align 4
  %23 = alloca float, align 4
  %24 = alloca %struct.b2Vec2, align 4
  %25 = alloca float, align 4
  %26 = alloca %struct.b2Vec2, align 4
  %27 = alloca %struct.b2Vec2, align 4
  %28 = alloca float, align 4
  %29 = alloca float, align 4
  %30 = alloca float, align 4
  %31 = alloca float, align 4
  %32 = alloca %struct.b2Vec2, align 4
  %33 = alloca %struct.b2Vec2, align 4
  %34 = alloca float, align 4
  %35 = alloca %struct.b2Circle, align 4
  %36 = alloca %struct.b2Circle, align 4
  %37 = alloca %struct.b2Vec2, align 4
  %38 = alloca %struct.b2Vec2, align 4
  %39 = alloca %struct.b2Vec2, align 4
  store ptr %1, ptr %4, align 8, !tbaa !5
  store ptr %2, ptr %5, align 8, !tbaa !5
  br label %40

40:                                               ; preds = %3
  %41 = load ptr, ptr %4, align 8, !tbaa !5
  %42 = call zeroext i1 @b2IsValidRay(ptr noundef %41)
  br i1 %42, label %47, label %43

43:                                               ; preds = %40
  %44 = call i32 @b2InternalAssertFcn(ptr noundef @.str.8, ptr noundef @.str.1, i32 noundef 566)
  %45 = icmp ne i32 %44, 0
  br i1 %45, label %46, label %47

46:                                               ; preds = %43
  call void @llvm.trap()
  br label %47

47:                                               ; preds = %46, %43, %40
  br label %48

48:                                               ; preds = %47
  call void @llvm.lifetime.start.p0(i64 28, ptr %6) #8
  call void @llvm.memset.p0.i64(ptr align 4 %6, i8 0, i64 28, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #8
  %49 = load ptr, ptr %5, align 8, !tbaa !5
  %50 = getelementptr inbounds %struct.b2Capsule, ptr %49, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %7, ptr align 4 %50, i64 8, i1 false), !tbaa.struct !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #8
  %51 = load ptr, ptr %5, align 8, !tbaa !5
  %52 = getelementptr inbounds %struct.b2Capsule, ptr %51, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %8, ptr align 4 %52, i64 8, i1 false), !tbaa.struct !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #8
  %53 = load <2 x float>, ptr %8, align 4
  %54 = load <2 x float>, ptr %7, align 4
  %55 = call <2 x float> @b2Sub(<2 x float> %53, <2 x float> %54)
  store <2 x float> %55, ptr %9, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #8
  %56 = load <2 x float>, ptr %9, align 4
  %57 = call <2 x float> @b2GetLengthAndNormalize(ptr noundef %10, <2 x float> %56)
  store <2 x float> %57, ptr %11, align 4
  %58 = load float, ptr %10, align 4, !tbaa !10
  %59 = fcmp olt float %58, 0x3E80000000000000
  br i1 %59, label %60, label %67

60:                                               ; preds = %48
  call void @llvm.lifetime.start.p0(i64 12, ptr %12) #8
  %61 = getelementptr inbounds %struct.b2Circle, ptr %12, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %61, ptr align 4 %7, i64 8, i1 false), !tbaa.struct !9
  %62 = getelementptr inbounds %struct.b2Circle, ptr %12, i32 0, i32 1
  %63 = load ptr, ptr %5, align 8, !tbaa !5
  %64 = getelementptr inbounds %struct.b2Capsule, ptr %63, i32 0, i32 2
  %65 = load float, ptr %64, align 4, !tbaa !12
  store float %65, ptr %62, align 4, !tbaa !15
  %66 = load ptr, ptr %4, align 8, !tbaa !5
  call void @b2RayCastCircle(ptr dead_on_unwind writable sret(%struct.b2CastOutput) align 4 %0, ptr noundef %66, ptr noundef %12)
  store i32 1, ptr %13, align 4
  call void @llvm.lifetime.end.p0(i64 12, ptr %12) #8
  br label %259

67:                                               ; preds = %48
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #8
  %68 = load ptr, ptr %4, align 8, !tbaa !5
  %69 = getelementptr inbounds %struct.b2RayCastInput, ptr %68, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %14, ptr align 4 %69, i64 8, i1 false), !tbaa.struct !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #8
  %70 = load ptr, ptr %4, align 8, !tbaa !5
  %71 = getelementptr inbounds %struct.b2RayCastInput, ptr %70, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %15, ptr align 4 %71, i64 8, i1 false), !tbaa.struct !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #8
  %72 = load <2 x float>, ptr %14, align 4
  %73 = load <2 x float>, ptr %7, align 4
  %74 = call <2 x float> @b2Sub(<2 x float> %72, <2 x float> %73)
  store <2 x float> %74, ptr %16, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #8
  %75 = load <2 x float>, ptr %16, align 4
  %76 = load <2 x float>, ptr %11, align 4
  %77 = call float @b2Dot(<2 x float> %75, <2 x float> %76)
  store float %77, ptr %17, align 4, !tbaa !10
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #8
  %78 = load float, ptr %17, align 4, !tbaa !10
  %79 = fneg float %78
  %80 = load <2 x float>, ptr %16, align 4
  %81 = load <2 x float>, ptr %11, align 4
  %82 = call <2 x float> @b2MulAdd(<2 x float> %80, float noundef %79, <2 x float> %81)
  store <2 x float> %82, ptr %18, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #8
  %83 = load ptr, ptr %5, align 8, !tbaa !5
  %84 = getelementptr inbounds %struct.b2Capsule, ptr %83, i32 0, i32 2
  %85 = load float, ptr %84, align 4, !tbaa !12
  store float %85, ptr %19, align 4, !tbaa !10
  %86 = load <2 x float>, ptr %18, align 4
  %87 = load <2 x float>, ptr %18, align 4
  %88 = call float @b2Dot(<2 x float> %86, <2 x float> %87)
  %89 = load float, ptr %19, align 4, !tbaa !10
  %90 = load float, ptr %19, align 4, !tbaa !10
  %91 = fmul float %89, %90
  %92 = fcmp olt float %88, %91
  br i1 %92, label %93, label %114

93:                                               ; preds = %67
  %94 = load float, ptr %17, align 4, !tbaa !10
  %95 = fcmp olt float %94, 0.000000e+00
  br i1 %95, label %96, label %103

96:                                               ; preds = %93
  call void @llvm.lifetime.start.p0(i64 12, ptr %20) #8
  %97 = getelementptr inbounds %struct.b2Circle, ptr %20, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %97, ptr align 4 %7, i64 8, i1 false), !tbaa.struct !9
  %98 = getelementptr inbounds %struct.b2Circle, ptr %20, i32 0, i32 1
  %99 = load ptr, ptr %5, align 8, !tbaa !5
  %100 = getelementptr inbounds %struct.b2Capsule, ptr %99, i32 0, i32 2
  %101 = load float, ptr %100, align 4, !tbaa !12
  store float %101, ptr %98, align 4, !tbaa !15
  %102 = load ptr, ptr %4, align 8, !tbaa !5
  call void @b2RayCastCircle(ptr dead_on_unwind writable sret(%struct.b2CastOutput) align 4 %0, ptr noundef %102, ptr noundef %20)
  store i32 1, ptr %13, align 4
  call void @llvm.lifetime.end.p0(i64 12, ptr %20) #8
  br label %258

103:                                              ; preds = %93
  %104 = load float, ptr %17, align 4, !tbaa !10
  %105 = fcmp ogt float %104, 1.000000e+00
  br i1 %105, label %106, label %113

106:                                              ; preds = %103
  call void @llvm.lifetime.start.p0(i64 12, ptr %21) #8
  %107 = getelementptr inbounds %struct.b2Circle, ptr %21, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %107, ptr align 4 %8, i64 8, i1 false), !tbaa.struct !9
  %108 = getelementptr inbounds %struct.b2Circle, ptr %21, i32 0, i32 1
  %109 = load ptr, ptr %5, align 8, !tbaa !5
  %110 = getelementptr inbounds %struct.b2Capsule, ptr %109, i32 0, i32 2
  %111 = load float, ptr %110, align 4, !tbaa !12
  store float %111, ptr %108, align 4, !tbaa !15
  %112 = load ptr, ptr %4, align 8, !tbaa !5
  call void @b2RayCastCircle(ptr dead_on_unwind writable sret(%struct.b2CastOutput) align 4 %0, ptr noundef %112, ptr noundef %21)
  store i32 1, ptr %13, align 4
  call void @llvm.lifetime.end.p0(i64 12, ptr %21) #8
  br label %258

113:                                              ; preds = %103
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 %6, i64 28, i1 false), !tbaa.struct !17
  store i32 1, ptr %13, align 4
  br label %258

114:                                              ; preds = %67
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #8
  %115 = getelementptr inbounds %struct.b2Vec2, ptr %22, i32 0, i32 0
  %116 = getelementptr inbounds %struct.b2Vec2, ptr %11, i32 0, i32 1
  %117 = load float, ptr %116, align 4, !tbaa !22
  store float %117, ptr %115, align 4, !tbaa !23
  %118 = getelementptr inbounds %struct.b2Vec2, ptr %22, i32 0, i32 1
  %119 = getelementptr inbounds %struct.b2Vec2, ptr %11, i32 0, i32 0
  %120 = load float, ptr %119, align 4, !tbaa !23
  %121 = fneg float %120
  store float %121, ptr %118, align 4, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #8
  %122 = load <2 x float>, ptr %15, align 4
  %123 = call <2 x float> @b2GetLengthAndNormalize(ptr noundef %23, <2 x float> %122)
  store <2 x float> %123, ptr %24, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #8
  %124 = getelementptr inbounds %struct.b2Vec2, ptr %11, i32 0, i32 0
  %125 = load float, ptr %124, align 4, !tbaa !23
  %126 = fneg float %125
  %127 = getelementptr inbounds %struct.b2Vec2, ptr %24, i32 0, i32 1
  %128 = load float, ptr %127, align 4, !tbaa !22
  %129 = getelementptr inbounds %struct.b2Vec2, ptr %24, i32 0, i32 0
  %130 = load float, ptr %129, align 4, !tbaa !23
  %131 = getelementptr inbounds %struct.b2Vec2, ptr %11, i32 0, i32 1
  %132 = load float, ptr %131, align 4, !tbaa !22
  %133 = fmul float %130, %132
  %134 = call float @llvm.fmuladd.f32(float %126, float %128, float %133)
  store float %134, ptr %25, align 4, !tbaa !10
  %135 = load float, ptr %25, align 4, !tbaa !10
  %136 = fcmp olt float 0xBE80000000000000, %135
  br i1 %136, label %137, label %141

137:                                              ; preds = %114
  %138 = load float, ptr %25, align 4, !tbaa !10
  %139 = fcmp olt float %138, 0x3E80000000000000
  br i1 %139, label %140, label %141

140:                                              ; preds = %137
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 %6, i64 28, i1 false), !tbaa.struct !17
  store i32 1, ptr %13, align 4
  br label %257

141:                                              ; preds = %137, %114
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #8
  %142 = load float, ptr %19, align 4, !tbaa !10
  %143 = load <2 x float>, ptr %16, align 4
  %144 = load <2 x float>, ptr %22, align 4
  %145 = call <2 x float> @b2MulSub(<2 x float> %143, float noundef %142, <2 x float> %144)
  store <2 x float> %145, ptr %26, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #8
  %146 = load float, ptr %19, align 4, !tbaa !10
  %147 = load <2 x float>, ptr %16, align 4
  %148 = load <2 x float>, ptr %22, align 4
  %149 = call <2 x float> @b2MulAdd(<2 x float> %147, float noundef %146, <2 x float> %148)
  store <2 x float> %149, ptr %27, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #8
  %150 = load float, ptr %25, align 4, !tbaa !10
  %151 = fdiv float 1.000000e+00, %150
  store float %151, ptr %28, align 4, !tbaa !10
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #8
  %152 = getelementptr inbounds %struct.b2Vec2, ptr %11, i32 0, i32 0
  %153 = load float, ptr %152, align 4, !tbaa !23
  %154 = getelementptr inbounds %struct.b2Vec2, ptr %26, i32 0, i32 1
  %155 = load float, ptr %154, align 4, !tbaa !22
  %156 = getelementptr inbounds %struct.b2Vec2, ptr %26, i32 0, i32 0
  %157 = load float, ptr %156, align 4, !tbaa !23
  %158 = getelementptr inbounds %struct.b2Vec2, ptr %11, i32 0, i32 1
  %159 = load float, ptr %158, align 4, !tbaa !22
  %160 = fmul float %157, %159
  %161 = fneg float %160
  %162 = call float @llvm.fmuladd.f32(float %153, float %155, float %161)
  %163 = load float, ptr %28, align 4, !tbaa !10
  %164 = fmul float %162, %163
  store float %164, ptr %29, align 4, !tbaa !10
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #8
  %165 = getelementptr inbounds %struct.b2Vec2, ptr %11, i32 0, i32 0
  %166 = load float, ptr %165, align 4, !tbaa !23
  %167 = getelementptr inbounds %struct.b2Vec2, ptr %27, i32 0, i32 1
  %168 = load float, ptr %167, align 4, !tbaa !22
  %169 = getelementptr inbounds %struct.b2Vec2, ptr %27, i32 0, i32 0
  %170 = load float, ptr %169, align 4, !tbaa !23
  %171 = getelementptr inbounds %struct.b2Vec2, ptr %11, i32 0, i32 1
  %172 = load float, ptr %171, align 4, !tbaa !22
  %173 = fmul float %170, %172
  %174 = fneg float %173
  %175 = call float @llvm.fmuladd.f32(float %166, float %168, float %174)
  %176 = load float, ptr %28, align 4, !tbaa !10
  %177 = fmul float %175, %176
  store float %177, ptr %30, align 4, !tbaa !10
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #8
  %178 = load float, ptr %29, align 4, !tbaa !10
  %179 = load float, ptr %30, align 4, !tbaa !10
  %180 = fcmp olt float %178, %179
  br i1 %180, label %181, label %183

181:                                              ; preds = %141
  %182 = load float, ptr %29, align 4, !tbaa !10
  store float %182, ptr %31, align 4, !tbaa !10
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %32, ptr align 4 %26, i64 8, i1 false), !tbaa.struct !9
  br label %187

183:                                              ; preds = %141
  %184 = load float, ptr %30, align 4, !tbaa !10
  store float %184, ptr %31, align 4, !tbaa !10
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %32, ptr align 4 %27, i64 8, i1 false), !tbaa.struct !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #8
  %185 = load <2 x float>, ptr %22, align 4
  %186 = call <2 x float> @b2Neg(<2 x float> %185)
  store <2 x float> %186, ptr %33, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %22, ptr align 4 %33, i64 8, i1 false), !tbaa.struct !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #8
  br label %187

187:                                              ; preds = %183, %181
  %188 = load float, ptr %31, align 4, !tbaa !10
  %189 = fcmp olt float %188, 0.000000e+00
  br i1 %189, label %198, label %190

190:                                              ; preds = %187
  %191 = load ptr, ptr %4, align 8, !tbaa !5
  %192 = getelementptr inbounds %struct.b2RayCastInput, ptr %191, i32 0, i32 2
  %193 = load float, ptr %192, align 4, !tbaa !24
  %194 = load float, ptr %23, align 4, !tbaa !10
  %195 = fmul float %193, %194
  %196 = load float, ptr %31, align 4, !tbaa !10
  %197 = fcmp olt float %195, %196
  br i1 %197, label %198, label %199

198:                                              ; preds = %190, %187
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 %6, i64 28, i1 false), !tbaa.struct !17
  store i32 1, ptr %13, align 4
  br label %256

199:                                              ; preds = %190
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #8
  %200 = getelementptr inbounds %struct.b2Vec2, ptr %32, i32 0, i32 0
  %201 = load float, ptr %200, align 4, !tbaa !23
  %202 = fneg float %201
  %203 = getelementptr inbounds %struct.b2Vec2, ptr %24, i32 0, i32 1
  %204 = load float, ptr %203, align 4, !tbaa !22
  %205 = getelementptr inbounds %struct.b2Vec2, ptr %24, i32 0, i32 0
  %206 = load float, ptr %205, align 4, !tbaa !23
  %207 = getelementptr inbounds %struct.b2Vec2, ptr %32, i32 0, i32 1
  %208 = load float, ptr %207, align 4, !tbaa !22
  %209 = fmul float %206, %208
  %210 = call float @llvm.fmuladd.f32(float %202, float %204, float %209)
  %211 = load float, ptr %28, align 4, !tbaa !10
  %212 = fmul float %210, %211
  store float %212, ptr %34, align 4, !tbaa !10
  %213 = load float, ptr %34, align 4, !tbaa !10
  %214 = fcmp olt float %213, 0.000000e+00
  br i1 %214, label %215, label %222

215:                                              ; preds = %199
  call void @llvm.lifetime.start.p0(i64 12, ptr %35) #8
  %216 = getelementptr inbounds %struct.b2Circle, ptr %35, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %216, ptr align 4 %7, i64 8, i1 false), !tbaa.struct !9
  %217 = getelementptr inbounds %struct.b2Circle, ptr %35, i32 0, i32 1
  %218 = load ptr, ptr %5, align 8, !tbaa !5
  %219 = getelementptr inbounds %struct.b2Capsule, ptr %218, i32 0, i32 2
  %220 = load float, ptr %219, align 4, !tbaa !12
  store float %220, ptr %217, align 4, !tbaa !15
  %221 = load ptr, ptr %4, align 8, !tbaa !5
  call void @b2RayCastCircle(ptr dead_on_unwind writable sret(%struct.b2CastOutput) align 4 %0, ptr noundef %221, ptr noundef %35)
  store i32 1, ptr %13, align 4
  call void @llvm.lifetime.end.p0(i64 12, ptr %35) #8
  br label %255

222:                                              ; preds = %199
  %223 = load float, ptr %10, align 4, !tbaa !10
  %224 = load float, ptr %34, align 4, !tbaa !10
  %225 = fcmp olt float %223, %224
  br i1 %225, label %226, label %233

226:                                              ; preds = %222
  call void @llvm.lifetime.start.p0(i64 12, ptr %36) #8
  %227 = getelementptr inbounds %struct.b2Circle, ptr %36, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %227, ptr align 4 %8, i64 8, i1 false), !tbaa.struct !9
  %228 = getelementptr inbounds %struct.b2Circle, ptr %36, i32 0, i32 1
  %229 = load ptr, ptr %5, align 8, !tbaa !5
  %230 = getelementptr inbounds %struct.b2Capsule, ptr %229, i32 0, i32 2
  %231 = load float, ptr %230, align 4, !tbaa !12
  store float %231, ptr %228, align 4, !tbaa !15
  %232 = load ptr, ptr %4, align 8, !tbaa !5
  call void @b2RayCastCircle(ptr dead_on_unwind writable sret(%struct.b2CastOutput) align 4 %0, ptr noundef %232, ptr noundef %36)
  store i32 1, ptr %13, align 4
  call void @llvm.lifetime.end.p0(i64 12, ptr %36) #8
  br label %255

233:                                              ; preds = %222
  %234 = load float, ptr %31, align 4, !tbaa !10
  %235 = load float, ptr %23, align 4, !tbaa !10
  %236 = fdiv float %234, %235
  %237 = getelementptr inbounds %struct.b2CastOutput, ptr %6, i32 0, i32 2
  store float %236, ptr %237, align 4, !tbaa !26
  %238 = getelementptr inbounds %struct.b2CastOutput, ptr %6, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #8
  %239 = load float, ptr %34, align 4, !tbaa !10
  %240 = load float, ptr %10, align 4, !tbaa !10
  %241 = fdiv float %239, %240
  %242 = load <2 x float>, ptr %7, align 4
  %243 = load <2 x float>, ptr %8, align 4
  %244 = call <2 x float> @b2Lerp(<2 x float> %242, <2 x float> %243, float noundef %241)
  store <2 x float> %244, ptr %38, align 4
  %245 = load ptr, ptr %5, align 8, !tbaa !5
  %246 = getelementptr inbounds %struct.b2Capsule, ptr %245, i32 0, i32 2
  %247 = load float, ptr %246, align 4, !tbaa !12
  %248 = load <2 x float>, ptr %22, align 4
  %249 = call <2 x float> @b2MulSV(float noundef %247, <2 x float> %248)
  store <2 x float> %249, ptr %39, align 4
  %250 = load <2 x float>, ptr %38, align 4
  %251 = load <2 x float>, ptr %39, align 4
  %252 = call <2 x float> @b2Add(<2 x float> %250, <2 x float> %251)
  store <2 x float> %252, ptr %37, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %238, ptr align 4 %37, i64 8, i1 false), !tbaa.struct !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #8
  %253 = getelementptr inbounds %struct.b2CastOutput, ptr %6, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %253, ptr align 4 %22, i64 8, i1 false), !tbaa.struct !9
  %254 = getelementptr inbounds %struct.b2CastOutput, ptr %6, i32 0, i32 4
  store i8 1, ptr %254, align 4, !tbaa !28
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 %6, i64 28, i1 false), !tbaa.struct !17
  store i32 1, ptr %13, align 4
  br label %255

255:                                              ; preds = %233, %226, %215
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #8
  br label %256

256:                                              ; preds = %255, %198
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #8
  br label %257

257:                                              ; preds = %256, %140
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #8
  br label %258

258:                                              ; preds = %257, %113, %106, %96
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %14) #8
  br label %259

259:                                              ; preds = %258, %60
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %8) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #8
  call void @llvm.lifetime.end.p0(i64 28, ptr %6) #8
  ret void
}

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2MulSub(<2 x float>, float noundef, <2 x float>) #6

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2Neg(<2 x float>) #6

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2Lerp(<2 x float>, <2 x float>, float noundef) #6

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2MulSV(float noundef, <2 x float>) #6

attributes #0 = { nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { cold noreturn nounwind memory(inaccessiblemem: write) }
attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #5 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #6 = { inlinehint nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #7 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #8 = { nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{i64 0, i64 4, !10, i64 4, i64 4, !10}
!10 = !{!11, !11, i64 0}
!11 = !{!"float", !7, i64 0}
!12 = !{!13, !11, i64 16}
!13 = !{!"b2Capsule", !14, i64 0, !14, i64 8, !11, i64 16}
!14 = !{!"b2Vec2", !11, i64 0, !11, i64 4}
!15 = !{!16, !11, i64 8}
!16 = !{!"b2Circle", !14, i64 0, !11, i64 8}
!17 = !{i64 0, i64 4, !10, i64 4, i64 4, !10, i64 8, i64 4, !10, i64 12, i64 4, !10, i64 16, i64 4, !10, i64 20, i64 4, !18, i64 24, i64 1, !20}
!18 = !{!19, !19, i64 0}
!19 = !{!"int", !7, i64 0}
!20 = !{!21, !21, i64 0}
!21 = !{!"_Bool", !7, i64 0}
!22 = !{!14, !11, i64 4}
!23 = !{!14, !11, i64 0}
!24 = !{!25, !11, i64 16}
!25 = !{!"b2RayCastInput", !14, i64 0, !14, i64 8, !11, i64 16}
!26 = !{!27, !11, i64 16}
!27 = !{!"b2CastOutput", !14, i64 0, !14, i64 8, !11, i64 16, !19, i64 20, !21, i64 24}
!28 = !{!27, !21, i64 24}


; Optimized IR (opt -passes='default<O3>'):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%struct.b2CastOutput = type { %struct.b2Vec2, %struct.b2Vec2, float, i32, i8 }
%struct.b2Vec2 = type { float, float }
%struct.b2Circle = type { %struct.b2Vec2, float }

@.str.1 = external hidden unnamed_addr constant [64 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [22 x i8], align 1

; Function Attrs: nounwind uwtable
declare dso_local zeroext i1 @b2IsValidRay(ptr noundef) local_unnamed_addr #0

; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #1

; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #1

declare i32 @b2InternalAssertFcn(ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #2

; Function Attrs: cold noreturn nounwind memory(inaccessiblemem: write)
declare void @llvm.trap() #3

; Function Attrs: mustprogress nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #4

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2Sub(<2 x float>, <2 x float>) local_unnamed_addr #5

; Function Attrs: inlinehint nounwind uwtable
declare hidden float @b2Dot(<2 x float>, <2 x float>) local_unnamed_addr #5

; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #6

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2Add(<2 x float>, <2 x float>) local_unnamed_addr #5

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2MulAdd(<2 x float>, float noundef, <2 x float>) local_unnamed_addr #5

; Function Attrs: nounwind uwtable
declare dso_local void @b2RayCastCircle(ptr dead_on_unwind noalias writable sret(%struct.b2CastOutput) align 4, ptr noundef, ptr noundef) local_unnamed_addr #0

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2GetLengthAndNormalize(ptr noundef, <2 x float>) local_unnamed_addr #5

; Function Attrs: nounwind uwtable
define dso_local void @b2RayCastCapsule(ptr dead_on_unwind noalias writable sret(%struct.b2CastOutput) align 4 %0, ptr noundef %1, ptr nocapture noundef readonly %2) local_unnamed_addr #0 {
  %4 = alloca float, align 4
  %5 = alloca %struct.b2Circle, align 8
  %6 = alloca %struct.b2Circle, align 8
  %7 = alloca %struct.b2Circle, align 8
  %8 = alloca float, align 4
  %9 = alloca %struct.b2Circle, align 8
  %10 = alloca %struct.b2Circle, align 8
  %11 = tail call zeroext i1 @b2IsValidRay(ptr noundef %1)
  br i1 %11, label %15, label %12

12:                                               ; preds = %3
  %13 = tail call i32 @b2InternalAssertFcn(ptr noundef nonnull @.str.8, ptr noundef nonnull @.str.1, i32 noundef 566) #8
  %.not = icmp eq i32 %13, 0
  br i1 %.not, label %15, label %14

14:                                               ; preds = %12
  tail call void @llvm.trap()
  unreachable

15:                                               ; preds = %3, %12
  %.sroa.079.0.copyload = load <2 x float>, ptr %2, align 4
  %16 = getelementptr inbounds i8, ptr %2, i64 8
  %.sroa.075.0.copyload = load <2 x float>, ptr %16, align 4
  %17 = tail call <2 x float> @b2Sub(<2 x float> %.sroa.075.0.copyload, <2 x float> %.sroa.079.0.copyload)
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %4) #8
  %18 = call <2 x float> @b2GetLengthAndNormalize(ptr noundef nonnull %4, <2 x float> %17)
  %19 = load float, ptr %4, align 4, !tbaa !5
  %20 = fcmp olt float %19, 0x3E80000000000000
  br i1 %20, label %21, label %25

21:                                               ; preds = %15
  call void @llvm.lifetime.start.p0(i64 12, ptr nonnull %5) #8
  store <2 x float> %.sroa.079.0.copyload, ptr %5, align 8
  %22 = getelementptr inbounds i8, ptr %5, i64 8
  %23 = getelementptr inbounds i8, ptr %2, i64 16
  %24 = load float, ptr %23, align 4, !tbaa !9
  store float %24, ptr %22, align 8, !tbaa !12
  call void @b2RayCastCircle(ptr dead_on_unwind writable sret(%struct.b2CastOutput) align 4 %0, ptr noundef %1, ptr noundef nonnull %5)
  call void @llvm.lifetime.end.p0(i64 12, ptr nonnull %5) #8
  br label %105

25:                                               ; preds = %15
  %.sroa.058.0.copyload = load <2 x float>, ptr %1, align 4
  %26 = getelementptr inbounds i8, ptr %1, i64 8
  %.sroa.057.0.copyload = load <2 x float>, ptr %26, align 4
  %27 = call <2 x float> @b2Sub(<2 x float> %.sroa.058.0.copyload, <2 x float> %.sroa.079.0.copyload)
  %28 = call float @b2Dot(<2 x float> %27, <2 x float> %18)
  %29 = fneg float %28
  %30 = call <2 x float> @b2MulAdd(<2 x float> %27, float noundef %29, <2 x float> %18)
  %31 = getelementptr inbounds i8, ptr %2, i64 16
  %32 = load float, ptr %31, align 4, !tbaa !9
  %33 = call float @b2Dot(<2 x float> %30, <2 x float> %30)
  %34 = fmul float %32, %32
  %35 = fcmp olt float %33, %34
  br i1 %35, label %36, label %47

36:                                               ; preds = %25
  %37 = fcmp olt float %28, 0.000000e+00
  br i1 %37, label %38, label %41

38:                                               ; preds = %36
  call void @llvm.lifetime.start.p0(i64 12, ptr nonnull %6) #8
  store <2 x float> %.sroa.079.0.copyload, ptr %6, align 8
  %39 = getelementptr inbounds i8, ptr %6, i64 8
  %40 = load float, ptr %31, align 4, !tbaa !9
  store float %40, ptr %39, align 8, !tbaa !12
  call void @b2RayCastCircle(ptr dead_on_unwind writable sret(%struct.b2CastOutput) align 4 %0, ptr noundef nonnull %1, ptr noundef nonnull %6)
  call void @llvm.lifetime.end.p0(i64 12, ptr nonnull %6) #8
  br label %105

41:                                               ; preds = %36
  %42 = fcmp ogt float %28, 1.000000e+00
  br i1 %42, label %43, label %46

43:                                               ; preds = %41
  call void @llvm.lifetime.start.p0(i64 12, ptr nonnull %7) #8
  store <2 x float> %.sroa.075.0.copyload, ptr %7, align 8
  %44 = getelementptr inbounds i8, ptr %7, i64 8
  %45 = load float, ptr %31, align 4, !tbaa !9
  store float %45, ptr %44, align 8, !tbaa !12
  call void @b2RayCastCircle(ptr dead_on_unwind writable sret(%struct.b2CastOutput) align 4 %0, ptr noundef nonnull %1, ptr noundef nonnull %7)
  call void @llvm.lifetime.end.p0(i64 12, ptr nonnull %7) #8
  br label %105

46:                                               ; preds = %41
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 4 dereferenceable(28) %0, i8 0, i64 28, i1 false)
  br label %105

47:                                               ; preds = %25
  %.sroa.059.4.vec.extract = extractelement <2 x float> %18, i64 1
  %.sroa.039.0.vec.insert = insertelement <2 x float> poison, float %.sroa.059.4.vec.extract, i64 0
  %.sroa.059.0.vec.extract = extractelement <2 x float> %18, i64 0
  %48 = fneg float %.sroa.059.0.vec.extract
  %.sroa.039.4.vec.insert = insertelement <2 x float> %.sroa.039.0.vec.insert, float %48, i64 1
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %8) #8
  %49 = call <2 x float> @b2GetLengthAndNormalize(ptr noundef nonnull %8, <2 x float> %.sroa.057.0.copyload)
  %.sroa.034.4.vec.extract = extractelement <2 x float> %49, i64 1
  %.sroa.034.0.vec.extract = extractelement <2 x float> %49, i64 0
  %50 = fmul float %.sroa.059.4.vec.extract, %.sroa.034.0.vec.extract
  %51 = call float @llvm.fmuladd.f32(float %48, float %.sroa.034.4.vec.extract, float %50)
  %52 = call float @llvm.fabs.f32(float %51)
  %or.cond = fcmp olt float %52, 0x3E80000000000000
  br i1 %or.cond, label %53, label %54

53:                                               ; preds = %47
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 4 dereferenceable(28) %0, i8 0, i64 28, i1 false)
  br label %104

54:                                               ; preds = %47
  %55 = call <2 x float> @b2MulSub(<2 x float> %27, float noundef %32, <2 x float> %.sroa.039.4.vec.insert)
  %56 = call <2 x float> @b2MulAdd(<2 x float> %27, float noundef %32, <2 x float> %.sroa.039.4.vec.insert)
  %57 = fdiv float 1.000000e+00, %51
  %.sroa.026.4.vec.extract = extractelement <2 x float> %55, i64 1
  %.sroa.026.0.vec.extract = extractelement <2 x float> %55, i64 0
  %58 = shufflevector <2 x float> %55, <2 x float> %56, <2 x i32> <i32 0, i32 2>
  %59 = fneg <2 x float> %58
  %60 = shufflevector <2 x float> %18, <2 x float> poison, <2 x i32> <i32 1, i32 1>
  %61 = fmul <2 x float> %60, %59
  %62 = shufflevector <2 x float> %18, <2 x float> poison, <2 x i32> zeroinitializer
  %63 = shufflevector <2 x float> %55, <2 x float> %56, <2 x i32> <i32 1, i32 3>
  %64 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %62, <2 x float> %63, <2 x float> %61)
  %65 = insertelement <2 x float> poison, float %57, i64 0
  %66 = shufflevector <2 x float> %65, <2 x float> poison, <2 x i32> zeroinitializer
  %67 = fmul <2 x float> %66, %64
  %68 = extractelement <2 x float> %67, i64 0
  %69 = extractelement <2 x float> %67, i64 1
  %70 = fcmp olt float %68, %69
  br i1 %70, label %73, label %71

71:                                               ; preds = %54
  %.sroa.021.0.vec.extract = extractelement <2 x float> %56, i64 0
  %.sroa.021.4.vec.extract = extractelement <2 x float> %56, i64 1
  %72 = call <2 x float> @b2Neg(<2 x float> %.sroa.039.4.vec.insert)
  br label %73

73:                                               ; preds = %54, %71
  %.sroa.039.0 = phi <2 x float> [ %72, %71 ], [ %.sroa.039.4.vec.insert, %54 ]
  %.0 = phi float [ %69, %71 ], [ %68, %54 ]
  %.sroa.5.0 = phi float [ %.sroa.021.4.vec.extract, %71 ], [ %.sroa.026.4.vec.extract, %54 ]
  %.sroa.07.0 = phi float [ %.sroa.021.0.vec.extract, %71 ], [ %.sroa.026.0.vec.extract, %54 ]
  %74 = fcmp olt float %.0, 0.000000e+00
  br i1 %74, label %81, label %75

75:                                               ; preds = %73
  %76 = getelementptr inbounds i8, ptr %1, i64 16
  %77 = load float, ptr %76, align 4, !tbaa !14
  %78 = load float, ptr %8, align 4, !tbaa !5
  %79 = fmul float %77, %78
  %80 = fcmp olt float %79, %.0
  br i1 %80, label %81, label %82

81:                                               ; preds = %75, %73
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 4 dereferenceable(28) %0, i8 0, i64 28, i1 false)
  br label %104

82:                                               ; preds = %75
  %83 = fneg float %.sroa.07.0
  %84 = fmul float %.sroa.034.0.vec.extract, %.sroa.5.0
  %85 = call float @llvm.fmuladd.f32(float %83, float %.sroa.034.4.vec.extract, float %84)
  %86 = fmul float %57, %85
  %87 = fcmp olt float %86, 0.000000e+00
  br i1 %87, label %88, label %91

88:                                               ; preds = %82
  call void @llvm.lifetime.start.p0(i64 12, ptr nonnull %9) #8
  store <2 x float> %.sroa.079.0.copyload, ptr %9, align 8
  %89 = getelementptr inbounds i8, ptr %9, i64 8
  %90 = load float, ptr %31, align 4, !tbaa !9
  store float %90, ptr %89, align 8, !tbaa !12
  call void @b2RayCastCircle(ptr dead_on_unwind writable sret(%struct.b2CastOutput) align 4 %0, ptr noundef nonnull %1, ptr noundef nonnull %9)
  call void @llvm.lifetime.end.p0(i64 12, ptr nonnull %9) #8
  br label %104

91:                                               ; preds = %82
  %92 = load float, ptr %4, align 4, !tbaa !5
  %93 = fcmp olt float %92, %86
  br i1 %93, label %94, label %97

94:                                               ; preds = %91
  call void @llvm.lifetime.start.p0(i64 12, ptr nonnull %10) #8
  store <2 x float> %.sroa.075.0.copyload, ptr %10, align 8
  %95 = getelementptr inbounds i8, ptr %10, i64 8
  %96 = load float, ptr %31, align 4, !tbaa !9
  store float %96, ptr %95, align 8, !tbaa !12
  call void @b2RayCastCircle(ptr dead_on_unwind writable sret(%struct.b2CastOutput) align 4 %0, ptr noundef nonnull %1, ptr noundef nonnull %10)
  call void @llvm.lifetime.end.p0(i64 12, ptr nonnull %10) #8
  br label %104

97:                                               ; preds = %91
  %98 = fdiv float %.0, %78
  %99 = fdiv float %86, %92
  %100 = call <2 x float> @b2Lerp(<2 x float> %.sroa.079.0.copyload, <2 x float> %.sroa.075.0.copyload, float noundef %99)
  %101 = load float, ptr %31, align 4, !tbaa !9
  %102 = call <2 x float> @b2MulSV(float noundef %101, <2 x float> %.sroa.039.0)
  %103 = call <2 x float> @b2Add(<2 x float> %100, <2 x float> %102)
  store <2 x float> %.sroa.039.0, ptr %0, align 4
  %.sroa.8.0..sroa_idx93 = getelementptr inbounds i8, ptr %0, i64 8
  store <2 x float> %103, ptr %.sroa.8.0..sroa_idx93, align 4
  %.sroa.9.0..sroa_idx99 = getelementptr inbounds i8, ptr %0, i64 16
  store float %98, ptr %.sroa.9.0..sroa_idx99, align 4, !tbaa !5
  %.sroa.10.0..sroa_idx105 = getelementptr inbounds i8, ptr %0, i64 20
  store i32 0, ptr %.sroa.10.0..sroa_idx105, align 4, !tbaa !16
  %.sroa.10107.0..sroa_idx112 = getelementptr inbounds i8, ptr %0, i64 24
  store i8 1, ptr %.sroa.10107.0..sroa_idx112, align 4, !tbaa !18
  %.sroa.11.0..sroa_idx116 = getelementptr inbounds i8, ptr %0, i64 25
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 1 dereferenceable(3) %.sroa.11.0..sroa_idx116, i8 0, i64 3, i1 false)
  br label %104

104:                                              ; preds = %81, %97, %94, %88, %53
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %8) #8
  br label %105

105:                                              ; preds = %38, %43, %46, %104, %21
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %4) #8
  ret void
}

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2MulSub(<2 x float>, float noundef, <2 x float>) local_unnamed_addr #5

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2Neg(<2 x float>) local_unnamed_addr #5

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2Lerp(<2 x float>, <2 x float>, float noundef) local_unnamed_addr #5

; Function Attrs: inlinehint nounwind uwtable
declare hidden <2 x float> @b2MulSV(float noundef, <2 x float>) local_unnamed_addr #5

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fabs.f32(float) #7

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <2 x float> @llvm.fmuladd.v2f32(<2 x float>, <2 x float>, <2 x float>) #7

attributes #0 = { nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { cold noreturn nounwind memory(inaccessiblemem: write) }
attributes #4 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #5 = { inlinehint nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #6 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #7 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #8 = { nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"float", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !6, i64 16}
!10 = !{!"b2Capsule", !11, i64 0, !11, i64 8, !6, i64 16}
!11 = !{!"b2Vec2", !6, i64 0, !6, i64 4}
!12 = !{!13, !6, i64 8}
!13 = !{!"b2Circle", !11, i64 0, !6, i64 8}
!14 = !{!15, !6, i64 16}
!15 = !{!"b2RayCastInput", !11, i64 0, !11, i64 8, !6, i64 16}
!16 = !{!17, !17, i64 0}
!17 = !{!"int", !7, i64 0}
!18 = !{!19, !19, i64 0}
!19 = !{!"_Bool", !7, i64 0}


; Effective O3 passes: CorrelatedValuePropagationPass,DSEPass,EarlyCSEPass,GlobalOptPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,MemCpyOptPass,PostOrderFunctionAttrsPass,ReassociatePass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass