; LLVM IR from Mithreindeir/VelocityRaptor :: VelocityRaptor/src (vrCollision)

; 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.vrPolygonShape = type { ptr, i32, ptr, i32, %struct.vrVec2 }
%struct.vrVec2 = type { float, float }
%struct.vrEdge = type { %struct.vrVec2, %struct.vrVec2, %struct.vrVec2, %struct.vrVec2, %struct.vrVec2 }
%struct.vrManifold = type { ptr, ptr, [2 x %struct.vrContactPoint], i32, %struct.vrVec2, %struct.vrVec2, float, float, float, %struct.vrBlockSolverData, i32, i32, i32, i32 }
%struct.vrContactPoint = type { %struct.vrVec2, %struct.vrVec2, float, float, float, float, %struct.vrVec2, %struct.vrVec2, float, float, float, float, %struct.vrLocalPoint }
%struct.vrLocalPoint = type { float, %struct.vrVec2, ptr }
%struct.vrBlockSolverData = type { %struct.vrVec2, %struct.vrMat2, %struct.vrVec2, %struct.vrVec2, %struct.vrVec2, %struct.vrVec2 }
%struct.vrMat2 = type { %struct.vrVec2, %struct.vrVec2 }

; Function Attrs: nounwind uwtable
define dso_local void @vrPolyPoly(ptr noundef %0, ptr noundef byval(%struct.vrPolygonShape) align 8 %1, ptr noundef byval(%struct.vrPolygonShape) align 8 %2) #0 {
  %4 = alloca ptr, align 8
  %5 = alloca %struct.vrEdge, align 4
  %6 = alloca %struct.vrEdge, align 4
  %7 = alloca %struct.vrVec2, align 4
  %8 = alloca float, align 4
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca %struct.vrVec2, align 4
  %12 = alloca %struct.vrVec2, align 4
  %13 = alloca %struct.vrEdge, align 4
  %14 = alloca %struct.vrEdge, align 4
  %15 = alloca float, align 4
  %16 = alloca %struct.vrVec2, align 4
  %17 = alloca i32, align 4
  %18 = alloca float, align 4
  %19 = alloca %struct.vrVec2, align 4
  %20 = alloca %struct.vrVec2, align 4
  %21 = alloca %struct.vrEdge, align 4
  %22 = alloca %struct.vrVec2, align 4
  %23 = alloca %struct.vrEdge, align 4
  %24 = alloca %struct.vrVec2, align 4
  %25 = alloca %struct.vrVec2, align 4
  %26 = alloca %struct.vrVec2, align 4
  %27 = alloca %struct.vrVec2, align 4
  %28 = alloca i1, align 1
  %29 = alloca %struct.vrVec2, align 4
  %30 = alloca float, align 4
  %31 = alloca float, align 4
  %32 = alloca float, align 4
  %33 = alloca [2 x %struct.vrVec2], align 16
  %34 = alloca %struct.vrVec2, align 4
  %35 = alloca %struct.vrVec2, align 4
  %36 = alloca %struct.vrVec2, align 4
  %37 = alloca i32, align 4
  %38 = alloca float, align 4
  store ptr %0, ptr %4, align 8, !tbaa !5
  %39 = load ptr, ptr %4, align 8, !tbaa !5
  %40 = getelementptr inbounds %struct.vrManifold, ptr %39, i32 0, i32 3
  store i32 0, ptr %40, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 40, ptr %5) #4
  call void @llvm.lifetime.start.p0(i64 40, ptr %6) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #4
  store i32 0, ptr %9, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #4
  store i32 0, ptr %10, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #4
  %41 = call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00)
  store <2 x float> %41, ptr %11, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #4
  %42 = call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00)
  store <2 x float> %42, ptr %12, align 4
  call void @llvm.lifetime.start.p0(i64 40, ptr %13) #4
  call void @llvm.lifetime.start.p0(i64 40, ptr %14) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #4
  %43 = getelementptr inbounds %struct.vrPolygonShape, ptr %2, i32 0, i32 4
  %44 = getelementptr inbounds %struct.vrPolygonShape, ptr %1, i32 0, i32 4
  %45 = load <2 x float>, ptr %43, align 4
  %46 = load <2 x float>, ptr %44, align 4
  %47 = call <2 x float> @vrSub(<2 x float> %45, <2 x float> %46)
  store <2 x float> %47, ptr %16, align 4
  %48 = load <2 x float>, ptr %16, align 4
  %49 = call float @vrPolyGetLeastAxis(ptr noundef byval(%struct.vrPolygonShape) align 8 %1, ptr noundef byval(%struct.vrPolygonShape) align 8 %2, ptr noundef %11, ptr noundef %13, <2 x float> %48)
  store float %49, ptr %15, align 4, !tbaa !17
  %50 = load float, ptr %15, align 4, !tbaa !17
  %51 = fcmp ole float %50, 0.000000e+00
  br i1 %51, label %52, label %53

52:                                               ; preds = %3
  store i32 1, ptr %17, align 4
  br label %288

53:                                               ; preds = %3
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #4
  %54 = getelementptr inbounds %struct.vrPolygonShape, ptr %1, i32 0, i32 4
  %55 = getelementptr inbounds %struct.vrPolygonShape, ptr %2, i32 0, i32 4
  %56 = load <2 x float>, ptr %54, align 4
  %57 = load <2 x float>, ptr %55, align 4
  %58 = call <2 x float> @vrSub(<2 x float> %56, <2 x float> %57)
  store <2 x float> %58, ptr %19, align 4
  %59 = load <2 x float>, ptr %19, align 4
  %60 = call float @vrPolyGetLeastAxis(ptr noundef byval(%struct.vrPolygonShape) align 8 %2, ptr noundef byval(%struct.vrPolygonShape) align 8 %1, ptr noundef %12, ptr noundef %14, <2 x float> %59)
  store float %60, ptr %18, align 4, !tbaa !17
  %61 = load float, ptr %18, align 4, !tbaa !17
  %62 = fcmp ole float %61, 0.000000e+00
  br i1 %62, label %63, label %64

63:                                               ; preds = %53
  store i32 1, ptr %17, align 4
  br label %287

64:                                               ; preds = %53
  %65 = load float, ptr %15, align 4, !tbaa !17
  %66 = load float, ptr %18, align 4, !tbaa !17
  %67 = fcmp oge float %65, %66
  br i1 %67, label %68, label %80

68:                                               ; preds = %64
  %69 = load float, ptr %18, align 4, !tbaa !17
  store float %69, ptr %8, align 4, !tbaa !17
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %7, ptr align 4 %12, i64 8, i1 false), !tbaa.struct !18
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #4
  %70 = getelementptr inbounds %struct.vrVec2, ptr %7, i32 0, i32 0
  %71 = load float, ptr %70, align 4, !tbaa !19
  %72 = fneg float %71
  %73 = getelementptr inbounds %struct.vrVec2, ptr %7, i32 0, i32 1
  %74 = load float, ptr %73, align 4, !tbaa !20
  %75 = fneg float %74
  %76 = call <2 x float> @vrVect(float noundef %72, float noundef %75)
  store <2 x float> %76, ptr %20, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %5, ptr align 4 %14, i64 40, i1 false), !tbaa.struct !21
  call void @llvm.lifetime.start.p0(i64 40, ptr %21) #4
  %77 = load <2 x float>, ptr %20, align 4
  %78 = call i32 @vrPolyGetFarthestVertex(ptr noundef byval(%struct.vrPolygonShape) align 8 %1, <2 x float> %77)
  %79 = load <2 x float>, ptr %20, align 4
  call void @vrPolyBestEdge(ptr dead_on_unwind writable sret(%struct.vrEdge) align 4 %21, ptr noundef byval(%struct.vrPolygonShape) align 8 %1, i32 noundef %78, <2 x float> %79)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %6, ptr align 4 %21, i64 40, i1 false), !tbaa.struct !21
  call void @llvm.lifetime.end.p0(i64 40, ptr %21) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #4
  br label %92

80:                                               ; preds = %64
  %81 = load float, ptr %15, align 4, !tbaa !17
  store float %81, ptr %8, align 4, !tbaa !17
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %7, ptr align 4 %11, i64 8, i1 false), !tbaa.struct !18
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #4
  %82 = getelementptr inbounds %struct.vrVec2, ptr %7, i32 0, i32 0
  %83 = load float, ptr %82, align 4, !tbaa !19
  %84 = fneg float %83
  %85 = getelementptr inbounds %struct.vrVec2, ptr %7, i32 0, i32 1
  %86 = load float, ptr %85, align 4, !tbaa !20
  %87 = fneg float %86
  %88 = call <2 x float> @vrVect(float noundef %84, float noundef %87)
  store <2 x float> %88, ptr %22, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %5, ptr align 4 %13, i64 40, i1 false), !tbaa.struct !21
  call void @llvm.lifetime.start.p0(i64 40, ptr %23) #4
  %89 = load <2 x float>, ptr %22, align 4
  %90 = call i32 @vrPolyGetFarthestVertex(ptr noundef byval(%struct.vrPolygonShape) align 8 %2, <2 x float> %89)
  %91 = load <2 x float>, ptr %22, align 4
  call void @vrPolyBestEdge(ptr dead_on_unwind writable sret(%struct.vrEdge) align 4 %23, ptr noundef byval(%struct.vrPolygonShape) align 8 %2, i32 noundef %90, <2 x float> %91)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %6, ptr align 4 %23, i64 40, i1 false), !tbaa.struct !21
  call void @llvm.lifetime.end.p0(i64 40, ptr %23) #4
  store i32 1, ptr %9, align 4, !tbaa !16
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #4
  br label %92

92:                                               ; preds = %80, %68
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #4
  %93 = getelementptr inbounds %struct.vrEdge, ptr %5, i32 0, i32 4
  %94 = load <2 x float>, ptr %93, align 4
  %95 = call <2 x float> @vrNormalize(<2 x float> %94)
  store <2 x float> %95, ptr %24, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #4
  %96 = getelementptr inbounds %struct.vrVec2, ptr %24, i32 0, i32 1
  %97 = load float, ptr %96, align 4, !tbaa !20
  %98 = getelementptr inbounds %struct.vrVec2, ptr %24, i32 0, i32 0
  %99 = load float, ptr %98, align 4, !tbaa !19
  %100 = fneg float %99
  %101 = call <2 x float> @vrVect(float noundef %97, float noundef %100)
  store <2 x float> %101, ptr %25, align 4
  %102 = getelementptr inbounds %struct.vrPolygonShape, ptr %2, i32 0, i32 4
  %103 = getelementptr inbounds %struct.vrPolygonShape, ptr %1, i32 0, i32 4
  %104 = load <2 x float>, ptr %102, align 4
  %105 = load <2 x float>, ptr %103, align 4
  %106 = call <2 x float> @vrSub(<2 x float> %104, <2 x float> %105)
  store <2 x float> %106, ptr %26, align 4
  %107 = load <2 x float>, ptr %25, align 4
  %108 = load <2 x float>, ptr %26, align 4
  %109 = call float @vrDot(<2 x float> %107, <2 x float> %108)
  %110 = fcmp oge float %109, 0.000000e+00
  %111 = zext i1 %110 to i32
  store i32 %111, ptr %10, align 4, !tbaa !16
  %112 = load i32, ptr %10, align 4, !tbaa !16
  %113 = icmp ne i32 %112, 0
  store i1 false, ptr %28, align 1
  br i1 %113, label %114, label %122

114:                                              ; preds = %92
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #4
  store i1 true, ptr %28, align 1
  %115 = getelementptr inbounds %struct.vrVec2, ptr %25, i32 0, i32 0
  %116 = load float, ptr %115, align 4, !tbaa !19
  %117 = fneg float %116
  %118 = getelementptr inbounds %struct.vrVec2, ptr %25, i32 0, i32 1
  %119 = load float, ptr %118, align 4, !tbaa !20
  %120 = fneg float %119
  %121 = call <2 x float> @vrVect(float noundef %117, float noundef %120)
  store <2 x float> %121, ptr %27, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %25, ptr align 4 %27, i64 8, i1 false), !tbaa.struct !18
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #4
  br label %123

122:                                              ; preds = %92
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %25, ptr align 4 %25, i64 8, i1 false), !tbaa.struct !18
  br label %123

123:                                              ; preds = %122, %114
  %124 = load i32, ptr %9, align 4, !tbaa !16
  %125 = icmp ne i32 %124, 0
  br i1 %125, label %126, label %134

126:                                              ; preds = %123
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #4
  %127 = getelementptr inbounds %struct.vrVec2, ptr %25, i32 0, i32 0
  %128 = load float, ptr %127, align 4, !tbaa !19
  %129 = fneg float %128
  %130 = getelementptr inbounds %struct.vrVec2, ptr %25, i32 0, i32 1
  %131 = load float, ptr %130, align 4, !tbaa !20
  %132 = fneg float %131
  %133 = call <2 x float> @vrVect(float noundef %129, float noundef %132)
  store <2 x float> %133, ptr %29, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %25, ptr align 4 %29, i64 8, i1 false), !tbaa.struct !18
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #4
  br label %134

134:                                              ; preds = %126, %123
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #4
  %135 = getelementptr inbounds %struct.vrEdge, ptr %5, i32 0, i32 0
  %136 = load <2 x float>, ptr %24, align 4
  %137 = load <2 x float>, ptr %135, align 4
  %138 = call float @vrDot(<2 x float> %136, <2 x float> %137)
  store float %138, ptr %30, align 4, !tbaa !17
  %139 = getelementptr inbounds %struct.vrEdge, ptr %5, i32 0, i32 1
  %140 = load <2 x float>, ptr %24, align 4
  %141 = load <2 x float>, ptr %139, align 4
  %142 = call float @vrDot(<2 x float> %140, <2 x float> %141)
  %143 = fneg float %142
  store float %143, ptr %31, align 4, !tbaa !17
  %144 = getelementptr inbounds %struct.vrEdge, ptr %5, i32 0, i32 2
  %145 = load <2 x float>, ptr %25, align 4
  %146 = load <2 x float>, ptr %144, align 4
  %147 = call float @vrDot(<2 x float> %145, <2 x float> %146)
  store float %147, ptr %32, align 4, !tbaa !17
  call void @llvm.lifetime.start.p0(i64 16, ptr %33) #4
  %148 = getelementptr inbounds [2 x %struct.vrVec2], ptr %33, i64 0, i64 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #4
  %149 = call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00)
  store <2 x float> %149, ptr %34, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %148, ptr align 4 %34, i64 8, i1 false), !tbaa.struct !18
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #4
  %150 = getelementptr inbounds [2 x %struct.vrVec2], ptr %33, i64 0, i64 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #4
  %151 = call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00)
  store <2 x float> %151, ptr %35, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %150, ptr align 4 %35, i64 8, i1 false), !tbaa.struct !18
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #4
  %152 = getelementptr inbounds %struct.vrEdge, ptr %6, i32 0, i32 0
  %153 = getelementptr inbounds %struct.vrEdge, ptr %6, i32 0, i32 1
  %154 = load float, ptr %30, align 4, !tbaa !17
  %155 = getelementptr inbounds [2 x %struct.vrVec2], ptr %33, i64 0, i64 0
  %156 = load <2 x float>, ptr %152, align 4
  %157 = load <2 x float>, ptr %153, align 4
  %158 = load <2 x float>, ptr %24, align 4
  %159 = call i32 @Clip(<2 x float> %156, <2 x float> %157, <2 x float> %158, float noundef %154, ptr noundef %155)
  %160 = icmp slt i32 %159, 2
  br i1 %160, label %161, label %162

161:                                              ; preds = %134
  store i32 1, ptr %17, align 4
  br label %286

162:                                              ; preds = %134
  %163 = getelementptr inbounds [2 x %struct.vrVec2], ptr %33, i64 0, i64 0
  %164 = getelementptr inbounds [2 x %struct.vrVec2], ptr %33, i64 0, i64 1
  %165 = getelementptr inbounds %struct.vrVec2, ptr %24, i32 0, i32 0
  %166 = load float, ptr %165, align 4, !tbaa !19
  %167 = fneg float %166
  %168 = getelementptr inbounds %struct.vrVec2, ptr %24, i32 0, i32 1
  %169 = load float, ptr %168, align 4, !tbaa !20
  %170 = fneg float %169
  %171 = call <2 x float> @vrVect(float noundef %167, float noundef %170)
  store <2 x float> %171, ptr %36, align 4
  %172 = load float, ptr %31, align 4, !tbaa !17
  %173 = getelementptr inbounds [2 x %struct.vrVec2], ptr %33, i64 0, i64 0
  %174 = load <2 x float>, ptr %163, align 16
  %175 = load <2 x float>, ptr %164, align 8
  %176 = load <2 x float>, ptr %36, align 4
  %177 = call i32 @Clip(<2 x float> %174, <2 x float> %175, <2 x float> %176, float noundef %172, ptr noundef %173)
  %178 = icmp slt i32 %177, 2
  br i1 %178, label %179, label %180

179:                                              ; preds = %162
  store i32 1, ptr %17, align 4
  br label %286

180:                                              ; preds = %162
  %181 = load ptr, ptr %4, align 8, !tbaa !5
  %182 = getelementptr inbounds %struct.vrManifold, ptr %181, i32 0, i32 8
  store float 0.000000e+00, ptr %182, align 4, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #4
  store i32 0, ptr %37, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #4
  %183 = getelementptr inbounds [2 x %struct.vrVec2], ptr %33, i64 0, i64 0
  %184 = load <2 x float>, ptr %25, align 4
  %185 = load <2 x float>, ptr %183, align 16
  %186 = call float @vrDot(<2 x float> %184, <2 x float> %185)
  %187 = load float, ptr %32, align 4, !tbaa !17
  %188 = fsub float %186, %187
  store float %188, ptr %38, align 4, !tbaa !17
  %189 = load float, ptr %38, align 4, !tbaa !17
  %190 = fpext float %189 to double
  %191 = fcmp ole double %190, 0.000000e+00
  br i1 %191, label %192, label %221

192:                                              ; preds = %180
  %193 = load ptr, ptr %4, align 8, !tbaa !5
  %194 = getelementptr inbounds %struct.vrManifold, ptr %193, i32 0, i32 2
  %195 = load i32, ptr %37, align 4, !tbaa !16
  %196 = sext i32 %195 to i64
  %197 = getelementptr inbounds [2 x %struct.vrContactPoint], ptr %194, i64 0, i64 %196
  %198 = getelementptr inbounds %struct.vrContactPoint, ptr %197, i32 0, i32 1
  %199 = getelementptr inbounds [2 x %struct.vrVec2], ptr %33, i64 0, i64 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %198, ptr align 16 %199, i64 8, i1 false), !tbaa.struct !18
  %200 = load ptr, ptr %4, align 8, !tbaa !5
  %201 = getelementptr inbounds %struct.vrManifold, ptr %200, i32 0, i32 2
  %202 = load i32, ptr %37, align 4, !tbaa !16
  %203 = sext i32 %202 to i64
  %204 = getelementptr inbounds [2 x %struct.vrContactPoint], ptr %201, i64 0, i64 %203
  %205 = getelementptr inbounds %struct.vrContactPoint, ptr %204, i32 0, i32 3
  store float 0.000000e+00, ptr %205, align 4, !tbaa !23
  %206 = load ptr, ptr %4, align 8, !tbaa !5
  %207 = getelementptr inbounds %struct.vrManifold, ptr %206, i32 0, i32 2
  %208 = load i32, ptr %37, align 4, !tbaa !16
  %209 = sext i32 %208 to i64
  %210 = getelementptr inbounds [2 x %struct.vrContactPoint], ptr %207, i64 0, i64 %209
  %211 = getelementptr inbounds %struct.vrContactPoint, ptr %210, i32 0, i32 4
  store float 0.000000e+00, ptr %211, align 8, !tbaa !26
  %212 = load float, ptr %38, align 4, !tbaa !17
  %213 = load ptr, ptr %4, align 8, !tbaa !5
  %214 = getelementptr inbounds %struct.vrManifold, ptr %213, i32 0, i32 2
  %215 = load i32, ptr %37, align 4, !tbaa !16
  %216 = sext i32 %215 to i64
  %217 = getelementptr inbounds [2 x %struct.vrContactPoint], ptr %214, i64 0, i64 %216
  %218 = getelementptr inbounds %struct.vrContactPoint, ptr %217, i32 0, i32 2
  store float %212, ptr %218, align 8, !tbaa !27
  %219 = load i32, ptr %37, align 4, !tbaa !16
  %220 = add nsw i32 %219, 1
  store i32 %220, ptr %37, align 4, !tbaa !16
  br label %224

221:                                              ; preds = %180
  %222 = load ptr, ptr %4, align 8, !tbaa !5
  %223 = getelementptr inbounds %struct.vrManifold, ptr %222, i32 0, i32 8
  store float 0.000000e+00, ptr %223, align 4, !tbaa !22
  br label %224

224:                                              ; preds = %221, %192
  %225 = getelementptr inbounds [2 x %struct.vrVec2], ptr %33, i64 0, i64 1
  %226 = load <2 x float>, ptr %25, align 4
  %227 = load <2 x float>, ptr %225, align 8
  %228 = call float @vrDot(<2 x float> %226, <2 x float> %227)
  %229 = load float, ptr %32, align 4, !tbaa !17
  %230 = fsub float %228, %229
  store float %230, ptr %38, align 4, !tbaa !17
  %231 = load float, ptr %38, align 4, !tbaa !17
  %232 = fcmp ole float %231, 0.000000e+00
  br i1 %232, label %233, label %268

233:                                              ; preds = %224
  %234 = load ptr, ptr %4, align 8, !tbaa !5
  %235 = getelementptr inbounds %struct.vrManifold, ptr %234, i32 0, i32 2
  %236 = load i32, ptr %37, align 4, !tbaa !16
  %237 = sext i32 %236 to i64
  %238 = getelementptr inbounds [2 x %struct.vrContactPoint], ptr %235, i64 0, i64 %237
  %239 = getelementptr inbounds %struct.vrContactPoint, ptr %238, i32 0, i32 1
  %240 = getelementptr inbounds [2 x %struct.vrVec2], ptr %33, i64 0, i64 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %239, ptr align 8 %240, i64 8, i1 false), !tbaa.struct !18
  %241 = load ptr, ptr %4, align 8, !tbaa !5
  %242 = getelementptr inbounds %struct.vrManifold, ptr %241, i32 0, i32 2
  %243 = load i32, ptr %37, align 4, !tbaa !16
  %244 = sext i32 %243 to i64
  %245 = getelementptr inbounds [2 x %struct.vrContactPoint], ptr %242, i64 0, i64 %244
  %246 = getelementptr inbounds %struct.vrContactPoint, ptr %245, i32 0, i32 3
  store float 0.000000e+00, ptr %246, align 4, !tbaa !23
  %247 = load ptr, ptr %4, align 8, !tbaa !5
  %248 = getelementptr inbounds %struct.vrManifold, ptr %247, i32 0, i32 2
  %249 = load i32, ptr %37, align 4, !tbaa !16
  %250 = sext i32 %249 to i64
  %251 = getelementptr inbounds [2 x %struct.vrContactPoint], ptr %248, i64 0, i64 %250
  %252 = getelementptr inbounds %struct.vrContactPoint, ptr %251, i32 0, i32 4
  store float 0.000000e+00, ptr %252, align 8, !tbaa !26
  %253 = load float, ptr %38, align 4, !tbaa !17
  %254 = load ptr, ptr %4, align 8, !tbaa !5
  %255 = getelementptr inbounds %struct.vrManifold, ptr %254, i32 0, i32 2
  %256 = load i32, ptr %37, align 4, !tbaa !16
  %257 = sext i32 %256 to i64
  %258 = getelementptr inbounds [2 x %struct.vrContactPoint], ptr %255, i64 0, i64 %257
  %259 = getelementptr inbounds %struct.vrContactPoint, ptr %258, i32 0, i32 2
  store float %253, ptr %259, align 8, !tbaa !27
  %260 = load float, ptr %38, align 4, !tbaa !17
  %261 = fneg float %260
  %262 = load ptr, ptr %4, align 8, !tbaa !5
  %263 = getelementptr inbounds %struct.vrManifold, ptr %262, i32 0, i32 8
  %264 = load float, ptr %263, align 4, !tbaa !22
  %265 = fadd float %264, %261
  store float %265, ptr %263, align 4, !tbaa !22
  %266 = load i32, ptr %37, align 4, !tbaa !16
  %267 = add nsw i32 %266, 1
  store i32 %267, ptr %37, align 4, !tbaa !16
  br label %268

268:                                              ; preds = %233, %224
  %269 = load i32, ptr %37, align 4, !tbaa !16
  %270 = sitofp i32 %269 to float
  %271 = load ptr, ptr %4, align 8, !tbaa !5
  %272 = getelementptr inbounds %struct.vrManifold, ptr %271, i32 0, i32 8
  %273 = load float, ptr %272, align 4, !tbaa !22
  %274 = fdiv float %273, %270
  store float %274, ptr %272, align 4, !tbaa !22
  %275 = load i32, ptr %37, align 4, !tbaa !16
  %276 = load ptr, ptr %4, align 8, !tbaa !5
  %277 = getelementptr inbounds %struct.vrManifold, ptr %276, i32 0, i32 3
  store i32 %275, ptr %277, align 8, !tbaa !9
  %278 = load ptr, ptr %4, align 8, !tbaa !5
  %279 = getelementptr inbounds %struct.vrManifold, ptr %278, i32 0, i32 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %279, ptr align 4 %25, i64 8, i1 false), !tbaa.struct !18
  %280 = load i32, ptr %9, align 4, !tbaa !16
  %281 = load ptr, ptr %4, align 8, !tbaa !5
  %282 = getelementptr inbounds %struct.vrManifold, ptr %281, i32 0, i32 10
  store i32 %280, ptr %282, align 8, !tbaa !28
  %283 = load float, ptr %8, align 4, !tbaa !17
  %284 = load ptr, ptr %4, align 8, !tbaa !5
  %285 = getelementptr inbounds %struct.vrManifold, ptr %284, i32 0, i32 8
  store float %283, ptr %285, align 4, !tbaa !22
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #4
  store i32 0, ptr %17, align 4
  br label %286

286:                                              ; preds = %268, %179, %161
  call void @llvm.lifetime.end.p0(i64 16, ptr %33) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #4
  br label %287

287:                                              ; preds = %286, %63
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #4
  br label %288

288:                                              ; preds = %287, %52
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #4
  call void @llvm.lifetime.end.p0(i64 40, ptr %14) #4
  call void @llvm.lifetime.end.p0(i64 40, ptr %13) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #4
  call void @llvm.lifetime.end.p0(i64 40, ptr %6) #4
  call void @llvm.lifetime.end.p0(i64 40, ptr %5) #4
  %289 = load i32, ptr %17, align 4
  switch i32 %289, label %291 [
    i32 0, label %290
    i32 1, label %290
  ]

290:                                              ; preds = %288, %288
  ret void

291:                                              ; preds = %288
  unreachable
}

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

declare <2 x float> @vrVect(float noundef, float noundef) #2

; Function Attrs: nounwind uwtable
declare dso_local float @vrPolyGetLeastAxis(ptr noundef byval(%struct.vrPolygonShape) align 8, ptr noundef byval(%struct.vrPolygonShape) align 8, ptr noundef, ptr noundef, <2 x float>) #0

declare <2 x float> @vrSub(<2 x float>, <2 x float>) #2

; 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) #3

; Function Attrs: nounwind uwtable
declare dso_local void @vrPolyBestEdge(ptr dead_on_unwind noalias writable sret(%struct.vrEdge) align 4, ptr noundef byval(%struct.vrPolygonShape) align 8, i32 noundef, <2 x float>) #0

; Function Attrs: nounwind uwtable
declare dso_local i32 @vrPolyGetFarthestVertex(ptr noundef byval(%struct.vrPolygonShape) align 8, <2 x float>) #0

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

declare <2 x float> @vrNormalize(<2 x float>) #2

declare float @vrDot(<2 x float>, <2 x float>) #2

; Function Attrs: nounwind uwtable
declare dso_local i32 @Clip(<2 x float>, <2 x float>, <2 x float>, float noundef, ptr noundef) #0

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 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #4 = { 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 = !{!10, !11, i64 192}
!10 = !{!"vrManifold", !6, i64 0, !6, i64 8, !7, i64 16, !11, i64 192, !12, i64 196, !12, i64 204, !13, i64 212, !13, i64 216, !13, i64 220, !14, i64 224, !11, i64 280, !11, i64 284, !11, i64 288, !11, i64 292}
!11 = !{!"int", !7, i64 0}
!12 = !{!"vrVec2", !13, i64 0, !13, i64 4}
!13 = !{!"float", !7, i64 0}
!14 = !{!"vrBlockSolverData", !12, i64 0, !15, i64 8, !12, i64 24, !12, i64 32, !12, i64 40, !12, i64 48}
!15 = !{!"vrMat2", !12, i64 0, !12, i64 8}
!16 = !{!11, !11, i64 0}
!17 = !{!13, !13, i64 0}
!18 = !{i64 0, i64 4, !17, i64 4, i64 4, !17}
!19 = !{!12, !13, i64 0}
!20 = !{!12, !13, i64 4}
!21 = !{i64 0, i64 4, !17, i64 4, i64 4, !17, i64 8, i64 4, !17, i64 12, i64 4, !17, i64 16, i64 4, !17, i64 20, i64 4, !17, i64 24, i64 4, !17, i64 28, i64 4, !17, i64 32, i64 4, !17, i64 36, i64 4, !17}
!22 = !{!10, !13, i64 220}
!23 = !{!24, !13, i64 20}
!24 = !{!"vrContactPoint", !12, i64 0, !12, i64 8, !13, i64 16, !13, i64 20, !13, i64 24, !13, i64 28, !12, i64 32, !12, i64 40, !13, i64 48, !13, i64 52, !13, i64 56, !13, i64 60, !25, i64 64}
!25 = !{!"vrLocalPoint", !13, i64 0, !12, i64 4, !6, i64 16}
!26 = !{!24, !13, i64 24}
!27 = !{!24, !13, i64 16}
!28 = !{!10, !11, i64 280}


; 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.vrPolygonShape = type { ptr, i32, ptr, i32, %struct.vrVec2 }
%struct.vrVec2 = type { float, float }
%struct.vrEdge = type { %struct.vrVec2, %struct.vrVec2, %struct.vrVec2, %struct.vrVec2, %struct.vrVec2 }
%struct.vrContactPoint = type { %struct.vrVec2, %struct.vrVec2, float, float, float, float, %struct.vrVec2, %struct.vrVec2, float, float, float, float, %struct.vrLocalPoint }
%struct.vrLocalPoint = type { float, %struct.vrVec2, ptr }

; Function Attrs: nounwind uwtable
define dso_local void @vrPolyPoly(ptr nocapture noundef writeonly %0, ptr noundef byval(%struct.vrPolygonShape) align 8 %1, ptr noundef byval(%struct.vrPolygonShape) align 8 %2) local_unnamed_addr #0 {
  %4 = alloca %struct.vrVec2, align 8
  %5 = alloca %struct.vrVec2, align 8
  %6 = alloca %struct.vrEdge, align 8
  %7 = alloca %struct.vrEdge, align 8
  %8 = alloca %struct.vrEdge, align 8
  %9 = alloca %struct.vrEdge, align 8
  %10 = alloca [2 x %struct.vrVec2], align 16
  %11 = getelementptr inbounds i8, ptr %0, i64 192
  store i32 0, ptr %11, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %4) #3
  %12 = tail call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00) #3
  store <2 x float> %12, ptr %4, align 8
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %5) #3
  %13 = tail call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00) #3
  store <2 x float> %13, ptr %5, align 8
  call void @llvm.lifetime.start.p0(i64 40, ptr nonnull %6) #3
  call void @llvm.lifetime.start.p0(i64 40, ptr nonnull %7) #3
  %14 = getelementptr inbounds i8, ptr %2, i64 28
  %15 = getelementptr inbounds i8, ptr %1, i64 28
  %16 = load <2 x float>, ptr %14, align 4
  %17 = load <2 x float>, ptr %15, align 4
  %18 = tail call <2 x float> @vrSub(<2 x float> %16, <2 x float> %17) #3
  %19 = call float @vrPolyGetLeastAxis(ptr noundef nonnull byval(%struct.vrPolygonShape) align 8 %1, ptr noundef nonnull byval(%struct.vrPolygonShape) align 8 %2, ptr noundef nonnull %4, ptr noundef nonnull %6, <2 x float> %18)
  %20 = fcmp ugt float %19, 0.000000e+00
  br i1 %20, label %21, label %104

21:                                               ; preds = %3
  %22 = load <2 x float>, ptr %15, align 4
  %23 = load <2 x float>, ptr %14, align 4
  %24 = call <2 x float> @vrSub(<2 x float> %22, <2 x float> %23) #3
  %25 = call float @vrPolyGetLeastAxis(ptr noundef nonnull byval(%struct.vrPolygonShape) align 8 %2, ptr noundef nonnull byval(%struct.vrPolygonShape) align 8 %1, ptr noundef nonnull %5, ptr noundef nonnull %7, <2 x float> %24)
  %26 = fcmp ugt float %25, 0.000000e+00
  br i1 %26, label %27, label %104

27:                                               ; preds = %21
  %28 = fcmp oge float %19, %25
  br i1 %28, label %29, label %34

29:                                               ; preds = %27
  %.sroa.058.0.copyload = load float, ptr %5, align 8, !tbaa !15
  %.sroa.6.0..sroa_idx = getelementptr inbounds i8, ptr %5, i64 4
  %.sroa.6.0.copyload = load float, ptr %.sroa.6.0..sroa_idx, align 4, !tbaa !15
  %30 = fneg float %.sroa.058.0.copyload
  %31 = fneg float %.sroa.6.0.copyload
  %32 = call <2 x float> @vrVect(float noundef %30, float noundef %31) #3
  %.sroa.070.0.copyload = load <2 x float>, ptr %7, align 8
  %.sroa.572.0..sroa_idx = getelementptr inbounds i8, ptr %7, i64 8
  %.sroa.572.0.copyload = load <2 x float>, ptr %.sroa.572.0..sroa_idx, align 8
  %.sroa.675.0..sroa_idx = getelementptr inbounds i8, ptr %7, i64 16
  %.sroa.675.0.copyload = load <2 x float>, ptr %.sroa.675.0..sroa_idx, align 8
  %.sroa.779.0..sroa_idx = getelementptr inbounds i8, ptr %7, i64 32
  %.sroa.779.0.copyload = load <2 x float>, ptr %.sroa.779.0..sroa_idx, align 8
  call void @llvm.lifetime.start.p0(i64 40, ptr nonnull %8) #3
  %33 = call i32 @vrPolyGetFarthestVertex(ptr noundef nonnull byval(%struct.vrPolygonShape) align 8 %1, <2 x float> %32)
  call void @vrPolyBestEdge(ptr dead_on_unwind nonnull writable sret(%struct.vrEdge) align 4 %8, ptr noundef nonnull byval(%struct.vrPolygonShape) align 8 %1, i32 noundef %33, <2 x float> %32)
  %.sroa.064.0.copyload = load <2 x float>, ptr %8, align 8
  %.sroa.5.0..sroa_idx = getelementptr inbounds i8, ptr %8, i64 8
  %.sroa.5.0.copyload = load <2 x float>, ptr %.sroa.5.0..sroa_idx, align 8
  call void @llvm.lifetime.end.p0(i64 40, ptr nonnull %8) #3
  br label %39

34:                                               ; preds = %27
  %.sroa.058.0.copyload60 = load float, ptr %4, align 8, !tbaa !15
  %.sroa.6.0..sroa_idx61 = getelementptr inbounds i8, ptr %4, i64 4
  %.sroa.6.0.copyload62 = load float, ptr %.sroa.6.0..sroa_idx61, align 4, !tbaa !15
  %35 = fneg float %.sroa.058.0.copyload60
  %36 = fneg float %.sroa.6.0.copyload62
  %37 = call <2 x float> @vrVect(float noundef %35, float noundef %36) #3
  %.sroa.070.0.copyload71 = load <2 x float>, ptr %6, align 8
  %.sroa.572.0..sroa_idx73 = getelementptr inbounds i8, ptr %6, i64 8
  %.sroa.572.0.copyload74 = load <2 x float>, ptr %.sroa.572.0..sroa_idx73, align 8
  %.sroa.675.0..sroa_idx76 = getelementptr inbounds i8, ptr %6, i64 16
  %.sroa.675.0.copyload77 = load <2 x float>, ptr %.sroa.675.0..sroa_idx76, align 8
  %.sroa.779.0..sroa_idx80 = getelementptr inbounds i8, ptr %6, i64 32
  %.sroa.779.0.copyload81 = load <2 x float>, ptr %.sroa.779.0..sroa_idx80, align 8
  call void @llvm.lifetime.start.p0(i64 40, ptr nonnull %9) #3
  %38 = call i32 @vrPolyGetFarthestVertex(ptr noundef nonnull byval(%struct.vrPolygonShape) align 8 %2, <2 x float> %37)
  call void @vrPolyBestEdge(ptr dead_on_unwind nonnull writable sret(%struct.vrEdge) align 4 %9, ptr noundef nonnull byval(%struct.vrPolygonShape) align 8 %2, i32 noundef %38, <2 x float> %37)
  %.sroa.064.0.copyload65 = load <2 x float>, ptr %9, align 8
  %.sroa.5.0..sroa_idx66 = getelementptr inbounds i8, ptr %9, i64 8
  %.sroa.5.0.copyload67 = load <2 x float>, ptr %.sroa.5.0..sroa_idx66, align 8
  call void @llvm.lifetime.end.p0(i64 40, ptr nonnull %9) #3
  br label %39

39:                                               ; preds = %34, %29
  %.0100 = phi i32 [ 0, %29 ], [ 1, %34 ]
  %.099 = phi float [ %25, %29 ], [ %19, %34 ]
  %.sroa.064.0 = phi <2 x float> [ %.sroa.064.0.copyload, %29 ], [ %.sroa.064.0.copyload65, %34 ]
  %.sroa.5.0 = phi <2 x float> [ %.sroa.5.0.copyload, %29 ], [ %.sroa.5.0.copyload67, %34 ]
  %.sroa.070.0 = phi <2 x float> [ %.sroa.070.0.copyload, %29 ], [ %.sroa.070.0.copyload71, %34 ]
  %.sroa.572.0 = phi <2 x float> [ %.sroa.572.0.copyload, %29 ], [ %.sroa.572.0.copyload74, %34 ]
  %.sroa.675.0 = phi <2 x float> [ %.sroa.675.0.copyload, %29 ], [ %.sroa.675.0.copyload77, %34 ]
  %.sroa.779.0 = phi <2 x float> [ %.sroa.779.0.copyload, %29 ], [ %.sroa.779.0.copyload81, %34 ]
  %40 = call <2 x float> @vrNormalize(<2 x float> %.sroa.779.0) #3
  %.sroa.034.4.vec.extract = extractelement <2 x float> %40, i64 1
  %.sroa.034.0.vec.extract = extractelement <2 x float> %40, i64 0
  %41 = fneg float %.sroa.034.0.vec.extract
  %42 = call <2 x float> @vrVect(float noundef %.sroa.034.4.vec.extract, float noundef %41) #3
  %43 = load <2 x float>, ptr %14, align 4
  %44 = load <2 x float>, ptr %15, align 4
  %45 = call <2 x float> @vrSub(<2 x float> %43, <2 x float> %44) #3
  %46 = call float @vrDot(<2 x float> %42, <2 x float> %45) #3
  %47 = fcmp ult float %46, 0.000000e+00
  br i1 %47, label %52, label %48

48:                                               ; preds = %39
  %.sroa.025.0.vec.extract = extractelement <2 x float> %42, i64 0
  %49 = fneg float %.sroa.025.0.vec.extract
  %.sroa.025.4.vec.extract = extractelement <2 x float> %42, i64 1
  %50 = fneg float %.sroa.025.4.vec.extract
  %51 = call <2 x float> @vrVect(float noundef %49, float noundef %50) #3
  br label %52

52:                                               ; preds = %39, %48
  %.sroa.025.0 = phi <2 x float> [ %51, %48 ], [ %42, %39 ]
  br i1 %28, label %57, label %53

53:                                               ; preds = %52
  %.sroa.025.0.vec.extract31 = extractelement <2 x float> %.sroa.025.0, i64 0
  %54 = fneg float %.sroa.025.0.vec.extract31
  %.sroa.025.4.vec.extract33 = extractelement <2 x float> %.sroa.025.0, i64 1
  %55 = fneg float %.sroa.025.4.vec.extract33
  %56 = call <2 x float> @vrVect(float noundef %54, float noundef %55) #3
  br label %57

57:                                               ; preds = %53, %52
  %.sroa.025.1 = phi <2 x float> [ %56, %53 ], [ %.sroa.025.0, %52 ]
  %58 = call float @vrDot(<2 x float> %40, <2 x float> %.sroa.070.0) #3
  %59 = call float @vrDot(<2 x float> %40, <2 x float> %.sroa.572.0) #3
  %60 = call float @vrDot(<2 x float> %.sroa.025.1, <2 x float> %.sroa.675.0) #3
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %10) #3
  %61 = call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00) #3
  store <2 x float> %61, ptr %10, align 16
  %62 = getelementptr inbounds i8, ptr %10, i64 8
  %63 = call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00) #3
  store <2 x float> %63, ptr %62, align 8
  %64 = call i32 @Clip(<2 x float> %.sroa.064.0, <2 x float> %.sroa.5.0, <2 x float> %40, float noundef %58, ptr noundef nonnull %10)
  %65 = icmp slt i32 %64, 2
  br i1 %65, label %103, label %66

66:                                               ; preds = %57
  %67 = fneg float %59
  %68 = fneg float %.sroa.034.4.vec.extract
  %69 = call <2 x float> @vrVect(float noundef %41, float noundef %68) #3
  %70 = load <2 x float>, ptr %10, align 16
  %71 = load <2 x float>, ptr %62, align 8
  %72 = call i32 @Clip(<2 x float> %70, <2 x float> %71, <2 x float> %69, float noundef %67, ptr noundef nonnull %10)
  %73 = icmp slt i32 %72, 2
  br i1 %73, label %103, label %74

74:                                               ; preds = %66
  %75 = getelementptr inbounds i8, ptr %0, i64 220
  store float 0.000000e+00, ptr %75, align 4, !tbaa !16
  %76 = load <2 x float>, ptr %10, align 16
  %77 = call float @vrDot(<2 x float> %.sroa.025.1, <2 x float> %76) #3
  %78 = fsub float %77, %60
  %79 = fcmp ugt float %78, 0.000000e+00
  br i1 %79, label %85, label %80

80:                                               ; preds = %74
  %81 = getelementptr inbounds i8, ptr %0, i64 24
  %82 = load i64, ptr %10, align 16
  store i64 %82, ptr %81, align 8
  %83 = getelementptr inbounds i8, ptr %0, i64 36
  store <2 x float> zeroinitializer, ptr %83, align 4, !tbaa !15
  %84 = getelementptr inbounds i8, ptr %0, i64 32
  store float %78, ptr %84, align 8, !tbaa !17
  br label %86

85:                                               ; preds = %74
  store float 0.000000e+00, ptr %75, align 4, !tbaa !16
  br label %86

86:                                               ; preds = %85, %80
  %.0 = phi i32 [ 1, %80 ], [ 0, %85 ]
  %87 = load <2 x float>, ptr %62, align 8
  %88 = call float @vrDot(<2 x float> %.sroa.025.1, <2 x float> %87) #3
  %89 = fsub float %88, %60
  %90 = fcmp ugt float %89, 0.000000e+00
  br i1 %90, label %100, label %91

91:                                               ; preds = %86
  %92 = getelementptr inbounds i8, ptr %0, i64 16
  %93 = zext nneg i32 %.0 to i64
  %94 = getelementptr inbounds [2 x %struct.vrContactPoint], ptr %92, i64 0, i64 %93
  %95 = getelementptr inbounds i8, ptr %94, i64 8
  %96 = load i64, ptr %62, align 8
  store i64 %96, ptr %95, align 8
  %97 = getelementptr inbounds i8, ptr %94, i64 20
  store <2 x float> zeroinitializer, ptr %97, align 4, !tbaa !15
  %98 = getelementptr inbounds i8, ptr %94, i64 16
  store float %89, ptr %98, align 8, !tbaa !17
  %99 = add nuw nsw i32 %.0, 1
  br label %100

100:                                              ; preds = %91, %86
  %.1 = phi i32 [ %99, %91 ], [ %.0, %86 ]
  store i32 %.1, ptr %11, align 8, !tbaa !5
  %101 = getelementptr inbounds i8, ptr %0, i64 196
  store <2 x float> %.sroa.025.1, ptr %101, align 4
  %102 = getelementptr inbounds i8, ptr %0, i64 280
  store i32 %.0100, ptr %102, align 8, !tbaa !20
  store float %.099, ptr %75, align 4, !tbaa !16
  br label %103

103:                                              ; preds = %66, %57, %100
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %10) #3
  br label %104

104:                                              ; preds = %103, %21, %3
  call void @llvm.lifetime.end.p0(i64 40, ptr nonnull %7) #3
  call void @llvm.lifetime.end.p0(i64 40, ptr nonnull %6) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %5) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %4) #3
  ret void
}

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

declare <2 x float> @vrVect(float noundef, float noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare dso_local float @vrPolyGetLeastAxis(ptr noundef byval(%struct.vrPolygonShape) align 8, ptr noundef byval(%struct.vrPolygonShape) align 8, ptr noundef, ptr noundef, <2 x float>) local_unnamed_addr #0

declare <2 x float> @vrSub(<2 x float>, <2 x float>) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare dso_local void @vrPolyBestEdge(ptr dead_on_unwind noalias writable sret(%struct.vrEdge) align 4, ptr noundef byval(%struct.vrPolygonShape) align 8, i32 noundef, <2 x float>) local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare dso_local i32 @vrPolyGetFarthestVertex(ptr noundef byval(%struct.vrPolygonShape) align 8, <2 x float>) local_unnamed_addr #0

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

declare <2 x float> @vrNormalize(<2 x float>) local_unnamed_addr #2

declare float @vrDot(<2 x float>, <2 x float>) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare dso_local i32 @Clip(<2 x float>, <2 x float>, <2 x float>, float noundef, ptr noundef) local_unnamed_addr #0

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 = { 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, !10, i64 192}
!6 = !{!"vrManifold", !7, i64 0, !7, i64 8, !8, i64 16, !10, i64 192, !11, i64 196, !11, i64 204, !12, i64 212, !12, i64 216, !12, i64 220, !13, i64 224, !10, i64 280, !10, i64 284, !10, i64 288, !10, i64 292}
!7 = !{!"any pointer", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"int", !8, i64 0}
!11 = !{!"vrVec2", !12, i64 0, !12, i64 4}
!12 = !{!"float", !8, i64 0}
!13 = !{!"vrBlockSolverData", !11, i64 0, !14, i64 8, !11, i64 24, !11, i64 32, !11, i64 40, !11, i64 48}
!14 = !{!"vrMat2", !11, i64 0, !11, i64 8}
!15 = !{!12, !12, i64 0}
!16 = !{!6, !12, i64 220}
!17 = !{!18, !12, i64 16}
!18 = !{!"vrContactPoint", !11, i64 0, !11, i64 8, !12, i64 16, !12, i64 20, !12, i64 24, !12, i64 28, !11, i64 32, !11, i64 40, !12, i64 48, !12, i64 52, !12, i64 56, !12, i64 60, !19, i64 64}
!19 = !{!"vrLocalPoint", !12, i64 0, !11, i64 4, !7, i64 16}
!20 = !{!6, !10, i64 280}


; Effective O3 passes: DSEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,PostOrderFunctionAttrsPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass