; LLVM IR from frozein/DoonEngine :: src/DoonEngine (voxelShapes)

; 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.DNvoxel = type { i8, %union.QMvec3, %struct.DNcolor }
%union.QMvec3 = type { [3 x float] }
%struct.DNcolor = type { i8, i8, i8 }
%union.QMquaternion = type { <4 x float> }
%union.QMmat4 = type { [4 x <4 x float>] }
%struct.DNivec3 = type { i32, i32, i32 }
%struct.DNchunkHandle = type { i8, i32 }
%struct.anon = type { float, float, float }
%struct.DNvolume = type { i32, i32, i32, %struct.DNuvec3, i64, i64, i64, i64, i64, i64, ptr, ptr, ptr, ptr, ptr, %union.QMvec3, %union.QMvec3, float, i32, %union.QMvec3, %union.QMvec3, %union.QMvec3, i32, i32, float, i8, i32, %union.QMvec3, %union.QMvec3, i32, float }
%struct.DNuvec3 = type { i32, i32, i32 }

; Function Attrs: nounwind uwtable
define dso_local void @DN_shape_sphere(ptr noundef %0, ptr noundef byval(%struct.DNvoxel) align 8 %1, i1 noundef zeroext %2, <2 x float> %3, float %4, float noundef %5, double %6, double %7, ptr noundef %8, ptr noundef %9) #0 {
  %11 = alloca %union.QMvec3, align 4
  %12 = alloca { <2 x float>, float }, align 4
  %13 = alloca %union.QMquaternion, align 16
  %14 = alloca ptr, align 8
  %15 = alloca i8, align 1
  %16 = alloca float, align 4
  %17 = alloca ptr, align 8
  %18 = alloca ptr, align 8
  %19 = alloca %union.QMmat4, align 16
  %20 = alloca %union.QMmat4, align 16
  %21 = alloca { <2 x float>, float }, align 4
  %22 = alloca %union.QMmat4, align 16
  %23 = alloca %union.QMmat4, align 16
  %24 = alloca %union.QMmat4, align 16
  %25 = alloca %union.QMvec3, align 4
  %26 = alloca %union.QMvec3, align 4
  %27 = alloca %struct.DNivec3, align 4
  %28 = alloca %struct.DNivec3, align 4
  %29 = alloca %struct.DNivec3, align 4
  %30 = alloca %struct.DNivec3, align 4
  %31 = alloca %struct.DNivec3, align 4
  %32 = alloca %struct.DNivec3, align 4
  %33 = alloca %struct.DNivec3, align 4
  %34 = alloca %struct.DNivec3, align 4
  %35 = alloca { i64, i32 }, align 4
  %36 = alloca { i64, i32 }, align 4
  %37 = alloca float, align 4
  %38 = alloca float, align 4
  %39 = alloca i32, align 4
  %40 = alloca i32, align 4
  %41 = alloca i32, align 4
  %42 = alloca i32, align 4
  %43 = alloca %struct.DNivec3, align 4
  %44 = alloca %struct.DNchunkHandle, align 4
  %45 = alloca i32, align 4
  %46 = alloca i32, align 4
  %47 = alloca i32, align 4
  %48 = alloca %struct.DNivec3, align 4
  %49 = alloca %union.QMvec3, align 4
  %50 = alloca %union.QMvec3, align 4
  %51 = alloca { <2 x float>, float }, align 4
  %52 = alloca { <2 x float>, float }, align 4
  %53 = alloca { <2 x float>, float }, align 8
  %54 = alloca float, align 4
  %55 = alloca { <2 x float>, float }, align 4
  %56 = alloca { <2 x float>, float }, align 4
  %57 = alloca { i64, i32 }, align 4
  %58 = alloca { i64, i32 }, align 4
  %59 = alloca %struct.DNvoxel, align 8
  %60 = alloca float, align 4
  %61 = alloca %union.QMvec3, align 4
  %62 = alloca { <2 x float>, float }, align 4
  %63 = alloca { <2 x float>, float }, align 8
  %64 = alloca %struct.DNvoxel, align 4
  %65 = alloca { <2 x float>, float }, align 4
  %66 = alloca { <2 x float>, float }, align 4
  %67 = alloca { <2 x float>, float }, align 4
  %68 = alloca { <2 x float>, float }, align 4
  %69 = alloca { i64, i32 }, align 4
  %70 = alloca { i64, i32 }, align 4
  %71 = alloca { i64, i32 }, align 4
  %72 = alloca { i64, i32 }, align 4
  %73 = alloca %struct.DNvoxel, align 8
  %74 = alloca { i64, i32 }, align 4
  %75 = alloca { i64, i32 }, align 4
  %76 = alloca float, align 4
  %77 = alloca %union.QMvec3, align 4
  %78 = alloca { <2 x float>, float }, align 4
  %79 = alloca { <2 x float>, float }, align 8
  %80 = alloca %struct.DNvoxel, align 4
  %81 = alloca { <2 x float>, float }, align 4
  %82 = alloca { <2 x float>, float }, align 4
  %83 = alloca { <2 x float>, float }, align 4
  %84 = alloca { <2 x float>, float }, align 4
  %85 = alloca { i64, i32 }, align 4
  %86 = alloca { i64, i32 }, align 4
  %87 = getelementptr inbounds { <2 x float>, float }, ptr %12, i32 0, i32 0
  store <2 x float> %3, ptr %87, align 4
  %88 = getelementptr inbounds { <2 x float>, float }, ptr %12, i32 0, i32 1
  store float %4, ptr %88, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %11, ptr align 4 %12, i64 12, i1 false)
  %89 = getelementptr inbounds { double, double }, ptr %13, i32 0, i32 0
  store double %6, ptr %89, align 16
  %90 = getelementptr inbounds { double, double }, ptr %13, i32 0, i32 1
  store double %7, ptr %90, align 8
  store ptr %0, ptr %14, align 8, !tbaa !5
  %91 = zext i1 %2 to i8
  store i8 %91, ptr %15, align 1, !tbaa !9
  store float %5, ptr %16, align 4, !tbaa !11
  store ptr %8, ptr %17, align 8, !tbaa !5
  store ptr %9, ptr %18, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 64, ptr %19) #8
  call void @llvm.lifetime.start.p0(i64 64, ptr %20) #8
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %21, ptr align 4 %11, i64 12, i1 false)
  %92 = getelementptr inbounds { <2 x float>, float }, ptr %21, i32 0, i32 0
  %93 = load <2 x float>, ptr %92, align 4
  %94 = getelementptr inbounds { <2 x float>, float }, ptr %21, i32 0, i32 1
  %95 = load float, ptr %94, align 4
  call void @DN_mat4_translate(ptr dead_on_unwind writable sret(%union.QMmat4) align 16 %20, <2 x float> %93, float %95)
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %19, ptr align 16 %20, i64 64, i1 false), !tbaa.struct !13
  call void @llvm.lifetime.end.p0(i64 64, ptr %20) #8
  call void @llvm.lifetime.start.p0(i64 64, ptr %22) #8
  %96 = getelementptr inbounds { double, double }, ptr %13, i32 0, i32 0
  %97 = load double, ptr %96, align 16
  %98 = getelementptr inbounds { double, double }, ptr %13, i32 0, i32 1
  %99 = load double, ptr %98, align 8
  call void @DN_quaternion_to_mat4(ptr dead_on_unwind writable sret(%union.QMmat4) align 16 %23, double %97, double %99)
  call void @DN_mat4_mult(ptr dead_on_unwind writable sret(%union.QMmat4) align 16 %22, ptr noundef byval(%union.QMmat4) align 16 %19, ptr noundef byval(%union.QMmat4) align 16 %23)
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %19, ptr align 16 %22, i64 64, i1 false), !tbaa.struct !13
  call void @llvm.lifetime.end.p0(i64 64, ptr %22) #8
  call void @llvm.lifetime.start.p0(i64 64, ptr %24) #8
  call void @DN_mat4_inv(ptr dead_on_unwind writable sret(%union.QMmat4) align 16 %24, ptr noundef byval(%union.QMmat4) align 16 %19)
  call void @llvm.lifetime.start.p0(i64 12, ptr %25) #8
  %100 = getelementptr inbounds %struct.anon, ptr %11, i32 0, i32 0
  %101 = load float, ptr %100, align 4, !tbaa !14
  %102 = load float, ptr %16, align 4, !tbaa !11
  %103 = fsub float %101, %102
  store float %103, ptr %25, align 4, !tbaa !11
  %104 = getelementptr inbounds float, ptr %25, i64 1
  %105 = getelementptr inbounds %struct.anon, ptr %11, i32 0, i32 1
  %106 = load float, ptr %105, align 4, !tbaa !14
  %107 = load float, ptr %16, align 4, !tbaa !11
  %108 = fsub float %106, %107
  store float %108, ptr %104, align 4, !tbaa !11
  %109 = getelementptr inbounds float, ptr %25, i64 2
  %110 = getelementptr inbounds %struct.anon, ptr %11, i32 0, i32 2
  %111 = load float, ptr %110, align 4, !tbaa !14
  %112 = load float, ptr %16, align 4, !tbaa !11
  %113 = fsub float %111, %112
  store float %113, ptr %109, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 12, ptr %26) #8
  %114 = getelementptr inbounds %struct.anon, ptr %11, i32 0, i32 0
  %115 = load float, ptr %114, align 4, !tbaa !14
  %116 = load float, ptr %16, align 4, !tbaa !11
  %117 = fadd float %115, %116
  store float %117, ptr %26, align 4, !tbaa !11
  %118 = getelementptr inbounds float, ptr %26, i64 1
  %119 = getelementptr inbounds %struct.anon, ptr %11, i32 0, i32 1
  %120 = load float, ptr %119, align 4, !tbaa !14
  %121 = load float, ptr %16, align 4, !tbaa !11
  %122 = fadd float %120, %121
  store float %122, ptr %118, align 4, !tbaa !11
  %123 = getelementptr inbounds float, ptr %26, i64 2
  %124 = getelementptr inbounds %struct.anon, ptr %11, i32 0, i32 2
  %125 = load float, ptr %124, align 4, !tbaa !14
  %126 = load float, ptr %16, align 4, !tbaa !11
  %127 = fadd float %125, %126
  store float %127, ptr %123, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 12, ptr %27) #8
  %128 = getelementptr inbounds %struct.DNivec3, ptr %27, i32 0, i32 0
  %129 = getelementptr inbounds %struct.anon, ptr %25, i32 0, i32 0
  %130 = load float, ptr %129, align 4, !tbaa !14
  %131 = call float @llvm.floor.f32(float %130)
  %132 = fptosi float %131 to i32
  store i32 %132, ptr %128, align 4, !tbaa !15
  %133 = getelementptr inbounds %struct.DNivec3, ptr %27, i32 0, i32 1
  %134 = getelementptr inbounds %struct.anon, ptr %25, i32 0, i32 1
  %135 = load float, ptr %134, align 4, !tbaa !14
  %136 = call float @llvm.floor.f32(float %135)
  %137 = fptosi float %136 to i32
  store i32 %137, ptr %133, align 4, !tbaa !18
  %138 = getelementptr inbounds %struct.DNivec3, ptr %27, i32 0, i32 2
  %139 = getelementptr inbounds %struct.anon, ptr %25, i32 0, i32 2
  %140 = load float, ptr %139, align 4, !tbaa !14
  %141 = call float @llvm.floor.f32(float %140)
  %142 = fptosi float %141 to i32
  store i32 %142, ptr %138, align 4, !tbaa !19
  call void @llvm.lifetime.start.p0(i64 12, ptr %28) #8
  %143 = getelementptr inbounds %struct.DNivec3, ptr %28, i32 0, i32 0
  %144 = getelementptr inbounds %struct.anon, ptr %26, i32 0, i32 0
  %145 = load float, ptr %144, align 4, !tbaa !14
  %146 = call float @llvm.ceil.f32(float %145)
  %147 = fptosi float %146 to i32
  store i32 %147, ptr %143, align 4, !tbaa !15
  %148 = getelementptr inbounds %struct.DNivec3, ptr %28, i32 0, i32 1
  %149 = getelementptr inbounds %struct.anon, ptr %26, i32 0, i32 1
  %150 = load float, ptr %149, align 4, !tbaa !14
  %151 = call float @llvm.ceil.f32(float %150)
  %152 = fptosi float %151 to i32
  store i32 %152, ptr %148, align 4, !tbaa !18
  %153 = getelementptr inbounds %struct.DNivec3, ptr %28, i32 0, i32 2
  %154 = getelementptr inbounds %struct.anon, ptr %26, i32 0, i32 2
  %155 = load float, ptr %154, align 4, !tbaa !14
  %156 = call float @llvm.ceil.f32(float %155)
  %157 = fptosi float %156 to i32
  store i32 %157, ptr %153, align 4, !tbaa !19
  %158 = getelementptr inbounds %struct.DNvoxel, ptr %1, i32 0, i32 0
  %159 = load i8, ptr %158, align 8, !tbaa !20
  %160 = zext i8 %159 to i32
  %161 = icmp eq i32 %160, 255
  br i1 %161, label %162, label %187

162:                                              ; preds = %10
  %163 = getelementptr inbounds %struct.DNivec3, ptr %29, i32 0, i32 0
  %164 = getelementptr inbounds %struct.DNivec3, ptr %27, i32 0, i32 0
  %165 = load i32, ptr %164, align 4, !tbaa !15
  %166 = sub nsw i32 %165, 1
  store i32 %166, ptr %163, align 4, !tbaa !15
  %167 = getelementptr inbounds %struct.DNivec3, ptr %29, i32 0, i32 1
  %168 = getelementptr inbounds %struct.DNivec3, ptr %27, i32 0, i32 1
  %169 = load i32, ptr %168, align 4, !tbaa !18
  %170 = sub nsw i32 %169, 1
  store i32 %170, ptr %167, align 4, !tbaa !18
  %171 = getelementptr inbounds %struct.DNivec3, ptr %29, i32 0, i32 2
  %172 = getelementptr inbounds %struct.DNivec3, ptr %27, i32 0, i32 2
  %173 = load i32, ptr %172, align 4, !tbaa !19
  %174 = sub nsw i32 %173, 1
  store i32 %174, ptr %171, align 4, !tbaa !19
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %27, ptr align 4 %29, i64 12, i1 false), !tbaa.struct !23
  %175 = getelementptr inbounds %struct.DNivec3, ptr %30, i32 0, i32 0
  %176 = getelementptr inbounds %struct.DNivec3, ptr %28, i32 0, i32 0
  %177 = load i32, ptr %176, align 4, !tbaa !15
  %178 = add nsw i32 %177, 1
  store i32 %178, ptr %175, align 4, !tbaa !15
  %179 = getelementptr inbounds %struct.DNivec3, ptr %30, i32 0, i32 1
  %180 = getelementptr inbounds %struct.DNivec3, ptr %28, i32 0, i32 1
  %181 = load i32, ptr %180, align 4, !tbaa !18
  %182 = add nsw i32 %181, 1
  store i32 %182, ptr %179, align 4, !tbaa !18
  %183 = getelementptr inbounds %struct.DNivec3, ptr %30, i32 0, i32 2
  %184 = getelementptr inbounds %struct.DNivec3, ptr %28, i32 0, i32 2
  %185 = load i32, ptr %184, align 4, !tbaa !19
  %186 = add nsw i32 %185, 1
  store i32 %186, ptr %183, align 4, !tbaa !19
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %28, ptr align 4 %30, i64 12, i1 false), !tbaa.struct !23
  br label %187

187:                                              ; preds = %162, %10
  call void @llvm.lifetime.start.p0(i64 12, ptr %31) #8
  call void @llvm.lifetime.start.p0(i64 12, ptr %32) #8
  call void @llvm.lifetime.start.p0(i64 12, ptr %33) #8
  call void @llvm.lifetime.start.p0(i64 12, ptr %34) #8
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %35, ptr align 4 %27, i64 12, i1 false)
  %188 = getelementptr inbounds { i64, i32 }, ptr %35, i32 0, i32 0
  %189 = load i64, ptr %188, align 4
  %190 = getelementptr inbounds { i64, i32 }, ptr %35, i32 0, i32 1
  %191 = load i32, ptr %190, align 4
  call void @DN_separate_position(i64 %189, i32 %191, ptr noundef %31, ptr noundef %33)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %36, ptr align 4 %28, i64 12, i1 false)
  %192 = getelementptr inbounds { i64, i32 }, ptr %36, i32 0, i32 0
  %193 = load i64, ptr %192, align 4
  %194 = getelementptr inbounds { i64, i32 }, ptr %36, i32 0, i32 1
  %195 = load i32, ptr %194, align 4
  call void @DN_separate_position(i64 %193, i32 %195, ptr noundef %32, ptr noundef %34)
  %196 = getelementptr inbounds %struct.DNivec3, ptr %31, i32 0, i32 0
  %197 = load i32, ptr %196, align 4, !tbaa !15
  %198 = icmp sgt i32 %197, 0
  br i1 %198, label %199, label %202

199:                                              ; preds = %187
  %200 = getelementptr inbounds %struct.DNivec3, ptr %31, i32 0, i32 0
  %201 = load i32, ptr %200, align 4, !tbaa !15
  br label %203

202:                                              ; preds = %187
  br label %203

203:                                              ; preds = %202, %199
  %204 = phi i32 [ %201, %199 ], [ 0, %202 ]
  %205 = getelementptr inbounds %struct.DNivec3, ptr %31, i32 0, i32 0
  store i32 %204, ptr %205, align 4, !tbaa !15
  %206 = getelementptr inbounds %struct.DNivec3, ptr %31, i32 0, i32 1
  %207 = load i32, ptr %206, align 4, !tbaa !18
  %208 = icmp sgt i32 %207, 0
  br i1 %208, label %209, label %212

209:                                              ; preds = %203
  %210 = getelementptr inbounds %struct.DNivec3, ptr %31, i32 0, i32 1
  %211 = load i32, ptr %210, align 4, !tbaa !18
  br label %213

212:                                              ; preds = %203
  br label %213

213:                                              ; preds = %212, %209
  %214 = phi i32 [ %211, %209 ], [ 0, %212 ]
  %215 = getelementptr inbounds %struct.DNivec3, ptr %31, i32 0, i32 1
  store i32 %214, ptr %215, align 4, !tbaa !18
  %216 = getelementptr inbounds %struct.DNivec3, ptr %31, i32 0, i32 2
  %217 = load i32, ptr %216, align 4, !tbaa !19
  %218 = icmp sgt i32 %217, 0
  br i1 %218, label %219, label %222

219:                                              ; preds = %213
  %220 = getelementptr inbounds %struct.DNivec3, ptr %31, i32 0, i32 2
  %221 = load i32, ptr %220, align 4, !tbaa !19
  br label %223

222:                                              ; preds = %213
  br label %223

223:                                              ; preds = %222, %219
  %224 = phi i32 [ %221, %219 ], [ 0, %222 ]
  %225 = getelementptr inbounds %struct.DNivec3, ptr %31, i32 0, i32 2
  store i32 %224, ptr %225, align 4, !tbaa !19
  %226 = getelementptr inbounds %struct.DNivec3, ptr %32, i32 0, i32 0
  %227 = load i32, ptr %226, align 4, !tbaa !15
  %228 = load ptr, ptr %14, align 8, !tbaa !5
  %229 = getelementptr inbounds %struct.DNvolume, ptr %228, i32 0, i32 3
  %230 = getelementptr inbounds %struct.DNuvec3, ptr %229, i32 0, i32 0
  %231 = load i32, ptr %230, align 4, !tbaa !25
  %232 = sub i32 %231, 1
  %233 = icmp ult i32 %227, %232
  br i1 %233, label %234, label %237

234:                                              ; preds = %223
  %235 = getelementptr inbounds %struct.DNivec3, ptr %32, i32 0, i32 0
  %236 = load i32, ptr %235, align 4, !tbaa !15
  br label %243

237:                                              ; preds = %223
  %238 = load ptr, ptr %14, align 8, !tbaa !5
  %239 = getelementptr inbounds %struct.DNvolume, ptr %238, i32 0, i32 3
  %240 = getelementptr inbounds %struct.DNuvec3, ptr %239, i32 0, i32 0
  %241 = load i32, ptr %240, align 4, !tbaa !25
  %242 = sub i32 %241, 1
  br label %243

243:                                              ; preds = %237, %234
  %244 = phi i32 [ %236, %234 ], [ %242, %237 ]
  %245 = getelementptr inbounds %struct.DNivec3, ptr %32, i32 0, i32 0
  store i32 %244, ptr %245, align 4, !tbaa !15
  %246 = getelementptr inbounds %struct.DNivec3, ptr %32, i32 0, i32 1
  %247 = load i32, ptr %246, align 4, !tbaa !18
  %248 = load ptr, ptr %14, align 8, !tbaa !5
  %249 = getelementptr inbounds %struct.DNvolume, ptr %248, i32 0, i32 3
  %250 = getelementptr inbounds %struct.DNuvec3, ptr %249, i32 0, i32 1
  %251 = load i32, ptr %250, align 4, !tbaa !29
  %252 = sub i32 %251, 1
  %253 = icmp ult i32 %247, %252
  br i1 %253, label %254, label %257

254:                                              ; preds = %243
  %255 = getelementptr inbounds %struct.DNivec3, ptr %32, i32 0, i32 1
  %256 = load i32, ptr %255, align 4, !tbaa !18
  br label %263

257:                                              ; preds = %243
  %258 = load ptr, ptr %14, align 8, !tbaa !5
  %259 = getelementptr inbounds %struct.DNvolume, ptr %258, i32 0, i32 3
  %260 = getelementptr inbounds %struct.DNuvec3, ptr %259, i32 0, i32 1
  %261 = load i32, ptr %260, align 4, !tbaa !29
  %262 = sub i32 %261, 1
  br label %263

263:                                              ; preds = %257, %254
  %264 = phi i32 [ %256, %254 ], [ %262, %257 ]
  %265 = getelementptr inbounds %struct.DNivec3, ptr %32, i32 0, i32 1
  store i32 %264, ptr %265, align 4, !tbaa !18
  %266 = getelementptr inbounds %struct.DNivec3, ptr %32, i32 0, i32 2
  %267 = load i32, ptr %266, align 4, !tbaa !19
  %268 = load ptr, ptr %14, align 8, !tbaa !5
  %269 = getelementptr inbounds %struct.DNvolume, ptr %268, i32 0, i32 3
  %270 = getelementptr inbounds %struct.DNuvec3, ptr %269, i32 0, i32 2
  %271 = load i32, ptr %270, align 4, !tbaa !30
  %272 = sub i32 %271, 1
  %273 = icmp ult i32 %267, %272
  br i1 %273, label %274, label %277

274:                                              ; preds = %263
  %275 = getelementptr inbounds %struct.DNivec3, ptr %32, i32 0, i32 2
  %276 = load i32, ptr %275, align 4, !tbaa !19
  br label %283

277:                                              ; preds = %263
  %278 = load ptr, ptr %14, align 8, !tbaa !5
  %279 = getelementptr inbounds %struct.DNvolume, ptr %278, i32 0, i32 3
  %280 = getelementptr inbounds %struct.DNuvec3, ptr %279, i32 0, i32 2
  %281 = load i32, ptr %280, align 4, !tbaa !30
  %282 = sub i32 %281, 1
  br label %283

283:                                              ; preds = %277, %274
  %284 = phi i32 [ %276, %274 ], [ %282, %277 ]
  %285 = getelementptr inbounds %struct.DNivec3, ptr %32, i32 0, i32 2
  store i32 %284, ptr %285, align 4, !tbaa !19
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #8
  %286 = load float, ptr %16, align 4, !tbaa !11
  %287 = load float, ptr %16, align 4, !tbaa !11
  %288 = fmul float %286, %287
  store float %288, ptr %37, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #8
  %289 = load float, ptr %16, align 4, !tbaa !11
  %290 = fadd float %289, 1.000000e+00
  %291 = load float, ptr %16, align 4, !tbaa !11
  %292 = fadd float %291, 1.000000e+00
  %293 = fmul float %290, %292
  store float %293, ptr %38, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #8
  %294 = getelementptr inbounds %struct.DNivec3, ptr %31, i32 0, i32 2
  %295 = load i32, ptr %294, align 4, !tbaa !19
  store i32 %295, ptr %39, align 4, !tbaa !24
  br label %296

296:                                              ; preds = %615, %283
  %297 = load i32, ptr %39, align 4, !tbaa !24
  %298 = getelementptr inbounds %struct.DNivec3, ptr %32, i32 0, i32 2
  %299 = load i32, ptr %298, align 4, !tbaa !19
  %300 = icmp sle i32 %297, %299
  br i1 %300, label %302, label %301

301:                                              ; preds = %296
  store i32 2, ptr %40, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #8
  br label %618

302:                                              ; preds = %296
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #8
  %303 = getelementptr inbounds %struct.DNivec3, ptr %31, i32 0, i32 1
  %304 = load i32, ptr %303, align 4, !tbaa !18
  store i32 %304, ptr %41, align 4, !tbaa !24
  br label %305

305:                                              ; preds = %611, %302
  %306 = load i32, ptr %41, align 4, !tbaa !24
  %307 = getelementptr inbounds %struct.DNivec3, ptr %32, i32 0, i32 1
  %308 = load i32, ptr %307, align 4, !tbaa !18
  %309 = icmp sle i32 %306, %308
  br i1 %309, label %311, label %310

310:                                              ; preds = %305
  store i32 5, ptr %40, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #8
  br label %614

311:                                              ; preds = %305
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #8
  %312 = getelementptr inbounds %struct.DNivec3, ptr %31, i32 0, i32 0
  %313 = load i32, ptr %312, align 4, !tbaa !15
  store i32 %313, ptr %42, align 4, !tbaa !24
  br label %314

314:                                              ; preds = %607, %311
  %315 = load i32, ptr %42, align 4, !tbaa !24
  %316 = getelementptr inbounds %struct.DNivec3, ptr %32, i32 0, i32 0
  %317 = load i32, ptr %316, align 4, !tbaa !15
  %318 = icmp sle i32 %315, %317
  br i1 %318, label %320, label %319

319:                                              ; preds = %314
  store i32 8, ptr %40, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #8
  br label %610

320:                                              ; preds = %314
  call void @llvm.lifetime.start.p0(i64 12, ptr %43) #8
  %321 = getelementptr inbounds %struct.DNivec3, ptr %43, i32 0, i32 0
  %322 = load i32, ptr %42, align 4, !tbaa !24
  store i32 %322, ptr %321, align 4, !tbaa !15
  %323 = getelementptr inbounds %struct.DNivec3, ptr %43, i32 0, i32 1
  %324 = load i32, ptr %41, align 4, !tbaa !24
  store i32 %324, ptr %323, align 4, !tbaa !18
  %325 = getelementptr inbounds %struct.DNivec3, ptr %43, i32 0, i32 2
  %326 = load i32, ptr %39, align 4, !tbaa !24
  store i32 %326, ptr %325, align 4, !tbaa !19
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #8
  %327 = load ptr, ptr %14, align 8, !tbaa !5
  %328 = getelementptr inbounds %struct.DNvolume, ptr %327, i32 0, i32 10
  %329 = load ptr, ptr %328, align 8, !tbaa !31
  %330 = getelementptr inbounds %struct.DNivec3, ptr %43, i32 0, i32 0
  %331 = load i32, ptr %330, align 4, !tbaa !15
  %332 = load ptr, ptr %14, align 8, !tbaa !5
  %333 = getelementptr inbounds %struct.DNvolume, ptr %332, i32 0, i32 3
  %334 = getelementptr inbounds %struct.DNuvec3, ptr %333, i32 0, i32 0
  %335 = load i32, ptr %334, align 4, !tbaa !25
  %336 = getelementptr inbounds %struct.DNivec3, ptr %43, i32 0, i32 1
  %337 = load i32, ptr %336, align 4, !tbaa !18
  %338 = getelementptr inbounds %struct.DNivec3, ptr %43, i32 0, i32 2
  %339 = load i32, ptr %338, align 4, !tbaa !19
  %340 = load ptr, ptr %14, align 8, !tbaa !5
  %341 = getelementptr inbounds %struct.DNvolume, ptr %340, i32 0, i32 3
  %342 = getelementptr inbounds %struct.DNuvec3, ptr %341, i32 0, i32 1
  %343 = load i32, ptr %342, align 4, !tbaa !29
  %344 = mul i32 %339, %343
  %345 = add i32 %337, %344
  %346 = mul i32 %335, %345
  %347 = add i32 %331, %346
  %348 = zext i32 %347 to i64
  %349 = getelementptr inbounds %struct.DNchunkHandle, ptr %329, i64 %348
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %44, ptr align 4 %349, i64 8, i1 false), !tbaa.struct !32
  call void @llvm.lifetime.start.p0(i64 4, ptr %45) #8
  store i32 0, ptr %45, align 4, !tbaa !24
  br label %350

350:                                              ; preds = %603, %320
  %351 = load i32, ptr %45, align 4, !tbaa !24
  %352 = icmp slt i32 %351, 8
  br i1 %352, label %354, label %353

353:                                              ; preds = %350
  store i32 11, ptr %40, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %45) #8
  br label %606

354:                                              ; preds = %350
  call void @llvm.lifetime.start.p0(i64 4, ptr %46) #8
  store i32 0, ptr %46, align 4, !tbaa !24
  br label %355

355:                                              ; preds = %599, %354
  %356 = load i32, ptr %46, align 4, !tbaa !24
  %357 = icmp slt i32 %356, 8
  br i1 %357, label %359, label %358

358:                                              ; preds = %355
  store i32 14, ptr %40, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %46) #8
  br label %602

359:                                              ; preds = %355
  call void @llvm.lifetime.start.p0(i64 4, ptr %47) #8
  store i32 0, ptr %47, align 4, !tbaa !24
  br label %360

360:                                              ; preds = %595, %359
  %361 = load i32, ptr %47, align 4, !tbaa !24
  %362 = icmp slt i32 %361, 8
  br i1 %362, label %364, label %363

363:                                              ; preds = %360
  store i32 17, ptr %40, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %47) #8
  br label %598

364:                                              ; preds = %360
  call void @llvm.lifetime.start.p0(i64 12, ptr %48) #8
  %365 = getelementptr inbounds %struct.DNivec3, ptr %48, i32 0, i32 0
  %366 = load i32, ptr %47, align 4, !tbaa !24
  store i32 %366, ptr %365, align 4, !tbaa !15
  %367 = getelementptr inbounds %struct.DNivec3, ptr %48, i32 0, i32 1
  %368 = load i32, ptr %46, align 4, !tbaa !24
  store i32 %368, ptr %367, align 4, !tbaa !18
  %369 = getelementptr inbounds %struct.DNivec3, ptr %48, i32 0, i32 2
  %370 = load i32, ptr %45, align 4, !tbaa !24
  store i32 %370, ptr %369, align 4, !tbaa !19
  call void @llvm.lifetime.start.p0(i64 12, ptr %49) #8
  %371 = load i32, ptr %42, align 4, !tbaa !24
  %372 = mul nsw i32 %371, 8
  %373 = load i32, ptr %47, align 4, !tbaa !24
  %374 = add nsw i32 %372, %373
  %375 = sitofp i32 %374 to float
  store float %375, ptr %49, align 4, !tbaa !11
  %376 = getelementptr inbounds float, ptr %49, i64 1
  %377 = load i32, ptr %41, align 4, !tbaa !24
  %378 = mul nsw i32 %377, 8
  %379 = load i32, ptr %46, align 4, !tbaa !24
  %380 = add nsw i32 %378, %379
  %381 = sitofp i32 %380 to float
  store float %381, ptr %376, align 4, !tbaa !11
  %382 = getelementptr inbounds float, ptr %49, i64 2
  %383 = load i32, ptr %39, align 4, !tbaa !24
  %384 = mul nsw i32 %383, 8
  %385 = load i32, ptr %45, align 4, !tbaa !24
  %386 = add nsw i32 %384, %385
  %387 = sitofp i32 %386 to float
  store float %387, ptr %382, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 12, ptr %50) #8
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %51, ptr align 4 %49, i64 12, i1 false)
  %388 = getelementptr inbounds { <2 x float>, float }, ptr %51, i32 0, i32 0
  %389 = load <2 x float>, ptr %388, align 4
  %390 = getelementptr inbounds { <2 x float>, float }, ptr %51, i32 0, i32 1
  %391 = load float, ptr %390, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %52, ptr align 4 %11, i64 12, i1 false)
  %392 = getelementptr inbounds { <2 x float>, float }, ptr %52, i32 0, i32 0
  %393 = load <2 x float>, ptr %392, align 4
  %394 = getelementptr inbounds { <2 x float>, float }, ptr %52, i32 0, i32 1
  %395 = load float, ptr %394, align 4
  %396 = call { <2 x float>, float } @DN_vec3_sub(<2 x float> %389, float %391, <2 x float> %393, float %395)
  %397 = getelementptr inbounds %union.QMvec3, ptr %50, i32 0, i32 0
  store { <2 x float>, float } %396, ptr %53, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %397, ptr align 8 %53, i64 12, i1 false)
  call void @llvm.lifetime.start.p0(i64 4, ptr %54) #8
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %55, ptr align 4 %50, i64 12, i1 false)
  %398 = getelementptr inbounds { <2 x float>, float }, ptr %55, i32 0, i32 0
  %399 = load <2 x float>, ptr %398, align 4
  %400 = getelementptr inbounds { <2 x float>, float }, ptr %55, i32 0, i32 1
  %401 = load float, ptr %400, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %56, ptr align 4 %50, i64 12, i1 false)
  %402 = getelementptr inbounds { <2 x float>, float }, ptr %56, i32 0, i32 0
  %403 = load <2 x float>, ptr %402, align 4
  %404 = getelementptr inbounds { <2 x float>, float }, ptr %56, i32 0, i32 1
  %405 = load float, ptr %404, align 4
  %406 = call float @DN_vec3_dot(<2 x float> %399, float %401, <2 x float> %403, float %405)
  store float %406, ptr %54, align 4, !tbaa !11
  %407 = load float, ptr %54, align 4, !tbaa !11
  %408 = load float, ptr %37, align 4, !tbaa !11
  %409 = fcmp olt float %407, %408
  br i1 %409, label %410, label %495

410:                                              ; preds = %364
  %411 = getelementptr inbounds %struct.DNchunkHandle, ptr %44, i32 0, i32 0
  %412 = load i8, ptr %411, align 4, !tbaa !33
  %413 = zext i8 %412 to i32
  %414 = icmp ne i32 %413, 0
  br i1 %414, label %415, label %432

415:                                              ; preds = %410
  %416 = load ptr, ptr %14, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %57, ptr align 4 %43, i64 12, i1 false)
  %417 = getelementptr inbounds { i64, i32 }, ptr %57, i32 0, i32 0
  %418 = load i64, ptr %417, align 4
  %419 = getelementptr inbounds { i64, i32 }, ptr %57, i32 0, i32 1
  %420 = load i32, ptr %419, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %58, ptr align 4 %48, i64 12, i1 false)
  %421 = getelementptr inbounds { i64, i32 }, ptr %58, i32 0, i32 0
  %422 = load i64, ptr %421, align 4
  %423 = getelementptr inbounds { i64, i32 }, ptr %58, i32 0, i32 1
  %424 = load i32, ptr %423, align 4
  %425 = call zeroext i1 @DN_does_voxel_exist(ptr noundef %416, i64 %418, i32 %420, i64 %422, i32 %424)
  br i1 %425, label %426, label %432

426:                                              ; preds = %415
  %427 = getelementptr inbounds %struct.DNvoxel, ptr %1, i32 0, i32 0
  %428 = load i8, ptr %427, align 8, !tbaa !20
  %429 = zext i8 %428 to i32
  %430 = icmp ne i32 %429, 255
  br i1 %430, label %431, label %432

431:                                              ; preds = %426
  store i32 19, ptr %40, align 4
  br label %592

432:                                              ; preds = %426, %415, %410
  call void @llvm.lifetime.start.p0(i64 20, ptr %59) #8
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %59, ptr align 8 %1, i64 20, i1 false), !tbaa.struct !35
  %433 = getelementptr inbounds %struct.DNvoxel, ptr %1, i32 0, i32 0
  %434 = load i8, ptr %433, align 8, !tbaa !20
  %435 = zext i8 %434 to i32
  %436 = icmp ne i32 %435, 255
  br i1 %436, label %437, label %485

437:                                              ; preds = %432
  call void @llvm.lifetime.start.p0(i64 4, ptr %60) #8
  %438 = getelementptr inbounds %struct.anon, ptr %50, i32 0, i32 0
  %439 = load float, ptr %438, align 4, !tbaa !14
  %440 = fpext float %439 to double
  %441 = call double @llvm.fabs.f64(double %440)
  %442 = getelementptr inbounds %struct.anon, ptr %50, i32 0, i32 1
  %443 = load float, ptr %442, align 4, !tbaa !14
  %444 = fpext float %443 to double
  %445 = call double @llvm.fabs.f64(double %444)
  %446 = call double @llvm.maxnum.f64(double %441, double %445)
  %447 = getelementptr inbounds %struct.anon, ptr %50, i32 0, i32 2
  %448 = load float, ptr %447, align 4, !tbaa !14
  %449 = fpext float %448 to double
  %450 = call double @llvm.fabs.f64(double %449)
  %451 = call double @llvm.maxnum.f64(double %446, double %450)
  %452 = fptrunc double %451 to float
  store float %452, ptr %60, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 12, ptr %61) #8
  %453 = load float, ptr %60, align 4, !tbaa !11
  %454 = fdiv float 1.000000e+00, %453
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %62, ptr align 4 %50, i64 12, i1 false)
  %455 = getelementptr inbounds { <2 x float>, float }, ptr %62, i32 0, i32 0
  %456 = load <2 x float>, ptr %455, align 4
  %457 = getelementptr inbounds { <2 x float>, float }, ptr %62, i32 0, i32 1
  %458 = load float, ptr %457, align 4
  %459 = call { <2 x float>, float } @DN_vec3_scale(<2 x float> %456, float %458, float noundef %454)
  %460 = getelementptr inbounds %union.QMvec3, ptr %61, i32 0, i32 0
  store { <2 x float>, float } %459, ptr %63, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %460, ptr align 8 %63, i64 12, i1 false)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %50, ptr align 4 %61, i64 12, i1 false), !tbaa.struct !36
  call void @llvm.lifetime.end.p0(i64 12, ptr %61) #8
  %461 = load ptr, ptr %17, align 8, !tbaa !5
  %462 = icmp ne ptr %461, null
  br i1 %462, label %463, label %482

463:                                              ; preds = %437
  call void @llvm.lifetime.start.p0(i64 20, ptr %64) #8
  %464 = load ptr, ptr %17, align 8, !tbaa !5
  %465 = load ptr, ptr %18, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %65, ptr align 4 %49, i64 12, i1 false)
  %466 = getelementptr inbounds { <2 x float>, float }, ptr %65, i32 0, i32 0
  %467 = load <2 x float>, ptr %466, align 4
  %468 = getelementptr inbounds { <2 x float>, float }, ptr %65, i32 0, i32 1
  %469 = load float, ptr %468, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %66, ptr align 4 %50, i64 12, i1 false)
  %470 = getelementptr inbounds { <2 x float>, float }, ptr %66, i32 0, i32 0
  %471 = load <2 x float>, ptr %470, align 4
  %472 = getelementptr inbounds { <2 x float>, float }, ptr %66, i32 0, i32 1
  %473 = load float, ptr %472, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %67, ptr align 4 %25, i64 12, i1 false)
  %474 = getelementptr inbounds { <2 x float>, float }, ptr %67, i32 0, i32 0
  %475 = load <2 x float>, ptr %474, align 4
  %476 = getelementptr inbounds { <2 x float>, float }, ptr %67, i32 0, i32 1
  %477 = load float, ptr %476, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %68, ptr align 4 %26, i64 12, i1 false)
  %478 = getelementptr inbounds { <2 x float>, float }, ptr %68, i32 0, i32 0
  %479 = load <2 x float>, ptr %478, align 4
  %480 = getelementptr inbounds { <2 x float>, float }, ptr %68, i32 0, i32 1
  %481 = load float, ptr %480, align 4
  call void %464(ptr dead_on_unwind writable sret(%struct.DNvoxel) align 4 %64, <2 x float> %467, float %469, <2 x float> %471, float %473, ptr noundef byval(%struct.DNvoxel) align 8 %1, <2 x float> %475, float %477, <2 x float> %479, float %481, ptr noundef byval(%union.QMmat4) align 16 %24, ptr noundef %465)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %59, ptr align 4 %64, i64 20, i1 false), !tbaa.struct !35
  call void @llvm.lifetime.end.p0(i64 20, ptr %64) #8
  br label %484

482:                                              ; preds = %437
  %483 = getelementptr inbounds %struct.DNvoxel, ptr %59, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %483, ptr align 4 %50, i64 12, i1 false), !tbaa.struct !36
  br label %484

484:                                              ; preds = %482, %463
  call void @llvm.lifetime.end.p0(i64 4, ptr %60) #8
  br label %485

485:                                              ; preds = %484, %432
  %486 = load ptr, ptr %14, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %69, ptr align 4 %43, i64 12, i1 false)
  %487 = getelementptr inbounds { i64, i32 }, ptr %69, i32 0, i32 0
  %488 = load i64, ptr %487, align 4
  %489 = getelementptr inbounds { i64, i32 }, ptr %69, i32 0, i32 1
  %490 = load i32, ptr %489, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %70, ptr align 4 %48, i64 12, i1 false)
  %491 = getelementptr inbounds { i64, i32 }, ptr %70, i32 0, i32 0
  %492 = load i64, ptr %491, align 4
  %493 = getelementptr inbounds { i64, i32 }, ptr %70, i32 0, i32 1
  %494 = load i32, ptr %493, align 4
  call void @DN_set_voxel(ptr noundef %486, i64 %488, i32 %490, i64 %492, i32 %494, ptr noundef byval(%struct.DNvoxel) align 8 %59)
  call void @llvm.lifetime.end.p0(i64 20, ptr %59) #8
  br label %591

495:                                              ; preds = %364
  %496 = getelementptr inbounds %struct.DNvoxel, ptr %1, i32 0, i32 0
  %497 = load i8, ptr %496, align 8, !tbaa !20
  %498 = zext i8 %497 to i32
  %499 = icmp eq i32 %498, 255
  br i1 %499, label %500, label %590

500:                                              ; preds = %495
  %501 = load i8, ptr %15, align 1, !tbaa !9, !range !37, !noundef !38
  %502 = trunc i8 %501 to i1
  br i1 %502, label %503, label %590

503:                                              ; preds = %500
  %504 = load float, ptr %54, align 4, !tbaa !11
  %505 = load float, ptr %38, align 4, !tbaa !11
  %506 = fcmp olt float %504, %505
  br i1 %506, label %507, label %590

507:                                              ; preds = %503
  %508 = getelementptr inbounds %struct.DNchunkHandle, ptr %44, i32 0, i32 0
  %509 = load i8, ptr %508, align 4, !tbaa !33
  %510 = zext i8 %509 to i32
  %511 = icmp eq i32 %510, 0
  br i1 %511, label %523, label %512

512:                                              ; preds = %507
  %513 = load ptr, ptr %14, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %71, ptr align 4 %43, i64 12, i1 false)
  %514 = getelementptr inbounds { i64, i32 }, ptr %71, i32 0, i32 0
  %515 = load i64, ptr %514, align 4
  %516 = getelementptr inbounds { i64, i32 }, ptr %71, i32 0, i32 1
  %517 = load i32, ptr %516, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %72, ptr align 4 %48, i64 12, i1 false)
  %518 = getelementptr inbounds { i64, i32 }, ptr %72, i32 0, i32 0
  %519 = load i64, ptr %518, align 4
  %520 = getelementptr inbounds { i64, i32 }, ptr %72, i32 0, i32 1
  %521 = load i32, ptr %520, align 4
  %522 = call zeroext i1 @DN_does_voxel_exist(ptr noundef %513, i64 %515, i32 %517, i64 %519, i32 %521)
  br i1 %522, label %524, label %523

523:                                              ; preds = %512, %507
  store i32 19, ptr %40, align 4
  br label %592

524:                                              ; preds = %512
  call void @llvm.lifetime.start.p0(i64 20, ptr %73) #8
  %525 = load ptr, ptr %14, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %74, ptr align 4 %43, i64 12, i1 false)
  %526 = getelementptr inbounds { i64, i32 }, ptr %74, i32 0, i32 0
  %527 = load i64, ptr %526, align 4
  %528 = getelementptr inbounds { i64, i32 }, ptr %74, i32 0, i32 1
  %529 = load i32, ptr %528, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %75, ptr align 4 %48, i64 12, i1 false)
  %530 = getelementptr inbounds { i64, i32 }, ptr %75, i32 0, i32 0
  %531 = load i64, ptr %530, align 4
  %532 = getelementptr inbounds { i64, i32 }, ptr %75, i32 0, i32 1
  %533 = load i32, ptr %532, align 4
  call void @DN_get_voxel(ptr dead_on_unwind writable sret(%struct.DNvoxel) align 4 %73, ptr noundef %525, i64 %527, i32 %529, i64 %531, i32 %533)
  call void @llvm.lifetime.start.p0(i64 4, ptr %76) #8
  %534 = getelementptr inbounds %struct.anon, ptr %50, i32 0, i32 0
  %535 = load float, ptr %534, align 4, !tbaa !14
  %536 = fpext float %535 to double
  %537 = call double @llvm.fabs.f64(double %536)
  %538 = getelementptr inbounds %struct.anon, ptr %50, i32 0, i32 1
  %539 = load float, ptr %538, align 4, !tbaa !14
  %540 = fpext float %539 to double
  %541 = call double @llvm.fabs.f64(double %540)
  %542 = call double @llvm.maxnum.f64(double %537, double %541)
  %543 = getelementptr inbounds %struct.anon, ptr %50, i32 0, i32 2
  %544 = load float, ptr %543, align 4, !tbaa !14
  %545 = fpext float %544 to double
  %546 = call double @llvm.fabs.f64(double %545)
  %547 = call double @llvm.maxnum.f64(double %542, double %546)
  %548 = fptrunc double %547 to float
  store float %548, ptr %76, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 12, ptr %77) #8
  %549 = load float, ptr %76, align 4, !tbaa !11
  %550 = fdiv float -1.000000e+00, %549
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %78, ptr align 4 %50, i64 12, i1 false)
  %551 = getelementptr inbounds { <2 x float>, float }, ptr %78, i32 0, i32 0
  %552 = load <2 x float>, ptr %551, align 4
  %553 = getelementptr inbounds { <2 x float>, float }, ptr %78, i32 0, i32 1
  %554 = load float, ptr %553, align 4
  %555 = call { <2 x float>, float } @DN_vec3_scale(<2 x float> %552, float %554, float noundef %550)
  %556 = getelementptr inbounds %union.QMvec3, ptr %77, i32 0, i32 0
  store { <2 x float>, float } %555, ptr %79, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %556, ptr align 8 %79, i64 12, i1 false)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %50, ptr align 4 %77, i64 12, i1 false), !tbaa.struct !36
  call void @llvm.lifetime.end.p0(i64 12, ptr %77) #8
  %557 = load ptr, ptr %17, align 8, !tbaa !5
  %558 = icmp ne ptr %557, null
  br i1 %558, label %559, label %578

559:                                              ; preds = %524
  call void @llvm.lifetime.start.p0(i64 20, ptr %80) #8
  %560 = load ptr, ptr %17, align 8, !tbaa !5
  %561 = load ptr, ptr %18, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %81, ptr align 4 %49, i64 12, i1 false)
  %562 = getelementptr inbounds { <2 x float>, float }, ptr %81, i32 0, i32 0
  %563 = load <2 x float>, ptr %562, align 4
  %564 = getelementptr inbounds { <2 x float>, float }, ptr %81, i32 0, i32 1
  %565 = load float, ptr %564, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %82, ptr align 4 %50, i64 12, i1 false)
  %566 = getelementptr inbounds { <2 x float>, float }, ptr %82, i32 0, i32 0
  %567 = load <2 x float>, ptr %566, align 4
  %568 = getelementptr inbounds { <2 x float>, float }, ptr %82, i32 0, i32 1
  %569 = load float, ptr %568, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %83, ptr align 4 %25, i64 12, i1 false)
  %570 = getelementptr inbounds { <2 x float>, float }, ptr %83, i32 0, i32 0
  %571 = load <2 x float>, ptr %570, align 4
  %572 = getelementptr inbounds { <2 x float>, float }, ptr %83, i32 0, i32 1
  %573 = load float, ptr %572, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %84, ptr align 4 %26, i64 12, i1 false)
  %574 = getelementptr inbounds { <2 x float>, float }, ptr %84, i32 0, i32 0
  %575 = load <2 x float>, ptr %574, align 4
  %576 = getelementptr inbounds { <2 x float>, float }, ptr %84, i32 0, i32 1
  %577 = load float, ptr %576, align 4
  call void %560(ptr dead_on_unwind writable sret(%struct.DNvoxel) align 4 %80, <2 x float> %563, float %565, <2 x float> %567, float %569, ptr noundef byval(%struct.DNvoxel) align 8 %73, <2 x float> %571, float %573, <2 x float> %575, float %577, ptr noundef byval(%union.QMmat4) align 16 %24, ptr noundef %561)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %73, ptr align 4 %80, i64 20, i1 false), !tbaa.struct !35
  call void @llvm.lifetime.end.p0(i64 20, ptr %80) #8
  br label %580

578:                                              ; preds = %524
  %579 = getelementptr inbounds %struct.DNvoxel, ptr %73, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %579, ptr align 4 %50, i64 12, i1 false), !tbaa.struct !36
  br label %580

580:                                              ; preds = %578, %559
  %581 = load ptr, ptr %14, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %85, ptr align 4 %43, i64 12, i1 false)
  %582 = getelementptr inbounds { i64, i32 }, ptr %85, i32 0, i32 0
  %583 = load i64, ptr %582, align 4
  %584 = getelementptr inbounds { i64, i32 }, ptr %85, i32 0, i32 1
  %585 = load i32, ptr %584, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %86, ptr align 4 %48, i64 12, i1 false)
  %586 = getelementptr inbounds { i64, i32 }, ptr %86, i32 0, i32 0
  %587 = load i64, ptr %586, align 4
  %588 = getelementptr inbounds { i64, i32 }, ptr %86, i32 0, i32 1
  %589 = load i32, ptr %588, align 4
  call void @DN_set_voxel(ptr noundef %581, i64 %583, i32 %585, i64 %587, i32 %589, ptr noundef byval(%struct.DNvoxel) align 8 %73)
  call void @llvm.lifetime.end.p0(i64 4, ptr %76) #8
  call void @llvm.lifetime.end.p0(i64 20, ptr %73) #8
  br label %590

590:                                              ; preds = %580, %503, %500, %495
  br label %591

591:                                              ; preds = %590, %485
  store i32 0, ptr %40, align 4
  br label %592

592:                                              ; preds = %591, %523, %431
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #8
  call void @llvm.lifetime.end.p0(i64 12, ptr %50) #8
  call void @llvm.lifetime.end.p0(i64 12, ptr %49) #8
  call void @llvm.lifetime.end.p0(i64 12, ptr %48) #8
  %593 = load i32, ptr %40, align 4
  switch i32 %593, label %619 [
    i32 0, label %594
    i32 19, label %595
  ]

594:                                              ; preds = %592
  br label %595

595:                                              ; preds = %594, %592
  %596 = load i32, ptr %47, align 4, !tbaa !24
  %597 = add nsw i32 %596, 1
  store i32 %597, ptr %47, align 4, !tbaa !24
  br label %360, !llvm.loop !39

598:                                              ; preds = %363
  br label %599

599:                                              ; preds = %598
  %600 = load i32, ptr %46, align 4, !tbaa !24
  %601 = add nsw i32 %600, 1
  store i32 %601, ptr %46, align 4, !tbaa !24
  br label %355, !llvm.loop !41

602:                                              ; preds = %358
  br label %603

603:                                              ; preds = %602
  %604 = load i32, ptr %45, align 4, !tbaa !24
  %605 = add nsw i32 %604, 1
  store i32 %605, ptr %45, align 4, !tbaa !24
  br label %350, !llvm.loop !42

606:                                              ; preds = %353
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #8
  call void @llvm.lifetime.end.p0(i64 12, ptr %43) #8
  br label %607

607:                                              ; preds = %606
  %608 = load i32, ptr %42, align 4, !tbaa !24
  %609 = add nsw i32 %608, 1
  store i32 %609, ptr %42, align 4, !tbaa !24
  br label %314, !llvm.loop !43

610:                                              ; preds = %319
  br label %611

611:                                              ; preds = %610
  %612 = load i32, ptr %41, align 4, !tbaa !24
  %613 = add nsw i32 %612, 1
  store i32 %613, ptr %41, align 4, !tbaa !24
  br label %305, !llvm.loop !44

614:                                              ; preds = %310
  br label %615

615:                                              ; preds = %614
  %616 = load i32, ptr %39, align 4, !tbaa !24
  %617 = add nsw i32 %616, 1
  store i32 %617, ptr %39, align 4, !tbaa !24
  br label %296, !llvm.loop !45

618:                                              ; preds = %301
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #8
  call void @llvm.lifetime.end.p0(i64 12, ptr %34) #8
  call void @llvm.lifetime.end.p0(i64 12, ptr %33) #8
  call void @llvm.lifetime.end.p0(i64 12, ptr %32) #8
  call void @llvm.lifetime.end.p0(i64 12, ptr %31) #8
  call void @llvm.lifetime.end.p0(i64 12, ptr %28) #8
  call void @llvm.lifetime.end.p0(i64 12, ptr %27) #8
  call void @llvm.lifetime.end.p0(i64 12, ptr %26) #8
  call void @llvm.lifetime.end.p0(i64 12, ptr %25) #8
  call void @llvm.lifetime.end.p0(i64 64, ptr %24) #8
  call void @llvm.lifetime.end.p0(i64 64, ptr %19) #8
  ret void

619:                                              ; preds = %592
  unreachable
}

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @DN_mat4_translate(ptr dead_on_unwind noalias writable sret(%union.QMmat4) align 16, <2 x float>, float) #3

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @DN_mat4_mult(ptr dead_on_unwind noalias writable sret(%union.QMmat4) align 16, ptr noundef byval(%union.QMmat4) align 16, ptr noundef byval(%union.QMmat4) align 16) #4

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @DN_quaternion_to_mat4(ptr dead_on_unwind noalias writable sret(%union.QMmat4) align 16, double, double) #5

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @DN_mat4_inv(ptr dead_on_unwind noalias writable sret(%union.QMmat4) align 16, ptr noundef byval(%union.QMmat4) align 16) #4

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

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

declare void @DN_separate_position(i64, i32, ptr noundef, ptr noundef) #7

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

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

declare zeroext i1 @DN_does_voxel_exist(ptr noundef, i64, i32, i64, i32) #7

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare double @llvm.fabs.f64(double) #6

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare double @llvm.maxnum.f64(double, double) #6

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

declare void @DN_set_voxel(ptr noundef, i64, i32, i64, i32, ptr noundef byval(%struct.DNvoxel) align 8) #7

declare void @DN_get_voxel(ptr dead_on_unwind writable sret(%struct.DNvoxel) align 4, ptr noundef, i64, i32, i64, i32) #7

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

!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 = !{!"_Bool", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"float", !7, i64 0}
!13 = !{i64 0, i64 64, !14}
!14 = !{!7, !7, i64 0}
!15 = !{!16, !17, i64 0}
!16 = !{!"DNivec3", !17, i64 0, !17, i64 4, !17, i64 8}
!17 = !{!"int", !7, i64 0}
!18 = !{!16, !17, i64 4}
!19 = !{!16, !17, i64 8}
!20 = !{!21, !7, i64 0}
!21 = !{!"DNvoxel", !7, i64 0, !7, i64 4, !22, i64 16}
!22 = !{!"DNcolor", !7, i64 0, !7, i64 1, !7, i64 2}
!23 = !{i64 0, i64 4, !24, i64 4, i64 4, !24, i64 8, i64 4, !24}
!24 = !{!17, !17, i64 0}
!25 = !{!26, !17, i64 12}
!26 = !{!"DNvolume", !17, i64 0, !17, i64 4, !17, i64 8, !27, i64 12, !28, i64 24, !28, i64 32, !28, i64 40, !28, i64 48, !28, i64 56, !28, i64 64, !6, i64 72, !6, i64 80, !6, i64 88, !6, i64 96, !6, i64 104, !7, i64 112, !7, i64 124, !12, i64 136, !17, i64 140, !7, i64 144, !7, i64 156, !7, i64 168, !17, i64 180, !17, i64 184, !12, i64 188, !10, i64 192, !17, i64 196, !7, i64 200, !7, i64 212, !17, i64 224, !12, i64 228}
!27 = !{!"DNuvec3", !17, i64 0, !17, i64 4, !17, i64 8}
!28 = !{!"long", !7, i64 0}
!29 = !{!26, !17, i64 16}
!30 = !{!26, !17, i64 20}
!31 = !{!26, !6, i64 72}
!32 = !{i64 0, i64 1, !14, i64 4, i64 4, !24}
!33 = !{!34, !7, i64 0}
!34 = !{!"DNchunkHandle", !7, i64 0, !17, i64 4}
!35 = !{i64 0, i64 1, !14, i64 4, i64 12, !14, i64 16, i64 1, !14, i64 17, i64 1, !14, i64 18, i64 1, !14}
!36 = !{i64 0, i64 12, !14}
!37 = !{i8 0, i8 2}
!38 = !{}
!39 = distinct !{!39, !40}
!40 = !{!"llvm.loop.mustprogress"}
!41 = distinct !{!41, !40}
!42 = distinct !{!42, !40}
!43 = distinct !{!43, !40}
!44 = distinct !{!44, !40}
!45 = distinct !{!45, !40}


; 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.DNvoxel = type { i8, %union.QMvec3, %struct.DNcolor }
%union.QMvec3 = type { [3 x float] }
%struct.DNcolor = type { i8, i8, i8 }
%union.QMmat4 = type { [4 x <4 x float>] }
%struct.DNivec3 = type { i32, i32, i32 }
%struct.DNchunkHandle = type { i8, i32 }

; Function Attrs: nounwind uwtable
define dso_local void @DN_shape_sphere(ptr noundef %0, ptr noundef byval(%struct.DNvoxel) align 8 %1, i1 noundef zeroext %2, <2 x float> %3, float %4, float noundef %5, double %6, double %7, ptr noundef readonly %8, ptr noundef %9) local_unnamed_addr #0 {
  %11 = alloca %union.QMmat4, align 16
  %12 = alloca %union.QMmat4, align 16
  %13 = alloca %union.QMmat4, align 16
  %14 = alloca %union.QMmat4, align 16
  %15 = alloca %struct.DNivec3, align 4
  %16 = alloca %struct.DNivec3, align 8
  %17 = alloca %struct.DNivec3, align 4
  %18 = alloca %struct.DNivec3, align 4
  %19 = alloca %struct.DNvoxel, align 8
  %20 = alloca %struct.DNvoxel, align 4
  %21 = alloca %struct.DNvoxel, align 8
  %22 = alloca %struct.DNvoxel, align 4
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %11) #9
  call void @DN_mat4_translate(ptr dead_on_unwind nonnull writable sret(%union.QMmat4) align 16 %11, <2 x float> %3, float %4)
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %12) #9
  call void @DN_quaternion_to_mat4(ptr dead_on_unwind nonnull writable sret(%union.QMmat4) align 16 %13, double %6, double %7)
  call void @DN_mat4_mult(ptr dead_on_unwind nonnull writable sret(%union.QMmat4) align 16 %12, ptr noundef nonnull byval(%union.QMmat4) align 16 %11, ptr noundef nonnull byval(%union.QMmat4) align 16 %13)
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(64) %11, ptr noundef nonnull align 16 dereferenceable(64) %12, i64 64, i1 false), !tbaa.struct !5
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %12) #9
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %14) #9
  call void @DN_mat4_inv(ptr dead_on_unwind nonnull writable sret(%union.QMmat4) align 16 %14, ptr noundef nonnull byval(%union.QMmat4) align 16 %11)
  %23 = insertelement <2 x float> poison, float %5, i64 0
  %24 = shufflevector <2 x float> %23, <2 x float> poison, <2 x i32> zeroinitializer
  %25 = fsub <2 x float> %3, %24
  %26 = fsub float %4, %5
  %27 = fadd <2 x float> %24, %3
  %28 = fadd float %4, %5
  %29 = extractelement <2 x float> %25, i64 0
  %30 = call float @llvm.floor.f32(float %29)
  %31 = extractelement <2 x float> %25, i64 1
  %32 = call float @llvm.floor.f32(float %31)
  %33 = call float @llvm.floor.f32(float %26)
  %34 = extractelement <2 x float> %27, i64 0
  %35 = call float @llvm.ceil.f32(float %34)
  %36 = extractelement <2 x float> %27, i64 1
  %37 = call float @llvm.ceil.f32(float %36)
  %38 = insertelement <2 x float> poison, float %35, i64 0
  %39 = insertelement <2 x float> %38, float %30, i64 1
  %40 = fptosi <2 x float> %39 to <2 x i32>
  %41 = zext <2 x i32> %40 to <2 x i64>
  %42 = insertelement <2 x float> poison, float %37, i64 0
  %43 = insertelement <2 x float> %42, float %32, i64 1
  %44 = fptosi <2 x float> %43 to <2 x i32>
  %45 = zext <2 x i32> %44 to <2 x i64>
  %46 = shl nuw <2 x i64> %45, <i64 32, i64 32>
  %47 = or disjoint <2 x i64> %46, %41
  %48 = call float @llvm.ceil.f32(float %28)
  %49 = insertelement <2 x float> poison, float %48, i64 0
  %50 = insertelement <2 x float> %49, float %33, i64 1
  %51 = fptosi <2 x float> %50 to <2 x i32>
  %52 = load i8, ptr %1, align 8, !tbaa !9
  %53 = icmp eq i8 %52, -1
  br i1 %53, label %54, label %62

54:                                               ; preds = %10
  %55 = add nsw <2 x i32> %40, <i32 1, i32 -1>
  %56 = add nsw <2 x i32> %44, <i32 1, i32 -1>
  %57 = add nsw <2 x i32> %51, <i32 1, i32 -1>
  %58 = zext <2 x i32> %55 to <2 x i64>
  %59 = zext <2 x i32> %56 to <2 x i64>
  %60 = shl nuw <2 x i64> %59, <i64 32, i64 32>
  %61 = or disjoint <2 x i64> %60, %58
  br label %62

62:                                               ; preds = %54, %10
  %63 = phi <2 x i32> [ %57, %54 ], [ %51, %10 ]
  %64 = phi <2 x i64> [ %61, %54 ], [ %47, %10 ]
  call void @llvm.lifetime.start.p0(i64 12, ptr nonnull %15) #9
  call void @llvm.lifetime.start.p0(i64 12, ptr nonnull %16) #9
  call void @llvm.lifetime.start.p0(i64 12, ptr nonnull %17) #9
  call void @llvm.lifetime.start.p0(i64 12, ptr nonnull %18) #9
  %65 = extractelement <2 x i32> %63, i64 1
  %66 = extractelement <2 x i64> %64, i64 1
  call void @DN_separate_position(i64 %66, i32 %65, ptr noundef nonnull %15, ptr noundef nonnull %17) #9
  %67 = extractelement <2 x i32> %63, i64 0
  %68 = extractelement <2 x i64> %64, i64 0
  call void @DN_separate_position(i64 %68, i32 %67, ptr noundef nonnull %16, ptr noundef nonnull %18) #9
  %69 = load i32, ptr %15, align 4
  %70 = call i32 @llvm.smax.i32(i32 %69, i32 0)
  store i32 %70, ptr %15, align 4, !tbaa !12
  %71 = getelementptr inbounds i8, ptr %15, i64 4
  %72 = load i32, ptr %71, align 4
  %73 = call i32 @llvm.smax.i32(i32 %72, i32 0)
  store i32 %73, ptr %71, align 4, !tbaa !15
  %74 = getelementptr inbounds i8, ptr %15, i64 8
  %75 = load i32, ptr %74, align 4
  %76 = call i32 @llvm.smax.i32(i32 %75, i32 0)
  store i32 %76, ptr %74, align 4, !tbaa !16
  %77 = getelementptr inbounds i8, ptr %0, i64 12
  %78 = getelementptr inbounds i8, ptr %16, i64 4
  %79 = getelementptr inbounds i8, ptr %0, i64 16
  %80 = load <2 x i32>, ptr %16, align 8, !tbaa !17
  %81 = load <2 x i32>, ptr %77, align 4, !tbaa !17
  %82 = add <2 x i32> %81, <i32 -1, i32 -1>
  %83 = call <2 x i32> @llvm.umin.v2i32(<2 x i32> %80, <2 x i32> %82)
  store <2 x i32> %83, ptr %16, align 8, !tbaa !17
  %84 = getelementptr inbounds i8, ptr %16, i64 8
  %85 = load i32, ptr %84, align 8, !tbaa !16
  %86 = getelementptr inbounds i8, ptr %0, i64 20
  %87 = load i32, ptr %86, align 4, !tbaa !18
  %88 = add i32 %87, -1
  %89 = call i32 @llvm.umin.i32(i32 %85, i32 %88)
  store i32 %89, ptr %84, align 8, !tbaa !16
  %90 = fmul float %5, %5
  %91 = fadd float %5, 1.000000e+00
  %92 = fmul float %91, %91
  %.not271 = icmp sgt i32 %76, %89
  br i1 %.not271, label %._crit_edge279, label %.lr.ph278

.lr.ph278:                                        ; preds = %62
  %93 = getelementptr inbounds i8, ptr %0, i64 72
  %.not239 = icmp eq ptr %8, null
  %94 = getelementptr inbounds i8, ptr %21, i64 4
  %.sroa.17.0..sroa_idx78 = getelementptr inbounds i8, ptr %21, i64 12
  %95 = getelementptr inbounds i8, ptr %19, i64 4
  %.sroa.17.0..sroa_idx = getelementptr inbounds i8, ptr %19, i64 12
  %96 = extractelement <2 x i32> %83, i64 1
  %97 = icmp sgt i32 %73, %96
  br i1 %97, label %._crit_edge279, label %.lr.ph278.split.preheader

.lr.ph278.split.preheader:                        ; preds = %.lr.ph278
  %98 = extractelement <2 x i32> %83, i64 0
  br label %.lr.ph278.split

._crit_edge279:                                   ; preds = %._crit_edge265, %.lr.ph278, %62
  call void @llvm.lifetime.end.p0(i64 12, ptr nonnull %18) #9
  call void @llvm.lifetime.end.p0(i64 12, ptr nonnull %17) #9
  call void @llvm.lifetime.end.p0(i64 12, ptr nonnull %16) #9
  call void @llvm.lifetime.end.p0(i64 12, ptr nonnull %15) #9
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %14) #9
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %11) #9
  ret void

.lr.ph278.split:                                  ; preds = %.lr.ph278.split.preheader, %._crit_edge265
  %99 = phi i32 [ %108, %._crit_edge265 ], [ %89, %.lr.ph278.split.preheader ]
  %100 = phi i32 [ %109, %._crit_edge265 ], [ %96, %.lr.ph278.split.preheader ]
  %101 = phi i32 [ %110, %._crit_edge265 ], [ %98, %.lr.ph278.split.preheader ]
  %102 = phi i32 [ %111, %._crit_edge265 ], [ %98, %.lr.ph278.split.preheader ]
  %103 = phi i32 [ %112, %._crit_edge265 ], [ %96, %.lr.ph278.split.preheader ]
  %.0275 = phi i32 [ %113, %._crit_edge265 ], [ %76, %.lr.ph278.split.preheader ]
  %104 = load i32, ptr %71, align 4, !tbaa !15
  %.not237258 = icmp sgt i32 %104, %103
  br i1 %.not237258, label %._crit_edge265, label %.lr.ph264

.lr.ph264:                                        ; preds = %.lr.ph278.split
  %105 = shl nsw i32 %.0275, 3
  %106 = load i32, ptr %15, align 4, !tbaa !12
  %107 = icmp sgt i32 %106, %102
  br i1 %107, label %._crit_edge265, label %.lr.ph264.split

._crit_edge265.loopexit280:                       ; preds = %._crit_edge
  %.pre288 = load i32, ptr %84, align 8, !tbaa !16
  br label %._crit_edge265

._crit_edge265:                                   ; preds = %.lr.ph264, %._crit_edge265.loopexit280, %.lr.ph278.split
  %108 = phi i32 [ %99, %.lr.ph278.split ], [ %.pre288, %._crit_edge265.loopexit280 ], [ %99, %.lr.ph264 ]
  %109 = phi i32 [ %100, %.lr.ph278.split ], [ %118, %._crit_edge265.loopexit280 ], [ %100, %.lr.ph264 ]
  %110 = phi i32 [ %101, %.lr.ph278.split ], [ %119, %._crit_edge265.loopexit280 ], [ %101, %.lr.ph264 ]
  %111 = phi i32 [ %102, %.lr.ph278.split ], [ %119, %._crit_edge265.loopexit280 ], [ %102, %.lr.ph264 ]
  %112 = phi i32 [ %103, %.lr.ph278.split ], [ %118, %._crit_edge265.loopexit280 ], [ %103, %.lr.ph264 ]
  %113 = add nuw nsw i32 %.0275, 1
  %.not.not = icmp slt i32 %.0275, %108
  br i1 %.not.not, label %.lr.ph278.split, label %._crit_edge279, !llvm.loop !25

.lr.ph264.split:                                  ; preds = %.lr.ph264, %._crit_edge
  %114 = phi i32 [ %118, %._crit_edge ], [ %100, %.lr.ph264 ]
  %115 = phi i32 [ %119, %._crit_edge ], [ %101, %.lr.ph264 ]
  %.0224262 = phi i32 [ %120, %._crit_edge ], [ %104, %.lr.ph264 ]
  %116 = load i32, ptr %15, align 4, !tbaa !12
  %.not238254 = icmp sgt i32 %116, %115
  br i1 %.not238254, label %._crit_edge, label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph264.split
  %.sroa.0107.4.insert.ext = zext i32 %.0224262 to i64
  %.sroa.0107.4.insert.shift = shl nuw i64 %.sroa.0107.4.insert.ext, 32
  %117 = shl nsw i32 %.0224262, 3
  br label %121

._crit_edge.loopexit:                             ; preds = %135
  %.pre = load i32, ptr %78, align 4, !tbaa !15
  br label %._crit_edge

._crit_edge:                                      ; preds = %._crit_edge.loopexit, %.lr.ph264.split
  %118 = phi i32 [ %114, %.lr.ph264.split ], [ %.pre, %._crit_edge.loopexit ]
  %119 = phi i32 [ %115, %.lr.ph264.split ], [ %137, %._crit_edge.loopexit ]
  %120 = add nsw i32 %.0224262, 1
  %.not237.not = icmp slt i32 %.0224262, %118
  br i1 %.not237.not, label %.lr.ph264.split, label %._crit_edge265.loopexit280, !llvm.loop !28

121:                                              ; preds = %.lr.ph, %135
  %.0225255 = phi i32 [ %116, %.lr.ph ], [ %136, %135 ]
  %.sroa.0107.0.insert.ext = zext i32 %.0225255 to i64
  %.sroa.0107.4.insert.insert = or disjoint i64 %.sroa.0107.4.insert.shift, %.sroa.0107.0.insert.ext
  %122 = load ptr, ptr %93, align 8, !tbaa !29
  %123 = load i32, ptr %77, align 4, !tbaa !30
  %124 = load i32, ptr %79, align 4, !tbaa !31
  %125 = mul i32 %124, %.0275
  %126 = add i32 %125, %.0224262
  %127 = mul i32 %126, %123
  %128 = add i32 %127, %.0225255
  %129 = zext i32 %128 to i64
  %130 = getelementptr inbounds %struct.DNchunkHandle, ptr %122, i64 %129
  %.sroa.0105.0.copyload = load i8, ptr %130, align 4, !tbaa !6
  %131 = shl nsw i32 %.0225255, 3
  %132 = icmp ne i8 %.sroa.0105.0.copyload, 0
  %.not240 = icmp eq i8 %.sroa.0105.0.copyload, 0
  br label %.preheader250

.preheader250:                                    ; preds = %121, %141
  %.0226253 = phi i32 [ 0, %121 ], [ %142, %141 ]
  %133 = add nuw nsw i32 %.0226253, %105
  %134 = uitofp nneg i32 %133 to float
  br label %.preheader

135:                                              ; preds = %141
  %136 = add nsw i32 %.0225255, 1
  %137 = load i32, ptr %16, align 8, !tbaa !12
  %.not238.not = icmp slt i32 %.0225255, %137
  br i1 %.not238.not, label %121, label %._crit_edge.loopexit, !llvm.loop !32

.preheader:                                       ; preds = %.preheader250, %143
  %indvars.iv283 = phi i64 [ 0, %.preheader250 ], [ %indvars.iv.next284, %143 ]
  %.sroa.085.4.insert.shift = shl nuw nsw i64 %indvars.iv283, 32
  %138 = trunc i64 %indvars.iv283 to i32
  %139 = add i32 %117, %138
  %140 = sitofp i32 %139 to float
  br label %144

141:                                              ; preds = %143
  %142 = add nuw nsw i32 %.0226253, 1
  %exitcond287.not = icmp eq i32 %142, 8
  br i1 %exitcond287.not, label %135, label %.preheader250, !llvm.loop !33

143:                                              ; preds = %186
  %indvars.iv.next284 = add nuw nsw i64 %indvars.iv283, 1
  %exitcond286.not = icmp eq i64 %indvars.iv.next284, 8
  br i1 %exitcond286.not, label %141, label %.preheader, !llvm.loop !34

144:                                              ; preds = %.preheader, %186
  %indvars.iv = phi i64 [ 0, %.preheader ], [ %indvars.iv.next, %186 ]
  %.sroa.085.4.insert.insert = or disjoint i64 %.sroa.085.4.insert.shift, %indvars.iv
  %145 = trunc i64 %indvars.iv to i32
  %146 = add i32 %131, %145
  %147 = sitofp i32 %146 to float
  %.sroa.081.0.vec.insert = insertelement <2 x float> poison, float %147, i64 0
  %.sroa.081.4.vec.insert = insertelement <2 x float> %.sroa.081.0.vec.insert, float %140, i64 1
  %148 = call { <2 x float>, float } @DN_vec3_sub(<2 x float> %.sroa.081.4.vec.insert, float %134, <2 x float> %3, float %4)
  %.fca.0.extract58 = extractvalue { <2 x float>, float } %148, 0
  %.fca.1.extract59 = extractvalue { <2 x float>, float } %148, 1
  %149 = call float @DN_vec3_dot(<2 x float> %.fca.0.extract58, float %.fca.1.extract59, <2 x float> %.fca.0.extract58, float %.fca.1.extract59)
  %150 = fcmp olt float %149, %90
  br i1 %150, label %151, label %169

151:                                              ; preds = %144
  br i1 %.not240, label %thread-pre-split, label %152

152:                                              ; preds = %151
  %153 = call zeroext i1 @DN_does_voxel_exist(ptr noundef %0, i64 %.sroa.0107.4.insert.insert, i32 %.0275, i64 %.sroa.085.4.insert.insert, i32 %.0226253) #9
  %154 = load i8, ptr %1, align 8
  %155 = icmp ne i8 %154, -1
  %or.cond = select i1 %153, i1 %155, i1 false
  br i1 %or.cond, label %186, label %156

thread-pre-split:                                 ; preds = %151
  %.pr = load i8, ptr %1, align 8, !tbaa !9
  br label %156

156:                                              ; preds = %thread-pre-split, %152
  %157 = phi i8 [ %.pr, %thread-pre-split ], [ %154, %152 ]
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %19) #9
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(20) %19, ptr noundef nonnull align 8 dereferenceable(20) %1, i64 20, i1 false), !tbaa.struct !35
  %.not241 = icmp eq i8 %157, -1
  br i1 %.not241, label %168, label %158

158:                                              ; preds = %156
  %.sroa.066.0.vec.extract = extractelement <2 x float> %.fca.0.extract58, i64 0
  %159 = call float @llvm.fabs.f32(float %.sroa.066.0.vec.extract)
  %.sroa.066.4.vec.extract = extractelement <2 x float> %.fca.0.extract58, i64 1
  %160 = call float @llvm.fabs.f32(float %.sroa.066.4.vec.extract)
  %161 = call float @llvm.maxnum.f32(float %159, float %160)
  %162 = call float @llvm.fabs.f32(float %.fca.1.extract59)
  %163 = call float @llvm.maxnum.f32(float %161, float %162)
  %164 = fdiv float 1.000000e+00, %163
  %165 = call { <2 x float>, float } @DN_vec3_scale(<2 x float> %.fca.0.extract58, float %.fca.1.extract59, float noundef %164)
  %.fca.0.extract39 = extractvalue { <2 x float>, float } %165, 0
  %.fca.1.extract40 = extractvalue { <2 x float>, float } %165, 1
  br i1 %.not239, label %167, label %166

166:                                              ; preds = %158
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %20) #9
  call void %8(ptr dead_on_unwind nonnull writable sret(%struct.DNvoxel) align 4 %20, <2 x float> %.sroa.081.4.vec.insert, float %134, <2 x float> %.fca.0.extract39, float %.fca.1.extract40, ptr noundef nonnull byval(%struct.DNvoxel) align 8 %1, <2 x float> %25, float %26, <2 x float> %27, float %28, ptr noundef nonnull byval(%union.QMmat4) align 16 %14, ptr noundef %9) #9
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(20) %19, ptr noundef nonnull align 4 dereferenceable(20) %20, i64 20, i1 false), !tbaa.struct !35
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %20) #9
  br label %168

167:                                              ; preds = %158
  store <2 x float> %.fca.0.extract39, ptr %95, align 4
  store float %.fca.1.extract40, ptr %.sroa.17.0..sroa_idx, align 4, !tbaa !6
  br label %168

168:                                              ; preds = %166, %167, %156
  call void @DN_set_voxel(ptr noundef %0, i64 %.sroa.0107.4.insert.insert, i32 %.0275, i64 %.sroa.085.4.insert.insert, i32 %.0226253, ptr noundef nonnull byval(%struct.DNvoxel) align 8 %19) #9
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %19) #9
  br label %186

169:                                              ; preds = %144
  %170 = load i8, ptr %1, align 8, !tbaa !9
  %171 = icmp eq i8 %170, -1
  %brmerge.not248 = and i1 %171, %2
  %172 = fcmp olt float %149, %92
  %or.cond245 = and i1 %172, %brmerge.not248
  %or.cond246.not = select i1 %or.cond245, i1 %132, i1 false
  br i1 %or.cond246.not, label %173, label %186

173:                                              ; preds = %169
  %174 = call zeroext i1 @DN_does_voxel_exist(ptr noundef %0, i64 %.sroa.0107.4.insert.insert, i32 %.0275, i64 %.sroa.085.4.insert.insert, i32 %.0226253) #9
  br i1 %174, label %175, label %186

175:                                              ; preds = %173
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %21) #9
  call void @DN_get_voxel(ptr dead_on_unwind nonnull writable sret(%struct.DNvoxel) align 4 %21, ptr noundef %0, i64 %.sroa.0107.4.insert.insert, i32 %.0275, i64 %.sroa.085.4.insert.insert, i32 %.0226253) #9
  %.sroa.066.0.vec.extract74 = extractelement <2 x float> %.fca.0.extract58, i64 0
  %176 = call float @llvm.fabs.f32(float %.sroa.066.0.vec.extract74)
  %.sroa.066.4.vec.extract77 = extractelement <2 x float> %.fca.0.extract58, i64 1
  %177 = call float @llvm.fabs.f32(float %.sroa.066.4.vec.extract77)
  %178 = call float @llvm.maxnum.f32(float %176, float %177)
  %179 = call float @llvm.fabs.f32(float %.fca.1.extract59)
  %180 = call float @llvm.maxnum.f32(float %178, float %179)
  %181 = fdiv float -1.000000e+00, %180
  %182 = call { <2 x float>, float } @DN_vec3_scale(<2 x float> %.fca.0.extract58, float %.fca.1.extract59, float noundef %181)
  %.fca.0.extract = extractvalue { <2 x float>, float } %182, 0
  %.fca.1.extract = extractvalue { <2 x float>, float } %182, 1
  br i1 %.not239, label %184, label %183

183:                                              ; preds = %175
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %22) #9
  call void %8(ptr dead_on_unwind nonnull writable sret(%struct.DNvoxel) align 4 %22, <2 x float> %.sroa.081.4.vec.insert, float %134, <2 x float> %.fca.0.extract, float %.fca.1.extract, ptr noundef nonnull byval(%struct.DNvoxel) align 8 %21, <2 x float> %25, float %26, <2 x float> %27, float %28, ptr noundef nonnull byval(%union.QMmat4) align 16 %14, ptr noundef %9) #9
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(20) %21, ptr noundef nonnull align 4 dereferenceable(20) %22, i64 20, i1 false), !tbaa.struct !35
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %22) #9
  br label %185

184:                                              ; preds = %175
  store <2 x float> %.fca.0.extract, ptr %94, align 4
  store float %.fca.1.extract, ptr %.sroa.17.0..sroa_idx78, align 4, !tbaa !6
  br label %185

185:                                              ; preds = %184, %183
  call void @DN_set_voxel(ptr noundef %0, i64 %.sroa.0107.4.insert.insert, i32 %.0275, i64 %.sroa.085.4.insert.insert, i32 %.0226253, ptr noundef nonnull byval(%struct.DNvoxel) align 8 %21) #9
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %21) #9
  br label %186

186:                                              ; preds = %168, %185, %169, %173, %152
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, 8
  br i1 %exitcond.not, label %143, label %144, !llvm.loop !36
}

; 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) #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: inlinehint nounwind uwtable
declare hidden void @DN_mat4_translate(ptr dead_on_unwind noalias writable sret(%union.QMmat4) align 16, <2 x float>, float) local_unnamed_addr #3

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @DN_mat4_mult(ptr dead_on_unwind noalias writable sret(%union.QMmat4) align 16, ptr noundef byval(%union.QMmat4) align 16, ptr noundef byval(%union.QMmat4) align 16) local_unnamed_addr #4

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @DN_quaternion_to_mat4(ptr dead_on_unwind noalias writable sret(%union.QMmat4) align 16, double, double) local_unnamed_addr #5

; Function Attrs: inlinehint nounwind uwtable
declare hidden void @DN_mat4_inv(ptr dead_on_unwind noalias writable sret(%union.QMmat4) align 16, ptr noundef byval(%union.QMmat4) align 16) local_unnamed_addr #4

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

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

declare void @DN_separate_position(i64, i32, ptr noundef, ptr noundef) local_unnamed_addr #7

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

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

declare zeroext i1 @DN_does_voxel_exist(ptr noundef, i64, i32, i64, i32) local_unnamed_addr #7

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

declare void @DN_set_voxel(ptr noundef, i64, i32, i64, i32, ptr noundef byval(%struct.DNvoxel) align 8) local_unnamed_addr #7

declare void @DN_get_voxel(ptr dead_on_unwind writable sret(%struct.DNvoxel) align 4, ptr noundef, i64, i32, i64, i32) local_unnamed_addr #7

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.smax.i32(i32, i32) #8

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

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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.umin.i32(i32, i32) #8

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <2 x i32> @llvm.umin.v2i32(<2 x i32>, <2 x i32>) #8

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{i64 0, i64 64, !6}
!6 = !{!7, !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !7, i64 0}
!10 = !{!"DNvoxel", !7, i64 0, !7, i64 4, !11, i64 16}
!11 = !{!"DNcolor", !7, i64 0, !7, i64 1, !7, i64 2}
!12 = !{!13, !14, i64 0}
!13 = !{!"DNivec3", !14, i64 0, !14, i64 4, !14, i64 8}
!14 = !{!"int", !7, i64 0}
!15 = !{!13, !14, i64 4}
!16 = !{!13, !14, i64 8}
!17 = !{!14, !14, i64 0}
!18 = !{!19, !14, i64 20}
!19 = !{!"DNvolume", !14, i64 0, !14, i64 4, !14, i64 8, !20, i64 12, !21, i64 24, !21, i64 32, !21, i64 40, !21, i64 48, !21, i64 56, !21, i64 64, !22, i64 72, !22, i64 80, !22, i64 88, !22, i64 96, !22, i64 104, !7, i64 112, !7, i64 124, !23, i64 136, !14, i64 140, !7, i64 144, !7, i64 156, !7, i64 168, !14, i64 180, !14, i64 184, !23, i64 188, !24, i64 192, !14, i64 196, !7, i64 200, !7, i64 212, !14, i64 224, !23, i64 228}
!20 = !{!"DNuvec3", !14, i64 0, !14, i64 4, !14, i64 8}
!21 = !{!"long", !7, i64 0}
!22 = !{!"any pointer", !7, i64 0}
!23 = !{!"float", !7, i64 0}
!24 = !{!"_Bool", !7, i64 0}
!25 = distinct !{!25, !26, !27}
!26 = !{!"llvm.loop.mustprogress"}
!27 = !{!"llvm.loop.unswitch.partial.disable"}
!28 = distinct !{!28, !26, !27}
!29 = !{!19, !22, i64 72}
!30 = !{!19, !14, i64 12}
!31 = !{!19, !14, i64 16}
!32 = distinct !{!32, !26}
!33 = distinct !{!33, !26}
!34 = distinct !{!34, !26}
!35 = !{i64 0, i64 1, !6, i64 4, i64 12, !6, i64 16, i64 1, !6, i64 17, i64 1, !6, i64 18, i64 1, !6}
!36 = distinct !{!36, !26}


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