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

; 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.vrRaycastOutput = type { i32, %struct.vrVec2, %struct.vrVec2, float, ptr }
%struct.vrVec2 = type { float, float }
%struct.vrRaycastInput = type { %struct.vrVec2, %struct.vrVec2, ptr }
%struct.vrWorld = type { ptr, i32, float, float, float, i32, i32, %struct.vrVec2, ptr, ptr, ptr, ptr, i32, ptr }
%struct.vrArray = type { ptr, i32, i32, i32, i32 }
%struct.vrRigidBody = type { %struct.vrVec2, %struct.vrVec2, %struct.vrVec2, %struct.vrVec2, float, float, float, float, %struct.vrCollisionGroup, %struct.vrMaterial, ptr, %struct.vrColor, %struct.vrVec2, %struct.vrOrientedBoundingBox, ptr, i32 }
%struct.vrCollisionGroup = type { i32, i32 }
%struct.vrMaterial = type { float, float, float, float, float, float, float, float }
%struct.vrColor = type { float, float, float }
%struct.vrOrientedBoundingBox = type { %struct.vrVec2, %struct.vrVec2 }
%struct.vrShape = type { ptr, i32, ptr, ptr, ptr, ptr, %struct.vrOrientedBoundingBox }
%struct.vrCircleShape = type { float, %struct.vrVec2 }
%struct.vrPolygonShape = type { ptr, i32, ptr, i32, %struct.vrVec2 }

; Function Attrs: nounwind uwtable
define dso_local void @vrRaycast(ptr dead_on_unwind noalias writable sret(%struct.vrRaycastOutput) align 8 %0, ptr noundef %1, ptr noundef byval(%struct.vrRaycastInput) align 8 %2) #0 {
  %4 = alloca ptr, align 8
  %5 = alloca %struct.vrVec2, align 4
  %6 = alloca %struct.vrVec2, align 4
  %7 = alloca %struct.vrVec2, align 4
  %8 = alloca float, align 4
  %9 = alloca %struct.vrVec2, align 4
  %10 = alloca float, align 4
  %11 = alloca %struct.vrVec2, align 4
  %12 = alloca %struct.vrVec2, align 4
  %13 = alloca i32, align 4
  %14 = alloca i32, align 4
  %15 = alloca i32, align 4
  %16 = alloca ptr, align 8
  %17 = alloca i32, align 4
  %18 = alloca ptr, align 8
  %19 = alloca ptr, align 8
  %20 = alloca %struct.vrVec2, align 4
  %21 = alloca %struct.vrVec2, align 4
  %22 = alloca %struct.vrVec2, align 4
  %23 = alloca float, align 4
  %24 = alloca %struct.vrVec2, align 4
  %25 = alloca %struct.vrVec2, align 4
  %26 = alloca float, align 4
  %27 = alloca float, align 4
  %28 = alloca float, align 4
  %29 = alloca float, align 4
  %30 = alloca float, align 4
  %31 = alloca float, align 4
  %32 = alloca %struct.vrVec2, align 4
  %33 = alloca %struct.vrVec2, align 4
  %34 = alloca %struct.vrVec2, align 4
  %35 = alloca %struct.vrVec2, align 4
  %36 = alloca %struct.vrVec2, align 4
  %37 = alloca %struct.vrVec2, align 4
  %38 = alloca %struct.vrVec2, align 4
  %39 = alloca %struct.vrVec2, align 4
  %40 = alloca %struct.vrVec2, align 4
  %41 = alloca %struct.vrVec2, align 4
  %42 = alloca ptr, align 8
  %43 = alloca i32, align 4
  %44 = alloca i32, align 4
  %45 = alloca %struct.vrVec2, align 4
  %46 = alloca %struct.vrVec2, align 4
  %47 = alloca %struct.vrVec2, align 4
  %48 = alloca %struct.vrVec2, align 4
  %49 = alloca %struct.vrVec2, align 4
  %50 = alloca %struct.vrVec2, align 4
  %51 = alloca %struct.vrVec2, align 4
  %52 = alloca %struct.vrVec2, align 4
  %53 = alloca float, align 4
  %54 = alloca float, align 4
  %55 = alloca %struct.vrVec2, align 4
  %56 = alloca %struct.vrVec2, align 4
  %57 = alloca %struct.vrVec2, align 4
  %58 = alloca %struct.vrVec2, align 4
  store ptr %1, ptr %4, align 8, !tbaa !5
  %59 = getelementptr inbounds %struct.vrRaycastOutput, ptr %0, i32 0, i32 4
  store ptr null, ptr %59, align 8, !tbaa !9
  %60 = getelementptr inbounds %struct.vrRaycastOutput, ptr %0, i32 0, i32 0
  store i32 0, ptr %60, align 8, !tbaa !14
  %61 = getelementptr inbounds %struct.vrRaycastOutput, ptr %0, i32 0, i32 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #6
  %62 = call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00)
  store <2 x float> %62, ptr %5, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %61, ptr align 4 %5, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #6
  %63 = getelementptr inbounds %struct.vrRaycastOutput, ptr %0, i32 0, i32 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %6) #6
  %64 = call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00)
  store <2 x float> %64, ptr %6, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %63, ptr align 4 %6, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #6
  %65 = getelementptr inbounds %struct.vrRaycastOutput, ptr %0, i32 0, i32 3
  store float 0.000000e+00, ptr %65, align 4, !tbaa !17
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #6
  %66 = getelementptr inbounds %struct.vrRaycastInput, ptr %2, i32 0, i32 1
  %67 = getelementptr inbounds %struct.vrRaycastInput, ptr %2, i32 0, i32 0
  %68 = load <2 x float>, ptr %66, align 8
  %69 = load <2 x float>, ptr %67, align 8
  %70 = call <2 x float> @vrSub(<2 x float> %68, <2 x float> %69)
  store <2 x float> %70, ptr %7, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #6
  %71 = load <2 x float>, ptr %7, align 4
  %72 = call float @vrLength(<2 x float> %71)
  store float %72, ptr %8, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #6
  %73 = load float, ptr %8, align 4, !tbaa !16
  %74 = fpext float %73 to double
  %75 = fdiv double 1.000000e+00, %74
  %76 = fptrunc double %75 to float
  %77 = load <2 x float>, ptr %7, align 4
  %78 = call <2 x float> @vrScale(<2 x float> %77, float noundef %76)
  store <2 x float> %78, ptr %9, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %7, ptr align 4 %9, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #6
  store i32 0, ptr %13, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #6
  store i32 0, ptr %14, align 4, !tbaa !18
  br label %79

79:                                               ; preds = %430, %3
  %80 = load i32, ptr %14, align 4, !tbaa !18
  %81 = load ptr, ptr %4, align 8, !tbaa !5
  %82 = getelementptr inbounds %struct.vrWorld, ptr %81, i32 0, i32 0
  %83 = load ptr, ptr %82, align 8, !tbaa !19
  %84 = getelementptr inbounds %struct.vrArray, ptr %83, i32 0, i32 1
  %85 = load i32, ptr %84, align 8, !tbaa !21
  %86 = icmp slt i32 %80, %85
  br i1 %86, label %88, label %87

87:                                               ; preds = %79
  store i32 2, ptr %15, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #6
  br label %433

88:                                               ; preds = %79
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #6
  %89 = load ptr, ptr %4, align 8, !tbaa !5
  %90 = getelementptr inbounds %struct.vrWorld, ptr %89, i32 0, i32 0
  %91 = load ptr, ptr %90, align 8, !tbaa !19
  %92 = getelementptr inbounds %struct.vrArray, ptr %91, i32 0, i32 0
  %93 = load ptr, ptr %92, align 8, !tbaa !23
  %94 = load i32, ptr %14, align 4, !tbaa !18
  %95 = sext i32 %94 to i64
  %96 = getelementptr inbounds ptr, ptr %93, i64 %95
  %97 = load ptr, ptr %96, align 8, !tbaa !5
  store ptr %97, ptr %16, align 8, !tbaa !5
  %98 = getelementptr inbounds %struct.vrRaycastInput, ptr %2, i32 0, i32 2
  %99 = load ptr, ptr %98, align 8, !tbaa !24
  %100 = icmp ne ptr %99, null
  br i1 %100, label %101, label %429

101:                                              ; preds = %88
  %102 = getelementptr inbounds %struct.vrRaycastInput, ptr %2, i32 0, i32 2
  %103 = load ptr, ptr %102, align 8, !tbaa !24
  %104 = load ptr, ptr %16, align 8, !tbaa !5
  %105 = call i32 %103(ptr noundef %104)
  %106 = icmp ne i32 %105, 0
  br i1 %106, label %107, label %428

107:                                              ; preds = %101
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #6
  store i32 0, ptr %17, align 4, !tbaa !18
  br label %108

108:                                              ; preds = %424, %107
  %109 = load i32, ptr %17, align 4, !tbaa !18
  %110 = load ptr, ptr %16, align 8, !tbaa !5
  %111 = getelementptr inbounds %struct.vrRigidBody, ptr %110, i32 0, i32 10
  %112 = load ptr, ptr %111, align 8, !tbaa !26
  %113 = getelementptr inbounds %struct.vrArray, ptr %112, i32 0, i32 1
  %114 = load i32, ptr %113, align 8, !tbaa !21
  %115 = icmp slt i32 %109, %114
  br i1 %115, label %117, label %116

116:                                              ; preds = %108
  store i32 5, ptr %15, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #6
  br label %427

117:                                              ; preds = %108
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #6
  %118 = load ptr, ptr %16, align 8, !tbaa !5
  %119 = getelementptr inbounds %struct.vrRigidBody, ptr %118, i32 0, i32 10
  %120 = load ptr, ptr %119, align 8, !tbaa !26
  %121 = getelementptr inbounds %struct.vrArray, ptr %120, i32 0, i32 0
  %122 = load ptr, ptr %121, align 8, !tbaa !23
  %123 = load i32, ptr %17, align 4, !tbaa !18
  %124 = sext i32 %123 to i64
  %125 = getelementptr inbounds ptr, ptr %122, i64 %124
  %126 = load ptr, ptr %125, align 8, !tbaa !5
  store ptr %126, ptr %18, align 8, !tbaa !5
  %127 = load ptr, ptr %18, align 8, !tbaa !5
  %128 = getelementptr inbounds %struct.vrShape, ptr %127, i32 0, i32 1
  %129 = load i32, ptr %128, align 8, !tbaa !32
  %130 = icmp eq i32 %129, 1
  br i1 %130, label %131, label %272

131:                                              ; preds = %117
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #6
  %132 = load ptr, ptr %18, align 8, !tbaa !5
  %133 = getelementptr inbounds %struct.vrShape, ptr %132, i32 0, i32 0
  %134 = load ptr, ptr %133, align 8, !tbaa !34
  store ptr %134, ptr %19, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #6
  %135 = getelementptr inbounds %struct.vrRaycastInput, ptr %2, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %20, ptr align 8 %135, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #6
  %136 = getelementptr inbounds %struct.vrRaycastInput, ptr %2, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %21, ptr align 8 %136, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #6
  %137 = load ptr, ptr %19, align 8, !tbaa !5
  %138 = getelementptr inbounds %struct.vrCircleShape, ptr %137, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %22, ptr align 4 %138, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #6
  %139 = load ptr, ptr %19, align 8, !tbaa !5
  %140 = getelementptr inbounds %struct.vrCircleShape, ptr %139, i32 0, i32 0
  %141 = load float, ptr %140, align 4, !tbaa !35
  store float %141, ptr %23, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %24, ptr align 4 %7, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #6
  %142 = load <2 x float>, ptr %20, align 4
  %143 = load <2 x float>, ptr %22, align 4
  %144 = call <2 x float> @vrSub(<2 x float> %142, <2 x float> %143)
  store <2 x float> %144, ptr %25, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #6
  %145 = load <2 x float>, ptr %24, align 4
  %146 = load <2 x float>, ptr %24, align 4
  %147 = call float @vrDot(<2 x float> %145, <2 x float> %146)
  store float %147, ptr %26, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #6
  %148 = load <2 x float>, ptr %25, align 4
  %149 = load <2 x float>, ptr %24, align 4
  %150 = call float @vrDot(<2 x float> %148, <2 x float> %149)
  %151 = fpext float %150 to double
  %152 = fmul double 2.000000e+00, %151
  %153 = fptrunc double %152 to float
  store float %153, ptr %27, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #6
  %154 = load <2 x float>, ptr %25, align 4
  %155 = load <2 x float>, ptr %25, align 4
  %156 = call float @vrDot(<2 x float> %154, <2 x float> %155)
  %157 = load float, ptr %23, align 4, !tbaa !16
  %158 = load float, ptr %23, align 4, !tbaa !16
  %159 = fneg float %157
  %160 = call float @llvm.fmuladd.f32(float %159, float %158, float %156)
  store float %160, ptr %28, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #6
  %161 = load float, ptr %27, align 4, !tbaa !16
  %162 = load float, ptr %27, align 4, !tbaa !16
  %163 = load float, ptr %26, align 4, !tbaa !16
  %164 = fmul float 4.000000e+00, %163
  %165 = load float, ptr %28, align 4, !tbaa !16
  %166 = fmul float %164, %165
  %167 = fneg float %166
  %168 = call float @llvm.fmuladd.f32(float %161, float %162, float %167)
  store float %168, ptr %29, align 4, !tbaa !16
  %169 = load float, ptr %29, align 4, !tbaa !16
  %170 = fcmp olt float %169, 0.000000e+00
  br i1 %170, label %171, label %172

171:                                              ; preds = %131
  store i32 7, ptr %15, align 4
  br label %269

172:                                              ; preds = %131
  %173 = load float, ptr %29, align 4, !tbaa !16
  %174 = fpext float %173 to double
  %175 = call double @sqrt(double noundef %174) #6
  %176 = fptrunc double %175 to float
  store float %176, ptr %29, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #6
  %177 = load float, ptr %27, align 4, !tbaa !16
  %178 = fneg float %177
  %179 = load float, ptr %29, align 4, !tbaa !16
  %180 = fsub float %178, %179
  %181 = fpext float %180 to double
  %182 = load float, ptr %26, align 4, !tbaa !16
  %183 = fpext float %182 to double
  %184 = fmul double 2.000000e+00, %183
  %185 = fdiv double %181, %184
  %186 = fptrunc double %185 to float
  store float %186, ptr %30, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #6
  %187 = load float, ptr %27, align 4, !tbaa !16
  %188 = fneg float %187
  %189 = load float, ptr %29, align 4, !tbaa !16
  %190 = fadd float %188, %189
  %191 = fpext float %190 to double
  %192 = load float, ptr %26, align 4, !tbaa !16
  %193 = fpext float %192 to double
  %194 = fmul double 2.000000e+00, %193
  %195 = fdiv double %191, %194
  %196 = fptrunc double %195 to float
  store float %196, ptr %31, align 4, !tbaa !16
  %197 = load float, ptr %30, align 4, !tbaa !16
  %198 = fcmp oge float %197, 0.000000e+00
  br i1 %198, label %199, label %231

199:                                              ; preds = %172
  %200 = load float, ptr %30, align 4, !tbaa !16
  %201 = fcmp ole float %200, 1.000000e+00
  br i1 %201, label %202, label %231

202:                                              ; preds = %199
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #6
  %203 = load float, ptr %30, align 4, !tbaa !16
  %204 = load <2 x float>, ptr %24, align 4
  %205 = call <2 x float> @vrScale(<2 x float> %204, float noundef %203)
  store <2 x float> %205, ptr %33, align 4
  %206 = load <2 x float>, ptr %20, align 4
  %207 = load <2 x float>, ptr %33, align 4
  %208 = call <2 x float> @vrAdd(<2 x float> %206, <2 x float> %207)
  store <2 x float> %208, ptr %32, align 4
  %209 = load float, ptr %30, align 4, !tbaa !16
  %210 = load float, ptr %10, align 4, !tbaa !16
  %211 = fcmp olt float %209, %210
  br i1 %211, label %215, label %212

212:                                              ; preds = %202
  %213 = load i32, ptr %13, align 4, !tbaa !18
  %214 = icmp ne i32 %213, 0
  br i1 %214, label %230, label %215

215:                                              ; preds = %212, %202
  %216 = load float, ptr %30, align 4, !tbaa !16
  store float %216, ptr %10, align 4, !tbaa !16
  store i32 1, ptr %13, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #6
  %217 = load <2 x float>, ptr %32, align 4
  %218 = load <2 x float>, ptr %22, align 4
  %219 = call <2 x float> @vrSub(<2 x float> %217, <2 x float> %218)
  store <2 x float> %219, ptr %35, align 4
  %220 = load <2 x float>, ptr %35, align 4
  %221 = call <2 x float> @vrNormalize(<2 x float> %220)
  store <2 x float> %221, ptr %34, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %36) #6
  %222 = getelementptr inbounds %struct.vrVec2, ptr %34, i32 0, i32 1
  %223 = load float, ptr %222, align 4, !tbaa !37
  %224 = getelementptr inbounds %struct.vrVec2, ptr %34, i32 0, i32 0
  %225 = load float, ptr %224, align 4, !tbaa !38
  %226 = fneg float %225
  %227 = call <2 x float> @vrVect(float noundef %223, float noundef %226)
  store <2 x float> %227, ptr %36, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %11, ptr align 4 %36, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %12, ptr align 4 %32, i64 8, i1 false), !tbaa.struct !15
  %228 = load ptr, ptr %16, align 8, !tbaa !5
  %229 = getelementptr inbounds %struct.vrRaycastOutput, ptr %0, i32 0, i32 4
  store ptr %228, ptr %229, align 8, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #6
  br label %230

230:                                              ; preds = %215, %212
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #6
  br label %267

231:                                              ; preds = %199, %172
  %232 = load float, ptr %31, align 4, !tbaa !16
  %233 = fcmp oge float %232, 0.000000e+00
  br i1 %233, label %234, label %266

234:                                              ; preds = %231
  %235 = load float, ptr %31, align 4, !tbaa !16
  %236 = fcmp ole float %235, 1.000000e+00
  br i1 %236, label %237, label %266

237:                                              ; preds = %234
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #6
  %238 = load float, ptr %30, align 4, !tbaa !16
  %239 = load <2 x float>, ptr %24, align 4
  %240 = call <2 x float> @vrScale(<2 x float> %239, float noundef %238)
  store <2 x float> %240, ptr %38, align 4
  %241 = load <2 x float>, ptr %20, align 4
  %242 = load <2 x float>, ptr %38, align 4
  %243 = call <2 x float> @vrAdd(<2 x float> %241, <2 x float> %242)
  store <2 x float> %243, ptr %37, align 4
  %244 = load float, ptr %31, align 4, !tbaa !16
  %245 = load float, ptr %10, align 4, !tbaa !16
  %246 = fcmp olt float %244, %245
  br i1 %246, label %250, label %247

247:                                              ; preds = %237
  %248 = load i32, ptr %13, align 4, !tbaa !18
  %249 = icmp ne i32 %248, 0
  br i1 %249, label %265, label %250

250:                                              ; preds = %247, %237
  %251 = load float, ptr %31, align 4, !tbaa !16
  store float %251, ptr %10, align 4, !tbaa !16
  store i32 1, ptr %13, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #6
  %252 = load <2 x float>, ptr %37, align 4
  %253 = load <2 x float>, ptr %22, align 4
  %254 = call <2 x float> @vrSub(<2 x float> %252, <2 x float> %253)
  store <2 x float> %254, ptr %40, align 4
  %255 = load <2 x float>, ptr %40, align 4
  %256 = call <2 x float> @vrNormalize(<2 x float> %255)
  store <2 x float> %256, ptr %39, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %41) #6
  %257 = getelementptr inbounds %struct.vrVec2, ptr %39, i32 0, i32 1
  %258 = load float, ptr %257, align 4, !tbaa !37
  %259 = getelementptr inbounds %struct.vrVec2, ptr %39, i32 0, i32 0
  %260 = load float, ptr %259, align 4, !tbaa !38
  %261 = fneg float %260
  %262 = call <2 x float> @vrVect(float noundef %258, float noundef %261)
  store <2 x float> %262, ptr %41, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %11, ptr align 4 %41, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %12, ptr align 4 %37, i64 8, i1 false), !tbaa.struct !15
  %263 = load ptr, ptr %16, align 8, !tbaa !5
  %264 = getelementptr inbounds %struct.vrRaycastOutput, ptr %0, i32 0, i32 4
  store ptr %263, ptr %264, align 8, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #6
  br label %265

265:                                              ; preds = %250, %247
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #6
  br label %266

266:                                              ; preds = %265, %234, %231
  br label %267

267:                                              ; preds = %266, %230
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #6
  br label %268

268:                                              ; preds = %267
  store i32 0, ptr %15, align 4
  br label %269

269:                                              ; preds = %268, %171
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #6
  %270 = load i32, ptr %15, align 4
  switch i32 %270, label %421 [
    i32 0, label %271
  ]

271:                                              ; preds = %269
  br label %420

272:                                              ; preds = %117
  call void @llvm.lifetime.start.p0(i64 8, ptr %42) #6
  %273 = load ptr, ptr %18, align 8, !tbaa !5
  %274 = getelementptr inbounds %struct.vrShape, ptr %273, i32 0, i32 0
  %275 = load ptr, ptr %274, align 8, !tbaa !34
  store ptr %275, ptr %42, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #6
  store i32 0, ptr %43, align 4, !tbaa !18
  br label %276

276:                                              ; preds = %416, %272
  %277 = load i32, ptr %43, align 4, !tbaa !18
  %278 = load ptr, ptr %42, align 8, !tbaa !5
  %279 = getelementptr inbounds %struct.vrPolygonShape, ptr %278, i32 0, i32 1
  %280 = load i32, ptr %279, align 8, !tbaa !39
  %281 = icmp slt i32 %277, %280
  br i1 %281, label %283, label %282

282:                                              ; preds = %276
  store i32 8, ptr %15, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #6
  br label %419

283:                                              ; preds = %276
  call void @llvm.lifetime.start.p0(i64 4, ptr %44) #6
  %284 = load i32, ptr %43, align 4, !tbaa !18
  %285 = load ptr, ptr %42, align 8, !tbaa !5
  %286 = getelementptr inbounds %struct.vrPolygonShape, ptr %285, i32 0, i32 1
  %287 = load i32, ptr %286, align 8, !tbaa !39
  %288 = sub nsw i32 %287, 1
  %289 = icmp slt i32 %284, %288
  br i1 %289, label %290, label %293

290:                                              ; preds = %283
  %291 = load i32, ptr %43, align 4, !tbaa !18
  %292 = add nsw i32 %291, 1
  br label %294

293:                                              ; preds = %283
  br label %294

294:                                              ; preds = %293, %290
  %295 = phi i32 [ %292, %290 ], [ 0, %293 ]
  store i32 %295, ptr %44, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %48) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %49) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %50) #6
  %296 = getelementptr inbounds %struct.vrRaycastInput, ptr %2, i32 0, i32 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %47, ptr align 8 %296, i64 8, i1 false), !tbaa.struct !15
  %297 = getelementptr inbounds %struct.vrRaycastInput, ptr %2, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %48, ptr align 8 %297, i64 8, i1 false), !tbaa.struct !15
  %298 = load ptr, ptr %42, align 8, !tbaa !5
  %299 = getelementptr inbounds %struct.vrPolygonShape, ptr %298, i32 0, i32 0
  %300 = load ptr, ptr %299, align 8, !tbaa !41
  %301 = load i32, ptr %43, align 4, !tbaa !18
  %302 = sext i32 %301 to i64
  %303 = getelementptr inbounds %struct.vrVec2, ptr %300, i64 %302
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %49, ptr align 4 %303, i64 8, i1 false), !tbaa.struct !15
  %304 = load ptr, ptr %42, align 8, !tbaa !5
  %305 = getelementptr inbounds %struct.vrPolygonShape, ptr %304, i32 0, i32 0
  %306 = load ptr, ptr %305, align 8, !tbaa !41
  %307 = load i32, ptr %44, align 4, !tbaa !18
  %308 = sext i32 %307 to i64
  %309 = getelementptr inbounds %struct.vrVec2, ptr %306, i64 %308
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %50, ptr align 4 %309, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.start.p0(i64 8, ptr %51) #6
  %310 = load <2 x float>, ptr %48, align 4
  %311 = load <2 x float>, ptr %47, align 4
  %312 = call <2 x float> @vrSub(<2 x float> %310, <2 x float> %311)
  store <2 x float> %312, ptr %51, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %45, ptr align 4 %51, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %51) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %52) #6
  %313 = load <2 x float>, ptr %50, align 4
  %314 = load <2 x float>, ptr %49, align 4
  %315 = call <2 x float> @vrSub(<2 x float> %313, <2 x float> %314)
  store <2 x float> %315, ptr %52, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %46, ptr align 4 %52, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %52) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %53) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %54) #6
  %316 = getelementptr inbounds %struct.vrVec2, ptr %45, i32 0, i32 1
  %317 = load float, ptr %316, align 4, !tbaa !37
  %318 = fneg float %317
  %319 = getelementptr inbounds %struct.vrVec2, ptr %47, i32 0, i32 0
  %320 = load float, ptr %319, align 4, !tbaa !38
  %321 = getelementptr inbounds %struct.vrVec2, ptr %49, i32 0, i32 0
  %322 = load float, ptr %321, align 4, !tbaa !38
  %323 = fsub float %320, %322
  %324 = getelementptr inbounds %struct.vrVec2, ptr %45, i32 0, i32 0
  %325 = load float, ptr %324, align 4, !tbaa !38
  %326 = getelementptr inbounds %struct.vrVec2, ptr %47, i32 0, i32 1
  %327 = load float, ptr %326, align 4, !tbaa !37
  %328 = getelementptr inbounds %struct.vrVec2, ptr %49, i32 0, i32 1
  %329 = load float, ptr %328, align 4, !tbaa !37
  %330 = fsub float %327, %329
  %331 = fmul float %325, %330
  %332 = call float @llvm.fmuladd.f32(float %318, float %323, float %331)
  %333 = getelementptr inbounds %struct.vrVec2, ptr %46, i32 0, i32 0
  %334 = load float, ptr %333, align 4, !tbaa !38
  %335 = fneg float %334
  %336 = getelementptr inbounds %struct.vrVec2, ptr %45, i32 0, i32 1
  %337 = load float, ptr %336, align 4, !tbaa !37
  %338 = getelementptr inbounds %struct.vrVec2, ptr %45, i32 0, i32 0
  %339 = load float, ptr %338, align 4, !tbaa !38
  %340 = getelementptr inbounds %struct.vrVec2, ptr %46, i32 0, i32 1
  %341 = load float, ptr %340, align 4, !tbaa !37
  %342 = fmul float %339, %341
  %343 = call float @llvm.fmuladd.f32(float %335, float %337, float %342)
  %344 = fdiv float %332, %343
  store float %344, ptr %53, align 4, !tbaa !16
  %345 = getelementptr inbounds %struct.vrVec2, ptr %46, i32 0, i32 0
  %346 = load float, ptr %345, align 4, !tbaa !38
  %347 = getelementptr inbounds %struct.vrVec2, ptr %47, i32 0, i32 1
  %348 = load float, ptr %347, align 4, !tbaa !37
  %349 = getelementptr inbounds %struct.vrVec2, ptr %49, i32 0, i32 1
  %350 = load float, ptr %349, align 4, !tbaa !37
  %351 = fsub float %348, %350
  %352 = getelementptr inbounds %struct.vrVec2, ptr %46, i32 0, i32 1
  %353 = load float, ptr %352, align 4, !tbaa !37
  %354 = getelementptr inbounds %struct.vrVec2, ptr %47, i32 0, i32 0
  %355 = load float, ptr %354, align 4, !tbaa !38
  %356 = getelementptr inbounds %struct.vrVec2, ptr %49, i32 0, i32 0
  %357 = load float, ptr %356, align 4, !tbaa !38
  %358 = fsub float %355, %357
  %359 = fmul float %353, %358
  %360 = fneg float %359
  %361 = call float @llvm.fmuladd.f32(float %346, float %351, float %360)
  %362 = getelementptr inbounds %struct.vrVec2, ptr %46, i32 0, i32 0
  %363 = load float, ptr %362, align 4, !tbaa !38
  %364 = fneg float %363
  %365 = getelementptr inbounds %struct.vrVec2, ptr %45, i32 0, i32 1
  %366 = load float, ptr %365, align 4, !tbaa !37
  %367 = getelementptr inbounds %struct.vrVec2, ptr %45, i32 0, i32 0
  %368 = load float, ptr %367, align 4, !tbaa !38
  %369 = getelementptr inbounds %struct.vrVec2, ptr %46, i32 0, i32 1
  %370 = load float, ptr %369, align 4, !tbaa !37
  %371 = fmul float %368, %370
  %372 = call float @llvm.fmuladd.f32(float %364, float %366, float %371)
  %373 = fdiv float %361, %372
  store float %373, ptr %54, align 4, !tbaa !16
  %374 = load float, ptr %53, align 4, !tbaa !16
  %375 = fcmp oge float %374, 0.000000e+00
  br i1 %375, label %376, label %411

376:                                              ; preds = %294
  %377 = load float, ptr %53, align 4, !tbaa !16
  %378 = fcmp ole float %377, 1.000000e+00
  br i1 %378, label %379, label %411

379:                                              ; preds = %376
  %380 = load float, ptr %54, align 4, !tbaa !16
  %381 = fcmp oge float %380, 0.000000e+00
  br i1 %381, label %382, label %411

382:                                              ; preds = %379
  %383 = load float, ptr %54, align 4, !tbaa !16
  %384 = fcmp ole float %383, 1.000000e+00
  br i1 %384, label %385, label %411

385:                                              ; preds = %382
  call void @llvm.lifetime.start.p0(i64 8, ptr %55) #6
  %386 = load float, ptr %54, align 4, !tbaa !16
  %387 = load <2 x float>, ptr %45, align 4
  %388 = call <2 x float> @vrScale(<2 x float> %387, float noundef %386)
  store <2 x float> %388, ptr %56, align 4
  %389 = load <2 x float>, ptr %47, align 4
  %390 = load <2 x float>, ptr %56, align 4
  %391 = call <2 x float> @vrAdd(<2 x float> %389, <2 x float> %390)
  store <2 x float> %391, ptr %55, align 4
  %392 = load float, ptr %54, align 4, !tbaa !16
  %393 = load float, ptr %10, align 4, !tbaa !16
  %394 = fcmp olt float %392, %393
  br i1 %394, label %398, label %395

395:                                              ; preds = %385
  %396 = load i32, ptr %13, align 4, !tbaa !18
  %397 = icmp ne i32 %396, 0
  br i1 %397, label %410, label %398

398:                                              ; preds = %395, %385
  %399 = load float, ptr %54, align 4, !tbaa !16
  store float %399, ptr %10, align 4, !tbaa !16
  store i32 1, ptr %13, align 4, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 8, ptr %57) #6
  %400 = load <2 x float>, ptr %46, align 4
  %401 = call <2 x float> @vrNormalize(<2 x float> %400)
  store <2 x float> %401, ptr %57, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %58) #6
  %402 = getelementptr inbounds %struct.vrVec2, ptr %57, i32 0, i32 1
  %403 = load float, ptr %402, align 4, !tbaa !37
  %404 = getelementptr inbounds %struct.vrVec2, ptr %57, i32 0, i32 0
  %405 = load float, ptr %404, align 4, !tbaa !38
  %406 = fneg float %405
  %407 = call <2 x float> @vrVect(float noundef %403, float noundef %406)
  store <2 x float> %407, ptr %58, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %11, ptr align 4 %58, i64 8, i1 false), !tbaa.struct !15
  call void @llvm.lifetime.end.p0(i64 8, ptr %58) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %12, ptr align 4 %55, i64 8, i1 false), !tbaa.struct !15
  %408 = load ptr, ptr %16, align 8, !tbaa !5
  %409 = getelementptr inbounds %struct.vrRaycastOutput, ptr %0, i32 0, i32 4
  store ptr %408, ptr %409, align 8, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %57) #6
  br label %410

410:                                              ; preds = %398, %395
  call void @llvm.lifetime.end.p0(i64 8, ptr %55) #6
  br label %412

411:                                              ; preds = %382, %379, %376, %294
  store i32 10, ptr %15, align 4
  br label %413

412:                                              ; preds = %410
  store i32 0, ptr %15, align 4
  br label %413

413:                                              ; preds = %412, %411
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %53) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %50) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %49) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %48) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %44) #6
  %414 = load i32, ptr %15, align 4
  switch i32 %414, label %440 [
    i32 0, label %415
    i32 10, label %416
  ]

415:                                              ; preds = %413
  br label %416

416:                                              ; preds = %415, %413
  %417 = load i32, ptr %43, align 4, !tbaa !18
  %418 = add nsw i32 %417, 1
  store i32 %418, ptr %43, align 4, !tbaa !18
  br label %276, !llvm.loop !42

419:                                              ; preds = %282
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #6
  br label %420

420:                                              ; preds = %419, %271
  store i32 0, ptr %15, align 4
  br label %421

421:                                              ; preds = %420, %269
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #6
  %422 = load i32, ptr %15, align 4
  switch i32 %422, label %440 [
    i32 0, label %423
    i32 7, label %424
  ]

423:                                              ; preds = %421
  br label %424

424:                                              ; preds = %423, %421
  %425 = load i32, ptr %17, align 4, !tbaa !18
  %426 = add nsw i32 %425, 1
  store i32 %426, ptr %17, align 4, !tbaa !18
  br label %108, !llvm.loop !44

427:                                              ; preds = %116
  br label %428

428:                                              ; preds = %427, %101
  br label %429

429:                                              ; preds = %428, %88
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #6
  br label %430

430:                                              ; preds = %429
  %431 = load i32, ptr %14, align 4, !tbaa !18
  %432 = add nsw i32 %431, 1
  store i32 %432, ptr %14, align 4, !tbaa !18
  br label %79, !llvm.loop !45

433:                                              ; preds = %87
  %434 = load i32, ptr %13, align 4, !tbaa !18
  %435 = getelementptr inbounds %struct.vrRaycastOutput, ptr %0, i32 0, i32 0
  store i32 %434, ptr %435, align 8, !tbaa !14
  %436 = getelementptr inbounds %struct.vrRaycastOutput, ptr %0, i32 0, i32 2
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %436, ptr align 4 %11, i64 8, i1 false), !tbaa.struct !15
  %437 = getelementptr inbounds %struct.vrRaycastOutput, ptr %0, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %437, ptr align 4 %12, i64 8, i1 false), !tbaa.struct !15
  %438 = load float, ptr %10, align 4, !tbaa !16
  %439 = getelementptr inbounds %struct.vrRaycastOutput, ptr %0, i32 0, i32 3
  store float %438, ptr %439, align 4, !tbaa !17
  store i32 1, ptr %15, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #6
  ret void

440:                                              ; preds = %421, %413
  unreachable
}

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

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

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

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

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

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

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

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

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

; Function Attrs: nounwind
declare double @sqrt(double noundef) #5

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

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

attributes #0 = { nounwind uwtable "min-legal-vector-width"="64" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #4 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #5 = { 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 #6 = { 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, !6, i64 24}
!10 = !{!"vrRaycastOutput", !11, i64 0, !12, i64 4, !12, i64 12, !13, i64 20, !6, i64 24}
!11 = !{!"int", !7, i64 0}
!12 = !{!"vrVec2", !13, i64 0, !13, i64 4}
!13 = !{!"float", !7, i64 0}
!14 = !{!10, !11, i64 0}
!15 = !{i64 0, i64 4, !16, i64 4, i64 4, !16}
!16 = !{!13, !13, i64 0}
!17 = !{!10, !13, i64 20}
!18 = !{!11, !11, i64 0}
!19 = !{!20, !6, i64 0}
!20 = !{!"vrWorld", !6, i64 0, !11, i64 8, !13, i64 12, !13, i64 16, !13, i64 20, !11, i64 24, !11, i64 28, !12, i64 32, !6, i64 40, !6, i64 48, !6, i64 56, !6, i64 64, !11, i64 72, !6, i64 80}
!21 = !{!22, !11, i64 8}
!22 = !{!"vrArray", !6, i64 0, !11, i64 8, !11, i64 12, !11, i64 16, !11, i64 20}
!23 = !{!22, !6, i64 0}
!24 = !{!25, !6, i64 16}
!25 = !{!"vrRaycastInput", !12, i64 0, !12, i64 8, !6, i64 16}
!26 = !{!27, !6, i64 88}
!27 = !{!"vrRigidBody", !12, i64 0, !12, i64 8, !12, i64 16, !12, i64 24, !13, i64 32, !13, i64 36, !13, i64 40, !13, i64 44, !28, i64 48, !29, i64 56, !6, i64 88, !30, i64 96, !12, i64 108, !31, i64 116, !6, i64 136, !11, i64 144}
!28 = !{!"vrCollisionGroup", !11, i64 0, !11, i64 4}
!29 = !{!"vrMaterial", !13, i64 0, !13, i64 4, !13, i64 8, !13, i64 12, !13, i64 16, !13, i64 20, !13, i64 24, !13, i64 28}
!30 = !{!"vrColor", !13, i64 0, !13, i64 4, !13, i64 8}
!31 = !{!"vrOrientedBoundingBox", !12, i64 0, !12, i64 8}
!32 = !{!33, !11, i64 8}
!33 = !{!"vrShape", !6, i64 0, !11, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !31, i64 48}
!34 = !{!33, !6, i64 0}
!35 = !{!36, !13, i64 0}
!36 = !{!"vrCircleShape", !13, i64 0, !12, i64 4}
!37 = !{!12, !13, i64 4}
!38 = !{!12, !13, i64 0}
!39 = !{!40, !11, i64 8}
!40 = !{!"vrPolygonShape", !6, i64 0, !11, i64 8, !6, i64 16, !11, i64 24, !12, i64 28}
!41 = !{!40, !6, i64 0}
!42 = distinct !{!42, !43}
!43 = !{!"llvm.loop.mustprogress"}
!44 = distinct !{!44, !43}
!45 = distinct !{!45, !43}


; 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.vrRaycastOutput = type { i32, %struct.vrVec2, %struct.vrVec2, float, ptr }
%struct.vrVec2 = type { float, float }
%struct.vrRaycastInput = type { %struct.vrVec2, %struct.vrVec2, ptr }

; Function Attrs: nounwind uwtable
define dso_local void @vrRaycast(ptr dead_on_unwind noalias nocapture writable writeonly sret(%struct.vrRaycastOutput) align 8 %0, ptr nocapture noundef readonly %1, ptr nocapture noundef readonly byval(%struct.vrRaycastInput) align 8 %2) local_unnamed_addr #0 {
  %4 = tail call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00) #4
  %5 = tail call <2 x float> @vrVect(float noundef 0.000000e+00, float noundef 0.000000e+00) #4
  %6 = getelementptr inbounds i8, ptr %2, i64 8
  %7 = load <2 x float>, ptr %6, align 8
  %8 = load <2 x float>, ptr %2, align 8
  %9 = tail call <2 x float> @vrSub(<2 x float> %7, <2 x float> %8) #4
  %10 = tail call float @vrLength(<2 x float> %9) #4
  %11 = fdiv float 1.000000e+00, %10
  %12 = tail call <2 x float> @vrScale(<2 x float> %9, float noundef %11) #4
  %13 = load ptr, ptr %1, align 8, !tbaa !5
  %14 = getelementptr inbounds i8, ptr %13, i64 8
  %15 = load i32, ptr %14, align 8, !tbaa !13
  %16 = icmp sgt i32 %15, 0
  br i1 %16, label %.lr.ph212, label %._crit_edge

.lr.ph212:                                        ; preds = %3
  %17 = getelementptr inbounds i8, ptr %2, i64 16
  %18 = load ptr, ptr %17, align 8, !tbaa !15
  %.not = icmp eq ptr %18, null
  br i1 %.not, label %._crit_edge, label %.lr.ph212.split

._crit_edge:                                      ; preds = %.loopexit179, %.lr.ph212, %3
  %.lcssa191.lcssa205.lcssa = phi ptr [ null, %3 ], [ null, %.lr.ph212 ], [ %.lcssa191.lcssa204, %.loopexit179 ]
  %.0156.lcssa = phi i32 [ 0, %3 ], [ 0, %.lr.ph212 ], [ %.11167, %.loopexit179 ]
  %.sroa.0141.0.lcssa = phi <2 x float> [ undef, %3 ], [ undef, %.lr.ph212 ], [ %.sroa.0141.11, %.loopexit179 ]
  %.sroa.0142.0.lcssa = phi <2 x float> [ undef, %3 ], [ undef, %.lr.ph212 ], [ %.sroa.0142.11, %.loopexit179 ]
  %.0.lcssa = phi float [ undef, %3 ], [ undef, %.lr.ph212 ], [ %.11, %.loopexit179 ]
  %19 = getelementptr inbounds i8, ptr %0, i64 20
  %20 = getelementptr inbounds i8, ptr %0, i64 12
  %21 = getelementptr inbounds i8, ptr %0, i64 4
  %22 = getelementptr inbounds i8, ptr %0, i64 24
  store ptr %.lcssa191.lcssa205.lcssa, ptr %22, align 8, !tbaa !17
  store i32 %.0156.lcssa, ptr %0, align 8, !tbaa !19
  store <2 x float> %.sroa.0142.0.lcssa, ptr %20, align 4
  store <2 x float> %.sroa.0141.0.lcssa, ptr %21, align 4
  store float %.0.lcssa, ptr %19, align 4, !tbaa !20
  ret void

.lr.ph212.split:                                  ; preds = %.lr.ph212, %.loopexit179
  %indvars.iv227 = phi i64 [ %indvars.iv.next228, %.loopexit179 ], [ 0, %.lr.ph212 ]
  %23 = phi ptr [ %145, %.loopexit179 ], [ %13, %.lr.ph212 ]
  %.0211 = phi float [ %.11, %.loopexit179 ], [ undef, %.lr.ph212 ]
  %.sroa.0142.0210 = phi <2 x float> [ %.sroa.0142.11, %.loopexit179 ], [ undef, %.lr.ph212 ]
  %.sroa.0141.0209 = phi <2 x float> [ %.sroa.0141.11, %.loopexit179 ], [ undef, %.lr.ph212 ]
  %.0156208 = phi i32 [ %.11167, %.loopexit179 ], [ 0, %.lr.ph212 ]
  %.lcssa191.lcssa205206 = phi ptr [ %.lcssa191.lcssa204, %.loopexit179 ], [ null, %.lr.ph212 ]
  %24 = load ptr, ptr %23, align 8, !tbaa !21
  %25 = getelementptr inbounds ptr, ptr %24, i64 %indvars.iv227
  %26 = load ptr, ptr %25, align 8, !tbaa !22
  %27 = tail call i32 %18(ptr noundef %26) #4
  %.not178 = icmp eq i32 %27, 0
  br i1 %.not178, label %.loopexit179, label %.preheader

.preheader:                                       ; preds = %.lr.ph212.split
  %28 = getelementptr inbounds i8, ptr %26, i64 88
  %29 = load ptr, ptr %28, align 8, !tbaa !23
  %30 = getelementptr inbounds i8, ptr %29, i64 8
  %31 = load i32, ptr %30, align 8, !tbaa !13
  %32 = icmp sgt i32 %31, 0
  br i1 %32, label %.lr.ph198, label %.loopexit179

.lr.ph198:                                        ; preds = %.preheader, %.loopexit
  %indvars.iv224 = phi i64 [ %indvars.iv.next225, %.loopexit ], [ 0, %.preheader ]
  %33 = phi ptr [ %140, %.loopexit ], [ %29, %.preheader ]
  %.1197 = phi float [ %.10, %.loopexit ], [ %.0211, %.preheader ]
  %.sroa.0142.1196 = phi <2 x float> [ %.sroa.0142.10, %.loopexit ], [ %.sroa.0142.0210, %.preheader ]
  %.sroa.0141.1195 = phi <2 x float> [ %.sroa.0141.10, %.loopexit ], [ %.sroa.0141.0209, %.preheader ]
  %.1157194 = phi i32 [ %.10166, %.loopexit ], [ %.0156208, %.preheader ]
  %.lcssa191192 = phi ptr [ %.lcssa190, %.loopexit ], [ %.lcssa191.lcssa205206, %.preheader ]
  %34 = load ptr, ptr %33, align 8, !tbaa !21
  %35 = getelementptr inbounds ptr, ptr %34, i64 %indvars.iv224
  %36 = load ptr, ptr %35, align 8, !tbaa !22
  %37 = getelementptr inbounds i8, ptr %36, i64 8
  %38 = load i32, ptr %37, align 8, !tbaa !29
  %39 = icmp eq i32 %38, 1
  %40 = load ptr, ptr %36, align 8, !tbaa !31
  br i1 %39, label %41, label %82

41:                                               ; preds = %.lr.ph198
  %42 = getelementptr inbounds i8, ptr %40, i64 4
  %.sroa.0113.0.copyload = load <2 x float>, ptr %42, align 4
  %43 = load float, ptr %40, align 4, !tbaa !32
  %44 = tail call <2 x float> @vrSub(<2 x float> %8, <2 x float> %.sroa.0113.0.copyload) #4
  %45 = tail call float @vrDot(<2 x float> %12, <2 x float> %12) #4
  %46 = tail call float @vrDot(<2 x float> %44, <2 x float> %12) #4
  %47 = fmul float %46, 2.000000e+00
  %48 = tail call float @vrDot(<2 x float> %44, <2 x float> %44) #4
  %49 = fneg float %43
  %50 = tail call float @llvm.fmuladd.f32(float %49, float %43, float %48)
  %51 = fmul float %45, -4.000000e+00
  %52 = fmul float %51, %50
  %53 = tail call float @llvm.fmuladd.f32(float %47, float %47, float %52)
  %54 = fcmp uge float %53, 0.000000e+00
  br i1 %54, label %55, label %.loopexit

55:                                               ; preds = %41
  %sqrtf = tail call float @sqrtf(float noundef %53) #5
  %56 = fneg float %47
  %57 = fsub float %56, %sqrtf
  %58 = fpext float %57 to double
  %59 = fpext float %45 to double
  %60 = fmul double %59, 2.000000e+00
  %61 = fdiv double %58, %60
  %62 = fptrunc double %61 to float
  %63 = fsub float %sqrtf, %47
  %64 = fpext float %63 to double
  %65 = fdiv double %64, %60
  %66 = fptrunc double %65 to float
  %67 = fcmp oge float %62, 0.000000e+00
  %68 = fcmp ole float %62, 1.000000e+00
  %or.cond = and i1 %67, %68
  br i1 %or.cond, label %69, label %74

69:                                               ; preds = %55
  %70 = tail call <2 x float> @vrScale(<2 x float> %12, float noundef %62) #4
  %71 = tail call <2 x float> @vrAdd(<2 x float> %8, <2 x float> %70) #4
  %72 = fcmp ule float %.1197, %62
  %73 = icmp ne i32 %.1157194, 0
  %or.cond3 = select i1 %72, i1 %73, i1 false
  br i1 %or.cond3, label %.loopexit, label %.loopexit.sink.split

74:                                               ; preds = %55
  %75 = fcmp oge float %66, 0.000000e+00
  %76 = fcmp ole float %66, 1.000000e+00
  %or.cond5 = and i1 %75, %76
  br i1 %or.cond5, label %77, label %.loopexit

77:                                               ; preds = %74
  %78 = tail call <2 x float> @vrScale(<2 x float> %12, float noundef %62) #4
  %79 = tail call <2 x float> @vrAdd(<2 x float> %8, <2 x float> %78) #4
  %80 = fcmp ule float %.1197, %66
  %81 = icmp ne i32 %.1157194, 0
  %or.cond7 = select i1 %80, i1 %81, i1 false
  br i1 %or.cond7, label %.loopexit, label %.loopexit.sink.split

82:                                               ; preds = %.lr.ph198
  %83 = getelementptr inbounds i8, ptr %40, i64 8
  %84 = load i32, ptr %83, align 8, !tbaa !34
  %85 = icmp sgt i32 %84, 0
  br i1 %85, label %.lr.ph, label %.loopexit

.lr.ph:                                           ; preds = %82, %131
  %indvars.iv = phi i64 [ %indvars.iv.next, %131 ], [ 0, %82 ]
  %86 = phi i32 [ %133, %131 ], [ %84, %82 ]
  %.6184 = phi float [ %.8, %131 ], [ %.1197, %82 ]
  %.sroa.0142.6183 = phi <2 x float> [ %.sroa.0142.8, %131 ], [ %.sroa.0142.1196, %82 ]
  %.sroa.0141.6182 = phi <2 x float> [ %.sroa.0141.8, %131 ], [ %.sroa.0141.1195, %82 ]
  %.6162181 = phi i32 [ %.8164, %131 ], [ %.1157194, %82 ]
  %87 = phi ptr [ %132, %131 ], [ %.lcssa191192, %82 ]
  %88 = add nsw i32 %86, -1
  %89 = sext i32 %88 to i64
  %90 = icmp slt i64 %indvars.iv, %89
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %91 = and i64 %indvars.iv.next, 4294967295
  %92 = load ptr, ptr %40, align 8, !tbaa !36
  %93 = getelementptr inbounds %struct.vrVec2, ptr %92, i64 %indvars.iv
  %.sroa.028.0.copyload = load <2 x float>, ptr %93, align 4
  %94 = select i1 %90, i64 %91, i64 0
  %95 = getelementptr inbounds %struct.vrVec2, ptr %92, i64 %94
  %.sroa.027.0.copyload = load <2 x float>, ptr %95, align 4
  %96 = tail call <2 x float> @vrSub(<2 x float> %7, <2 x float> %8) #4
  %97 = tail call <2 x float> @vrSub(<2 x float> %.sroa.027.0.copyload, <2 x float> %.sroa.028.0.copyload) #4
  %.sroa.052.4.vec.extract = extractelement <2 x float> %96, i64 1
  %98 = fneg float %.sroa.052.4.vec.extract
  %.sroa.052.0.vec.extract = extractelement <2 x float> %96, i64 0
  %.sroa.042.0.vec.extract = extractelement <2 x float> %97, i64 0
  %99 = fneg float %.sroa.042.0.vec.extract
  %.sroa.042.4.vec.extract = extractelement <2 x float> %97, i64 1
  %100 = fmul float %.sroa.052.0.vec.extract, %.sroa.042.4.vec.extract
  %101 = tail call float @llvm.fmuladd.f32(float %99, float %.sroa.052.4.vec.extract, float %100)
  %102 = fneg float %.sroa.042.4.vec.extract
  %103 = fsub <2 x float> %8, %.sroa.028.0.copyload
  %104 = shufflevector <2 x float> %96, <2 x float> poison, <2 x i32> <i32 poison, i32 0>
  %105 = insertelement <2 x float> %104, float %102, i64 0
  %106 = fmul <2 x float> %103, %105
  %107 = shufflevector <2 x float> %106, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %108 = shufflevector <2 x float> %97, <2 x float> poison, <2 x i32> <i32 poison, i32 0>
  %109 = insertelement <2 x float> %108, float %98, i64 0
  %110 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %109, <2 x float> %103, <2 x float> %107)
  %111 = insertelement <2 x float> poison, float %101, i64 0
  %112 = shufflevector <2 x float> %111, <2 x float> poison, <2 x i32> zeroinitializer
  %113 = fdiv <2 x float> %110, %112
  %114 = shufflevector <2 x float> %113, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
  %115 = fcmp ole <4 x float> %114, <float 1.000000e+00, float 1.000000e+00, float 0.000000e+00, float 0.000000e+00>
  %116 = fcmp oge <4 x float> %114, <float 1.000000e+00, float 1.000000e+00, float 0.000000e+00, float 0.000000e+00>
  %117 = shufflevector <4 x i1> %115, <4 x i1> %116, <4 x i32> <i32 0, i32 1, i32 6, i32 7>
  %118 = freeze <4 x i1> %117
  %119 = bitcast <4 x i1> %118 to i4
  %120 = icmp eq i4 %119, -1
  br i1 %120, label %121, label %131

121:                                              ; preds = %.lr.ph
  %122 = extractelement <2 x float> %113, i64 1
  %123 = tail call <2 x float> @vrScale(<2 x float> %96, float noundef %122) #4
  %124 = tail call <2 x float> @vrAdd(<2 x float> %8, <2 x float> %123) #4
  %125 = fcmp uge float %122, %.6184
  %126 = icmp ne i32 %.6162181, 0
  %or.cond15 = select i1 %125, i1 %126, i1 false
  br i1 %or.cond15, label %131, label %127

127:                                              ; preds = %121
  %128 = tail call <2 x float> @vrNormalize(<2 x float> %97) #4
  %.sroa.016.4.vec.extract = extractelement <2 x float> %128, i64 1
  %.sroa.016.0.vec.extract = extractelement <2 x float> %128, i64 0
  %129 = fneg float %.sroa.016.0.vec.extract
  %130 = tail call <2 x float> @vrVect(float noundef %.sroa.016.4.vec.extract, float noundef %129) #4
  br label %131

131:                                              ; preds = %.lr.ph, %127, %121
  %132 = phi ptr [ %87, %121 ], [ %26, %127 ], [ %87, %.lr.ph ]
  %.8164 = phi i32 [ %.6162181, %121 ], [ 1, %127 ], [ %.6162181, %.lr.ph ]
  %.sroa.0141.8 = phi <2 x float> [ %.sroa.0141.6182, %121 ], [ %124, %127 ], [ %.sroa.0141.6182, %.lr.ph ]
  %.sroa.0142.8 = phi <2 x float> [ %.sroa.0142.6183, %121 ], [ %130, %127 ], [ %.sroa.0142.6183, %.lr.ph ]
  %.8 = phi float [ %.6184, %121 ], [ %122, %127 ], [ %.6184, %.lr.ph ]
  %133 = load i32, ptr %83, align 8, !tbaa !34
  %134 = sext i32 %133 to i64
  %135 = icmp slt i64 %indvars.iv.next, %134
  br i1 %135, label %.lr.ph, label %.loopexit, !llvm.loop !37

.loopexit.sink.split:                             ; preds = %77, %69
  %.sink = phi <2 x float> [ %71, %69 ], [ %79, %77 ]
  %.10.ph = phi float [ %62, %69 ], [ %66, %77 ]
  %136 = tail call <2 x float> @vrSub(<2 x float> %.sink, <2 x float> %.sroa.0113.0.copyload) #4
  %137 = tail call <2 x float> @vrNormalize(<2 x float> %136) #4
  %.sroa.073.4.vec.extract = extractelement <2 x float> %137, i64 1
  %.sroa.073.0.vec.extract = extractelement <2 x float> %137, i64 0
  %138 = fneg float %.sroa.073.0.vec.extract
  %139 = tail call <2 x float> @vrVect(float noundef %.sroa.073.4.vec.extract, float noundef %138) #4
  br label %.loopexit

.loopexit:                                        ; preds = %131, %.loopexit.sink.split, %82, %41, %77, %69, %74
  %.lcssa190 = phi ptr [ %.lcssa191192, %41 ], [ %.lcssa191192, %74 ], [ %.lcssa191192, %69 ], [ %.lcssa191192, %77 ], [ %.lcssa191192, %82 ], [ %26, %.loopexit.sink.split ], [ %132, %131 ]
  %.10166 = phi i32 [ %.1157194, %41 ], [ %.1157194, %74 ], [ %.1157194, %69 ], [ %.1157194, %77 ], [ %.1157194, %82 ], [ 1, %.loopexit.sink.split ], [ %.8164, %131 ]
  %.sroa.0141.10 = phi <2 x float> [ %.sroa.0141.1195, %41 ], [ %.sroa.0141.1195, %74 ], [ %.sroa.0141.1195, %69 ], [ %.sroa.0141.1195, %77 ], [ %.sroa.0141.1195, %82 ], [ %.sink, %.loopexit.sink.split ], [ %.sroa.0141.8, %131 ]
  %.sroa.0142.10 = phi <2 x float> [ %.sroa.0142.1196, %41 ], [ %.sroa.0142.1196, %74 ], [ %.sroa.0142.1196, %69 ], [ %.sroa.0142.1196, %77 ], [ %.sroa.0142.1196, %82 ], [ %139, %.loopexit.sink.split ], [ %.sroa.0142.8, %131 ]
  %.10 = phi float [ %.1197, %41 ], [ %.1197, %74 ], [ %.1197, %69 ], [ %.1197, %77 ], [ %.1197, %82 ], [ %.10.ph, %.loopexit.sink.split ], [ %.8, %131 ]
  %indvars.iv.next225 = add nuw nsw i64 %indvars.iv224, 1
  %140 = load ptr, ptr %28, align 8, !tbaa !23
  %141 = getelementptr inbounds i8, ptr %140, i64 8
  %142 = load i32, ptr %141, align 8, !tbaa !13
  %143 = sext i32 %142 to i64
  %144 = icmp slt i64 %indvars.iv.next225, %143
  br i1 %144, label %.lr.ph198, label %.loopexit179, !llvm.loop !39

.loopexit179:                                     ; preds = %.loopexit, %.preheader, %.lr.ph212.split
  %.lcssa191.lcssa204 = phi ptr [ %.lcssa191.lcssa205206, %.lr.ph212.split ], [ %.lcssa191.lcssa205206, %.preheader ], [ %.lcssa190, %.loopexit ]
  %.11167 = phi i32 [ %.0156208, %.lr.ph212.split ], [ %.0156208, %.preheader ], [ %.10166, %.loopexit ]
  %.sroa.0141.11 = phi <2 x float> [ %.sroa.0141.0209, %.lr.ph212.split ], [ %.sroa.0141.0209, %.preheader ], [ %.sroa.0141.10, %.loopexit ]
  %.sroa.0142.11 = phi <2 x float> [ %.sroa.0142.0210, %.lr.ph212.split ], [ %.sroa.0142.0210, %.preheader ], [ %.sroa.0142.10, %.loopexit ]
  %.11 = phi float [ %.0211, %.lr.ph212.split ], [ %.0211, %.preheader ], [ %.10, %.loopexit ]
  %indvars.iv.next228 = add nuw nsw i64 %indvars.iv227, 1
  %145 = load ptr, ptr %1, align 8, !tbaa !5
  %146 = getelementptr inbounds i8, ptr %145, i64 8
  %147 = load i32, ptr %146, align 8, !tbaa !13
  %148 = sext i32 %147 to i64
  %149 = icmp slt i64 %indvars.iv.next228, %148
  br i1 %149, label %.lr.ph212.split, label %._crit_edge, !llvm.loop !40
}

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

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

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

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

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

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

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

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

declare float @sqrtf(float) local_unnamed_addr

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

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 = { "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 speculatable willreturn memory(none) }
attributes #3 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #4 = { nounwind }
attributes #5 = { mustprogress nofree nounwind willreturn memory(write) "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }

!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, !7, i64 0}
!6 = !{!"vrWorld", !7, i64 0, !10, i64 8, !11, i64 12, !11, i64 16, !11, i64 20, !10, i64 24, !10, i64 28, !12, i64 32, !7, i64 40, !7, i64 48, !7, i64 56, !7, i64 64, !10, i64 72, !7, i64 80}
!7 = !{!"any pointer", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"int", !8, i64 0}
!11 = !{!"float", !8, i64 0}
!12 = !{!"vrVec2", !11, i64 0, !11, i64 4}
!13 = !{!14, !10, i64 8}
!14 = !{!"vrArray", !7, i64 0, !10, i64 8, !10, i64 12, !10, i64 16, !10, i64 20}
!15 = !{!16, !7, i64 16}
!16 = !{!"vrRaycastInput", !12, i64 0, !12, i64 8, !7, i64 16}
!17 = !{!18, !7, i64 24}
!18 = !{!"vrRaycastOutput", !10, i64 0, !12, i64 4, !12, i64 12, !11, i64 20, !7, i64 24}
!19 = !{!18, !10, i64 0}
!20 = !{!18, !11, i64 20}
!21 = !{!14, !7, i64 0}
!22 = !{!7, !7, i64 0}
!23 = !{!24, !7, i64 88}
!24 = !{!"vrRigidBody", !12, i64 0, !12, i64 8, !12, i64 16, !12, i64 24, !11, i64 32, !11, i64 36, !11, i64 40, !11, i64 44, !25, i64 48, !26, i64 56, !7, i64 88, !27, i64 96, !12, i64 108, !28, i64 116, !7, i64 136, !10, i64 144}
!25 = !{!"vrCollisionGroup", !10, i64 0, !10, i64 4}
!26 = !{!"vrMaterial", !11, i64 0, !11, i64 4, !11, i64 8, !11, i64 12, !11, i64 16, !11, i64 20, !11, i64 24, !11, i64 28}
!27 = !{!"vrColor", !11, i64 0, !11, i64 4, !11, i64 8}
!28 = !{!"vrOrientedBoundingBox", !12, i64 0, !12, i64 8}
!29 = !{!30, !10, i64 8}
!30 = !{!"vrShape", !7, i64 0, !10, i64 8, !7, i64 16, !7, i64 24, !7, i64 32, !7, i64 40, !28, i64 48}
!31 = !{!30, !7, i64 0}
!32 = !{!33, !11, i64 0}
!33 = !{!"vrCircleShape", !11, i64 0, !12, i64 4}
!34 = !{!35, !10, i64 8}
!35 = !{!"vrPolygonShape", !7, i64 0, !10, i64 8, !7, i64 16, !10, i64 24, !12, i64 28}
!36 = !{!35, !7, i64 0}
!37 = distinct !{!37, !38}
!38 = !{!"llvm.loop.mustprogress"}
!39 = distinct !{!39, !38}
!40 = distinct !{!40, !38}


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