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

; 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.b2Transform = type { %struct.b2Vec2, %struct.b2Rot }
%struct.b2Vec2 = type { float, float }
%struct.b2Rot = type { float, float }
%struct.b2Manifold = type { %struct.b2Vec2, float, [2 x %struct.b2ManifoldPoint], i32 }
%struct.b2ManifoldPoint = type { %struct.b2Vec2, %struct.b2Vec2, %struct.b2Vec2, float, float, float, float, float, i16, i8 }
%struct.b2ChainSegmentParams = type { %struct.b2Vec2, %struct.b2Vec2, %struct.b2Vec2, i8, i8 }
%struct.b2DistanceInput = type { %struct.b2ShapeProxy, %struct.b2ShapeProxy, %struct.b2Transform, %struct.b2Transform, i8 }
%struct.b2ShapeProxy = type { [8 x %struct.b2Vec2], i32, float }
%struct.b2DistanceOutput = type { %struct.b2Vec2, %struct.b2Vec2, %struct.b2Vec2, float, i32, i32 }
%struct.b2Polygon = type { [8 x %struct.b2Vec2], [8 x %struct.b2Vec2], %struct.b2Vec2, float, i32 }
%struct.b2ChainSegment = type { %struct.b2Vec2, %struct.b2Segment, %struct.b2Vec2, i32 }
%struct.b2Segment = type { %struct.b2Vec2, %struct.b2Vec2 }
%struct.b2SimplexCache = type { i16, [3 x i8], [3 x i8] }

@b2_lengthUnitsPerMeter = external global float, align 4
@.str.1 = external hidden unnamed_addr constant [64 x i8], align 1
@b2Transform_identity = external hidden constant %struct.b2Transform, align 4
@.str.3 = external hidden unnamed_addr constant [18 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [53 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [44 x i8], align 1

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden { <2 x float>, <2 x float> } @b2InvMulTransforms(<2 x float>, <2 x float>, <2 x float>, <2 x float>) #2

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

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

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

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

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

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

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

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

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

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

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden float @b2MinFloat(float noundef, float noundef) #7

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

; Function Attrs: nounwind uwtable
define dso_local void @b2CollideChainSegmentAndPolygon(ptr dead_on_unwind noalias writable sret(%struct.b2Manifold) align 4 %0, ptr noundef %1, <2 x float> %2, <2 x float> %3, ptr noundef %4, <2 x float> %5, <2 x float> %6, ptr noundef %7) #8 {
  %9 = alloca %struct.b2Transform, align 4
  %10 = alloca %struct.b2Transform, align 4
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca %struct.b2Transform, align 4
  %15 = alloca %struct.b2Vec2, align 4
  %16 = alloca float, align 4
  %17 = alloca %struct.b2Vec2, align 4
  %18 = alloca %struct.b2Vec2, align 4
  %19 = alloca %struct.b2Vec2, align 4
  %20 = alloca %struct.b2Vec2, align 4
  %21 = alloca %struct.b2ChainSegmentParams, align 8
  %22 = alloca float, align 4
  %23 = alloca %struct.b2Vec2, align 4
  %24 = alloca %struct.b2Vec2, align 4
  %25 = alloca %struct.b2Vec2, align 4
  %26 = alloca %struct.b2Vec2, align 4
  %27 = alloca %struct.b2Vec2, align 4
  %28 = alloca %struct.b2Vec2, align 4
  %29 = alloca %struct.b2Vec2, align 4
  %30 = alloca i8, align 1
  %31 = alloca %struct.b2Vec2, align 4
  %32 = alloca i8, align 1
  %33 = alloca i8, align 1
  %34 = alloca %struct.b2Vec2, align 4
  %35 = alloca %struct.b2Vec2, align 4
  %36 = alloca i32, align 4
  %37 = alloca i32, align 4
  %38 = alloca [8 x %struct.b2Vec2], align 16
  %39 = alloca [8 x %struct.b2Vec2], align 16
  %40 = alloca i32, align 4
  %41 = alloca %struct.b2Vec2, align 4
  %42 = alloca %struct.b2Vec2, align 4
  %43 = alloca %struct.b2DistanceInput, align 4
  %44 = alloca %struct.b2ShapeProxy, align 4
  %45 = alloca %struct.b2ShapeProxy, align 4
  %46 = alloca %struct.b2DistanceOutput, align 4
  %47 = alloca %struct.b2Vec2, align 4
  %48 = alloca %struct.b2Vec2, align 4
  %49 = alloca i32, align 4
  %50 = alloca i32, align 4
  %51 = alloca %struct.b2Vec2, align 4
  %52 = alloca %struct.b2Vec2, align 4
  %53 = alloca %struct.b2Vec2, align 4
  %54 = alloca %struct.b2Vec2, align 4
  %55 = alloca i32, align 4
  %56 = alloca %struct.b2Vec2, align 4
  %57 = alloca ptr, align 8
  %58 = alloca %struct.b2Vec2, align 4
  %59 = alloca %struct.b2Vec2, align 4
  %60 = alloca %struct.b2Vec2, align 4
  %61 = alloca %struct.b2Vec2, align 4
  %62 = alloca i32, align 4
  %63 = alloca i32, align 4
  %64 = alloca i32, align 4
  %65 = alloca i32, align 4
  %66 = alloca %struct.b2Vec2, align 4
  %67 = alloca float, align 4
  %68 = alloca float, align 4
  %69 = alloca i32, align 4
  %70 = alloca i32, align 4
  %71 = alloca %struct.b2Vec2, align 4
  %72 = alloca %struct.b2Vec2, align 4
  %73 = alloca %struct.b2Vec2, align 4
  %74 = alloca %struct.b2Vec2, align 4
  %75 = alloca %struct.b2Vec2, align 4
  %76 = alloca %struct.b2Manifold, align 4
  %77 = alloca %struct.b2Vec2, align 4
  %78 = alloca %struct.b2Vec2, align 4
  %79 = alloca %struct.b2Vec2, align 4
  %80 = alloca %struct.b2Vec2, align 4
  %81 = alloca %struct.b2Vec2, align 4
  %82 = alloca %struct.b2Vec2, align 4
  %83 = alloca %struct.b2Vec2, align 4
  %84 = alloca %struct.b2Vec2, align 4
  %85 = alloca %struct.b2Vec2, align 4
  %86 = alloca float, align 4
  %87 = alloca %struct.b2Vec2, align 4
  %88 = alloca float, align 4
  %89 = alloca %struct.b2Vec2, align 4
  %90 = alloca float, align 4
  %91 = alloca i32, align 4
  %92 = alloca float, align 4
  %93 = alloca %struct.b2Vec2, align 4
  %94 = alloca float, align 4
  %95 = alloca i32, align 4
  %96 = alloca float, align 4
  %97 = alloca %struct.b2Vec2, align 4
  %98 = alloca float, align 4
  %99 = alloca i32, align 4
  %100 = alloca float, align 4
  %101 = alloca %struct.b2Vec2, align 4
  %102 = alloca float, align 4
  %103 = alloca i32, align 4
  %104 = alloca i32, align 4
  %105 = alloca %struct.b2Vec2, align 4
  %106 = alloca i32, align 4
  %107 = alloca %struct.b2Vec2, align 4
  %108 = alloca %struct.b2Vec2, align 4
  %109 = alloca float, align 4
  %110 = alloca %struct.b2Vec2, align 4
  %111 = alloca %struct.b2Vec2, align 4
  %112 = alloca i32, align 4
  %113 = alloca i32, align 4
  %114 = alloca %struct.b2Vec2, align 4
  %115 = alloca %struct.b2Vec2, align 4
  %116 = alloca %struct.b2Vec2, align 4
  %117 = alloca float, align 4
  %118 = alloca %struct.b2Vec2, align 4
  %119 = alloca float, align 4
  %120 = alloca %struct.b2Vec2, align 4
  %121 = alloca %struct.b2Manifold, align 4
  %122 = alloca %struct.b2Vec2, align 4
  %123 = alloca %struct.b2Vec2, align 4
  %124 = alloca %struct.b2Vec2, align 4
  %125 = alloca %struct.b2Vec2, align 4
  %126 = alloca %struct.b2Vec2, align 4
  %127 = alloca %struct.b2Vec2, align 4
  %128 = alloca %struct.b2Vec2, align 4
  %129 = alloca %struct.b2Vec2, align 4
  %130 = alloca %struct.b2Vec2, align 4
  %131 = alloca %struct.b2Vec2, align 4
  %132 = alloca %struct.b2Vec2, align 4
  %133 = alloca i32, align 4
  %134 = alloca i32, align 4
  %135 = alloca i32, align 4
  %136 = alloca i32, align 4
  %137 = alloca float, align 4
  %138 = alloca float, align 4
  %139 = alloca %struct.b2Manifold, align 4
  %140 = alloca %struct.b2Vec2, align 4
  %141 = alloca %struct.b2Vec2, align 4
  %142 = alloca %struct.b2Vec2, align 4
  %143 = alloca %struct.b2Vec2, align 4
  %144 = alloca %struct.b2Vec2, align 4
  %145 = alloca %struct.b2Vec2, align 4
  %146 = alloca %struct.b2Vec2, align 4
  %147 = alloca %struct.b2Vec2, align 4
  %148 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %9, i32 0, i32 0
  store <2 x float> %2, ptr %148, align 4
  %149 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %9, i32 0, i32 1
  store <2 x float> %3, ptr %149, align 4
  %150 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %10, i32 0, i32 0
  store <2 x float> %5, ptr %150, align 4
  %151 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %10, i32 0, i32 1
  store <2 x float> %6, ptr %151, align 4
  store ptr %1, ptr %11, align 8, !tbaa !5
  store ptr %4, ptr %12, align 8, !tbaa !5
  store ptr %7, ptr %13, align 8, !tbaa !5
  call void @llvm.memset.p0.i64(ptr align 4 %0, i8 0, i64 112, i1 false)
  call void @llvm.lifetime.start.p0(i64 16, ptr %14) #9
  %152 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %9, i32 0, i32 0
  %153 = load <2 x float>, ptr %152, align 4
  %154 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %9, i32 0, i32 1
  %155 = load <2 x float>, ptr %154, align 4
  %156 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %10, i32 0, i32 0
  %157 = load <2 x float>, ptr %156, align 4
  %158 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %10, i32 0, i32 1
  %159 = load <2 x float>, ptr %158, align 4
  %160 = call { <2 x float>, <2 x float> } @b2InvMulTransforms(<2 x float> %153, <2 x float> %155, <2 x float> %157, <2 x float> %159)
  %161 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %14, i32 0, i32 0
  %162 = extractvalue { <2 x float>, <2 x float> } %160, 0
  store <2 x float> %162, ptr %161, align 4
  %163 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %14, i32 0, i32 1
  %164 = extractvalue { <2 x float>, <2 x float> } %160, 1
  store <2 x float> %164, ptr %163, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #9
  %165 = load ptr, ptr %12, align 8, !tbaa !5
  %166 = getelementptr inbounds %struct.b2Polygon, ptr %165, i32 0, i32 2
  %167 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %14, i32 0, i32 0
  %168 = load <2 x float>, ptr %167, align 4
  %169 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %14, i32 0, i32 1
  %170 = load <2 x float>, ptr %169, align 4
  %171 = load <2 x float>, ptr %166, align 4
  %172 = call <2 x float> @b2TransformPoint(<2 x float> %168, <2 x float> %170, <2 x float> %171)
  store <2 x float> %172, ptr %15, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #9
  %173 = load ptr, ptr %12, align 8, !tbaa !5
  %174 = getelementptr inbounds %struct.b2Polygon, ptr %173, i32 0, i32 3
  %175 = load float, ptr %174, align 4, !tbaa !9
  store float %175, ptr %16, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #9
  %176 = load ptr, ptr %11, align 8, !tbaa !5
  %177 = getelementptr inbounds %struct.b2ChainSegment, ptr %176, i32 0, i32 1
  %178 = getelementptr inbounds %struct.b2Segment, ptr %177, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %17, ptr align 4 %178, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #9
  %179 = load ptr, ptr %11, align 8, !tbaa !5
  %180 = getelementptr inbounds %struct.b2ChainSegment, ptr %179, i32 0, i32 1
  %181 = getelementptr inbounds %struct.b2Segment, ptr %180, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %18, ptr align 4 %181, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #9
  %182 = load <2 x float>, ptr %18, align 4
  %183 = load <2 x float>, ptr %17, align 4
  %184 = call <2 x float> @b2Sub(<2 x float> %182, <2 x float> %183)
  store <2 x float> %184, ptr %20, align 4
  %185 = load <2 x float>, ptr %20, align 4
  %186 = call <2 x float> @b2Normalize(<2 x float> %185)
  store <2 x float> %186, ptr %19, align 4
  call void @llvm.lifetime.start.p0(i64 28, ptr %21) #9
  call void @llvm.memset.p0.i64(ptr align 4 %21, i8 0, i64 28, i1 false)
  %187 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %187, ptr align 4 %19, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #9
  store float 0x3F847AE140000000, ptr %22, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #9
  %188 = load ptr, ptr %11, align 8, !tbaa !5
  %189 = getelementptr inbounds %struct.b2ChainSegment, ptr %188, i32 0, i32 0
  %190 = load <2 x float>, ptr %17, align 4
  %191 = load <2 x float>, ptr %189, align 4
  %192 = call <2 x float> @b2Sub(<2 x float> %190, <2 x float> %191)
  store <2 x float> %192, ptr %24, align 4
  %193 = load <2 x float>, ptr %24, align 4
  %194 = call <2 x float> @b2Normalize(<2 x float> %193)
  store <2 x float> %194, ptr %23, align 4
  %195 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #9
  %196 = load <2 x float>, ptr %23, align 4
  %197 = call <2 x float> @b2RightPerp(<2 x float> %196)
  store <2 x float> %197, ptr %25, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %195, ptr align 4 %25, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #9
  %198 = load <2 x float>, ptr %23, align 4
  %199 = load <2 x float>, ptr %19, align 4
  %200 = call float @b2Cross(<2 x float> %198, <2 x float> %199)
  %201 = fcmp oge float %200, 0x3F847AE140000000
  %202 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 3
  %203 = zext i1 %201 to i8
  store i8 %203, ptr %202, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #9
  %204 = load ptr, ptr %11, align 8, !tbaa !5
  %205 = getelementptr inbounds %struct.b2ChainSegment, ptr %204, i32 0, i32 2
  %206 = load <2 x float>, ptr %205, align 4
  %207 = load <2 x float>, ptr %18, align 4
  %208 = call <2 x float> @b2Sub(<2 x float> %206, <2 x float> %207)
  store <2 x float> %208, ptr %27, align 4
  %209 = load <2 x float>, ptr %27, align 4
  %210 = call <2 x float> @b2Normalize(<2 x float> %209)
  store <2 x float> %210, ptr %26, align 4
  %211 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #9
  %212 = load <2 x float>, ptr %26, align 4
  %213 = call <2 x float> @b2RightPerp(<2 x float> %212)
  store <2 x float> %213, ptr %28, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %211, ptr align 4 %28, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #9
  %214 = load <2 x float>, ptr %19, align 4
  %215 = load <2 x float>, ptr %26, align 4
  %216 = call float @b2Cross(<2 x float> %214, <2 x float> %215)
  %217 = fcmp oge float %216, 0x3F847AE140000000
  %218 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 4
  %219 = zext i1 %217 to i8
  store i8 %219, ptr %218, align 1, !tbaa !19
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #9
  %220 = load <2 x float>, ptr %19, align 4
  %221 = call <2 x float> @b2RightPerp(<2 x float> %220)
  store <2 x float> %221, ptr %29, align 4
  call void @llvm.lifetime.start.p0(i64 1, ptr %30) #9
  %222 = load <2 x float>, ptr %15, align 4
  %223 = load <2 x float>, ptr %17, align 4
  %224 = call <2 x float> @b2Sub(<2 x float> %222, <2 x float> %223)
  store <2 x float> %224, ptr %31, align 4
  %225 = load <2 x float>, ptr %29, align 4
  %226 = load <2 x float>, ptr %31, align 4
  %227 = call float @b2Dot(<2 x float> %225, <2 x float> %226)
  %228 = fcmp olt float %227, 0.000000e+00
  %229 = zext i1 %228 to i8
  store i8 %229, ptr %30, align 1, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 1, ptr %32) #9
  store i8 1, ptr %32, align 1, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 1, ptr %33) #9
  store i8 1, ptr %33, align 1, !tbaa !20
  %230 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 3
  %231 = load i8, ptr %230, align 4, !tbaa !16, !range !21, !noundef !22
  %232 = trunc i8 %231 to i1
  br i1 %232, label %233, label %243

233:                                              ; preds = %8
  %234 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 1
  %235 = load <2 x float>, ptr %15, align 4
  %236 = load <2 x float>, ptr %17, align 4
  %237 = call <2 x float> @b2Sub(<2 x float> %235, <2 x float> %236)
  store <2 x float> %237, ptr %34, align 4
  %238 = load <2 x float>, ptr %234, align 4
  %239 = load <2 x float>, ptr %34, align 4
  %240 = call float @b2Dot(<2 x float> %238, <2 x float> %239)
  %241 = fcmp olt float %240, 0.000000e+00
  %242 = zext i1 %241 to i8
  store i8 %242, ptr %32, align 1, !tbaa !20
  br label %243

243:                                              ; preds = %233, %8
  %244 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 4
  %245 = load i8, ptr %244, align 1, !tbaa !19, !range !21, !noundef !22
  %246 = trunc i8 %245 to i1
  br i1 %246, label %247, label %257

247:                                              ; preds = %243
  %248 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 2
  %249 = load <2 x float>, ptr %15, align 4
  %250 = load <2 x float>, ptr %18, align 4
  %251 = call <2 x float> @b2Sub(<2 x float> %249, <2 x float> %250)
  store <2 x float> %251, ptr %35, align 4
  %252 = load <2 x float>, ptr %248, align 4
  %253 = load <2 x float>, ptr %35, align 4
  %254 = call float @b2Dot(<2 x float> %252, <2 x float> %253)
  %255 = fcmp olt float %254, 0.000000e+00
  %256 = zext i1 %255 to i8
  store i8 %256, ptr %33, align 1, !tbaa !20
  br label %257

257:                                              ; preds = %247, %243
  %258 = load i8, ptr %30, align 1, !tbaa !20, !range !21, !noundef !22
  %259 = trunc i8 %258 to i1
  br i1 %259, label %260, label %267

260:                                              ; preds = %257
  %261 = load i8, ptr %32, align 1, !tbaa !20, !range !21, !noundef !22
  %262 = trunc i8 %261 to i1
  br i1 %262, label %263, label %267

263:                                              ; preds = %260
  %264 = load i8, ptr %33, align 1, !tbaa !20, !range !21, !noundef !22
  %265 = trunc i8 %264 to i1
  br i1 %265, label %266, label %267

266:                                              ; preds = %263
  store i32 1, ptr %36, align 4
  br label %1257

267:                                              ; preds = %263, %260, %257
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #9
  %268 = load ptr, ptr %12, align 8, !tbaa !5
  %269 = getelementptr inbounds %struct.b2Polygon, ptr %268, i32 0, i32 4
  %270 = load i32, ptr %269, align 4, !tbaa !23
  store i32 %270, ptr %37, align 4, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 64, ptr %38) #9
  call void @llvm.lifetime.start.p0(i64 64, ptr %39) #9
  call void @llvm.lifetime.start.p0(i64 4, ptr %40) #9
  store i32 0, ptr %40, align 4, !tbaa !24
  br label %271

271:                                              ; preds = %303, %267
  %272 = load i32, ptr %40, align 4, !tbaa !24
  %273 = load i32, ptr %37, align 4, !tbaa !24
  %274 = icmp slt i32 %272, %273
  br i1 %274, label %276, label %275

275:                                              ; preds = %271
  store i32 2, ptr %36, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #9
  br label %306

276:                                              ; preds = %271
  %277 = load i32, ptr %40, align 4, !tbaa !24
  %278 = sext i32 %277 to i64
  %279 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %278
  call void @llvm.lifetime.start.p0(i64 8, ptr %41) #9
  %280 = load ptr, ptr %12, align 8, !tbaa !5
  %281 = getelementptr inbounds %struct.b2Polygon, ptr %280, i32 0, i32 0
  %282 = load i32, ptr %40, align 4, !tbaa !24
  %283 = sext i32 %282 to i64
  %284 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %281, i64 0, i64 %283
  %285 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %14, i32 0, i32 0
  %286 = load <2 x float>, ptr %285, align 4
  %287 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %14, i32 0, i32 1
  %288 = load <2 x float>, ptr %287, align 4
  %289 = load <2 x float>, ptr %284, align 4
  %290 = call <2 x float> @b2TransformPoint(<2 x float> %286, <2 x float> %288, <2 x float> %289)
  store <2 x float> %290, ptr %41, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %279, ptr align 4 %41, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #9
  %291 = load i32, ptr %40, align 4, !tbaa !24
  %292 = sext i32 %291 to i64
  %293 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %39, i64 0, i64 %292
  call void @llvm.lifetime.start.p0(i64 8, ptr %42) #9
  %294 = getelementptr inbounds %struct.b2Transform, ptr %14, i32 0, i32 1
  %295 = load ptr, ptr %12, align 8, !tbaa !5
  %296 = getelementptr inbounds %struct.b2Polygon, ptr %295, i32 0, i32 1
  %297 = load i32, ptr %40, align 4, !tbaa !24
  %298 = sext i32 %297 to i64
  %299 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %296, i64 0, i64 %298
  %300 = load <2 x float>, ptr %294, align 4
  %301 = load <2 x float>, ptr %299, align 4
  %302 = call <2 x float> @b2RotateVector(<2 x float> %300, <2 x float> %301)
  store <2 x float> %302, ptr %42, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %293, ptr align 4 %42, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #9
  br label %303

303:                                              ; preds = %276
  %304 = load i32, ptr %40, align 4, !tbaa !24
  %305 = add nsw i32 %304, 1
  store i32 %305, ptr %40, align 4, !tbaa !24
  br label %271, !llvm.loop !25

306:                                              ; preds = %275
  call void @llvm.lifetime.start.p0(i64 180, ptr %43) #9
  %307 = getelementptr inbounds %struct.b2DistanceInput, ptr %43, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 72, ptr %44) #9
  %308 = load ptr, ptr %11, align 8, !tbaa !5
  %309 = getelementptr inbounds %struct.b2ChainSegment, ptr %308, i32 0, i32 1
  %310 = getelementptr inbounds %struct.b2Segment, ptr %309, i32 0, i32 0
  call void @b2MakeProxy(ptr dead_on_unwind writable sret(%struct.b2ShapeProxy) align 4 %44, ptr noundef %310, i32 noundef 2, float noundef 0.000000e+00)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %307, ptr align 4 %44, i64 72, i1 false), !tbaa.struct !27
  call void @llvm.lifetime.end.p0(i64 72, ptr %44) #9
  %311 = getelementptr inbounds %struct.b2DistanceInput, ptr %43, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 72, ptr %45) #9
  %312 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 0
  %313 = load i32, ptr %37, align 4, !tbaa !24
  call void @b2MakeProxy(ptr dead_on_unwind writable sret(%struct.b2ShapeProxy) align 4 %45, ptr noundef %312, i32 noundef %313, float noundef 0.000000e+00)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %311, ptr align 4 %45, i64 72, i1 false), !tbaa.struct !27
  call void @llvm.lifetime.end.p0(i64 72, ptr %45) #9
  %314 = getelementptr inbounds %struct.b2DistanceInput, ptr %43, i32 0, i32 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %314, ptr align 4 @b2Transform_identity, i64 16, i1 false), !tbaa.struct !29
  %315 = getelementptr inbounds %struct.b2DistanceInput, ptr %43, i32 0, i32 3
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %315, ptr align 4 @b2Transform_identity, i64 16, i1 false), !tbaa.struct !29
  %316 = getelementptr inbounds %struct.b2DistanceInput, ptr %43, i32 0, i32 4
  store i8 0, ptr %316, align 4, !tbaa !30
  call void @llvm.lifetime.start.p0(i64 36, ptr %46) #9
  %317 = load ptr, ptr %13, align 8, !tbaa !5
  call void @b2ShapeDistance(ptr dead_on_unwind writable sret(%struct.b2DistanceOutput) align 4 %46, ptr noundef %43, ptr noundef %317, ptr noundef null, i32 noundef 0)
  %318 = getelementptr inbounds %struct.b2DistanceOutput, ptr %46, i32 0, i32 3
  %319 = load float, ptr %318, align 4, !tbaa !35
  %320 = load float, ptr %16, align 4, !tbaa !14
  %321 = load float, ptr @b2_lengthUnitsPerMeter, align 4, !tbaa !14
  %322 = fmul float 0x3F747AE140000000, %321
  %323 = call float @llvm.fmuladd.f32(float 4.000000e+00, float %322, float %320)
  %324 = fcmp ogt float %319, %323
  br i1 %324, label %325, label %326

325:                                              ; preds = %306
  store i32 1, ptr %36, align 4
  br label %1256

326:                                              ; preds = %306
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #9
  %327 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 3
  %328 = load i8, ptr %327, align 4, !tbaa !16, !range !21, !noundef !22
  %329 = trunc i8 %328 to i1
  br i1 %329, label %330, label %332

330:                                              ; preds = %326
  %331 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %47, ptr align 4 %331, i64 8, i1 false), !tbaa.struct !15
  br label %333

332:                                              ; preds = %326
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %47, ptr align 4 %29, i64 8, i1 false), !tbaa.struct !15
  br label %333

333:                                              ; preds = %332, %330
  call void @llvm.lifetime.start.p0(i64 8, ptr %48) #9
  %334 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 4
  %335 = load i8, ptr %334, align 1, !tbaa !19, !range !21, !noundef !22
  %336 = trunc i8 %335 to i1
  br i1 %336, label %337, label %339

337:                                              ; preds = %333
  %338 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %48, ptr align 4 %338, i64 8, i1 false), !tbaa.struct !15
  br label %340

339:                                              ; preds = %333
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %48, ptr align 4 %29, i64 8, i1 false), !tbaa.struct !15
  br label %340

340:                                              ; preds = %339, %337
  call void @llvm.lifetime.start.p0(i64 4, ptr %49) #9
  store i32 -1, ptr %49, align 4, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 4, ptr %50) #9
  store i32 -1, ptr %50, align 4, !tbaa !24
  %341 = load i8, ptr %30, align 1, !tbaa !20, !range !21, !noundef !22
  %342 = trunc i8 %341 to i1
  %343 = zext i1 %342 to i32
  %344 = icmp eq i32 %343, 0
  br i1 %344, label %345, label %729

345:                                              ; preds = %340
  %346 = getelementptr inbounds %struct.b2DistanceOutput, ptr %46, i32 0, i32 3
  %347 = load float, ptr %346, align 4, !tbaa !35
  %348 = load float, ptr @b2_lengthUnitsPerMeter, align 4, !tbaa !14
  %349 = fmul float 0x3F747AE140000000, %348
  %350 = fmul float 0x3FB99999A0000000, %349
  %351 = fcmp ogt float %347, %350
  br i1 %351, label %352, label %729

352:                                              ; preds = %345
  %353 = load ptr, ptr %13, align 8, !tbaa !5
  %354 = getelementptr inbounds %struct.b2SimplexCache, ptr %353, i32 0, i32 0
  %355 = load i16, ptr %354, align 2, !tbaa !37
  %356 = zext i16 %355 to i32
  %357 = icmp eq i32 %356, 1
  br i1 %357, label %358, label %440

358:                                              ; preds = %352
  call void @llvm.lifetime.start.p0(i64 8, ptr %51) #9
  %359 = getelementptr inbounds %struct.b2DistanceOutput, ptr %46, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %51, ptr align 4 %359, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 8, ptr %52) #9
  %360 = getelementptr inbounds %struct.b2DistanceOutput, ptr %46, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %52, ptr align 4 %360, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 8, ptr %53) #9
  %361 = load <2 x float>, ptr %52, align 4
  %362 = load <2 x float>, ptr %51, align 4
  %363 = call <2 x float> @b2Sub(<2 x float> %361, <2 x float> %362)
  store <2 x float> %363, ptr %54, align 4
  %364 = load <2 x float>, ptr %54, align 4
  %365 = call <2 x float> @b2Normalize(<2 x float> %364)
  store <2 x float> %365, ptr %53, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %55) #9
  %366 = load <2 x float>, ptr %53, align 4
  %367 = call i32 @b2ClassifyNormal(ptr noundef byval(%struct.b2ChainSegmentParams) align 8 %21, <2 x float> %366)
  store i32 %367, ptr %55, align 4, !tbaa !24
  %368 = load i32, ptr %55, align 4, !tbaa !24
  %369 = icmp eq i32 %368, 0
  br i1 %369, label %370, label %371

370:                                              ; preds = %358
  store i32 1, ptr %36, align 4
  br label %437

371:                                              ; preds = %358
  %372 = load i32, ptr %55, align 4, !tbaa !24
  %373 = icmp eq i32 %372, 1
  br i1 %373, label %374, label %431

374:                                              ; preds = %371
  %375 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %56) #9
  %376 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 1
  %377 = load <2 x float>, ptr %376, align 4
  %378 = load <2 x float>, ptr %53, align 4
  %379 = call <2 x float> @b2RotateVector(<2 x float> %377, <2 x float> %378)
  store <2 x float> %379, ptr %56, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %375, ptr align 4 %56, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %56) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %57) #9
  %380 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %381 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %380, i64 0, i64 0
  %382 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %381, i64 0
  store ptr %382, ptr %57, align 8, !tbaa !5
  %383 = load ptr, ptr %57, align 8, !tbaa !5
  %384 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %383, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %58) #9
  %385 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 1
  %386 = load <2 x float>, ptr %385, align 4
  %387 = load <2 x float>, ptr %51, align 4
  %388 = call <2 x float> @b2RotateVector(<2 x float> %386, <2 x float> %387)
  store <2 x float> %388, ptr %58, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %384, ptr align 4 %58, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %58) #9
  %389 = load ptr, ptr %57, align 8, !tbaa !5
  %390 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %389, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %59) #9
  %391 = load ptr, ptr %57, align 8, !tbaa !5
  %392 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %391, i32 0, i32 1
  %393 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 0
  %394 = getelementptr inbounds %struct.b2Transform, ptr %10, i32 0, i32 0
  %395 = load <2 x float>, ptr %393, align 4
  %396 = load <2 x float>, ptr %394, align 4
  %397 = call <2 x float> @b2Sub(<2 x float> %395, <2 x float> %396)
  store <2 x float> %397, ptr %60, align 4
  %398 = load <2 x float>, ptr %392, align 4
  %399 = load <2 x float>, ptr %60, align 4
  %400 = call <2 x float> @b2Add(<2 x float> %398, <2 x float> %399)
  store <2 x float> %400, ptr %59, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %390, ptr align 4 %59, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %59) #9
  %401 = load ptr, ptr %57, align 8, !tbaa !5
  %402 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %401, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %61) #9
  %403 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 0
  %404 = load ptr, ptr %57, align 8, !tbaa !5
  %405 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %404, i32 0, i32 1
  %406 = load <2 x float>, ptr %403, align 4
  %407 = load <2 x float>, ptr %405, align 4
  %408 = call <2 x float> @b2Add(<2 x float> %406, <2 x float> %407)
  store <2 x float> %408, ptr %61, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %402, ptr align 4 %61, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %61) #9
  %409 = getelementptr inbounds %struct.b2DistanceOutput, ptr %46, i32 0, i32 3
  %410 = load float, ptr %409, align 4, !tbaa !35
  %411 = load float, ptr %16, align 4, !tbaa !14
  %412 = fsub float %410, %411
  %413 = load ptr, ptr %57, align 8, !tbaa !5
  %414 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %413, i32 0, i32 3
  store float %412, ptr %414, align 4, !tbaa !40
  %415 = load ptr, ptr %13, align 8, !tbaa !5
  %416 = getelementptr inbounds %struct.b2SimplexCache, ptr %415, i32 0, i32 1
  %417 = getelementptr inbounds [3 x i8], ptr %416, i64 0, i64 0
  %418 = load i8, ptr %417, align 2, !tbaa !28
  %419 = zext i8 %418 to i32
  %420 = shl i32 %419, 8
  %421 = load ptr, ptr %13, align 8, !tbaa !5
  %422 = getelementptr inbounds %struct.b2SimplexCache, ptr %421, i32 0, i32 2
  %423 = getelementptr inbounds [3 x i8], ptr %422, i64 0, i64 0
  %424 = load i8, ptr %423, align 1, !tbaa !28
  %425 = zext i8 %424 to i32
  %426 = or i32 %420, %425
  %427 = trunc i32 %426 to i16
  %428 = load ptr, ptr %57, align 8, !tbaa !5
  %429 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %428, i32 0, i32 8
  store i16 %427, ptr %429, align 4, !tbaa !42
  %430 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 3
  store i32 1, ptr %430, align 4, !tbaa !43
  store i32 1, ptr %36, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %57) #9
  br label %437

431:                                              ; preds = %371
  %432 = load ptr, ptr %13, align 8, !tbaa !5
  %433 = getelementptr inbounds %struct.b2SimplexCache, ptr %432, i32 0, i32 2
  %434 = getelementptr inbounds [3 x i8], ptr %433, i64 0, i64 0
  %435 = load i8, ptr %434, align 1, !tbaa !28
  %436 = zext i8 %435 to i32
  store i32 %436, ptr %49, align 4, !tbaa !24
  store i32 0, ptr %36, align 4
  br label %437

437:                                              ; preds = %431, %374, %370
  call void @llvm.lifetime.end.p0(i64 4, ptr %55) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %53) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %52) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %51) #9
  %438 = load i32, ptr %36, align 4
  switch i32 %438, label %1255 [
    i32 0, label %439
  ]

439:                                              ; preds = %437
  br label %728

440:                                              ; preds = %352
  br label %441

441:                                              ; preds = %440
  %442 = load ptr, ptr %13, align 8, !tbaa !5
  %443 = getelementptr inbounds %struct.b2SimplexCache, ptr %442, i32 0, i32 0
  %444 = load i16, ptr %443, align 2, !tbaa !37
  %445 = zext i16 %444 to i32
  %446 = icmp eq i32 %445, 2
  br i1 %446, label %451, label %447

447:                                              ; preds = %441
  %448 = call i32 @b2InternalAssertFcn(ptr noundef @.str.3, ptr noundef @.str.1, i32 noundef 1438)
  %449 = icmp ne i32 %448, 0
  br i1 %449, label %450, label %451

450:                                              ; preds = %447
  call void @llvm.trap()
  br label %451

451:                                              ; preds = %450, %447, %441
  br label %452

452:                                              ; preds = %451
  br label %453

453:                                              ; preds = %452
  call void @llvm.lifetime.start.p0(i64 4, ptr %62) #9
  %454 = load ptr, ptr %13, align 8, !tbaa !5
  %455 = getelementptr inbounds %struct.b2SimplexCache, ptr %454, i32 0, i32 1
  %456 = getelementptr inbounds [3 x i8], ptr %455, i64 0, i64 0
  %457 = load i8, ptr %456, align 2, !tbaa !28
  %458 = zext i8 %457 to i32
  store i32 %458, ptr %62, align 4, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 4, ptr %63) #9
  %459 = load ptr, ptr %13, align 8, !tbaa !5
  %460 = getelementptr inbounds %struct.b2SimplexCache, ptr %459, i32 0, i32 1
  %461 = getelementptr inbounds [3 x i8], ptr %460, i64 0, i64 1
  %462 = load i8, ptr %461, align 1, !tbaa !28
  %463 = zext i8 %462 to i32
  store i32 %463, ptr %63, align 4, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 4, ptr %64) #9
  %464 = load ptr, ptr %13, align 8, !tbaa !5
  %465 = getelementptr inbounds %struct.b2SimplexCache, ptr %464, i32 0, i32 2
  %466 = getelementptr inbounds [3 x i8], ptr %465, i64 0, i64 0
  %467 = load i8, ptr %466, align 1, !tbaa !28
  %468 = zext i8 %467 to i32
  store i32 %468, ptr %64, align 4, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 4, ptr %65) #9
  %469 = load ptr, ptr %13, align 8, !tbaa !5
  %470 = getelementptr inbounds %struct.b2SimplexCache, ptr %469, i32 0, i32 2
  %471 = getelementptr inbounds [3 x i8], ptr %470, i64 0, i64 1
  %472 = load i8, ptr %471, align 1, !tbaa !28
  %473 = zext i8 %472 to i32
  store i32 %473, ptr %65, align 4, !tbaa !24
  %474 = load i32, ptr %62, align 4, !tbaa !24
  %475 = load i32, ptr %63, align 4, !tbaa !24
  %476 = icmp eq i32 %474, %475
  br i1 %476, label %477, label %696

477:                                              ; preds = %453
  br label %478

478:                                              ; preds = %477
  %479 = load i32, ptr %64, align 4, !tbaa !24
  %480 = load i32, ptr %65, align 4, !tbaa !24
  %481 = icmp ne i32 %479, %480
  br i1 %481, label %486, label %482

482:                                              ; preds = %478
  %483 = call i32 @b2InternalAssertFcn(ptr noundef @.str.4, ptr noundef @.str.1, i32 noundef 1448)
  %484 = icmp ne i32 %483, 0
  br i1 %484, label %485, label %486

485:                                              ; preds = %482
  call void @llvm.trap()
  br label %486

486:                                              ; preds = %485, %482, %478
  br label %487

487:                                              ; preds = %486
  br label %488

488:                                              ; preds = %487
  call void @llvm.lifetime.start.p0(i64 8, ptr %66) #9
  %489 = getelementptr inbounds %struct.b2DistanceOutput, ptr %46, i32 0, i32 0
  %490 = getelementptr inbounds %struct.b2DistanceOutput, ptr %46, i32 0, i32 1
  %491 = load <2 x float>, ptr %489, align 4
  %492 = load <2 x float>, ptr %490, align 4
  %493 = call <2 x float> @b2Sub(<2 x float> %491, <2 x float> %492)
  store <2 x float> %493, ptr %66, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %67) #9
  %494 = load i32, ptr %64, align 4, !tbaa !24
  %495 = sext i32 %494 to i64
  %496 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %39, i64 0, i64 %495
  %497 = load <2 x float>, ptr %66, align 4
  %498 = load <2 x float>, ptr %496, align 8
  %499 = call float @b2Dot(<2 x float> %497, <2 x float> %498)
  store float %499, ptr %67, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %68) #9
  %500 = load i32, ptr %65, align 4, !tbaa !24
  %501 = sext i32 %500 to i64
  %502 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %39, i64 0, i64 %501
  %503 = load <2 x float>, ptr %66, align 4
  %504 = load <2 x float>, ptr %502, align 8
  %505 = call float @b2Dot(<2 x float> %503, <2 x float> %504)
  store float %505, ptr %68, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %69) #9
  %506 = load float, ptr %67, align 4, !tbaa !14
  %507 = load float, ptr %68, align 4, !tbaa !14
  %508 = fcmp ogt float %506, %507
  br i1 %508, label %509, label %511

509:                                              ; preds = %488
  %510 = load i32, ptr %64, align 4, !tbaa !24
  br label %513

511:                                              ; preds = %488
  %512 = load i32, ptr %65, align 4, !tbaa !24
  br label %513

513:                                              ; preds = %511, %509
  %514 = phi i32 [ %510, %509 ], [ %512, %511 ]
  store i32 %514, ptr %69, align 4, !tbaa !24
  %515 = load i32, ptr %69, align 4, !tbaa !24
  %516 = sext i32 %515 to i64
  %517 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %39, i64 0, i64 %516
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %66, ptr align 8 %517, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %70) #9
  %518 = load <2 x float>, ptr %66, align 4
  %519 = call <2 x float> @b2Neg(<2 x float> %518)
  store <2 x float> %519, ptr %71, align 4
  %520 = load <2 x float>, ptr %71, align 4
  %521 = call i32 @b2ClassifyNormal(ptr noundef byval(%struct.b2ChainSegmentParams) align 8 %21, <2 x float> %520)
  store i32 %521, ptr %70, align 4, !tbaa !24
  %522 = load i32, ptr %70, align 4, !tbaa !24
  %523 = icmp eq i32 %522, 0
  br i1 %523, label %524, label %525

524:                                              ; preds = %513
  store i32 1, ptr %36, align 4
  br label %693

525:                                              ; preds = %513
  %526 = load i32, ptr %70, align 4, !tbaa !24
  %527 = icmp eq i32 %526, 1
  br i1 %527, label %528, label %691

528:                                              ; preds = %525
  %529 = load i32, ptr %69, align 4, !tbaa !24
  store i32 %529, ptr %64, align 4, !tbaa !24
  %530 = load i32, ptr %69, align 4, !tbaa !24
  %531 = load i32, ptr %37, align 4, !tbaa !24
  %532 = sub nsw i32 %531, 1
  %533 = icmp slt i32 %530, %532
  br i1 %533, label %534, label %537

534:                                              ; preds = %528
  %535 = load i32, ptr %69, align 4, !tbaa !24
  %536 = add nsw i32 %535, 1
  br label %538

537:                                              ; preds = %528
  br label %538

538:                                              ; preds = %537, %534
  %539 = phi i32 [ %536, %534 ], [ 0, %537 ]
  store i32 %539, ptr %65, align 4, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %72) #9
  %540 = load i32, ptr %64, align 4, !tbaa !24
  %541 = sext i32 %540 to i64
  %542 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %541
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %72, ptr align 8 %542, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 8, ptr %73) #9
  %543 = load i32, ptr %65, align 4, !tbaa !24
  %544 = sext i32 %543 to i64
  %545 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %544
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %73, ptr align 8 %545, i64 8, i1 false), !tbaa.struct !15
  %546 = load <2 x float>, ptr %17, align 4
  %547 = load <2 x float>, ptr %72, align 4
  %548 = call <2 x float> @b2Sub(<2 x float> %546, <2 x float> %547)
  store <2 x float> %548, ptr %74, align 4
  %549 = load <2 x float>, ptr %66, align 4
  %550 = load <2 x float>, ptr %74, align 4
  %551 = call float @b2Dot(<2 x float> %549, <2 x float> %550)
  store float %551, ptr %67, align 4, !tbaa !14
  %552 = load <2 x float>, ptr %18, align 4
  %553 = load <2 x float>, ptr %72, align 4
  %554 = call <2 x float> @b2Sub(<2 x float> %552, <2 x float> %553)
  store <2 x float> %554, ptr %75, align 4
  %555 = load <2 x float>, ptr %66, align 4
  %556 = load <2 x float>, ptr %75, align 4
  %557 = call float @b2Dot(<2 x float> %555, <2 x float> %556)
  store float %557, ptr %68, align 4, !tbaa !14
  %558 = load float, ptr %67, align 4, !tbaa !14
  %559 = load float, ptr %68, align 4, !tbaa !14
  %560 = fcmp olt float %558, %559
  br i1 %560, label %561, label %571

561:                                              ; preds = %538
  %562 = load <2 x float>, ptr %47, align 4
  %563 = load <2 x float>, ptr %66, align 4
  %564 = call float @b2Dot(<2 x float> %562, <2 x float> %563)
  %565 = load <2 x float>, ptr %29, align 4
  %566 = load <2 x float>, ptr %66, align 4
  %567 = call float @b2Dot(<2 x float> %565, <2 x float> %566)
  %568 = fcmp olt float %564, %567
  br i1 %568, label %569, label %570

569:                                              ; preds = %561
  store i32 1, ptr %36, align 4
  br label %690

570:                                              ; preds = %561
  br label %581

571:                                              ; preds = %538
  %572 = load <2 x float>, ptr %48, align 4
  %573 = load <2 x float>, ptr %66, align 4
  %574 = call float @b2Dot(<2 x float> %572, <2 x float> %573)
  %575 = load <2 x float>, ptr %29, align 4
  %576 = load <2 x float>, ptr %66, align 4
  %577 = call float @b2Dot(<2 x float> %575, <2 x float> %576)
  %578 = fcmp olt float %574, %577
  br i1 %578, label %579, label %580

579:                                              ; preds = %571
  store i32 1, ptr %36, align 4
  br label %690

580:                                              ; preds = %571
  br label %581

581:                                              ; preds = %580, %570
  call void @llvm.lifetime.start.p0(i64 112, ptr %76) #9
  %582 = load float, ptr %16, align 4, !tbaa !14
  %583 = load i32, ptr %64, align 4, !tbaa !24
  %584 = trunc i32 %583 to i8
  %585 = zext i8 %584 to i32
  %586 = shl i32 %585, 8
  %587 = or i32 %586, 1
  %588 = trunc i32 %587 to i16
  %589 = load i32, ptr %65, align 4, !tbaa !24
  %590 = trunc i32 %589 to i8
  %591 = zext i8 %590 to i32
  %592 = shl i32 %591, 8
  %593 = or i32 %592, 0
  %594 = trunc i32 %593 to i16
  %595 = load <2 x float>, ptr %72, align 4
  %596 = load <2 x float>, ptr %73, align 4
  %597 = load <2 x float>, ptr %17, align 4
  %598 = load <2 x float>, ptr %18, align 4
  %599 = load <2 x float>, ptr %66, align 4
  call void @b2ClipSegments(ptr dead_on_unwind writable sret(%struct.b2Manifold) align 4 %76, <2 x float> %595, <2 x float> %596, <2 x float> %597, <2 x float> %598, <2 x float> %599, float noundef %582, float noundef 0.000000e+00, i16 noundef zeroext %588, i16 noundef zeroext %594)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 %76, i64 112, i1 false), !tbaa.struct !45
  call void @llvm.lifetime.end.p0(i64 112, ptr %76) #9
  br label %600

600:                                              ; preds = %581
  %601 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 3
  %602 = load i32, ptr %601, align 4, !tbaa !43
  %603 = icmp eq i32 %602, 0
  br i1 %603, label %612, label %604

604:                                              ; preds = %600
  %605 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 3
  %606 = load i32, ptr %605, align 4, !tbaa !43
  %607 = icmp eq i32 %606, 2
  br i1 %607, label %612, label %608

608:                                              ; preds = %604
  %609 = call i32 @b2InternalAssertFcn(ptr noundef @.str.5, ptr noundef @.str.1, i32 noundef 1499)
  %610 = icmp ne i32 %609, 0
  br i1 %610, label %611, label %612

611:                                              ; preds = %608
  call void @llvm.trap()
  br label %612

612:                                              ; preds = %611, %608, %604, %600
  br label %613

613:                                              ; preds = %612
  br label %614

614:                                              ; preds = %613
  %615 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 3
  %616 = load i32, ptr %615, align 4, !tbaa !43
  %617 = icmp eq i32 %616, 2
  br i1 %617, label %618, label %689

618:                                              ; preds = %614
  %619 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %77) #9
  %620 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 1
  %621 = load <2 x float>, ptr %66, align 4
  %622 = call <2 x float> @b2Neg(<2 x float> %621)
  store <2 x float> %622, ptr %78, align 4
  %623 = load <2 x float>, ptr %620, align 4
  %624 = load <2 x float>, ptr %78, align 4
  %625 = call <2 x float> @b2RotateVector(<2 x float> %623, <2 x float> %624)
  store <2 x float> %625, ptr %77, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %619, ptr align 4 %77, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %77) #9
  %626 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %627 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %626, i64 0, i64 0
  %628 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %627, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %79) #9
  %629 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 1
  %630 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %631 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %630, i64 0, i64 0
  %632 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %631, i32 0, i32 1
  %633 = load <2 x float>, ptr %629, align 4
  %634 = load <2 x float>, ptr %632, align 4
  %635 = call <2 x float> @b2RotateVector(<2 x float> %633, <2 x float> %634)
  store <2 x float> %635, ptr %79, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %628, ptr align 4 %79, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %79) #9
  %636 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %637 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %636, i64 0, i64 1
  %638 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %637, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %80) #9
  %639 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 1
  %640 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %641 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %640, i64 0, i64 1
  %642 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %641, i32 0, i32 1
  %643 = load <2 x float>, ptr %639, align 4
  %644 = load <2 x float>, ptr %642, align 4
  %645 = call <2 x float> @b2RotateVector(<2 x float> %643, <2 x float> %644)
  store <2 x float> %645, ptr %80, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %638, ptr align 4 %80, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %80) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %81) #9
  %646 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 0
  %647 = getelementptr inbounds %struct.b2Transform, ptr %10, i32 0, i32 0
  %648 = load <2 x float>, ptr %646, align 4
  %649 = load <2 x float>, ptr %647, align 4
  %650 = call <2 x float> @b2Sub(<2 x float> %648, <2 x float> %649)
  store <2 x float> %650, ptr %81, align 4
  %651 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %652 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %651, i64 0, i64 0
  %653 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %652, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %82) #9
  %654 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %655 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %654, i64 0, i64 0
  %656 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %655, i32 0, i32 1
  %657 = load <2 x float>, ptr %656, align 4
  %658 = load <2 x float>, ptr %81, align 4
  %659 = call <2 x float> @b2Add(<2 x float> %657, <2 x float> %658)
  store <2 x float> %659, ptr %82, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %653, ptr align 4 %82, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %82) #9
  %660 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %661 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %660, i64 0, i64 1
  %662 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %661, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %83) #9
  %663 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %664 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %663, i64 0, i64 1
  %665 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %664, i32 0, i32 1
  %666 = load <2 x float>, ptr %665, align 4
  %667 = load <2 x float>, ptr %81, align 4
  %668 = call <2 x float> @b2Add(<2 x float> %666, <2 x float> %667)
  store <2 x float> %668, ptr %83, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %662, ptr align 4 %83, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %83) #9
  %669 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %670 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %669, i64 0, i64 0
  %671 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %670, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %84) #9
  %672 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 0
  %673 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %674 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %673, i64 0, i64 0
  %675 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %674, i32 0, i32 1
  %676 = load <2 x float>, ptr %672, align 4
  %677 = load <2 x float>, ptr %675, align 4
  %678 = call <2 x float> @b2Add(<2 x float> %676, <2 x float> %677)
  store <2 x float> %678, ptr %84, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %671, ptr align 4 %84, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %84) #9
  %679 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %680 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %679, i64 0, i64 1
  %681 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %680, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %85) #9
  %682 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 0
  %683 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %684 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %683, i64 0, i64 1
  %685 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %684, i32 0, i32 1
  %686 = load <2 x float>, ptr %682, align 4
  %687 = load <2 x float>, ptr %685, align 4
  %688 = call <2 x float> @b2Add(<2 x float> %686, <2 x float> %687)
  store <2 x float> %688, ptr %85, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %681, ptr align 4 %85, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %85) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %81) #9
  br label %689

689:                                              ; preds = %618, %614
  store i32 1, ptr %36, align 4
  br label %690

690:                                              ; preds = %689, %579, %569
  call void @llvm.lifetime.end.p0(i64 8, ptr %73) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %72) #9
  br label %693

691:                                              ; preds = %525
  %692 = load i32, ptr %69, align 4, !tbaa !24
  store i32 %692, ptr %50, align 4, !tbaa !24
  store i32 0, ptr %36, align 4
  br label %693

693:                                              ; preds = %691, %690, %524
  call void @llvm.lifetime.end.p0(i64 4, ptr %70) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %69) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %68) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %67) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %66) #9
  %694 = load i32, ptr %36, align 4
  switch i32 %694, label %725 [
    i32 0, label %695
  ]

695:                                              ; preds = %693
  br label %724

696:                                              ; preds = %453
  call void @llvm.lifetime.start.p0(i64 4, ptr %86) #9
  %697 = load i32, ptr %64, align 4, !tbaa !24
  %698 = sext i32 %697 to i64
  %699 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %698
  %700 = load <2 x float>, ptr %699, align 8
  %701 = load <2 x float>, ptr %17, align 4
  %702 = call <2 x float> @b2Sub(<2 x float> %700, <2 x float> %701)
  store <2 x float> %702, ptr %87, align 4
  %703 = load <2 x float>, ptr %29, align 4
  %704 = load <2 x float>, ptr %87, align 4
  %705 = call float @b2Dot(<2 x float> %703, <2 x float> %704)
  store float %705, ptr %86, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %88) #9
  %706 = load i32, ptr %65, align 4, !tbaa !24
  %707 = sext i32 %706 to i64
  %708 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %707
  %709 = load <2 x float>, ptr %708, align 8
  %710 = load <2 x float>, ptr %18, align 4
  %711 = call <2 x float> @b2Sub(<2 x float> %709, <2 x float> %710)
  store <2 x float> %711, ptr %89, align 4
  %712 = load <2 x float>, ptr %29, align 4
  %713 = load <2 x float>, ptr %89, align 4
  %714 = call float @b2Dot(<2 x float> %712, <2 x float> %713)
  store float %714, ptr %88, align 4, !tbaa !14
  %715 = load float, ptr %86, align 4, !tbaa !14
  %716 = load float, ptr %88, align 4, !tbaa !14
  %717 = fcmp olt float %715, %716
  br i1 %717, label %718, label %720

718:                                              ; preds = %696
  %719 = load i32, ptr %64, align 4, !tbaa !24
  br label %722

720:                                              ; preds = %696
  %721 = load i32, ptr %65, align 4, !tbaa !24
  br label %722

722:                                              ; preds = %720, %718
  %723 = phi i32 [ %719, %718 ], [ %721, %720 ]
  store i32 %723, ptr %49, align 4, !tbaa !24
  call void @llvm.lifetime.end.p0(i64 4, ptr %88) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %86) #9
  br label %724

724:                                              ; preds = %722, %695
  store i32 0, ptr %36, align 4
  br label %725

725:                                              ; preds = %724, %693
  call void @llvm.lifetime.end.p0(i64 4, ptr %65) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %64) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %62) #9
  %726 = load i32, ptr %36, align 4
  switch i32 %726, label %1255 [
    i32 0, label %727
  ]

727:                                              ; preds = %725
  br label %728

728:                                              ; preds = %727, %439
  br label %1060

729:                                              ; preds = %345, %340
  call void @llvm.lifetime.start.p0(i64 4, ptr %90) #9
  store float 0x47EFFFFFE0000000, ptr %90, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %91) #9
  store i32 0, ptr %91, align 4, !tbaa !24
  br label %730

730:                                              ; preds = %752, %729
  %731 = load i32, ptr %91, align 4, !tbaa !24
  %732 = load i32, ptr %37, align 4, !tbaa !24
  %733 = icmp slt i32 %731, %732
  br i1 %733, label %735, label %734

734:                                              ; preds = %730
  store i32 11, ptr %36, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %91) #9
  br label %755

735:                                              ; preds = %730
  call void @llvm.lifetime.start.p0(i64 4, ptr %92) #9
  %736 = load i32, ptr %91, align 4, !tbaa !24
  %737 = sext i32 %736 to i64
  %738 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %737
  %739 = load <2 x float>, ptr %738, align 8
  %740 = load <2 x float>, ptr %17, align 4
  %741 = call <2 x float> @b2Sub(<2 x float> %739, <2 x float> %740)
  store <2 x float> %741, ptr %93, align 4
  %742 = load <2 x float>, ptr %29, align 4
  %743 = load <2 x float>, ptr %93, align 4
  %744 = call float @b2Dot(<2 x float> %742, <2 x float> %743)
  store float %744, ptr %92, align 4, !tbaa !14
  %745 = load float, ptr %92, align 4, !tbaa !14
  %746 = load float, ptr %90, align 4, !tbaa !14
  %747 = fcmp olt float %745, %746
  br i1 %747, label %748, label %751

748:                                              ; preds = %735
  %749 = load float, ptr %92, align 4, !tbaa !14
  store float %749, ptr %90, align 4, !tbaa !14
  %750 = load i32, ptr %91, align 4, !tbaa !24
  store i32 %750, ptr %49, align 4, !tbaa !24
  br label %751

751:                                              ; preds = %748, %735
  call void @llvm.lifetime.end.p0(i64 4, ptr %92) #9
  br label %752

752:                                              ; preds = %751
  %753 = load i32, ptr %91, align 4, !tbaa !24
  %754 = add nsw i32 %753, 1
  store i32 %754, ptr %91, align 4, !tbaa !24
  br label %730, !llvm.loop !46

755:                                              ; preds = %734
  %756 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 3
  %757 = load i8, ptr %756, align 4, !tbaa !16, !range !21, !noundef !22
  %758 = trunc i8 %757 to i1
  br i1 %758, label %759, label %792

759:                                              ; preds = %755
  call void @llvm.lifetime.start.p0(i64 4, ptr %94) #9
  store float 0x47EFFFFFE0000000, ptr %94, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %95) #9
  store i32 0, ptr %95, align 4, !tbaa !24
  br label %760

760:                                              ; preds = %782, %759
  %761 = load i32, ptr %95, align 4, !tbaa !24
  %762 = load i32, ptr %37, align 4, !tbaa !24
  %763 = icmp slt i32 %761, %762
  br i1 %763, label %765, label %764

764:                                              ; preds = %760
  store i32 14, ptr %36, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %95) #9
  br label %785

765:                                              ; preds = %760
  call void @llvm.lifetime.start.p0(i64 4, ptr %96) #9
  %766 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 1
  %767 = load i32, ptr %95, align 4, !tbaa !24
  %768 = sext i32 %767 to i64
  %769 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %768
  %770 = load <2 x float>, ptr %769, align 8
  %771 = load <2 x float>, ptr %17, align 4
  %772 = call <2 x float> @b2Sub(<2 x float> %770, <2 x float> %771)
  store <2 x float> %772, ptr %97, align 4
  %773 = load <2 x float>, ptr %766, align 4
  %774 = load <2 x float>, ptr %97, align 4
  %775 = call float @b2Dot(<2 x float> %773, <2 x float> %774)
  store float %775, ptr %96, align 4, !tbaa !14
  %776 = load float, ptr %96, align 4, !tbaa !14
  %777 = load float, ptr %94, align 4, !tbaa !14
  %778 = fcmp olt float %776, %777
  br i1 %778, label %779, label %781

779:                                              ; preds = %765
  %780 = load float, ptr %96, align 4, !tbaa !14
  store float %780, ptr %94, align 4, !tbaa !14
  br label %781

781:                                              ; preds = %779, %765
  call void @llvm.lifetime.end.p0(i64 4, ptr %96) #9
  br label %782

782:                                              ; preds = %781
  %783 = load i32, ptr %95, align 4, !tbaa !24
  %784 = add nsw i32 %783, 1
  store i32 %784, ptr %95, align 4, !tbaa !24
  br label %760, !llvm.loop !47

785:                                              ; preds = %764
  %786 = load float, ptr %94, align 4, !tbaa !14
  %787 = load float, ptr %90, align 4, !tbaa !14
  %788 = fcmp ogt float %786, %787
  br i1 %788, label %789, label %791

789:                                              ; preds = %785
  %790 = load float, ptr %94, align 4, !tbaa !14
  store float %790, ptr %90, align 4, !tbaa !14
  store i32 -1, ptr %49, align 4, !tbaa !24
  br label %791

791:                                              ; preds = %789, %785
  call void @llvm.lifetime.end.p0(i64 4, ptr %94) #9
  br label %792

792:                                              ; preds = %791, %755
  %793 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 4
  %794 = load i8, ptr %793, align 1, !tbaa !19, !range !21, !noundef !22
  %795 = trunc i8 %794 to i1
  br i1 %795, label %796, label %829

796:                                              ; preds = %792
  call void @llvm.lifetime.start.p0(i64 4, ptr %98) #9
  store float 0x47EFFFFFE0000000, ptr %98, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %99) #9
  store i32 0, ptr %99, align 4, !tbaa !24
  br label %797

797:                                              ; preds = %819, %796
  %798 = load i32, ptr %99, align 4, !tbaa !24
  %799 = load i32, ptr %37, align 4, !tbaa !24
  %800 = icmp slt i32 %798, %799
  br i1 %800, label %802, label %801

801:                                              ; preds = %797
  store i32 17, ptr %36, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %99) #9
  br label %822

802:                                              ; preds = %797
  call void @llvm.lifetime.start.p0(i64 4, ptr %100) #9
  %803 = getelementptr inbounds %struct.b2ChainSegmentParams, ptr %21, i32 0, i32 2
  %804 = load i32, ptr %99, align 4, !tbaa !24
  %805 = sext i32 %804 to i64
  %806 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %805
  %807 = load <2 x float>, ptr %806, align 8
  %808 = load <2 x float>, ptr %18, align 4
  %809 = call <2 x float> @b2Sub(<2 x float> %807, <2 x float> %808)
  store <2 x float> %809, ptr %101, align 4
  %810 = load <2 x float>, ptr %803, align 4
  %811 = load <2 x float>, ptr %101, align 4
  %812 = call float @b2Dot(<2 x float> %810, <2 x float> %811)
  store float %812, ptr %100, align 4, !tbaa !14
  %813 = load float, ptr %100, align 4, !tbaa !14
  %814 = load float, ptr %98, align 4, !tbaa !14
  %815 = fcmp olt float %813, %814
  br i1 %815, label %816, label %818

816:                                              ; preds = %802
  %817 = load float, ptr %100, align 4, !tbaa !14
  store float %817, ptr %98, align 4, !tbaa !14
  br label %818

818:                                              ; preds = %816, %802
  call void @llvm.lifetime.end.p0(i64 4, ptr %100) #9
  br label %819

819:                                              ; preds = %818
  %820 = load i32, ptr %99, align 4, !tbaa !24
  %821 = add nsw i32 %820, 1
  store i32 %821, ptr %99, align 4, !tbaa !24
  br label %797, !llvm.loop !48

822:                                              ; preds = %801
  %823 = load float, ptr %98, align 4, !tbaa !14
  %824 = load float, ptr %90, align 4, !tbaa !14
  %825 = fcmp ogt float %823, %824
  br i1 %825, label %826, label %828

826:                                              ; preds = %822
  %827 = load float, ptr %98, align 4, !tbaa !14
  store float %827, ptr %90, align 4, !tbaa !14
  store i32 -1, ptr %49, align 4, !tbaa !24
  br label %828

828:                                              ; preds = %826, %822
  call void @llvm.lifetime.end.p0(i64 4, ptr %98) #9
  br label %829

829:                                              ; preds = %828, %792
  call void @llvm.lifetime.start.p0(i64 4, ptr %102) #9
  store float 0xC7EFFFFFE0000000, ptr %102, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %103) #9
  store i32 -1, ptr %103, align 4, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 4, ptr %104) #9
  store i32 0, ptr %104, align 4, !tbaa !24
  br label %830

830:                                              ; preds = %873, %829
  %831 = load i32, ptr %104, align 4, !tbaa !24
  %832 = load i32, ptr %37, align 4, !tbaa !24
  %833 = icmp slt i32 %831, %832
  br i1 %833, label %835, label %834

834:                                              ; preds = %830
  store i32 20, ptr %36, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %104) #9
  br label %876

835:                                              ; preds = %830
  call void @llvm.lifetime.start.p0(i64 8, ptr %105) #9
  %836 = load i32, ptr %104, align 4, !tbaa !24
  %837 = sext i32 %836 to i64
  %838 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %39, i64 0, i64 %837
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %105, ptr align 8 %838, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %106) #9
  %839 = load <2 x float>, ptr %105, align 4
  %840 = call <2 x float> @b2Neg(<2 x float> %839)
  store <2 x float> %840, ptr %107, align 4
  %841 = load <2 x float>, ptr %107, align 4
  %842 = call i32 @b2ClassifyNormal(ptr noundef byval(%struct.b2ChainSegmentParams) align 8 %21, <2 x float> %841)
  store i32 %842, ptr %106, align 4, !tbaa !24
  %843 = load i32, ptr %106, align 4, !tbaa !24
  %844 = icmp ne i32 %843, 1
  br i1 %844, label %845, label %846

845:                                              ; preds = %835
  store i32 22, ptr %36, align 4
  br label %870

846:                                              ; preds = %835
  call void @llvm.lifetime.start.p0(i64 8, ptr %108) #9
  %847 = load i32, ptr %104, align 4, !tbaa !24
  %848 = sext i32 %847 to i64
  %849 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %848
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %108, ptr align 8 %849, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %109) #9
  %850 = load <2 x float>, ptr %18, align 4
  %851 = load <2 x float>, ptr %108, align 4
  %852 = call <2 x float> @b2Sub(<2 x float> %850, <2 x float> %851)
  store <2 x float> %852, ptr %110, align 4
  %853 = load <2 x float>, ptr %105, align 4
  %854 = load <2 x float>, ptr %110, align 4
  %855 = call float @b2Dot(<2 x float> %853, <2 x float> %854)
  %856 = load <2 x float>, ptr %17, align 4
  %857 = load <2 x float>, ptr %108, align 4
  %858 = call <2 x float> @b2Sub(<2 x float> %856, <2 x float> %857)
  store <2 x float> %858, ptr %111, align 4
  %859 = load <2 x float>, ptr %105, align 4
  %860 = load <2 x float>, ptr %111, align 4
  %861 = call float @b2Dot(<2 x float> %859, <2 x float> %860)
  %862 = call float @b2MinFloat(float noundef %855, float noundef %861)
  store float %862, ptr %109, align 4, !tbaa !14
  %863 = load float, ptr %109, align 4, !tbaa !14
  %864 = load float, ptr %102, align 4, !tbaa !14
  %865 = fcmp ogt float %863, %864
  br i1 %865, label %866, label %869

866:                                              ; preds = %846
  %867 = load float, ptr %109, align 4, !tbaa !14
  store float %867, ptr %102, align 4, !tbaa !14
  %868 = load i32, ptr %104, align 4, !tbaa !24
  store i32 %868, ptr %103, align 4, !tbaa !24
  br label %869

869:                                              ; preds = %866, %846
  call void @llvm.lifetime.end.p0(i64 4, ptr %109) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %108) #9
  store i32 0, ptr %36, align 4
  br label %870

870:                                              ; preds = %869, %845
  call void @llvm.lifetime.end.p0(i64 4, ptr %106) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %105) #9
  %871 = load i32, ptr %36, align 4
  switch i32 %871, label %1258 [
    i32 0, label %872
    i32 22, label %873
  ]

872:                                              ; preds = %870
  br label %873

873:                                              ; preds = %872, %870
  %874 = load i32, ptr %104, align 4, !tbaa !24
  %875 = add nsw i32 %874, 1
  store i32 %875, ptr %104, align 4, !tbaa !24
  br label %830, !llvm.loop !49

876:                                              ; preds = %834
  %877 = load float, ptr %102, align 4, !tbaa !14
  %878 = load float, ptr %90, align 4, !tbaa !14
  %879 = fcmp ogt float %877, %878
  br i1 %879, label %880, label %1052

880:                                              ; preds = %876
  call void @llvm.lifetime.start.p0(i64 4, ptr %112) #9
  %881 = load i32, ptr %103, align 4, !tbaa !24
  store i32 %881, ptr %112, align 4, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 4, ptr %113) #9
  %882 = load i32, ptr %112, align 4, !tbaa !24
  %883 = load i32, ptr %37, align 4, !tbaa !24
  %884 = sub nsw i32 %883, 1
  %885 = icmp slt i32 %882, %884
  br i1 %885, label %886, label %889

886:                                              ; preds = %880
  %887 = load i32, ptr %112, align 4, !tbaa !24
  %888 = add nsw i32 %887, 1
  br label %890

889:                                              ; preds = %880
  br label %890

890:                                              ; preds = %889, %886
  %891 = phi i32 [ %888, %886 ], [ 0, %889 ]
  store i32 %891, ptr %113, align 4, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 8, ptr %114) #9
  %892 = load i32, ptr %112, align 4, !tbaa !24
  %893 = sext i32 %892 to i64
  %894 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %893
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %114, ptr align 8 %894, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 8, ptr %115) #9
  %895 = load i32, ptr %113, align 4, !tbaa !24
  %896 = sext i32 %895 to i64
  %897 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %896
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %115, ptr align 8 %897, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 8, ptr %116) #9
  %898 = load i32, ptr %112, align 4, !tbaa !24
  %899 = sext i32 %898 to i64
  %900 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %39, i64 0, i64 %899
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %116, ptr align 8 %900, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %117) #9
  %901 = load <2 x float>, ptr %17, align 4
  %902 = load <2 x float>, ptr %114, align 4
  %903 = call <2 x float> @b2Sub(<2 x float> %901, <2 x float> %902)
  store <2 x float> %903, ptr %118, align 4
  %904 = load <2 x float>, ptr %116, align 4
  %905 = load <2 x float>, ptr %118, align 4
  %906 = call float @b2Dot(<2 x float> %904, <2 x float> %905)
  store float %906, ptr %117, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %119) #9
  %907 = load <2 x float>, ptr %18, align 4
  %908 = load <2 x float>, ptr %114, align 4
  %909 = call <2 x float> @b2Sub(<2 x float> %907, <2 x float> %908)
  store <2 x float> %909, ptr %120, align 4
  %910 = load <2 x float>, ptr %116, align 4
  %911 = load <2 x float>, ptr %120, align 4
  %912 = call float @b2Dot(<2 x float> %910, <2 x float> %911)
  store float %912, ptr %119, align 4, !tbaa !14
  %913 = load float, ptr %117, align 4, !tbaa !14
  %914 = load float, ptr %119, align 4, !tbaa !14
  %915 = fcmp olt float %913, %914
  br i1 %915, label %916, label %926

916:                                              ; preds = %890
  %917 = load <2 x float>, ptr %47, align 4
  %918 = load <2 x float>, ptr %116, align 4
  %919 = call float @b2Dot(<2 x float> %917, <2 x float> %918)
  %920 = load <2 x float>, ptr %29, align 4
  %921 = load <2 x float>, ptr %116, align 4
  %922 = call float @b2Dot(<2 x float> %920, <2 x float> %921)
  %923 = fcmp olt float %919, %922
  br i1 %923, label %924, label %925

924:                                              ; preds = %916
  store i32 1, ptr %36, align 4
  br label %1051

925:                                              ; preds = %916
  br label %936

926:                                              ; preds = %890
  %927 = load <2 x float>, ptr %48, align 4
  %928 = load <2 x float>, ptr %116, align 4
  %929 = call float @b2Dot(<2 x float> %927, <2 x float> %928)
  %930 = load <2 x float>, ptr %29, align 4
  %931 = load <2 x float>, ptr %116, align 4
  %932 = call float @b2Dot(<2 x float> %930, <2 x float> %931)
  %933 = fcmp olt float %929, %932
  br i1 %933, label %934, label %935

934:                                              ; preds = %926
  store i32 1, ptr %36, align 4
  br label %1051

935:                                              ; preds = %926
  br label %936

936:                                              ; preds = %935, %925
  call void @llvm.lifetime.start.p0(i64 112, ptr %121) #9
  %937 = load i32, ptr %112, align 4, !tbaa !24
  %938 = sext i32 %937 to i64
  %939 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %39, i64 0, i64 %938
  %940 = load float, ptr %16, align 4, !tbaa !14
  %941 = load i32, ptr %112, align 4, !tbaa !24
  %942 = trunc i32 %941 to i8
  %943 = zext i8 %942 to i32
  %944 = shl i32 %943, 8
  %945 = or i32 %944, 1
  %946 = trunc i32 %945 to i16
  %947 = load i32, ptr %113, align 4, !tbaa !24
  %948 = trunc i32 %947 to i8
  %949 = zext i8 %948 to i32
  %950 = shl i32 %949, 8
  %951 = or i32 %950, 0
  %952 = trunc i32 %951 to i16
  %953 = load <2 x float>, ptr %114, align 4
  %954 = load <2 x float>, ptr %115, align 4
  %955 = load <2 x float>, ptr %17, align 4
  %956 = load <2 x float>, ptr %18, align 4
  %957 = load <2 x float>, ptr %939, align 8
  call void @b2ClipSegments(ptr dead_on_unwind writable sret(%struct.b2Manifold) align 4 %121, <2 x float> %953, <2 x float> %954, <2 x float> %955, <2 x float> %956, <2 x float> %957, float noundef %940, float noundef 0.000000e+00, i16 noundef zeroext %946, i16 noundef zeroext %952)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 %121, i64 112, i1 false), !tbaa.struct !45
  call void @llvm.lifetime.end.p0(i64 112, ptr %121) #9
  br label %958

958:                                              ; preds = %936
  %959 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 3
  %960 = load i32, ptr %959, align 4, !tbaa !43
  %961 = icmp eq i32 %960, 0
  br i1 %961, label %970, label %962

962:                                              ; preds = %958
  %963 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 3
  %964 = load i32, ptr %963, align 4, !tbaa !43
  %965 = icmp eq i32 %964, 2
  br i1 %965, label %970, label %966

966:                                              ; preds = %962
  %967 = call i32 @b2InternalAssertFcn(ptr noundef @.str.5, ptr noundef @.str.1, i32 noundef 1648)
  %968 = icmp ne i32 %967, 0
  br i1 %968, label %969, label %970

969:                                              ; preds = %966
  call void @llvm.trap()
  br label %970

970:                                              ; preds = %969, %966, %962, %958
  br label %971

971:                                              ; preds = %970
  br label %972

972:                                              ; preds = %971
  %973 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 3
  %974 = load i32, ptr %973, align 4, !tbaa !43
  %975 = icmp eq i32 %974, 2
  br i1 %975, label %976, label %1050

976:                                              ; preds = %972
  %977 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %122) #9
  %978 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 1
  %979 = load i32, ptr %112, align 4, !tbaa !24
  %980 = sext i32 %979 to i64
  %981 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %39, i64 0, i64 %980
  %982 = load <2 x float>, ptr %981, align 8
  %983 = call <2 x float> @b2Neg(<2 x float> %982)
  store <2 x float> %983, ptr %123, align 4
  %984 = load <2 x float>, ptr %978, align 4
  %985 = load <2 x float>, ptr %123, align 4
  %986 = call <2 x float> @b2RotateVector(<2 x float> %984, <2 x float> %985)
  store <2 x float> %986, ptr %122, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %977, ptr align 4 %122, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %122) #9
  %987 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %988 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %987, i64 0, i64 0
  %989 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %988, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %124) #9
  %990 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 1
  %991 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %992 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %991, i64 0, i64 0
  %993 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %992, i32 0, i32 1
  %994 = load <2 x float>, ptr %990, align 4
  %995 = load <2 x float>, ptr %993, align 4
  %996 = call <2 x float> @b2RotateVector(<2 x float> %994, <2 x float> %995)
  store <2 x float> %996, ptr %124, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %989, ptr align 4 %124, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %124) #9
  %997 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %998 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %997, i64 0, i64 1
  %999 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %998, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %125) #9
  %1000 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 1
  %1001 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1002 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1001, i64 0, i64 1
  %1003 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1002, i32 0, i32 1
  %1004 = load <2 x float>, ptr %1000, align 4
  %1005 = load <2 x float>, ptr %1003, align 4
  %1006 = call <2 x float> @b2RotateVector(<2 x float> %1004, <2 x float> %1005)
  store <2 x float> %1006, ptr %125, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %999, ptr align 4 %125, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %125) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %126) #9
  %1007 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 0
  %1008 = getelementptr inbounds %struct.b2Transform, ptr %10, i32 0, i32 0
  %1009 = load <2 x float>, ptr %1007, align 4
  %1010 = load <2 x float>, ptr %1008, align 4
  %1011 = call <2 x float> @b2Sub(<2 x float> %1009, <2 x float> %1010)
  store <2 x float> %1011, ptr %126, align 4
  %1012 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1013 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1012, i64 0, i64 0
  %1014 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1013, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %127) #9
  %1015 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1016 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1015, i64 0, i64 0
  %1017 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1016, i32 0, i32 1
  %1018 = load <2 x float>, ptr %1017, align 4
  %1019 = load <2 x float>, ptr %126, align 4
  %1020 = call <2 x float> @b2Add(<2 x float> %1018, <2 x float> %1019)
  store <2 x float> %1020, ptr %127, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1014, ptr align 4 %127, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %127) #9
  %1021 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1022 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1021, i64 0, i64 1
  %1023 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1022, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %128) #9
  %1024 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1025 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1024, i64 0, i64 1
  %1026 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1025, i32 0, i32 1
  %1027 = load <2 x float>, ptr %1026, align 4
  %1028 = load <2 x float>, ptr %126, align 4
  %1029 = call <2 x float> @b2Add(<2 x float> %1027, <2 x float> %1028)
  store <2 x float> %1029, ptr %128, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1023, ptr align 4 %128, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %128) #9
  %1030 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1031 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1030, i64 0, i64 0
  %1032 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1031, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %129) #9
  %1033 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 0
  %1034 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1035 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1034, i64 0, i64 0
  %1036 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1035, i32 0, i32 1
  %1037 = load <2 x float>, ptr %1033, align 4
  %1038 = load <2 x float>, ptr %1036, align 4
  %1039 = call <2 x float> @b2Add(<2 x float> %1037, <2 x float> %1038)
  store <2 x float> %1039, ptr %129, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1032, ptr align 4 %129, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %129) #9
  %1040 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1041 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1040, i64 0, i64 1
  %1042 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1041, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %130) #9
  %1043 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 0
  %1044 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1045 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1044, i64 0, i64 1
  %1046 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1045, i32 0, i32 1
  %1047 = load <2 x float>, ptr %1043, align 4
  %1048 = load <2 x float>, ptr %1046, align 4
  %1049 = call <2 x float> @b2Add(<2 x float> %1047, <2 x float> %1048)
  store <2 x float> %1049, ptr %130, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1042, ptr align 4 %130, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %130) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %126) #9
  br label %1050

1050:                                             ; preds = %976, %972
  store i32 1, ptr %36, align 4
  br label %1051

1051:                                             ; preds = %1050, %934, %924
  call void @llvm.lifetime.end.p0(i64 4, ptr %119) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %117) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %116) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %115) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %114) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %113) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %112) #9
  br label %1057

1052:                                             ; preds = %876
  %1053 = load i32, ptr %49, align 4, !tbaa !24
  %1054 = icmp eq i32 %1053, -1
  br i1 %1054, label %1055, label %1056

1055:                                             ; preds = %1052
  store i32 1, ptr %36, align 4
  br label %1057

1056:                                             ; preds = %1052
  store i32 0, ptr %36, align 4
  br label %1057

1057:                                             ; preds = %1056, %1055, %1051
  call void @llvm.lifetime.end.p0(i64 4, ptr %103) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %102) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %90) #9
  %1058 = load i32, ptr %36, align 4
  switch i32 %1058, label %1255 [
    i32 0, label %1059
  ]

1059:                                             ; preds = %1057
  br label %1060

1060:                                             ; preds = %1059, %728
  br label %1061

1061:                                             ; preds = %1060
  %1062 = load i32, ptr %50, align 4, !tbaa !24
  %1063 = icmp ne i32 %1062, -1
  br i1 %1063, label %1071, label %1064

1064:                                             ; preds = %1061
  %1065 = load i32, ptr %49, align 4, !tbaa !24
  %1066 = icmp ne i32 %1065, -1
  br i1 %1066, label %1071, label %1067

1067:                                             ; preds = %1064
  %1068 = call i32 @b2InternalAssertFcn(ptr noundef @.str.6, ptr noundef @.str.1, i32 noundef 1674)
  %1069 = icmp ne i32 %1068, 0
  br i1 %1069, label %1070, label %1071

1070:                                             ; preds = %1067
  call void @llvm.trap()
  br label %1071

1071:                                             ; preds = %1070, %1067, %1064, %1061
  br label %1072

1072:                                             ; preds = %1071
  br label %1073

1073:                                             ; preds = %1072
  call void @llvm.lifetime.start.p0(i64 8, ptr %131) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %132) #9
  call void @llvm.lifetime.start.p0(i64 4, ptr %133) #9
  call void @llvm.lifetime.start.p0(i64 4, ptr %134) #9
  %1074 = load i32, ptr %50, align 4, !tbaa !24
  %1075 = icmp ne i32 %1074, -1
  br i1 %1075, label %1076, label %1094

1076:                                             ; preds = %1073
  %1077 = load i32, ptr %50, align 4, !tbaa !24
  store i32 %1077, ptr %133, align 4, !tbaa !24
  %1078 = load i32, ptr %133, align 4, !tbaa !24
  %1079 = load i32, ptr %37, align 4, !tbaa !24
  %1080 = sub nsw i32 %1079, 1
  %1081 = icmp slt i32 %1078, %1080
  br i1 %1081, label %1082, label %1085

1082:                                             ; preds = %1076
  %1083 = load i32, ptr %133, align 4, !tbaa !24
  %1084 = add nsw i32 %1083, 1
  br label %1086

1085:                                             ; preds = %1076
  br label %1086

1086:                                             ; preds = %1085, %1082
  %1087 = phi i32 [ %1084, %1082 ], [ 0, %1085 ]
  store i32 %1087, ptr %134, align 4, !tbaa !24
  %1088 = load i32, ptr %133, align 4, !tbaa !24
  %1089 = sext i32 %1088 to i64
  %1090 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %1089
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %131, ptr align 8 %1090, i64 8, i1 false), !tbaa.struct !15
  %1091 = load i32, ptr %134, align 4, !tbaa !24
  %1092 = sext i32 %1091 to i64
  %1093 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %1092
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %132, ptr align 8 %1093, i64 8, i1 false), !tbaa.struct !15
  br label %1149

1094:                                             ; preds = %1073
  call void @llvm.lifetime.start.p0(i64 4, ptr %135) #9
  %1095 = load i32, ptr %49, align 4, !tbaa !24
  store i32 %1095, ptr %135, align 4, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 4, ptr %136) #9
  %1096 = load i32, ptr %135, align 4, !tbaa !24
  %1097 = icmp sgt i32 %1096, 0
  br i1 %1097, label %1098, label %1101

1098:                                             ; preds = %1094
  %1099 = load i32, ptr %135, align 4, !tbaa !24
  %1100 = sub nsw i32 %1099, 1
  br label %1104

1101:                                             ; preds = %1094
  %1102 = load i32, ptr %37, align 4, !tbaa !24
  %1103 = sub nsw i32 %1102, 1
  br label %1104

1104:                                             ; preds = %1101, %1098
  %1105 = phi i32 [ %1100, %1098 ], [ %1103, %1101 ]
  store i32 %1105, ptr %136, align 4, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 4, ptr %137) #9
  %1106 = load i32, ptr %136, align 4, !tbaa !24
  %1107 = sext i32 %1106 to i64
  %1108 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %39, i64 0, i64 %1107
  %1109 = load <2 x float>, ptr %29, align 4
  %1110 = load <2 x float>, ptr %1108, align 8
  %1111 = call float @b2Dot(<2 x float> %1109, <2 x float> %1110)
  store float %1111, ptr %137, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %138) #9
  %1112 = load i32, ptr %135, align 4, !tbaa !24
  %1113 = sext i32 %1112 to i64
  %1114 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %39, i64 0, i64 %1113
  %1115 = load <2 x float>, ptr %29, align 4
  %1116 = load <2 x float>, ptr %1114, align 8
  %1117 = call float @b2Dot(<2 x float> %1115, <2 x float> %1116)
  store float %1117, ptr %138, align 4, !tbaa !14
  %1118 = load float, ptr %137, align 4, !tbaa !14
  %1119 = load float, ptr %138, align 4, !tbaa !14
  %1120 = fcmp olt float %1118, %1119
  br i1 %1120, label %1121, label %1130

1121:                                             ; preds = %1104
  %1122 = load i32, ptr %136, align 4, !tbaa !24
  store i32 %1122, ptr %133, align 4, !tbaa !24
  %1123 = load i32, ptr %135, align 4, !tbaa !24
  store i32 %1123, ptr %134, align 4, !tbaa !24
  %1124 = load i32, ptr %133, align 4, !tbaa !24
  %1125 = sext i32 %1124 to i64
  %1126 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %1125
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %131, ptr align 8 %1126, i64 8, i1 false), !tbaa.struct !15
  %1127 = load i32, ptr %134, align 4, !tbaa !24
  %1128 = sext i32 %1127 to i64
  %1129 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %1128
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %132, ptr align 8 %1129, i64 8, i1 false), !tbaa.struct !15
  br label %1148

1130:                                             ; preds = %1104
  %1131 = load i32, ptr %135, align 4, !tbaa !24
  store i32 %1131, ptr %133, align 4, !tbaa !24
  %1132 = load i32, ptr %135, align 4, !tbaa !24
  %1133 = load i32, ptr %37, align 4, !tbaa !24
  %1134 = sub nsw i32 %1133, 1
  %1135 = icmp slt i32 %1132, %1134
  br i1 %1135, label %1136, label %1139

1136:                                             ; preds = %1130
  %1137 = load i32, ptr %135, align 4, !tbaa !24
  %1138 = add nsw i32 %1137, 1
  br label %1140

1139:                                             ; preds = %1130
  br label %1140

1140:                                             ; preds = %1139, %1136
  %1141 = phi i32 [ %1138, %1136 ], [ 0, %1139 ]
  store i32 %1141, ptr %134, align 4, !tbaa !24
  %1142 = load i32, ptr %133, align 4, !tbaa !24
  %1143 = sext i32 %1142 to i64
  %1144 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %1143
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %131, ptr align 8 %1144, i64 8, i1 false), !tbaa.struct !15
  %1145 = load i32, ptr %134, align 4, !tbaa !24
  %1146 = sext i32 %1145 to i64
  %1147 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %38, i64 0, i64 %1146
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %132, ptr align 8 %1147, i64 8, i1 false), !tbaa.struct !15
  br label %1148

1148:                                             ; preds = %1140, %1121
  call void @llvm.lifetime.end.p0(i64 4, ptr %138) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %137) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %136) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %135) #9
  br label %1149

1149:                                             ; preds = %1148, %1086
  call void @llvm.lifetime.start.p0(i64 112, ptr %139) #9
  %1150 = load float, ptr %16, align 4, !tbaa !14
  %1151 = load i32, ptr %134, align 4, !tbaa !24
  %1152 = trunc i32 %1151 to i8
  %1153 = zext i8 %1152 to i32
  %1154 = or i32 0, %1153
  %1155 = trunc i32 %1154 to i16
  %1156 = load i32, ptr %133, align 4, !tbaa !24
  %1157 = trunc i32 %1156 to i8
  %1158 = zext i8 %1157 to i32
  %1159 = or i32 256, %1158
  %1160 = trunc i32 %1159 to i16
  %1161 = load <2 x float>, ptr %17, align 4
  %1162 = load <2 x float>, ptr %18, align 4
  %1163 = load <2 x float>, ptr %131, align 4
  %1164 = load <2 x float>, ptr %132, align 4
  %1165 = load <2 x float>, ptr %29, align 4
  call void @b2ClipSegments(ptr dead_on_unwind writable sret(%struct.b2Manifold) align 4 %139, <2 x float> %1161, <2 x float> %1162, <2 x float> %1163, <2 x float> %1164, <2 x float> %1165, float noundef 0.000000e+00, float noundef %1150, i16 noundef zeroext %1155, i16 noundef zeroext %1160)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 %139, i64 112, i1 false), !tbaa.struct !45
  call void @llvm.lifetime.end.p0(i64 112, ptr %139) #9
  br label %1166

1166:                                             ; preds = %1149
  %1167 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 3
  %1168 = load i32, ptr %1167, align 4, !tbaa !43
  %1169 = icmp eq i32 %1168, 0
  br i1 %1169, label %1178, label %1170

1170:                                             ; preds = %1166
  %1171 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 3
  %1172 = load i32, ptr %1171, align 4, !tbaa !43
  %1173 = icmp eq i32 %1172, 2
  br i1 %1173, label %1178, label %1174

1174:                                             ; preds = %1170
  %1175 = call i32 @b2InternalAssertFcn(ptr noundef @.str.5, ptr noundef @.str.1, i32 noundef 1711)
  %1176 = icmp ne i32 %1175, 0
  br i1 %1176, label %1177, label %1178

1177:                                             ; preds = %1174
  call void @llvm.trap()
  br label %1178

1178:                                             ; preds = %1177, %1174, %1170, %1166
  br label %1179

1179:                                             ; preds = %1178
  br label %1180

1180:                                             ; preds = %1179
  %1181 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 3
  %1182 = load i32, ptr %1181, align 4, !tbaa !43
  %1183 = icmp eq i32 %1182, 2
  br i1 %1183, label %1184, label %1254

1184:                                             ; preds = %1180
  %1185 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %140) #9
  %1186 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 1
  %1187 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 0
  %1188 = load <2 x float>, ptr %1186, align 4
  %1189 = load <2 x float>, ptr %1187, align 4
  %1190 = call <2 x float> @b2RotateVector(<2 x float> %1188, <2 x float> %1189)
  store <2 x float> %1190, ptr %140, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1185, ptr align 4 %140, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %140) #9
  %1191 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1192 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1191, i64 0, i64 0
  %1193 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1192, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %141) #9
  %1194 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 1
  %1195 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1196 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1195, i64 0, i64 0
  %1197 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1196, i32 0, i32 1
  %1198 = load <2 x float>, ptr %1194, align 4
  %1199 = load <2 x float>, ptr %1197, align 4
  %1200 = call <2 x float> @b2RotateVector(<2 x float> %1198, <2 x float> %1199)
  store <2 x float> %1200, ptr %141, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1193, ptr align 4 %141, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %141) #9
  %1201 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1202 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1201, i64 0, i64 1
  %1203 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1202, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %142) #9
  %1204 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 1
  %1205 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1206 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1205, i64 0, i64 1
  %1207 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1206, i32 0, i32 1
  %1208 = load <2 x float>, ptr %1204, align 4
  %1209 = load <2 x float>, ptr %1207, align 4
  %1210 = call <2 x float> @b2RotateVector(<2 x float> %1208, <2 x float> %1209)
  store <2 x float> %1210, ptr %142, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1203, ptr align 4 %142, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %142) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %143) #9
  %1211 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 0
  %1212 = getelementptr inbounds %struct.b2Transform, ptr %10, i32 0, i32 0
  %1213 = load <2 x float>, ptr %1211, align 4
  %1214 = load <2 x float>, ptr %1212, align 4
  %1215 = call <2 x float> @b2Sub(<2 x float> %1213, <2 x float> %1214)
  store <2 x float> %1215, ptr %143, align 4
  %1216 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1217 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1216, i64 0, i64 0
  %1218 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1217, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %144) #9
  %1219 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1220 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1219, i64 0, i64 0
  %1221 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1220, i32 0, i32 1
  %1222 = load <2 x float>, ptr %1221, align 4
  %1223 = load <2 x float>, ptr %143, align 4
  %1224 = call <2 x float> @b2Add(<2 x float> %1222, <2 x float> %1223)
  store <2 x float> %1224, ptr %144, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1218, ptr align 4 %144, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %144) #9
  %1225 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1226 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1225, i64 0, i64 1
  %1227 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1226, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %145) #9
  %1228 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1229 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1228, i64 0, i64 1
  %1230 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1229, i32 0, i32 1
  %1231 = load <2 x float>, ptr %1230, align 4
  %1232 = load <2 x float>, ptr %143, align 4
  %1233 = call <2 x float> @b2Add(<2 x float> %1231, <2 x float> %1232)
  store <2 x float> %1233, ptr %145, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1227, ptr align 4 %145, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %145) #9
  %1234 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1235 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1234, i64 0, i64 0
  %1236 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1235, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %146) #9
  %1237 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 0
  %1238 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1239 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1238, i64 0, i64 0
  %1240 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1239, i32 0, i32 1
  %1241 = load <2 x float>, ptr %1237, align 4
  %1242 = load <2 x float>, ptr %1240, align 4
  %1243 = call <2 x float> @b2Add(<2 x float> %1241, <2 x float> %1242)
  store <2 x float> %1243, ptr %146, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1236, ptr align 4 %146, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %146) #9
  %1244 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1245 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1244, i64 0, i64 1
  %1246 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1245, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %147) #9
  %1247 = getelementptr inbounds %struct.b2Transform, ptr %9, i32 0, i32 0
  %1248 = getelementptr inbounds %struct.b2Manifold, ptr %0, i32 0, i32 2
  %1249 = getelementptr inbounds [2 x %struct.b2ManifoldPoint], ptr %1248, i64 0, i64 1
  %1250 = getelementptr inbounds %struct.b2ManifoldPoint, ptr %1249, i32 0, i32 1
  %1251 = load <2 x float>, ptr %1247, align 4
  %1252 = load <2 x float>, ptr %1250, align 4
  %1253 = call <2 x float> @b2Add(<2 x float> %1251, <2 x float> %1252)
  store <2 x float> %1253, ptr %147, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1246, ptr align 4 %147, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %147) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %143) #9
  br label %1254

1254:                                             ; preds = %1184, %1180
  store i32 1, ptr %36, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %134) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %133) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %132) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %131) #9
  br label %1255

1255:                                             ; preds = %1254, %1057, %725, %437
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %48) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #9
  br label %1256

1256:                                             ; preds = %1255, %325
  call void @llvm.lifetime.end.p0(i64 36, ptr %46) #9
  call void @llvm.lifetime.end.p0(i64 180, ptr %43) #9
  call void @llvm.lifetime.end.p0(i64 64, ptr %39) #9
  call void @llvm.lifetime.end.p0(i64 64, ptr %38) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #9
  br label %1257

1257:                                             ; preds = %1256, %266
  call void @llvm.lifetime.end.p0(i64 1, ptr %33) #9
  call void @llvm.lifetime.end.p0(i64 1, ptr %32) #9
  call void @llvm.lifetime.end.p0(i64 1, ptr %30) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #9
  call void @llvm.lifetime.end.p0(i64 28, ptr %21) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #9
  call void @llvm.lifetime.end.p0(i64 16, ptr %14) #9
  ret void

1258:                                             ; preds = %870
  unreachable
}

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

declare void @b2MakeProxy(ptr dead_on_unwind writable sret(%struct.b2ShapeProxy) align 4, ptr noundef, i32 noundef, float noundef) #4

declare void @b2ShapeDistance(ptr dead_on_unwind writable sret(%struct.b2DistanceOutput) align 4, ptr noundef, ptr noundef, ptr noundef, i32 noundef) #4

; Function Attrs: nounwind uwtable
declare hidden i32 @b2ClassifyNormal(ptr noundef byval(%struct.b2ChainSegmentParams) align 8, <2 x float>) #8

; Function Attrs: nounwind uwtable
declare hidden void @b2ClipSegments(ptr dead_on_unwind noalias writable sret(%struct.b2Manifold) align 4, <2 x float>, <2 x float>, <2 x float>, <2 x float>, <2 x float>, float noundef, float noundef, i16 noundef zeroext, i16 noundef zeroext) #8

attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { inlinehint nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #4 = { "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 = { cold noreturn nounwind memory(inaccessiblemem: write) }
attributes #6 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #7 = { inlinehint 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 #8 = { 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 #9 = { 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, !12, i64 136}
!10 = !{!"b2Polygon", !7, i64 0, !7, i64 64, !11, i64 128, !12, i64 136, !13, i64 140}
!11 = !{!"b2Vec2", !12, i64 0, !12, i64 4}
!12 = !{!"float", !7, i64 0}
!13 = !{!"int", !7, i64 0}
!14 = !{!12, !12, i64 0}
!15 = !{i64 0, i64 4, !14, i64 4, i64 4, !14}
!16 = !{!17, !18, i64 24}
!17 = !{!"b2ChainSegmentParams", !11, i64 0, !11, i64 8, !11, i64 16, !18, i64 24, !18, i64 25}
!18 = !{!"_Bool", !7, i64 0}
!19 = !{!17, !18, i64 25}
!20 = !{!18, !18, i64 0}
!21 = !{i8 0, i8 2}
!22 = !{}
!23 = !{!10, !13, i64 140}
!24 = !{!13, !13, i64 0}
!25 = distinct !{!25, !26}
!26 = !{!"llvm.loop.mustprogress"}
!27 = !{i64 0, i64 64, !28, i64 64, i64 4, !24, i64 68, i64 4, !14}
!28 = !{!7, !7, i64 0}
!29 = !{i64 0, i64 4, !14, i64 4, i64 4, !14, i64 8, i64 4, !14, i64 12, i64 4, !14}
!30 = !{!31, !18, i64 176}
!31 = !{!"b2DistanceInput", !32, i64 0, !32, i64 72, !33, i64 144, !33, i64 160, !18, i64 176}
!32 = !{!"b2ShapeProxy", !7, i64 0, !13, i64 64, !12, i64 68}
!33 = !{!"b2Transform", !11, i64 0, !34, i64 8}
!34 = !{!"b2Rot", !12, i64 0, !12, i64 4}
!35 = !{!36, !12, i64 24}
!36 = !{!"b2DistanceOutput", !11, i64 0, !11, i64 8, !11, i64 16, !12, i64 24, !13, i64 28, !13, i64 32}
!37 = !{!38, !39, i64 0}
!38 = !{!"b2SimplexCache", !39, i64 0, !7, i64 2, !7, i64 5}
!39 = !{!"short", !7, i64 0}
!40 = !{!41, !12, i64 24}
!41 = !{!"b2ManifoldPoint", !11, i64 0, !11, i64 8, !11, i64 16, !12, i64 24, !12, i64 28, !12, i64 32, !12, i64 36, !12, i64 40, !39, i64 44, !18, i64 46}
!42 = !{!41, !39, i64 44}
!43 = !{!44, !13, i64 108}
!44 = !{!"b2Manifold", !11, i64 0, !12, i64 8, !7, i64 12, !13, i64 108}
!45 = !{i64 0, i64 4, !14, i64 4, i64 4, !14, i64 8, i64 4, !14, i64 12, i64 96, !28, i64 108, i64 4, !24}
!46 = distinct !{!46, !26}
!47 = distinct !{!47, !26}
!48 = distinct !{!48, !26}
!49 = distinct !{!49, !26}


; 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.b2Transform = type { %struct.b2Vec2, %struct.b2Rot }
%struct.b2Vec2 = type { float, float }
%struct.b2Rot = type { float, float }
%struct.b2Manifold = type { %struct.b2Vec2, float, [2 x %struct.b2ManifoldPoint], i32 }
%struct.b2ManifoldPoint = type { %struct.b2Vec2, %struct.b2Vec2, %struct.b2Vec2, float, float, float, float, float, i16, i8 }
%struct.b2ChainSegmentParams = type { %struct.b2Vec2, %struct.b2Vec2, %struct.b2Vec2, i8, i8 }
%struct.b2DistanceInput = type { %struct.b2ShapeProxy, %struct.b2ShapeProxy, %struct.b2Transform, %struct.b2Transform, i8 }
%struct.b2ShapeProxy = type { [8 x %struct.b2Vec2], i32, float }
%struct.b2DistanceOutput = type { %struct.b2Vec2, %struct.b2Vec2, %struct.b2Vec2, float, i32, i32 }

@b2_lengthUnitsPerMeter = external local_unnamed_addr global float, align 4
@.str.1 = external hidden unnamed_addr constant [64 x i8], align 1
@b2Transform_identity = external hidden local_unnamed_addr constant %struct.b2Transform, align 4
@.str.3 = external hidden unnamed_addr constant [18 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [53 x i8], align 1

; Function Attrs: mustprogress nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #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: inlinehint nounwind uwtable
declare hidden { <2 x float>, <2 x float> } @b2InvMulTransforms(<2 x float>, <2 x float>, <2 x float>, <2 x float>) 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: inlinehint nounwind uwtable
declare hidden <2 x float> @b2TransformPoint(<2 x float>, <2 x float>, <2 x float>) local_unnamed_addr #2

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

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

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

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

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

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

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

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

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden float @b2MinFloat(float noundef, float noundef) local_unnamed_addr #7

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

; Function Attrs: nounwind uwtable
define dso_local void @b2CollideChainSegmentAndPolygon(ptr dead_on_unwind noalias nocapture writable sret(%struct.b2Manifold) align 4 %0, ptr noundef %1, <2 x float> %2, <2 x float> %3, ptr nocapture noundef readonly %4, <2 x float> %5, <2 x float> %6, ptr noundef %7) local_unnamed_addr #8 {
  %9 = alloca %struct.b2ChainSegmentParams, align 8
  %10 = alloca [8 x %struct.b2Vec2], align 16
  %11 = alloca [8 x %struct.b2Vec2], align 16
  %12 = alloca %struct.b2DistanceInput, align 4
  %13 = alloca %struct.b2ShapeProxy, align 4
  %14 = alloca %struct.b2ShapeProxy, align 4
  %15 = alloca %struct.b2DistanceOutput, align 8
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 4 dereferenceable(112) %0, i8 0, i64 112, i1 false)
  %16 = tail call { <2 x float>, <2 x float> } @b2InvMulTransforms(<2 x float> %2, <2 x float> %3, <2 x float> %5, <2 x float> %6)
  %17 = extractvalue { <2 x float>, <2 x float> } %16, 0
  %18 = extractvalue { <2 x float>, <2 x float> } %16, 1
  %19 = getelementptr inbounds i8, ptr %4, i64 128
  %20 = load <2 x float>, ptr %19, align 4
  %21 = tail call <2 x float> @b2TransformPoint(<2 x float> %17, <2 x float> %18, <2 x float> %20)
  %22 = getelementptr inbounds i8, ptr %4, i64 136
  %23 = load float, ptr %22, align 4, !tbaa !5
  %24 = getelementptr inbounds i8, ptr %1, i64 8
  %.sroa.0285.0.copyload = load <2 x float>, ptr %24, align 4
  %25 = getelementptr inbounds i8, ptr %1, i64 16
  %.sroa.0274.0.copyload = load <2 x float>, ptr %25, align 4
  %26 = tail call <2 x float> @b2Sub(<2 x float> %.sroa.0274.0.copyload, <2 x float> %.sroa.0285.0.copyload)
  %27 = tail call <2 x float> @b2Normalize(<2 x float> %26)
  call void @llvm.lifetime.start.p0(i64 28, ptr nonnull %9) #9
  %28 = getelementptr inbounds i8, ptr %9, i64 24
  store i32 0, ptr %28, align 8
  store <2 x float> %27, ptr %9, align 8
  %29 = load <2 x float>, ptr %1, align 4
  %30 = tail call <2 x float> @b2Sub(<2 x float> %.sroa.0285.0.copyload, <2 x float> %29)
  %31 = tail call <2 x float> @b2Normalize(<2 x float> %30)
  %32 = getelementptr inbounds i8, ptr %9, i64 8
  %33 = tail call <2 x float> @b2RightPerp(<2 x float> %31)
  store <2 x float> %33, ptr %32, align 8
  %34 = tail call float @b2Cross(<2 x float> %31, <2 x float> %27)
  %35 = fcmp oge float %34, 0x3F847AE140000000
  %36 = getelementptr inbounds i8, ptr %9, i64 24
  %37 = zext i1 %35 to i8
  store i8 %37, ptr %36, align 8, !tbaa !12
  %38 = getelementptr inbounds i8, ptr %1, i64 24
  %39 = load <2 x float>, ptr %38, align 4
  %40 = tail call <2 x float> @b2Sub(<2 x float> %39, <2 x float> %.sroa.0274.0.copyload)
  %41 = tail call <2 x float> @b2Normalize(<2 x float> %40)
  %42 = getelementptr inbounds i8, ptr %9, i64 16
  %43 = tail call <2 x float> @b2RightPerp(<2 x float> %41)
  store <2 x float> %43, ptr %42, align 8
  %44 = tail call float @b2Cross(<2 x float> %27, <2 x float> %41)
  %45 = fcmp oge float %44, 0x3F847AE140000000
  %46 = getelementptr inbounds i8, ptr %9, i64 25
  %47 = zext i1 %45 to i8
  store i8 %47, ptr %46, align 1, !tbaa !15
  %48 = tail call <2 x float> @b2RightPerp(<2 x float> %27)
  %49 = tail call <2 x float> @b2Sub(<2 x float> %21, <2 x float> %.sroa.0285.0.copyload)
  %50 = tail call float @b2Dot(<2 x float> %48, <2 x float> %49)
  %51 = fcmp uge float %50, 0.000000e+00
  br i1 %35, label %52, label %56

52:                                               ; preds = %8
  %53 = tail call <2 x float> @b2Sub(<2 x float> %21, <2 x float> %.sroa.0285.0.copyload)
  %54 = tail call float @b2Dot(<2 x float> %33, <2 x float> %53)
  %55 = fcmp olt float %54, 0.000000e+00
  br label %56

56:                                               ; preds = %52, %8
  %.0 = phi i1 [ %55, %52 ], [ true, %8 ]
  br i1 %45, label %57, label %61

57:                                               ; preds = %56
  %58 = tail call <2 x float> @b2Sub(<2 x float> %21, <2 x float> %.sroa.0274.0.copyload)
  %59 = tail call float @b2Dot(<2 x float> %43, <2 x float> %58)
  %60 = fcmp olt float %59, 0.000000e+00
  br label %61

61:                                               ; preds = %57, %56
  %.0358 = phi i1 [ %60, %57 ], [ true, %56 ]
  %.0.not = xor i1 %.0, true
  %brmerge = select i1 %51, i1 true, i1 %.0.not
  %.0358.not = xor i1 %.0358, true
  %brmerge415 = select i1 %brmerge, i1 true, i1 %.0358.not
  br i1 %brmerge415, label %62, label %379

62:                                               ; preds = %61
  %63 = getelementptr inbounds i8, ptr %4, i64 140
  %64 = load i32, ptr %63, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %10) #9
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %11) #9
  %65 = icmp sgt i32 %64, 0
  br i1 %65, label %.lr.ph, label %._crit_edge

.lr.ph:                                           ; preds = %62
  %66 = getelementptr inbounds i8, ptr %4, i64 64
  %wide.trip.count = zext nneg i32 %64 to i64
  br label %77

._crit_edge:                                      ; preds = %77, %62
  call void @llvm.lifetime.start.p0(i64 180, ptr nonnull %12) #9
  call void @llvm.lifetime.start.p0(i64 72, ptr nonnull %13) #9
  call void @b2MakeProxy(ptr dead_on_unwind nonnull writable sret(%struct.b2ShapeProxy) align 4 %13, ptr noundef nonnull %24, i32 noundef 2, float noundef 0.000000e+00) #9
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 4 dereferenceable(72) %12, ptr noundef nonnull align 4 dereferenceable(72) %13, i64 72, i1 false), !tbaa.struct !17
  call void @llvm.lifetime.end.p0(i64 72, ptr nonnull %13) #9
  %67 = getelementptr inbounds i8, ptr %12, i64 72
  call void @llvm.lifetime.start.p0(i64 72, ptr nonnull %14) #9
  call void @b2MakeProxy(ptr dead_on_unwind nonnull writable sret(%struct.b2ShapeProxy) align 4 %14, ptr noundef nonnull %10, i32 noundef %64, float noundef 0.000000e+00) #9
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 4 dereferenceable(72) %67, ptr noundef nonnull align 4 dereferenceable(72) %14, i64 72, i1 false), !tbaa.struct !17
  call void @llvm.lifetime.end.p0(i64 72, ptr nonnull %14) #9
  %68 = getelementptr inbounds i8, ptr %12, i64 144
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 4 dereferenceable(16) %68, ptr noundef nonnull align 4 dereferenceable(16) @b2Transform_identity, i64 16, i1 false), !tbaa.struct !21
  %69 = getelementptr inbounds i8, ptr %12, i64 160
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 4 dereferenceable(16) %69, ptr noundef nonnull align 4 dereferenceable(16) @b2Transform_identity, i64 16, i1 false), !tbaa.struct !21
  %70 = getelementptr inbounds i8, ptr %12, i64 176
  store i8 0, ptr %70, align 4, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 36, ptr nonnull %15) #9
  call void @b2ShapeDistance(ptr dead_on_unwind nonnull writable sret(%struct.b2DistanceOutput) align 4 %15, ptr noundef nonnull %12, ptr noundef %7, ptr noundef null, i32 noundef 0) #9
  %71 = getelementptr inbounds i8, ptr %15, i64 24
  %72 = load float, ptr %71, align 8, !tbaa !27
  %73 = load float, ptr @b2_lengthUnitsPerMeter, align 4, !tbaa !20
  %74 = fmul float %73, 0x3F747AE140000000
  %75 = call float @llvm.fmuladd.f32(float %74, float 4.000000e+00, float %23)
  %76 = fcmp ogt float %72, %75
  br i1 %76, label %.critedge, label %86

77:                                               ; preds = %.lr.ph, %77
  %indvars.iv = phi i64 [ 0, %.lr.ph ], [ %indvars.iv.next, %77 ]
  %78 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %10, i64 0, i64 %indvars.iv
  %79 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %4, i64 0, i64 %indvars.iv
  %80 = load <2 x float>, ptr %79, align 4
  %81 = tail call <2 x float> @b2TransformPoint(<2 x float> %17, <2 x float> %18, <2 x float> %80)
  store <2 x float> %81, ptr %78, align 8
  %82 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %11, i64 0, i64 %indvars.iv
  %83 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %66, i64 0, i64 %indvars.iv
  %84 = load <2 x float>, ptr %83, align 4
  %85 = tail call <2 x float> @b2RotateVector(<2 x float> %18, <2 x float> %84)
  store <2 x float> %85, ptr %82, align 8
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %._crit_edge, label %77, !llvm.loop !29

86:                                               ; preds = %._crit_edge
  %87 = load i8, ptr %36, align 8, !tbaa !12, !range !31, !noundef !32
  %88 = trunc nuw i8 %87 to i1
  %.sroa.0216.0.copyload = load <2 x float>, ptr %32, align 8
  %.sroa.0216.0 = select i1 %88, <2 x float> %.sroa.0216.0.copyload, <2 x float> %48
  %89 = load i8, ptr %46, align 1, !tbaa !15, !range !31, !noundef !32
  %90 = trunc nuw i8 %89 to i1
  %.sroa.0213.0.copyload = load <2 x float>, ptr %42, align 8
  %.sroa.0213.0 = select i1 %90, <2 x float> %.sroa.0213.0.copyload, <2 x float> %48
  %91 = fmul float %74, 0x3FB99999A0000000
  %92 = fcmp ogt float %72, %91
  %or.cond435 = select i1 %51, i1 %92, i1 false
  br i1 %or.cond435, label %93, label %.preheader438

.preheader438:                                    ; preds = %86
  br i1 %65, label %.lr.ph443.preheader, label %._crit_edge444.thread

.lr.ph443.preheader:                              ; preds = %.preheader438
  %wide.trip.count468 = zext nneg i32 %64 to i64
  br label %.lr.ph443

93:                                               ; preds = %86
  %94 = load i16, ptr %7, align 2, !tbaa !33
  switch i16 %94, label %126 [
    i16 1, label %95
    i16 2, label %129
  ]

95:                                               ; preds = %93
  %.sroa.0205.0.copyload = load <2 x float>, ptr %15, align 8
  %96 = getelementptr inbounds i8, ptr %15, i64 8
  %.sroa.0204.0.copyload = load <2 x float>, ptr %96, align 8
  %97 = call <2 x float> @b2Sub(<2 x float> %.sroa.0204.0.copyload, <2 x float> %.sroa.0205.0.copyload)
  %98 = call <2 x float> @b2Normalize(<2 x float> %97)
  %99 = call i32 @b2ClassifyNormal(ptr noundef nonnull byval(%struct.b2ChainSegmentParams) align 8 %9, <2 x float> %98)
  switch i32 %99, label %122 [
    i32 0, label %.critedge
    i32 1, label %100
  ]

100:                                              ; preds = %95
  %101 = call <2 x float> @b2RotateVector(<2 x float> %3, <2 x float> %98)
  store <2 x float> %101, ptr %0, align 4
  %102 = getelementptr inbounds i8, ptr %0, i64 12
  %103 = getelementptr inbounds i8, ptr %0, i64 20
  %104 = call <2 x float> @b2RotateVector(<2 x float> %3, <2 x float> %.sroa.0205.0.copyload)
  store <2 x float> %104, ptr %103, align 4
  %105 = getelementptr inbounds i8, ptr %0, i64 28
  %106 = call <2 x float> @b2Sub(<2 x float> %2, <2 x float> %5)
  %107 = call <2 x float> @b2Add(<2 x float> %104, <2 x float> %106)
  store <2 x float> %107, ptr %105, align 4
  %108 = call <2 x float> @b2Add(<2 x float> %2, <2 x float> %104)
  store <2 x float> %108, ptr %102, align 4
  %109 = load float, ptr %71, align 8, !tbaa !27
  %110 = fsub float %109, %23
  %111 = getelementptr inbounds i8, ptr %0, i64 36
  store float %110, ptr %111, align 4, !tbaa !36
  %112 = getelementptr inbounds i8, ptr %7, i64 2
  %113 = load i8, ptr %112, align 2, !tbaa !18
  %114 = zext i8 %113 to i16
  %115 = shl nuw i16 %114, 8
  %116 = getelementptr inbounds i8, ptr %7, i64 5
  %117 = load i8, ptr %116, align 1, !tbaa !18
  %118 = zext i8 %117 to i16
  %119 = or disjoint i16 %115, %118
  %120 = getelementptr inbounds i8, ptr %0, i64 56
  store i16 %119, ptr %120, align 4, !tbaa !38
  %121 = getelementptr inbounds i8, ptr %0, i64 108
  store i32 1, ptr %121, align 4, !tbaa !39
  br label %.critedge

122:                                              ; preds = %95
  %123 = getelementptr inbounds i8, ptr %7, i64 5
  %124 = load i8, ptr %123, align 1, !tbaa !18
  %125 = zext i8 %124 to i32
  br label %.thread424.thread

126:                                              ; preds = %93
  %127 = call i32 @b2InternalAssertFcn(ptr noundef nonnull @.str.3, ptr noundef nonnull @.str.1, i32 noundef 1438) #9
  %.not404 = icmp eq i32 %127, 0
  br i1 %.not404, label %129, label %128

128:                                              ; preds = %126
  call void @llvm.trap()
  unreachable

129:                                              ; preds = %93, %126
  %130 = getelementptr inbounds i8, ptr %7, i64 2
  %131 = load i8, ptr %130, align 2, !tbaa !18
  %132 = getelementptr inbounds i8, ptr %7, i64 3
  %133 = load i8, ptr %132, align 1, !tbaa !18
  %134 = getelementptr inbounds i8, ptr %7, i64 5
  %135 = load i8, ptr %134, align 1, !tbaa !18
  %136 = zext i8 %135 to i32
  %137 = getelementptr inbounds i8, ptr %7, i64 6
  %138 = load i8, ptr %137, align 1, !tbaa !18
  %139 = zext i8 %138 to i32
  %140 = icmp eq i8 %131, %133
  br i1 %140, label %141, label %215

141:                                              ; preds = %129
  %.not405 = icmp eq i8 %135, %138
  br i1 %.not405, label %142, label %145

142:                                              ; preds = %141
  %143 = call i32 @b2InternalAssertFcn(ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.1, i32 noundef 1448) #9
  %.not406 = icmp eq i32 %143, 0
  br i1 %.not406, label %145, label %144

144:                                              ; preds = %142
  call void @llvm.trap()
  unreachable

145:                                              ; preds = %142, %141
  %146 = getelementptr inbounds i8, ptr %15, i64 8
  %147 = load <2 x float>, ptr %15, align 8
  %148 = load <2 x float>, ptr %146, align 8
  %149 = call <2 x float> @b2Sub(<2 x float> %147, <2 x float> %148)
  %150 = zext i8 %135 to i64
  %151 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %11, i64 0, i64 %150
  %152 = load <2 x float>, ptr %151, align 8
  %153 = call float @b2Dot(<2 x float> %149, <2 x float> %152)
  %154 = zext i8 %138 to i64
  %155 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %11, i64 0, i64 %154
  %156 = load <2 x float>, ptr %155, align 8
  %157 = call float @b2Dot(<2 x float> %149, <2 x float> %156)
  %158 = fcmp ogt float %153, %157
  %159 = select i1 %158, i32 %136, i32 %139
  %160 = zext nneg i32 %159 to i64
  %161 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %11, i64 0, i64 %160
  %.sroa.0160.0.copyload = load <2 x float>, ptr %161, align 8
  %162 = call <2 x float> @b2Neg(<2 x float> %.sroa.0160.0.copyload)
  %163 = call i32 @b2ClassifyNormal(ptr noundef nonnull byval(%struct.b2ChainSegmentParams) align 8 %9, <2 x float> %162)
  switch i32 %163, label %.thread424 [
    i32 0, label %.critedge
    i32 1, label %164
  ]

164:                                              ; preds = %145
  %165 = add nsw i32 %64, -1
  %166 = icmp slt i32 %159, %165
  %167 = add nuw nsw i32 %159, 1
  %168 = select i1 %166, i32 %167, i32 0
  %169 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %10, i64 0, i64 %160
  %.sroa.0145.0.copyload = load <2 x float>, ptr %169, align 8
  %170 = zext nneg i32 %168 to i64
  %171 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %10, i64 0, i64 %170
  %.sroa.0144.0.copyload = load <2 x float>, ptr %171, align 8
  %172 = call <2 x float> @b2Sub(<2 x float> %.sroa.0285.0.copyload, <2 x float> %.sroa.0145.0.copyload)
  %173 = call float @b2Dot(<2 x float> %.sroa.0160.0.copyload, <2 x float> %172)
  %174 = call <2 x float> @b2Sub(<2 x float> %.sroa.0274.0.copyload, <2 x float> %.sroa.0145.0.copyload)
  %175 = call float @b2Dot(<2 x float> %.sroa.0160.0.copyload, <2 x float> %174)
  %176 = fcmp olt float %173, %175
  br i1 %176, label %177, label %181

177:                                              ; preds = %164
  %178 = call float @b2Dot(<2 x float> %.sroa.0216.0, <2 x float> %.sroa.0160.0.copyload)
  %179 = call float @b2Dot(<2 x float> %48, <2 x float> %.sroa.0160.0.copyload)
  %180 = fcmp olt float %178, %179
  br i1 %180, label %.critedge, label %185

181:                                              ; preds = %164
  %182 = call float @b2Dot(<2 x float> %.sroa.0213.0, <2 x float> %.sroa.0160.0.copyload)
  %183 = call float @b2Dot(<2 x float> %48, <2 x float> %.sroa.0160.0.copyload)
  %184 = fcmp olt float %182, %183
  br i1 %184, label %.critedge, label %185

185:                                              ; preds = %181, %177
  %.tr407 = trunc nuw nsw i32 %159 to i16
  %186 = shl nuw i16 %.tr407, 8
  %187 = or disjoint i16 %186, 1
  %.tr408 = trunc nuw nsw i32 %168 to i16
  %188 = shl i16 %.tr408, 8
  call void @b2ClipSegments(ptr dead_on_unwind nonnull writable sret(%struct.b2Manifold) align 4 %0, <2 x float> %.sroa.0145.0.copyload, <2 x float> %.sroa.0144.0.copyload, <2 x float> %.sroa.0285.0.copyload, <2 x float> %.sroa.0274.0.copyload, <2 x float> %.sroa.0160.0.copyload, float noundef %23, float noundef 0.000000e+00, i16 noundef zeroext %187, i16 noundef zeroext %188)
  %189 = getelementptr inbounds i8, ptr %0, i64 108
  %190 = load i32, ptr %189, align 4
  %191 = and i32 %190, -3
  %or.cond = icmp eq i32 %191, 0
  br i1 %or.cond, label %195, label %192

192:                                              ; preds = %185
  %193 = call i32 @b2InternalAssertFcn(ptr noundef nonnull @.str.5, ptr noundef nonnull @.str.1, i32 noundef 1499) #9
  %.not409 = icmp eq i32 %193, 0
  br i1 %.not409, label %195, label %194

194:                                              ; preds = %192
  call void @llvm.trap()
  unreachable

195:                                              ; preds = %192, %185
  %196 = icmp eq i32 %190, 2
  br i1 %196, label %197, label %.critedge

197:                                              ; preds = %195
  %198 = call <2 x float> @b2Neg(<2 x float> %.sroa.0160.0.copyload)
  %199 = call <2 x float> @b2RotateVector(<2 x float> %3, <2 x float> %198)
  store <2 x float> %199, ptr %0, align 4
  %200 = getelementptr inbounds i8, ptr %0, i64 12
  %201 = getelementptr inbounds i8, ptr %0, i64 20
  %202 = load <2 x float>, ptr %201, align 4
  %203 = call <2 x float> @b2RotateVector(<2 x float> %3, <2 x float> %202)
  store <2 x float> %203, ptr %201, align 4
  %204 = getelementptr inbounds i8, ptr %0, i64 60
  %205 = getelementptr inbounds i8, ptr %0, i64 68
  %206 = load <2 x float>, ptr %205, align 4
  %207 = call <2 x float> @b2RotateVector(<2 x float> %3, <2 x float> %206)
  store <2 x float> %207, ptr %205, align 4
  %208 = call <2 x float> @b2Sub(<2 x float> %2, <2 x float> %5)
  %209 = getelementptr inbounds i8, ptr %0, i64 28
  %210 = call <2 x float> @b2Add(<2 x float> %203, <2 x float> %208)
  store <2 x float> %210, ptr %209, align 4
  %211 = getelementptr inbounds i8, ptr %0, i64 76
  %212 = call <2 x float> @b2Add(<2 x float> %207, <2 x float> %208)
  store <2 x float> %212, ptr %211, align 4
  %213 = call <2 x float> @b2Add(<2 x float> %2, <2 x float> %203)
  store <2 x float> %213, ptr %200, align 4
  %214 = call <2 x float> @b2Add(<2 x float> %2, <2 x float> %207)
  store <2 x float> %214, ptr %204, align 4
  br label %.critedge

215:                                              ; preds = %129
  %216 = zext i8 %135 to i64
  %217 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %10, i64 0, i64 %216
  %218 = load <2 x float>, ptr %217, align 8
  %219 = call <2 x float> @b2Sub(<2 x float> %218, <2 x float> %.sroa.0285.0.copyload)
  %220 = call float @b2Dot(<2 x float> %48, <2 x float> %219)
  %221 = zext i8 %138 to i64
  %222 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %10, i64 0, i64 %221
  %223 = load <2 x float>, ptr %222, align 8
  %224 = call <2 x float> @b2Sub(<2 x float> %223, <2 x float> %.sroa.0274.0.copyload)
  %225 = call float @b2Dot(<2 x float> %48, <2 x float> %224)
  %226 = fcmp olt float %220, %225
  %227 = select i1 %226, i32 %136, i32 %139
  br label %.thread424.thread

._crit_edge444:                                   ; preds = %.lr.ph443
  %.pre = load i8, ptr %36, align 8, !tbaa !12, !range !31
  %228 = trunc nuw i8 %.pre to i1
  br i1 %228, label %.preheader437, label %243

._crit_edge444.thread:                            ; preds = %.preheader438
  %229 = trunc nuw i8 %87 to i1
  br i1 %229, label %._crit_edge449, label %.thread

.preheader437:                                    ; preds = %._crit_edge444
  br i1 %65, label %.lr.ph448.preheader, label %._crit_edge449

.lr.ph448.preheader:                              ; preds = %.preheader437
  %wide.trip.count473 = zext nneg i32 %64 to i64
  br label %.lr.ph448

.lr.ph443:                                        ; preds = %.lr.ph443.preheader, %.lr.ph443
  %indvars.iv465 = phi i64 [ 0, %.lr.ph443.preheader ], [ %indvars.iv.next466, %.lr.ph443 ]
  %.3364442 = phi i32 [ -1, %.lr.ph443.preheader ], [ %.4365, %.lr.ph443 ]
  %.0375441 = phi float [ 0x47EFFFFFE0000000, %.lr.ph443.preheader ], [ %.1376, %.lr.ph443 ]
  %230 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %10, i64 0, i64 %indvars.iv465
  %231 = load <2 x float>, ptr %230, align 8
  %232 = call <2 x float> @b2Sub(<2 x float> %231, <2 x float> %.sroa.0285.0.copyload)
  %233 = call float @b2Dot(<2 x float> %48, <2 x float> %232)
  %234 = fcmp olt float %233, %.0375441
  %.1376 = select i1 %234, float %233, float %.0375441
  %235 = trunc nuw nsw i64 %indvars.iv465 to i32
  %.4365 = select i1 %234, i32 %235, i32 %.3364442
  %indvars.iv.next466 = add nuw nsw i64 %indvars.iv465, 1
  %exitcond469.not = icmp eq i64 %indvars.iv.next466, %wide.trip.count468
  br i1 %exitcond469.not, label %._crit_edge444, label %.lr.ph443, !llvm.loop !41

._crit_edge449:                                   ; preds = %.lr.ph448, %._crit_edge444.thread, %.preheader437
  %.0375.lcssa487492 = phi float [ %.1376, %.preheader437 ], [ 0x47EFFFFFE0000000, %._crit_edge444.thread ], [ %.1376, %.lr.ph448 ]
  %.3364.lcssa488491 = phi i32 [ %.4365, %.preheader437 ], [ -1, %._crit_edge444.thread ], [ %.4365, %.lr.ph448 ]
  %.0382.lcssa = phi float [ 0x47EFFFFFE0000000, %.preheader437 ], [ 0x47EFFFFFE0000000, %._crit_edge444.thread ], [ %.1383, %.lr.ph448 ]
  %236 = fcmp ogt float %.0382.lcssa, %.0375.lcssa487492
  %.2377 = select i1 %236, float %.0382.lcssa, float %.0375.lcssa487492
  %.5366 = select i1 %236, i32 -1, i32 %.3364.lcssa488491
  br label %243

.lr.ph448:                                        ; preds = %.lr.ph448.preheader, %.lr.ph448
  %indvars.iv470 = phi i64 [ 0, %.lr.ph448.preheader ], [ %indvars.iv.next471, %.lr.ph448 ]
  %.0382447 = phi float [ 0x47EFFFFFE0000000, %.lr.ph448.preheader ], [ %.1383, %.lr.ph448 ]
  %237 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %10, i64 0, i64 %indvars.iv470
  %238 = load <2 x float>, ptr %237, align 8
  %239 = call <2 x float> @b2Sub(<2 x float> %238, <2 x float> %.sroa.0285.0.copyload)
  %240 = load <2 x float>, ptr %32, align 8
  %241 = call float @b2Dot(<2 x float> %240, <2 x float> %239)
  %242 = fcmp olt float %241, %.0382447
  %.1383 = select i1 %242, float %241, float %.0382447
  %indvars.iv.next471 = add nuw nsw i64 %indvars.iv470, 1
  %exitcond474.not = icmp eq i64 %indvars.iv.next471, %wide.trip.count473
  br i1 %exitcond474.not, label %._crit_edge449, label %.lr.ph448, !llvm.loop !42

243:                                              ; preds = %._crit_edge449, %._crit_edge444
  %.3378 = phi float [ %.2377, %._crit_edge449 ], [ %.1376, %._crit_edge444 ]
  %.6 = phi i32 [ %.5366, %._crit_edge449 ], [ %.4365, %._crit_edge444 ]
  %244 = load i8, ptr %46, align 1, !tbaa !15, !range !31, !noundef !32
  %245 = trunc nuw i8 %244 to i1
  br i1 %245, label %.preheader, label %255

.thread:                                          ; preds = %._crit_edge444.thread
  %246 = load i8, ptr %46, align 1, !tbaa !15, !range !31, !noundef !32
  %247 = trunc nuw i8 %246 to i1
  br i1 %247, label %._crit_edge454, label %.critedge

.preheader:                                       ; preds = %243
  br i1 %65, label %.lr.ph453.preheader, label %._crit_edge454

.lr.ph453.preheader:                              ; preds = %.preheader
  %wide.trip.count478 = zext nneg i32 %64 to i64
  br label %.lr.ph453

._crit_edge454:                                   ; preds = %.lr.ph453, %.thread, %.preheader
  %.3378495500 = phi float [ %.3378, %.preheader ], [ 0x47EFFFFFE0000000, %.thread ], [ %.3378, %.lr.ph453 ]
  %.6496499 = phi i32 [ %.6, %.preheader ], [ -1, %.thread ], [ %.6, %.lr.ph453 ]
  %.0385.lcssa = phi float [ 0x47EFFFFFE0000000, %.preheader ], [ 0x47EFFFFFE0000000, %.thread ], [ %.1386, %.lr.ph453 ]
  %248 = fcmp ogt float %.0385.lcssa, %.3378495500
  %.4379 = select i1 %248, float %.0385.lcssa, float %.3378495500
  %.7 = select i1 %248, i32 -1, i32 %.6496499
  br label %255

.lr.ph453:                                        ; preds = %.lr.ph453.preheader, %.lr.ph453
  %indvars.iv475 = phi i64 [ 0, %.lr.ph453.preheader ], [ %indvars.iv.next476, %.lr.ph453 ]
  %.0385452 = phi float [ 0x47EFFFFFE0000000, %.lr.ph453.preheader ], [ %.1386, %.lr.ph453 ]
  %249 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %10, i64 0, i64 %indvars.iv475
  %250 = load <2 x float>, ptr %249, align 8
  %251 = call <2 x float> @b2Sub(<2 x float> %250, <2 x float> %.sroa.0274.0.copyload)
  %252 = load <2 x float>, ptr %42, align 8
  %253 = call float @b2Dot(<2 x float> %252, <2 x float> %251)
  %254 = fcmp olt float %253, %.0385452
  %.1386 = select i1 %254, float %253, float %.0385452
  %indvars.iv.next476 = add nuw nsw i64 %indvars.iv475, 1
  %exitcond479.not = icmp eq i64 %indvars.iv.next476, %wide.trip.count478
  br i1 %exitcond479.not, label %._crit_edge454, label %.lr.ph453, !llvm.loop !43

255:                                              ; preds = %._crit_edge454, %243
  %.5380 = phi float [ %.4379, %._crit_edge454 ], [ %.3378, %243 ]
  %.8 = phi i32 [ %.7, %._crit_edge454 ], [ %.6, %243 ]
  br i1 %65, label %.lr.ph460.preheader, label %._crit_edge461

.lr.ph460.preheader:                              ; preds = %255
  %wide.trip.count483 = zext nneg i32 %64 to i64
  br label %.lr.ph460

._crit_edge461:                                   ; preds = %269, %255
  %.0391.lcssa = phi i32 [ -1, %255 ], [ %.2393, %269 ]
  %.0388.lcssa = phi float [ 0xC7EFFFFFE0000000, %255 ], [ %.2390, %269 ]
  %256 = fcmp ogt float %.0388.lcssa, %.5380
  br i1 %256, label %270, label %323

.lr.ph460:                                        ; preds = %.lr.ph460.preheader, %269
  %indvars.iv480 = phi i64 [ 0, %.lr.ph460.preheader ], [ %indvars.iv.next481, %269 ]
  %.0388458 = phi float [ 0xC7EFFFFFE0000000, %.lr.ph460.preheader ], [ %.2390, %269 ]
  %.0391457 = phi i32 [ -1, %.lr.ph460.preheader ], [ %.2393, %269 ]
  %257 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %11, i64 0, i64 %indvars.iv480
  %.sroa.088.0.copyload = load <2 x float>, ptr %257, align 8
  %258 = call <2 x float> @b2Neg(<2 x float> %.sroa.088.0.copyload)
  %259 = call i32 @b2ClassifyNormal(ptr noundef nonnull byval(%struct.b2ChainSegmentParams) align 8 %9, <2 x float> %258)
  %.not403 = icmp eq i32 %259, 1
  br i1 %.not403, label %260, label %269

260:                                              ; preds = %.lr.ph460
  %261 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %10, i64 0, i64 %indvars.iv480
  %.sroa.084.0.copyload = load <2 x float>, ptr %261, align 8
  %262 = call <2 x float> @b2Sub(<2 x float> %.sroa.0274.0.copyload, <2 x float> %.sroa.084.0.copyload)
  %263 = call float @b2Dot(<2 x float> %.sroa.088.0.copyload, <2 x float> %262)
  %264 = call <2 x float> @b2Sub(<2 x float> %.sroa.0285.0.copyload, <2 x float> %.sroa.084.0.copyload)
  %265 = call float @b2Dot(<2 x float> %.sroa.088.0.copyload, <2 x float> %264)
  %266 = call float @b2MinFloat(float noundef %263, float noundef %265)
  %267 = fcmp ogt float %266, %.0388458
  %268 = trunc nuw nsw i64 %indvars.iv480 to i32
  %.1392 = select i1 %267, i32 %268, i32 %.0391457
  %.1389 = select i1 %267, float %266, float %.0388458
  br label %269

269:                                              ; preds = %.lr.ph460, %260
  %.2393 = phi i32 [ %.1392, %260 ], [ %.0391457, %.lr.ph460 ]
  %.2390 = phi float [ %.1389, %260 ], [ %.0388458, %.lr.ph460 ]
  %indvars.iv.next481 = add nuw nsw i64 %indvars.iv480, 1
  %exitcond484.not = icmp eq i64 %indvars.iv.next481, %wide.trip.count483
  br i1 %exitcond484.not, label %._crit_edge461, label %.lr.ph460, !llvm.loop !44

270:                                              ; preds = %._crit_edge461
  %271 = add nsw i32 %64, -1
  %272 = icmp slt i32 %.0391.lcssa, %271
  %273 = add nsw i32 %.0391.lcssa, 1
  %274 = select i1 %272, i32 %273, i32 0
  %275 = sext i32 %.0391.lcssa to i64
  %276 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %10, i64 0, i64 %275
  %.sroa.068.0.copyload = load <2 x float>, ptr %276, align 8
  %277 = sext i32 %274 to i64
  %278 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %10, i64 0, i64 %277
  %.sroa.067.0.copyload = load <2 x float>, ptr %278, align 8
  %279 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %11, i64 0, i64 %275
  %.sroa.061.0.copyload = load <2 x float>, ptr %279, align 8
  %280 = call <2 x float> @b2Sub(<2 x float> %.sroa.0285.0.copyload, <2 x float> %.sroa.068.0.copyload)
  %281 = call float @b2Dot(<2 x float> %.sroa.061.0.copyload, <2 x float> %280)
  %282 = call <2 x float> @b2Sub(<2 x float> %.sroa.0274.0.copyload, <2 x float> %.sroa.068.0.copyload)
  %283 = call float @b2Dot(<2 x float> %.sroa.061.0.copyload, <2 x float> %282)
  %284 = fcmp olt float %281, %283
  br i1 %284, label %285, label %289

285:                                              ; preds = %270
  %286 = call float @b2Dot(<2 x float> %.sroa.0216.0, <2 x float> %.sroa.061.0.copyload)
  %287 = call float @b2Dot(<2 x float> %48, <2 x float> %.sroa.061.0.copyload)
  %288 = fcmp olt float %286, %287
  br i1 %288, label %.critedge, label %293

289:                                              ; preds = %270
  %290 = call float @b2Dot(<2 x float> %.sroa.0213.0, <2 x float> %.sroa.061.0.copyload)
  %291 = call float @b2Dot(<2 x float> %48, <2 x float> %.sroa.061.0.copyload)
  %292 = fcmp olt float %290, %291
  br i1 %292, label %.critedge, label %293

293:                                              ; preds = %289, %285
  %.0391.tr = trunc i32 %.0391.lcssa to i16
  %294 = shl i16 %.0391.tr, 8
  %295 = or disjoint i16 %294, 1
  %.tr = trunc i32 %274 to i16
  %296 = shl i16 %.tr, 8
  call void @b2ClipSegments(ptr dead_on_unwind nonnull writable sret(%struct.b2Manifold) align 4 %0, <2 x float> %.sroa.068.0.copyload, <2 x float> %.sroa.067.0.copyload, <2 x float> %.sroa.0285.0.copyload, <2 x float> %.sroa.0274.0.copyload, <2 x float> %.sroa.061.0.copyload, float noundef %23, float noundef 0.000000e+00, i16 noundef zeroext %295, i16 noundef zeroext %296)
  %297 = getelementptr inbounds i8, ptr %0, i64 108
  %298 = load i32, ptr %297, align 4
  %299 = and i32 %298, -3
  %or.cond8 = icmp eq i32 %299, 0
  br i1 %or.cond8, label %303, label %300

300:                                              ; preds = %293
  %301 = call i32 @b2InternalAssertFcn(ptr noundef nonnull @.str.5, ptr noundef nonnull @.str.1, i32 noundef 1648) #9
  %.not = icmp eq i32 %301, 0
  br i1 %.not, label %303, label %302

302:                                              ; preds = %300
  call void @llvm.trap()
  unreachable

303:                                              ; preds = %300, %293
  %304 = icmp eq i32 %298, 2
  br i1 %304, label %305, label %.critedge

305:                                              ; preds = %303
  %306 = call <2 x float> @b2Neg(<2 x float> %.sroa.061.0.copyload)
  %307 = call <2 x float> @b2RotateVector(<2 x float> %3, <2 x float> %306)
  store <2 x float> %307, ptr %0, align 4
  %308 = getelementptr inbounds i8, ptr %0, i64 12
  %309 = getelementptr inbounds i8, ptr %0, i64 20
  %310 = load <2 x float>, ptr %309, align 4
  %311 = call <2 x float> @b2RotateVector(<2 x float> %3, <2 x float> %310)
  store <2 x float> %311, ptr %309, align 4
  %312 = getelementptr inbounds i8, ptr %0, i64 60
  %313 = getelementptr inbounds i8, ptr %0, i64 68
  %314 = load <2 x float>, ptr %313, align 4
  %315 = call <2 x float> @b2RotateVector(<2 x float> %3, <2 x float> %314)
  store <2 x float> %315, ptr %313, align 4
  %316 = call <2 x float> @b2Sub(<2 x float> %2, <2 x float> %5)
  %317 = getelementptr inbounds i8, ptr %0, i64 28
  %318 = call <2 x float> @b2Add(<2 x float> %311, <2 x float> %316)
  store <2 x float> %318, ptr %317, align 4
  %319 = getelementptr inbounds i8, ptr %0, i64 76
  %320 = call <2 x float> @b2Add(<2 x float> %315, <2 x float> %316)
  store <2 x float> %320, ptr %319, align 4
  %321 = call <2 x float> @b2Add(<2 x float> %2, <2 x float> %311)
  store <2 x float> %321, ptr %308, align 4
  %322 = call <2 x float> @b2Add(<2 x float> %2, <2 x float> %315)
  store <2 x float> %322, ptr %312, align 4
  br label %.critedge

323:                                              ; preds = %._crit_edge461
  %.not436 = icmp eq i32 %.8, -1
  br i1 %.not436, label %.critedge, label %.thread424.thread

.thread424:                                       ; preds = %145
  %324 = add nsw i32 %64, -1
  %325 = icmp slt i32 %159, %324
  %326 = add nuw nsw i32 %159, 1
  %327 = select i1 %325, i32 %326, i32 0
  %328 = zext nneg i32 %327 to i64
  br label %347

.thread424.thread:                                ; preds = %323, %122, %215
  %.9429430 = phi i32 [ %125, %122 ], [ %227, %215 ], [ %.8, %323 ]
  %329 = icmp sgt i32 %.9429430, 0
  %330 = add nsw i32 %.9429430, -1
  %331 = add nsw i32 %64, -1
  %332 = select i1 %329, i32 %330, i32 %331
  %333 = sext i32 %332 to i64
  %334 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %11, i64 0, i64 %333
  %335 = load <2 x float>, ptr %334, align 8
  %336 = call float @b2Dot(<2 x float> %48, <2 x float> %335)
  %337 = sext i32 %.9429430 to i64
  %338 = getelementptr inbounds [8 x %struct.b2Vec2], ptr %11, i64 0, i64 %337
  %339 = load <2 x float>, ptr %338, align 8
  %340 = call float @b2Dot(<2 x float> %48, <2 x float> %339)
  %341 = fcmp olt float %336, %340
  br i1 %341, label %347, label %342

342:                                              ; preds = %.thread424.thread
  %343 = icmp slt i32 %.9429430, %331
  %344 = add nuw nsw i32 %.9429430, 1
  %345 = select i1 %343, i32 %344, i32 0
  %346 = sext i32 %345 to i64
  br label %347

347:                                              ; preds = %342, %.thread424.thread, %.thread424
  %.pn412 = phi i64 [ %160, %.thread424 ], [ %337, %342 ], [ %333, %.thread424.thread ]
  %.pn413 = phi i64 [ %328, %.thread424 ], [ %346, %342 ], [ %337, %.thread424.thread ]
  %.1374 = phi i32 [ %159, %.thread424 ], [ %.9429430, %342 ], [ %332, %.thread424.thread ]
  %.1372 = phi i32 [ %327, %.thread424 ], [ %345, %342 ], [ %.9429430, %.thread424.thread ]
  %.sroa.041.1.in = getelementptr inbounds [8 x %struct.b2Vec2], ptr %10, i64 0, i64 %.pn413
  %.sroa.041.1 = load <2 x float>, ptr %.sroa.041.1.in, align 8
  %.sroa.044.1.in = getelementptr inbounds [8 x %struct.b2Vec2], ptr %10, i64 0, i64 %.pn412
  %.sroa.044.1 = load <2 x float>, ptr %.sroa.044.1.in, align 8
  %348 = trunc i32 %.1372 to i16
  %349 = and i16 %348, 255
  %350 = trunc i32 %.1374 to i16
  %351 = and i16 %350, 255
  %352 = or disjoint i16 %351, 256
  call void @b2ClipSegments(ptr dead_on_unwind nonnull writable sret(%struct.b2Manifold) align 4 %0, <2 x float> %.sroa.0285.0.copyload, <2 x float> %.sroa.0274.0.copyload, <2 x float> %.sroa.044.1, <2 x float> %.sroa.041.1, <2 x float> %48, float noundef 0.000000e+00, float noundef %23, i16 noundef zeroext %349, i16 noundef zeroext %352)
  %353 = getelementptr inbounds i8, ptr %0, i64 108
  %354 = load i32, ptr %353, align 4
  %355 = and i32 %354, -3
  %or.cond13 = icmp eq i32 %355, 0
  br i1 %or.cond13, label %359, label %356

356:                                              ; preds = %347
  %357 = call i32 @b2InternalAssertFcn(ptr noundef nonnull @.str.5, ptr noundef nonnull @.str.1, i32 noundef 1711) #9
  %.not414 = icmp eq i32 %357, 0
  br i1 %.not414, label %359, label %358

358:                                              ; preds = %356
  call void @llvm.trap()
  unreachable

359:                                              ; preds = %356, %347
  %360 = icmp eq i32 %354, 2
  br i1 %360, label %361, label %.critedge

361:                                              ; preds = %359
  %362 = load <2 x float>, ptr %0, align 4
  %363 = call <2 x float> @b2RotateVector(<2 x float> %3, <2 x float> %362)
  store <2 x float> %363, ptr %0, align 4
  %364 = getelementptr inbounds i8, ptr %0, i64 12
  %365 = getelementptr inbounds i8, ptr %0, i64 20
  %366 = load <2 x float>, ptr %365, align 4
  %367 = call <2 x float> @b2RotateVector(<2 x float> %3, <2 x float> %366)
  store <2 x float> %367, ptr %365, align 4
  %368 = getelementptr inbounds i8, ptr %0, i64 60
  %369 = getelementptr inbounds i8, ptr %0, i64 68
  %370 = load <2 x float>, ptr %369, align 4
  %371 = call <2 x float> @b2RotateVector(<2 x float> %3, <2 x float> %370)
  store <2 x float> %371, ptr %369, align 4
  %372 = call <2 x float> @b2Sub(<2 x float> %2, <2 x float> %5)
  %373 = getelementptr inbounds i8, ptr %0, i64 28
  %374 = call <2 x float> @b2Add(<2 x float> %367, <2 x float> %372)
  store <2 x float> %374, ptr %373, align 4
  %375 = getelementptr inbounds i8, ptr %0, i64 76
  %376 = call <2 x float> @b2Add(<2 x float> %371, <2 x float> %372)
  store <2 x float> %376, ptr %375, align 4
  %377 = call <2 x float> @b2Add(<2 x float> %2, <2 x float> %367)
  store <2 x float> %377, ptr %364, align 4
  %378 = call <2 x float> @b2Add(<2 x float> %2, <2 x float> %371)
  store <2 x float> %378, ptr %368, align 4
  br label %.critedge

.critedge:                                        ; preds = %.thread, %177, %181, %197, %195, %145, %95, %100, %323, %361, %359, %285, %289, %305, %303, %._crit_edge
  call void @llvm.lifetime.end.p0(i64 36, ptr nonnull %15) #9
  call void @llvm.lifetime.end.p0(i64 180, ptr nonnull %12) #9
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %11) #9
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %10) #9
  br label %379

379:                                              ; preds = %61, %.critedge
  call void @llvm.lifetime.end.p0(i64 28, ptr nonnull %9) #9
  ret void
}

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

declare void @b2MakeProxy(ptr dead_on_unwind writable sret(%struct.b2ShapeProxy) align 4, ptr noundef, i32 noundef, float noundef) local_unnamed_addr #4

declare void @b2ShapeDistance(ptr dead_on_unwind writable sret(%struct.b2DistanceOutput) align 4, ptr noundef, ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #4

; Function Attrs: nounwind uwtable
declare hidden i32 @b2ClassifyNormal(ptr noundef byval(%struct.b2ChainSegmentParams) align 8, <2 x float>) local_unnamed_addr #8

; Function Attrs: nounwind uwtable
declare hidden void @b2ClipSegments(ptr dead_on_unwind noalias writable sret(%struct.b2Manifold) align 4, <2 x float>, <2 x float>, <2 x float>, <2 x float>, <2 x float>, float noundef, float noundef, i16 noundef zeroext, i16 noundef zeroext) local_unnamed_addr #8

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !10, i64 136}
!6 = !{!"b2Polygon", !7, i64 0, !7, i64 64, !9, i64 128, !10, i64 136, !11, i64 140}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!"b2Vec2", !10, i64 0, !10, i64 4}
!10 = !{!"float", !7, i64 0}
!11 = !{!"int", !7, i64 0}
!12 = !{!13, !14, i64 24}
!13 = !{!"b2ChainSegmentParams", !9, i64 0, !9, i64 8, !9, i64 16, !14, i64 24, !14, i64 25}
!14 = !{!"_Bool", !7, i64 0}
!15 = !{!13, !14, i64 25}
!16 = !{!6, !11, i64 140}
!17 = !{i64 0, i64 64, !18, i64 64, i64 4, !19, i64 68, i64 4, !20}
!18 = !{!7, !7, i64 0}
!19 = !{!11, !11, i64 0}
!20 = !{!10, !10, i64 0}
!21 = !{i64 0, i64 4, !20, i64 4, i64 4, !20, i64 8, i64 4, !20, i64 12, i64 4, !20}
!22 = !{!23, !14, i64 176}
!23 = !{!"b2DistanceInput", !24, i64 0, !24, i64 72, !25, i64 144, !25, i64 160, !14, i64 176}
!24 = !{!"b2ShapeProxy", !7, i64 0, !11, i64 64, !10, i64 68}
!25 = !{!"b2Transform", !9, i64 0, !26, i64 8}
!26 = !{!"b2Rot", !10, i64 0, !10, i64 4}
!27 = !{!28, !10, i64 24}
!28 = !{!"b2DistanceOutput", !9, i64 0, !9, i64 8, !9, i64 16, !10, i64 24, !11, i64 28, !11, i64 32}
!29 = distinct !{!29, !30}
!30 = !{!"llvm.loop.mustprogress"}
!31 = !{i8 0, i8 2}
!32 = !{}
!33 = !{!34, !35, i64 0}
!34 = !{!"b2SimplexCache", !35, i64 0, !7, i64 2, !7, i64 5}
!35 = !{!"short", !7, i64 0}
!36 = !{!37, !10, i64 24}
!37 = !{!"b2ManifoldPoint", !9, i64 0, !9, i64 8, !9, i64 16, !10, i64 24, !10, i64 28, !10, i64 32, !10, i64 36, !10, i64 40, !35, i64 44, !14, i64 46}
!38 = !{!37, !35, i64 44}
!39 = !{!40, !11, i64 108}
!40 = !{!"b2Manifold", !9, i64 0, !10, i64 8, !7, i64 12, !11, i64 108}
!41 = distinct !{!41, !30}
!42 = distinct !{!42, !30}
!43 = distinct !{!43, !30}
!44 = distinct !{!44, !30}


; Effective O3 passes: CorrelatedValuePropagationPass,DSEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,MemCpyOptPass,PostOrderFunctionAttrsPass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass