; LLVM IR from VTIvanov20/eight-ball-pool :: src (main)

; 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.Vector2 = type { float, float }
%struct.PhysicsVertexData = type { i32, [24 x %struct.Vector2], [24 x %struct.Vector2] }
%struct.Matrix2x2 = type { float, float, float, float }
%struct.PhysicsBodyData = type { i32, i8, %struct.Vector2, %struct.Vector2, %struct.Vector2, float, float, float, float, float, float, float, float, float, float, i8, i8, i8, %struct.PhysicsShape }
%struct.PhysicsShape = type { i32, ptr, %struct.PhysicsVertexData, float, %struct.Matrix2x2 }

@.str.4 = external hidden unnamed_addr constant [52 x i8], align 1

declare i32 @printf(ptr noundef, ...) #0

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

; Function Attrs: mustprogress uwtable
declare dso_local ptr @CreatePhysicsBodyPolygon(<2 x float>, float noundef, i32 noundef, float noundef) #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: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #1

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

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

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

; Function Attrs: nounwind allocsize(0)
declare noalias ptr @malloc(i64 noundef) #7

; Function Attrs: mustprogress uwtable
declare dso_local void @PhysicsAddForce(ptr noundef, <2 x float>) #2

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

; Function Attrs: mustprogress uwtable
define dso_local void @PhysicsShatter(ptr noundef %0, <2 x float> %1, float noundef %2) #2 {
  %4 = alloca %struct.Vector2, align 4
  %5 = alloca ptr, align 8
  %6 = alloca float, align 4
  %7 = alloca %struct.PhysicsVertexData, align 4
  %8 = alloca i8, align 1
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca %struct.Vector2, align 4
  %12 = alloca %struct.Vector2, align 4
  %13 = alloca %struct.Matrix2x2, align 4
  %14 = alloca %struct.Vector2, align 4
  %15 = alloca %struct.Vector2, align 4
  %16 = alloca %struct.Vector2, align 4
  %17 = alloca i32, align 4
  %18 = alloca %struct.Vector2, align 4
  %19 = alloca %struct.Matrix2x2, align 4
  %20 = alloca %struct.Vector2, align 4
  %21 = alloca %struct.Vector2, align 4
  %22 = alloca %struct.Vector2, align 4
  %23 = alloca float, align 4
  %24 = alloca float, align 4
  %25 = alloca float, align 4
  %26 = alloca i32, align 4
  %27 = alloca %struct.Vector2, align 4
  %28 = alloca ptr, align 8
  %29 = alloca %struct.Matrix2x2, align 4
  %30 = alloca i32, align 4
  %31 = alloca i32, align 4
  %32 = alloca i32, align 4
  %33 = alloca %struct.Vector2, align 4
  %34 = alloca %struct.Vector2, align 4
  %35 = alloca %struct.Vector2, align 4
  %36 = alloca %struct.Vector2, align 4
  %37 = alloca %struct.Vector2, align 4
  %38 = alloca %struct.Vector2, align 4
  %39 = alloca %struct.Vector2, align 4
  %40 = alloca %struct.Vector2, align 4
  %41 = alloca %struct.Vector2, align 4
  %42 = alloca %struct.Vector2, align 4
  %43 = alloca ptr, align 8
  %44 = alloca %struct.Vector2, align 4
  %45 = alloca %struct.PhysicsVertexData, align 4
  %46 = alloca %struct.Vector2, align 4
  %47 = alloca %struct.Vector2, align 4
  %48 = alloca %struct.Vector2, align 4
  %49 = alloca %struct.Vector2, align 4
  %50 = alloca %struct.Vector2, align 4
  %51 = alloca %struct.Vector2, align 4
  %52 = alloca %struct.Vector2, align 4
  %53 = alloca %struct.Vector2, align 4
  %54 = alloca %struct.Vector2, align 4
  %55 = alloca i32, align 4
  %56 = alloca i32, align 4
  %57 = alloca %struct.Vector2, align 4
  %58 = alloca %struct.Vector2, align 4
  %59 = alloca %struct.Vector2, align 4
  %60 = alloca %struct.Vector2, align 4
  %61 = alloca %struct.Vector2, align 4
  %62 = alloca float, align 4
  %63 = alloca float, align 4
  %64 = alloca i32, align 4
  %65 = alloca %struct.Vector2, align 4
  %66 = alloca i32, align 4
  %67 = alloca %struct.Vector2, align 4
  %68 = alloca float, align 4
  %69 = alloca %struct.Vector2, align 4
  %70 = alloca %struct.Vector2, align 4
  %71 = alloca float, align 4
  %72 = alloca float, align 4
  %73 = alloca float, align 4
  %74 = alloca %struct.Vector2, align 4
  %75 = alloca %struct.Vector2, align 4
  %76 = alloca %struct.Vector2, align 4
  %77 = alloca %struct.Vector2, align 4
  %78 = alloca %struct.Vector2, align 4
  %79 = alloca %struct.Vector2, align 4
  %80 = alloca %struct.Vector2, align 4
  %81 = alloca %struct.Vector2, align 4
  %82 = alloca %struct.Vector2, align 4
  %83 = alloca %struct.Vector2, align 4
  %84 = alloca %struct.Vector2, align 4
  %85 = alloca %struct.Vector2, align 4
  store <2 x float> %1, ptr %4, align 4
  store ptr %0, ptr %5, align 8, !tbaa !5
  store float %2, ptr %6, align 4, !tbaa !9
  %86 = load ptr, ptr %5, align 8, !tbaa !5
  %87 = icmp ne ptr %86, null
  br i1 %87, label %88, label %648

88:                                               ; preds = %3
  %89 = load ptr, ptr %5, align 8, !tbaa !5
  %90 = getelementptr inbounds %struct.PhysicsBodyData, ptr %89, i32 0, i32 18
  %91 = getelementptr inbounds %struct.PhysicsShape, ptr %90, i32 0, i32 0
  %92 = load i32, ptr %91, align 8, !tbaa !11
  %93 = icmp eq i32 %92, 1
  br i1 %93, label %94, label %647

94:                                               ; preds = %88
  call void @llvm.lifetime.start.p0(i64 388, ptr %7) #12
  %95 = load ptr, ptr %5, align 8, !tbaa !5
  %96 = getelementptr inbounds %struct.PhysicsBodyData, ptr %95, i32 0, i32 18
  %97 = getelementptr inbounds %struct.PhysicsShape, ptr %96, i32 0, i32 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %7, ptr align 8 %97, i64 388, i1 false), !tbaa.struct !20
  call void @llvm.lifetime.start.p0(i64 1, ptr %8) #12
  store i8 0, ptr %8, align 1, !tbaa !23
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #12
  store i32 0, ptr %9, align 4, !tbaa !21
  br label %98

98:                                               ; preds = %264, %94
  %99 = load i32, ptr %9, align 4, !tbaa !21
  %100 = getelementptr inbounds %struct.PhysicsVertexData, ptr %7, i32 0, i32 0
  %101 = load i32, ptr %100, align 4, !tbaa !24
  %102 = icmp ult i32 %99, %101
  br i1 %102, label %104, label %103

103:                                              ; preds = %98
  store i32 2, ptr %10, align 4
  br label %267

104:                                              ; preds = %98
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #12
  %105 = load ptr, ptr %5, align 8, !tbaa !5
  %106 = getelementptr inbounds %struct.PhysicsBodyData, ptr %105, i32 0, i32 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %11, ptr align 8 %106, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #12
  %107 = load ptr, ptr %5, align 8, !tbaa !5
  %108 = getelementptr inbounds %struct.PhysicsBodyData, ptr %107, i32 0, i32 18
  %109 = getelementptr inbounds %struct.PhysicsShape, ptr %108, i32 0, i32 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %13, ptr align 8 %109, i64 16, i1 false), !tbaa.struct !26
  %110 = load ptr, ptr %5, align 8, !tbaa !5
  %111 = getelementptr inbounds %struct.PhysicsBodyData, ptr %110, i32 0, i32 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %15, ptr align 8 %111, i64 8, i1 false), !tbaa.struct !25
  %112 = getelementptr inbounds %struct.PhysicsVertexData, ptr %7, i32 0, i32 1
  %113 = load i32, ptr %9, align 4, !tbaa !21
  %114 = zext i32 %113 to i64
  %115 = getelementptr inbounds [24 x %struct.Vector2], ptr %112, i64 0, i64 %114
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %16, ptr align 4 %115, i64 8, i1 false), !tbaa.struct !25
  %116 = load <2 x float>, ptr %15, align 4
  %117 = load <2 x float>, ptr %16, align 4
  %118 = call <2 x float> @_ZL14MathVector2Add7Vector2S_(<2 x float> %116, <2 x float> %117)
  store <2 x float> %118, ptr %14, align 4
  %119 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %13, i32 0, i32 0
  %120 = load <2 x float>, ptr %119, align 4
  %121 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %13, i32 0, i32 1
  %122 = load <2 x float>, ptr %121, align 4
  %123 = load <2 x float>, ptr %14, align 4
  %124 = call <2 x float> @_ZL21MathMatVector2Product9Matrix2x27Vector2(<2 x float> %120, <2 x float> %122, <2 x float> %123)
  store <2 x float> %124, ptr %12, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #12
  %125 = load i32, ptr %9, align 4, !tbaa !21
  %126 = add i32 %125, 1
  %127 = getelementptr inbounds %struct.PhysicsVertexData, ptr %7, i32 0, i32 0
  %128 = load i32, ptr %127, align 4, !tbaa !24
  %129 = icmp ult i32 %126, %128
  br i1 %129, label %130, label %133

130:                                              ; preds = %104
  %131 = load i32, ptr %9, align 4, !tbaa !21
  %132 = add i32 %131, 1
  br label %134

133:                                              ; preds = %104
  br label %134

134:                                              ; preds = %133, %130
  %135 = phi i32 [ %132, %130 ], [ 0, %133 ]
  store i32 %135, ptr %17, align 4, !tbaa !21
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #12
  %136 = load ptr, ptr %5, align 8, !tbaa !5
  %137 = getelementptr inbounds %struct.PhysicsBodyData, ptr %136, i32 0, i32 18
  %138 = getelementptr inbounds %struct.PhysicsShape, ptr %137, i32 0, i32 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %19, ptr align 8 %138, i64 16, i1 false), !tbaa.struct !26
  %139 = load ptr, ptr %5, align 8, !tbaa !5
  %140 = getelementptr inbounds %struct.PhysicsBodyData, ptr %139, i32 0, i32 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %21, ptr align 8 %140, i64 8, i1 false), !tbaa.struct !25
  %141 = getelementptr inbounds %struct.PhysicsVertexData, ptr %7, i32 0, i32 1
  %142 = load i32, ptr %17, align 4, !tbaa !21
  %143 = zext i32 %142 to i64
  %144 = getelementptr inbounds [24 x %struct.Vector2], ptr %141, i64 0, i64 %143
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %22, ptr align 4 %144, i64 8, i1 false), !tbaa.struct !25
  %145 = load <2 x float>, ptr %21, align 4
  %146 = load <2 x float>, ptr %22, align 4
  %147 = call <2 x float> @_ZL14MathVector2Add7Vector2S_(<2 x float> %145, <2 x float> %146)
  store <2 x float> %147, ptr %20, align 4
  %148 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %19, i32 0, i32 0
  %149 = load <2 x float>, ptr %148, align 4
  %150 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %19, i32 0, i32 1
  %151 = load <2 x float>, ptr %150, align 4
  %152 = load <2 x float>, ptr %20, align 4
  %153 = call <2 x float> @_ZL21MathMatVector2Product9Matrix2x27Vector2(<2 x float> %149, <2 x float> %151, <2 x float> %152)
  store <2 x float> %153, ptr %18, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #12
  %154 = getelementptr inbounds %struct.Vector2, ptr %12, i32 0, i32 1
  %155 = load float, ptr %154, align 4, !tbaa !27
  %156 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 1
  %157 = load float, ptr %156, align 4, !tbaa !27
  %158 = fsub float %155, %157
  %159 = getelementptr inbounds %struct.Vector2, ptr %4, i32 0, i32 0
  %160 = load float, ptr %159, align 4, !tbaa !28
  %161 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 0
  %162 = load float, ptr %161, align 4, !tbaa !28
  %163 = fsub float %160, %162
  %164 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 0
  %165 = load float, ptr %164, align 4, !tbaa !28
  %166 = getelementptr inbounds %struct.Vector2, ptr %12, i32 0, i32 0
  %167 = load float, ptr %166, align 4, !tbaa !28
  %168 = fsub float %165, %167
  %169 = getelementptr inbounds %struct.Vector2, ptr %4, i32 0, i32 1
  %170 = load float, ptr %169, align 4, !tbaa !27
  %171 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 1
  %172 = load float, ptr %171, align 4, !tbaa !27
  %173 = fsub float %170, %172
  %174 = fmul float %168, %173
  %175 = call float @llvm.fmuladd.f32(float %158, float %163, float %174)
  %176 = getelementptr inbounds %struct.Vector2, ptr %12, i32 0, i32 1
  %177 = load float, ptr %176, align 4, !tbaa !27
  %178 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 1
  %179 = load float, ptr %178, align 4, !tbaa !27
  %180 = fsub float %177, %179
  %181 = getelementptr inbounds %struct.Vector2, ptr %11, i32 0, i32 0
  %182 = load float, ptr %181, align 4, !tbaa !28
  %183 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 0
  %184 = load float, ptr %183, align 4, !tbaa !28
  %185 = fsub float %182, %184
  %186 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 0
  %187 = load float, ptr %186, align 4, !tbaa !28
  %188 = getelementptr inbounds %struct.Vector2, ptr %12, i32 0, i32 0
  %189 = load float, ptr %188, align 4, !tbaa !28
  %190 = fsub float %187, %189
  %191 = getelementptr inbounds %struct.Vector2, ptr %11, i32 0, i32 1
  %192 = load float, ptr %191, align 4, !tbaa !27
  %193 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 1
  %194 = load float, ptr %193, align 4, !tbaa !27
  %195 = fsub float %192, %194
  %196 = fmul float %190, %195
  %197 = call float @llvm.fmuladd.f32(float %180, float %185, float %196)
  %198 = fdiv float %175, %197
  store float %198, ptr %23, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #12
  %199 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 1
  %200 = load float, ptr %199, align 4, !tbaa !27
  %201 = getelementptr inbounds %struct.Vector2, ptr %11, i32 0, i32 1
  %202 = load float, ptr %201, align 4, !tbaa !27
  %203 = fsub float %200, %202
  %204 = getelementptr inbounds %struct.Vector2, ptr %4, i32 0, i32 0
  %205 = load float, ptr %204, align 4, !tbaa !28
  %206 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 0
  %207 = load float, ptr %206, align 4, !tbaa !28
  %208 = fsub float %205, %207
  %209 = getelementptr inbounds %struct.Vector2, ptr %11, i32 0, i32 0
  %210 = load float, ptr %209, align 4, !tbaa !28
  %211 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 0
  %212 = load float, ptr %211, align 4, !tbaa !28
  %213 = fsub float %210, %212
  %214 = getelementptr inbounds %struct.Vector2, ptr %4, i32 0, i32 1
  %215 = load float, ptr %214, align 4, !tbaa !27
  %216 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 1
  %217 = load float, ptr %216, align 4, !tbaa !27
  %218 = fsub float %215, %217
  %219 = fmul float %213, %218
  %220 = call float @llvm.fmuladd.f32(float %203, float %208, float %219)
  %221 = getelementptr inbounds %struct.Vector2, ptr %12, i32 0, i32 1
  %222 = load float, ptr %221, align 4, !tbaa !27
  %223 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 1
  %224 = load float, ptr %223, align 4, !tbaa !27
  %225 = fsub float %222, %224
  %226 = getelementptr inbounds %struct.Vector2, ptr %11, i32 0, i32 0
  %227 = load float, ptr %226, align 4, !tbaa !28
  %228 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 0
  %229 = load float, ptr %228, align 4, !tbaa !28
  %230 = fsub float %227, %229
  %231 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 0
  %232 = load float, ptr %231, align 4, !tbaa !28
  %233 = getelementptr inbounds %struct.Vector2, ptr %12, i32 0, i32 0
  %234 = load float, ptr %233, align 4, !tbaa !28
  %235 = fsub float %232, %234
  %236 = getelementptr inbounds %struct.Vector2, ptr %11, i32 0, i32 1
  %237 = load float, ptr %236, align 4, !tbaa !27
  %238 = getelementptr inbounds %struct.Vector2, ptr %18, i32 0, i32 1
  %239 = load float, ptr %238, align 4, !tbaa !27
  %240 = fsub float %237, %239
  %241 = fmul float %235, %240
  %242 = call float @llvm.fmuladd.f32(float %225, float %230, float %241)
  %243 = fdiv float %220, %242
  store float %243, ptr %24, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #12
  %244 = load float, ptr %23, align 4, !tbaa !9
  %245 = fsub float 1.000000e+00, %244
  %246 = load float, ptr %24, align 4, !tbaa !9
  %247 = fsub float %245, %246
  store float %247, ptr %25, align 4, !tbaa !9
  %248 = load float, ptr %23, align 4, !tbaa !9
  %249 = fcmp ogt float %248, 0.000000e+00
  br i1 %249, label %250, label %260

250:                                              ; preds = %134
  %251 = load float, ptr %24, align 4, !tbaa !9
  %252 = fcmp ogt float %251, 0.000000e+00
  %253 = zext i1 %252 to i32
  %254 = load float, ptr %25, align 4, !tbaa !9
  %255 = fcmp ogt float %254, 0.000000e+00
  %256 = zext i1 %255 to i32
  %257 = and i32 %253, %256
  %258 = icmp ne i32 %257, 0
  br i1 %258, label %259, label %260

259:                                              ; preds = %250
  store i8 1, ptr %8, align 1, !tbaa !23
  store i32 2, ptr %10, align 4
  br label %261

260:                                              ; preds = %250, %134
  store i32 0, ptr %10, align 4
  br label %261

261:                                              ; preds = %260, %259
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #12
  %262 = load i32, ptr %10, align 4
  switch i32 %262, label %267 [
    i32 0, label %263
  ]

263:                                              ; preds = %261
  br label %264

264:                                              ; preds = %263
  %265 = load i32, ptr %9, align 4, !tbaa !21
  %266 = add i32 %265, 1
  store i32 %266, ptr %9, align 4, !tbaa !21
  br label %98, !llvm.loop !29

267:                                              ; preds = %261, %103
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #12
  br label %268

268:                                              ; preds = %267
  %269 = load i8, ptr %8, align 1, !tbaa !23, !range !31, !noundef !32
  %270 = trunc i8 %269 to i1
  br i1 %270, label %271, label %646

271:                                              ; preds = %268
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #12
  %272 = getelementptr inbounds %struct.PhysicsVertexData, ptr %7, i32 0, i32 0
  %273 = load i32, ptr %272, align 4, !tbaa !24
  store i32 %273, ptr %26, align 4, !tbaa !21
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #12
  %274 = load ptr, ptr %5, align 8, !tbaa !5
  %275 = getelementptr inbounds %struct.PhysicsBodyData, ptr %274, i32 0, i32 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %27, ptr align 8 %275, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #12
  %276 = load i32, ptr %26, align 4, !tbaa !21
  %277 = sext i32 %276 to i64
  %278 = mul i64 8, %277
  %279 = call noalias ptr @malloc(i64 noundef %278) #13
  store ptr %279, ptr %28, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 16, ptr %29) #12
  %280 = load ptr, ptr %5, align 8, !tbaa !5
  %281 = getelementptr inbounds %struct.PhysicsBodyData, ptr %280, i32 0, i32 18
  %282 = getelementptr inbounds %struct.PhysicsShape, ptr %281, i32 0, i32 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %29, ptr align 8 %282, i64 16, i1 false), !tbaa.struct !26
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #12
  store i32 0, ptr %30, align 4, !tbaa !21
  br label %283

283:                                              ; preds = %297, %271
  %284 = load i32, ptr %30, align 4, !tbaa !21
  %285 = load i32, ptr %26, align 4, !tbaa !21
  %286 = icmp slt i32 %284, %285
  br i1 %286, label %288, label %287

287:                                              ; preds = %283
  store i32 5, ptr %10, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #12
  br label %300

288:                                              ; preds = %283
  %289 = getelementptr inbounds %struct.PhysicsVertexData, ptr %7, i32 0, i32 1
  %290 = load i32, ptr %30, align 4, !tbaa !21
  %291 = sext i32 %290 to i64
  %292 = getelementptr inbounds [24 x %struct.Vector2], ptr %289, i64 0, i64 %291
  %293 = load ptr, ptr %28, align 8, !tbaa !5
  %294 = load i32, ptr %30, align 4, !tbaa !21
  %295 = sext i32 %294 to i64
  %296 = getelementptr inbounds %struct.Vector2, ptr %293, i64 %295
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %296, ptr align 4 %292, i64 8, i1 false), !tbaa.struct !25
  br label %297

297:                                              ; preds = %288
  %298 = load i32, ptr %30, align 4, !tbaa !21
  %299 = add nsw i32 %298, 1
  store i32 %299, ptr %30, align 4, !tbaa !21
  br label %283, !llvm.loop !33

300:                                              ; preds = %287
  %301 = load ptr, ptr %5, align 8, !tbaa !5
  call void @DestroyPhysicsBody(ptr noundef %301)
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #12
  store i32 0, ptr %31, align 4, !tbaa !21
  br label %302

302:                                              ; preds = %641, %300
  %303 = load i32, ptr %31, align 4, !tbaa !21
  %304 = load i32, ptr %26, align 4, !tbaa !21
  %305 = icmp slt i32 %303, %304
  br i1 %305, label %307, label %306

306:                                              ; preds = %302
  store i32 8, ptr %10, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #12
  br label %644

307:                                              ; preds = %302
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #12
  %308 = load i32, ptr %31, align 4, !tbaa !21
  %309 = add nsw i32 %308, 1
  %310 = load i32, ptr %26, align 4, !tbaa !21
  %311 = icmp slt i32 %309, %310
  br i1 %311, label %312, label %315

312:                                              ; preds = %307
  %313 = load i32, ptr %31, align 4, !tbaa !21
  %314 = add nsw i32 %313, 1
  br label %316

315:                                              ; preds = %307
  br label %316

316:                                              ; preds = %315, %312
  %317 = phi i32 [ %314, %312 ], [ 0, %315 ]
  store i32 %317, ptr %32, align 4, !tbaa !21
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #12
  %318 = load ptr, ptr %28, align 8, !tbaa !5
  %319 = load i32, ptr %31, align 4, !tbaa !21
  %320 = sext i32 %319 to i64
  %321 = getelementptr inbounds %struct.Vector2, ptr %318, i64 %320
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %34, ptr align 4 %321, i64 8, i1 false), !tbaa.struct !25
  %322 = load ptr, ptr %28, align 8, !tbaa !5
  %323 = load i32, ptr %32, align 4, !tbaa !21
  %324 = sext i32 %323 to i64
  %325 = getelementptr inbounds %struct.Vector2, ptr %322, i64 %324
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %35, ptr align 4 %325, i64 8, i1 false), !tbaa.struct !25
  %326 = getelementptr inbounds %struct.Vector2, ptr %36, i32 0, i32 0
  store float 0.000000e+00, ptr %326, align 4, !tbaa !28
  %327 = getelementptr inbounds %struct.Vector2, ptr %36, i32 0, i32 1
  store float 0.000000e+00, ptr %327, align 4, !tbaa !27
  %328 = load <2 x float>, ptr %34, align 4
  %329 = load <2 x float>, ptr %35, align 4
  %330 = load <2 x float>, ptr %36, align 4
  %331 = call <2 x float> @_ZL22MathTriangleBarycenter7Vector2S_S_(<2 x float> %328, <2 x float> %329, <2 x float> %330)
  store <2 x float> %331, ptr %33, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #12
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %38, ptr align 4 %27, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %39, ptr align 4 %33, i64 8, i1 false), !tbaa.struct !25
  %332 = load <2 x float>, ptr %38, align 4
  %333 = load <2 x float>, ptr %39, align 4
  %334 = call <2 x float> @_ZL14MathVector2Add7Vector2S_(<2 x float> %332, <2 x float> %333)
  store <2 x float> %334, ptr %37, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %33, ptr align 4 %37, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #12
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %41, ptr align 4 %33, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %42, ptr align 4 %27, i64 8, i1 false), !tbaa.struct !25
  %335 = load <2 x float>, ptr %41, align 4
  %336 = load <2 x float>, ptr %42, align 4
  %337 = call <2 x float> @_ZL19MathVector2Subtract7Vector2S_(<2 x float> %335, <2 x float> %336)
  store <2 x float> %337, ptr %40, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %43) #12
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %44, ptr align 4 %33, i64 8, i1 false), !tbaa.struct !25
  %338 = load <2 x float>, ptr %44, align 4
  %339 = call ptr @CreatePhysicsBodyPolygon(<2 x float> %338, float noundef 1.000000e+01, i32 noundef 3, float noundef 1.000000e+01)
  store ptr %339, ptr %43, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 388, ptr %45) #12
  call void @llvm.memset.p0.i64(ptr align 4 %45, i8 0, i64 388, i1 false)
  %340 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 0
  store i32 3, ptr %340, align 4, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #12
  %341 = load ptr, ptr %28, align 8, !tbaa !5
  %342 = load i32, ptr %31, align 4, !tbaa !21
  %343 = sext i32 %342 to i64
  %344 = getelementptr inbounds %struct.Vector2, ptr %341, i64 %343
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %47, ptr align 4 %344, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %48, ptr align 4 %40, i64 8, i1 false), !tbaa.struct !25
  %345 = load <2 x float>, ptr %47, align 4
  %346 = load <2 x float>, ptr %48, align 4
  %347 = call <2 x float> @_ZL19MathVector2Subtract7Vector2S_(<2 x float> %345, <2 x float> %346)
  store <2 x float> %347, ptr %46, align 4
  %348 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 1
  %349 = getelementptr inbounds [24 x %struct.Vector2], ptr %348, i64 0, i64 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %349, ptr align 4 %46, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %49) #12
  %350 = load ptr, ptr %28, align 8, !tbaa !5
  %351 = load i32, ptr %32, align 4, !tbaa !21
  %352 = sext i32 %351 to i64
  %353 = getelementptr inbounds %struct.Vector2, ptr %350, i64 %352
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %50, ptr align 4 %353, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %51, ptr align 4 %40, i64 8, i1 false), !tbaa.struct !25
  %354 = load <2 x float>, ptr %50, align 4
  %355 = load <2 x float>, ptr %51, align 4
  %356 = call <2 x float> @_ZL19MathVector2Subtract7Vector2S_(<2 x float> %354, <2 x float> %355)
  store <2 x float> %356, ptr %49, align 4
  %357 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 1
  %358 = getelementptr inbounds [24 x %struct.Vector2], ptr %357, i64 0, i64 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %358, ptr align 4 %49, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.lifetime.end.p0(i64 8, ptr %49) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %52) #12
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %53, ptr align 4 %4, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %54, ptr align 4 %33, i64 8, i1 false), !tbaa.struct !25
  %359 = load <2 x float>, ptr %53, align 4
  %360 = load <2 x float>, ptr %54, align 4
  %361 = call <2 x float> @_ZL19MathVector2Subtract7Vector2S_(<2 x float> %359, <2 x float> %360)
  store <2 x float> %361, ptr %52, align 4
  %362 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 1
  %363 = getelementptr inbounds [24 x %struct.Vector2], ptr %362, i64 0, i64 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %363, ptr align 4 %52, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.lifetime.end.p0(i64 8, ptr %52) #12
  %364 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 1
  %365 = getelementptr inbounds [24 x %struct.Vector2], ptr %364, i64 0, i64 0
  %366 = getelementptr inbounds %struct.Vector2, ptr %365, i32 0, i32 0
  %367 = load float, ptr %366, align 4, !tbaa !28
  %368 = fmul float %367, 0x3FEE666660000000
  store float %368, ptr %366, align 4, !tbaa !28
  %369 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 1
  %370 = getelementptr inbounds [24 x %struct.Vector2], ptr %369, i64 0, i64 0
  %371 = getelementptr inbounds %struct.Vector2, ptr %370, i32 0, i32 1
  %372 = load float, ptr %371, align 4, !tbaa !27
  %373 = fmul float %372, 0x3FEE666660000000
  store float %373, ptr %371, align 4, !tbaa !27
  %374 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 1
  %375 = getelementptr inbounds [24 x %struct.Vector2], ptr %374, i64 0, i64 1
  %376 = getelementptr inbounds %struct.Vector2, ptr %375, i32 0, i32 0
  %377 = load float, ptr %376, align 4, !tbaa !28
  %378 = fmul float %377, 0x3FEE666660000000
  store float %378, ptr %376, align 4, !tbaa !28
  %379 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 1
  %380 = getelementptr inbounds [24 x %struct.Vector2], ptr %379, i64 0, i64 1
  %381 = getelementptr inbounds %struct.Vector2, ptr %380, i32 0, i32 1
  %382 = load float, ptr %381, align 4, !tbaa !27
  %383 = fmul float %382, 0x3FEE666660000000
  store float %383, ptr %381, align 4, !tbaa !27
  %384 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 1
  %385 = getelementptr inbounds [24 x %struct.Vector2], ptr %384, i64 0, i64 2
  %386 = getelementptr inbounds %struct.Vector2, ptr %385, i32 0, i32 0
  %387 = load float, ptr %386, align 4, !tbaa !28
  %388 = fmul float %387, 0x3FEE666660000000
  store float %388, ptr %386, align 4, !tbaa !28
  %389 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 1
  %390 = getelementptr inbounds [24 x %struct.Vector2], ptr %389, i64 0, i64 2
  %391 = getelementptr inbounds %struct.Vector2, ptr %390, i32 0, i32 1
  %392 = load float, ptr %391, align 4, !tbaa !27
  %393 = fmul float %392, 0x3FEE666660000000
  store float %393, ptr %391, align 4, !tbaa !27
  call void @llvm.lifetime.start.p0(i64 4, ptr %55) #12
  store i32 0, ptr %55, align 4, !tbaa !21
  br label %394

394:                                              ; preds = %438, %316
  %395 = load i32, ptr %55, align 4, !tbaa !21
  %396 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 0
  %397 = load i32, ptr %396, align 4, !tbaa !24
  %398 = icmp ult i32 %395, %397
  br i1 %398, label %400, label %399

399:                                              ; preds = %394
  store i32 11, ptr %10, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %55) #12
  br label %441

400:                                              ; preds = %394
  call void @llvm.lifetime.start.p0(i64 4, ptr %56) #12
  %401 = load i32, ptr %55, align 4, !tbaa !21
  %402 = add i32 %401, 1
  %403 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 0
  %404 = load i32, ptr %403, align 4, !tbaa !24
  %405 = icmp ult i32 %402, %404
  br i1 %405, label %406, label %409

406:                                              ; preds = %400
  %407 = load i32, ptr %55, align 4, !tbaa !21
  %408 = add i32 %407, 1
  br label %410

409:                                              ; preds = %400
  br label %410

410:                                              ; preds = %409, %406
  %411 = phi i32 [ %408, %406 ], [ 0, %409 ]
  store i32 %411, ptr %56, align 4, !tbaa !21
  call void @llvm.lifetime.start.p0(i64 8, ptr %57) #12
  %412 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 1
  %413 = load i32, ptr %56, align 4, !tbaa !21
  %414 = zext i32 %413 to i64
  %415 = getelementptr inbounds [24 x %struct.Vector2], ptr %412, i64 0, i64 %414
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %58, ptr align 4 %415, i64 8, i1 false), !tbaa.struct !25
  %416 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 1
  %417 = load i32, ptr %55, align 4, !tbaa !21
  %418 = zext i32 %417 to i64
  %419 = getelementptr inbounds [24 x %struct.Vector2], ptr %416, i64 0, i64 %418
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %59, ptr align 4 %419, i64 8, i1 false), !tbaa.struct !25
  %420 = load <2 x float>, ptr %58, align 4
  %421 = load <2 x float>, ptr %59, align 4
  %422 = call <2 x float> @_ZL19MathVector2Subtract7Vector2S_(<2 x float> %420, <2 x float> %421)
  store <2 x float> %422, ptr %57, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %60) #12
  %423 = getelementptr inbounds %struct.Vector2, ptr %60, i32 0, i32 0
  %424 = getelementptr inbounds %struct.Vector2, ptr %57, i32 0, i32 1
  %425 = load float, ptr %424, align 4, !tbaa !27
  store float %425, ptr %423, align 4, !tbaa !28
  %426 = getelementptr inbounds %struct.Vector2, ptr %60, i32 0, i32 1
  %427 = getelementptr inbounds %struct.Vector2, ptr %57, i32 0, i32 0
  %428 = load float, ptr %427, align 4, !tbaa !28
  %429 = fneg float %428
  store float %429, ptr %426, align 4, !tbaa !27
  %430 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 2
  %431 = load i32, ptr %55, align 4, !tbaa !21
  %432 = zext i32 %431 to i64
  %433 = getelementptr inbounds [24 x %struct.Vector2], ptr %430, i64 0, i64 %432
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %433, ptr align 4 %60, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.lifetime.end.p0(i64 8, ptr %60) #12
  %434 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 2
  %435 = load i32, ptr %55, align 4, !tbaa !21
  %436 = zext i32 %435 to i64
  %437 = getelementptr inbounds [24 x %struct.Vector2], ptr %434, i64 0, i64 %436
  call void @_ZL20MathVector2NormalizeP7Vector2(ptr noundef %437)
  call void @llvm.lifetime.end.p0(i64 8, ptr %57) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %56) #12
  br label %438

438:                                              ; preds = %410
  %439 = load i32, ptr %55, align 4, !tbaa !21
  %440 = add i32 %439, 1
  store i32 %440, ptr %55, align 4, !tbaa !21
  br label %394, !llvm.loop !34

441:                                              ; preds = %399
  %442 = load ptr, ptr %43, align 8, !tbaa !5
  %443 = getelementptr inbounds %struct.PhysicsBodyData, ptr %442, i32 0, i32 18
  %444 = getelementptr inbounds %struct.PhysicsShape, ptr %443, i32 0, i32 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %444, ptr align 4 %45, i64 388, i1 false), !tbaa.struct !20
  %445 = load ptr, ptr %43, align 8, !tbaa !5
  %446 = getelementptr inbounds %struct.PhysicsBodyData, ptr %445, i32 0, i32 18
  %447 = getelementptr inbounds %struct.PhysicsShape, ptr %446, i32 0, i32 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %447, ptr align 4 %29, i64 16, i1 false), !tbaa.struct !26
  call void @llvm.lifetime.start.p0(i64 8, ptr %61) #12
  %448 = getelementptr inbounds %struct.Vector2, ptr %61, i32 0, i32 0
  store float 0.000000e+00, ptr %448, align 4, !tbaa !28
  %449 = getelementptr inbounds %struct.Vector2, ptr %61, i32 0, i32 1
  store float 0.000000e+00, ptr %449, align 4, !tbaa !27
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %33, ptr align 4 %61, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.lifetime.end.p0(i64 8, ptr %61) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %62) #12
  store float 0.000000e+00, ptr %62, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %63) #12
  store float 0.000000e+00, ptr %63, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %64) #12
  store i32 0, ptr %64, align 4, !tbaa !21
  br label %450

450:                                              ; preds = %555, %441
  %451 = load i32, ptr %64, align 4, !tbaa !21
  %452 = load ptr, ptr %43, align 8, !tbaa !5
  %453 = getelementptr inbounds %struct.PhysicsBodyData, ptr %452, i32 0, i32 18
  %454 = getelementptr inbounds %struct.PhysicsShape, ptr %453, i32 0, i32 2
  %455 = getelementptr inbounds %struct.PhysicsVertexData, ptr %454, i32 0, i32 0
  %456 = load i32, ptr %455, align 8, !tbaa !35
  %457 = icmp ult i32 %451, %456
  br i1 %457, label %459, label %458

458:                                              ; preds = %450
  store i32 14, ptr %10, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %64) #12
  br label %558

459:                                              ; preds = %450
  call void @llvm.lifetime.start.p0(i64 8, ptr %65) #12
  %460 = load ptr, ptr %43, align 8, !tbaa !5
  %461 = getelementptr inbounds %struct.PhysicsBodyData, ptr %460, i32 0, i32 18
  %462 = getelementptr inbounds %struct.PhysicsShape, ptr %461, i32 0, i32 2
  %463 = getelementptr inbounds %struct.PhysicsVertexData, ptr %462, i32 0, i32 1
  %464 = load i32, ptr %64, align 4, !tbaa !21
  %465 = zext i32 %464 to i64
  %466 = getelementptr inbounds [24 x %struct.Vector2], ptr %463, i64 0, i64 %465
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %65, ptr align 4 %466, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.lifetime.start.p0(i64 4, ptr %66) #12
  %467 = load i32, ptr %64, align 4, !tbaa !21
  %468 = add i32 %467, 1
  %469 = load ptr, ptr %43, align 8, !tbaa !5
  %470 = getelementptr inbounds %struct.PhysicsBodyData, ptr %469, i32 0, i32 18
  %471 = getelementptr inbounds %struct.PhysicsShape, ptr %470, i32 0, i32 2
  %472 = getelementptr inbounds %struct.PhysicsVertexData, ptr %471, i32 0, i32 0
  %473 = load i32, ptr %472, align 8, !tbaa !35
  %474 = icmp ult i32 %468, %473
  br i1 %474, label %475, label %478

475:                                              ; preds = %459
  %476 = load i32, ptr %64, align 4, !tbaa !21
  %477 = add i32 %476, 1
  br label %479

478:                                              ; preds = %459
  br label %479

479:                                              ; preds = %478, %475
  %480 = phi i32 [ %477, %475 ], [ 0, %478 ]
  store i32 %480, ptr %66, align 4, !tbaa !21
  call void @llvm.lifetime.start.p0(i64 8, ptr %67) #12
  %481 = load ptr, ptr %43, align 8, !tbaa !5
  %482 = getelementptr inbounds %struct.PhysicsBodyData, ptr %481, i32 0, i32 18
  %483 = getelementptr inbounds %struct.PhysicsShape, ptr %482, i32 0, i32 2
  %484 = getelementptr inbounds %struct.PhysicsVertexData, ptr %483, i32 0, i32 1
  %485 = load i32, ptr %66, align 4, !tbaa !21
  %486 = zext i32 %485 to i64
  %487 = getelementptr inbounds [24 x %struct.Vector2], ptr %484, i64 0, i64 %486
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %67, ptr align 4 %487, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.lifetime.start.p0(i64 4, ptr %68) #12
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %69, ptr align 4 %65, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %70, ptr align 4 %67, i64 8, i1 false), !tbaa.struct !25
  %488 = load <2 x float>, ptr %69, align 4
  %489 = load <2 x float>, ptr %70, align 4
  %490 = call noundef float @_ZL23MathVector2CrossProduct7Vector2S_(<2 x float> %488, <2 x float> %489)
  store float %490, ptr %68, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %71) #12
  %491 = load float, ptr %68, align 4, !tbaa !9
  %492 = fdiv float %491, 2.000000e+00
  store float %492, ptr %71, align 4, !tbaa !9
  %493 = load float, ptr %71, align 4, !tbaa !9
  %494 = load float, ptr %62, align 4, !tbaa !9
  %495 = fadd float %494, %493
  store float %495, ptr %62, align 4, !tbaa !9
  %496 = load float, ptr %71, align 4, !tbaa !9
  %497 = fmul float %496, 1.000000e+00
  %498 = fdiv float %497, 3.000000e+00
  %499 = getelementptr inbounds %struct.Vector2, ptr %65, i32 0, i32 0
  %500 = load float, ptr %499, align 4, !tbaa !28
  %501 = getelementptr inbounds %struct.Vector2, ptr %67, i32 0, i32 0
  %502 = load float, ptr %501, align 4, !tbaa !28
  %503 = fadd float %500, %502
  %504 = getelementptr inbounds %struct.Vector2, ptr %33, i32 0, i32 0
  %505 = load float, ptr %504, align 4, !tbaa !28
  %506 = call float @llvm.fmuladd.f32(float %498, float %503, float %505)
  store float %506, ptr %504, align 4, !tbaa !28
  %507 = load float, ptr %71, align 4, !tbaa !9
  %508 = fmul float %507, 1.000000e+00
  %509 = fdiv float %508, 3.000000e+00
  %510 = getelementptr inbounds %struct.Vector2, ptr %65, i32 0, i32 1
  %511 = load float, ptr %510, align 4, !tbaa !27
  %512 = getelementptr inbounds %struct.Vector2, ptr %67, i32 0, i32 1
  %513 = load float, ptr %512, align 4, !tbaa !27
  %514 = fadd float %511, %513
  %515 = getelementptr inbounds %struct.Vector2, ptr %33, i32 0, i32 1
  %516 = load float, ptr %515, align 4, !tbaa !27
  %517 = call float @llvm.fmuladd.f32(float %509, float %514, float %516)
  store float %517, ptr %515, align 4, !tbaa !27
  call void @llvm.lifetime.start.p0(i64 4, ptr %72) #12
  %518 = getelementptr inbounds %struct.Vector2, ptr %65, i32 0, i32 0
  %519 = load float, ptr %518, align 4, !tbaa !28
  %520 = getelementptr inbounds %struct.Vector2, ptr %65, i32 0, i32 0
  %521 = load float, ptr %520, align 4, !tbaa !28
  %522 = getelementptr inbounds %struct.Vector2, ptr %67, i32 0, i32 0
  %523 = load float, ptr %522, align 4, !tbaa !28
  %524 = getelementptr inbounds %struct.Vector2, ptr %65, i32 0, i32 0
  %525 = load float, ptr %524, align 4, !tbaa !28
  %526 = fmul float %523, %525
  %527 = call float @llvm.fmuladd.f32(float %519, float %521, float %526)
  %528 = getelementptr inbounds %struct.Vector2, ptr %67, i32 0, i32 0
  %529 = load float, ptr %528, align 4, !tbaa !28
  %530 = getelementptr inbounds %struct.Vector2, ptr %67, i32 0, i32 0
  %531 = load float, ptr %530, align 4, !tbaa !28
  %532 = call float @llvm.fmuladd.f32(float %529, float %531, float %527)
  store float %532, ptr %72, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %73) #12
  %533 = getelementptr inbounds %struct.Vector2, ptr %65, i32 0, i32 1
  %534 = load float, ptr %533, align 4, !tbaa !27
  %535 = getelementptr inbounds %struct.Vector2, ptr %65, i32 0, i32 1
  %536 = load float, ptr %535, align 4, !tbaa !27
  %537 = getelementptr inbounds %struct.Vector2, ptr %67, i32 0, i32 1
  %538 = load float, ptr %537, align 4, !tbaa !27
  %539 = getelementptr inbounds %struct.Vector2, ptr %65, i32 0, i32 1
  %540 = load float, ptr %539, align 4, !tbaa !27
  %541 = fmul float %538, %540
  %542 = call float @llvm.fmuladd.f32(float %534, float %536, float %541)
  %543 = getelementptr inbounds %struct.Vector2, ptr %67, i32 0, i32 1
  %544 = load float, ptr %543, align 4, !tbaa !27
  %545 = getelementptr inbounds %struct.Vector2, ptr %67, i32 0, i32 1
  %546 = load float, ptr %545, align 4, !tbaa !27
  %547 = call float @llvm.fmuladd.f32(float %544, float %546, float %542)
  store float %547, ptr %73, align 4, !tbaa !9
  %548 = load float, ptr %68, align 4, !tbaa !9
  %549 = fmul float 0x3FB5555560000000, %548
  %550 = load float, ptr %72, align 4, !tbaa !9
  %551 = load float, ptr %73, align 4, !tbaa !9
  %552 = fadd float %550, %551
  %553 = load float, ptr %63, align 4, !tbaa !9
  %554 = call float @llvm.fmuladd.f32(float %549, float %552, float %553)
  store float %554, ptr %63, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 4, ptr %73) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %72) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %71) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %68) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %67) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %66) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %65) #12
  br label %555

555:                                              ; preds = %479
  %556 = load i32, ptr %64, align 4, !tbaa !21
  %557 = add i32 %556, 1
  store i32 %557, ptr %64, align 4, !tbaa !21
  br label %450, !llvm.loop !36

558:                                              ; preds = %458
  %559 = load float, ptr %62, align 4, !tbaa !9
  %560 = fdiv float 1.000000e+00, %559
  %561 = getelementptr inbounds %struct.Vector2, ptr %33, i32 0, i32 0
  %562 = load float, ptr %561, align 4, !tbaa !28
  %563 = fmul float %562, %560
  store float %563, ptr %561, align 4, !tbaa !28
  %564 = load float, ptr %62, align 4, !tbaa !9
  %565 = fdiv float 1.000000e+00, %564
  %566 = getelementptr inbounds %struct.Vector2, ptr %33, i32 0, i32 1
  %567 = load float, ptr %566, align 4, !tbaa !27
  %568 = fmul float %567, %565
  store float %568, ptr %566, align 4, !tbaa !27
  %569 = load float, ptr %62, align 4, !tbaa !9
  %570 = load ptr, ptr %43, align 8, !tbaa !5
  %571 = getelementptr inbounds %struct.PhysicsBodyData, ptr %570, i32 0, i32 10
  store float %569, ptr %571, align 4, !tbaa !37
  %572 = load ptr, ptr %43, align 8, !tbaa !5
  %573 = getelementptr inbounds %struct.PhysicsBodyData, ptr %572, i32 0, i32 10
  %574 = load float, ptr %573, align 4, !tbaa !37
  %575 = fcmp une float %574, 0.000000e+00
  br i1 %575, label %576, label %581

576:                                              ; preds = %558
  %577 = load ptr, ptr %43, align 8, !tbaa !5
  %578 = getelementptr inbounds %struct.PhysicsBodyData, ptr %577, i32 0, i32 10
  %579 = load float, ptr %578, align 4, !tbaa !37
  %580 = fdiv float 1.000000e+00, %579
  br label %582

581:                                              ; preds = %558
  br label %582

582:                                              ; preds = %581, %576
  %583 = phi float [ %580, %576 ], [ 0.000000e+00, %581 ]
  %584 = load ptr, ptr %43, align 8, !tbaa !5
  %585 = getelementptr inbounds %struct.PhysicsBodyData, ptr %584, i32 0, i32 11
  store float %583, ptr %585, align 8, !tbaa !38
  %586 = load float, ptr %63, align 4, !tbaa !9
  %587 = load ptr, ptr %43, align 8, !tbaa !5
  %588 = getelementptr inbounds %struct.PhysicsBodyData, ptr %587, i32 0, i32 8
  store float %586, ptr %588, align 4, !tbaa !39
  %589 = load ptr, ptr %43, align 8, !tbaa !5
  %590 = getelementptr inbounds %struct.PhysicsBodyData, ptr %589, i32 0, i32 8
  %591 = load float, ptr %590, align 4, !tbaa !39
  %592 = fcmp une float %591, 0.000000e+00
  br i1 %592, label %593, label %598

593:                                              ; preds = %582
  %594 = load ptr, ptr %43, align 8, !tbaa !5
  %595 = getelementptr inbounds %struct.PhysicsBodyData, ptr %594, i32 0, i32 8
  %596 = load float, ptr %595, align 4, !tbaa !39
  %597 = fdiv float 1.000000e+00, %596
  br label %599

598:                                              ; preds = %582
  br label %599

599:                                              ; preds = %598, %593
  %600 = phi float [ %597, %593 ], [ 0.000000e+00, %598 ]
  %601 = load ptr, ptr %43, align 8, !tbaa !5
  %602 = getelementptr inbounds %struct.PhysicsBodyData, ptr %601, i32 0, i32 9
  store float %600, ptr %602, align 8, !tbaa !40
  call void @llvm.lifetime.start.p0(i64 8, ptr %74) #12
  %603 = load ptr, ptr %43, align 8, !tbaa !5
  %604 = getelementptr inbounds %struct.PhysicsBodyData, ptr %603, i32 0, i32 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %74, ptr align 8 %604, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.lifetime.start.p0(i64 8, ptr %75) #12
  %605 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 1
  %606 = getelementptr inbounds [24 x %struct.Vector2], ptr %605, i64 0, i64 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %76, ptr align 4 %606, i64 8, i1 false), !tbaa.struct !25
  %607 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 1
  %608 = getelementptr inbounds [24 x %struct.Vector2], ptr %607, i64 0, i64 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %77, ptr align 4 %608, i64 8, i1 false), !tbaa.struct !25
  %609 = load <2 x float>, ptr %76, align 4
  %610 = load <2 x float>, ptr %77, align 4
  %611 = call <2 x float> @_ZL19MathVector2Subtract7Vector2S_(<2 x float> %609, <2 x float> %610)
  store <2 x float> %611, ptr %75, align 4
  %612 = getelementptr inbounds %struct.Vector2, ptr %75, i32 0, i32 0
  %613 = load float, ptr %612, align 4, !tbaa !28
  %614 = fdiv float %613, 2.000000e+00
  store float %614, ptr %612, align 4, !tbaa !28
  %615 = getelementptr inbounds %struct.Vector2, ptr %75, i32 0, i32 1
  %616 = load float, ptr %615, align 4, !tbaa !27
  %617 = fdiv float %616, 2.000000e+00
  store float %617, ptr %615, align 4, !tbaa !27
  call void @llvm.lifetime.start.p0(i64 8, ptr %78) #12
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %80, ptr align 4 %74, i64 8, i1 false), !tbaa.struct !25
  %618 = getelementptr inbounds %struct.PhysicsVertexData, ptr %45, i32 0, i32 1
  %619 = getelementptr inbounds [24 x %struct.Vector2], ptr %618, i64 0, i64 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %82, ptr align 4 %619, i64 8, i1 false), !tbaa.struct !25
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %83, ptr align 4 %75, i64 8, i1 false), !tbaa.struct !25
  %620 = load <2 x float>, ptr %82, align 4
  %621 = load <2 x float>, ptr %83, align 4
  %622 = call <2 x float> @_ZL14MathVector2Add7Vector2S_(<2 x float> %620, <2 x float> %621)
  store <2 x float> %622, ptr %81, align 4
  %623 = load <2 x float>, ptr %80, align 4
  %624 = load <2 x float>, ptr %81, align 4
  %625 = call <2 x float> @_ZL14MathVector2Add7Vector2S_(<2 x float> %623, <2 x float> %624)
  store <2 x float> %625, ptr %79, align 4
  %626 = load ptr, ptr %43, align 8, !tbaa !5
  %627 = getelementptr inbounds %struct.PhysicsBodyData, ptr %626, i32 0, i32 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %84, ptr align 8 %627, i64 8, i1 false), !tbaa.struct !25
  %628 = load <2 x float>, ptr %79, align 4
  %629 = load <2 x float>, ptr %84, align 4
  %630 = call <2 x float> @_ZL19MathVector2Subtract7Vector2S_(<2 x float> %628, <2 x float> %629)
  store <2 x float> %630, ptr %78, align 4
  call void @_ZL20MathVector2NormalizeP7Vector2(ptr noundef %78)
  %631 = load float, ptr %6, align 4, !tbaa !9
  %632 = getelementptr inbounds %struct.Vector2, ptr %78, i32 0, i32 0
  %633 = load float, ptr %632, align 4, !tbaa !28
  %634 = fmul float %633, %631
  store float %634, ptr %632, align 4, !tbaa !28
  %635 = load float, ptr %6, align 4, !tbaa !9
  %636 = getelementptr inbounds %struct.Vector2, ptr %78, i32 0, i32 1
  %637 = load float, ptr %636, align 4, !tbaa !27
  %638 = fmul float %637, %635
  store float %638, ptr %636, align 4, !tbaa !27
  %639 = load ptr, ptr %43, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %85, ptr align 4 %78, i64 8, i1 false), !tbaa.struct !25
  %640 = load <2 x float>, ptr %85, align 4
  call void @PhysicsAddForce(ptr noundef %639, <2 x float> %640)
  call void @llvm.lifetime.end.p0(i64 8, ptr %78) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %75) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %74) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %62) #12
  call void @llvm.lifetime.end.p0(i64 388, ptr %45) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %43) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #12
  br label %641

641:                                              ; preds = %599
  %642 = load i32, ptr %31, align 4, !tbaa !21
  %643 = add nsw i32 %642, 1
  store i32 %643, ptr %31, align 4, !tbaa !21
  br label %302, !llvm.loop !41

644:                                              ; preds = %306
  %645 = load ptr, ptr %28, align 8, !tbaa !5
  call void @free(ptr noundef %645) #12
  call void @llvm.lifetime.end.p0(i64 16, ptr %29) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #12
  br label %646

646:                                              ; preds = %644, %268
  call void @llvm.lifetime.end.p0(i64 1, ptr %8) #12
  call void @llvm.lifetime.end.p0(i64 388, ptr %7) #12
  br label %647

647:                                              ; preds = %646, %88
  br label %650

648:                                              ; preds = %3
  %649 = call i32 (ptr, ...) @printf(ptr noundef @.str.4)
  br label %650

650:                                              ; preds = %648, %647
  ret void
}

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

; Function Attrs: mustprogress uwtable
declare dso_local void @DestroyPhysicsBody(ptr noundef) #8

; Function Attrs: mustprogress nounwind uwtable
declare hidden <2 x float> @_ZL22MathTriangleBarycenter7Vector2S_S_(<2 x float>, <2 x float>, <2 x float>) #9

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

; Function Attrs: mustprogress nounwind uwtable
declare hidden void @_ZL20MathVector2NormalizeP7Vector2(ptr noundef) #10

; Function Attrs: nounwind
declare void @free(ptr noundef) #11

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 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { mustprogress 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 #3 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #5 = { inlinehint mustprogress nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #6 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #7 = { nounwind allocsize(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 #8 = { mustprogress uwtable "min-legal-vector-width"="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 #9 = { mustprogress 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 #10 = { mustprogress nounwind uwtable "min-legal-vector-width"="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 #11 = { 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 #12 = { nounwind }
attributes #13 = { nounwind allocsize(0) }

!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++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"float", !7, i64 0}
!11 = !{!12, !17, i64 80}
!12 = !{!"_ZTS15PhysicsBodyData", !13, i64 0, !14, i64 4, !15, i64 8, !15, i64 16, !15, i64 24, !10, i64 32, !10, i64 36, !10, i64 40, !10, i64 44, !10, i64 48, !10, i64 52, !10, i64 56, !10, i64 60, !10, i64 64, !10, i64 68, !14, i64 72, !14, i64 73, !14, i64 74, !16, i64 80}
!13 = !{!"int", !7, i64 0}
!14 = !{!"bool", !7, i64 0}
!15 = !{!"_ZTS7Vector2", !10, i64 0, !10, i64 4}
!16 = !{!"_ZTS12PhysicsShape", !17, i64 0, !6, i64 8, !18, i64 16, !10, i64 404, !19, i64 408}
!17 = !{!"_ZTS16PhysicsShapeType", !7, i64 0}
!18 = !{!"_ZTS17PhysicsVertexData", !13, i64 0, !7, i64 4, !7, i64 196}
!19 = !{!"_ZTS9Matrix2x2", !10, i64 0, !10, i64 4, !10, i64 8, !10, i64 12}
!20 = !{i64 0, i64 4, !21, i64 4, i64 192, !22, i64 196, i64 192, !22}
!21 = !{!13, !13, i64 0}
!22 = !{!7, !7, i64 0}
!23 = !{!14, !14, i64 0}
!24 = !{!18, !13, i64 0}
!25 = !{i64 0, i64 4, !9, i64 4, i64 4, !9}
!26 = !{i64 0, i64 4, !9, i64 4, i64 4, !9, i64 8, i64 4, !9, i64 12, i64 4, !9}
!27 = !{!15, !10, i64 4}
!28 = !{!15, !10, i64 0}
!29 = distinct !{!29, !30}
!30 = !{!"llvm.loop.mustprogress"}
!31 = !{i8 0, i8 2}
!32 = !{}
!33 = distinct !{!33, !30}
!34 = distinct !{!34, !30}
!35 = !{!12, !13, i64 96}
!36 = distinct !{!36, !30}
!37 = !{!12, !10, i64 52}
!38 = !{!12, !10, i64 56}
!39 = !{!12, !10, i64 44}
!40 = !{!12, !10, i64 48}
!41 = distinct !{!41, !30}


; 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.PhysicsVertexData = type { i32, [24 x %struct.Vector2], [24 x %struct.Vector2] }
%struct.Vector2 = type { float, float }
%struct.Matrix2x2 = type { float, float, float, float }

@.str.4 = external hidden unnamed_addr constant [52 x i8], align 1

; Function Attrs: nofree nounwind
declare noundef i32 @printf(ptr nocapture noundef readonly, ...) local_unnamed_addr #0

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

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

; Function Attrs: mustprogress 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: mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #1

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

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

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

; Function Attrs: mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite)
declare noalias noundef ptr @malloc(i64 noundef) local_unnamed_addr #7

; Function Attrs: mustprogress uwtable
declare dso_local void @PhysicsAddForce(ptr noundef, <2 x float>) local_unnamed_addr #2

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

; Function Attrs: mustprogress uwtable
define dso_local void @PhysicsShatter(ptr noundef %0, <2 x float> %1, float noundef %2) local_unnamed_addr #2 {
  %4 = alloca %struct.PhysicsVertexData, align 4
  %5 = alloca %struct.Matrix2x2, align 4
  %6 = alloca %struct.PhysicsVertexData, align 4
  %7 = alloca %struct.Vector2, align 8
  %.not = icmp eq ptr %0, null
  br i1 %.not, label %138, label %8

8:                                                ; preds = %3
  %9 = getelementptr inbounds i8, ptr %0, i64 80
  %10 = load i32, ptr %9, align 8, !tbaa !5
  %11 = icmp eq i32 %10, 1
  br i1 %11, label %12, label %140

12:                                               ; preds = %8
  call void @llvm.lifetime.start.p0(i64 388, ptr nonnull %4) #13
  %13 = getelementptr inbounds i8, ptr %0, i64 96
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 4 dereferenceable(388) %4, ptr noundef nonnull align 8 dereferenceable(388) %13, i64 388, i1 false), !tbaa.struct !18
  %14 = load i32, ptr %4, align 4, !tbaa !21
  %.not276 = icmp eq i32 %14, 0
  br i1 %.not276, label %.loopexit, label %.lr.ph

.lr.ph:                                           ; preds = %12
  %15 = getelementptr inbounds i8, ptr %0, i64 8
  %.sroa.6.0..sroa_idx = getelementptr inbounds i8, ptr %0, i64 12
  %16 = getelementptr inbounds i8, ptr %0, i64 488
  %.sroa.2199.0..sroa_idx = getelementptr inbounds i8, ptr %0, i64 496
  %17 = getelementptr inbounds i8, ptr %4, i64 4
  %18 = zext i32 %14 to i64
  br label %19

19:                                               ; preds = %.lr.ph, %54
  %indvars.iv = phi i64 [ 0, %.lr.ph ], [ %indvars.iv.next, %54 ]
  %.sroa.0209.0.copyload = load float, ptr %15, align 8, !tbaa !22
  %.sroa.6.0.copyload = load float, ptr %.sroa.6.0..sroa_idx, align 4, !tbaa !22
  %.sroa.0198.0.copyload = load <2 x float>, ptr %16, align 8
  %.sroa.2199.0.copyload = load <2 x float>, ptr %.sroa.2199.0..sroa_idx, align 8
  %.sroa.0196.0.copyload = load <2 x float>, ptr %15, align 8
  %20 = getelementptr inbounds [24 x %struct.Vector2], ptr %17, i64 0, i64 %indvars.iv
  %.sroa.0195.0.copyload = load <2 x float>, ptr %20, align 4
  %21 = tail call <2 x float> @_ZL14MathVector2Add7Vector2S_(<2 x float> %.sroa.0196.0.copyload, <2 x float> %.sroa.0195.0.copyload)
  %22 = tail call <2 x float> @_ZL21MathMatVector2Product9Matrix2x27Vector2(<2 x float> %.sroa.0198.0.copyload, <2 x float> %.sroa.2199.0.copyload, <2 x float> %21)
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %23 = icmp ult i64 %indvars.iv.next, %18
  %24 = and i64 %indvars.iv.next, 4294967295
  %.sroa.0164.0.copyload = load <2 x float>, ptr %16, align 8
  %.sroa.2.0.copyload = load <2 x float>, ptr %.sroa.2199.0..sroa_idx, align 8
  %.sroa.0162.0.copyload = load <2 x float>, ptr %15, align 8
  %25 = select i1 %23, i64 %24, i64 0
  %26 = getelementptr inbounds [24 x %struct.Vector2], ptr %17, i64 0, i64 %25
  %.sroa.0161.0.copyload = load <2 x float>, ptr %26, align 4
  %27 = tail call <2 x float> @_ZL14MathVector2Add7Vector2S_(<2 x float> %.sroa.0162.0.copyload, <2 x float> %.sroa.0161.0.copyload)
  %28 = tail call <2 x float> @_ZL21MathMatVector2Product9Matrix2x27Vector2(<2 x float> %.sroa.0164.0.copyload, <2 x float> %.sroa.2.0.copyload, <2 x float> %27)
  %.sroa.0165.4.vec.extract = extractelement <2 x float> %28, i64 1
  %29 = fsub <2 x float> %22, %28
  %30 = extractelement <2 x float> %29, i64 1
  %.sroa.0165.0.vec.extract = extractelement <2 x float> %28, i64 0
  %31 = fsub <2 x float> %1, %28
  %32 = extractelement <2 x float> %31, i64 0
  %33 = fsub <2 x float> %28, %22
  %34 = extractelement <2 x float> %33, i64 0
  %35 = fsub <2 x float> %1, %28
  %36 = extractelement <2 x float> %35, i64 1
  %37 = fmul float %34, %36
  %38 = tail call float @llvm.fmuladd.f32(float %30, float %32, float %37)
  %39 = fsub float %.sroa.0209.0.copyload, %.sroa.0165.0.vec.extract
  %40 = fsub float %.sroa.6.0.copyload, %.sroa.0165.4.vec.extract
  %41 = fmul float %34, %40
  %42 = tail call float @llvm.fmuladd.f32(float %30, float %39, float %41)
  %43 = fdiv float %38, %42
  %44 = fcmp ogt float %43, 0.000000e+00
  br i1 %44, label %45, label %54

45:                                               ; preds = %19
  %46 = fsub float 1.000000e+00, %43
  %47 = fsub float %.sroa.0165.4.vec.extract, %.sroa.6.0.copyload
  %48 = fmul float %39, %36
  %49 = tail call float @llvm.fmuladd.f32(float %47, float %32, float %48)
  %50 = fdiv float %49, %42
  %51 = fcmp ogt float %50, 0.000000e+00
  %52 = fcmp ogt float %46, %50
  %53 = and i1 %51, %52
  br i1 %53, label %.thread254, label %54

54:                                               ; preds = %19, %45
  %exitcond.not = icmp eq i64 %indvars.iv.next, %18
  br i1 %exitcond.not, label %.loopexit, label %19, !llvm.loop !23

.thread254:                                       ; preds = %45
  %.sroa.0150.0.copyload = load <2 x float>, ptr %15, align 8
  %55 = sext i32 %14 to i64
  %56 = shl nsw i64 %55, 3
  %57 = tail call noalias ptr @malloc(i64 noundef %56) #14
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %5)
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 4 dereferenceable(16) %5, ptr noundef nonnull align 8 dereferenceable(16) %16, i64 16, i1 false), !tbaa.struct !25
  %58 = icmp sgt i32 %14, 0
  br i1 %58, label %.lr.ph274, label %._crit_edge

._crit_edge:                                      ; preds = %.thread254
  tail call void @DestroyPhysicsBody(ptr noundef nonnull %0)
  br label %._crit_edge275

.lr.ph274:                                        ; preds = %.thread254
  %59 = shl nuw nsw i64 %18, 3
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %57, ptr nonnull align 4 %17, i64 %59, i1 false)
  tail call void @DestroyPhysicsBody(ptr noundef nonnull %0)
  %60 = getelementptr inbounds i8, ptr %6, i64 4
  %61 = getelementptr inbounds i8, ptr %6, i64 12
  %62 = getelementptr inbounds i8, ptr %6, i64 20
  %63 = getelementptr inbounds i8, ptr %6, i64 196
  %64 = getelementptr inbounds i8, ptr %6, i64 4
  %65 = insertelement <2 x float> poison, float %2, i64 0
  %66 = shufflevector <2 x float> %65, <2 x float> poison, <2 x i32> zeroinitializer
  br label %67

._crit_edge275:                                   ; preds = %._crit_edge270, %._crit_edge
  call void @free(ptr noundef %57) #13
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %5)
  br label %.loopexit

67:                                               ; preds = %.lr.ph274, %._crit_edge270
  %indvars.iv290 = phi i64 [ 0, %.lr.ph274 ], [ %indvars.iv.next291, %._crit_edge270 ]
  %indvars.iv.next291 = add nuw nsw i64 %indvars.iv290, 1
  %68 = icmp slt i64 %indvars.iv.next291, %55
  %69 = and i64 %indvars.iv.next291, 4294967295
  %70 = getelementptr inbounds %struct.Vector2, ptr %57, i64 %indvars.iv290
  %.sroa.0112.0.copyload = load <2 x float>, ptr %70, align 4
  %71 = select i1 %68, i64 %69, i64 0
  %72 = getelementptr inbounds %struct.Vector2, ptr %57, i64 %71
  %.sroa.0111.0.copyload = load <2 x float>, ptr %72, align 4
  %73 = call <2 x float> @_ZL22MathTriangleBarycenter7Vector2S_S_(<2 x float> %.sroa.0112.0.copyload, <2 x float> %.sroa.0111.0.copyload, <2 x float> zeroinitializer)
  %74 = call <2 x float> @_ZL14MathVector2Add7Vector2S_(<2 x float> %.sroa.0150.0.copyload, <2 x float> %73)
  %75 = call <2 x float> @_ZL19MathVector2Subtract7Vector2S_(<2 x float> %74, <2 x float> %.sroa.0150.0.copyload)
  %76 = call ptr @CreatePhysicsBodyPolygon(<2 x float> %74, float noundef 1.000000e+01, i32 noundef 3, float noundef 1.000000e+01)
  call void @llvm.lifetime.start.p0(i64 388, ptr nonnull %6) #13
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 4 dereferenceable(388) %64, i8 0, i64 384, i1 false)
  store i32 3, ptr %6, align 4, !tbaa !21
  %77 = call <2 x float> @_ZL19MathVector2Subtract7Vector2S_(<2 x float> %.sroa.0112.0.copyload, <2 x float> %75)
  store <2 x float> %77, ptr %60, align 4
  %78 = call <2 x float> @_ZL19MathVector2Subtract7Vector2S_(<2 x float> %.sroa.0111.0.copyload, <2 x float> %75)
  store <2 x float> %78, ptr %61, align 4
  %79 = call <2 x float> @_ZL19MathVector2Subtract7Vector2S_(<2 x float> %1, <2 x float> %74)
  %80 = load <4 x float>, ptr %60, align 4, !tbaa !22
  %81 = fmul <4 x float> %80, <float 0x3FEE666660000000, float 0x3FEE666660000000, float 0x3FEE666660000000, float 0x3FEE666660000000>
  store <4 x float> %81, ptr %60, align 4, !tbaa !22
  %82 = fmul <2 x float> %79, <float 0x3FEE666660000000, float 0x3FEE666660000000>
  store <2 x float> %82, ptr %62, align 4, !tbaa !22
  %83 = load i32, ptr %6, align 4, !tbaa !21
  %.not277 = icmp eq i32 %83, 0
  br i1 %.not277, label %._crit_edge263, label %.lr.ph262

._crit_edge263:                                   ; preds = %.lr.ph262, %67
  %84 = getelementptr inbounds i8, ptr %76, i64 96
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(388) %84, ptr noundef nonnull align 4 dereferenceable(388) %6, i64 388, i1 false), !tbaa.struct !18
  %85 = getelementptr inbounds i8, ptr %76, i64 488
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %85, ptr noundef nonnull align 4 dereferenceable(16) %5, i64 16, i1 false), !tbaa.struct !25
  %86 = load i32, ptr %84, align 8, !tbaa !26
  %.not278 = icmp eq i32 %86, 0
  br i1 %.not278, label %._crit_edge270, label %.lr.ph269

.lr.ph269:                                        ; preds = %._crit_edge263
  %87 = getelementptr inbounds i8, ptr %76, i64 100
  br label %118

.lr.ph262:                                        ; preds = %67, %.lr.ph262
  %indvars.iv284 = phi i64 [ %indvars.iv.next285, %.lr.ph262 ], [ 0, %67 ]
  %88 = phi i32 [ %97, %.lr.ph262 ], [ %83, %67 ]
  %indvars.iv.next285 = add nuw nsw i64 %indvars.iv284, 1
  %89 = zext i32 %88 to i64
  %90 = icmp ult i64 %indvars.iv.next285, %89
  %91 = select i1 %90, i64 %indvars.iv.next285, i64 0
  %92 = getelementptr inbounds [24 x %struct.Vector2], ptr %60, i64 0, i64 %91
  %.sroa.065.0.copyload = load <2 x float>, ptr %92, align 4
  %93 = getelementptr inbounds [24 x %struct.Vector2], ptr %60, i64 0, i64 %indvars.iv284
  %.sroa.064.0.copyload = load <2 x float>, ptr %93, align 4
  %94 = call <2 x float> @_ZL19MathVector2Subtract7Vector2S_(<2 x float> %.sroa.065.0.copyload, <2 x float> %.sroa.064.0.copyload)
  %.sroa.066.4.vec.extract = extractelement <2 x float> %94, i64 1
  %.sroa.066.0.vec.extract = extractelement <2 x float> %94, i64 0
  %95 = fneg float %.sroa.066.0.vec.extract
  %96 = getelementptr inbounds [24 x %struct.Vector2], ptr %63, i64 0, i64 %indvars.iv284
  store float %.sroa.066.4.vec.extract, ptr %96, align 4, !tbaa !22
  %.sroa.463.0..sroa_idx = getelementptr inbounds i8, ptr %96, i64 4
  store float %95, ptr %.sroa.463.0..sroa_idx, align 4, !tbaa !22
  call void @_ZL20MathVector2NormalizeP7Vector2(ptr noundef nonnull %96)
  %97 = load i32, ptr %6, align 4, !tbaa !21
  %98 = zext i32 %97 to i64
  %99 = icmp ult i64 %indvars.iv.next285, %98
  br i1 %99, label %.lr.ph262, label %._crit_edge263, !llvm.loop !27

._crit_edge270:                                   ; preds = %118, %._crit_edge263
  %.0246.lcssa = phi float [ 0.000000e+00, %._crit_edge263 ], [ %134, %118 ]
  %.0245.lcssa = phi float [ 0.000000e+00, %._crit_edge263 ], [ %127, %118 ]
  %100 = getelementptr inbounds i8, ptr %76, i64 52
  store float %.0245.lcssa, ptr %100, align 4, !tbaa !28
  %101 = fcmp une float %.0245.lcssa, 0.000000e+00
  %102 = fdiv float 1.000000e+00, %.0245.lcssa
  %103 = select i1 %101, float %102, float 0.000000e+00
  %104 = getelementptr inbounds i8, ptr %76, i64 56
  store float %103, ptr %104, align 8, !tbaa !29
  %105 = getelementptr inbounds i8, ptr %76, i64 44
  store float %.0246.lcssa, ptr %105, align 4, !tbaa !30
  %106 = fcmp une float %.0246.lcssa, 0.000000e+00
  %107 = fdiv float 1.000000e+00, %.0246.lcssa
  %108 = select i1 %106, float %107, float 0.000000e+00
  %109 = getelementptr inbounds i8, ptr %76, i64 48
  store float %108, ptr %109, align 8, !tbaa !31
  %110 = getelementptr inbounds i8, ptr %76, i64 8
  %.sroa.013.0.copyload = load <2 x float>, ptr %110, align 8
  %.sroa.08.0.copyload = load <2 x float>, ptr %61, align 4
  %.sroa.07.0.copyload = load <2 x float>, ptr %60, align 4
  %111 = call <2 x float> @_ZL19MathVector2Subtract7Vector2S_(<2 x float> %.sroa.08.0.copyload, <2 x float> %.sroa.07.0.copyload)
  %112 = fmul <2 x float> %111, <float 5.000000e-01, float 5.000000e-01>
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %7) #13
  %.sroa.03.0.copyload = load <2 x float>, ptr %60, align 4
  %113 = call <2 x float> @_ZL14MathVector2Add7Vector2S_(<2 x float> %.sroa.03.0.copyload, <2 x float> %112)
  %114 = call <2 x float> @_ZL14MathVector2Add7Vector2S_(<2 x float> %.sroa.013.0.copyload, <2 x float> %113)
  %.sroa.01.0.copyload = load <2 x float>, ptr %110, align 8
  %115 = call <2 x float> @_ZL19MathVector2Subtract7Vector2S_(<2 x float> %114, <2 x float> %.sroa.01.0.copyload)
  store <2 x float> %115, ptr %7, align 8
  call void @_ZL20MathVector2NormalizeP7Vector2(ptr noundef nonnull %7)
  %116 = load <2 x float>, ptr %7, align 8, !tbaa !22
  %117 = fmul <2 x float> %116, %66
  store <2 x float> %117, ptr %7, align 8, !tbaa !22
  call void @PhysicsAddForce(ptr noundef nonnull %76, <2 x float> %117)
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %7) #13
  call void @llvm.lifetime.end.p0(i64 388, ptr nonnull %6) #13
  %exitcond294.not = icmp eq i64 %indvars.iv.next291, %18
  br i1 %exitcond294.not, label %._crit_edge275, label %67, !llvm.loop !32

118:                                              ; preds = %.lr.ph269, %118
  %indvars.iv287 = phi i64 [ 0, %.lr.ph269 ], [ %indvars.iv.next288, %118 ]
  %119 = phi i32 [ %86, %.lr.ph269 ], [ %135, %118 ]
  %.0245266 = phi float [ 0.000000e+00, %.lr.ph269 ], [ %127, %118 ]
  %.0246265 = phi float [ 0.000000e+00, %.lr.ph269 ], [ %134, %118 ]
  %120 = getelementptr inbounds [24 x %struct.Vector2], ptr %87, i64 0, i64 %indvars.iv287
  %.sroa.036.0.copyload = load <2 x float>, ptr %120, align 4
  %indvars.iv.next288 = add nuw nsw i64 %indvars.iv287, 1
  %121 = zext i32 %119 to i64
  %122 = icmp ult i64 %indvars.iv.next288, %121
  %123 = select i1 %122, i64 %indvars.iv.next288, i64 0
  %124 = getelementptr inbounds [24 x %struct.Vector2], ptr %87, i64 0, i64 %123
  %.sroa.022.0.copyload = load <2 x float>, ptr %124, align 4
  %125 = call noundef float @_ZL23MathVector2CrossProduct7Vector2S_(<2 x float> %.sroa.036.0.copyload, <2 x float> %.sroa.022.0.copyload)
  %126 = fmul float %125, 5.000000e-01
  %127 = fadd float %.0245266, %126
  %128 = fmul <2 x float> %.sroa.036.0.copyload, %.sroa.022.0.copyload
  %129 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %.sroa.036.0.copyload, <2 x float> %.sroa.036.0.copyload, <2 x float> %128)
  %130 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %.sroa.022.0.copyload, <2 x float> %.sroa.022.0.copyload, <2 x float> %129)
  %131 = fmul float %125, 0x3FB5555560000000
  %shift = shufflevector <2 x float> %130, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %132 = fadd <2 x float> %130, %shift
  %133 = extractelement <2 x float> %132, i64 0
  %134 = call float @llvm.fmuladd.f32(float %131, float %133, float %.0246265)
  %135 = load i32, ptr %84, align 8, !tbaa !26
  %136 = zext i32 %135 to i64
  %137 = icmp ult i64 %indvars.iv.next288, %136
  br i1 %137, label %118, label %._crit_edge270, !llvm.loop !33

.loopexit:                                        ; preds = %54, %12, %._crit_edge275
  call void @llvm.lifetime.end.p0(i64 388, ptr nonnull %4) #13
  br label %140

138:                                              ; preds = %3
  %139 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.4)
  br label %140

140:                                              ; preds = %8, %.loopexit, %138
  ret void
}

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

; Function Attrs: mustprogress uwtable
declare dso_local void @DestroyPhysicsBody(ptr noundef) local_unnamed_addr #8

; Function Attrs: mustprogress nounwind uwtable
declare hidden <2 x float> @_ZL22MathTriangleBarycenter7Vector2S_S_(<2 x float>, <2 x float>, <2 x float>) local_unnamed_addr #9

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

; Function Attrs: mustprogress nounwind uwtable
declare hidden void @_ZL20MathVector2NormalizeP7Vector2(ptr noundef) local_unnamed_addr #10

; Function Attrs: mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite)
declare void @free(ptr allocptr nocapture noundef) local_unnamed_addr #11

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

attributes #0 = { nofree 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 #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { mustprogress 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 #3 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #4 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #5 = { inlinehint mustprogress nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #6 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #7 = { mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite) "alloc-family"="malloc" "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 #8 = { mustprogress uwtable "min-legal-vector-width"="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 #9 = { mustprogress 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 #10 = { mustprogress nounwind uwtable "min-legal-vector-width"="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 #11 = { mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" "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 #12 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #13 = { nounwind }
attributes #14 = { nounwind allocsize(0) }

!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 80}
!6 = !{!"_ZTS15PhysicsBodyData", !7, i64 0, !10, i64 4, !11, i64 8, !11, i64 16, !11, i64 24, !12, i64 32, !12, i64 36, !12, i64 40, !12, i64 44, !12, i64 48, !12, i64 52, !12, i64 56, !12, i64 60, !12, i64 64, !12, i64 68, !10, i64 72, !10, i64 73, !10, i64 74, !13, i64 80}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C++ TBAA"}
!10 = !{!"bool", !8, i64 0}
!11 = !{!"_ZTS7Vector2", !12, i64 0, !12, i64 4}
!12 = !{!"float", !8, i64 0}
!13 = !{!"_ZTS12PhysicsShape", !14, i64 0, !15, i64 8, !16, i64 16, !12, i64 404, !17, i64 408}
!14 = !{!"_ZTS16PhysicsShapeType", !8, i64 0}
!15 = !{!"any pointer", !8, i64 0}
!16 = !{!"_ZTS17PhysicsVertexData", !7, i64 0, !8, i64 4, !8, i64 196}
!17 = !{!"_ZTS9Matrix2x2", !12, i64 0, !12, i64 4, !12, i64 8, !12, i64 12}
!18 = !{i64 0, i64 4, !19, i64 4, i64 192, !20, i64 196, i64 192, !20}
!19 = !{!7, !7, i64 0}
!20 = !{!8, !8, i64 0}
!21 = !{!16, !7, i64 0}
!22 = !{!12, !12, i64 0}
!23 = distinct !{!23, !24}
!24 = !{!"llvm.loop.mustprogress"}
!25 = !{i64 0, i64 4, !22, i64 4, i64 4, !22, i64 8, i64 4, !22, i64 12, i64 4, !22}
!26 = !{!6, !7, i64 96}
!27 = distinct !{!27, !24}
!28 = !{!6, !12, i64 52}
!29 = !{!6, !12, i64 56}
!30 = !{!6, !12, i64 44}
!31 = !{!6, !12, i64 48}
!32 = distinct !{!32, !24}
!33 = distinct !{!33, !24}


; Effective O3 passes: BDCEPass,CorrelatedValuePropagationPass,DSEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopIdiomRecognizePass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,ReassociatePass,SCCPPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass,VectorCombinePass