; LLVM IR from erincatto/box2d :: shared (human)

; 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.b2BodyId = type { i32, i16, i16 }
%struct.b2JointId = type { i32, i16, i16 }
%struct.b2WorldId = type { i16, i16 }
%struct.b2Vec2 = type { float, float }
%struct.b2BodyDef = type { i32, %struct.b2Vec2, %struct.b2Rot, %struct.b2Vec2, float, float, float, float, float, ptr, ptr, i8, i8, i8, i8, i8, i8, i32 }
%struct.b2Rot = type { float, float }
%struct.b2ShapeDef = type { ptr, %struct.b2SurfaceMaterial, float, %struct.b2Filter, i8, i8, i8, i8, i8, i8, i8, i32 }
%struct.b2SurfaceMaterial = type { float, float, float, float, i32, i32 }
%struct.b2Filter = type { i64, i64, i32 }
%struct.b2Capsule = type { %struct.b2Vec2, %struct.b2Vec2, float }
%struct.b2ShapeId = type { i32, i16, i16 }
%struct.b2RevoluteJointDef = type { %struct.b2BodyId, %struct.b2BodyId, %struct.b2Vec2, %struct.b2Vec2, float, i8, float, float, i8, float, float, i8, float, float, float, i8, ptr, i32 }
%struct.b2Hull = type { [8 x %struct.b2Vec2], i32 }
%struct.b2Polygon = type { [8 x %struct.b2Vec2], [8 x %struct.b2Vec2], %struct.b2Vec2, float, i32 }
%struct.Human = type { [11 x %struct.Bone], float, i8 }
%struct.Bone = type { %struct.b2BodyId, %struct.b2JointId, float, i32 }

@.str = external hidden unnamed_addr constant [26 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [64 x i8], align 1
@__PRETTY_FUNCTION__.CreateHuman = external hidden unnamed_addr constant [93 x i8], align 1
@b2_nullBodyId = external hidden constant %struct.b2BodyId, align 4
@b2_nullJointId = external hidden constant %struct.b2JointId, align 4
@__const.CreateHuman.skinColors = external hidden unnamed_addr constant [4 x i32], align 16
@.str.2 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [16 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @CreateHuman(ptr noundef %0, i32 %1, <2 x float> %2, float noundef %3, float noundef %4, float noundef %5, float noundef %6, i32 noundef %7, ptr noundef %8, i1 noundef zeroext %9) #0 {
  %11 = alloca %struct.b2WorldId, align 2
  %12 = alloca %struct.b2Vec2, align 4
  %13 = alloca ptr, align 8
  %14 = alloca float, align 4
  %15 = alloca float, align 4
  %16 = alloca float, align 4
  %17 = alloca float, align 4
  %18 = alloca i32, align 4
  %19 = alloca ptr, align 8
  %20 = alloca i8, align 1
  %21 = alloca i32, align 4
  %22 = alloca %struct.b2BodyDef, align 8
  %23 = alloca %struct.b2ShapeDef, align 8
  %24 = alloca %struct.b2ShapeDef, align 8
  %25 = alloca float, align 4
  %26 = alloca float, align 4
  %27 = alloca i8, align 1
  %28 = alloca i8, align 1
  %29 = alloca float, align 4
  %30 = alloca i32, align 4
  %31 = alloca i32, align 4
  %32 = alloca [4 x i32], align 16
  %33 = alloca i32, align 4
  %34 = alloca ptr, align 8
  %35 = alloca %struct.b2Vec2, align 4
  %36 = alloca %struct.b2Vec2, align 4
  %37 = alloca %struct.b2BodyId, align 4
  %38 = alloca %struct.b2Capsule, align 4
  %39 = alloca %struct.b2ShapeId, align 4
  %40 = alloca ptr, align 8
  %41 = alloca %struct.b2Vec2, align 4
  %42 = alloca %struct.b2Vec2, align 4
  %43 = alloca %struct.b2BodyId, align 4
  %44 = alloca %struct.b2Capsule, align 4
  %45 = alloca %struct.b2ShapeId, align 4
  %46 = alloca %struct.b2Vec2, align 4
  %47 = alloca %struct.b2Vec2, align 4
  %48 = alloca %struct.b2RevoluteJointDef, align 8
  %49 = alloca %struct.b2Vec2, align 4
  %50 = alloca %struct.b2Vec2, align 4
  %51 = alloca %struct.b2JointId, align 4
  %52 = alloca ptr, align 8
  %53 = alloca %struct.b2Vec2, align 4
  %54 = alloca %struct.b2Vec2, align 4
  %55 = alloca %struct.b2BodyId, align 4
  %56 = alloca %struct.b2Capsule, align 4
  %57 = alloca %struct.b2ShapeId, align 4
  %58 = alloca %struct.b2Vec2, align 4
  %59 = alloca %struct.b2Vec2, align 4
  %60 = alloca %struct.b2RevoluteJointDef, align 8
  %61 = alloca %struct.b2Vec2, align 4
  %62 = alloca %struct.b2Vec2, align 4
  %63 = alloca %struct.b2JointId, align 4
  %64 = alloca ptr, align 8
  %65 = alloca %struct.b2Vec2, align 4
  %66 = alloca %struct.b2Vec2, align 4
  %67 = alloca %struct.b2BodyId, align 4
  %68 = alloca %struct.b2Capsule, align 4
  %69 = alloca %struct.b2ShapeId, align 4
  %70 = alloca %struct.b2Vec2, align 4
  %71 = alloca %struct.b2Vec2, align 4
  %72 = alloca %struct.b2RevoluteJointDef, align 8
  %73 = alloca %struct.b2Vec2, align 4
  %74 = alloca %struct.b2Vec2, align 4
  %75 = alloca %struct.b2JointId, align 4
  %76 = alloca [4 x %struct.b2Vec2], align 16
  %77 = alloca %struct.b2Hull, align 4
  %78 = alloca %struct.b2Polygon, align 4
  %79 = alloca ptr, align 8
  %80 = alloca %struct.b2Vec2, align 4
  %81 = alloca %struct.b2Vec2, align 4
  %82 = alloca %struct.b2BodyId, align 4
  %83 = alloca %struct.b2Capsule, align 4
  %84 = alloca %struct.b2ShapeId, align 4
  %85 = alloca %struct.b2ShapeId, align 4
  %86 = alloca %struct.b2Vec2, align 4
  %87 = alloca %struct.b2Vec2, align 4
  %88 = alloca %struct.b2RevoluteJointDef, align 8
  %89 = alloca %struct.b2Vec2, align 4
  %90 = alloca %struct.b2Vec2, align 4
  %91 = alloca %struct.b2JointId, align 4
  %92 = alloca ptr, align 8
  %93 = alloca %struct.b2Vec2, align 4
  %94 = alloca %struct.b2Vec2, align 4
  %95 = alloca %struct.b2BodyId, align 4
  %96 = alloca %struct.b2Capsule, align 4
  %97 = alloca %struct.b2ShapeId, align 4
  %98 = alloca %struct.b2Vec2, align 4
  %99 = alloca %struct.b2Vec2, align 4
  %100 = alloca %struct.b2RevoluteJointDef, align 8
  %101 = alloca %struct.b2Vec2, align 4
  %102 = alloca %struct.b2Vec2, align 4
  %103 = alloca %struct.b2JointId, align 4
  %104 = alloca ptr, align 8
  %105 = alloca %struct.b2Vec2, align 4
  %106 = alloca %struct.b2Vec2, align 4
  %107 = alloca %struct.b2BodyId, align 4
  %108 = alloca %struct.b2Capsule, align 4
  %109 = alloca %struct.b2ShapeId, align 4
  %110 = alloca %struct.b2ShapeId, align 4
  %111 = alloca %struct.b2Vec2, align 4
  %112 = alloca %struct.b2Vec2, align 4
  %113 = alloca %struct.b2RevoluteJointDef, align 8
  %114 = alloca %struct.b2Vec2, align 4
  %115 = alloca %struct.b2Vec2, align 4
  %116 = alloca %struct.b2JointId, align 4
  %117 = alloca ptr, align 8
  %118 = alloca %struct.b2Vec2, align 4
  %119 = alloca %struct.b2Vec2, align 4
  %120 = alloca %struct.b2BodyId, align 4
  %121 = alloca %struct.b2Capsule, align 4
  %122 = alloca %struct.b2ShapeId, align 4
  %123 = alloca %struct.b2Vec2, align 4
  %124 = alloca %struct.b2Vec2, align 4
  %125 = alloca %struct.b2RevoluteJointDef, align 8
  %126 = alloca %struct.b2Vec2, align 4
  %127 = alloca %struct.b2Vec2, align 4
  %128 = alloca %struct.b2JointId, align 4
  %129 = alloca ptr, align 8
  %130 = alloca %struct.b2Vec2, align 4
  %131 = alloca %struct.b2Vec2, align 4
  %132 = alloca %struct.b2BodyId, align 4
  %133 = alloca %struct.b2Capsule, align 4
  %134 = alloca %struct.b2ShapeId, align 4
  %135 = alloca %struct.b2Vec2, align 4
  %136 = alloca %struct.b2Vec2, align 4
  %137 = alloca %struct.b2RevoluteJointDef, align 8
  %138 = alloca %struct.b2Vec2, align 4
  %139 = alloca %struct.b2Vec2, align 4
  %140 = alloca %struct.b2JointId, align 4
  %141 = alloca ptr, align 8
  %142 = alloca %struct.b2Vec2, align 4
  %143 = alloca %struct.b2Vec2, align 4
  %144 = alloca %struct.b2BodyId, align 4
  %145 = alloca %struct.b2Capsule, align 4
  %146 = alloca %struct.b2ShapeId, align 4
  %147 = alloca %struct.b2Vec2, align 4
  %148 = alloca %struct.b2Vec2, align 4
  %149 = alloca %struct.b2RevoluteJointDef, align 8
  %150 = alloca %struct.b2Vec2, align 4
  %151 = alloca %struct.b2Vec2, align 4
  %152 = alloca %struct.b2JointId, align 4
  %153 = alloca ptr, align 8
  %154 = alloca %struct.b2Vec2, align 4
  %155 = alloca %struct.b2Vec2, align 4
  %156 = alloca %struct.b2BodyId, align 4
  %157 = alloca %struct.b2Capsule, align 4
  %158 = alloca %struct.b2ShapeId, align 4
  %159 = alloca %struct.b2Vec2, align 4
  %160 = alloca %struct.b2Vec2, align 4
  %161 = alloca %struct.b2RevoluteJointDef, align 8
  %162 = alloca %struct.b2Vec2, align 4
  %163 = alloca %struct.b2Vec2, align 4
  %164 = alloca %struct.b2JointId, align 4
  store i32 %1, ptr %11, align 2
  store <2 x float> %2, ptr %12, align 4
  store ptr %0, ptr %13, align 8, !tbaa !5
  store float %3, ptr %14, align 4, !tbaa !9
  store float %4, ptr %15, align 4, !tbaa !9
  store float %5, ptr %16, align 4, !tbaa !9
  store float %6, ptr %17, align 4, !tbaa !9
  store i32 %7, ptr %18, align 4, !tbaa !11
  store ptr %8, ptr %19, align 8, !tbaa !5
  %165 = zext i1 %9 to i8
  store i8 %165, ptr %20, align 1, !tbaa !13
  %166 = load ptr, ptr %13, align 8, !tbaa !5
  %167 = getelementptr inbounds %struct.Human, ptr %166, i32 0, i32 2
  %168 = load i8, ptr %167, align 4, !tbaa !15, !range !17, !noundef !18
  %169 = trunc i8 %168 to i1
  %170 = zext i1 %169 to i32
  %171 = icmp eq i32 %170, 0
  br i1 %171, label %172, label %173

172:                                              ; preds = %10
  br label %174

173:                                              ; preds = %10
  call void @__assert_fail(ptr noundef @.str, ptr noundef @.str.1, i32 noundef 16, ptr noundef @__PRETTY_FUNCTION__.CreateHuman) #6
  unreachable

174:                                              ; preds = %172
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #7
  store i32 0, ptr %21, align 4, !tbaa !11
  br label %175

175:                                              ; preds = %204, %174
  %176 = load i32, ptr %21, align 4, !tbaa !11
  %177 = icmp slt i32 %176, 11
  br i1 %177, label %179, label %178

178:                                              ; preds = %175
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #7
  br label %207

179:                                              ; preds = %175
  %180 = load ptr, ptr %13, align 8, !tbaa !5
  %181 = getelementptr inbounds %struct.Human, ptr %180, i32 0, i32 0
  %182 = load i32, ptr %21, align 4, !tbaa !11
  %183 = sext i32 %182 to i64
  %184 = getelementptr inbounds [11 x %struct.Bone], ptr %181, i64 0, i64 %183
  %185 = getelementptr inbounds %struct.Bone, ptr %184, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %185, ptr align 4 @b2_nullBodyId, i64 8, i1 false), !tbaa.struct !19
  %186 = load ptr, ptr %13, align 8, !tbaa !5
  %187 = getelementptr inbounds %struct.Human, ptr %186, i32 0, i32 0
  %188 = load i32, ptr %21, align 4, !tbaa !11
  %189 = sext i32 %188 to i64
  %190 = getelementptr inbounds [11 x %struct.Bone], ptr %187, i64 0, i64 %189
  %191 = getelementptr inbounds %struct.Bone, ptr %190, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %191, ptr align 4 @b2_nullJointId, i64 8, i1 false), !tbaa.struct !19
  %192 = load ptr, ptr %13, align 8, !tbaa !5
  %193 = getelementptr inbounds %struct.Human, ptr %192, i32 0, i32 0
  %194 = load i32, ptr %21, align 4, !tbaa !11
  %195 = sext i32 %194 to i64
  %196 = getelementptr inbounds [11 x %struct.Bone], ptr %193, i64 0, i64 %195
  %197 = getelementptr inbounds %struct.Bone, ptr %196, i32 0, i32 2
  store float 1.000000e+00, ptr %197, align 4, !tbaa !22
  %198 = load ptr, ptr %13, align 8, !tbaa !5
  %199 = getelementptr inbounds %struct.Human, ptr %198, i32 0, i32 0
  %200 = load i32, ptr %21, align 4, !tbaa !11
  %201 = sext i32 %200 to i64
  %202 = getelementptr inbounds [11 x %struct.Bone], ptr %199, i64 0, i64 %201
  %203 = getelementptr inbounds %struct.Bone, ptr %202, i32 0, i32 3
  store i32 -1, ptr %203, align 4, !tbaa !26
  br label %204

204:                                              ; preds = %179
  %205 = load i32, ptr %21, align 4, !tbaa !11
  %206 = add nsw i32 %205, 1
  store i32 %206, ptr %21, align 4, !tbaa !11
  br label %175, !llvm.loop !27

207:                                              ; preds = %178
  %208 = load float, ptr %14, align 4, !tbaa !9
  %209 = load ptr, ptr %13, align 8, !tbaa !5
  %210 = getelementptr inbounds %struct.Human, ptr %209, i32 0, i32 1
  store float %208, ptr %210, align 4, !tbaa !29
  call void @llvm.lifetime.start.p0(i64 80, ptr %22) #7
  call void @b2DefaultBodyDef(ptr dead_on_unwind writable sret(%struct.b2BodyDef) align 8 %22)
  %211 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 0
  store i32 2, ptr %211, align 8, !tbaa !30
  %212 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 8
  store float 0x3FB99999A0000000, ptr %212, align 4, !tbaa !34
  %213 = load ptr, ptr %19, align 8, !tbaa !5
  %214 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 10
  store ptr %213, ptr %214, align 8, !tbaa !35
  call void @llvm.lifetime.start.p0(i64 80, ptr %23) #7
  call void @b2DefaultShapeDef(ptr dead_on_unwind writable sret(%struct.b2ShapeDef) align 8 %23)
  %215 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 1
  %216 = getelementptr inbounds %struct.b2SurfaceMaterial, ptr %215, i32 0, i32 0
  store float 0x3FC99999A0000000, ptr %216, align 8, !tbaa !36
  %217 = load i32, ptr %18, align 4, !tbaa !11
  %218 = sub nsw i32 0, %217
  %219 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 3
  %220 = getelementptr inbounds %struct.b2Filter, ptr %219, i32 0, i32 2
  store i32 %218, ptr %220, align 8, !tbaa !41
  %221 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 3
  %222 = getelementptr inbounds %struct.b2Filter, ptr %221, i32 0, i32 0
  store i64 2, ptr %222, align 8, !tbaa !42
  %223 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 3
  %224 = getelementptr inbounds %struct.b2Filter, ptr %223, i32 0, i32 1
  store i64 3, ptr %224, align 8, !tbaa !43
  call void @llvm.lifetime.start.p0(i64 80, ptr %24) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %24, ptr align 8 %23, i64 80, i1 false), !tbaa.struct !44
  %225 = getelementptr inbounds %struct.b2ShapeDef, ptr %24, i32 0, i32 1
  %226 = getelementptr inbounds %struct.b2SurfaceMaterial, ptr %225, i32 0, i32 0
  store float 0x3FA99999A0000000, ptr %226, align 8, !tbaa !36
  %227 = getelementptr inbounds %struct.b2ShapeDef, ptr %24, i32 0, i32 3
  %228 = getelementptr inbounds %struct.b2Filter, ptr %227, i32 0, i32 0
  store i64 2, ptr %228, align 8, !tbaa !42
  %229 = getelementptr inbounds %struct.b2ShapeDef, ptr %24, i32 0, i32 3
  %230 = getelementptr inbounds %struct.b2Filter, ptr %229, i32 0, i32 1
  store i64 1, ptr %230, align 8, !tbaa !43
  %231 = load i8, ptr %20, align 1, !tbaa !13, !range !17, !noundef !18
  %232 = trunc i8 %231 to i1
  br i1 %232, label %233, label %236

233:                                              ; preds = %207
  %234 = getelementptr inbounds %struct.b2ShapeDef, ptr %24, i32 0, i32 1
  %235 = getelementptr inbounds %struct.b2SurfaceMaterial, ptr %234, i32 0, i32 5
  store i32 9127187, ptr %235, align 4, !tbaa !46
  br label %236

236:                                              ; preds = %233, %207
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #7
  %237 = load float, ptr %14, align 4, !tbaa !9
  store float %237, ptr %25, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #7
  %238 = load float, ptr %15, align 4, !tbaa !9
  %239 = load float, ptr %25, align 4, !tbaa !9
  %240 = fmul float %238, %239
  store float %240, ptr %26, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 1, ptr %27) #7
  store i8 1, ptr %27, align 1, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 1, ptr %28) #7
  store i8 1, ptr %28, align 1, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #7
  store float 0x3FA99999A0000000, ptr %29, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #7
  store i32 4772300, ptr %30, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #7
  store i32 2003199, ptr %31, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 16, ptr %32) #7
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %32, ptr align 16 @__const.CreateHuman.skinColors, i64 16, i1 false)
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #7
  %241 = load i32, ptr %18, align 4, !tbaa !11
  %242 = srem i32 %241, 4
  %243 = sext i32 %242 to i64
  %244 = getelementptr inbounds [4 x i32], ptr %32, i64 0, i64 %243
  %245 = load i32, ptr %244, align 4, !tbaa !11
  store i32 %245, ptr %33, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #7
  %246 = load ptr, ptr %13, align 8, !tbaa !5
  %247 = getelementptr inbounds %struct.Human, ptr %246, i32 0, i32 0
  %248 = getelementptr inbounds [11 x %struct.Bone], ptr %247, i64 0, i64 0
  %249 = getelementptr inbounds %struct.Bone, ptr %248, i64 0
  store ptr %249, ptr %34, align 8, !tbaa !5
  %250 = load ptr, ptr %34, align 8, !tbaa !5
  %251 = getelementptr inbounds %struct.Bone, ptr %250, i32 0, i32 3
  store i32 -1, ptr %251, align 4, !tbaa !26
  %252 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #7
  %253 = getelementptr inbounds %struct.b2Vec2, ptr %36, i32 0, i32 0
  store float 0.000000e+00, ptr %253, align 4, !tbaa !47
  %254 = getelementptr inbounds %struct.b2Vec2, ptr %36, i32 0, i32 1
  %255 = load float, ptr %25, align 4, !tbaa !9
  %256 = fmul float 0x3FEE666660000000, %255
  store float %256, ptr %254, align 4, !tbaa !48
  %257 = load <2 x float>, ptr %36, align 4
  %258 = load <2 x float>, ptr %12, align 4
  %259 = call <2 x float> @b2Add(<2 x float> %257, <2 x float> %258)
  store <2 x float> %259, ptr %35, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %252, ptr align 4 %35, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #7
  %260 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 5
  store float 0.000000e+00, ptr %260, align 8, !tbaa !50
  %261 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 9
  store ptr @.str.2, ptr %261, align 8, !tbaa !51
  %262 = load ptr, ptr %34, align 8, !tbaa !5
  %263 = getelementptr inbounds %struct.Bone, ptr %262, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #7
  %264 = load i32, ptr %11, align 2
  %265 = call i64 @b2CreateBody(i32 %264, ptr noundef %22)
  store i64 %265, ptr %37, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %263, ptr align 4 %37, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #7
  %266 = load i8, ptr %20, align 1, !tbaa !13, !range !17, !noundef !18
  %267 = trunc i8 %266 to i1
  br i1 %267, label %268, label %272

268:                                              ; preds = %236
  %269 = load i32, ptr %31, align 4, !tbaa !11
  %270 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 1
  %271 = getelementptr inbounds %struct.b2SurfaceMaterial, ptr %270, i32 0, i32 5
  store i32 %269, ptr %271, align 4, !tbaa !46
  br label %272

272:                                              ; preds = %268, %236
  call void @llvm.lifetime.start.p0(i64 20, ptr %38) #7
  %273 = getelementptr inbounds %struct.b2Capsule, ptr %38, i32 0, i32 0
  %274 = getelementptr inbounds %struct.b2Vec2, ptr %273, i32 0, i32 0
  store float 0.000000e+00, ptr %274, align 4, !tbaa !47
  %275 = getelementptr inbounds %struct.b2Vec2, ptr %273, i32 0, i32 1
  %276 = load float, ptr %25, align 4, !tbaa !9
  %277 = fmul float 0xBF947AE140000000, %276
  store float %277, ptr %275, align 4, !tbaa !48
  %278 = getelementptr inbounds %struct.b2Capsule, ptr %38, i32 0, i32 1
  %279 = getelementptr inbounds %struct.b2Vec2, ptr %278, i32 0, i32 0
  store float 0.000000e+00, ptr %279, align 4, !tbaa !47
  %280 = getelementptr inbounds %struct.b2Vec2, ptr %278, i32 0, i32 1
  %281 = load float, ptr %25, align 4, !tbaa !9
  %282 = fmul float 0x3F947AE140000000, %281
  store float %282, ptr %280, align 4, !tbaa !48
  %283 = getelementptr inbounds %struct.b2Capsule, ptr %38, i32 0, i32 2
  %284 = load float, ptr %25, align 4, !tbaa !9
  %285 = fmul float 0x3FB851EB80000000, %284
  store float %285, ptr %283, align 4, !tbaa !52
  %286 = load ptr, ptr %34, align 8, !tbaa !5
  %287 = getelementptr inbounds %struct.Bone, ptr %286, i32 0, i32 0
  %288 = load i64, ptr %287, align 4
  %289 = call i64 @b2CreateCapsuleShape(i64 %288, ptr noundef %23, ptr noundef %38)
  store i64 %289, ptr %39, align 4
  call void @llvm.lifetime.end.p0(i64 20, ptr %38) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #7
  %290 = load ptr, ptr %13, align 8, !tbaa !5
  %291 = getelementptr inbounds %struct.Human, ptr %290, i32 0, i32 0
  %292 = getelementptr inbounds [11 x %struct.Bone], ptr %291, i64 0, i64 0
  %293 = getelementptr inbounds %struct.Bone, ptr %292, i64 1
  store ptr %293, ptr %40, align 8, !tbaa !5
  %294 = load ptr, ptr %40, align 8, !tbaa !5
  %295 = getelementptr inbounds %struct.Bone, ptr %294, i32 0, i32 3
  store i32 0, ptr %295, align 4, !tbaa !26
  %296 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %41) #7
  %297 = getelementptr inbounds %struct.b2Vec2, ptr %42, i32 0, i32 0
  store float 0.000000e+00, ptr %297, align 4, !tbaa !47
  %298 = getelementptr inbounds %struct.b2Vec2, ptr %42, i32 0, i32 1
  %299 = load float, ptr %25, align 4, !tbaa !9
  %300 = fmul float 0x3FF3333340000000, %299
  store float %300, ptr %298, align 4, !tbaa !48
  %301 = load <2 x float>, ptr %42, align 4
  %302 = load <2 x float>, ptr %12, align 4
  %303 = call <2 x float> @b2Add(<2 x float> %301, <2 x float> %302)
  store <2 x float> %303, ptr %41, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %296, ptr align 4 %41, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #7
  %304 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 5
  store float 0.000000e+00, ptr %304, align 8, !tbaa !50
  %305 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 9
  store ptr @.str.3, ptr %305, align 8, !tbaa !51
  %306 = load ptr, ptr %40, align 8, !tbaa !5
  %307 = getelementptr inbounds %struct.Bone, ptr %306, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %43) #7
  %308 = load i32, ptr %11, align 2
  %309 = call i64 @b2CreateBody(i32 %308, ptr noundef %22)
  store i64 %309, ptr %43, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %307, ptr align 4 %43, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %43) #7
  %310 = load ptr, ptr %40, align 8, !tbaa !5
  %311 = getelementptr inbounds %struct.Bone, ptr %310, i32 0, i32 2
  store float 5.000000e-01, ptr %311, align 4, !tbaa !22
  %312 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 0
  store i32 2, ptr %312, align 8, !tbaa !30
  %313 = load i8, ptr %20, align 1, !tbaa !13, !range !17, !noundef !18
  %314 = trunc i8 %313 to i1
  br i1 %314, label %315, label %319

315:                                              ; preds = %272
  %316 = load i32, ptr %30, align 4, !tbaa !11
  %317 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 1
  %318 = getelementptr inbounds %struct.b2SurfaceMaterial, ptr %317, i32 0, i32 5
  store i32 %316, ptr %318, align 4, !tbaa !46
  br label %319

319:                                              ; preds = %315, %272
  call void @llvm.lifetime.start.p0(i64 20, ptr %44) #7
  %320 = getelementptr inbounds %struct.b2Capsule, ptr %44, i32 0, i32 0
  %321 = getelementptr inbounds %struct.b2Vec2, ptr %320, i32 0, i32 0
  store float 0.000000e+00, ptr %321, align 4, !tbaa !47
  %322 = getelementptr inbounds %struct.b2Vec2, ptr %320, i32 0, i32 1
  %323 = load float, ptr %25, align 4, !tbaa !9
  %324 = fmul float 0xBFC147AE20000000, %323
  store float %324, ptr %322, align 4, !tbaa !48
  %325 = getelementptr inbounds %struct.b2Capsule, ptr %44, i32 0, i32 1
  %326 = getelementptr inbounds %struct.b2Vec2, ptr %325, i32 0, i32 0
  store float 0.000000e+00, ptr %326, align 4, !tbaa !47
  %327 = getelementptr inbounds %struct.b2Vec2, ptr %325, i32 0, i32 1
  %328 = load float, ptr %25, align 4, !tbaa !9
  %329 = fmul float 0x3FC147AE20000000, %328
  store float %329, ptr %327, align 4, !tbaa !48
  %330 = getelementptr inbounds %struct.b2Capsule, ptr %44, i32 0, i32 2
  %331 = load float, ptr %25, align 4, !tbaa !9
  %332 = fmul float 0x3FB70A3D80000000, %331
  store float %332, ptr %330, align 4, !tbaa !52
  %333 = load ptr, ptr %40, align 8, !tbaa !5
  %334 = getelementptr inbounds %struct.Bone, ptr %333, i32 0, i32 0
  %335 = load i64, ptr %334, align 4
  %336 = call i64 @b2CreateCapsuleShape(i64 %335, ptr noundef %23, ptr noundef %44)
  store i64 %336, ptr %45, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #7
  %337 = getelementptr inbounds %struct.b2Vec2, ptr %47, i32 0, i32 0
  store float 0.000000e+00, ptr %337, align 4, !tbaa !47
  %338 = getelementptr inbounds %struct.b2Vec2, ptr %47, i32 0, i32 1
  %339 = load float, ptr %25, align 4, !tbaa !9
  %340 = fmul float 1.000000e+00, %339
  store float %340, ptr %338, align 4, !tbaa !48
  %341 = load <2 x float>, ptr %47, align 4
  %342 = load <2 x float>, ptr %12, align 4
  %343 = call <2 x float> @b2Add(<2 x float> %341, <2 x float> %342)
  store <2 x float> %343, ptr %46, align 4
  call void @llvm.lifetime.start.p0(i64 96, ptr %48) #7
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind writable sret(%struct.b2RevoluteJointDef) align 8 %48)
  %344 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 0
  %345 = load ptr, ptr %13, align 8, !tbaa !5
  %346 = getelementptr inbounds %struct.Human, ptr %345, i32 0, i32 0
  %347 = load ptr, ptr %40, align 8, !tbaa !5
  %348 = getelementptr inbounds %struct.Bone, ptr %347, i32 0, i32 3
  %349 = load i32, ptr %348, align 4, !tbaa !26
  %350 = sext i32 %349 to i64
  %351 = getelementptr inbounds [11 x %struct.Bone], ptr %346, i64 0, i64 %350
  %352 = getelementptr inbounds %struct.Bone, ptr %351, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %344, ptr align 4 %352, i64 8, i1 false), !tbaa.struct !19
  %353 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 1
  %354 = load ptr, ptr %40, align 8, !tbaa !5
  %355 = getelementptr inbounds %struct.Bone, ptr %354, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %353, ptr align 4 %355, i64 8, i1 false), !tbaa.struct !19
  %356 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %49) #7
  %357 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 0
  %358 = load i64, ptr %357, align 8
  %359 = load <2 x float>, ptr %46, align 4
  %360 = call <2 x float> @b2Body_GetLocalPoint(i64 %358, <2 x float> %359)
  store <2 x float> %360, ptr %49, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %356, ptr align 4 %49, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %49) #7
  %361 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 3
  call void @llvm.lifetime.start.p0(i64 8, ptr %50) #7
  %362 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 1
  %363 = load i64, ptr %362, align 8
  %364 = load <2 x float>, ptr %46, align 4
  %365 = call <2 x float> @b2Body_GetLocalPoint(i64 %363, <2 x float> %364)
  store <2 x float> %365, ptr %50, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %361, ptr align 4 %50, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %50) #7
  %366 = load i8, ptr %28, align 1, !tbaa !13, !range !17, !noundef !18
  %367 = trunc i8 %366 to i1
  %368 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 8
  %369 = zext i1 %367 to i8
  store i8 %369, ptr %368, align 8, !tbaa !54
  %370 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 9
  store float 0xBFE921FB60000000, ptr %370, align 4, !tbaa !56
  %371 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 10
  store float 0.000000e+00, ptr %371, align 8, !tbaa !57
  %372 = load i8, ptr %27, align 1, !tbaa !13, !range !17, !noundef !18
  %373 = trunc i8 %372 to i1
  %374 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 11
  %375 = zext i1 %373 to i8
  store i8 %375, ptr %374, align 4, !tbaa !58
  %376 = load ptr, ptr %40, align 8, !tbaa !5
  %377 = getelementptr inbounds %struct.Bone, ptr %376, i32 0, i32 2
  %378 = load float, ptr %377, align 4, !tbaa !22
  %379 = load float, ptr %26, align 4, !tbaa !9
  %380 = fmul float %378, %379
  %381 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 12
  store float %380, ptr %381, align 8, !tbaa !59
  %382 = load float, ptr %16, align 4, !tbaa !9
  %383 = fcmp ogt float %382, 0.000000e+00
  %384 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 5
  %385 = zext i1 %383 to i8
  store i8 %385, ptr %384, align 4, !tbaa !60
  %386 = load float, ptr %16, align 4, !tbaa !9
  %387 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 6
  store float %386, ptr %387, align 8, !tbaa !61
  %388 = load float, ptr %17, align 4, !tbaa !9
  %389 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 7
  store float %388, ptr %389, align 4, !tbaa !62
  %390 = load float, ptr %29, align 4, !tbaa !9
  %391 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %48, i32 0, i32 14
  store float %390, ptr %391, align 8, !tbaa !63
  %392 = load ptr, ptr %40, align 8, !tbaa !5
  %393 = getelementptr inbounds %struct.Bone, ptr %392, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %51) #7
  %394 = load i32, ptr %11, align 2
  %395 = call i64 @b2CreateRevoluteJoint(i32 %394, ptr noundef %48)
  store i64 %395, ptr %51, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %393, ptr align 4 %51, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %51) #7
  call void @llvm.lifetime.end.p0(i64 96, ptr %48) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #7
  call void @llvm.lifetime.end.p0(i64 20, ptr %44) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %52) #7
  %396 = load ptr, ptr %13, align 8, !tbaa !5
  %397 = getelementptr inbounds %struct.Human, ptr %396, i32 0, i32 0
  %398 = getelementptr inbounds [11 x %struct.Bone], ptr %397, i64 0, i64 0
  %399 = getelementptr inbounds %struct.Bone, ptr %398, i64 2
  store ptr %399, ptr %52, align 8, !tbaa !5
  %400 = load ptr, ptr %52, align 8, !tbaa !5
  %401 = getelementptr inbounds %struct.Bone, ptr %400, i32 0, i32 3
  store i32 1, ptr %401, align 4, !tbaa !26
  %402 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %53) #7
  %403 = getelementptr inbounds %struct.b2Vec2, ptr %54, i32 0, i32 0
  %404 = load float, ptr %25, align 4, !tbaa !9
  %405 = fmul float 0.000000e+00, %404
  store float %405, ptr %403, align 4, !tbaa !47
  %406 = getelementptr inbounds %struct.b2Vec2, ptr %54, i32 0, i32 1
  %407 = load float, ptr %25, align 4, !tbaa !9
  %408 = fmul float 0x3FF79999A0000000, %407
  store float %408, ptr %406, align 4, !tbaa !48
  %409 = load <2 x float>, ptr %54, align 4
  %410 = load <2 x float>, ptr %12, align 4
  %411 = call <2 x float> @b2Add(<2 x float> %409, <2 x float> %410)
  store <2 x float> %411, ptr %53, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %402, ptr align 4 %53, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %53) #7
  %412 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 5
  store float 0x3FB99999A0000000, ptr %412, align 8, !tbaa !50
  %413 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 9
  store ptr @.str.4, ptr %413, align 8, !tbaa !51
  %414 = load ptr, ptr %52, align 8, !tbaa !5
  %415 = getelementptr inbounds %struct.Bone, ptr %414, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %55) #7
  %416 = load i32, ptr %11, align 2
  %417 = call i64 @b2CreateBody(i32 %416, ptr noundef %22)
  store i64 %417, ptr %55, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %415, ptr align 4 %55, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %55) #7
  %418 = load ptr, ptr %52, align 8, !tbaa !5
  %419 = getelementptr inbounds %struct.Bone, ptr %418, i32 0, i32 2
  store float 2.500000e-01, ptr %419, align 4, !tbaa !22
  %420 = load i8, ptr %20, align 1, !tbaa !13, !range !17, !noundef !18
  %421 = trunc i8 %420 to i1
  br i1 %421, label %422, label %426

422:                                              ; preds = %319
  %423 = load i32, ptr %33, align 4, !tbaa !11
  %424 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 1
  %425 = getelementptr inbounds %struct.b2SurfaceMaterial, ptr %424, i32 0, i32 5
  store i32 %423, ptr %425, align 4, !tbaa !46
  br label %426

426:                                              ; preds = %422, %319
  call void @llvm.lifetime.start.p0(i64 20, ptr %56) #7
  %427 = getelementptr inbounds %struct.b2Capsule, ptr %56, i32 0, i32 0
  %428 = getelementptr inbounds %struct.b2Vec2, ptr %427, i32 0, i32 0
  store float 0.000000e+00, ptr %428, align 4, !tbaa !47
  %429 = getelementptr inbounds %struct.b2Vec2, ptr %427, i32 0, i32 1
  %430 = load float, ptr %25, align 4, !tbaa !9
  %431 = fmul float 0xBFA374BC60000000, %430
  store float %431, ptr %429, align 4, !tbaa !48
  %432 = getelementptr inbounds %struct.b2Capsule, ptr %56, i32 0, i32 1
  %433 = getelementptr inbounds %struct.b2Vec2, ptr %432, i32 0, i32 0
  store float 0.000000e+00, ptr %433, align 4, !tbaa !47
  %434 = getelementptr inbounds %struct.b2Vec2, ptr %432, i32 0, i32 1
  %435 = load float, ptr %25, align 4, !tbaa !9
  %436 = fmul float 0x3FA3F7CEE0000000, %435
  store float %436, ptr %434, align 4, !tbaa !48
  %437 = getelementptr inbounds %struct.b2Capsule, ptr %56, i32 0, i32 2
  %438 = load float, ptr %25, align 4, !tbaa !9
  %439 = fmul float 0x3FB3333340000000, %438
  store float %439, ptr %437, align 4, !tbaa !52
  %440 = load ptr, ptr %52, align 8, !tbaa !5
  %441 = getelementptr inbounds %struct.Bone, ptr %440, i32 0, i32 0
  %442 = load i64, ptr %441, align 4
  %443 = call i64 @b2CreateCapsuleShape(i64 %442, ptr noundef %23, ptr noundef %56)
  store i64 %443, ptr %57, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %58) #7
  %444 = getelementptr inbounds %struct.b2Vec2, ptr %59, i32 0, i32 0
  store float 0.000000e+00, ptr %444, align 4, !tbaa !47
  %445 = getelementptr inbounds %struct.b2Vec2, ptr %59, i32 0, i32 1
  %446 = load float, ptr %25, align 4, !tbaa !9
  %447 = fmul float 0x3FF6666660000000, %446
  store float %447, ptr %445, align 4, !tbaa !48
  %448 = load <2 x float>, ptr %59, align 4
  %449 = load <2 x float>, ptr %12, align 4
  %450 = call <2 x float> @b2Add(<2 x float> %448, <2 x float> %449)
  store <2 x float> %450, ptr %58, align 4
  call void @llvm.lifetime.start.p0(i64 96, ptr %60) #7
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind writable sret(%struct.b2RevoluteJointDef) align 8 %60)
  %451 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 0
  %452 = load ptr, ptr %13, align 8, !tbaa !5
  %453 = getelementptr inbounds %struct.Human, ptr %452, i32 0, i32 0
  %454 = load ptr, ptr %52, align 8, !tbaa !5
  %455 = getelementptr inbounds %struct.Bone, ptr %454, i32 0, i32 3
  %456 = load i32, ptr %455, align 4, !tbaa !26
  %457 = sext i32 %456 to i64
  %458 = getelementptr inbounds [11 x %struct.Bone], ptr %453, i64 0, i64 %457
  %459 = getelementptr inbounds %struct.Bone, ptr %458, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %451, ptr align 4 %459, i64 8, i1 false), !tbaa.struct !19
  %460 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 1
  %461 = load ptr, ptr %52, align 8, !tbaa !5
  %462 = getelementptr inbounds %struct.Bone, ptr %461, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %460, ptr align 4 %462, i64 8, i1 false), !tbaa.struct !19
  %463 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %61) #7
  %464 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 0
  %465 = load i64, ptr %464, align 8
  %466 = load <2 x float>, ptr %58, align 4
  %467 = call <2 x float> @b2Body_GetLocalPoint(i64 %465, <2 x float> %466)
  store <2 x float> %467, ptr %61, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %463, ptr align 4 %61, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %61) #7
  %468 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 3
  call void @llvm.lifetime.start.p0(i64 8, ptr %62) #7
  %469 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 1
  %470 = load i64, ptr %469, align 8
  %471 = load <2 x float>, ptr %58, align 4
  %472 = call <2 x float> @b2Body_GetLocalPoint(i64 %470, <2 x float> %471)
  store <2 x float> %472, ptr %62, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %468, ptr align 4 %62, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %62) #7
  %473 = load i8, ptr %28, align 1, !tbaa !13, !range !17, !noundef !18
  %474 = trunc i8 %473 to i1
  %475 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 8
  %476 = zext i1 %474 to i8
  store i8 %476, ptr %475, align 8, !tbaa !54
  %477 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 9
  store float 0xBFEE28C760000000, ptr %477, align 4, !tbaa !56
  %478 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 10
  store float 0x3FD41B2F80000000, ptr %478, align 8, !tbaa !57
  %479 = load i8, ptr %27, align 1, !tbaa !13, !range !17, !noundef !18
  %480 = trunc i8 %479 to i1
  %481 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 11
  %482 = zext i1 %480 to i8
  store i8 %482, ptr %481, align 4, !tbaa !58
  %483 = load ptr, ptr %52, align 8, !tbaa !5
  %484 = getelementptr inbounds %struct.Bone, ptr %483, i32 0, i32 2
  %485 = load float, ptr %484, align 4, !tbaa !22
  %486 = load float, ptr %26, align 4, !tbaa !9
  %487 = fmul float %485, %486
  %488 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 12
  store float %487, ptr %488, align 8, !tbaa !59
  %489 = load float, ptr %16, align 4, !tbaa !9
  %490 = fcmp ogt float %489, 0.000000e+00
  %491 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 5
  %492 = zext i1 %490 to i8
  store i8 %492, ptr %491, align 4, !tbaa !60
  %493 = load float, ptr %16, align 4, !tbaa !9
  %494 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 6
  store float %493, ptr %494, align 8, !tbaa !61
  %495 = load float, ptr %17, align 4, !tbaa !9
  %496 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 7
  store float %495, ptr %496, align 4, !tbaa !62
  %497 = load float, ptr %29, align 4, !tbaa !9
  %498 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %60, i32 0, i32 14
  store float %497, ptr %498, align 8, !tbaa !63
  %499 = load ptr, ptr %52, align 8, !tbaa !5
  %500 = getelementptr inbounds %struct.Bone, ptr %499, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %63) #7
  %501 = load i32, ptr %11, align 2
  %502 = call i64 @b2CreateRevoluteJoint(i32 %501, ptr noundef %60)
  store i64 %502, ptr %63, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %500, ptr align 4 %63, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %63) #7
  call void @llvm.lifetime.end.p0(i64 96, ptr %60) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %58) #7
  call void @llvm.lifetime.end.p0(i64 20, ptr %56) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %52) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %64) #7
  %503 = load ptr, ptr %13, align 8, !tbaa !5
  %504 = getelementptr inbounds %struct.Human, ptr %503, i32 0, i32 0
  %505 = getelementptr inbounds [11 x %struct.Bone], ptr %504, i64 0, i64 0
  %506 = getelementptr inbounds %struct.Bone, ptr %505, i64 3
  store ptr %506, ptr %64, align 8, !tbaa !5
  %507 = load ptr, ptr %64, align 8, !tbaa !5
  %508 = getelementptr inbounds %struct.Bone, ptr %507, i32 0, i32 3
  store i32 0, ptr %508, align 4, !tbaa !26
  %509 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %65) #7
  %510 = getelementptr inbounds %struct.b2Vec2, ptr %66, i32 0, i32 0
  store float 0.000000e+00, ptr %510, align 4, !tbaa !47
  %511 = getelementptr inbounds %struct.b2Vec2, ptr %66, i32 0, i32 1
  %512 = load float, ptr %25, align 4, !tbaa !9
  %513 = fmul float 0x3FE8CCCCC0000000, %512
  store float %513, ptr %511, align 4, !tbaa !48
  %514 = load <2 x float>, ptr %66, align 4
  %515 = load <2 x float>, ptr %12, align 4
  %516 = call <2 x float> @b2Add(<2 x float> %514, <2 x float> %515)
  store <2 x float> %516, ptr %65, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %509, ptr align 4 %65, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %65) #7
  %517 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 5
  store float 0.000000e+00, ptr %517, align 8, !tbaa !50
  %518 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 9
  store ptr @.str.5, ptr %518, align 8, !tbaa !51
  %519 = load ptr, ptr %64, align 8, !tbaa !5
  %520 = getelementptr inbounds %struct.Bone, ptr %519, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %67) #7
  %521 = load i32, ptr %11, align 2
  %522 = call i64 @b2CreateBody(i32 %521, ptr noundef %22)
  store i64 %522, ptr %67, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %520, ptr align 4 %67, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %67) #7
  %523 = load ptr, ptr %64, align 8, !tbaa !5
  %524 = getelementptr inbounds %struct.Bone, ptr %523, i32 0, i32 2
  store float 1.000000e+00, ptr %524, align 4, !tbaa !22
  %525 = load i8, ptr %20, align 1, !tbaa !13, !range !17, !noundef !18
  %526 = trunc i8 %525 to i1
  br i1 %526, label %527, label %531

527:                                              ; preds = %426
  %528 = load i32, ptr %31, align 4, !tbaa !11
  %529 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 1
  %530 = getelementptr inbounds %struct.b2SurfaceMaterial, ptr %529, i32 0, i32 5
  store i32 %528, ptr %530, align 4, !tbaa !46
  br label %531

531:                                              ; preds = %527, %426
  call void @llvm.lifetime.start.p0(i64 20, ptr %68) #7
  %532 = getelementptr inbounds %struct.b2Capsule, ptr %68, i32 0, i32 0
  %533 = getelementptr inbounds %struct.b2Vec2, ptr %532, i32 0, i32 0
  store float 0.000000e+00, ptr %533, align 4, !tbaa !47
  %534 = getelementptr inbounds %struct.b2Vec2, ptr %532, i32 0, i32 1
  %535 = load float, ptr %25, align 4, !tbaa !9
  %536 = fmul float -1.250000e-01, %535
  store float %536, ptr %534, align 4, !tbaa !48
  %537 = getelementptr inbounds %struct.b2Capsule, ptr %68, i32 0, i32 1
  %538 = getelementptr inbounds %struct.b2Vec2, ptr %537, i32 0, i32 0
  store float 0.000000e+00, ptr %538, align 4, !tbaa !47
  %539 = getelementptr inbounds %struct.b2Vec2, ptr %537, i32 0, i32 1
  %540 = load float, ptr %25, align 4, !tbaa !9
  %541 = fmul float 1.250000e-01, %540
  store float %541, ptr %539, align 4, !tbaa !48
  %542 = getelementptr inbounds %struct.b2Capsule, ptr %68, i32 0, i32 2
  %543 = load float, ptr %25, align 4, !tbaa !9
  %544 = fmul float 0x3FAEB851E0000000, %543
  store float %544, ptr %542, align 4, !tbaa !52
  %545 = load ptr, ptr %64, align 8, !tbaa !5
  %546 = getelementptr inbounds %struct.Bone, ptr %545, i32 0, i32 0
  %547 = load i64, ptr %546, align 4
  %548 = call i64 @b2CreateCapsuleShape(i64 %547, ptr noundef %23, ptr noundef %68)
  store i64 %548, ptr %69, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %70) #7
  %549 = getelementptr inbounds %struct.b2Vec2, ptr %71, i32 0, i32 0
  store float 0.000000e+00, ptr %549, align 4, !tbaa !47
  %550 = getelementptr inbounds %struct.b2Vec2, ptr %71, i32 0, i32 1
  %551 = load float, ptr %25, align 4, !tbaa !9
  %552 = fmul float 0x3FECCCCCC0000000, %551
  store float %552, ptr %550, align 4, !tbaa !48
  %553 = load <2 x float>, ptr %71, align 4
  %554 = load <2 x float>, ptr %12, align 4
  %555 = call <2 x float> @b2Add(<2 x float> %553, <2 x float> %554)
  store <2 x float> %555, ptr %70, align 4
  call void @llvm.lifetime.start.p0(i64 96, ptr %72) #7
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind writable sret(%struct.b2RevoluteJointDef) align 8 %72)
  %556 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 0
  %557 = load ptr, ptr %13, align 8, !tbaa !5
  %558 = getelementptr inbounds %struct.Human, ptr %557, i32 0, i32 0
  %559 = load ptr, ptr %64, align 8, !tbaa !5
  %560 = getelementptr inbounds %struct.Bone, ptr %559, i32 0, i32 3
  %561 = load i32, ptr %560, align 4, !tbaa !26
  %562 = sext i32 %561 to i64
  %563 = getelementptr inbounds [11 x %struct.Bone], ptr %558, i64 0, i64 %562
  %564 = getelementptr inbounds %struct.Bone, ptr %563, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %556, ptr align 4 %564, i64 8, i1 false), !tbaa.struct !19
  %565 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 1
  %566 = load ptr, ptr %64, align 8, !tbaa !5
  %567 = getelementptr inbounds %struct.Bone, ptr %566, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %565, ptr align 4 %567, i64 8, i1 false), !tbaa.struct !19
  %568 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %73) #7
  %569 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 0
  %570 = load i64, ptr %569, align 8
  %571 = load <2 x float>, ptr %70, align 4
  %572 = call <2 x float> @b2Body_GetLocalPoint(i64 %570, <2 x float> %571)
  store <2 x float> %572, ptr %73, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %568, ptr align 4 %73, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %73) #7
  %573 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 3
  call void @llvm.lifetime.start.p0(i64 8, ptr %74) #7
  %574 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 1
  %575 = load i64, ptr %574, align 8
  %576 = load <2 x float>, ptr %70, align 4
  %577 = call <2 x float> @b2Body_GetLocalPoint(i64 %575, <2 x float> %576)
  store <2 x float> %577, ptr %74, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %573, ptr align 4 %74, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %74) #7
  %578 = load i8, ptr %28, align 1, !tbaa !13, !range !17, !noundef !18
  %579 = trunc i8 %578 to i1
  %580 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 8
  %581 = zext i1 %579 to i8
  store i8 %581, ptr %580, align 8, !tbaa !54
  %582 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 9
  store float 0xBFC41B2F80000000, ptr %582, align 4, !tbaa !56
  %583 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 10
  store float 0x3FF41B2F80000000, ptr %583, align 8, !tbaa !57
  %584 = load i8, ptr %27, align 1, !tbaa !13, !range !17, !noundef !18
  %585 = trunc i8 %584 to i1
  %586 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 11
  %587 = zext i1 %585 to i8
  store i8 %587, ptr %586, align 4, !tbaa !58
  %588 = load ptr, ptr %64, align 8, !tbaa !5
  %589 = getelementptr inbounds %struct.Bone, ptr %588, i32 0, i32 2
  %590 = load float, ptr %589, align 4, !tbaa !22
  %591 = load float, ptr %26, align 4, !tbaa !9
  %592 = fmul float %590, %591
  %593 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 12
  store float %592, ptr %593, align 8, !tbaa !59
  %594 = load float, ptr %16, align 4, !tbaa !9
  %595 = fcmp ogt float %594, 0.000000e+00
  %596 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 5
  %597 = zext i1 %595 to i8
  store i8 %597, ptr %596, align 4, !tbaa !60
  %598 = load float, ptr %16, align 4, !tbaa !9
  %599 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 6
  store float %598, ptr %599, align 8, !tbaa !61
  %600 = load float, ptr %17, align 4, !tbaa !9
  %601 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 7
  store float %600, ptr %601, align 4, !tbaa !62
  %602 = load float, ptr %29, align 4, !tbaa !9
  %603 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %72, i32 0, i32 14
  store float %602, ptr %603, align 8, !tbaa !63
  %604 = load ptr, ptr %64, align 8, !tbaa !5
  %605 = getelementptr inbounds %struct.Bone, ptr %604, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %75) #7
  %606 = load i32, ptr %11, align 2
  %607 = call i64 @b2CreateRevoluteJoint(i32 %606, ptr noundef %72)
  store i64 %607, ptr %75, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %605, ptr align 4 %75, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %75) #7
  call void @llvm.lifetime.end.p0(i64 96, ptr %72) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %70) #7
  call void @llvm.lifetime.end.p0(i64 20, ptr %68) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %64) #7
  call void @llvm.lifetime.start.p0(i64 32, ptr %76) #7
  %608 = getelementptr inbounds %struct.b2Vec2, ptr %76, i32 0, i32 0
  %609 = load float, ptr %25, align 4, !tbaa !9
  %610 = fmul float 0xBF9EB851E0000000, %609
  store float %610, ptr %608, align 8, !tbaa !47
  %611 = getelementptr inbounds %struct.b2Vec2, ptr %76, i32 0, i32 1
  %612 = load float, ptr %25, align 4, !tbaa !9
  %613 = fmul float 0xBFC7AE1480000000, %612
  store float %613, ptr %611, align 4, !tbaa !48
  %614 = getelementptr inbounds %struct.b2Vec2, ptr %76, i64 1
  %615 = getelementptr inbounds %struct.b2Vec2, ptr %614, i32 0, i32 0
  %616 = load float, ptr %25, align 4, !tbaa !9
  %617 = fmul float 0x3FBC28F5C0000000, %616
  store float %617, ptr %615, align 8, !tbaa !47
  %618 = getelementptr inbounds %struct.b2Vec2, ptr %614, i32 0, i32 1
  %619 = load float, ptr %25, align 4, !tbaa !9
  %620 = fmul float 0xBFC7AE1480000000, %619
  store float %620, ptr %618, align 4, !tbaa !48
  %621 = getelementptr inbounds %struct.b2Vec2, ptr %76, i64 2
  %622 = getelementptr inbounds %struct.b2Vec2, ptr %621, i32 0, i32 0
  %623 = load float, ptr %25, align 4, !tbaa !9
  %624 = fmul float 0x3FBC28F5C0000000, %623
  store float %624, ptr %622, align 8, !tbaa !47
  %625 = getelementptr inbounds %struct.b2Vec2, ptr %621, i32 0, i32 1
  %626 = load float, ptr %25, align 4, !tbaa !9
  %627 = fmul float 0xBFC47AE140000000, %626
  store float %627, ptr %625, align 4, !tbaa !48
  %628 = getelementptr inbounds %struct.b2Vec2, ptr %76, i64 3
  %629 = getelementptr inbounds %struct.b2Vec2, ptr %628, i32 0, i32 0
  %630 = load float, ptr %25, align 4, !tbaa !9
  %631 = fmul float 0xBF9EB851E0000000, %630
  store float %631, ptr %629, align 8, !tbaa !47
  %632 = getelementptr inbounds %struct.b2Vec2, ptr %628, i32 0, i32 1
  %633 = load float, ptr %25, align 4, !tbaa !9
  %634 = fmul float 0xBFC1EB8520000000, %633
  store float %634, ptr %632, align 4, !tbaa !48
  call void @llvm.lifetime.start.p0(i64 68, ptr %77) #7
  %635 = getelementptr inbounds [4 x %struct.b2Vec2], ptr %76, i64 0, i64 0
  call void @b2ComputeHull(ptr dead_on_unwind writable sret(%struct.b2Hull) align 4 %77, ptr noundef %635, i32 noundef 4)
  call void @llvm.lifetime.start.p0(i64 144, ptr %78) #7
  %636 = load float, ptr %25, align 4, !tbaa !9
  %637 = fmul float 0x3F8EB851E0000000, %636
  call void @b2MakePolygon(ptr dead_on_unwind writable sret(%struct.b2Polygon) align 4 %78, ptr noundef %77, float noundef %637)
  call void @llvm.lifetime.start.p0(i64 8, ptr %79) #7
  %638 = load ptr, ptr %13, align 8, !tbaa !5
  %639 = getelementptr inbounds %struct.Human, ptr %638, i32 0, i32 0
  %640 = getelementptr inbounds [11 x %struct.Bone], ptr %639, i64 0, i64 0
  %641 = getelementptr inbounds %struct.Bone, ptr %640, i64 4
  store ptr %641, ptr %79, align 8, !tbaa !5
  %642 = load ptr, ptr %79, align 8, !tbaa !5
  %643 = getelementptr inbounds %struct.Bone, ptr %642, i32 0, i32 3
  store i32 3, ptr %643, align 4, !tbaa !26
  %644 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %80) #7
  %645 = getelementptr inbounds %struct.b2Vec2, ptr %81, i32 0, i32 0
  store float 0.000000e+00, ptr %645, align 4, !tbaa !47
  %646 = getelementptr inbounds %struct.b2Vec2, ptr %81, i32 0, i32 1
  %647 = load float, ptr %25, align 4, !tbaa !9
  %648 = fmul float 0x3FDE666660000000, %647
  store float %648, ptr %646, align 4, !tbaa !48
  %649 = load <2 x float>, ptr %81, align 4
  %650 = load <2 x float>, ptr %12, align 4
  %651 = call <2 x float> @b2Add(<2 x float> %649, <2 x float> %650)
  store <2 x float> %651, ptr %80, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %644, ptr align 4 %80, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %80) #7
  %652 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 5
  store float 0.000000e+00, ptr %652, align 8, !tbaa !50
  %653 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 9
  store ptr @.str.6, ptr %653, align 8, !tbaa !51
  %654 = load ptr, ptr %79, align 8, !tbaa !5
  %655 = getelementptr inbounds %struct.Bone, ptr %654, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %82) #7
  %656 = load i32, ptr %11, align 2
  %657 = call i64 @b2CreateBody(i32 %656, ptr noundef %22)
  store i64 %657, ptr %82, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %655, ptr align 4 %82, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %82) #7
  %658 = load ptr, ptr %79, align 8, !tbaa !5
  %659 = getelementptr inbounds %struct.Bone, ptr %658, i32 0, i32 2
  store float 5.000000e-01, ptr %659, align 4, !tbaa !22
  %660 = load i8, ptr %20, align 1, !tbaa !13, !range !17, !noundef !18
  %661 = trunc i8 %660 to i1
  br i1 %661, label %662, label %666

662:                                              ; preds = %531
  %663 = load i32, ptr %31, align 4, !tbaa !11
  %664 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 1
  %665 = getelementptr inbounds %struct.b2SurfaceMaterial, ptr %664, i32 0, i32 5
  store i32 %663, ptr %665, align 4, !tbaa !46
  br label %666

666:                                              ; preds = %662, %531
  call void @llvm.lifetime.start.p0(i64 20, ptr %83) #7
  %667 = getelementptr inbounds %struct.b2Capsule, ptr %83, i32 0, i32 0
  %668 = getelementptr inbounds %struct.b2Vec2, ptr %667, i32 0, i32 0
  store float 0.000000e+00, ptr %668, align 4, !tbaa !47
  %669 = getelementptr inbounds %struct.b2Vec2, ptr %667, i32 0, i32 1
  %670 = load float, ptr %25, align 4, !tbaa !9
  %671 = fmul float 0xBFC3D70A40000000, %670
  store float %671, ptr %669, align 4, !tbaa !48
  %672 = getelementptr inbounds %struct.b2Capsule, ptr %83, i32 0, i32 1
  %673 = getelementptr inbounds %struct.b2Vec2, ptr %672, i32 0, i32 0
  store float 0.000000e+00, ptr %673, align 4, !tbaa !47
  %674 = getelementptr inbounds %struct.b2Vec2, ptr %672, i32 0, i32 1
  %675 = load float, ptr %25, align 4, !tbaa !9
  %676 = fmul float 1.250000e-01, %675
  store float %676, ptr %674, align 4, !tbaa !48
  %677 = getelementptr inbounds %struct.b2Capsule, ptr %83, i32 0, i32 2
  %678 = load float, ptr %25, align 4, !tbaa !9
  %679 = fmul float 0x3FA70A3D80000000, %678
  store float %679, ptr %677, align 4, !tbaa !52
  %680 = load ptr, ptr %79, align 8, !tbaa !5
  %681 = getelementptr inbounds %struct.Bone, ptr %680, i32 0, i32 0
  %682 = load i64, ptr %681, align 4
  %683 = call i64 @b2CreateCapsuleShape(i64 %682, ptr noundef %23, ptr noundef %83)
  store i64 %683, ptr %84, align 4
  %684 = load ptr, ptr %79, align 8, !tbaa !5
  %685 = getelementptr inbounds %struct.Bone, ptr %684, i32 0, i32 0
  %686 = load i64, ptr %685, align 4
  %687 = call i64 @b2CreatePolygonShape(i64 %686, ptr noundef %24, ptr noundef %78)
  store i64 %687, ptr %85, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %86) #7
  %688 = getelementptr inbounds %struct.b2Vec2, ptr %87, i32 0, i32 0
  store float 0.000000e+00, ptr %688, align 4, !tbaa !47
  %689 = getelementptr inbounds %struct.b2Vec2, ptr %87, i32 0, i32 1
  %690 = load float, ptr %25, align 4, !tbaa !9
  %691 = fmul float 6.250000e-01, %690
  store float %691, ptr %689, align 4, !tbaa !48
  %692 = load <2 x float>, ptr %87, align 4
  %693 = load <2 x float>, ptr %12, align 4
  %694 = call <2 x float> @b2Add(<2 x float> %692, <2 x float> %693)
  store <2 x float> %694, ptr %86, align 4
  call void @llvm.lifetime.start.p0(i64 96, ptr %88) #7
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind writable sret(%struct.b2RevoluteJointDef) align 8 %88)
  %695 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 0
  %696 = load ptr, ptr %13, align 8, !tbaa !5
  %697 = getelementptr inbounds %struct.Human, ptr %696, i32 0, i32 0
  %698 = load ptr, ptr %79, align 8, !tbaa !5
  %699 = getelementptr inbounds %struct.Bone, ptr %698, i32 0, i32 3
  %700 = load i32, ptr %699, align 4, !tbaa !26
  %701 = sext i32 %700 to i64
  %702 = getelementptr inbounds [11 x %struct.Bone], ptr %697, i64 0, i64 %701
  %703 = getelementptr inbounds %struct.Bone, ptr %702, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %695, ptr align 4 %703, i64 8, i1 false), !tbaa.struct !19
  %704 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 1
  %705 = load ptr, ptr %79, align 8, !tbaa !5
  %706 = getelementptr inbounds %struct.Bone, ptr %705, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %704, ptr align 4 %706, i64 8, i1 false), !tbaa.struct !19
  %707 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %89) #7
  %708 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 0
  %709 = load i64, ptr %708, align 8
  %710 = load <2 x float>, ptr %86, align 4
  %711 = call <2 x float> @b2Body_GetLocalPoint(i64 %709, <2 x float> %710)
  store <2 x float> %711, ptr %89, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %707, ptr align 4 %89, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %89) #7
  %712 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 3
  call void @llvm.lifetime.start.p0(i64 8, ptr %90) #7
  %713 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 1
  %714 = load i64, ptr %713, align 8
  %715 = load <2 x float>, ptr %86, align 4
  %716 = call <2 x float> @b2Body_GetLocalPoint(i64 %714, <2 x float> %715)
  store <2 x float> %716, ptr %90, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %712, ptr align 4 %90, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %90) #7
  %717 = load i8, ptr %28, align 1, !tbaa !13, !range !17, !noundef !18
  %718 = trunc i8 %717 to i1
  %719 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 8
  %720 = zext i1 %718 to i8
  store i8 %720, ptr %719, align 8, !tbaa !54
  %721 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 9
  store float 0xBFF921FB60000000, ptr %721, align 4, !tbaa !56
  %722 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 10
  store float 0xBFB015BFA0000000, ptr %722, align 8, !tbaa !57
  %723 = load i8, ptr %27, align 1, !tbaa !13, !range !17, !noundef !18
  %724 = trunc i8 %723 to i1
  %725 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 11
  %726 = zext i1 %724 to i8
  store i8 %726, ptr %725, align 4, !tbaa !58
  %727 = load ptr, ptr %79, align 8, !tbaa !5
  %728 = getelementptr inbounds %struct.Bone, ptr %727, i32 0, i32 2
  %729 = load float, ptr %728, align 4, !tbaa !22
  %730 = load float, ptr %26, align 4, !tbaa !9
  %731 = fmul float %729, %730
  %732 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 12
  store float %731, ptr %732, align 8, !tbaa !59
  %733 = load float, ptr %16, align 4, !tbaa !9
  %734 = fcmp ogt float %733, 0.000000e+00
  %735 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 5
  %736 = zext i1 %734 to i8
  store i8 %736, ptr %735, align 4, !tbaa !60
  %737 = load float, ptr %16, align 4, !tbaa !9
  %738 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 6
  store float %737, ptr %738, align 8, !tbaa !61
  %739 = load float, ptr %17, align 4, !tbaa !9
  %740 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 7
  store float %739, ptr %740, align 4, !tbaa !62
  %741 = load float, ptr %29, align 4, !tbaa !9
  %742 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %88, i32 0, i32 14
  store float %741, ptr %742, align 8, !tbaa !63
  %743 = load ptr, ptr %79, align 8, !tbaa !5
  %744 = getelementptr inbounds %struct.Bone, ptr %743, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %91) #7
  %745 = load i32, ptr %11, align 2
  %746 = call i64 @b2CreateRevoluteJoint(i32 %745, ptr noundef %88)
  store i64 %746, ptr %91, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %744, ptr align 4 %91, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %91) #7
  call void @llvm.lifetime.end.p0(i64 96, ptr %88) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %86) #7
  call void @llvm.lifetime.end.p0(i64 20, ptr %83) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %79) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %92) #7
  %747 = load ptr, ptr %13, align 8, !tbaa !5
  %748 = getelementptr inbounds %struct.Human, ptr %747, i32 0, i32 0
  %749 = getelementptr inbounds [11 x %struct.Bone], ptr %748, i64 0, i64 0
  %750 = getelementptr inbounds %struct.Bone, ptr %749, i64 5
  store ptr %750, ptr %92, align 8, !tbaa !5
  %751 = load ptr, ptr %92, align 8, !tbaa !5
  %752 = getelementptr inbounds %struct.Bone, ptr %751, i32 0, i32 3
  store i32 0, ptr %752, align 4, !tbaa !26
  %753 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %93) #7
  %754 = getelementptr inbounds %struct.b2Vec2, ptr %94, i32 0, i32 0
  store float 0.000000e+00, ptr %754, align 4, !tbaa !47
  %755 = getelementptr inbounds %struct.b2Vec2, ptr %94, i32 0, i32 1
  %756 = load float, ptr %25, align 4, !tbaa !9
  %757 = fmul float 0x3FE8CCCCC0000000, %756
  store float %757, ptr %755, align 4, !tbaa !48
  %758 = load <2 x float>, ptr %94, align 4
  %759 = load <2 x float>, ptr %12, align 4
  %760 = call <2 x float> @b2Add(<2 x float> %758, <2 x float> %759)
  store <2 x float> %760, ptr %93, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %753, ptr align 4 %93, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %93) #7
  %761 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 5
  store float 0.000000e+00, ptr %761, align 8, !tbaa !50
  %762 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 9
  store ptr @.str.7, ptr %762, align 8, !tbaa !51
  %763 = load ptr, ptr %92, align 8, !tbaa !5
  %764 = getelementptr inbounds %struct.Bone, ptr %763, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %95) #7
  %765 = load i32, ptr %11, align 2
  %766 = call i64 @b2CreateBody(i32 %765, ptr noundef %22)
  store i64 %766, ptr %95, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %764, ptr align 4 %95, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %95) #7
  %767 = load ptr, ptr %92, align 8, !tbaa !5
  %768 = getelementptr inbounds %struct.Bone, ptr %767, i32 0, i32 2
  store float 1.000000e+00, ptr %768, align 4, !tbaa !22
  %769 = load i8, ptr %20, align 1, !tbaa !13, !range !17, !noundef !18
  %770 = trunc i8 %769 to i1
  br i1 %770, label %771, label %775

771:                                              ; preds = %666
  %772 = load i32, ptr %31, align 4, !tbaa !11
  %773 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 1
  %774 = getelementptr inbounds %struct.b2SurfaceMaterial, ptr %773, i32 0, i32 5
  store i32 %772, ptr %774, align 4, !tbaa !46
  br label %775

775:                                              ; preds = %771, %666
  call void @llvm.lifetime.start.p0(i64 20, ptr %96) #7
  %776 = getelementptr inbounds %struct.b2Capsule, ptr %96, i32 0, i32 0
  %777 = getelementptr inbounds %struct.b2Vec2, ptr %776, i32 0, i32 0
  store float 0.000000e+00, ptr %777, align 4, !tbaa !47
  %778 = getelementptr inbounds %struct.b2Vec2, ptr %776, i32 0, i32 1
  %779 = load float, ptr %25, align 4, !tbaa !9
  %780 = fmul float -1.250000e-01, %779
  store float %780, ptr %778, align 4, !tbaa !48
  %781 = getelementptr inbounds %struct.b2Capsule, ptr %96, i32 0, i32 1
  %782 = getelementptr inbounds %struct.b2Vec2, ptr %781, i32 0, i32 0
  store float 0.000000e+00, ptr %782, align 4, !tbaa !47
  %783 = getelementptr inbounds %struct.b2Vec2, ptr %781, i32 0, i32 1
  %784 = load float, ptr %25, align 4, !tbaa !9
  %785 = fmul float 1.250000e-01, %784
  store float %785, ptr %783, align 4, !tbaa !48
  %786 = getelementptr inbounds %struct.b2Capsule, ptr %96, i32 0, i32 2
  %787 = load float, ptr %25, align 4, !tbaa !9
  %788 = fmul float 0x3FAEB851E0000000, %787
  store float %788, ptr %786, align 4, !tbaa !52
  %789 = load ptr, ptr %92, align 8, !tbaa !5
  %790 = getelementptr inbounds %struct.Bone, ptr %789, i32 0, i32 0
  %791 = load i64, ptr %790, align 4
  %792 = call i64 @b2CreateCapsuleShape(i64 %791, ptr noundef %23, ptr noundef %96)
  store i64 %792, ptr %97, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %98) #7
  %793 = getelementptr inbounds %struct.b2Vec2, ptr %99, i32 0, i32 0
  store float 0.000000e+00, ptr %793, align 4, !tbaa !47
  %794 = getelementptr inbounds %struct.b2Vec2, ptr %99, i32 0, i32 1
  %795 = load float, ptr %25, align 4, !tbaa !9
  %796 = fmul float 0x3FECCCCCC0000000, %795
  store float %796, ptr %794, align 4, !tbaa !48
  %797 = load <2 x float>, ptr %99, align 4
  %798 = load <2 x float>, ptr %12, align 4
  %799 = call <2 x float> @b2Add(<2 x float> %797, <2 x float> %798)
  store <2 x float> %799, ptr %98, align 4
  call void @llvm.lifetime.start.p0(i64 96, ptr %100) #7
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind writable sret(%struct.b2RevoluteJointDef) align 8 %100)
  %800 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 0
  %801 = load ptr, ptr %13, align 8, !tbaa !5
  %802 = getelementptr inbounds %struct.Human, ptr %801, i32 0, i32 0
  %803 = load ptr, ptr %92, align 8, !tbaa !5
  %804 = getelementptr inbounds %struct.Bone, ptr %803, i32 0, i32 3
  %805 = load i32, ptr %804, align 4, !tbaa !26
  %806 = sext i32 %805 to i64
  %807 = getelementptr inbounds [11 x %struct.Bone], ptr %802, i64 0, i64 %806
  %808 = getelementptr inbounds %struct.Bone, ptr %807, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %800, ptr align 4 %808, i64 8, i1 false), !tbaa.struct !19
  %809 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 1
  %810 = load ptr, ptr %92, align 8, !tbaa !5
  %811 = getelementptr inbounds %struct.Bone, ptr %810, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %809, ptr align 4 %811, i64 8, i1 false), !tbaa.struct !19
  %812 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %101) #7
  %813 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 0
  %814 = load i64, ptr %813, align 8
  %815 = load <2 x float>, ptr %98, align 4
  %816 = call <2 x float> @b2Body_GetLocalPoint(i64 %814, <2 x float> %815)
  store <2 x float> %816, ptr %101, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %812, ptr align 4 %101, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %101) #7
  %817 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 3
  call void @llvm.lifetime.start.p0(i64 8, ptr %102) #7
  %818 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 1
  %819 = load i64, ptr %818, align 8
  %820 = load <2 x float>, ptr %98, align 4
  %821 = call <2 x float> @b2Body_GetLocalPoint(i64 %819, <2 x float> %820)
  store <2 x float> %821, ptr %102, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %817, ptr align 4 %102, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %102) #7
  %822 = load i8, ptr %28, align 1, !tbaa !13, !range !17, !noundef !18
  %823 = trunc i8 %822 to i1
  %824 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 8
  %825 = zext i1 %823 to i8
  store i8 %825, ptr %824, align 8, !tbaa !54
  %826 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 9
  store float 0xBFC41B2F80000000, ptr %826, align 4, !tbaa !56
  %827 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 10
  store float 0x3FF41B2F80000000, ptr %827, align 8, !tbaa !57
  %828 = load i8, ptr %27, align 1, !tbaa !13, !range !17, !noundef !18
  %829 = trunc i8 %828 to i1
  %830 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 11
  %831 = zext i1 %829 to i8
  store i8 %831, ptr %830, align 4, !tbaa !58
  %832 = load ptr, ptr %92, align 8, !tbaa !5
  %833 = getelementptr inbounds %struct.Bone, ptr %832, i32 0, i32 2
  %834 = load float, ptr %833, align 4, !tbaa !22
  %835 = load float, ptr %26, align 4, !tbaa !9
  %836 = fmul float %834, %835
  %837 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 12
  store float %836, ptr %837, align 8, !tbaa !59
  %838 = load float, ptr %16, align 4, !tbaa !9
  %839 = fcmp ogt float %838, 0.000000e+00
  %840 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 5
  %841 = zext i1 %839 to i8
  store i8 %841, ptr %840, align 4, !tbaa !60
  %842 = load float, ptr %16, align 4, !tbaa !9
  %843 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 6
  store float %842, ptr %843, align 8, !tbaa !61
  %844 = load float, ptr %17, align 4, !tbaa !9
  %845 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 7
  store float %844, ptr %845, align 4, !tbaa !62
  %846 = load float, ptr %29, align 4, !tbaa !9
  %847 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %100, i32 0, i32 14
  store float %846, ptr %847, align 8, !tbaa !63
  %848 = load ptr, ptr %92, align 8, !tbaa !5
  %849 = getelementptr inbounds %struct.Bone, ptr %848, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %103) #7
  %850 = load i32, ptr %11, align 2
  %851 = call i64 @b2CreateRevoluteJoint(i32 %850, ptr noundef %100)
  store i64 %851, ptr %103, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %849, ptr align 4 %103, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %103) #7
  call void @llvm.lifetime.end.p0(i64 96, ptr %100) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %98) #7
  call void @llvm.lifetime.end.p0(i64 20, ptr %96) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %92) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %104) #7
  %852 = load ptr, ptr %13, align 8, !tbaa !5
  %853 = getelementptr inbounds %struct.Human, ptr %852, i32 0, i32 0
  %854 = getelementptr inbounds [11 x %struct.Bone], ptr %853, i64 0, i64 0
  %855 = getelementptr inbounds %struct.Bone, ptr %854, i64 6
  store ptr %855, ptr %104, align 8, !tbaa !5
  %856 = load ptr, ptr %104, align 8, !tbaa !5
  %857 = getelementptr inbounds %struct.Bone, ptr %856, i32 0, i32 3
  store i32 5, ptr %857, align 4, !tbaa !26
  %858 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %105) #7
  %859 = getelementptr inbounds %struct.b2Vec2, ptr %106, i32 0, i32 0
  store float 0.000000e+00, ptr %859, align 4, !tbaa !47
  %860 = getelementptr inbounds %struct.b2Vec2, ptr %106, i32 0, i32 1
  %861 = load float, ptr %25, align 4, !tbaa !9
  %862 = fmul float 0x3FDE666660000000, %861
  store float %862, ptr %860, align 4, !tbaa !48
  %863 = load <2 x float>, ptr %106, align 4
  %864 = load <2 x float>, ptr %12, align 4
  %865 = call <2 x float> @b2Add(<2 x float> %863, <2 x float> %864)
  store <2 x float> %865, ptr %105, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %858, ptr align 4 %105, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %105) #7
  %866 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 5
  store float 0.000000e+00, ptr %866, align 8, !tbaa !50
  %867 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 9
  store ptr @.str.8, ptr %867, align 8, !tbaa !51
  %868 = load ptr, ptr %104, align 8, !tbaa !5
  %869 = getelementptr inbounds %struct.Bone, ptr %868, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %107) #7
  %870 = load i32, ptr %11, align 2
  %871 = call i64 @b2CreateBody(i32 %870, ptr noundef %22)
  store i64 %871, ptr %107, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %869, ptr align 4 %107, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %107) #7
  %872 = load ptr, ptr %104, align 8, !tbaa !5
  %873 = getelementptr inbounds %struct.Bone, ptr %872, i32 0, i32 2
  store float 5.000000e-01, ptr %873, align 4, !tbaa !22
  %874 = load i8, ptr %20, align 1, !tbaa !13, !range !17, !noundef !18
  %875 = trunc i8 %874 to i1
  br i1 %875, label %876, label %880

876:                                              ; preds = %775
  %877 = load i32, ptr %31, align 4, !tbaa !11
  %878 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 1
  %879 = getelementptr inbounds %struct.b2SurfaceMaterial, ptr %878, i32 0, i32 5
  store i32 %877, ptr %879, align 4, !tbaa !46
  br label %880

880:                                              ; preds = %876, %775
  call void @llvm.lifetime.start.p0(i64 20, ptr %108) #7
  %881 = getelementptr inbounds %struct.b2Capsule, ptr %108, i32 0, i32 0
  %882 = getelementptr inbounds %struct.b2Vec2, ptr %881, i32 0, i32 0
  store float 0.000000e+00, ptr %882, align 4, !tbaa !47
  %883 = getelementptr inbounds %struct.b2Vec2, ptr %881, i32 0, i32 1
  %884 = load float, ptr %25, align 4, !tbaa !9
  %885 = fmul float 0xBFC3D70A40000000, %884
  store float %885, ptr %883, align 4, !tbaa !48
  %886 = getelementptr inbounds %struct.b2Capsule, ptr %108, i32 0, i32 1
  %887 = getelementptr inbounds %struct.b2Vec2, ptr %886, i32 0, i32 0
  store float 0.000000e+00, ptr %887, align 4, !tbaa !47
  %888 = getelementptr inbounds %struct.b2Vec2, ptr %886, i32 0, i32 1
  %889 = load float, ptr %25, align 4, !tbaa !9
  %890 = fmul float 1.250000e-01, %889
  store float %890, ptr %888, align 4, !tbaa !48
  %891 = getelementptr inbounds %struct.b2Capsule, ptr %108, i32 0, i32 2
  %892 = load float, ptr %25, align 4, !tbaa !9
  %893 = fmul float 0x3FA70A3D80000000, %892
  store float %893, ptr %891, align 4, !tbaa !52
  %894 = load ptr, ptr %104, align 8, !tbaa !5
  %895 = getelementptr inbounds %struct.Bone, ptr %894, i32 0, i32 0
  %896 = load i64, ptr %895, align 4
  %897 = call i64 @b2CreateCapsuleShape(i64 %896, ptr noundef %23, ptr noundef %108)
  store i64 %897, ptr %109, align 4
  %898 = load ptr, ptr %104, align 8, !tbaa !5
  %899 = getelementptr inbounds %struct.Bone, ptr %898, i32 0, i32 0
  %900 = load i64, ptr %899, align 4
  %901 = call i64 @b2CreatePolygonShape(i64 %900, ptr noundef %24, ptr noundef %78)
  store i64 %901, ptr %110, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %111) #7
  %902 = getelementptr inbounds %struct.b2Vec2, ptr %112, i32 0, i32 0
  store float 0.000000e+00, ptr %902, align 4, !tbaa !47
  %903 = getelementptr inbounds %struct.b2Vec2, ptr %112, i32 0, i32 1
  %904 = load float, ptr %25, align 4, !tbaa !9
  %905 = fmul float 6.250000e-01, %904
  store float %905, ptr %903, align 4, !tbaa !48
  %906 = load <2 x float>, ptr %112, align 4
  %907 = load <2 x float>, ptr %12, align 4
  %908 = call <2 x float> @b2Add(<2 x float> %906, <2 x float> %907)
  store <2 x float> %908, ptr %111, align 4
  call void @llvm.lifetime.start.p0(i64 96, ptr %113) #7
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind writable sret(%struct.b2RevoluteJointDef) align 8 %113)
  %909 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 0
  %910 = load ptr, ptr %13, align 8, !tbaa !5
  %911 = getelementptr inbounds %struct.Human, ptr %910, i32 0, i32 0
  %912 = load ptr, ptr %104, align 8, !tbaa !5
  %913 = getelementptr inbounds %struct.Bone, ptr %912, i32 0, i32 3
  %914 = load i32, ptr %913, align 4, !tbaa !26
  %915 = sext i32 %914 to i64
  %916 = getelementptr inbounds [11 x %struct.Bone], ptr %911, i64 0, i64 %915
  %917 = getelementptr inbounds %struct.Bone, ptr %916, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %909, ptr align 4 %917, i64 8, i1 false), !tbaa.struct !19
  %918 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 1
  %919 = load ptr, ptr %104, align 8, !tbaa !5
  %920 = getelementptr inbounds %struct.Bone, ptr %919, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %918, ptr align 4 %920, i64 8, i1 false), !tbaa.struct !19
  %921 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %114) #7
  %922 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 0
  %923 = load i64, ptr %922, align 8
  %924 = load <2 x float>, ptr %111, align 4
  %925 = call <2 x float> @b2Body_GetLocalPoint(i64 %923, <2 x float> %924)
  store <2 x float> %925, ptr %114, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %921, ptr align 4 %114, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %114) #7
  %926 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 3
  call void @llvm.lifetime.start.p0(i64 8, ptr %115) #7
  %927 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 1
  %928 = load i64, ptr %927, align 8
  %929 = load <2 x float>, ptr %111, align 4
  %930 = call <2 x float> @b2Body_GetLocalPoint(i64 %928, <2 x float> %929)
  store <2 x float> %930, ptr %115, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %926, ptr align 4 %115, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %115) #7
  %931 = load i8, ptr %28, align 1, !tbaa !13, !range !17, !noundef !18
  %932 = trunc i8 %931 to i1
  %933 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 8
  %934 = zext i1 %932 to i8
  store i8 %934, ptr %933, align 8, !tbaa !54
  %935 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 9
  store float 0xBFF921FB60000000, ptr %935, align 4, !tbaa !56
  %936 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 10
  store float 0xBFB015BFA0000000, ptr %936, align 8, !tbaa !57
  %937 = load i8, ptr %27, align 1, !tbaa !13, !range !17, !noundef !18
  %938 = trunc i8 %937 to i1
  %939 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 11
  %940 = zext i1 %938 to i8
  store i8 %940, ptr %939, align 4, !tbaa !58
  %941 = load ptr, ptr %104, align 8, !tbaa !5
  %942 = getelementptr inbounds %struct.Bone, ptr %941, i32 0, i32 2
  %943 = load float, ptr %942, align 4, !tbaa !22
  %944 = load float, ptr %26, align 4, !tbaa !9
  %945 = fmul float %943, %944
  %946 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 12
  store float %945, ptr %946, align 8, !tbaa !59
  %947 = load float, ptr %16, align 4, !tbaa !9
  %948 = fcmp ogt float %947, 0.000000e+00
  %949 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 5
  %950 = zext i1 %948 to i8
  store i8 %950, ptr %949, align 4, !tbaa !60
  %951 = load float, ptr %16, align 4, !tbaa !9
  %952 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 6
  store float %951, ptr %952, align 8, !tbaa !61
  %953 = load float, ptr %17, align 4, !tbaa !9
  %954 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 7
  store float %953, ptr %954, align 4, !tbaa !62
  %955 = load float, ptr %29, align 4, !tbaa !9
  %956 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %113, i32 0, i32 14
  store float %955, ptr %956, align 8, !tbaa !63
  %957 = load ptr, ptr %104, align 8, !tbaa !5
  %958 = getelementptr inbounds %struct.Bone, ptr %957, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %116) #7
  %959 = load i32, ptr %11, align 2
  %960 = call i64 @b2CreateRevoluteJoint(i32 %959, ptr noundef %113)
  store i64 %960, ptr %116, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %958, ptr align 4 %116, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %116) #7
  call void @llvm.lifetime.end.p0(i64 96, ptr %113) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %111) #7
  call void @llvm.lifetime.end.p0(i64 20, ptr %108) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %104) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %117) #7
  %961 = load ptr, ptr %13, align 8, !tbaa !5
  %962 = getelementptr inbounds %struct.Human, ptr %961, i32 0, i32 0
  %963 = getelementptr inbounds [11 x %struct.Bone], ptr %962, i64 0, i64 0
  %964 = getelementptr inbounds %struct.Bone, ptr %963, i64 7
  store ptr %964, ptr %117, align 8, !tbaa !5
  %965 = load ptr, ptr %117, align 8, !tbaa !5
  %966 = getelementptr inbounds %struct.Bone, ptr %965, i32 0, i32 3
  store i32 1, ptr %966, align 4, !tbaa !26
  %967 = load ptr, ptr %117, align 8, !tbaa !5
  %968 = getelementptr inbounds %struct.Bone, ptr %967, i32 0, i32 2
  store float 5.000000e-01, ptr %968, align 4, !tbaa !22
  %969 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %118) #7
  %970 = getelementptr inbounds %struct.b2Vec2, ptr %119, i32 0, i32 0
  store float 0.000000e+00, ptr %970, align 4, !tbaa !47
  %971 = getelementptr inbounds %struct.b2Vec2, ptr %119, i32 0, i32 1
  %972 = load float, ptr %25, align 4, !tbaa !9
  %973 = fmul float 0x3FF39999A0000000, %972
  store float %973, ptr %971, align 4, !tbaa !48
  %974 = load <2 x float>, ptr %119, align 4
  %975 = load <2 x float>, ptr %12, align 4
  %976 = call <2 x float> @b2Add(<2 x float> %974, <2 x float> %975)
  store <2 x float> %976, ptr %118, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %969, ptr align 4 %118, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %118) #7
  %977 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 5
  store float 0.000000e+00, ptr %977, align 8, !tbaa !50
  %978 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 9
  store ptr @.str.6, ptr %978, align 8, !tbaa !51
  %979 = load ptr, ptr %117, align 8, !tbaa !5
  %980 = getelementptr inbounds %struct.Bone, ptr %979, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %120) #7
  %981 = load i32, ptr %11, align 2
  %982 = call i64 @b2CreateBody(i32 %981, ptr noundef %22)
  store i64 %982, ptr %120, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %980, ptr align 4 %120, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %120) #7
  %983 = load i8, ptr %20, align 1, !tbaa !13, !range !17, !noundef !18
  %984 = trunc i8 %983 to i1
  br i1 %984, label %985, label %989

985:                                              ; preds = %880
  %986 = load i32, ptr %30, align 4, !tbaa !11
  %987 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 1
  %988 = getelementptr inbounds %struct.b2SurfaceMaterial, ptr %987, i32 0, i32 5
  store i32 %986, ptr %988, align 4, !tbaa !46
  br label %989

989:                                              ; preds = %985, %880
  call void @llvm.lifetime.start.p0(i64 20, ptr %121) #7
  %990 = getelementptr inbounds %struct.b2Capsule, ptr %121, i32 0, i32 0
  %991 = getelementptr inbounds %struct.b2Vec2, ptr %990, i32 0, i32 0
  store float 0.000000e+00, ptr %991, align 4, !tbaa !47
  %992 = getelementptr inbounds %struct.b2Vec2, ptr %990, i32 0, i32 1
  %993 = load float, ptr %25, align 4, !tbaa !9
  %994 = fmul float -1.250000e-01, %993
  store float %994, ptr %992, align 4, !tbaa !48
  %995 = getelementptr inbounds %struct.b2Capsule, ptr %121, i32 0, i32 1
  %996 = getelementptr inbounds %struct.b2Vec2, ptr %995, i32 0, i32 0
  store float 0.000000e+00, ptr %996, align 4, !tbaa !47
  %997 = getelementptr inbounds %struct.b2Vec2, ptr %995, i32 0, i32 1
  %998 = load float, ptr %25, align 4, !tbaa !9
  %999 = fmul float 1.250000e-01, %998
  store float %999, ptr %997, align 4, !tbaa !48
  %1000 = getelementptr inbounds %struct.b2Capsule, ptr %121, i32 0, i32 2
  %1001 = load float, ptr %25, align 4, !tbaa !9
  %1002 = fmul float 0x3FA1EB8520000000, %1001
  store float %1002, ptr %1000, align 4, !tbaa !52
  %1003 = load ptr, ptr %117, align 8, !tbaa !5
  %1004 = getelementptr inbounds %struct.Bone, ptr %1003, i32 0, i32 0
  %1005 = load i64, ptr %1004, align 4
  %1006 = call i64 @b2CreateCapsuleShape(i64 %1005, ptr noundef %23, ptr noundef %121)
  store i64 %1006, ptr %122, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %123) #7
  %1007 = getelementptr inbounds %struct.b2Vec2, ptr %124, i32 0, i32 0
  store float 0.000000e+00, ptr %1007, align 4, !tbaa !47
  %1008 = getelementptr inbounds %struct.b2Vec2, ptr %124, i32 0, i32 1
  %1009 = load float, ptr %25, align 4, !tbaa !9
  %1010 = fmul float 0x3FF59999A0000000, %1009
  store float %1010, ptr %1008, align 4, !tbaa !48
  %1011 = load <2 x float>, ptr %124, align 4
  %1012 = load <2 x float>, ptr %12, align 4
  %1013 = call <2 x float> @b2Add(<2 x float> %1011, <2 x float> %1012)
  store <2 x float> %1013, ptr %123, align 4
  call void @llvm.lifetime.start.p0(i64 96, ptr %125) #7
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind writable sret(%struct.b2RevoluteJointDef) align 8 %125)
  %1014 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 0
  %1015 = load ptr, ptr %13, align 8, !tbaa !5
  %1016 = getelementptr inbounds %struct.Human, ptr %1015, i32 0, i32 0
  %1017 = load ptr, ptr %117, align 8, !tbaa !5
  %1018 = getelementptr inbounds %struct.Bone, ptr %1017, i32 0, i32 3
  %1019 = load i32, ptr %1018, align 4, !tbaa !26
  %1020 = sext i32 %1019 to i64
  %1021 = getelementptr inbounds [11 x %struct.Bone], ptr %1016, i64 0, i64 %1020
  %1022 = getelementptr inbounds %struct.Bone, ptr %1021, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1014, ptr align 4 %1022, i64 8, i1 false), !tbaa.struct !19
  %1023 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 1
  %1024 = load ptr, ptr %117, align 8, !tbaa !5
  %1025 = getelementptr inbounds %struct.Bone, ptr %1024, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1023, ptr align 4 %1025, i64 8, i1 false), !tbaa.struct !19
  %1026 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %126) #7
  %1027 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 0
  %1028 = load i64, ptr %1027, align 8
  %1029 = load <2 x float>, ptr %123, align 4
  %1030 = call <2 x float> @b2Body_GetLocalPoint(i64 %1028, <2 x float> %1029)
  store <2 x float> %1030, ptr %126, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1026, ptr align 4 %126, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %126) #7
  %1031 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 3
  call void @llvm.lifetime.start.p0(i64 8, ptr %127) #7
  %1032 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 1
  %1033 = load i64, ptr %1032, align 8
  %1034 = load <2 x float>, ptr %123, align 4
  %1035 = call <2 x float> @b2Body_GetLocalPoint(i64 %1033, <2 x float> %1034)
  store <2 x float> %1035, ptr %127, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1031, ptr align 4 %127, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %127) #7
  %1036 = load i8, ptr %28, align 1, !tbaa !13, !range !17, !noundef !18
  %1037 = trunc i8 %1036 to i1
  %1038 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 8
  %1039 = zext i1 %1037 to i8
  store i8 %1039, ptr %1038, align 8, !tbaa !54
  %1040 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 9
  store float 0xBFD41B2F80000000, ptr %1040, align 4, !tbaa !56
  %1041 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 10
  store float 0x40041B2F80000000, ptr %1041, align 8, !tbaa !57
  %1042 = load i8, ptr %27, align 1, !tbaa !13, !range !17, !noundef !18
  %1043 = trunc i8 %1042 to i1
  %1044 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 11
  %1045 = zext i1 %1043 to i8
  store i8 %1045, ptr %1044, align 4, !tbaa !58
  %1046 = load ptr, ptr %117, align 8, !tbaa !5
  %1047 = getelementptr inbounds %struct.Bone, ptr %1046, i32 0, i32 2
  %1048 = load float, ptr %1047, align 4, !tbaa !22
  %1049 = load float, ptr %26, align 4, !tbaa !9
  %1050 = fmul float %1048, %1049
  %1051 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 12
  store float %1050, ptr %1051, align 8, !tbaa !59
  %1052 = load float, ptr %16, align 4, !tbaa !9
  %1053 = fcmp ogt float %1052, 0.000000e+00
  %1054 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 5
  %1055 = zext i1 %1053 to i8
  store i8 %1055, ptr %1054, align 4, !tbaa !60
  %1056 = load float, ptr %16, align 4, !tbaa !9
  %1057 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 6
  store float %1056, ptr %1057, align 8, !tbaa !61
  %1058 = load float, ptr %17, align 4, !tbaa !9
  %1059 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 7
  store float %1058, ptr %1059, align 4, !tbaa !62
  %1060 = load float, ptr %29, align 4, !tbaa !9
  %1061 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %125, i32 0, i32 14
  store float %1060, ptr %1061, align 8, !tbaa !63
  %1062 = load ptr, ptr %117, align 8, !tbaa !5
  %1063 = getelementptr inbounds %struct.Bone, ptr %1062, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %128) #7
  %1064 = load i32, ptr %11, align 2
  %1065 = call i64 @b2CreateRevoluteJoint(i32 %1064, ptr noundef %125)
  store i64 %1065, ptr %128, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1063, ptr align 4 %128, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %128) #7
  call void @llvm.lifetime.end.p0(i64 96, ptr %125) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %123) #7
  call void @llvm.lifetime.end.p0(i64 20, ptr %121) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %117) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %129) #7
  %1066 = load ptr, ptr %13, align 8, !tbaa !5
  %1067 = getelementptr inbounds %struct.Human, ptr %1066, i32 0, i32 0
  %1068 = getelementptr inbounds [11 x %struct.Bone], ptr %1067, i64 0, i64 0
  %1069 = getelementptr inbounds %struct.Bone, ptr %1068, i64 8
  store ptr %1069, ptr %129, align 8, !tbaa !5
  %1070 = load ptr, ptr %129, align 8, !tbaa !5
  %1071 = getelementptr inbounds %struct.Bone, ptr %1070, i32 0, i32 3
  store i32 7, ptr %1071, align 4, !tbaa !26
  %1072 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %130) #7
  %1073 = getelementptr inbounds %struct.b2Vec2, ptr %131, i32 0, i32 0
  store float 0.000000e+00, ptr %1073, align 4, !tbaa !47
  %1074 = getelementptr inbounds %struct.b2Vec2, ptr %131, i32 0, i32 1
  %1075 = load float, ptr %25, align 4, !tbaa !9
  %1076 = fmul float 0x3FEF333340000000, %1075
  store float %1076, ptr %1074, align 4, !tbaa !48
  %1077 = load <2 x float>, ptr %131, align 4
  %1078 = load <2 x float>, ptr %12, align 4
  %1079 = call <2 x float> @b2Add(<2 x float> %1077, <2 x float> %1078)
  store <2 x float> %1079, ptr %130, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1072, ptr align 4 %130, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %130) #7
  %1080 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 5
  store float 0x3FB99999A0000000, ptr %1080, align 8, !tbaa !50
  %1081 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 9
  store ptr @.str.9, ptr %1081, align 8, !tbaa !51
  %1082 = load ptr, ptr %129, align 8, !tbaa !5
  %1083 = getelementptr inbounds %struct.Bone, ptr %1082, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %132) #7
  %1084 = load i32, ptr %11, align 2
  %1085 = call i64 @b2CreateBody(i32 %1084, ptr noundef %22)
  store i64 %1085, ptr %132, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1083, ptr align 4 %132, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %132) #7
  %1086 = load ptr, ptr %129, align 8, !tbaa !5
  %1087 = getelementptr inbounds %struct.Bone, ptr %1086, i32 0, i32 2
  store float 0x3FB99999A0000000, ptr %1087, align 4, !tbaa !22
  %1088 = load i8, ptr %20, align 1, !tbaa !13, !range !17, !noundef !18
  %1089 = trunc i8 %1088 to i1
  br i1 %1089, label %1090, label %1094

1090:                                             ; preds = %989
  %1091 = load i32, ptr %33, align 4, !tbaa !11
  %1092 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 1
  %1093 = getelementptr inbounds %struct.b2SurfaceMaterial, ptr %1092, i32 0, i32 5
  store i32 %1091, ptr %1093, align 4, !tbaa !46
  br label %1094

1094:                                             ; preds = %1090, %989
  call void @llvm.lifetime.start.p0(i64 20, ptr %133) #7
  %1095 = getelementptr inbounds %struct.b2Capsule, ptr %133, i32 0, i32 0
  %1096 = getelementptr inbounds %struct.b2Vec2, ptr %1095, i32 0, i32 0
  store float 0.000000e+00, ptr %1096, align 4, !tbaa !47
  %1097 = getelementptr inbounds %struct.b2Vec2, ptr %1095, i32 0, i32 1
  %1098 = load float, ptr %25, align 4, !tbaa !9
  %1099 = fmul float -1.250000e-01, %1098
  store float %1099, ptr %1097, align 4, !tbaa !48
  %1100 = getelementptr inbounds %struct.b2Capsule, ptr %133, i32 0, i32 1
  %1101 = getelementptr inbounds %struct.b2Vec2, ptr %1100, i32 0, i32 0
  store float 0.000000e+00, ptr %1101, align 4, !tbaa !47
  %1102 = getelementptr inbounds %struct.b2Vec2, ptr %1100, i32 0, i32 1
  %1103 = load float, ptr %25, align 4, !tbaa !9
  %1104 = fmul float 1.250000e-01, %1103
  store float %1104, ptr %1102, align 4, !tbaa !48
  %1105 = getelementptr inbounds %struct.b2Capsule, ptr %133, i32 0, i32 2
  %1106 = load float, ptr %25, align 4, !tbaa !9
  %1107 = fmul float 0x3F9EB851E0000000, %1106
  store float %1107, ptr %1105, align 4, !tbaa !52
  %1108 = load ptr, ptr %129, align 8, !tbaa !5
  %1109 = getelementptr inbounds %struct.Bone, ptr %1108, i32 0, i32 0
  %1110 = load i64, ptr %1109, align 4
  %1111 = call i64 @b2CreateCapsuleShape(i64 %1110, ptr noundef %23, ptr noundef %133)
  store i64 %1111, ptr %134, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %135) #7
  %1112 = getelementptr inbounds %struct.b2Vec2, ptr %136, i32 0, i32 0
  store float 0.000000e+00, ptr %1112, align 4, !tbaa !47
  %1113 = getelementptr inbounds %struct.b2Vec2, ptr %136, i32 0, i32 1
  %1114 = load float, ptr %25, align 4, !tbaa !9
  %1115 = fmul float 0x3FF19999A0000000, %1114
  store float %1115, ptr %1113, align 4, !tbaa !48
  %1116 = load <2 x float>, ptr %136, align 4
  %1117 = load <2 x float>, ptr %12, align 4
  %1118 = call <2 x float> @b2Add(<2 x float> %1116, <2 x float> %1117)
  store <2 x float> %1118, ptr %135, align 4
  call void @llvm.lifetime.start.p0(i64 96, ptr %137) #7
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind writable sret(%struct.b2RevoluteJointDef) align 8 %137)
  %1119 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 0
  %1120 = load ptr, ptr %13, align 8, !tbaa !5
  %1121 = getelementptr inbounds %struct.Human, ptr %1120, i32 0, i32 0
  %1122 = load ptr, ptr %129, align 8, !tbaa !5
  %1123 = getelementptr inbounds %struct.Bone, ptr %1122, i32 0, i32 3
  %1124 = load i32, ptr %1123, align 4, !tbaa !26
  %1125 = sext i32 %1124 to i64
  %1126 = getelementptr inbounds [11 x %struct.Bone], ptr %1121, i64 0, i64 %1125
  %1127 = getelementptr inbounds %struct.Bone, ptr %1126, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1119, ptr align 4 %1127, i64 8, i1 false), !tbaa.struct !19
  %1128 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 1
  %1129 = load ptr, ptr %129, align 8, !tbaa !5
  %1130 = getelementptr inbounds %struct.Bone, ptr %1129, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1128, ptr align 4 %1130, i64 8, i1 false), !tbaa.struct !19
  %1131 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %138) #7
  %1132 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 0
  %1133 = load i64, ptr %1132, align 8
  %1134 = load <2 x float>, ptr %135, align 4
  %1135 = call <2 x float> @b2Body_GetLocalPoint(i64 %1133, <2 x float> %1134)
  store <2 x float> %1135, ptr %138, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1131, ptr align 4 %138, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %138) #7
  %1136 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 3
  call void @llvm.lifetime.start.p0(i64 8, ptr %139) #7
  %1137 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 1
  %1138 = load i64, ptr %1137, align 8
  %1139 = load <2 x float>, ptr %135, align 4
  %1140 = call <2 x float> @b2Body_GetLocalPoint(i64 %1138, <2 x float> %1139)
  store <2 x float> %1140, ptr %139, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1136, ptr align 4 %139, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %139) #7
  %1141 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 4
  store float 0x3FE921FB60000000, ptr %1141, align 8, !tbaa !64
  %1142 = load i8, ptr %28, align 1, !tbaa !13, !range !17, !noundef !18
  %1143 = trunc i8 %1142 to i1
  %1144 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 8
  %1145 = zext i1 %1143 to i8
  store i8 %1145, ptr %1144, align 8, !tbaa !54
  %1146 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 9
  store float 0xBFE41B2F80000000, ptr %1146, align 4, !tbaa !56
  %1147 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 10
  store float 0x3FEE28C760000000, ptr %1147, align 8, !tbaa !57
  %1148 = load i8, ptr %27, align 1, !tbaa !13, !range !17, !noundef !18
  %1149 = trunc i8 %1148 to i1
  %1150 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 11
  %1151 = zext i1 %1149 to i8
  store i8 %1151, ptr %1150, align 4, !tbaa !58
  %1152 = load ptr, ptr %129, align 8, !tbaa !5
  %1153 = getelementptr inbounds %struct.Bone, ptr %1152, i32 0, i32 2
  %1154 = load float, ptr %1153, align 4, !tbaa !22
  %1155 = load float, ptr %26, align 4, !tbaa !9
  %1156 = fmul float %1154, %1155
  %1157 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 12
  store float %1156, ptr %1157, align 8, !tbaa !59
  %1158 = load float, ptr %16, align 4, !tbaa !9
  %1159 = fcmp ogt float %1158, 0.000000e+00
  %1160 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 5
  %1161 = zext i1 %1159 to i8
  store i8 %1161, ptr %1160, align 4, !tbaa !60
  %1162 = load float, ptr %16, align 4, !tbaa !9
  %1163 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 6
  store float %1162, ptr %1163, align 8, !tbaa !61
  %1164 = load float, ptr %17, align 4, !tbaa !9
  %1165 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 7
  store float %1164, ptr %1165, align 4, !tbaa !62
  %1166 = load float, ptr %29, align 4, !tbaa !9
  %1167 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %137, i32 0, i32 14
  store float %1166, ptr %1167, align 8, !tbaa !63
  %1168 = load ptr, ptr %129, align 8, !tbaa !5
  %1169 = getelementptr inbounds %struct.Bone, ptr %1168, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %140) #7
  %1170 = load i32, ptr %11, align 2
  %1171 = call i64 @b2CreateRevoluteJoint(i32 %1170, ptr noundef %137)
  store i64 %1171, ptr %140, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1169, ptr align 4 %140, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %140) #7
  call void @llvm.lifetime.end.p0(i64 96, ptr %137) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %135) #7
  call void @llvm.lifetime.end.p0(i64 20, ptr %133) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %129) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %141) #7
  %1172 = load ptr, ptr %13, align 8, !tbaa !5
  %1173 = getelementptr inbounds %struct.Human, ptr %1172, i32 0, i32 0
  %1174 = getelementptr inbounds [11 x %struct.Bone], ptr %1173, i64 0, i64 0
  %1175 = getelementptr inbounds %struct.Bone, ptr %1174, i64 9
  store ptr %1175, ptr %141, align 8, !tbaa !5
  %1176 = load ptr, ptr %141, align 8, !tbaa !5
  %1177 = getelementptr inbounds %struct.Bone, ptr %1176, i32 0, i32 3
  store i32 1, ptr %1177, align 4, !tbaa !26
  %1178 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %142) #7
  %1179 = getelementptr inbounds %struct.b2Vec2, ptr %143, i32 0, i32 0
  store float 0.000000e+00, ptr %1179, align 4, !tbaa !47
  %1180 = getelementptr inbounds %struct.b2Vec2, ptr %143, i32 0, i32 1
  %1181 = load float, ptr %25, align 4, !tbaa !9
  %1182 = fmul float 0x3FF39999A0000000, %1181
  store float %1182, ptr %1180, align 4, !tbaa !48
  %1183 = load <2 x float>, ptr %143, align 4
  %1184 = load <2 x float>, ptr %12, align 4
  %1185 = call <2 x float> @b2Add(<2 x float> %1183, <2 x float> %1184)
  store <2 x float> %1185, ptr %142, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1178, ptr align 4 %142, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %142) #7
  %1186 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 5
  store float 0.000000e+00, ptr %1186, align 8, !tbaa !50
  %1187 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 9
  store ptr @.str.10, ptr %1187, align 8, !tbaa !51
  %1188 = load ptr, ptr %141, align 8, !tbaa !5
  %1189 = getelementptr inbounds %struct.Bone, ptr %1188, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %144) #7
  %1190 = load i32, ptr %11, align 2
  %1191 = call i64 @b2CreateBody(i32 %1190, ptr noundef %22)
  store i64 %1191, ptr %144, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1189, ptr align 4 %144, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %144) #7
  %1192 = load ptr, ptr %141, align 8, !tbaa !5
  %1193 = getelementptr inbounds %struct.Bone, ptr %1192, i32 0, i32 2
  store float 5.000000e-01, ptr %1193, align 4, !tbaa !22
  %1194 = load i8, ptr %20, align 1, !tbaa !13, !range !17, !noundef !18
  %1195 = trunc i8 %1194 to i1
  br i1 %1195, label %1196, label %1200

1196:                                             ; preds = %1094
  %1197 = load i32, ptr %30, align 4, !tbaa !11
  %1198 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 1
  %1199 = getelementptr inbounds %struct.b2SurfaceMaterial, ptr %1198, i32 0, i32 5
  store i32 %1197, ptr %1199, align 4, !tbaa !46
  br label %1200

1200:                                             ; preds = %1196, %1094
  call void @llvm.lifetime.start.p0(i64 20, ptr %145) #7
  %1201 = getelementptr inbounds %struct.b2Capsule, ptr %145, i32 0, i32 0
  %1202 = getelementptr inbounds %struct.b2Vec2, ptr %1201, i32 0, i32 0
  store float 0.000000e+00, ptr %1202, align 4, !tbaa !47
  %1203 = getelementptr inbounds %struct.b2Vec2, ptr %1201, i32 0, i32 1
  %1204 = load float, ptr %25, align 4, !tbaa !9
  %1205 = fmul float -1.250000e-01, %1204
  store float %1205, ptr %1203, align 4, !tbaa !48
  %1206 = getelementptr inbounds %struct.b2Capsule, ptr %145, i32 0, i32 1
  %1207 = getelementptr inbounds %struct.b2Vec2, ptr %1206, i32 0, i32 0
  store float 0.000000e+00, ptr %1207, align 4, !tbaa !47
  %1208 = getelementptr inbounds %struct.b2Vec2, ptr %1206, i32 0, i32 1
  %1209 = load float, ptr %25, align 4, !tbaa !9
  %1210 = fmul float 1.250000e-01, %1209
  store float %1210, ptr %1208, align 4, !tbaa !48
  %1211 = getelementptr inbounds %struct.b2Capsule, ptr %145, i32 0, i32 2
  %1212 = load float, ptr %25, align 4, !tbaa !9
  %1213 = fmul float 0x3FA1EB8520000000, %1212
  store float %1213, ptr %1211, align 4, !tbaa !52
  %1214 = load ptr, ptr %141, align 8, !tbaa !5
  %1215 = getelementptr inbounds %struct.Bone, ptr %1214, i32 0, i32 0
  %1216 = load i64, ptr %1215, align 4
  %1217 = call i64 @b2CreateCapsuleShape(i64 %1216, ptr noundef %23, ptr noundef %145)
  store i64 %1217, ptr %146, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %147) #7
  %1218 = getelementptr inbounds %struct.b2Vec2, ptr %148, i32 0, i32 0
  store float 0.000000e+00, ptr %1218, align 4, !tbaa !47
  %1219 = getelementptr inbounds %struct.b2Vec2, ptr %148, i32 0, i32 1
  %1220 = load float, ptr %25, align 4, !tbaa !9
  %1221 = fmul float 0x3FF59999A0000000, %1220
  store float %1221, ptr %1219, align 4, !tbaa !48
  %1222 = load <2 x float>, ptr %148, align 4
  %1223 = load <2 x float>, ptr %12, align 4
  %1224 = call <2 x float> @b2Add(<2 x float> %1222, <2 x float> %1223)
  store <2 x float> %1224, ptr %147, align 4
  call void @llvm.lifetime.start.p0(i64 96, ptr %149) #7
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind writable sret(%struct.b2RevoluteJointDef) align 8 %149)
  %1225 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 0
  %1226 = load ptr, ptr %13, align 8, !tbaa !5
  %1227 = getelementptr inbounds %struct.Human, ptr %1226, i32 0, i32 0
  %1228 = load ptr, ptr %141, align 8, !tbaa !5
  %1229 = getelementptr inbounds %struct.Bone, ptr %1228, i32 0, i32 3
  %1230 = load i32, ptr %1229, align 4, !tbaa !26
  %1231 = sext i32 %1230 to i64
  %1232 = getelementptr inbounds [11 x %struct.Bone], ptr %1227, i64 0, i64 %1231
  %1233 = getelementptr inbounds %struct.Bone, ptr %1232, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1225, ptr align 4 %1233, i64 8, i1 false), !tbaa.struct !19
  %1234 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 1
  %1235 = load ptr, ptr %141, align 8, !tbaa !5
  %1236 = getelementptr inbounds %struct.Bone, ptr %1235, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1234, ptr align 4 %1236, i64 8, i1 false), !tbaa.struct !19
  %1237 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %150) #7
  %1238 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 0
  %1239 = load i64, ptr %1238, align 8
  %1240 = load <2 x float>, ptr %147, align 4
  %1241 = call <2 x float> @b2Body_GetLocalPoint(i64 %1239, <2 x float> %1240)
  store <2 x float> %1241, ptr %150, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1237, ptr align 4 %150, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %150) #7
  %1242 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 3
  call void @llvm.lifetime.start.p0(i64 8, ptr %151) #7
  %1243 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 1
  %1244 = load i64, ptr %1243, align 8
  %1245 = load <2 x float>, ptr %147, align 4
  %1246 = call <2 x float> @b2Body_GetLocalPoint(i64 %1244, <2 x float> %1245)
  store <2 x float> %1246, ptr %151, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1242, ptr align 4 %151, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %151) #7
  %1247 = load i8, ptr %28, align 1, !tbaa !13, !range !17, !noundef !18
  %1248 = trunc i8 %1247 to i1
  %1249 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 8
  %1250 = zext i1 %1248 to i8
  store i8 %1250, ptr %1249, align 8, !tbaa !54
  %1251 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 9
  store float 0xBFD41B2F80000000, ptr %1251, align 4, !tbaa !56
  %1252 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 10
  store float 0x40041B2F80000000, ptr %1252, align 8, !tbaa !57
  %1253 = load i8, ptr %27, align 1, !tbaa !13, !range !17, !noundef !18
  %1254 = trunc i8 %1253 to i1
  %1255 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 11
  %1256 = zext i1 %1254 to i8
  store i8 %1256, ptr %1255, align 4, !tbaa !58
  %1257 = load ptr, ptr %141, align 8, !tbaa !5
  %1258 = getelementptr inbounds %struct.Bone, ptr %1257, i32 0, i32 2
  %1259 = load float, ptr %1258, align 4, !tbaa !22
  %1260 = load float, ptr %26, align 4, !tbaa !9
  %1261 = fmul float %1259, %1260
  %1262 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 12
  store float %1261, ptr %1262, align 8, !tbaa !59
  %1263 = load float, ptr %16, align 4, !tbaa !9
  %1264 = fcmp ogt float %1263, 0.000000e+00
  %1265 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 5
  %1266 = zext i1 %1264 to i8
  store i8 %1266, ptr %1265, align 4, !tbaa !60
  %1267 = load float, ptr %16, align 4, !tbaa !9
  %1268 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 6
  store float %1267, ptr %1268, align 8, !tbaa !61
  %1269 = load float, ptr %17, align 4, !tbaa !9
  %1270 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 7
  store float %1269, ptr %1270, align 4, !tbaa !62
  %1271 = load float, ptr %29, align 4, !tbaa !9
  %1272 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %149, i32 0, i32 14
  store float %1271, ptr %1272, align 8, !tbaa !63
  %1273 = load ptr, ptr %141, align 8, !tbaa !5
  %1274 = getelementptr inbounds %struct.Bone, ptr %1273, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %152) #7
  %1275 = load i32, ptr %11, align 2
  %1276 = call i64 @b2CreateRevoluteJoint(i32 %1275, ptr noundef %149)
  store i64 %1276, ptr %152, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1274, ptr align 4 %152, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %152) #7
  call void @llvm.lifetime.end.p0(i64 96, ptr %149) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %147) #7
  call void @llvm.lifetime.end.p0(i64 20, ptr %145) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %141) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %153) #7
  %1277 = load ptr, ptr %13, align 8, !tbaa !5
  %1278 = getelementptr inbounds %struct.Human, ptr %1277, i32 0, i32 0
  %1279 = getelementptr inbounds [11 x %struct.Bone], ptr %1278, i64 0, i64 0
  %1280 = getelementptr inbounds %struct.Bone, ptr %1279, i64 10
  store ptr %1280, ptr %153, align 8, !tbaa !5
  %1281 = load ptr, ptr %153, align 8, !tbaa !5
  %1282 = getelementptr inbounds %struct.Bone, ptr %1281, i32 0, i32 3
  store i32 9, ptr %1282, align 4, !tbaa !26
  %1283 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %154) #7
  %1284 = getelementptr inbounds %struct.b2Vec2, ptr %155, i32 0, i32 0
  store float 0.000000e+00, ptr %1284, align 4, !tbaa !47
  %1285 = getelementptr inbounds %struct.b2Vec2, ptr %155, i32 0, i32 1
  %1286 = load float, ptr %25, align 4, !tbaa !9
  %1287 = fmul float 0x3FEF333340000000, %1286
  store float %1287, ptr %1285, align 4, !tbaa !48
  %1288 = load <2 x float>, ptr %155, align 4
  %1289 = load <2 x float>, ptr %12, align 4
  %1290 = call <2 x float> @b2Add(<2 x float> %1288, <2 x float> %1289)
  store <2 x float> %1290, ptr %154, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1283, ptr align 4 %154, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %154) #7
  %1291 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 5
  store float 0x3FB99999A0000000, ptr %1291, align 8, !tbaa !50
  %1292 = getelementptr inbounds %struct.b2BodyDef, ptr %22, i32 0, i32 9
  store ptr @.str.11, ptr %1292, align 8, !tbaa !51
  %1293 = load ptr, ptr %153, align 8, !tbaa !5
  %1294 = getelementptr inbounds %struct.Bone, ptr %1293, i32 0, i32 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %156) #7
  %1295 = load i32, ptr %11, align 2
  %1296 = call i64 @b2CreateBody(i32 %1295, ptr noundef %22)
  store i64 %1296, ptr %156, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1294, ptr align 4 %156, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %156) #7
  %1297 = load ptr, ptr %153, align 8, !tbaa !5
  %1298 = getelementptr inbounds %struct.Bone, ptr %1297, i32 0, i32 2
  store float 0x3FB99999A0000000, ptr %1298, align 4, !tbaa !22
  %1299 = load i8, ptr %20, align 1, !tbaa !13, !range !17, !noundef !18
  %1300 = trunc i8 %1299 to i1
  br i1 %1300, label %1301, label %1305

1301:                                             ; preds = %1200
  %1302 = load i32, ptr %33, align 4, !tbaa !11
  %1303 = getelementptr inbounds %struct.b2ShapeDef, ptr %23, i32 0, i32 1
  %1304 = getelementptr inbounds %struct.b2SurfaceMaterial, ptr %1303, i32 0, i32 5
  store i32 %1302, ptr %1304, align 4, !tbaa !46
  br label %1305

1305:                                             ; preds = %1301, %1200
  call void @llvm.lifetime.start.p0(i64 20, ptr %157) #7
  %1306 = getelementptr inbounds %struct.b2Capsule, ptr %157, i32 0, i32 0
  %1307 = getelementptr inbounds %struct.b2Vec2, ptr %1306, i32 0, i32 0
  store float 0.000000e+00, ptr %1307, align 4, !tbaa !47
  %1308 = getelementptr inbounds %struct.b2Vec2, ptr %1306, i32 0, i32 1
  %1309 = load float, ptr %25, align 4, !tbaa !9
  %1310 = fmul float -1.250000e-01, %1309
  store float %1310, ptr %1308, align 4, !tbaa !48
  %1311 = getelementptr inbounds %struct.b2Capsule, ptr %157, i32 0, i32 1
  %1312 = getelementptr inbounds %struct.b2Vec2, ptr %1311, i32 0, i32 0
  store float 0.000000e+00, ptr %1312, align 4, !tbaa !47
  %1313 = getelementptr inbounds %struct.b2Vec2, ptr %1311, i32 0, i32 1
  %1314 = load float, ptr %25, align 4, !tbaa !9
  %1315 = fmul float 1.250000e-01, %1314
  store float %1315, ptr %1313, align 4, !tbaa !48
  %1316 = getelementptr inbounds %struct.b2Capsule, ptr %157, i32 0, i32 2
  %1317 = load float, ptr %25, align 4, !tbaa !9
  %1318 = fmul float 0x3F9EB851E0000000, %1317
  store float %1318, ptr %1316, align 4, !tbaa !52
  %1319 = load ptr, ptr %153, align 8, !tbaa !5
  %1320 = getelementptr inbounds %struct.Bone, ptr %1319, i32 0, i32 0
  %1321 = load i64, ptr %1320, align 4
  %1322 = call i64 @b2CreateCapsuleShape(i64 %1321, ptr noundef %23, ptr noundef %157)
  store i64 %1322, ptr %158, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %159) #7
  %1323 = getelementptr inbounds %struct.b2Vec2, ptr %160, i32 0, i32 0
  store float 0.000000e+00, ptr %1323, align 4, !tbaa !47
  %1324 = getelementptr inbounds %struct.b2Vec2, ptr %160, i32 0, i32 1
  %1325 = load float, ptr %25, align 4, !tbaa !9
  %1326 = fmul float 0x3FF19999A0000000, %1325
  store float %1326, ptr %1324, align 4, !tbaa !48
  %1327 = load <2 x float>, ptr %160, align 4
  %1328 = load <2 x float>, ptr %12, align 4
  %1329 = call <2 x float> @b2Add(<2 x float> %1327, <2 x float> %1328)
  store <2 x float> %1329, ptr %159, align 4
  call void @llvm.lifetime.start.p0(i64 96, ptr %161) #7
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind writable sret(%struct.b2RevoluteJointDef) align 8 %161)
  %1330 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 0
  %1331 = load ptr, ptr %13, align 8, !tbaa !5
  %1332 = getelementptr inbounds %struct.Human, ptr %1331, i32 0, i32 0
  %1333 = load ptr, ptr %153, align 8, !tbaa !5
  %1334 = getelementptr inbounds %struct.Bone, ptr %1333, i32 0, i32 3
  %1335 = load i32, ptr %1334, align 4, !tbaa !26
  %1336 = sext i32 %1335 to i64
  %1337 = getelementptr inbounds [11 x %struct.Bone], ptr %1332, i64 0, i64 %1336
  %1338 = getelementptr inbounds %struct.Bone, ptr %1337, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1330, ptr align 4 %1338, i64 8, i1 false), !tbaa.struct !19
  %1339 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 1
  %1340 = load ptr, ptr %153, align 8, !tbaa !5
  %1341 = getelementptr inbounds %struct.Bone, ptr %1340, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1339, ptr align 4 %1341, i64 8, i1 false), !tbaa.struct !19
  %1342 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %162) #7
  %1343 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 0
  %1344 = load i64, ptr %1343, align 8
  %1345 = load <2 x float>, ptr %159, align 4
  %1346 = call <2 x float> @b2Body_GetLocalPoint(i64 %1344, <2 x float> %1345)
  store <2 x float> %1346, ptr %162, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1342, ptr align 4 %162, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %162) #7
  %1347 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 3
  call void @llvm.lifetime.start.p0(i64 8, ptr %163) #7
  %1348 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 1
  %1349 = load i64, ptr %1348, align 8
  %1350 = load <2 x float>, ptr %159, align 4
  %1351 = call <2 x float> @b2Body_GetLocalPoint(i64 %1349, <2 x float> %1350)
  store <2 x float> %1351, ptr %163, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %1347, ptr align 4 %163, i64 8, i1 false), !tbaa.struct !49
  call void @llvm.lifetime.end.p0(i64 8, ptr %163) #7
  %1352 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 4
  store float 0x3FE921FB60000000, ptr %1352, align 8, !tbaa !64
  %1353 = load i8, ptr %28, align 1, !tbaa !13, !range !17, !noundef !18
  %1354 = trunc i8 %1353 to i1
  %1355 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 8
  %1356 = zext i1 %1354 to i8
  store i8 %1356, ptr %1355, align 8, !tbaa !54
  %1357 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 9
  store float 0xBFE41B2F80000000, ptr %1357, align 4, !tbaa !56
  %1358 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 10
  store float 0x3FEE28C760000000, ptr %1358, align 8, !tbaa !57
  %1359 = load i8, ptr %27, align 1, !tbaa !13, !range !17, !noundef !18
  %1360 = trunc i8 %1359 to i1
  %1361 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 11
  %1362 = zext i1 %1360 to i8
  store i8 %1362, ptr %1361, align 4, !tbaa !58
  %1363 = load ptr, ptr %153, align 8, !tbaa !5
  %1364 = getelementptr inbounds %struct.Bone, ptr %1363, i32 0, i32 2
  %1365 = load float, ptr %1364, align 4, !tbaa !22
  %1366 = load float, ptr %26, align 4, !tbaa !9
  %1367 = fmul float %1365, %1366
  %1368 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 12
  store float %1367, ptr %1368, align 8, !tbaa !59
  %1369 = load float, ptr %16, align 4, !tbaa !9
  %1370 = fcmp ogt float %1369, 0.000000e+00
  %1371 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 5
  %1372 = zext i1 %1370 to i8
  store i8 %1372, ptr %1371, align 4, !tbaa !60
  %1373 = load float, ptr %16, align 4, !tbaa !9
  %1374 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 6
  store float %1373, ptr %1374, align 8, !tbaa !61
  %1375 = load float, ptr %17, align 4, !tbaa !9
  %1376 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 7
  store float %1375, ptr %1376, align 4, !tbaa !62
  %1377 = load float, ptr %29, align 4, !tbaa !9
  %1378 = getelementptr inbounds %struct.b2RevoluteJointDef, ptr %161, i32 0, i32 14
  store float %1377, ptr %1378, align 8, !tbaa !63
  %1379 = load ptr, ptr %153, align 8, !tbaa !5
  %1380 = getelementptr inbounds %struct.Bone, ptr %1379, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %164) #7
  %1381 = load i32, ptr %11, align 2
  %1382 = call i64 @b2CreateRevoluteJoint(i32 %1381, ptr noundef %161)
  store i64 %1382, ptr %164, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1380, ptr align 4 %164, i64 8, i1 false), !tbaa.struct !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %164) #7
  call void @llvm.lifetime.end.p0(i64 96, ptr %161) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %159) #7
  call void @llvm.lifetime.end.p0(i64 20, ptr %157) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %153) #7
  %1383 = load ptr, ptr %13, align 8, !tbaa !5
  %1384 = getelementptr inbounds %struct.Human, ptr %1383, i32 0, i32 2
  store i8 1, ptr %1384, align 4, !tbaa !15
  call void @llvm.lifetime.end.p0(i64 144, ptr %78) #7
  call void @llvm.lifetime.end.p0(i64 68, ptr %77) #7
  call void @llvm.lifetime.end.p0(i64 32, ptr %76) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr %32) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #7
  call void @llvm.lifetime.end.p0(i64 1, ptr %28) #7
  call void @llvm.lifetime.end.p0(i64 1, ptr %27) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #7
  call void @llvm.lifetime.end.p0(i64 80, ptr %24) #7
  call void @llvm.lifetime.end.p0(i64 80, ptr %23) #7
  call void @llvm.lifetime.end.p0(i64 80, ptr %22) #7
  ret void
}

; Function Attrs: noreturn nounwind
declare void @__assert_fail(ptr noundef, ptr noundef, i32 noundef, ptr noundef) #1

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

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

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

declare void @b2DefaultBodyDef(ptr dead_on_unwind writable sret(%struct.b2BodyDef) align 8) #4

declare void @b2DefaultShapeDef(ptr dead_on_unwind writable sret(%struct.b2ShapeDef) align 8) #4

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

declare i64 @b2CreateBody(i32, ptr noundef) #4

declare i64 @b2CreateCapsuleShape(i64, ptr noundef, ptr noundef) #4

declare void @b2DefaultRevoluteJointDef(ptr dead_on_unwind writable sret(%struct.b2RevoluteJointDef) align 8) #4

declare <2 x float> @b2Body_GetLocalPoint(i64, <2 x float>) #4

declare i64 @b2CreateRevoluteJoint(i32, ptr noundef) #4

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

declare void @b2MakePolygon(ptr dead_on_unwind writable sret(%struct.b2Polygon) align 4, ptr noundef, float noundef) #4

declare i64 @b2CreatePolygonShape(i64, ptr noundef, ptr noundef) #4

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"float", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"int", !7, i64 0}
!13 = !{!14, !14, i64 0}
!14 = !{!"_Bool", !7, i64 0}
!15 = !{!16, !14, i64 268}
!16 = !{!"Human", !7, i64 0, !10, i64 264, !14, i64 268}
!17 = !{i8 0, i8 2}
!18 = !{}
!19 = !{i64 0, i64 4, !11, i64 4, i64 2, !20, i64 6, i64 2, !20}
!20 = !{!21, !21, i64 0}
!21 = !{!"short", !7, i64 0}
!22 = !{!23, !10, i64 16}
!23 = !{!"Bone", !24, i64 0, !25, i64 8, !10, i64 16, !12, i64 20}
!24 = !{!"b2BodyId", !12, i64 0, !21, i64 4, !21, i64 6}
!25 = !{!"b2JointId", !12, i64 0, !21, i64 4, !21, i64 6}
!26 = !{!23, !12, i64 20}
!27 = distinct !{!27, !28}
!28 = !{!"llvm.loop.mustprogress"}
!29 = !{!16, !10, i64 264}
!30 = !{!31, !12, i64 0}
!31 = !{!"b2BodyDef", !12, i64 0, !32, i64 4, !33, i64 12, !32, i64 20, !10, i64 28, !10, i64 32, !10, i64 36, !10, i64 40, !10, i64 44, !6, i64 48, !6, i64 56, !14, i64 64, !14, i64 65, !14, i64 66, !14, i64 67, !14, i64 68, !14, i64 69, !12, i64 72}
!32 = !{!"b2Vec2", !10, i64 0, !10, i64 4}
!33 = !{!"b2Rot", !10, i64 0, !10, i64 4}
!34 = !{!31, !10, i64 44}
!35 = !{!31, !6, i64 56}
!36 = !{!37, !10, i64 8}
!37 = !{!"b2ShapeDef", !6, i64 0, !38, i64 8, !10, i64 32, !39, i64 40, !14, i64 64, !14, i64 65, !14, i64 66, !14, i64 67, !14, i64 68, !14, i64 69, !14, i64 70, !12, i64 72}
!38 = !{!"b2SurfaceMaterial", !10, i64 0, !10, i64 4, !10, i64 8, !10, i64 12, !12, i64 16, !12, i64 20}
!39 = !{!"b2Filter", !40, i64 0, !40, i64 8, !12, i64 16}
!40 = !{!"long", !7, i64 0}
!41 = !{!37, !12, i64 56}
!42 = !{!37, !40, i64 40}
!43 = !{!37, !40, i64 48}
!44 = !{i64 0, i64 8, !5, i64 8, i64 4, !9, i64 12, i64 4, !9, i64 16, i64 4, !9, i64 20, i64 4, !9, i64 24, i64 4, !11, i64 28, i64 4, !11, i64 32, i64 4, !9, i64 40, i64 8, !45, i64 48, i64 8, !45, i64 56, i64 4, !11, i64 64, i64 1, !13, i64 65, i64 1, !13, i64 66, i64 1, !13, i64 67, i64 1, !13, i64 68, i64 1, !13, i64 69, i64 1, !13, i64 70, i64 1, !13, i64 72, i64 4, !11}
!45 = !{!40, !40, i64 0}
!46 = !{!37, !12, i64 28}
!47 = !{!32, !10, i64 0}
!48 = !{!32, !10, i64 4}
!49 = !{i64 0, i64 4, !9, i64 4, i64 4, !9}
!50 = !{!31, !10, i64 32}
!51 = !{!31, !6, i64 48}
!52 = !{!53, !10, i64 16}
!53 = !{!"b2Capsule", !32, i64 0, !32, i64 8, !10, i64 16}
!54 = !{!55, !14, i64 48}
!55 = !{!"b2RevoluteJointDef", !24, i64 0, !24, i64 8, !32, i64 16, !32, i64 24, !10, i64 32, !14, i64 36, !10, i64 40, !10, i64 44, !14, i64 48, !10, i64 52, !10, i64 56, !14, i64 60, !10, i64 64, !10, i64 68, !10, i64 72, !14, i64 76, !6, i64 80, !12, i64 88}
!56 = !{!55, !10, i64 52}
!57 = !{!55, !10, i64 56}
!58 = !{!55, !14, i64 60}
!59 = !{!55, !10, i64 64}
!60 = !{!55, !14, i64 36}
!61 = !{!55, !10, i64 40}
!62 = !{!55, !10, i64 44}
!63 = !{!55, !10, i64 72}
!64 = !{!55, !10, i64 32}


; 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.b2BodyId = type { i32, i16, i16 }
%struct.b2JointId = type { i32, i16, i16 }
%struct.b2BodyDef = type { i32, %struct.b2Vec2, %struct.b2Rot, %struct.b2Vec2, float, float, float, float, float, ptr, ptr, i8, i8, i8, i8, i8, i8, i32 }
%struct.b2Rot = type { float, float }
%struct.b2Vec2 = type { float, float }
%struct.b2ShapeDef = type { ptr, %struct.b2SurfaceMaterial, float, %struct.b2Filter, i8, i8, i8, i8, i8, i8, i8, i32 }
%struct.b2SurfaceMaterial = type { float, float, float, float, i32, i32 }
%struct.b2Filter = type { i64, i64, i32 }
%struct.b2Capsule = type { %struct.b2Vec2, %struct.b2Vec2, float }
%struct.b2RevoluteJointDef = type { %struct.b2BodyId, %struct.b2BodyId, %struct.b2Vec2, %struct.b2Vec2, float, i8, float, float, i8, float, float, i8, float, float, float, i8, ptr, i32 }
%struct.b2Hull = type { [8 x %struct.b2Vec2], i32 }
%struct.b2Polygon = type { [8 x %struct.b2Vec2], [8 x %struct.b2Vec2], %struct.b2Vec2, float, i32 }
%struct.Bone = type { %struct.b2BodyId, %struct.b2JointId, float, i32 }

@.str = external hidden unnamed_addr constant [26 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [64 x i8], align 1
@__PRETTY_FUNCTION__.CreateHuman = external hidden unnamed_addr constant [93 x i8], align 1
@b2_nullBodyId = external hidden local_unnamed_addr constant %struct.b2BodyId, align 4
@b2_nullJointId = external hidden local_unnamed_addr constant %struct.b2JointId, align 4
@__const.CreateHuman.skinColors = external hidden unnamed_addr constant [4 x i32], align 16
@.str.2 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [16 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @CreateHuman(ptr noundef %0, i32 %1, <2 x float> %2, float noundef %3, float noundef %4, float noundef %5, float noundef %6, i32 noundef %7, ptr noundef %8, i1 noundef zeroext %9) local_unnamed_addr #0 {
  %11 = alloca %struct.b2BodyDef, align 8
  %12 = alloca %struct.b2ShapeDef, align 8
  %13 = alloca %struct.b2ShapeDef, align 8
  %14 = alloca %struct.b2Capsule, align 4
  %15 = alloca %struct.b2Capsule, align 4
  %16 = alloca %struct.b2RevoluteJointDef, align 8
  %17 = alloca %struct.b2Capsule, align 4
  %18 = alloca %struct.b2RevoluteJointDef, align 8
  %19 = alloca %struct.b2Capsule, align 4
  %20 = alloca %struct.b2RevoluteJointDef, align 8
  %21 = alloca [4 x %struct.b2Vec2], align 16
  %22 = alloca %struct.b2Hull, align 4
  %23 = alloca %struct.b2Polygon, align 4
  %24 = alloca %struct.b2Capsule, align 4
  %25 = alloca %struct.b2RevoluteJointDef, align 8
  %26 = alloca %struct.b2Capsule, align 4
  %27 = alloca %struct.b2RevoluteJointDef, align 8
  %28 = alloca %struct.b2Capsule, align 4
  %29 = alloca %struct.b2RevoluteJointDef, align 8
  %30 = alloca %struct.b2Capsule, align 4
  %31 = alloca %struct.b2RevoluteJointDef, align 8
  %32 = alloca %struct.b2Capsule, align 4
  %33 = alloca %struct.b2RevoluteJointDef, align 8
  %34 = alloca %struct.b2Capsule, align 4
  %35 = alloca %struct.b2RevoluteJointDef, align 8
  %36 = alloca %struct.b2Capsule, align 4
  %37 = alloca %struct.b2RevoluteJointDef, align 8
  %38 = getelementptr inbounds i8, ptr %0, i64 268
  %39 = load i8, ptr %38, align 4, !tbaa !5, !range !11, !noundef !12
  %40 = icmp eq i8 %39, 0
  br i1 %40, label %.preheader, label %97

.preheader:                                       ; preds = %10
  %41 = load i64, ptr @b2_nullBodyId, align 4
  %42 = load i64, ptr @b2_nullJointId, align 4
  store i64 %41, ptr %0, align 4
  %43 = getelementptr inbounds i8, ptr %0, i64 8
  store i64 %42, ptr %43, align 4
  %44 = getelementptr inbounds i8, ptr %0, i64 16
  store float 1.000000e+00, ptr %44, align 4, !tbaa !13
  %45 = getelementptr inbounds i8, ptr %0, i64 20
  store i32 -1, ptr %45, align 4, !tbaa !19
  %46 = getelementptr inbounds i8, ptr %0, i64 24
  store i64 %41, ptr %46, align 4
  %47 = getelementptr inbounds i8, ptr %0, i64 32
  store i64 %42, ptr %47, align 4
  %48 = getelementptr inbounds i8, ptr %0, i64 40
  store float 1.000000e+00, ptr %48, align 4, !tbaa !13
  %49 = getelementptr inbounds i8, ptr %0, i64 44
  store i32 -1, ptr %49, align 4, !tbaa !19
  %50 = getelementptr inbounds i8, ptr %0, i64 48
  store i64 %41, ptr %50, align 4
  %51 = getelementptr inbounds i8, ptr %0, i64 56
  store i64 %42, ptr %51, align 4
  %52 = getelementptr inbounds i8, ptr %0, i64 64
  store float 1.000000e+00, ptr %52, align 4, !tbaa !13
  %53 = getelementptr inbounds i8, ptr %0, i64 68
  store i32 -1, ptr %53, align 4, !tbaa !19
  %54 = getelementptr inbounds i8, ptr %0, i64 72
  store i64 %41, ptr %54, align 4
  %55 = getelementptr inbounds i8, ptr %0, i64 80
  store i64 %42, ptr %55, align 4
  %56 = getelementptr inbounds i8, ptr %0, i64 88
  store float 1.000000e+00, ptr %56, align 4, !tbaa !13
  %57 = getelementptr inbounds i8, ptr %0, i64 92
  store i32 -1, ptr %57, align 4, !tbaa !19
  %58 = getelementptr inbounds i8, ptr %0, i64 96
  store i64 %41, ptr %58, align 4
  %59 = getelementptr inbounds i8, ptr %0, i64 104
  store i64 %42, ptr %59, align 4
  %60 = getelementptr inbounds i8, ptr %0, i64 112
  store float 1.000000e+00, ptr %60, align 4, !tbaa !13
  %61 = getelementptr inbounds i8, ptr %0, i64 116
  store i32 -1, ptr %61, align 4, !tbaa !19
  %62 = getelementptr inbounds i8, ptr %0, i64 120
  store i64 %41, ptr %62, align 4
  %63 = getelementptr inbounds i8, ptr %0, i64 128
  store i64 %42, ptr %63, align 4
  %64 = getelementptr inbounds i8, ptr %0, i64 136
  store float 1.000000e+00, ptr %64, align 4, !tbaa !13
  %65 = getelementptr inbounds i8, ptr %0, i64 140
  store i32 -1, ptr %65, align 4, !tbaa !19
  %66 = getelementptr inbounds i8, ptr %0, i64 144
  store i64 %41, ptr %66, align 4
  %67 = getelementptr inbounds i8, ptr %0, i64 152
  store i64 %42, ptr %67, align 4
  %68 = getelementptr inbounds i8, ptr %0, i64 160
  store float 1.000000e+00, ptr %68, align 4, !tbaa !13
  %69 = getelementptr inbounds i8, ptr %0, i64 164
  store i32 -1, ptr %69, align 4, !tbaa !19
  %70 = getelementptr inbounds i8, ptr %0, i64 168
  store i64 %41, ptr %70, align 4
  %71 = getelementptr inbounds i8, ptr %0, i64 176
  store i64 %42, ptr %71, align 4
  %72 = getelementptr inbounds i8, ptr %0, i64 184
  store float 1.000000e+00, ptr %72, align 4, !tbaa !13
  %73 = getelementptr inbounds i8, ptr %0, i64 188
  store i32 -1, ptr %73, align 4, !tbaa !19
  %74 = getelementptr inbounds i8, ptr %0, i64 192
  store i64 %41, ptr %74, align 4
  %75 = getelementptr inbounds i8, ptr %0, i64 200
  store i64 %42, ptr %75, align 4
  %76 = getelementptr inbounds i8, ptr %0, i64 208
  store float 1.000000e+00, ptr %76, align 4, !tbaa !13
  %77 = getelementptr inbounds i8, ptr %0, i64 212
  store i32 -1, ptr %77, align 4, !tbaa !19
  %78 = getelementptr inbounds i8, ptr %0, i64 216
  store i64 %41, ptr %78, align 4
  %79 = getelementptr inbounds i8, ptr %0, i64 224
  store i64 %42, ptr %79, align 4
  %80 = getelementptr inbounds i8, ptr %0, i64 232
  store float 1.000000e+00, ptr %80, align 4, !tbaa !13
  %81 = getelementptr inbounds i8, ptr %0, i64 236
  store i32 -1, ptr %81, align 4, !tbaa !19
  %82 = getelementptr inbounds i8, ptr %0, i64 240
  store i64 %41, ptr %82, align 4
  %83 = getelementptr inbounds i8, ptr %0, i64 248
  store i64 %42, ptr %83, align 4
  %84 = getelementptr inbounds i8, ptr %0, i64 256
  store float 1.000000e+00, ptr %84, align 4, !tbaa !13
  %85 = getelementptr inbounds i8, ptr %0, i64 260
  store i32 -1, ptr %85, align 4, !tbaa !19
  %86 = getelementptr inbounds i8, ptr %0, i64 264
  store float %3, ptr %86, align 4, !tbaa !20
  call void @llvm.lifetime.start.p0(i64 80, ptr nonnull %11) #6
  call void @b2DefaultBodyDef(ptr dead_on_unwind nonnull writable sret(%struct.b2BodyDef) align 8 %11) #6
  store i32 2, ptr %11, align 8, !tbaa !21
  %87 = getelementptr inbounds i8, ptr %11, i64 44
  store float 0x3FB99999A0000000, ptr %87, align 4, !tbaa !26
  %88 = getelementptr inbounds i8, ptr %11, i64 56
  store ptr %8, ptr %88, align 8, !tbaa !27
  call void @llvm.lifetime.start.p0(i64 80, ptr nonnull %12) #6
  call void @b2DefaultShapeDef(ptr dead_on_unwind nonnull writable sret(%struct.b2ShapeDef) align 8 %12) #6
  %89 = getelementptr inbounds i8, ptr %12, i64 8
  store float 0x3FC99999A0000000, ptr %89, align 8, !tbaa !28
  %90 = sub nsw i32 0, %7
  %91 = getelementptr inbounds i8, ptr %12, i64 40
  %92 = getelementptr inbounds i8, ptr %12, i64 56
  store i32 %90, ptr %92, align 8, !tbaa !33
  store i64 2, ptr %91, align 8, !tbaa !34
  %93 = getelementptr inbounds i8, ptr %12, i64 48
  store i64 3, ptr %93, align 8, !tbaa !35
  call void @llvm.lifetime.start.p0(i64 80, ptr nonnull %13) #6
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(80) %13, ptr noundef nonnull align 8 dereferenceable(80) %12, i64 80, i1 false), !tbaa.struct !36
  %94 = getelementptr inbounds i8, ptr %13, i64 8
  store float 0x3FA99999A0000000, ptr %94, align 8, !tbaa !28
  %95 = getelementptr inbounds i8, ptr %13, i64 40
  store i64 2, ptr %95, align 8, !tbaa !34
  %96 = getelementptr inbounds i8, ptr %13, i64 48
  store i64 1, ptr %96, align 8, !tbaa !35
  br i1 %9, label %98, label %100

97:                                               ; preds = %10
  tail call void @__assert_fail(ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, i32 noundef 16, ptr noundef nonnull @__PRETTY_FUNCTION__.CreateHuman) #7
  unreachable

98:                                               ; preds = %.preheader
  %99 = getelementptr inbounds i8, ptr %13, i64 28
  store i32 9127187, ptr %99, align 4, !tbaa !42
  br label %100

100:                                              ; preds = %98, %.preheader
  %101 = fmul float %3, %4
  %102 = srem i32 %7, 4
  %103 = sext i32 %102 to i64
  %104 = getelementptr inbounds [4 x i32], ptr @__const.CreateHuman.skinColors, i64 0, i64 %103
  %105 = load i32, ptr %104, align 4, !tbaa !39
  store i32 -1, ptr %45, align 4, !tbaa !19
  %106 = getelementptr inbounds i8, ptr %11, i64 4
  %107 = fmul float %3, 0x3FEE666660000000
  %.sroa.0205.4.vec.insert = insertelement <2 x float> <float 0.000000e+00, float poison>, float %107, i64 1
  %108 = call <2 x float> @b2Add(<2 x float> %.sroa.0205.4.vec.insert, <2 x float> %2)
  store <2 x float> %108, ptr %106, align 4
  %109 = getelementptr inbounds i8, ptr %11, i64 32
  store float 0.000000e+00, ptr %109, align 8, !tbaa !43
  %110 = getelementptr inbounds i8, ptr %11, i64 48
  store ptr @.str.2, ptr %110, align 8, !tbaa !44
  %111 = call i64 @b2CreateBody(i32 %1, ptr noundef nonnull %11) #6
  store i64 %111, ptr %0, align 4
  br i1 %9, label %112, label %114

112:                                              ; preds = %100
  %113 = getelementptr inbounds i8, ptr %12, i64 28
  store i32 2003199, ptr %113, align 4, !tbaa !42
  br label %114

114:                                              ; preds = %112, %100
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %14) #6
  store float 0.000000e+00, ptr %14, align 4, !tbaa !45
  %115 = getelementptr inbounds i8, ptr %14, i64 4
  %116 = fmul float %3, 0xBF947AE140000000
  store float %116, ptr %115, align 4, !tbaa !46
  %117 = getelementptr inbounds i8, ptr %14, i64 8
  store float 0.000000e+00, ptr %117, align 4, !tbaa !45
  %118 = getelementptr inbounds i8, ptr %14, i64 12
  %119 = insertelement <2 x float> poison, float %3, i64 0
  %120 = shufflevector <2 x float> %119, <2 x float> poison, <2 x i32> zeroinitializer
  %121 = fmul <2 x float> %120, <float 0x3F947AE140000000, float 0x3FB851EB80000000>
  store <2 x float> %121, ptr %118, align 4, !tbaa !38
  %122 = call i64 @b2CreateCapsuleShape(i64 %111, ptr noundef nonnull %12, ptr noundef nonnull %14) #6
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %14) #6
  %123 = getelementptr inbounds i8, ptr %0, i64 44
  store i32 0, ptr %123, align 4, !tbaa !19
  %124 = fmul float %3, 0x3FF3333340000000
  %.sroa.0192.4.vec.insert = insertelement <2 x float> <float 0.000000e+00, float poison>, float %124, i64 1
  %125 = call <2 x float> @b2Add(<2 x float> %.sroa.0192.4.vec.insert, <2 x float> %2)
  store <2 x float> %125, ptr %106, align 4
  store float 0.000000e+00, ptr %109, align 8, !tbaa !43
  store ptr @.str.3, ptr %110, align 8, !tbaa !44
  %126 = call i64 @b2CreateBody(i32 %1, ptr noundef nonnull %11) #6
  store i64 %126, ptr %46, align 4
  %127 = getelementptr inbounds i8, ptr %0, i64 40
  store float 5.000000e-01, ptr %127, align 4, !tbaa !13
  store i32 2, ptr %11, align 8, !tbaa !21
  br i1 %9, label %128, label %130

128:                                              ; preds = %114
  %129 = getelementptr inbounds i8, ptr %12, i64 28
  store i32 4772300, ptr %129, align 4, !tbaa !42
  br label %130

130:                                              ; preds = %128, %114
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %15) #6
  store float 0.000000e+00, ptr %15, align 4, !tbaa !45
  %131 = getelementptr inbounds i8, ptr %15, i64 4
  %132 = fmul float %3, 0xBFC147AE20000000
  store float %132, ptr %131, align 4, !tbaa !46
  %133 = getelementptr inbounds i8, ptr %15, i64 8
  store float 0.000000e+00, ptr %133, align 4, !tbaa !45
  %134 = getelementptr inbounds i8, ptr %15, i64 12
  %135 = fmul <2 x float> %120, <float 0x3FC147AE20000000, float 0x3FB70A3D80000000>
  store <2 x float> %135, ptr %134, align 4, !tbaa !38
  %136 = call i64 @b2CreateCapsuleShape(i64 %126, ptr noundef nonnull %12, ptr noundef nonnull %15) #6
  %.sroa.0186.4.vec.insert = insertelement <2 x float> <float 0.000000e+00, float poison>, float %3, i64 1
  %137 = call <2 x float> @b2Add(<2 x float> %.sroa.0186.4.vec.insert, <2 x float> %2)
  call void @llvm.lifetime.start.p0(i64 96, ptr nonnull %16) #6
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind nonnull writable sret(%struct.b2RevoluteJointDef) align 8 %16) #6
  %138 = load i32, ptr %123, align 4, !tbaa !19
  %139 = sext i32 %138 to i64
  %140 = getelementptr inbounds [11 x %struct.Bone], ptr %0, i64 0, i64 %139
  %141 = load i64, ptr %140, align 4
  store i64 %141, ptr %16, align 8
  %142 = getelementptr inbounds i8, ptr %16, i64 8
  %143 = load i64, ptr %46, align 4
  store i64 %143, ptr %142, align 8
  %144 = getelementptr inbounds i8, ptr %16, i64 16
  %145 = call <2 x float> @b2Body_GetLocalPoint(i64 %141, <2 x float> %137) #6
  store <2 x float> %145, ptr %144, align 8
  %146 = getelementptr inbounds i8, ptr %16, i64 24
  %147 = load i64, ptr %142, align 8
  %148 = call <2 x float> @b2Body_GetLocalPoint(i64 %147, <2 x float> %137) #6
  store <2 x float> %148, ptr %146, align 8
  %149 = getelementptr inbounds i8, ptr %16, i64 48
  store i8 1, ptr %149, align 8, !tbaa !47
  %150 = getelementptr inbounds i8, ptr %16, i64 52
  store <2 x float> <float 0xBFE921FB60000000, float 0.000000e+00>, ptr %150, align 4, !tbaa !38
  %151 = getelementptr inbounds i8, ptr %16, i64 60
  store i8 1, ptr %151, align 4, !tbaa !49
  %152 = load float, ptr %127, align 4, !tbaa !13
  %153 = fmul float %101, %152
  %154 = getelementptr inbounds i8, ptr %16, i64 64
  store float %153, ptr %154, align 8, !tbaa !50
  %155 = fcmp ogt float %5, 0.000000e+00
  %156 = getelementptr inbounds i8, ptr %16, i64 36
  %157 = zext i1 %155 to i8
  store i8 %157, ptr %156, align 4, !tbaa !51
  %158 = getelementptr inbounds i8, ptr %16, i64 40
  store float %5, ptr %158, align 8, !tbaa !52
  %159 = getelementptr inbounds i8, ptr %16, i64 44
  store float %6, ptr %159, align 4, !tbaa !53
  %160 = getelementptr inbounds i8, ptr %16, i64 72
  store float 0x3FA99999A0000000, ptr %160, align 8, !tbaa !54
  %161 = getelementptr inbounds i8, ptr %0, i64 32
  %162 = call i64 @b2CreateRevoluteJoint(i32 %1, ptr noundef nonnull %16) #6
  store i64 %162, ptr %161, align 4
  call void @llvm.lifetime.end.p0(i64 96, ptr nonnull %16) #6
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %15) #6
  %163 = getelementptr inbounds i8, ptr %0, i64 68
  store i32 1, ptr %163, align 4, !tbaa !19
  %164 = fmul <2 x float> %120, <float 0.000000e+00, float 0x3FF79999A0000000>
  %165 = call <2 x float> @b2Add(<2 x float> %164, <2 x float> %2)
  store <2 x float> %165, ptr %106, align 4
  store float 0x3FB99999A0000000, ptr %109, align 8, !tbaa !43
  store ptr @.str.4, ptr %110, align 8, !tbaa !44
  %166 = call i64 @b2CreateBody(i32 %1, ptr noundef nonnull %11) #6
  store i64 %166, ptr %50, align 4
  %167 = getelementptr inbounds i8, ptr %0, i64 64
  store float 2.500000e-01, ptr %167, align 4, !tbaa !13
  br i1 %9, label %168, label %170

168:                                              ; preds = %130
  %169 = getelementptr inbounds i8, ptr %12, i64 28
  store i32 %105, ptr %169, align 4, !tbaa !42
  br label %170

170:                                              ; preds = %168, %130
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %17) #6
  store float 0.000000e+00, ptr %17, align 4, !tbaa !45
  %171 = getelementptr inbounds i8, ptr %17, i64 4
  %172 = fmul float %3, 0xBFA374BC60000000
  store float %172, ptr %171, align 4, !tbaa !46
  %173 = getelementptr inbounds i8, ptr %17, i64 8
  store float 0.000000e+00, ptr %173, align 4, !tbaa !45
  %174 = getelementptr inbounds i8, ptr %17, i64 12
  %175 = fmul <2 x float> %120, <float 0x3FA3F7CEE0000000, float 0x3FB3333340000000>
  store <2 x float> %175, ptr %174, align 4, !tbaa !38
  %176 = call i64 @b2CreateCapsuleShape(i64 %166, ptr noundef nonnull %12, ptr noundef nonnull %17) #6
  %177 = fmul float %3, 0x3FF6666660000000
  %.sroa.0166.4.vec.insert = insertelement <2 x float> <float 0.000000e+00, float poison>, float %177, i64 1
  %178 = call <2 x float> @b2Add(<2 x float> %.sroa.0166.4.vec.insert, <2 x float> %2)
  call void @llvm.lifetime.start.p0(i64 96, ptr nonnull %18) #6
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind nonnull writable sret(%struct.b2RevoluteJointDef) align 8 %18) #6
  %179 = load i32, ptr %163, align 4, !tbaa !19
  %180 = sext i32 %179 to i64
  %181 = getelementptr inbounds [11 x %struct.Bone], ptr %0, i64 0, i64 %180
  %182 = load i64, ptr %181, align 4
  store i64 %182, ptr %18, align 8
  %183 = getelementptr inbounds i8, ptr %18, i64 8
  %184 = load i64, ptr %50, align 4
  store i64 %184, ptr %183, align 8
  %185 = getelementptr inbounds i8, ptr %18, i64 16
  %186 = call <2 x float> @b2Body_GetLocalPoint(i64 %182, <2 x float> %178) #6
  store <2 x float> %186, ptr %185, align 8
  %187 = getelementptr inbounds i8, ptr %18, i64 24
  %188 = load i64, ptr %183, align 8
  %189 = call <2 x float> @b2Body_GetLocalPoint(i64 %188, <2 x float> %178) #6
  store <2 x float> %189, ptr %187, align 8
  %190 = getelementptr inbounds i8, ptr %18, i64 48
  store i8 1, ptr %190, align 8, !tbaa !47
  %191 = getelementptr inbounds i8, ptr %18, i64 52
  store <2 x float> <float 0xBFEE28C760000000, float 0x3FD41B2F80000000>, ptr %191, align 4, !tbaa !38
  %192 = getelementptr inbounds i8, ptr %18, i64 60
  store i8 1, ptr %192, align 4, !tbaa !49
  %193 = load float, ptr %167, align 4, !tbaa !13
  %194 = fmul float %101, %193
  %195 = getelementptr inbounds i8, ptr %18, i64 64
  store float %194, ptr %195, align 8, !tbaa !50
  %196 = getelementptr inbounds i8, ptr %18, i64 36
  store i8 %157, ptr %196, align 4, !tbaa !51
  %197 = getelementptr inbounds i8, ptr %18, i64 40
  store float %5, ptr %197, align 8, !tbaa !52
  %198 = getelementptr inbounds i8, ptr %18, i64 44
  store float %6, ptr %198, align 4, !tbaa !53
  %199 = getelementptr inbounds i8, ptr %18, i64 72
  store float 0x3FA99999A0000000, ptr %199, align 8, !tbaa !54
  %200 = getelementptr inbounds i8, ptr %0, i64 56
  %201 = call i64 @b2CreateRevoluteJoint(i32 %1, ptr noundef nonnull %18) #6
  store i64 %201, ptr %200, align 4
  call void @llvm.lifetime.end.p0(i64 96, ptr nonnull %18) #6
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %17) #6
  %202 = getelementptr inbounds i8, ptr %0, i64 92
  store i32 0, ptr %202, align 4, !tbaa !19
  %203 = fmul float %3, 0x3FE8CCCCC0000000
  %.sroa.0152.4.vec.insert = insertelement <2 x float> <float 0.000000e+00, float poison>, float %203, i64 1
  %204 = call <2 x float> @b2Add(<2 x float> %.sroa.0152.4.vec.insert, <2 x float> %2)
  store <2 x float> %204, ptr %106, align 4
  store float 0.000000e+00, ptr %109, align 8, !tbaa !43
  store ptr @.str.5, ptr %110, align 8, !tbaa !44
  %205 = call i64 @b2CreateBody(i32 %1, ptr noundef nonnull %11) #6
  store i64 %205, ptr %54, align 4
  %206 = getelementptr inbounds i8, ptr %0, i64 88
  store float 1.000000e+00, ptr %206, align 4, !tbaa !13
  br i1 %9, label %207, label %209

207:                                              ; preds = %170
  %208 = getelementptr inbounds i8, ptr %12, i64 28
  store i32 2003199, ptr %208, align 4, !tbaa !42
  br label %209

209:                                              ; preds = %207, %170
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %19) #6
  store float 0.000000e+00, ptr %19, align 4, !tbaa !45
  %210 = getelementptr inbounds i8, ptr %19, i64 4
  %211 = fmul float %3, -1.250000e-01
  store float %211, ptr %210, align 4, !tbaa !46
  %212 = getelementptr inbounds i8, ptr %19, i64 8
  store float 0.000000e+00, ptr %212, align 4, !tbaa !45
  %213 = getelementptr inbounds i8, ptr %19, i64 12
  %214 = fmul <2 x float> %120, <float 1.250000e-01, float 0x3FAEB851E0000000>
  store <2 x float> %214, ptr %213, align 4, !tbaa !38
  %215 = call i64 @b2CreateCapsuleShape(i64 %205, ptr noundef nonnull %12, ptr noundef nonnull %19) #6
  %216 = fmul float %3, 0x3FECCCCCC0000000
  %.sroa.0146.4.vec.insert = insertelement <2 x float> <float 0.000000e+00, float poison>, float %216, i64 1
  %217 = call <2 x float> @b2Add(<2 x float> %.sroa.0146.4.vec.insert, <2 x float> %2)
  call void @llvm.lifetime.start.p0(i64 96, ptr nonnull %20) #6
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind nonnull writable sret(%struct.b2RevoluteJointDef) align 8 %20) #6
  %218 = load i32, ptr %202, align 4, !tbaa !19
  %219 = sext i32 %218 to i64
  %220 = getelementptr inbounds [11 x %struct.Bone], ptr %0, i64 0, i64 %219
  %221 = load i64, ptr %220, align 4
  store i64 %221, ptr %20, align 8
  %222 = getelementptr inbounds i8, ptr %20, i64 8
  %223 = load i64, ptr %54, align 4
  store i64 %223, ptr %222, align 8
  %224 = getelementptr inbounds i8, ptr %20, i64 16
  %225 = call <2 x float> @b2Body_GetLocalPoint(i64 %221, <2 x float> %217) #6
  store <2 x float> %225, ptr %224, align 8
  %226 = getelementptr inbounds i8, ptr %20, i64 24
  %227 = load i64, ptr %222, align 8
  %228 = call <2 x float> @b2Body_GetLocalPoint(i64 %227, <2 x float> %217) #6
  store <2 x float> %228, ptr %226, align 8
  %229 = getelementptr inbounds i8, ptr %20, i64 48
  store i8 1, ptr %229, align 8, !tbaa !47
  %230 = getelementptr inbounds i8, ptr %20, i64 52
  store <2 x float> <float 0xBFC41B2F80000000, float 0x3FF41B2F80000000>, ptr %230, align 4, !tbaa !38
  %231 = getelementptr inbounds i8, ptr %20, i64 60
  store i8 1, ptr %231, align 4, !tbaa !49
  %232 = load float, ptr %206, align 4, !tbaa !13
  %233 = fmul float %101, %232
  %234 = getelementptr inbounds i8, ptr %20, i64 64
  store float %233, ptr %234, align 8, !tbaa !50
  %235 = getelementptr inbounds i8, ptr %20, i64 36
  store i8 %157, ptr %235, align 4, !tbaa !51
  %236 = getelementptr inbounds i8, ptr %20, i64 40
  store float %5, ptr %236, align 8, !tbaa !52
  %237 = getelementptr inbounds i8, ptr %20, i64 44
  store float %6, ptr %237, align 4, !tbaa !53
  %238 = getelementptr inbounds i8, ptr %20, i64 72
  store float 0x3FA99999A0000000, ptr %238, align 8, !tbaa !54
  %239 = getelementptr inbounds i8, ptr %0, i64 80
  %240 = call i64 @b2CreateRevoluteJoint(i32 %1, ptr noundef nonnull %20) #6
  store i64 %240, ptr %239, align 4
  call void @llvm.lifetime.end.p0(i64 96, ptr nonnull %20) #6
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %19) #6
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %21) #6
  %241 = fmul <2 x float> %120, <float 0xBFC47AE140000000, float 0xBF9EB851E0000000>
  %242 = extractelement <2 x float> %241, i64 1
  store float %242, ptr %21, align 16, !tbaa !45
  %243 = getelementptr inbounds i8, ptr %21, i64 4
  %244 = fmul <2 x float> %120, <float 0xBFC7AE1480000000, float 0x3FBC28F5C0000000>
  %245 = shufflevector <2 x float> %244, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
  store <4 x float> %245, ptr %243, align 4, !tbaa !38
  %246 = getelementptr inbounds i8, ptr %21, i64 20
  store <2 x float> %241, ptr %246, align 4, !tbaa !38
  %247 = getelementptr inbounds i8, ptr %21, i64 28
  %248 = fmul float %3, 0xBFC1EB8520000000
  store float %248, ptr %247, align 4, !tbaa !46
  call void @llvm.lifetime.start.p0(i64 68, ptr nonnull %22) #6
  call void @b2ComputeHull(ptr dead_on_unwind nonnull writable sret(%struct.b2Hull) align 4 %22, ptr noundef nonnull %21, i32 noundef 4) #6
  call void @llvm.lifetime.start.p0(i64 144, ptr nonnull %23) #6
  %249 = fmul float %3, 0x3F8EB851E0000000
  call void @b2MakePolygon(ptr dead_on_unwind nonnull writable sret(%struct.b2Polygon) align 4 %23, ptr noundef nonnull %22, float noundef %249) #6
  %250 = getelementptr inbounds i8, ptr %0, i64 116
  store i32 3, ptr %250, align 4, !tbaa !19
  %251 = fmul float %3, 0x3FDE666660000000
  %.sroa.0131.4.vec.insert = insertelement <2 x float> <float 0.000000e+00, float poison>, float %251, i64 1
  %252 = call <2 x float> @b2Add(<2 x float> %.sroa.0131.4.vec.insert, <2 x float> %2)
  store <2 x float> %252, ptr %106, align 4
  store float 0.000000e+00, ptr %109, align 8, !tbaa !43
  store ptr @.str.6, ptr %110, align 8, !tbaa !44
  %253 = call i64 @b2CreateBody(i32 %1, ptr noundef nonnull %11) #6
  store i64 %253, ptr %58, align 4
  %254 = getelementptr inbounds i8, ptr %0, i64 112
  store float 5.000000e-01, ptr %254, align 4, !tbaa !13
  br i1 %9, label %255, label %257

255:                                              ; preds = %209
  %256 = getelementptr inbounds i8, ptr %12, i64 28
  store i32 2003199, ptr %256, align 4, !tbaa !42
  br label %257

257:                                              ; preds = %255, %209
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %24) #6
  store float 0.000000e+00, ptr %24, align 4, !tbaa !45
  %258 = getelementptr inbounds i8, ptr %24, i64 4
  %259 = fmul float %3, 0xBFC3D70A40000000
  store float %259, ptr %258, align 4, !tbaa !46
  %260 = getelementptr inbounds i8, ptr %24, i64 8
  store float 0.000000e+00, ptr %260, align 4, !tbaa !45
  %261 = getelementptr inbounds i8, ptr %24, i64 12
  %262 = extractelement <2 x float> %214, i64 0
  store float %262, ptr %261, align 4, !tbaa !46
  %263 = getelementptr inbounds i8, ptr %24, i64 16
  %264 = fmul float %3, 0x3FA70A3D80000000
  store float %264, ptr %263, align 4, !tbaa !55
  %265 = call i64 @b2CreateCapsuleShape(i64 %253, ptr noundef nonnull %12, ptr noundef nonnull %24) #6
  %266 = load i64, ptr %58, align 4
  %267 = call i64 @b2CreatePolygonShape(i64 %266, ptr noundef nonnull %13, ptr noundef nonnull %23) #6
  %268 = fmul float %3, 6.250000e-01
  %.sroa.0124.4.vec.insert = insertelement <2 x float> <float 0.000000e+00, float poison>, float %268, i64 1
  %269 = call <2 x float> @b2Add(<2 x float> %.sroa.0124.4.vec.insert, <2 x float> %2)
  call void @llvm.lifetime.start.p0(i64 96, ptr nonnull %25) #6
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind nonnull writable sret(%struct.b2RevoluteJointDef) align 8 %25) #6
  %270 = load i32, ptr %250, align 4, !tbaa !19
  %271 = sext i32 %270 to i64
  %272 = getelementptr inbounds [11 x %struct.Bone], ptr %0, i64 0, i64 %271
  %273 = load i64, ptr %272, align 4
  store i64 %273, ptr %25, align 8
  %274 = getelementptr inbounds i8, ptr %25, i64 8
  %275 = load i64, ptr %58, align 4
  store i64 %275, ptr %274, align 8
  %276 = getelementptr inbounds i8, ptr %25, i64 16
  %277 = call <2 x float> @b2Body_GetLocalPoint(i64 %273, <2 x float> %269) #6
  store <2 x float> %277, ptr %276, align 8
  %278 = getelementptr inbounds i8, ptr %25, i64 24
  %279 = load i64, ptr %274, align 8
  %280 = call <2 x float> @b2Body_GetLocalPoint(i64 %279, <2 x float> %269) #6
  store <2 x float> %280, ptr %278, align 8
  %281 = getelementptr inbounds i8, ptr %25, i64 48
  store i8 1, ptr %281, align 8, !tbaa !47
  %282 = getelementptr inbounds i8, ptr %25, i64 52
  store <2 x float> <float 0xBFF921FB60000000, float 0xBFB015BFA0000000>, ptr %282, align 4, !tbaa !38
  %283 = getelementptr inbounds i8, ptr %25, i64 60
  store i8 1, ptr %283, align 4, !tbaa !49
  %284 = load float, ptr %254, align 4, !tbaa !13
  %285 = fmul float %101, %284
  %286 = getelementptr inbounds i8, ptr %25, i64 64
  store float %285, ptr %286, align 8, !tbaa !50
  %287 = getelementptr inbounds i8, ptr %25, i64 36
  store i8 %157, ptr %287, align 4, !tbaa !51
  %288 = getelementptr inbounds i8, ptr %25, i64 40
  store float %5, ptr %288, align 8, !tbaa !52
  %289 = getelementptr inbounds i8, ptr %25, i64 44
  store float %6, ptr %289, align 4, !tbaa !53
  %290 = getelementptr inbounds i8, ptr %25, i64 72
  store float 0x3FA99999A0000000, ptr %290, align 8, !tbaa !54
  %291 = getelementptr inbounds i8, ptr %0, i64 104
  %292 = call i64 @b2CreateRevoluteJoint(i32 %1, ptr noundef nonnull %25) #6
  store i64 %292, ptr %291, align 4
  call void @llvm.lifetime.end.p0(i64 96, ptr nonnull %25) #6
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %24) #6
  %293 = getelementptr inbounds i8, ptr %0, i64 140
  store i32 0, ptr %293, align 4, !tbaa !19
  %294 = call <2 x float> @b2Add(<2 x float> %.sroa.0152.4.vec.insert, <2 x float> %2)
  store <2 x float> %294, ptr %106, align 4
  store float 0.000000e+00, ptr %109, align 8, !tbaa !43
  store ptr @.str.7, ptr %110, align 8, !tbaa !44
  %295 = call i64 @b2CreateBody(i32 %1, ptr noundef nonnull %11) #6
  store i64 %295, ptr %62, align 4
  %296 = getelementptr inbounds i8, ptr %0, i64 136
  store float 1.000000e+00, ptr %296, align 4, !tbaa !13
  br i1 %9, label %297, label %299

297:                                              ; preds = %257
  %298 = getelementptr inbounds i8, ptr %12, i64 28
  store i32 2003199, ptr %298, align 4, !tbaa !42
  br label %299

299:                                              ; preds = %297, %257
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %26) #6
  store float 0.000000e+00, ptr %26, align 4, !tbaa !45
  %300 = getelementptr inbounds i8, ptr %26, i64 4
  store float %211, ptr %300, align 4, !tbaa !46
  %301 = getelementptr inbounds i8, ptr %26, i64 8
  store float 0.000000e+00, ptr %301, align 4, !tbaa !45
  %302 = getelementptr inbounds i8, ptr %26, i64 12
  store <2 x float> %214, ptr %302, align 4, !tbaa !38
  %303 = call i64 @b2CreateCapsuleShape(i64 %295, ptr noundef nonnull %12, ptr noundef nonnull %26) #6
  %304 = call <2 x float> @b2Add(<2 x float> %.sroa.0146.4.vec.insert, <2 x float> %2)
  call void @llvm.lifetime.start.p0(i64 96, ptr nonnull %27) #6
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind nonnull writable sret(%struct.b2RevoluteJointDef) align 8 %27) #6
  %305 = load i32, ptr %293, align 4, !tbaa !19
  %306 = sext i32 %305 to i64
  %307 = getelementptr inbounds [11 x %struct.Bone], ptr %0, i64 0, i64 %306
  %308 = load i64, ptr %307, align 4
  store i64 %308, ptr %27, align 8
  %309 = getelementptr inbounds i8, ptr %27, i64 8
  %310 = load i64, ptr %62, align 4
  store i64 %310, ptr %309, align 8
  %311 = getelementptr inbounds i8, ptr %27, i64 16
  %312 = call <2 x float> @b2Body_GetLocalPoint(i64 %308, <2 x float> %304) #6
  store <2 x float> %312, ptr %311, align 8
  %313 = getelementptr inbounds i8, ptr %27, i64 24
  %314 = load i64, ptr %309, align 8
  %315 = call <2 x float> @b2Body_GetLocalPoint(i64 %314, <2 x float> %304) #6
  store <2 x float> %315, ptr %313, align 8
  %316 = getelementptr inbounds i8, ptr %27, i64 48
  store i8 1, ptr %316, align 8, !tbaa !47
  %317 = getelementptr inbounds i8, ptr %27, i64 52
  store <2 x float> <float 0xBFC41B2F80000000, float 0x3FF41B2F80000000>, ptr %317, align 4, !tbaa !38
  %318 = getelementptr inbounds i8, ptr %27, i64 60
  store i8 1, ptr %318, align 4, !tbaa !49
  %319 = load float, ptr %296, align 4, !tbaa !13
  %320 = fmul float %101, %319
  %321 = getelementptr inbounds i8, ptr %27, i64 64
  store float %320, ptr %321, align 8, !tbaa !50
  %322 = getelementptr inbounds i8, ptr %27, i64 36
  store i8 %157, ptr %322, align 4, !tbaa !51
  %323 = getelementptr inbounds i8, ptr %27, i64 40
  store float %5, ptr %323, align 8, !tbaa !52
  %324 = getelementptr inbounds i8, ptr %27, i64 44
  store float %6, ptr %324, align 4, !tbaa !53
  %325 = getelementptr inbounds i8, ptr %27, i64 72
  store float 0x3FA99999A0000000, ptr %325, align 8, !tbaa !54
  %326 = getelementptr inbounds i8, ptr %0, i64 128
  %327 = call i64 @b2CreateRevoluteJoint(i32 %1, ptr noundef nonnull %27) #6
  store i64 %327, ptr %326, align 4
  call void @llvm.lifetime.end.p0(i64 96, ptr nonnull %27) #6
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %26) #6
  %328 = getelementptr inbounds i8, ptr %0, i64 164
  store i32 5, ptr %328, align 4, !tbaa !19
  %329 = call <2 x float> @b2Add(<2 x float> %.sroa.0131.4.vec.insert, <2 x float> %2)
  store <2 x float> %329, ptr %106, align 4
  store float 0.000000e+00, ptr %109, align 8, !tbaa !43
  store ptr @.str.8, ptr %110, align 8, !tbaa !44
  %330 = call i64 @b2CreateBody(i32 %1, ptr noundef nonnull %11) #6
  store i64 %330, ptr %66, align 4
  %331 = getelementptr inbounds i8, ptr %0, i64 160
  store float 5.000000e-01, ptr %331, align 4, !tbaa !13
  br i1 %9, label %332, label %334

332:                                              ; preds = %299
  %333 = getelementptr inbounds i8, ptr %12, i64 28
  store i32 2003199, ptr %333, align 4, !tbaa !42
  br label %334

334:                                              ; preds = %332, %299
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %28) #6
  store float 0.000000e+00, ptr %28, align 4, !tbaa !45
  %335 = getelementptr inbounds i8, ptr %28, i64 4
  store float %259, ptr %335, align 4, !tbaa !46
  %336 = getelementptr inbounds i8, ptr %28, i64 8
  store float 0.000000e+00, ptr %336, align 4, !tbaa !45
  %337 = getelementptr inbounds i8, ptr %28, i64 12
  store float %262, ptr %337, align 4, !tbaa !46
  %338 = getelementptr inbounds i8, ptr %28, i64 16
  store float %264, ptr %338, align 4, !tbaa !55
  %339 = call i64 @b2CreateCapsuleShape(i64 %330, ptr noundef nonnull %12, ptr noundef nonnull %28) #6
  %340 = load i64, ptr %66, align 4
  %341 = call i64 @b2CreatePolygonShape(i64 %340, ptr noundef nonnull %13, ptr noundef nonnull %23) #6
  %342 = call <2 x float> @b2Add(<2 x float> %.sroa.0124.4.vec.insert, <2 x float> %2)
  call void @llvm.lifetime.start.p0(i64 96, ptr nonnull %29) #6
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind nonnull writable sret(%struct.b2RevoluteJointDef) align 8 %29) #6
  %343 = load i32, ptr %328, align 4, !tbaa !19
  %344 = sext i32 %343 to i64
  %345 = getelementptr inbounds [11 x %struct.Bone], ptr %0, i64 0, i64 %344
  %346 = load i64, ptr %345, align 4
  store i64 %346, ptr %29, align 8
  %347 = getelementptr inbounds i8, ptr %29, i64 8
  %348 = load i64, ptr %66, align 4
  store i64 %348, ptr %347, align 8
  %349 = getelementptr inbounds i8, ptr %29, i64 16
  %350 = call <2 x float> @b2Body_GetLocalPoint(i64 %346, <2 x float> %342) #6
  store <2 x float> %350, ptr %349, align 8
  %351 = getelementptr inbounds i8, ptr %29, i64 24
  %352 = load i64, ptr %347, align 8
  %353 = call <2 x float> @b2Body_GetLocalPoint(i64 %352, <2 x float> %342) #6
  store <2 x float> %353, ptr %351, align 8
  %354 = getelementptr inbounds i8, ptr %29, i64 48
  store i8 1, ptr %354, align 8, !tbaa !47
  %355 = getelementptr inbounds i8, ptr %29, i64 52
  store <2 x float> <float 0xBFF921FB60000000, float 0xBFB015BFA0000000>, ptr %355, align 4, !tbaa !38
  %356 = getelementptr inbounds i8, ptr %29, i64 60
  store i8 1, ptr %356, align 4, !tbaa !49
  %357 = load float, ptr %331, align 4, !tbaa !13
  %358 = fmul float %101, %357
  %359 = getelementptr inbounds i8, ptr %29, i64 64
  store float %358, ptr %359, align 8, !tbaa !50
  %360 = getelementptr inbounds i8, ptr %29, i64 36
  store i8 %157, ptr %360, align 4, !tbaa !51
  %361 = getelementptr inbounds i8, ptr %29, i64 40
  store float %5, ptr %361, align 8, !tbaa !52
  %362 = getelementptr inbounds i8, ptr %29, i64 44
  store float %6, ptr %362, align 4, !tbaa !53
  %363 = getelementptr inbounds i8, ptr %29, i64 72
  store float 0x3FA99999A0000000, ptr %363, align 8, !tbaa !54
  %364 = getelementptr inbounds i8, ptr %0, i64 152
  %365 = call i64 @b2CreateRevoluteJoint(i32 %1, ptr noundef nonnull %29) #6
  store i64 %365, ptr %364, align 4
  call void @llvm.lifetime.end.p0(i64 96, ptr nonnull %29) #6
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %28) #6
  %366 = getelementptr inbounds i8, ptr %0, i64 188
  store i32 1, ptr %366, align 4, !tbaa !19
  %367 = getelementptr inbounds i8, ptr %0, i64 184
  store float 5.000000e-01, ptr %367, align 4, !tbaa !13
  %368 = fmul float %3, 0x3FF39999A0000000
  %.sroa.068.4.vec.insert = insertelement <2 x float> <float 0.000000e+00, float poison>, float %368, i64 1
  %369 = call <2 x float> @b2Add(<2 x float> %.sroa.068.4.vec.insert, <2 x float> %2)
  store <2 x float> %369, ptr %106, align 4
  store float 0.000000e+00, ptr %109, align 8, !tbaa !43
  store ptr @.str.6, ptr %110, align 8, !tbaa !44
  %370 = call i64 @b2CreateBody(i32 %1, ptr noundef nonnull %11) #6
  store i64 %370, ptr %70, align 4
  br i1 %9, label %371, label %373

371:                                              ; preds = %334
  %372 = getelementptr inbounds i8, ptr %12, i64 28
  store i32 4772300, ptr %372, align 4, !tbaa !42
  br label %373

373:                                              ; preds = %371, %334
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %30) #6
  store float 0.000000e+00, ptr %30, align 4, !tbaa !45
  %374 = getelementptr inbounds i8, ptr %30, i64 4
  store float %211, ptr %374, align 4, !tbaa !46
  %375 = getelementptr inbounds i8, ptr %30, i64 8
  store float 0.000000e+00, ptr %375, align 4, !tbaa !45
  %376 = getelementptr inbounds i8, ptr %30, i64 12
  store float %262, ptr %376, align 4, !tbaa !46
  %377 = getelementptr inbounds i8, ptr %30, i64 16
  %378 = fmul float %3, 0x3FA1EB8520000000
  store float %378, ptr %377, align 4, !tbaa !55
  %379 = call i64 @b2CreateCapsuleShape(i64 %370, ptr noundef nonnull %12, ptr noundef nonnull %30) #6
  %380 = fmul float %3, 0x3FF59999A0000000
  %.sroa.062.4.vec.insert = insertelement <2 x float> <float 0.000000e+00, float poison>, float %380, i64 1
  %381 = call <2 x float> @b2Add(<2 x float> %.sroa.062.4.vec.insert, <2 x float> %2)
  call void @llvm.lifetime.start.p0(i64 96, ptr nonnull %31) #6
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind nonnull writable sret(%struct.b2RevoluteJointDef) align 8 %31) #6
  %382 = load i32, ptr %366, align 4, !tbaa !19
  %383 = sext i32 %382 to i64
  %384 = getelementptr inbounds [11 x %struct.Bone], ptr %0, i64 0, i64 %383
  %385 = load i64, ptr %384, align 4
  store i64 %385, ptr %31, align 8
  %386 = getelementptr inbounds i8, ptr %31, i64 8
  %387 = load i64, ptr %70, align 4
  store i64 %387, ptr %386, align 8
  %388 = getelementptr inbounds i8, ptr %31, i64 16
  %389 = call <2 x float> @b2Body_GetLocalPoint(i64 %385, <2 x float> %381) #6
  store <2 x float> %389, ptr %388, align 8
  %390 = getelementptr inbounds i8, ptr %31, i64 24
  %391 = load i64, ptr %386, align 8
  %392 = call <2 x float> @b2Body_GetLocalPoint(i64 %391, <2 x float> %381) #6
  store <2 x float> %392, ptr %390, align 8
  %393 = getelementptr inbounds i8, ptr %31, i64 48
  store i8 1, ptr %393, align 8, !tbaa !47
  %394 = getelementptr inbounds i8, ptr %31, i64 52
  store <2 x float> <float 0xBFD41B2F80000000, float 0x40041B2F80000000>, ptr %394, align 4, !tbaa !38
  %395 = getelementptr inbounds i8, ptr %31, i64 60
  store i8 1, ptr %395, align 4, !tbaa !49
  %396 = load float, ptr %367, align 4, !tbaa !13
  %397 = fmul float %101, %396
  %398 = getelementptr inbounds i8, ptr %31, i64 64
  store float %397, ptr %398, align 8, !tbaa !50
  %399 = getelementptr inbounds i8, ptr %31, i64 36
  store i8 %157, ptr %399, align 4, !tbaa !51
  %400 = getelementptr inbounds i8, ptr %31, i64 40
  store float %5, ptr %400, align 8, !tbaa !52
  %401 = getelementptr inbounds i8, ptr %31, i64 44
  store float %6, ptr %401, align 4, !tbaa !53
  %402 = getelementptr inbounds i8, ptr %31, i64 72
  store float 0x3FA99999A0000000, ptr %402, align 8, !tbaa !54
  %403 = getelementptr inbounds i8, ptr %0, i64 176
  %404 = call i64 @b2CreateRevoluteJoint(i32 %1, ptr noundef nonnull %31) #6
  store i64 %404, ptr %403, align 4
  call void @llvm.lifetime.end.p0(i64 96, ptr nonnull %31) #6
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %30) #6
  %405 = getelementptr inbounds i8, ptr %0, i64 212
  store i32 7, ptr %405, align 4, !tbaa !19
  %406 = fmul float %3, 0x3FEF333340000000
  %.sroa.048.4.vec.insert = insertelement <2 x float> <float 0.000000e+00, float poison>, float %406, i64 1
  %407 = call <2 x float> @b2Add(<2 x float> %.sroa.048.4.vec.insert, <2 x float> %2)
  store <2 x float> %407, ptr %106, align 4
  store float 0x3FB99999A0000000, ptr %109, align 8, !tbaa !43
  store ptr @.str.9, ptr %110, align 8, !tbaa !44
  %408 = call i64 @b2CreateBody(i32 %1, ptr noundef nonnull %11) #6
  store i64 %408, ptr %74, align 4
  %409 = getelementptr inbounds i8, ptr %0, i64 208
  store float 0x3FB99999A0000000, ptr %409, align 4, !tbaa !13
  br i1 %9, label %410, label %412

410:                                              ; preds = %373
  %411 = getelementptr inbounds i8, ptr %12, i64 28
  store i32 %105, ptr %411, align 4, !tbaa !42
  br label %412

412:                                              ; preds = %410, %373
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %32) #6
  store float 0.000000e+00, ptr %32, align 4, !tbaa !45
  %413 = getelementptr inbounds i8, ptr %32, i64 4
  store float %211, ptr %413, align 4, !tbaa !46
  %414 = getelementptr inbounds i8, ptr %32, i64 8
  store float 0.000000e+00, ptr %414, align 4, !tbaa !45
  %415 = getelementptr inbounds i8, ptr %32, i64 12
  store float %262, ptr %415, align 4, !tbaa !46
  %416 = getelementptr inbounds i8, ptr %32, i64 16
  %417 = fmul float %3, 0x3F9EB851E0000000
  store float %417, ptr %416, align 4, !tbaa !55
  %418 = call i64 @b2CreateCapsuleShape(i64 %408, ptr noundef nonnull %12, ptr noundef nonnull %32) #6
  %419 = fmul float %3, 0x3FF19999A0000000
  %.sroa.042.4.vec.insert = insertelement <2 x float> <float 0.000000e+00, float poison>, float %419, i64 1
  %420 = call <2 x float> @b2Add(<2 x float> %.sroa.042.4.vec.insert, <2 x float> %2)
  call void @llvm.lifetime.start.p0(i64 96, ptr nonnull %33) #6
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind nonnull writable sret(%struct.b2RevoluteJointDef) align 8 %33) #6
  %421 = load i32, ptr %405, align 4, !tbaa !19
  %422 = sext i32 %421 to i64
  %423 = getelementptr inbounds [11 x %struct.Bone], ptr %0, i64 0, i64 %422
  %424 = load i64, ptr %423, align 4
  store i64 %424, ptr %33, align 8
  %425 = getelementptr inbounds i8, ptr %33, i64 8
  %426 = load i64, ptr %74, align 4
  store i64 %426, ptr %425, align 8
  %427 = getelementptr inbounds i8, ptr %33, i64 16
  %428 = call <2 x float> @b2Body_GetLocalPoint(i64 %424, <2 x float> %420) #6
  store <2 x float> %428, ptr %427, align 8
  %429 = getelementptr inbounds i8, ptr %33, i64 24
  %430 = load i64, ptr %425, align 8
  %431 = call <2 x float> @b2Body_GetLocalPoint(i64 %430, <2 x float> %420) #6
  store <2 x float> %431, ptr %429, align 8
  %432 = getelementptr inbounds i8, ptr %33, i64 32
  store float 0x3FE921FB60000000, ptr %432, align 8, !tbaa !57
  %433 = getelementptr inbounds i8, ptr %33, i64 48
  store i8 1, ptr %433, align 8, !tbaa !47
  %434 = getelementptr inbounds i8, ptr %33, i64 52
  store <2 x float> <float 0xBFE41B2F80000000, float 0x3FEE28C760000000>, ptr %434, align 4, !tbaa !38
  %435 = getelementptr inbounds i8, ptr %33, i64 60
  store i8 1, ptr %435, align 4, !tbaa !49
  %436 = load float, ptr %409, align 4, !tbaa !13
  %437 = fmul float %101, %436
  %438 = getelementptr inbounds i8, ptr %33, i64 64
  store float %437, ptr %438, align 8, !tbaa !50
  %439 = getelementptr inbounds i8, ptr %33, i64 36
  store i8 %157, ptr %439, align 4, !tbaa !51
  %440 = getelementptr inbounds i8, ptr %33, i64 40
  store float %5, ptr %440, align 8, !tbaa !52
  %441 = getelementptr inbounds i8, ptr %33, i64 44
  store float %6, ptr %441, align 4, !tbaa !53
  %442 = getelementptr inbounds i8, ptr %33, i64 72
  store float 0x3FA99999A0000000, ptr %442, align 8, !tbaa !54
  %443 = getelementptr inbounds i8, ptr %0, i64 200
  %444 = call i64 @b2CreateRevoluteJoint(i32 %1, ptr noundef nonnull %33) #6
  store i64 %444, ptr %443, align 4
  call void @llvm.lifetime.end.p0(i64 96, ptr nonnull %33) #6
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %32) #6
  %445 = getelementptr inbounds i8, ptr %0, i64 236
  store i32 1, ptr %445, align 4, !tbaa !19
  %446 = call <2 x float> @b2Add(<2 x float> %.sroa.068.4.vec.insert, <2 x float> %2)
  store <2 x float> %446, ptr %106, align 4
  store float 0.000000e+00, ptr %109, align 8, !tbaa !43
  store ptr @.str.10, ptr %110, align 8, !tbaa !44
  %447 = call i64 @b2CreateBody(i32 %1, ptr noundef nonnull %11) #6
  store i64 %447, ptr %78, align 4
  %448 = getelementptr inbounds i8, ptr %0, i64 232
  store float 5.000000e-01, ptr %448, align 4, !tbaa !13
  br i1 %9, label %449, label %451

449:                                              ; preds = %412
  %450 = getelementptr inbounds i8, ptr %12, i64 28
  store i32 4772300, ptr %450, align 4, !tbaa !42
  br label %451

451:                                              ; preds = %449, %412
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %34) #6
  store float 0.000000e+00, ptr %34, align 4, !tbaa !45
  %452 = getelementptr inbounds i8, ptr %34, i64 4
  store float %211, ptr %452, align 4, !tbaa !46
  %453 = getelementptr inbounds i8, ptr %34, i64 8
  store float 0.000000e+00, ptr %453, align 4, !tbaa !45
  %454 = getelementptr inbounds i8, ptr %34, i64 12
  store float %262, ptr %454, align 4, !tbaa !46
  %455 = getelementptr inbounds i8, ptr %34, i64 16
  store float %378, ptr %455, align 4, !tbaa !55
  %456 = call i64 @b2CreateCapsuleShape(i64 %447, ptr noundef nonnull %12, ptr noundef nonnull %34) #6
  %457 = call <2 x float> @b2Add(<2 x float> %.sroa.062.4.vec.insert, <2 x float> %2)
  call void @llvm.lifetime.start.p0(i64 96, ptr nonnull %35) #6
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind nonnull writable sret(%struct.b2RevoluteJointDef) align 8 %35) #6
  %458 = load i32, ptr %445, align 4, !tbaa !19
  %459 = sext i32 %458 to i64
  %460 = getelementptr inbounds [11 x %struct.Bone], ptr %0, i64 0, i64 %459
  %461 = load i64, ptr %460, align 4
  store i64 %461, ptr %35, align 8
  %462 = getelementptr inbounds i8, ptr %35, i64 8
  %463 = load i64, ptr %78, align 4
  store i64 %463, ptr %462, align 8
  %464 = getelementptr inbounds i8, ptr %35, i64 16
  %465 = call <2 x float> @b2Body_GetLocalPoint(i64 %461, <2 x float> %457) #6
  store <2 x float> %465, ptr %464, align 8
  %466 = getelementptr inbounds i8, ptr %35, i64 24
  %467 = load i64, ptr %462, align 8
  %468 = call <2 x float> @b2Body_GetLocalPoint(i64 %467, <2 x float> %457) #6
  store <2 x float> %468, ptr %466, align 8
  %469 = getelementptr inbounds i8, ptr %35, i64 48
  store i8 1, ptr %469, align 8, !tbaa !47
  %470 = getelementptr inbounds i8, ptr %35, i64 52
  store <2 x float> <float 0xBFD41B2F80000000, float 0x40041B2F80000000>, ptr %470, align 4, !tbaa !38
  %471 = getelementptr inbounds i8, ptr %35, i64 60
  store i8 1, ptr %471, align 4, !tbaa !49
  %472 = load float, ptr %448, align 4, !tbaa !13
  %473 = fmul float %101, %472
  %474 = getelementptr inbounds i8, ptr %35, i64 64
  store float %473, ptr %474, align 8, !tbaa !50
  %475 = getelementptr inbounds i8, ptr %35, i64 36
  store i8 %157, ptr %475, align 4, !tbaa !51
  %476 = getelementptr inbounds i8, ptr %35, i64 40
  store float %5, ptr %476, align 8, !tbaa !52
  %477 = getelementptr inbounds i8, ptr %35, i64 44
  store float %6, ptr %477, align 4, !tbaa !53
  %478 = getelementptr inbounds i8, ptr %35, i64 72
  store float 0x3FA99999A0000000, ptr %478, align 8, !tbaa !54
  %479 = getelementptr inbounds i8, ptr %0, i64 224
  %480 = call i64 @b2CreateRevoluteJoint(i32 %1, ptr noundef nonnull %35) #6
  store i64 %480, ptr %479, align 4
  call void @llvm.lifetime.end.p0(i64 96, ptr nonnull %35) #6
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %34) #6
  %481 = getelementptr inbounds i8, ptr %0, i64 260
  store i32 9, ptr %481, align 4, !tbaa !19
  %482 = call <2 x float> @b2Add(<2 x float> %.sroa.048.4.vec.insert, <2 x float> %2)
  store <2 x float> %482, ptr %106, align 4
  store float 0x3FB99999A0000000, ptr %109, align 8, !tbaa !43
  store ptr @.str.11, ptr %110, align 8, !tbaa !44
  %483 = call i64 @b2CreateBody(i32 %1, ptr noundef nonnull %11) #6
  store i64 %483, ptr %82, align 4
  %484 = getelementptr inbounds i8, ptr %0, i64 256
  store float 0x3FB99999A0000000, ptr %484, align 4, !tbaa !13
  br i1 %9, label %485, label %487

485:                                              ; preds = %451
  %486 = getelementptr inbounds i8, ptr %12, i64 28
  store i32 %105, ptr %486, align 4, !tbaa !42
  br label %487

487:                                              ; preds = %485, %451
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %36) #6
  store float 0.000000e+00, ptr %36, align 4, !tbaa !45
  %488 = getelementptr inbounds i8, ptr %36, i64 4
  store float %211, ptr %488, align 4, !tbaa !46
  %489 = getelementptr inbounds i8, ptr %36, i64 8
  store float 0.000000e+00, ptr %489, align 4, !tbaa !45
  %490 = getelementptr inbounds i8, ptr %36, i64 12
  store float %262, ptr %490, align 4, !tbaa !46
  %491 = getelementptr inbounds i8, ptr %36, i64 16
  store float %417, ptr %491, align 4, !tbaa !55
  %492 = call i64 @b2CreateCapsuleShape(i64 %483, ptr noundef nonnull %12, ptr noundef nonnull %36) #6
  %493 = call <2 x float> @b2Add(<2 x float> %.sroa.042.4.vec.insert, <2 x float> %2)
  call void @llvm.lifetime.start.p0(i64 96, ptr nonnull %37) #6
  call void @b2DefaultRevoluteJointDef(ptr dead_on_unwind nonnull writable sret(%struct.b2RevoluteJointDef) align 8 %37) #6
  %494 = load i32, ptr %481, align 4, !tbaa !19
  %495 = sext i32 %494 to i64
  %496 = getelementptr inbounds [11 x %struct.Bone], ptr %0, i64 0, i64 %495
  %497 = load i64, ptr %496, align 4
  store i64 %497, ptr %37, align 8
  %498 = getelementptr inbounds i8, ptr %37, i64 8
  %499 = load i64, ptr %82, align 4
  store i64 %499, ptr %498, align 8
  %500 = getelementptr inbounds i8, ptr %37, i64 16
  %501 = call <2 x float> @b2Body_GetLocalPoint(i64 %497, <2 x float> %493) #6
  store <2 x float> %501, ptr %500, align 8
  %502 = getelementptr inbounds i8, ptr %37, i64 24
  %503 = load i64, ptr %498, align 8
  %504 = call <2 x float> @b2Body_GetLocalPoint(i64 %503, <2 x float> %493) #6
  store <2 x float> %504, ptr %502, align 8
  %505 = getelementptr inbounds i8, ptr %37, i64 32
  store float 0x3FE921FB60000000, ptr %505, align 8, !tbaa !57
  %506 = getelementptr inbounds i8, ptr %37, i64 48
  store i8 1, ptr %506, align 8, !tbaa !47
  %507 = getelementptr inbounds i8, ptr %37, i64 52
  store <2 x float> <float 0xBFE41B2F80000000, float 0x3FEE28C760000000>, ptr %507, align 4, !tbaa !38
  %508 = getelementptr inbounds i8, ptr %37, i64 60
  store i8 1, ptr %508, align 4, !tbaa !49
  %509 = load float, ptr %484, align 4, !tbaa !13
  %510 = fmul float %101, %509
  %511 = getelementptr inbounds i8, ptr %37, i64 64
  store float %510, ptr %511, align 8, !tbaa !50
  %512 = getelementptr inbounds i8, ptr %37, i64 36
  store i8 %157, ptr %512, align 4, !tbaa !51
  %513 = getelementptr inbounds i8, ptr %37, i64 40
  store float %5, ptr %513, align 8, !tbaa !52
  %514 = getelementptr inbounds i8, ptr %37, i64 44
  store float %6, ptr %514, align 4, !tbaa !53
  %515 = getelementptr inbounds i8, ptr %37, i64 72
  store float 0x3FA99999A0000000, ptr %515, align 8, !tbaa !54
  %516 = getelementptr inbounds i8, ptr %0, i64 248
  %517 = call i64 @b2CreateRevoluteJoint(i32 %1, ptr noundef nonnull %37) #6
  store i64 %517, ptr %516, align 4
  call void @llvm.lifetime.end.p0(i64 96, ptr nonnull %37) #6
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %36) #6
  store i8 1, ptr %38, align 4, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 144, ptr nonnull %23) #6
  call void @llvm.lifetime.end.p0(i64 68, ptr nonnull %22) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %21) #6
  call void @llvm.lifetime.end.p0(i64 80, ptr nonnull %13) #6
  call void @llvm.lifetime.end.p0(i64 80, ptr nonnull %12) #6
  call void @llvm.lifetime.end.p0(i64 80, ptr nonnull %11) #6
  ret void
}

; Function Attrs: noreturn nounwind
declare void @__assert_fail(ptr noundef, ptr noundef, i32 noundef, ptr noundef) local_unnamed_addr #1

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

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

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

declare void @b2DefaultBodyDef(ptr dead_on_unwind writable sret(%struct.b2BodyDef) align 8) local_unnamed_addr #4

declare void @b2DefaultShapeDef(ptr dead_on_unwind writable sret(%struct.b2ShapeDef) align 8) local_unnamed_addr #4

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

declare i64 @b2CreateBody(i32, ptr noundef) local_unnamed_addr #4

declare i64 @b2CreateCapsuleShape(i64, ptr noundef, ptr noundef) local_unnamed_addr #4

declare void @b2DefaultRevoluteJointDef(ptr dead_on_unwind writable sret(%struct.b2RevoluteJointDef) align 8) local_unnamed_addr #4

declare <2 x float> @b2Body_GetLocalPoint(i64, <2 x float>) local_unnamed_addr #4

declare i64 @b2CreateRevoluteJoint(i32, ptr noundef) local_unnamed_addr #4

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

declare void @b2MakePolygon(ptr dead_on_unwind writable sret(%struct.b2Polygon) align 4, ptr noundef, float noundef) local_unnamed_addr #4

declare i64 @b2CreatePolygonShape(i64, ptr noundef, ptr noundef) local_unnamed_addr #4

attributes #0 = { nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
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 = { inlinehint nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #6 = { nounwind }
attributes #7 = { noreturn 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 268}
!6 = !{!"Human", !7, i64 0, !9, i64 264, !10, i64 268}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!"float", !7, i64 0}
!10 = !{!"_Bool", !7, i64 0}
!11 = !{i8 0, i8 2}
!12 = !{}
!13 = !{!14, !9, i64 16}
!14 = !{!"Bone", !15, i64 0, !18, i64 8, !9, i64 16, !16, i64 20}
!15 = !{!"b2BodyId", !16, i64 0, !17, i64 4, !17, i64 6}
!16 = !{!"int", !7, i64 0}
!17 = !{!"short", !7, i64 0}
!18 = !{!"b2JointId", !16, i64 0, !17, i64 4, !17, i64 6}
!19 = !{!14, !16, i64 20}
!20 = !{!6, !9, i64 264}
!21 = !{!22, !16, i64 0}
!22 = !{!"b2BodyDef", !16, i64 0, !23, i64 4, !24, i64 12, !23, i64 20, !9, i64 28, !9, i64 32, !9, i64 36, !9, i64 40, !9, i64 44, !25, i64 48, !25, i64 56, !10, i64 64, !10, i64 65, !10, i64 66, !10, i64 67, !10, i64 68, !10, i64 69, !16, i64 72}
!23 = !{!"b2Vec2", !9, i64 0, !9, i64 4}
!24 = !{!"b2Rot", !9, i64 0, !9, i64 4}
!25 = !{!"any pointer", !7, i64 0}
!26 = !{!22, !9, i64 44}
!27 = !{!22, !25, i64 56}
!28 = !{!29, !9, i64 8}
!29 = !{!"b2ShapeDef", !25, i64 0, !30, i64 8, !9, i64 32, !31, i64 40, !10, i64 64, !10, i64 65, !10, i64 66, !10, i64 67, !10, i64 68, !10, i64 69, !10, i64 70, !16, i64 72}
!30 = !{!"b2SurfaceMaterial", !9, i64 0, !9, i64 4, !9, i64 8, !9, i64 12, !16, i64 16, !16, i64 20}
!31 = !{!"b2Filter", !32, i64 0, !32, i64 8, !16, i64 16}
!32 = !{!"long", !7, i64 0}
!33 = !{!29, !16, i64 56}
!34 = !{!29, !32, i64 40}
!35 = !{!29, !32, i64 48}
!36 = !{i64 0, i64 8, !37, i64 8, i64 4, !38, i64 12, i64 4, !38, i64 16, i64 4, !38, i64 20, i64 4, !38, i64 24, i64 4, !39, i64 28, i64 4, !39, i64 32, i64 4, !38, i64 40, i64 8, !40, i64 48, i64 8, !40, i64 56, i64 4, !39, i64 64, i64 1, !41, i64 65, i64 1, !41, i64 66, i64 1, !41, i64 67, i64 1, !41, i64 68, i64 1, !41, i64 69, i64 1, !41, i64 70, i64 1, !41, i64 72, i64 4, !39}
!37 = !{!25, !25, i64 0}
!38 = !{!9, !9, i64 0}
!39 = !{!16, !16, i64 0}
!40 = !{!32, !32, i64 0}
!41 = !{!10, !10, i64 0}
!42 = !{!29, !16, i64 28}
!43 = !{!22, !9, i64 32}
!44 = !{!22, !25, i64 48}
!45 = !{!23, !9, i64 0}
!46 = !{!23, !9, i64 4}
!47 = !{!48, !10, i64 48}
!48 = !{!"b2RevoluteJointDef", !15, i64 0, !15, i64 8, !23, i64 16, !23, i64 24, !9, i64 32, !10, i64 36, !9, i64 40, !9, i64 44, !10, i64 48, !9, i64 52, !9, i64 56, !10, i64 60, !9, i64 64, !9, i64 68, !9, i64 72, !10, i64 76, !25, i64 80, !16, i64 88}
!49 = !{!48, !10, i64 60}
!50 = !{!48, !9, i64 64}
!51 = !{!48, !10, i64 36}
!52 = !{!48, !9, i64 40}
!53 = !{!48, !9, i64 44}
!54 = !{!48, !9, i64 72}
!55 = !{!56, !9, i64 16}
!56 = !{!"b2Capsule", !23, i64 0, !23, i64 8, !9, i64 16}
!57 = !{!48, !9, i64 32}


; Effective O3 passes: EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,LICMPass,LoopRotatePass,LoopSimplifyPass,ReassociatePass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass