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

; 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.vrOrientedBoundingBox = type { %struct.vrVec2, %struct.vrVec2 }
%struct.vrVec2 = type { float, float }
%struct.vrRigidBody = type { %struct.vrVec2, %struct.vrVec2, %struct.vrVec2, %struct.vrVec2, float, float, float, float, %struct.vrCollisionGroup, %struct.vrMaterial, ptr, %struct.vrColor, %struct.vrVec2, %struct.vrOrientedBoundingBox, ptr, i32 }
%struct.vrCollisionGroup = type { i32, i32 }
%struct.vrMaterial = type { float, float, float, float, float, float, float, float }
%struct.vrColor = type { float, float, float }
%struct.vrArray = type { ptr, i32, i32, i32, i32 }
%struct.vrParticleSystem = type { ptr, float, float, float, float, float, float, float, %struct.vrVec2, ptr }
%struct.vrParticle = type { %struct.vrVec2, %struct.vrVec2, %struct.vrVec2, %struct.vrVec2, %struct.vrVec2, float, float, float, float, float, float, float, %struct.vrColor }
%struct.vrShape = type { ptr, i32, ptr, ptr, ptr, ptr, %struct.vrOrientedBoundingBox }
%struct.vrCircleShape = type { float, %struct.vrVec2 }
%struct.vrPolygonShape = type { ptr, i32, ptr, i32, %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: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #0

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

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

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

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

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

declare <2 x float> @vrAdd(<2 x float>, <2 x float>) #1

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

50:                                               ; preds = %543, %4
  %51 = load i32, ptr %12, align 4, !tbaa !11
  %52 = load ptr, ptr %6, align 8, !tbaa !5
  %53 = getelementptr inbounds %struct.vrRigidBody, ptr %52, i32 0, i32 10
  %54 = load ptr, ptr %53, align 8, !tbaa !13
  %55 = getelementptr inbounds %struct.vrArray, ptr %54, i32 0, i32 1
  %56 = load i32, ptr %55, align 8, !tbaa !20
  %57 = icmp slt i32 %51, %56
  br i1 %57, label %59, label %58

58:                                               ; preds = %50
  store i32 2, ptr %13, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #5
  br label %546

59:                                               ; preds = %50
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #5
  %60 = load ptr, ptr %6, align 8, !tbaa !5
  %61 = getelementptr inbounds %struct.vrRigidBody, ptr %60, i32 0, i32 10
  %62 = load ptr, ptr %61, align 8, !tbaa !13
  %63 = getelementptr inbounds %struct.vrArray, ptr %62, i32 0, i32 0
  %64 = load ptr, ptr %63, align 8, !tbaa !22
  %65 = load i32, ptr %12, align 4, !tbaa !11
  %66 = sext i32 %65 to i64
  %67 = getelementptr inbounds ptr, ptr %64, i64 %66
  %68 = load ptr, ptr %67, align 8, !tbaa !5
  store ptr %68, ptr %14, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #5
  store i32 0, ptr %15, align 4, !tbaa !11
  br label %69

69:                                               ; preds = %539, %59
  %70 = load i32, ptr %15, align 4, !tbaa !11
  %71 = load ptr, ptr %5, align 8, !tbaa !5
  %72 = getelementptr inbounds %struct.vrParticleSystem, ptr %71, i32 0, i32 0
  %73 = load ptr, ptr %72, align 8, !tbaa !23
  %74 = getelementptr inbounds %struct.vrArray, ptr %73, i32 0, i32 1
  %75 = load i32, ptr %74, align 8, !tbaa !20
  %76 = icmp slt i32 %70, %75
  br i1 %76, label %78, label %77

77:                                               ; preds = %69
  store i32 5, ptr %13, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #5
  br label %542

78:                                               ; preds = %69
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #5
  store i32 0, ptr %16, align 4, !tbaa !11
  br label %79

79:                                               ; preds = %535, %78
  %80 = load i32, ptr %16, align 4, !tbaa !11
  %81 = load ptr, ptr %5, align 8, !tbaa !5
  %82 = getelementptr inbounds %struct.vrParticleSystem, ptr %81, i32 0, i32 9
  %83 = load ptr, ptr %82, align 8, !tbaa !25
  %84 = getelementptr inbounds %struct.vrRigidBody, ptr %83, i32 0, i32 10
  %85 = load ptr, ptr %84, align 8, !tbaa !13
  %86 = getelementptr inbounds %struct.vrArray, ptr %85, i32 0, i32 1
  %87 = load i32, ptr %86, align 8, !tbaa !20
  %88 = icmp slt i32 %80, %87
  br i1 %88, label %90, label %89

89:                                               ; preds = %79
  store i32 8, ptr %13, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #5
  br label %538

90:                                               ; preds = %79
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #5
  %91 = load ptr, ptr %5, align 8, !tbaa !5
  %92 = getelementptr inbounds %struct.vrParticleSystem, ptr %91, i32 0, i32 0
  %93 = load ptr, ptr %92, align 8, !tbaa !23
  %94 = getelementptr inbounds %struct.vrArray, ptr %93, i32 0, i32 0
  %95 = load ptr, ptr %94, align 8, !tbaa !22
  %96 = load i32, ptr %15, align 4, !tbaa !11
  %97 = sext i32 %96 to i64
  %98 = getelementptr inbounds ptr, ptr %95, i64 %97
  %99 = load ptr, ptr %98, align 8, !tbaa !5
  store ptr %99, ptr %17, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 16, ptr %18) #5
  %100 = getelementptr inbounds %struct.vrOrientedBoundingBox, ptr %18, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #5
  %101 = load ptr, ptr %17, align 8, !tbaa !5
  %102 = getelementptr inbounds %struct.vrParticle, ptr %101, i32 0, i32 0
  %103 = load float, ptr %7, align 4, !tbaa !9
  %104 = load <2 x float>, ptr %102, align 4
  %105 = call <2 x float> @vrScale(<2 x float> %104, float noundef %103)
  store <2 x float> %105, ptr %20, align 4
  %106 = load ptr, ptr %17, align 8, !tbaa !5
  %107 = getelementptr inbounds %struct.vrParticle, ptr %106, i32 0, i32 8
  %108 = load float, ptr %107, align 4, !tbaa !26
  %109 = load float, ptr %7, align 4, !tbaa !9
  %110 = fmul float %108, %109
  %111 = load ptr, ptr %17, align 8, !tbaa !5
  %112 = getelementptr inbounds %struct.vrParticle, ptr %111, i32 0, i32 8
  %113 = load float, ptr %112, align 4, !tbaa !26
  %114 = load float, ptr %7, align 4, !tbaa !9
  %115 = fmul float %113, %114
  %116 = call <2 x float> @vrVect(float noundef %110, float noundef %115)
  store <2 x float> %116, ptr %21, align 4
  %117 = load <2 x float>, ptr %20, align 4
  %118 = load <2 x float>, ptr %21, align 4
  %119 = call <2 x float> @vrSub(<2 x float> %117, <2 x float> %118)
  store <2 x float> %119, ptr %19, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %100, ptr align 4 %19, i64 8, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #5
  %120 = getelementptr inbounds %struct.vrOrientedBoundingBox, ptr %18, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #5
  %121 = load ptr, ptr %17, align 8, !tbaa !5
  %122 = getelementptr inbounds %struct.vrParticle, ptr %121, i32 0, i32 8
  %123 = load float, ptr %122, align 4, !tbaa !26
  %124 = fmul float %123, 2.000000e+00
  %125 = load float, ptr %7, align 4, !tbaa !9
  %126 = fmul float %124, %125
  %127 = load ptr, ptr %17, align 8, !tbaa !5
  %128 = getelementptr inbounds %struct.vrParticle, ptr %127, i32 0, i32 8
  %129 = load float, ptr %128, align 4, !tbaa !26
  %130 = fmul float %129, 2.000000e+00
  %131 = load float, ptr %7, align 4, !tbaa !9
  %132 = fmul float %130, %131
  %133 = call <2 x float> @vrVect(float noundef %126, float noundef %132)
  store <2 x float> %133, ptr %22, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %120, ptr align 4 %22, i64 8, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #5
  %134 = load ptr, ptr %17, align 8, !tbaa !5
  %135 = getelementptr inbounds %struct.vrParticle, ptr %134, i32 0, i32 8
  %136 = load float, ptr %135, align 4, !tbaa !26
  %137 = load float, ptr %7, align 4, !tbaa !9
  %138 = fmul float %136, %137
  store float %138, ptr %9, align 4, !tbaa !9
  %139 = load ptr, ptr %14, align 8, !tbaa !5
  %140 = getelementptr inbounds %struct.vrShape, ptr %139, i32 0, i32 5
  %141 = load ptr, ptr %140, align 8, !tbaa !29
  %142 = load ptr, ptr %14, align 8, !tbaa !5
  %143 = getelementptr inbounds %struct.vrShape, ptr %142, i32 0, i32 0
  %144 = load ptr, ptr %143, align 8, !tbaa !31
  %145 = call { <2 x float>, <2 x float> } %141(ptr noundef %144)
  %146 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %23, i32 0, i32 0
  %147 = extractvalue { <2 x float>, <2 x float> } %145, 0
  store <2 x float> %147, ptr %146, align 4
  %148 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %23, i32 0, i32 1
  %149 = extractvalue { <2 x float>, <2 x float> } %145, 1
  store <2 x float> %149, ptr %148, align 4
  %150 = load ptr, ptr %14, align 8, !tbaa !5
  %151 = getelementptr inbounds %struct.vrShape, ptr %150, i32 0, i32 6
  %152 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %18, i32 0, i32 0
  %153 = load <2 x float>, ptr %152, align 4
  %154 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %18, i32 0, i32 1
  %155 = load <2 x float>, ptr %154, align 4
  %156 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %151, i32 0, i32 0
  %157 = load <2 x float>, ptr %156, align 8
  %158 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %151, i32 0, i32 1
  %159 = load <2 x float>, ptr %158, align 8
  %160 = call i32 @vrOBBOverlaps(<2 x float> %153, <2 x float> %155, <2 x float> %157, <2 x float> %159)
  %161 = icmp ne i32 %160, 0
  br i1 %161, label %162, label %534

162:                                              ; preds = %90
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #5
  %163 = load ptr, ptr %5, align 8, !tbaa !5
  %164 = getelementptr inbounds %struct.vrParticleSystem, ptr %163, i32 0, i32 9
  %165 = load ptr, ptr %164, align 8, !tbaa !25
  %166 = getelementptr inbounds %struct.vrRigidBody, ptr %165, i32 0, i32 10
  %167 = load ptr, ptr %166, align 8, !tbaa !13
  %168 = getelementptr inbounds %struct.vrArray, ptr %167, i32 0, i32 0
  %169 = load ptr, ptr %168, align 8, !tbaa !22
  %170 = getelementptr inbounds ptr, ptr %169, i64 0
  %171 = load ptr, ptr %170, align 8, !tbaa !5
  store ptr %171, ptr %24, align 8, !tbaa !5
  %172 = load ptr, ptr %5, align 8, !tbaa !5
  %173 = getelementptr inbounds %struct.vrParticleSystem, ptr %172, i32 0, i32 9
  %174 = load ptr, ptr %173, align 8, !tbaa !25
  %175 = getelementptr inbounds %struct.vrRigidBody, ptr %174, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #5
  %176 = load ptr, ptr %17, align 8, !tbaa !5
  %177 = getelementptr inbounds %struct.vrParticle, ptr %176, i32 0, i32 2
  %178 = load float, ptr %7, align 4, !tbaa !9
  %179 = load <2 x float>, ptr %177, align 4
  %180 = call <2 x float> @vrScale(<2 x float> %179, float noundef %178)
  store <2 x float> %180, ptr %25, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %175, ptr align 4 %25, i64 8, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #5
  %181 = load ptr, ptr %5, align 8, !tbaa !5
  %182 = getelementptr inbounds %struct.vrParticleSystem, ptr %181, i32 0, i32 9
  %183 = load ptr, ptr %182, align 8, !tbaa !25
  %184 = getelementptr inbounds %struct.vrRigidBody, ptr %183, i32 0, i32 9
  %185 = getelementptr inbounds %struct.vrMaterial, ptr %184, i32 0, i32 5
  store float 0.000000e+00, ptr %185, align 4, !tbaa !32
  %186 = load ptr, ptr %5, align 8, !tbaa !5
  %187 = getelementptr inbounds %struct.vrParticleSystem, ptr %186, i32 0, i32 9
  %188 = load ptr, ptr %187, align 8, !tbaa !25
  %189 = getelementptr inbounds %struct.vrRigidBody, ptr %188, i32 0, i32 9
  %190 = getelementptr inbounds %struct.vrMaterial, ptr %189, i32 0, i32 0
  store float 0.000000e+00, ptr %190, align 8, !tbaa !33
  %191 = load ptr, ptr %5, align 8, !tbaa !5
  %192 = getelementptr inbounds %struct.vrParticleSystem, ptr %191, i32 0, i32 9
  %193 = load ptr, ptr %192, align 8, !tbaa !25
  %194 = getelementptr inbounds %struct.vrRigidBody, ptr %193, i32 0, i32 9
  %195 = getelementptr inbounds %struct.vrMaterial, ptr %194, i32 0, i32 1
  store float 0.000000e+00, ptr %195, align 4, !tbaa !34
  %196 = load ptr, ptr %5, align 8, !tbaa !5
  %197 = getelementptr inbounds %struct.vrParticleSystem, ptr %196, i32 0, i32 9
  %198 = load ptr, ptr %197, align 8, !tbaa !25
  %199 = getelementptr inbounds %struct.vrRigidBody, ptr %198, i32 0, i32 9
  %200 = getelementptr inbounds %struct.vrMaterial, ptr %199, i32 0, i32 4
  store float 1.000000e+00, ptr %200, align 8, !tbaa !35
  %201 = load ptr, ptr %5, align 8, !tbaa !5
  %202 = getelementptr inbounds %struct.vrParticleSystem, ptr %201, i32 0, i32 9
  %203 = load ptr, ptr %202, align 8, !tbaa !25
  %204 = getelementptr inbounds %struct.vrRigidBody, ptr %203, i32 0, i32 9
  %205 = getelementptr inbounds %struct.vrMaterial, ptr %204, i32 0, i32 2
  %206 = load float, ptr %205, align 8, !tbaa !36
  store float %206, ptr %10, align 4, !tbaa !9
  %207 = load ptr, ptr %24, align 8, !tbaa !5
  %208 = getelementptr inbounds %struct.vrShape, ptr %207, i32 0, i32 0
  %209 = load ptr, ptr %208, align 8, !tbaa !31
  %210 = getelementptr inbounds %struct.vrCircleShape, ptr %209, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #5
  %211 = load ptr, ptr %17, align 8, !tbaa !5
  %212 = getelementptr inbounds %struct.vrParticle, ptr %211, i32 0, i32 0
  %213 = load float, ptr %7, align 4, !tbaa !9
  %214 = load <2 x float>, ptr %212, align 4
  %215 = call <2 x float> @vrScale(<2 x float> %214, float noundef %213)
  store <2 x float> %215, ptr %26, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %210, ptr align 4 %26, i64 8, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #5
  %216 = load ptr, ptr %17, align 8, !tbaa !5
  %217 = getelementptr inbounds %struct.vrParticle, ptr %216, i32 0, i32 8
  %218 = load float, ptr %217, align 4, !tbaa !26
  %219 = load float, ptr %7, align 4, !tbaa !9
  %220 = fmul float %218, %219
  %221 = load ptr, ptr %24, align 8, !tbaa !5
  %222 = getelementptr inbounds %struct.vrShape, ptr %221, i32 0, i32 0
  %223 = load ptr, ptr %222, align 8, !tbaa !31
  %224 = getelementptr inbounds %struct.vrCircleShape, ptr %223, i32 0, i32 0
  store float %220, ptr %224, align 4, !tbaa !37
  %225 = load ptr, ptr %14, align 8, !tbaa !5
  %226 = getelementptr inbounds %struct.vrShape, ptr %225, i32 0, i32 1
  %227 = load i32, ptr %226, align 8, !tbaa !39
  %228 = icmp eq i32 %227, 0
  br i1 %228, label %229, label %383

229:                                              ; preds = %162
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #5
  %230 = call ptr (...) @vrManifoldAlloc()
  %231 = call ptr @vrManifoldInit(ptr noundef %230)
  store ptr %231, ptr %27, align 8, !tbaa !5
  %232 = load ptr, ptr %27, align 8, !tbaa !5
  %233 = load ptr, ptr %24, align 8, !tbaa !5
  %234 = getelementptr inbounds %struct.vrShape, ptr %233, i32 0, i32 0
  %235 = load ptr, ptr %234, align 8, !tbaa !31
  %236 = load ptr, ptr %14, align 8, !tbaa !5
  %237 = getelementptr inbounds %struct.vrShape, ptr %236, i32 0, i32 0
  %238 = load ptr, ptr %237, align 8, !tbaa !31
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %28, ptr align 4 %235, i64 12, i1 false)
  %239 = getelementptr inbounds { <2 x float>, float }, ptr %28, i32 0, i32 0
  %240 = load <2 x float>, ptr %239, align 4
  %241 = getelementptr inbounds { <2 x float>, float }, ptr %28, i32 0, i32 1
  %242 = load float, ptr %241, align 4
  call void @vrCirclePoly(ptr noundef %232, <2 x float> %240, float %242, ptr noundef byval(%struct.vrPolygonShape) align 8 %238)
  %243 = load ptr, ptr %27, align 8, !tbaa !5
  %244 = getelementptr inbounds %struct.vrManifold, ptr %243, i32 0, i32 3
  %245 = load i32, ptr %244, align 8, !tbaa !40
  %246 = icmp sgt i32 %245, 0
  br i1 %246, label %247, label %381

247:                                              ; preds = %229
  %248 = load ptr, ptr %27, align 8, !tbaa !5
  %249 = load ptr, ptr %5, align 8, !tbaa !5
  %250 = getelementptr inbounds %struct.vrParticleSystem, ptr %249, i32 0, i32 9
  %251 = load ptr, ptr %250, align 8, !tbaa !25
  %252 = load ptr, ptr %6, align 8, !tbaa !5
  call void @vrManifoldSetBodies(ptr noundef %248, ptr noundef %251, ptr noundef %252)
  %253 = load ptr, ptr %27, align 8, !tbaa !5
  %254 = load float, ptr %8, align 4, !tbaa !9
  call void @vrManifoldPreStep(ptr noundef %253, float noundef %254)
  %255 = load ptr, ptr %27, align 8, !tbaa !5
  %256 = load float, ptr %8, align 4, !tbaa !9
  call void @vrManifoldPostStep(ptr noundef %255, float noundef %256)
  %257 = load ptr, ptr %27, align 8, !tbaa !5
  %258 = load float, ptr %8, align 4, !tbaa !9
  call void @vrManifoldSolvePosition(ptr noundef %257, float noundef %258)
  %259 = load ptr, ptr %17, align 8, !tbaa !5
  %260 = getelementptr inbounds %struct.vrParticle, ptr %259, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #5
  %261 = load ptr, ptr %5, align 8, !tbaa !5
  %262 = getelementptr inbounds %struct.vrParticleSystem, ptr %261, i32 0, i32 9
  %263 = load ptr, ptr %262, align 8, !tbaa !25
  %264 = getelementptr inbounds %struct.vrRigidBody, ptr %263, i32 0, i32 1
  %265 = load float, ptr %7, align 4, !tbaa !9
  %266 = fpext float %265 to double
  %267 = fdiv double 1.000000e+00, %266
  %268 = fptrunc double %267 to float
  %269 = load <2 x float>, ptr %264, align 8
  %270 = call <2 x float> @vrScale(<2 x float> %269, float noundef %268)
  store <2 x float> %270, ptr %29, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %260, ptr align 4 %29, i64 8, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #5
  %271 = load ptr, ptr %5, align 8, !tbaa !5
  %272 = getelementptr inbounds %struct.vrParticleSystem, ptr %271, i32 0, i32 9
  %273 = load ptr, ptr %272, align 8, !tbaa !25
  %274 = getelementptr inbounds %struct.vrRigidBody, ptr %273, i32 0, i32 1
  %275 = load float, ptr %7, align 4, !tbaa !9
  %276 = fpext float %275 to double
  %277 = fdiv double 1.000000e+00, %276
  %278 = fptrunc double %277 to float
  %279 = load <2 x float>, ptr %274, align 8
  %280 = call <2 x float> @vrScale(<2 x float> %279, float noundef %278)
  store <2 x float> %280, ptr %30, align 4
  %281 = load <2 x float>, ptr %30, align 4
  %282 = call float @vrLength(<2 x float> %281)
  %283 = load float, ptr %9, align 4, !tbaa !9
  %284 = fdiv float %282, %283
  %285 = load float, ptr %11, align 4, !tbaa !9
  %286 = fadd float %285, %284
  store float %286, ptr %11, align 4, !tbaa !9
  %287 = load ptr, ptr %17, align 8, !tbaa !5
  %288 = getelementptr inbounds %struct.vrParticle, ptr %287, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #5
  %289 = load ptr, ptr %17, align 8, !tbaa !5
  %290 = getelementptr inbounds %struct.vrParticle, ptr %289, i32 0, i32 0
  %291 = load ptr, ptr %5, align 8, !tbaa !5
  %292 = getelementptr inbounds %struct.vrParticleSystem, ptr %291, i32 0, i32 9
  %293 = load ptr, ptr %292, align 8, !tbaa !25
  %294 = getelementptr inbounds %struct.vrRigidBody, ptr %293, i32 0, i32 3
  %295 = load float, ptr %7, align 4, !tbaa !9
  %296 = fpext float %295 to double
  %297 = fdiv double 1.000000e+00, %296
  %298 = load float, ptr %8, align 4, !tbaa !9
  %299 = fpext float %298 to double
  %300 = fmul double %297, %299
  %301 = fptrunc double %300 to float
  %302 = load <2 x float>, ptr %294, align 8
  %303 = call <2 x float> @vrScale(<2 x float> %302, float noundef %301)
  store <2 x float> %303, ptr %32, align 4
  %304 = load <2 x float>, ptr %290, align 4
  %305 = load <2 x float>, ptr %32, align 4
  %306 = call <2 x float> @vrAdd(<2 x float> %304, <2 x float> %305)
  store <2 x float> %306, ptr %31, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %288, ptr align 4 %31, i64 8, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #5
  %307 = load ptr, ptr %5, align 8, !tbaa !5
  %308 = getelementptr inbounds %struct.vrParticleSystem, ptr %307, i32 0, i32 9
  %309 = load ptr, ptr %308, align 8, !tbaa !25
  %310 = getelementptr inbounds %struct.vrRigidBody, ptr %309, i32 0, i32 3
  %311 = load float, ptr %7, align 4, !tbaa !9
  %312 = fpext float %311 to double
  %313 = fdiv double 1.000000e+00, %312
  %314 = load float, ptr %8, align 4, !tbaa !9
  %315 = fpext float %314 to double
  %316 = fmul double %313, %315
  %317 = fptrunc double %316 to float
  %318 = load <2 x float>, ptr %310, align 8
  %319 = call <2 x float> @vrScale(<2 x float> %318, float noundef %317)
  store <2 x float> %319, ptr %33, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %30, ptr align 4 %33, i64 8, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #5
  %320 = load <2 x float>, ptr %30, align 4
  %321 = call float @vrLength(<2 x float> %320)
  %322 = load float, ptr %9, align 4, !tbaa !9
  %323 = fdiv float %321, %322
  %324 = load float, ptr %11, align 4, !tbaa !9
  %325 = fadd float %324, %323
  store float %325, ptr %11, align 4, !tbaa !9
  %326 = load ptr, ptr %5, align 8, !tbaa !5
  %327 = getelementptr inbounds %struct.vrParticleSystem, ptr %326, i32 0, i32 9
  %328 = load ptr, ptr %327, align 8, !tbaa !25
  %329 = getelementptr inbounds %struct.vrRigidBody, ptr %328, i32 0, i32 3
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #5
  %330 = call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00)
  store <2 x float> %330, ptr %34, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %329, ptr align 4 %34, i64 8, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #5
  %331 = load ptr, ptr %6, align 8, !tbaa !5
  %332 = getelementptr inbounds %struct.vrRigidBody, ptr %331, i32 0, i32 9
  %333 = getelementptr inbounds %struct.vrMaterial, ptr %332, i32 0, i32 2
  %334 = load float, ptr %333, align 8, !tbaa !36
  %335 = fneg float %334
  %336 = fpext float %335 to double
  %337 = load ptr, ptr %27, align 8, !tbaa !5
  %338 = getelementptr inbounds %struct.vrManifold, ptr %337, i32 0, i32 8
  %339 = load float, ptr %338, align 4, !tbaa !44
  %340 = load ptr, ptr %17, align 8, !tbaa !5
  %341 = getelementptr inbounds %struct.vrParticle, ptr %340, i32 0, i32 8
  %342 = load float, ptr %341, align 4, !tbaa !26
  %343 = load float, ptr %7, align 4, !tbaa !9
  %344 = fmul float %342, %343
  %345 = fdiv float %339, %344
  %346 = fsub float 1.000000e+00, %345
  %347 = fpext float %346 to double
  %348 = call double @pow(double noundef %347, double noundef 2.000000e+00) #5
  %349 = fmul double %336, %348
  %350 = load float, ptr %7, align 4, !tbaa !9
  %351 = fpext float %350 to double
  %352 = fdiv double %349, %351
  %353 = fptrunc double %352 to float
  %354 = load ptr, ptr %17, align 8, !tbaa !5
  %355 = getelementptr inbounds %struct.vrParticle, ptr %354, i32 0, i32 5
  store float %353, ptr %355, align 4, !tbaa !45
  %356 = load ptr, ptr %6, align 8, !tbaa !5
  %357 = getelementptr inbounds %struct.vrRigidBody, ptr %356, i32 0, i32 9
  %358 = getelementptr inbounds %struct.vrMaterial, ptr %357, i32 0, i32 2
  %359 = load float, ptr %358, align 8, !tbaa !36
  %360 = fneg float %359
  %361 = fpext float %360 to double
  %362 = load ptr, ptr %27, align 8, !tbaa !5
  %363 = getelementptr inbounds %struct.vrManifold, ptr %362, i32 0, i32 8
  %364 = load float, ptr %363, align 4, !tbaa !44
  %365 = load ptr, ptr %17, align 8, !tbaa !5
  %366 = getelementptr inbounds %struct.vrParticle, ptr %365, i32 0, i32 8
  %367 = load float, ptr %366, align 4, !tbaa !26
  %368 = load float, ptr %7, align 4, !tbaa !9
  %369 = fmul float %367, %368
  %370 = fdiv float %364, %369
  %371 = fsub float 1.000000e+00, %370
  %372 = fpext float %371 to double
  %373 = call double @pow(double noundef %372, double noundef 3.000000e+00) #5
  %374 = fmul double %361, %373
  %375 = load float, ptr %7, align 4, !tbaa !9
  %376 = fpext float %375 to double
  %377 = fdiv double %374, %376
  %378 = fptrunc double %377 to float
  %379 = load ptr, ptr %17, align 8, !tbaa !5
  %380 = getelementptr inbounds %struct.vrParticle, ptr %379, i32 0, i32 10
  store float %378, ptr %380, align 4, !tbaa !46
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #5
  br label %381

381:                                              ; preds = %247, %229
  %382 = load ptr, ptr %27, align 8, !tbaa !5
  call void @vrManifoldDestroy(ptr noundef %382)
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #5
  br label %533

383:                                              ; preds = %162
  %384 = load ptr, ptr %14, align 8, !tbaa !5
  %385 = getelementptr inbounds %struct.vrShape, ptr %384, i32 0, i32 1
  %386 = load i32, ptr %385, align 8, !tbaa !39
  %387 = icmp eq i32 %386, 1
  br i1 %387, label %388, label %532

388:                                              ; preds = %383
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #5
  %389 = call ptr (...) @vrManifoldAlloc()
  %390 = call ptr @vrManifoldInit(ptr noundef %389)
  store ptr %390, ptr %35, align 8, !tbaa !5
  %391 = load ptr, ptr %35, align 8, !tbaa !5
  %392 = load ptr, ptr %24, align 8, !tbaa !5
  %393 = getelementptr inbounds %struct.vrShape, ptr %392, i32 0, i32 0
  %394 = load ptr, ptr %393, align 8, !tbaa !31
  %395 = load ptr, ptr %14, align 8, !tbaa !5
  %396 = getelementptr inbounds %struct.vrShape, ptr %395, i32 0, i32 0
  %397 = load ptr, ptr %396, align 8, !tbaa !31
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %36, ptr align 4 %394, i64 12, i1 false)
  %398 = getelementptr inbounds { <2 x float>, float }, ptr %36, i32 0, i32 0
  %399 = load <2 x float>, ptr %398, align 4
  %400 = getelementptr inbounds { <2 x float>, float }, ptr %36, i32 0, i32 1
  %401 = load float, ptr %400, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %37, ptr align 4 %397, i64 12, i1 false)
  %402 = getelementptr inbounds { <2 x float>, float }, ptr %37, i32 0, i32 0
  %403 = load <2 x float>, ptr %402, align 4
  %404 = getelementptr inbounds { <2 x float>, float }, ptr %37, i32 0, i32 1
  %405 = load float, ptr %404, align 4
  call void @vrCircleCircle(ptr noundef %391, <2 x float> %399, float %401, <2 x float> %403, float %405)
  %406 = load ptr, ptr %35, align 8, !tbaa !5
  %407 = getelementptr inbounds %struct.vrManifold, ptr %406, i32 0, i32 3
  %408 = load i32, ptr %407, align 8, !tbaa !40
  %409 = icmp sgt i32 %408, 0
  br i1 %409, label %410, label %530

410:                                              ; preds = %388
  %411 = load ptr, ptr %35, align 8, !tbaa !5
  %412 = load ptr, ptr %5, align 8, !tbaa !5
  %413 = getelementptr inbounds %struct.vrParticleSystem, ptr %412, i32 0, i32 9
  %414 = load ptr, ptr %413, align 8, !tbaa !25
  %415 = load ptr, ptr %6, align 8, !tbaa !5
  call void @vrManifoldSetBodies(ptr noundef %411, ptr noundef %414, ptr noundef %415)
  %416 = load ptr, ptr %35, align 8, !tbaa !5
  %417 = load float, ptr %8, align 4, !tbaa !9
  call void @vrManifoldPreStep(ptr noundef %416, float noundef %417)
  %418 = load ptr, ptr %35, align 8, !tbaa !5
  %419 = load float, ptr %8, align 4, !tbaa !9
  call void @vrManifoldPostStep(ptr noundef %418, float noundef %419)
  %420 = load ptr, ptr %35, align 8, !tbaa !5
  %421 = load float, ptr %8, align 4, !tbaa !9
  call void @vrManifoldSolvePosition(ptr noundef %420, float noundef %421)
  %422 = load ptr, ptr %17, align 8, !tbaa !5
  %423 = getelementptr inbounds %struct.vrParticle, ptr %422, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #5
  %424 = load ptr, ptr %5, align 8, !tbaa !5
  %425 = getelementptr inbounds %struct.vrParticleSystem, ptr %424, i32 0, i32 9
  %426 = load ptr, ptr %425, align 8, !tbaa !25
  %427 = getelementptr inbounds %struct.vrRigidBody, ptr %426, i32 0, i32 1
  %428 = load float, ptr %7, align 4, !tbaa !9
  %429 = fpext float %428 to double
  %430 = fdiv double 1.000000e+00, %429
  %431 = fptrunc double %430 to float
  %432 = load <2 x float>, ptr %427, align 8
  %433 = call <2 x float> @vrScale(<2 x float> %432, float noundef %431)
  store <2 x float> %433, ptr %38, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %423, ptr align 4 %38, i64 8, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #5
  %434 = load ptr, ptr %5, align 8, !tbaa !5
  %435 = getelementptr inbounds %struct.vrParticleSystem, ptr %434, i32 0, i32 9
  %436 = load ptr, ptr %435, align 8, !tbaa !25
  %437 = getelementptr inbounds %struct.vrRigidBody, ptr %436, i32 0, i32 1
  %438 = load float, ptr %7, align 4, !tbaa !9
  %439 = fpext float %438 to double
  %440 = fdiv double 1.000000e+00, %439
  %441 = fptrunc double %440 to float
  %442 = load <2 x float>, ptr %437, align 8
  %443 = call <2 x float> @vrScale(<2 x float> %442, float noundef %441)
  store <2 x float> %443, ptr %39, align 4
  %444 = load <2 x float>, ptr %39, align 4
  %445 = call float @vrLength(<2 x float> %444)
  %446 = load float, ptr %9, align 4, !tbaa !9
  %447 = fdiv float %445, %446
  %448 = load float, ptr %11, align 4, !tbaa !9
  %449 = fadd float %448, %447
  store float %449, ptr %11, align 4, !tbaa !9
  %450 = load ptr, ptr %17, align 8, !tbaa !5
  %451 = getelementptr inbounds %struct.vrParticle, ptr %450, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #5
  %452 = load ptr, ptr %17, align 8, !tbaa !5
  %453 = getelementptr inbounds %struct.vrParticle, ptr %452, i32 0, i32 0
  %454 = load ptr, ptr %5, align 8, !tbaa !5
  %455 = getelementptr inbounds %struct.vrParticleSystem, ptr %454, i32 0, i32 9
  %456 = load ptr, ptr %455, align 8, !tbaa !25
  %457 = getelementptr inbounds %struct.vrRigidBody, ptr %456, i32 0, i32 3
  %458 = load float, ptr %7, align 4, !tbaa !9
  %459 = fpext float %458 to double
  %460 = fdiv double 1.000000e+00, %459
  %461 = load float, ptr %8, align 4, !tbaa !9
  %462 = fpext float %461 to double
  %463 = fmul double %460, %462
  %464 = fptrunc double %463 to float
  %465 = load <2 x float>, ptr %457, align 8
  %466 = call <2 x float> @vrScale(<2 x float> %465, float noundef %464)
  store <2 x float> %466, ptr %41, align 4
  %467 = load <2 x float>, ptr %453, align 4
  %468 = load <2 x float>, ptr %41, align 4
  %469 = call <2 x float> @vrAdd(<2 x float> %467, <2 x float> %468)
  store <2 x float> %469, ptr %40, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %451, ptr align 4 %40, i64 8, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %42) #5
  %470 = load ptr, ptr %5, align 8, !tbaa !5
  %471 = getelementptr inbounds %struct.vrParticleSystem, ptr %470, i32 0, i32 9
  %472 = load ptr, ptr %471, align 8, !tbaa !25
  %473 = getelementptr inbounds %struct.vrRigidBody, ptr %472, i32 0, i32 3
  %474 = load float, ptr %7, align 4, !tbaa !9
  %475 = fpext float %474 to double
  %476 = fdiv double 1.000000e+00, %475
  %477 = load float, ptr %8, align 4, !tbaa !9
  %478 = fpext float %477 to double
  %479 = fmul double %476, %478
  %480 = fptrunc double %479 to float
  %481 = load <2 x float>, ptr %473, align 8
  %482 = call <2 x float> @vrScale(<2 x float> %481, float noundef %480)
  store <2 x float> %482, ptr %42, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %39, ptr align 4 %42, i64 8, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #5
  %483 = load <2 x float>, ptr %39, align 4
  %484 = call float @vrLength(<2 x float> %483)
  %485 = load float, ptr %9, align 4, !tbaa !9
  %486 = fdiv float %484, %485
  %487 = load float, ptr %11, align 4, !tbaa !9
  %488 = fadd float %487, %486
  store float %488, ptr %11, align 4, !tbaa !9
  %489 = load ptr, ptr %5, align 8, !tbaa !5
  %490 = getelementptr inbounds %struct.vrParticleSystem, ptr %489, i32 0, i32 9
  %491 = load ptr, ptr %490, align 8, !tbaa !25
  %492 = getelementptr inbounds %struct.vrRigidBody, ptr %491, i32 0, i32 3
  call void @llvm.lifetime.start.p0(i64 8, ptr %43) #5
  %493 = call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00)
  store <2 x float> %493, ptr %43, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %492, ptr align 4 %43, i64 8, i1 false), !tbaa.struct !28
  call void @llvm.lifetime.end.p0(i64 8, ptr %43) #5
  %494 = load ptr, ptr %35, align 8, !tbaa !5
  %495 = getelementptr inbounds %struct.vrManifold, ptr %494, i32 0, i32 8
  %496 = load float, ptr %495, align 4, !tbaa !44
  %497 = load ptr, ptr %17, align 8, !tbaa !5
  %498 = getelementptr inbounds %struct.vrParticle, ptr %497, i32 0, i32 8
  %499 = load float, ptr %498, align 4, !tbaa !26
  %500 = load float, ptr %7, align 4, !tbaa !9
  %501 = fmul float %499, %500
  %502 = fdiv float %496, %501
  %503 = fsub float 1.000000e+00, %502
  %504 = fpext float %503 to double
  %505 = call double @pow(double noundef %504, double noundef 2.000000e+00) #5
  %506 = load float, ptr %7, align 4, !tbaa !9
  %507 = fpext float %506 to double
  %508 = fdiv double %505, %507
  %509 = fptrunc double %508 to float
  %510 = load ptr, ptr %17, align 8, !tbaa !5
  %511 = getelementptr inbounds %struct.vrParticle, ptr %510, i32 0, i32 5
  store float %509, ptr %511, align 4, !tbaa !45
  %512 = load ptr, ptr %35, align 8, !tbaa !5
  %513 = getelementptr inbounds %struct.vrManifold, ptr %512, i32 0, i32 8
  %514 = load float, ptr %513, align 4, !tbaa !44
  %515 = load ptr, ptr %17, align 8, !tbaa !5
  %516 = getelementptr inbounds %struct.vrParticle, ptr %515, i32 0, i32 8
  %517 = load float, ptr %516, align 4, !tbaa !26
  %518 = load float, ptr %7, align 4, !tbaa !9
  %519 = fmul float %517, %518
  %520 = fdiv float %514, %519
  %521 = fsub float 1.000000e+00, %520
  %522 = fpext float %521 to double
  %523 = call double @pow(double noundef %522, double noundef 3.000000e+00) #5
  %524 = load float, ptr %7, align 4, !tbaa !9
  %525 = fpext float %524 to double
  %526 = fdiv double %523, %525
  %527 = fptrunc double %526 to float
  %528 = load ptr, ptr %17, align 8, !tbaa !5
  %529 = getelementptr inbounds %struct.vrParticle, ptr %528, i32 0, i32 10
  store float %527, ptr %529, align 4, !tbaa !46
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #5
  br label %530

530:                                              ; preds = %410, %388
  %531 = load ptr, ptr %35, align 8, !tbaa !5
  call void @vrManifoldDestroy(ptr noundef %531)
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #5
  br label %532

532:                                              ; preds = %530, %383
  br label %533

533:                                              ; preds = %532, %381
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #5
  br label %534

534:                                              ; preds = %533, %90
  call void @llvm.lifetime.end.p0(i64 16, ptr %18) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #5
  br label %535

535:                                              ; preds = %534
  %536 = load i32, ptr %16, align 4, !tbaa !11
  %537 = add nsw i32 %536, 1
  store i32 %537, ptr %16, align 4, !tbaa !11
  br label %79, !llvm.loop !47

538:                                              ; preds = %89
  br label %539

539:                                              ; preds = %538
  %540 = load i32, ptr %15, align 4, !tbaa !11
  %541 = add nsw i32 %540, 1
  store i32 %541, ptr %15, align 4, !tbaa !11
  br label %69, !llvm.loop !49

542:                                              ; preds = %77
  call void @llvm.lifetime.end.p0(i64 8, ptr %14) #5
  br label %543

543:                                              ; preds = %542
  %544 = load i32, ptr %12, align 4, !tbaa !11
  %545 = add nsw i32 %544, 1
  store i32 %545, ptr %12, align 4, !tbaa !11
  br label %50, !llvm.loop !50

546:                                              ; preds = %58
  store i32 1, ptr %13, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #5
  ret void
}

declare i32 @vrOBBOverlaps(<2 x float>, <2 x float>, <2 x float>, <2 x float>) #1

declare ptr @vrManifoldInit(ptr noundef) #1

declare ptr @vrManifoldAlloc(...) #1

declare void @vrCirclePoly(ptr noundef, <2 x float>, float, ptr noundef byval(%struct.vrPolygonShape) align 8) #1

declare void @vrManifoldSetBodies(ptr noundef, ptr noundef, ptr noundef) #1

declare void @vrManifoldPreStep(ptr noundef, float noundef) #1

declare void @vrManifoldPostStep(ptr noundef, float noundef) #1

declare void @vrManifoldSolvePosition(ptr noundef, float noundef) #1

declare float @vrLength(<2 x float>) #1

; Function Attrs: nounwind
declare double @pow(double noundef, double noundef) #4

declare void @vrManifoldDestroy(ptr noundef) #1

declare void @vrCircleCircle(ptr noundef, <2 x float>, float, <2 x float>, float) #1

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { "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 #2 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #3 = { 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 #4 = { nounwind "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 #5 = { 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, !10, i64 0}
!10 = !{!"float", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"int", !7, i64 0}
!13 = !{!14, !6, i64 88}
!14 = !{!"vrRigidBody", !15, i64 0, !15, i64 8, !15, i64 16, !15, i64 24, !10, i64 32, !10, i64 36, !10, i64 40, !10, i64 44, !16, i64 48, !17, i64 56, !6, i64 88, !18, i64 96, !15, i64 108, !19, i64 116, !6, i64 136, !12, i64 144}
!15 = !{!"vrVec2", !10, i64 0, !10, i64 4}
!16 = !{!"vrCollisionGroup", !12, i64 0, !12, i64 4}
!17 = !{!"vrMaterial", !10, i64 0, !10, i64 4, !10, i64 8, !10, i64 12, !10, i64 16, !10, i64 20, !10, i64 24, !10, i64 28}
!18 = !{!"vrColor", !10, i64 0, !10, i64 4, !10, i64 8}
!19 = !{!"vrOrientedBoundingBox", !15, i64 0, !15, i64 8}
!20 = !{!21, !12, i64 8}
!21 = !{!"vrArray", !6, i64 0, !12, i64 8, !12, i64 12, !12, i64 16, !12, i64 20}
!22 = !{!21, !6, i64 0}
!23 = !{!24, !6, i64 0}
!24 = !{!"vrParticleSystem", !6, i64 0, !10, i64 8, !10, i64 12, !10, i64 16, !10, i64 20, !10, i64 24, !10, i64 28, !10, i64 32, !15, i64 36, !6, i64 48}
!25 = !{!24, !6, i64 48}
!26 = !{!27, !10, i64 52}
!27 = !{!"vrParticle", !15, i64 0, !15, i64 8, !15, i64 16, !15, i64 24, !15, i64 32, !10, i64 40, !10, i64 44, !10, i64 48, !10, i64 52, !10, i64 56, !10, i64 60, !10, i64 64, !18, i64 68}
!28 = !{i64 0, i64 4, !9, i64 4, i64 4, !9}
!29 = !{!30, !6, i64 40}
!30 = !{!"vrShape", !6, i64 0, !12, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !19, i64 48}
!31 = !{!30, !6, i64 0}
!32 = !{!14, !10, i64 76}
!33 = !{!14, !10, i64 56}
!34 = !{!14, !10, i64 60}
!35 = !{!14, !10, i64 72}
!36 = !{!14, !10, i64 64}
!37 = !{!38, !10, i64 0}
!38 = !{!"vrCircleShape", !10, i64 0, !15, i64 4}
!39 = !{!30, !12, i64 8}
!40 = !{!41, !12, i64 192}
!41 = !{!"vrManifold", !6, i64 0, !6, i64 8, !7, i64 16, !12, i64 192, !15, i64 196, !15, i64 204, !10, i64 212, !10, i64 216, !10, i64 220, !42, i64 224, !12, i64 280, !12, i64 284, !12, i64 288, !12, i64 292}
!42 = !{!"vrBlockSolverData", !15, i64 0, !43, i64 8, !15, i64 24, !15, i64 32, !15, i64 40, !15, i64 48}
!43 = !{!"vrMat2", !15, i64 0, !15, i64 8}
!44 = !{!41, !10, i64 220}
!45 = !{!27, !10, i64 40}
!46 = !{!27, !10, i64 60}
!47 = distinct !{!47, !48}
!48 = !{!"llvm.loop.mustprogress"}
!49 = distinct !{!49, !48}
!50 = distinct !{!50, !48}


; 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 }

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

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

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

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

; Function Attrs: nounwind uwtable
define dso_local void @vrParticleSystemCollide(ptr nocapture noundef readonly %0, ptr noundef %1, float noundef %2, float noundef %3) local_unnamed_addr #1 {
  %5 = getelementptr inbounds i8, ptr %1, i64 88
  %6 = load ptr, ptr %5, align 8, !tbaa !5
  %7 = getelementptr inbounds i8, ptr %6, i64 8
  %8 = load i32, ptr %7, align 8, !tbaa !17
  %9 = icmp sgt i32 %8, 0
  br i1 %9, label %.lr.ph170, label %._crit_edge171

.lr.ph170:                                        ; preds = %4
  %10 = getelementptr inbounds i8, ptr %0, i64 48
  %11 = fpext float %2 to double
  %12 = fdiv double 1.000000e+00, %11
  %13 = fptrunc double %12 to float
  %14 = fpext float %3 to double
  %15 = fmul double %12, %14
  %16 = fptrunc double %15 to float
  %17 = getelementptr inbounds i8, ptr %1, i64 64
  %18 = load ptr, ptr %0, align 8, !tbaa !19
  %19 = getelementptr inbounds i8, ptr %18, i64 8
  %20 = load i32, ptr %19, align 8, !tbaa !17
  %21 = icmp sgt i32 %20, 0
  br i1 %21, label %.lr.ph170.split, label %._crit_edge171

._crit_edge171:                                   ; preds = %._crit_edge165, %.lr.ph170, %4
  ret void

.lr.ph170.split:                                  ; preds = %.lr.ph170, %._crit_edge165
  %22 = phi ptr [ %48, %._crit_edge165 ], [ %6, %.lr.ph170 ]
  %23 = phi ptr [ %49, %._crit_edge165 ], [ %18, %.lr.ph170 ]
  %24 = phi ptr [ %50, %._crit_edge165 ], [ %18, %.lr.ph170 ]
  %indvars.iv175 = phi i64 [ %indvars.iv.next176, %._crit_edge165 ], [ 0, %.lr.ph170 ]
  %25 = load ptr, ptr %22, align 8, !tbaa !21
  %26 = getelementptr inbounds ptr, ptr %25, i64 %indvars.iv175
  %27 = load ptr, ptr %26, align 8, !tbaa !22
  %28 = getelementptr inbounds i8, ptr %24, i64 8
  %29 = load i32, ptr %28, align 8, !tbaa !17
  %30 = icmp sgt i32 %29, 0
  br i1 %30, label %.preheader.lr.ph, label %._crit_edge165

.preheader.lr.ph:                                 ; preds = %.lr.ph170.split
  %31 = getelementptr inbounds i8, ptr %27, i64 40
  %32 = getelementptr inbounds i8, ptr %27, i64 48
  %33 = getelementptr inbounds i8, ptr %27, i64 56
  %34 = getelementptr inbounds i8, ptr %27, i64 8
  %35 = load ptr, ptr %10, align 8, !tbaa !23
  %36 = getelementptr inbounds i8, ptr %35, i64 88
  %37 = load ptr, ptr %36, align 8, !tbaa !5
  %38 = getelementptr inbounds i8, ptr %37, i64 8
  %39 = load i32, ptr %38, align 8, !tbaa !17
  %40 = icmp sgt i32 %39, 0
  br i1 %40, label %.preheader, label %._crit_edge165

.preheader:                                       ; preds = %.preheader.lr.ph, %._crit_edge
  %41 = phi ptr [ %55, %._crit_edge ], [ %23, %.preheader.lr.ph ]
  %42 = phi ptr [ %56, %._crit_edge ], [ %35, %.preheader.lr.ph ]
  %indvars.iv = phi i64 [ %indvars.iv.next, %._crit_edge ], [ 0, %.preheader.lr.ph ]
  %43 = getelementptr inbounds i8, ptr %42, i64 88
  %44 = load ptr, ptr %43, align 8, !tbaa !5
  %45 = getelementptr inbounds i8, ptr %44, i64 8
  %46 = load i32, ptr %45, align 8, !tbaa !17
  %47 = icmp sgt i32 %46, 0
  br i1 %47, label %.lr.ph, label %._crit_edge

._crit_edge165.loopexit:                          ; preds = %._crit_edge
  %.pre178 = load ptr, ptr %5, align 8, !tbaa !5
  br label %._crit_edge165

._crit_edge165:                                   ; preds = %.preheader.lr.ph, %._crit_edge165.loopexit, %.lr.ph170.split
  %48 = phi ptr [ %22, %.lr.ph170.split ], [ %.pre178, %._crit_edge165.loopexit ], [ %22, %.preheader.lr.ph ]
  %49 = phi ptr [ %23, %.lr.ph170.split ], [ %55, %._crit_edge165.loopexit ], [ %23, %.preheader.lr.ph ]
  %50 = phi ptr [ %24, %.lr.ph170.split ], [ %55, %._crit_edge165.loopexit ], [ %24, %.preheader.lr.ph ]
  %indvars.iv.next176 = add nuw nsw i64 %indvars.iv175, 1
  %51 = getelementptr inbounds i8, ptr %48, i64 8
  %52 = load i32, ptr %51, align 8, !tbaa !17
  %53 = sext i32 %52 to i64
  %54 = icmp slt i64 %indvars.iv.next176, %53
  br i1 %54, label %.lr.ph170.split, label %._crit_edge171, !llvm.loop !24

._crit_edge.loopexit:                             ; preds = %199
  %.pre = load ptr, ptr %0, align 8, !tbaa !19
  br label %._crit_edge

._crit_edge:                                      ; preds = %._crit_edge.loopexit, %.preheader
  %55 = phi ptr [ %41, %.preheader ], [ %.pre, %._crit_edge.loopexit ]
  %56 = phi ptr [ %42, %.preheader ], [ %201, %._crit_edge.loopexit ]
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %57 = getelementptr inbounds i8, ptr %55, i64 8
  %58 = load i32, ptr %57, align 8, !tbaa !17
  %59 = sext i32 %58 to i64
  %60 = icmp slt i64 %indvars.iv.next, %59
  br i1 %60, label %.preheader, label %._crit_edge165.loopexit, !llvm.loop !27

.lr.ph:                                           ; preds = %.preheader, %199
  %.0158161 = phi i32 [ %200, %199 ], [ 0, %.preheader ]
  %61 = load ptr, ptr %0, align 8, !tbaa !19
  %62 = load ptr, ptr %61, align 8, !tbaa !21
  %63 = getelementptr inbounds ptr, ptr %62, i64 %indvars.iv
  %64 = load ptr, ptr %63, align 8, !tbaa !22
  %65 = load <2 x float>, ptr %64, align 4
  %66 = tail call <2 x float> @vrScale(<2 x float> %65, float noundef %2) #3
  %67 = getelementptr inbounds i8, ptr %64, i64 52
  %68 = load float, ptr %67, align 4, !tbaa !28
  %69 = fmul float %68, %2
  %70 = tail call <2 x float> @vrVect(float noundef %69, float noundef %69) #3
  %71 = tail call <2 x float> @vrSub(<2 x float> %66, <2 x float> %70) #3
  %72 = load float, ptr %67, align 4, !tbaa !28
  %73 = fmul float %72, 2.000000e+00
  %74 = fmul float %73, %2
  %75 = tail call <2 x float> @vrVect(float noundef %74, float noundef %74) #3
  %76 = load ptr, ptr %31, align 8, !tbaa !30
  %77 = load ptr, ptr %27, align 8, !tbaa !32
  %78 = tail call { <2 x float>, <2 x float> } %76(ptr noundef %77) #3
  %79 = load <2 x float>, ptr %32, align 8
  %80 = load <2 x float>, ptr %33, align 8
  %81 = tail call i32 @vrOBBOverlaps(<2 x float> %71, <2 x float> %75, <2 x float> %79, <2 x float> %80) #3
  %.not = icmp eq i32 %81, 0
  br i1 %.not, label %199, label %82

82:                                               ; preds = %.lr.ph
  %83 = load ptr, ptr %10, align 8, !tbaa !23
  %84 = getelementptr inbounds i8, ptr %83, i64 88
  %85 = load ptr, ptr %84, align 8, !tbaa !5
  %86 = load ptr, ptr %85, align 8, !tbaa !21
  %87 = load ptr, ptr %86, align 8, !tbaa !22
  %88 = getelementptr inbounds i8, ptr %83, i64 8
  %89 = getelementptr inbounds i8, ptr %64, i64 16
  %90 = load <2 x float>, ptr %89, align 4
  %91 = tail call <2 x float> @vrScale(<2 x float> %90, float noundef %2) #3
  store <2 x float> %91, ptr %88, align 8
  %92 = load ptr, ptr %10, align 8, !tbaa !23
  %93 = getelementptr inbounds i8, ptr %92, i64 56
  store <2 x float> zeroinitializer, ptr %93, align 8, !tbaa !33
  %94 = getelementptr inbounds i8, ptr %92, i64 72
  store <2 x float> <float 1.000000e+00, float 0.000000e+00>, ptr %94, align 8, !tbaa !33
  %95 = load ptr, ptr %87, align 8, !tbaa !32
  %96 = getelementptr inbounds i8, ptr %95, i64 4
  %97 = load <2 x float>, ptr %64, align 4
  %98 = tail call <2 x float> @vrScale(<2 x float> %97, float noundef %2) #3
  store <2 x float> %98, ptr %96, align 4
  %99 = load float, ptr %67, align 4, !tbaa !28
  %100 = fmul float %99, %2
  %101 = load ptr, ptr %87, align 8, !tbaa !32
  store float %100, ptr %101, align 4, !tbaa !34
  %102 = load i32, ptr %34, align 8, !tbaa !36
  switch i32 %102, label %199 [
    i32 0, label %103
    i32 1, label %152
  ]

103:                                              ; preds = %82
  %104 = tail call ptr (...) @vrManifoldAlloc() #3
  %105 = tail call ptr @vrManifoldInit(ptr noundef %104) #3
  %106 = load ptr, ptr %87, align 8, !tbaa !32
  %107 = load ptr, ptr %27, align 8, !tbaa !32
  %.sroa.025.0.copyload = load <2 x float>, ptr %106, align 4
  %.sroa.226.0..sroa_idx = getelementptr inbounds i8, ptr %106, i64 8
  %.sroa.226.0.copyload = load float, ptr %.sroa.226.0..sroa_idx, align 4
  tail call void @vrCirclePoly(ptr noundef %105, <2 x float> %.sroa.025.0.copyload, float %.sroa.226.0.copyload, ptr noundef byval(%struct.vrPolygonShape) align 8 %107) #3
  %108 = getelementptr inbounds i8, ptr %105, i64 192
  %109 = load i32, ptr %108, align 8, !tbaa !37
  %110 = icmp sgt i32 %109, 0
  br i1 %110, label %111, label %.sink.split

111:                                              ; preds = %103
  %112 = load ptr, ptr %10, align 8, !tbaa !23
  tail call void @vrManifoldSetBodies(ptr noundef nonnull %105, ptr noundef %112, ptr noundef %1) #3
  tail call void @vrManifoldPreStep(ptr noundef nonnull %105, float noundef %3) #3
  tail call void @vrManifoldPostStep(ptr noundef nonnull %105, float noundef %3) #3
  tail call void @vrManifoldSolvePosition(ptr noundef nonnull %105, float noundef %3) #3
  %113 = load ptr, ptr %10, align 8, !tbaa !23
  %114 = getelementptr inbounds i8, ptr %113, i64 8
  %115 = load <2 x float>, ptr %114, align 8
  %116 = tail call <2 x float> @vrScale(<2 x float> %115, float noundef %13) #3
  store <2 x float> %116, ptr %89, align 4
  %117 = load ptr, ptr %10, align 8, !tbaa !23
  %118 = getelementptr inbounds i8, ptr %117, i64 8
  %119 = load <2 x float>, ptr %118, align 8
  %120 = tail call <2 x float> @vrScale(<2 x float> %119, float noundef %13) #3
  %121 = tail call float @vrLength(<2 x float> %120) #3
  %122 = load ptr, ptr %10, align 8, !tbaa !23
  %123 = getelementptr inbounds i8, ptr %122, i64 24
  %124 = load <2 x float>, ptr %123, align 8
  %125 = tail call <2 x float> @vrScale(<2 x float> %124, float noundef %16) #3
  %126 = load <2 x float>, ptr %64, align 4
  %127 = tail call <2 x float> @vrAdd(<2 x float> %126, <2 x float> %125) #3
  store <2 x float> %127, ptr %64, align 4
  %128 = load ptr, ptr %10, align 8, !tbaa !23
  %129 = getelementptr inbounds i8, ptr %128, i64 24
  %130 = load <2 x float>, ptr %129, align 8
  %131 = tail call <2 x float> @vrScale(<2 x float> %130, float noundef %16) #3
  %132 = tail call float @vrLength(<2 x float> %131) #3
  %133 = load ptr, ptr %10, align 8, !tbaa !23
  %134 = getelementptr inbounds i8, ptr %133, i64 24
  %135 = tail call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00) #3
  store <2 x float> %135, ptr %134, align 8
  %136 = load float, ptr %17, align 8, !tbaa !41
  %137 = fneg float %136
  %138 = fpext float %137 to double
  %139 = getelementptr inbounds i8, ptr %105, i64 220
  %140 = load float, ptr %139, align 4, !tbaa !42
  %141 = load float, ptr %67, align 4, !tbaa !28
  %142 = fmul float %141, %2
  %143 = fdiv float %140, %142
  %144 = fsub float 1.000000e+00, %143
  %145 = fpext float %144 to double
  %square160 = fmul double %145, %145
  %146 = fmul double %square160, %138
  %147 = fdiv double %146, %11
  %148 = fptrunc double %147 to float
  %149 = getelementptr inbounds i8, ptr %64, i64 40
  store float %148, ptr %149, align 4, !tbaa !43
  %150 = tail call double @pow(double noundef %145, double noundef 3.000000e+00) #3
  %151 = fmul double %150, %138
  br label %.sink.split.sink.split

152:                                              ; preds = %82
  %153 = tail call ptr (...) @vrManifoldAlloc() #3
  %154 = tail call ptr @vrManifoldInit(ptr noundef %153) #3
  %155 = load ptr, ptr %87, align 8, !tbaa !32
  %156 = load ptr, ptr %27, align 8, !tbaa !32
  %.sroa.08.0.copyload = load <2 x float>, ptr %155, align 4
  %.sroa.29.0..sroa_idx = getelementptr inbounds i8, ptr %155, i64 8
  %.sroa.29.0.copyload = load float, ptr %.sroa.29.0..sroa_idx, align 4
  %.sroa.07.0.copyload = load <2 x float>, ptr %156, align 4
  %.sroa.2.0..sroa_idx = getelementptr inbounds i8, ptr %156, i64 8
  %.sroa.2.0.copyload = load float, ptr %.sroa.2.0..sroa_idx, align 4
  tail call void @vrCircleCircle(ptr noundef %154, <2 x float> %.sroa.08.0.copyload, float %.sroa.29.0.copyload, <2 x float> %.sroa.07.0.copyload, float %.sroa.2.0.copyload) #3
  %157 = getelementptr inbounds i8, ptr %154, i64 192
  %158 = load i32, ptr %157, align 8, !tbaa !37
  %159 = icmp sgt i32 %158, 0
  br i1 %159, label %160, label %.sink.split

160:                                              ; preds = %152
  %161 = load ptr, ptr %10, align 8, !tbaa !23
  tail call void @vrManifoldSetBodies(ptr noundef nonnull %154, ptr noundef %161, ptr noundef %1) #3
  tail call void @vrManifoldPreStep(ptr noundef nonnull %154, float noundef %3) #3
  tail call void @vrManifoldPostStep(ptr noundef nonnull %154, float noundef %3) #3
  tail call void @vrManifoldSolvePosition(ptr noundef nonnull %154, float noundef %3) #3
  %162 = load ptr, ptr %10, align 8, !tbaa !23
  %163 = getelementptr inbounds i8, ptr %162, i64 8
  %164 = load <2 x float>, ptr %163, align 8
  %165 = tail call <2 x float> @vrScale(<2 x float> %164, float noundef %13) #3
  store <2 x float> %165, ptr %89, align 4
  %166 = load ptr, ptr %10, align 8, !tbaa !23
  %167 = getelementptr inbounds i8, ptr %166, i64 8
  %168 = load <2 x float>, ptr %167, align 8
  %169 = tail call <2 x float> @vrScale(<2 x float> %168, float noundef %13) #3
  %170 = tail call float @vrLength(<2 x float> %169) #3
  %171 = load ptr, ptr %10, align 8, !tbaa !23
  %172 = getelementptr inbounds i8, ptr %171, i64 24
  %173 = load <2 x float>, ptr %172, align 8
  %174 = tail call <2 x float> @vrScale(<2 x float> %173, float noundef %16) #3
  %175 = load <2 x float>, ptr %64, align 4
  %176 = tail call <2 x float> @vrAdd(<2 x float> %175, <2 x float> %174) #3
  store <2 x float> %176, ptr %64, align 4
  %177 = load ptr, ptr %10, align 8, !tbaa !23
  %178 = getelementptr inbounds i8, ptr %177, i64 24
  %179 = load <2 x float>, ptr %178, align 8
  %180 = tail call <2 x float> @vrScale(<2 x float> %179, float noundef %16) #3
  %181 = tail call float @vrLength(<2 x float> %180) #3
  %182 = load ptr, ptr %10, align 8, !tbaa !23
  %183 = getelementptr inbounds i8, ptr %182, i64 24
  %184 = tail call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00) #3
  store <2 x float> %184, ptr %183, align 8
  %185 = getelementptr inbounds i8, ptr %154, i64 220
  %186 = load float, ptr %185, align 4, !tbaa !42
  %187 = load float, ptr %67, align 4, !tbaa !28
  %188 = fmul float %187, %2
  %189 = fdiv float %186, %188
  %190 = fsub float 1.000000e+00, %189
  %191 = fpext float %190 to double
  %square = fmul double %191, %191
  %192 = fdiv double %square, %11
  %193 = fptrunc double %192 to float
  %194 = getelementptr inbounds i8, ptr %64, i64 40
  store float %193, ptr %194, align 4, !tbaa !43
  %195 = tail call double @pow(double noundef %191, double noundef 3.000000e+00) #3
  br label %.sink.split.sink.split

.sink.split.sink.split:                           ; preds = %111, %160
  %.sink183 = phi double [ %195, %160 ], [ %151, %111 ]
  %.sink.ph = phi ptr [ %154, %160 ], [ %105, %111 ]
  %196 = fdiv double %.sink183, %11
  %197 = fptrunc double %196 to float
  %198 = getelementptr inbounds i8, ptr %64, i64 60
  store float %197, ptr %198, align 4, !tbaa !44
  br label %.sink.split

.sink.split:                                      ; preds = %.sink.split.sink.split, %152, %103
  %.sink = phi ptr [ %105, %103 ], [ %154, %152 ], [ %.sink.ph, %.sink.split.sink.split ]
  tail call void @vrManifoldDestroy(ptr noundef nonnull %.sink) #3
  br label %199

199:                                              ; preds = %.sink.split, %82, %.lr.ph
  %200 = add nuw nsw i32 %.0158161, 1
  %201 = load ptr, ptr %10, align 8, !tbaa !23
  %202 = getelementptr inbounds i8, ptr %201, i64 88
  %203 = load ptr, ptr %202, align 8, !tbaa !5
  %204 = getelementptr inbounds i8, ptr %203, i64 8
  %205 = load i32, ptr %204, align 8, !tbaa !17
  %206 = icmp slt i32 %200, %205
  br i1 %206, label %.lr.ph, label %._crit_edge.loopexit, !llvm.loop !45
}

declare i32 @vrOBBOverlaps(<2 x float>, <2 x float>, <2 x float>, <2 x float>) local_unnamed_addr #0

declare ptr @vrManifoldInit(ptr noundef) local_unnamed_addr #0

declare ptr @vrManifoldAlloc(...) local_unnamed_addr #0

declare void @vrCirclePoly(ptr noundef, <2 x float>, float, ptr noundef byval(%struct.vrPolygonShape) align 8) local_unnamed_addr #0

declare void @vrManifoldSetBodies(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #0

declare void @vrManifoldPreStep(ptr noundef, float noundef) local_unnamed_addr #0

declare void @vrManifoldPostStep(ptr noundef, float noundef) local_unnamed_addr #0

declare void @vrManifoldSolvePosition(ptr noundef, float noundef) local_unnamed_addr #0

declare float @vrLength(<2 x float>) local_unnamed_addr #0

; Function Attrs: mustprogress nofree nounwind willreturn memory(write)
declare double @pow(double noundef, double noundef) local_unnamed_addr #2

declare void @vrManifoldDestroy(ptr noundef) local_unnamed_addr #0

declare void @vrCircleCircle(ptr noundef, <2 x float>, float, <2 x float>, float) local_unnamed_addr #0

attributes #0 = { "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 = { 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 #2 = { mustprogress nofree nounwind willreturn memory(write) "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, !14, i64 88}
!6 = !{!"vrRigidBody", !7, i64 0, !7, i64 8, !7, i64 16, !7, i64 24, !8, i64 32, !8, i64 36, !8, i64 40, !8, i64 44, !11, i64 48, !13, i64 56, !14, i64 88, !15, i64 96, !7, i64 108, !16, i64 116, !14, i64 136, !12, i64 144}
!7 = !{!"vrVec2", !8, i64 0, !8, i64 4}
!8 = !{!"float", !9, i64 0}
!9 = !{!"omnipotent char", !10, i64 0}
!10 = !{!"Simple C/C++ TBAA"}
!11 = !{!"vrCollisionGroup", !12, i64 0, !12, i64 4}
!12 = !{!"int", !9, i64 0}
!13 = !{!"vrMaterial", !8, i64 0, !8, i64 4, !8, i64 8, !8, i64 12, !8, i64 16, !8, i64 20, !8, i64 24, !8, i64 28}
!14 = !{!"any pointer", !9, i64 0}
!15 = !{!"vrColor", !8, i64 0, !8, i64 4, !8, i64 8}
!16 = !{!"vrOrientedBoundingBox", !7, i64 0, !7, i64 8}
!17 = !{!18, !12, i64 8}
!18 = !{!"vrArray", !14, i64 0, !12, i64 8, !12, i64 12, !12, i64 16, !12, i64 20}
!19 = !{!20, !14, i64 0}
!20 = !{!"vrParticleSystem", !14, i64 0, !8, i64 8, !8, i64 12, !8, i64 16, !8, i64 20, !8, i64 24, !8, i64 28, !8, i64 32, !7, i64 36, !14, i64 48}
!21 = !{!18, !14, i64 0}
!22 = !{!14, !14, i64 0}
!23 = !{!20, !14, i64 48}
!24 = distinct !{!24, !25, !26}
!25 = !{!"llvm.loop.mustprogress"}
!26 = !{!"llvm.loop.unswitch.partial.disable"}
!27 = distinct !{!27, !25, !26}
!28 = !{!29, !8, i64 52}
!29 = !{!"vrParticle", !7, i64 0, !7, i64 8, !7, i64 16, !7, i64 24, !7, i64 32, !8, i64 40, !8, i64 44, !8, i64 48, !8, i64 52, !8, i64 56, !8, i64 60, !8, i64 64, !15, i64 68}
!30 = !{!31, !14, i64 40}
!31 = !{!"vrShape", !14, i64 0, !12, i64 8, !14, i64 16, !14, i64 24, !14, i64 32, !14, i64 40, !16, i64 48}
!32 = !{!31, !14, i64 0}
!33 = !{!8, !8, i64 0}
!34 = !{!35, !8, i64 0}
!35 = !{!"vrCircleShape", !8, i64 0, !7, i64 4}
!36 = !{!31, !12, i64 8}
!37 = !{!38, !12, i64 192}
!38 = !{!"vrManifold", !14, i64 0, !14, i64 8, !9, i64 16, !12, i64 192, !7, i64 196, !7, i64 204, !8, i64 212, !8, i64 216, !8, i64 220, !39, i64 224, !12, i64 280, !12, i64 284, !12, i64 288, !12, i64 292}
!39 = !{!"vrBlockSolverData", !7, i64 0, !40, i64 8, !7, i64 24, !7, i64 32, !7, i64 40, !7, i64 48}
!40 = !{!"vrMat2", !7, i64 0, !7, i64 8}
!41 = !{!6, !8, i64 64}
!42 = !{!38, !8, i64 220}
!43 = !{!29, !8, i64 40}
!44 = !{!29, !8, i64 60}
!45 = distinct !{!45, !25}


; Effective O3 passes: BDCEPass,CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopInstSimplifyPass,LoopRotatePass,LoopSimplifyCFGPass,LoopSimplifyPass,LoopUnrollPass,PostOrderFunctionAttrsPass,ReassociatePass,SLPVectorizerPass,SROAPass,SimpleLoopUnswitchPass,SimplifyCFGPass,TailCallElimPass