; LLVM IR from unitreerobotics/kinect_teleoperate :: src/extern/glfw/src/tests (gamma)

; 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.nk_color = type { i8, i8, i8, i8 }
%struct.nk_colorf = type { float, float, float, float }
%struct.nk_vec2 = type { float, float }
%struct.nk_draw_list = type { %struct.nk_rect, [12 x %struct.nk_vec2], %struct.nk_convert_config, ptr, ptr, ptr, i32, i32, i32, i64, i32, i32, i32, i32 }
%struct.nk_rect = type { float, float, float, float }
%struct.nk_convert_config = type { float, i32, i32, i32, i32, i32, %struct.nk_draw_null_texture, ptr, i64, i64 }
%struct.nk_draw_null_texture = type { %union.nk_handle, %struct.nk_vec2 }
%union.nk_handle = type { ptr }
%struct.nk_buffer = type { [2 x %struct.nk_buffer_marker], %struct.nk_allocator, i32, %struct.nk_memory, float, i64, i64, i64, i64 }
%struct.nk_buffer_marker = type { i32, i64 }
%struct.nk_allocator = type { %union.nk_handle, ptr, ptr }
%struct.nk_memory = type { ptr, i64 }

@.str.2 = external hidden unnamed_addr constant [103 x i8], align 1
@.str.26 = external hidden unnamed_addr constant [5 x i8], align 1
@__PRETTY_FUNCTION__.nk_draw_list_stroke_poly_line = external hidden unnamed_addr constant [175 x i8], align 1

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

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

; 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: nounwind uwtable
declare dso_local <2 x float> @nk_vec2(float noundef, float noundef) #2

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

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

; Function Attrs: nounwind uwtable
declare dso_local void @nk_color_fv(ptr noundef, i32) #5

; Function Attrs: nounwind uwtable
declare hidden ptr @nk_buffer_alloc(ptr noundef, i32 noundef, i64 noundef, i64 noundef) #5

; Function Attrs: nounwind uwtable
declare dso_local void @nk_buffer_mark(ptr noundef, i32 noundef) #5

; Function Attrs: nounwind uwtable
declare dso_local void @nk_buffer_reset(ptr noundef, i32 noundef) #5

; Function Attrs: nounwind uwtable
define dso_local void @nk_draw_list_stroke_poly_line(ptr noundef %0, ptr noundef %1, i32 noundef %2, i32 %3, i32 noundef %4, float noundef %5, i32 noundef %6) #2 {
  %8 = alloca %struct.nk_color, align 1
  %9 = alloca ptr, align 8
  %10 = alloca ptr, align 8
  %11 = alloca i32, align 4
  %12 = alloca i32, align 4
  %13 = alloca float, align 4
  %14 = alloca i32, align 4
  %15 = alloca i64, align 8
  %16 = alloca i32, align 4
  %17 = alloca %struct.nk_colorf, align 4
  %18 = alloca %struct.nk_colorf, align 4
  %19 = alloca i32, align 4
  %20 = alloca float, align 4
  %21 = alloca i64, align 8
  %22 = alloca i64, align 8
  %23 = alloca i64, align 8
  %24 = alloca i64, align 8
  %25 = alloca i64, align 8
  %26 = alloca ptr, align 8
  %27 = alloca ptr, align 8
  %28 = alloca i64, align 8
  %29 = alloca ptr, align 8
  %30 = alloca ptr, align 8
  %31 = alloca i64, align 8
  %32 = alloca %struct.nk_vec2, align 4
  %33 = alloca float, align 4
  %34 = alloca %struct.nk_vec2, align 4
  %35 = alloca i64, align 8
  %36 = alloca i64, align 8
  %37 = alloca %struct.nk_vec2, align 4
  %38 = alloca %struct.nk_vec2, align 4
  %39 = alloca %struct.nk_vec2, align 4
  %40 = alloca %struct.nk_vec2, align 4
  %41 = alloca %struct.nk_vec2, align 4
  %42 = alloca %struct.nk_vec2, align 4
  %43 = alloca %struct.nk_vec2, align 4
  %44 = alloca %struct.nk_vec2, align 4
  %45 = alloca %struct.nk_vec2, align 4
  %46 = alloca %struct.nk_vec2, align 4
  %47 = alloca %struct.nk_vec2, align 4
  %48 = alloca float, align 4
  %49 = alloca i64, align 8
  %50 = alloca i64, align 8
  %51 = alloca %struct.nk_vec2, align 4
  %52 = alloca %struct.nk_vec2, align 4
  %53 = alloca %struct.nk_vec2, align 4
  %54 = alloca float, align 4
  %55 = alloca %struct.nk_vec2, align 4
  %56 = alloca %struct.nk_vec2, align 4
  %57 = alloca %struct.nk_vec2, align 4
  %58 = alloca %struct.nk_vec2, align 4
  %59 = alloca %struct.nk_vec2, align 4
  %60 = alloca i64, align 8
  %61 = alloca i64, align 8
  %62 = alloca float, align 4
  %63 = alloca %struct.nk_vec2, align 4
  %64 = alloca %struct.nk_vec2, align 4
  %65 = alloca %struct.nk_vec2, align 4
  %66 = alloca %struct.nk_vec2, align 4
  %67 = alloca %struct.nk_vec2, align 4
  %68 = alloca %struct.nk_vec2, align 4
  %69 = alloca %struct.nk_vec2, align 4
  %70 = alloca %struct.nk_vec2, align 4
  %71 = alloca %struct.nk_vec2, align 4
  %72 = alloca %struct.nk_vec2, align 4
  %73 = alloca %struct.nk_vec2, align 4
  %74 = alloca %struct.nk_vec2, align 4
  %75 = alloca %struct.nk_vec2, align 4
  %76 = alloca %struct.nk_vec2, align 4
  %77 = alloca i64, align 8
  %78 = alloca i64, align 8
  %79 = alloca %struct.nk_vec2, align 4
  %80 = alloca %struct.nk_vec2, align 4
  %81 = alloca %struct.nk_vec2, align 4
  %82 = alloca float, align 4
  %83 = alloca float, align 4
  %84 = alloca %struct.nk_vec2, align 4
  %85 = alloca %struct.nk_vec2, align 4
  %86 = alloca %struct.nk_vec2, align 4
  %87 = alloca %struct.nk_vec2, align 4
  %88 = alloca %struct.nk_vec2, align 4
  %89 = alloca %struct.nk_vec2, align 4
  %90 = alloca %struct.nk_vec2, align 4
  %91 = alloca %struct.nk_vec2, align 4
  %92 = alloca i64, align 8
  %93 = alloca i64, align 8
  %94 = alloca i64, align 8
  %95 = alloca i64, align 8
  %96 = alloca ptr, align 8
  %97 = alloca ptr, align 8
  %98 = alloca float, align 4
  %99 = alloca float, align 4
  %100 = alloca %struct.nk_vec2, align 4
  %101 = alloca i64, align 8
  %102 = alloca %struct.nk_vec2, align 4
  %103 = alloca %struct.nk_vec2, align 4
  %104 = alloca %struct.nk_vec2, align 4
  %105 = alloca float, align 4
  %106 = alloca %struct.nk_vec2, align 4
  %107 = alloca %struct.nk_vec2, align 4
  %108 = alloca %struct.nk_vec2, align 4
  %109 = alloca %struct.nk_vec2, align 4
  %110 = alloca %struct.nk_vec2, align 4
  store i32 %3, ptr %8, align 1
  store ptr %0, ptr %9, align 8, !tbaa !5
  store ptr %1, ptr %10, align 8, !tbaa !5
  store i32 %2, ptr %11, align 4, !tbaa !9
  store i32 %4, ptr %12, align 4, !tbaa !9
  store float %5, ptr %13, align 4, !tbaa !11
  store i32 %6, ptr %14, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %17) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %18) #6
  %111 = load ptr, ptr %9, align 8, !tbaa !5
  %112 = icmp ne ptr %111, null
  br i1 %112, label %113, label %114

113:                                              ; preds = %7
  br label %115

114:                                              ; preds = %7
  call void @__assert_fail(ptr noundef @.str.26, ptr noundef @.str.2, i32 noundef 9632, ptr noundef @__PRETTY_FUNCTION__.nk_draw_list_stroke_poly_line) #7
  unreachable

115:                                              ; preds = %113
  %116 = load ptr, ptr %9, align 8, !tbaa !5
  %117 = icmp ne ptr %116, null
  br i1 %117, label %118, label %121

118:                                              ; preds = %115
  %119 = load i32, ptr %11, align 4, !tbaa !9
  %120 = icmp ult i32 %119, 2
  br i1 %120, label %121, label %122

121:                                              ; preds = %118, %115
  store i32 1, ptr %19, align 4
  br label %1654

122:                                              ; preds = %118
  %123 = getelementptr inbounds %struct.nk_color, ptr %8, i32 0, i32 3
  %124 = load i8, ptr %123, align 1, !tbaa !13
  %125 = uitofp i8 %124 to float
  %126 = load ptr, ptr %9, align 8, !tbaa !5
  %127 = getelementptr inbounds %struct.nk_draw_list, ptr %126, i32 0, i32 2
  %128 = getelementptr inbounds %struct.nk_convert_config, ptr %127, i32 0, i32 0
  %129 = load float, ptr %128, align 8, !tbaa !15
  %130 = fmul float %125, %129
  %131 = fptoui float %130 to i8
  %132 = getelementptr inbounds %struct.nk_color, ptr %8, i32 0, i32 3
  store i8 %131, ptr %132, align 1, !tbaa !13
  %133 = load i32, ptr %11, align 4, !tbaa !9
  %134 = zext i32 %133 to i64
  store i64 %134, ptr %15, align 8, !tbaa !22
  %135 = load i32, ptr %12, align 4, !tbaa !9
  %136 = icmp ne i32 %135, 0
  br i1 %136, label %141, label %137

137:                                              ; preds = %122
  %138 = load i32, ptr %11, align 4, !tbaa !9
  %139 = sub i32 %138, 1
  %140 = zext i32 %139 to i64
  store i64 %140, ptr %15, align 8, !tbaa !22
  br label %141

141:                                              ; preds = %137, %122
  %142 = load float, ptr %13, align 4, !tbaa !11
  %143 = fcmp ogt float %142, 1.000000e+00
  %144 = zext i1 %143 to i32
  store i32 %144, ptr %16, align 4, !tbaa !9
  %145 = getelementptr inbounds %struct.nk_color, ptr %8, i32 0, i32 3
  %146 = load i8, ptr %145, align 1, !tbaa !13
  %147 = uitofp i8 %146 to float
  %148 = load ptr, ptr %9, align 8, !tbaa !5
  %149 = getelementptr inbounds %struct.nk_draw_list, ptr %148, i32 0, i32 2
  %150 = getelementptr inbounds %struct.nk_convert_config, ptr %149, i32 0, i32 0
  %151 = load float, ptr %150, align 8, !tbaa !15
  %152 = fmul float %147, %151
  %153 = fptoui float %152 to i8
  %154 = getelementptr inbounds %struct.nk_color, ptr %8, i32 0, i32 3
  store i8 %153, ptr %154, align 1, !tbaa !13
  %155 = getelementptr inbounds %struct.nk_colorf, ptr %17, i32 0, i32 0
  %156 = load i32, ptr %8, align 1
  call void @nk_color_fv(ptr noundef %155, i32 %156)
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %18, ptr align 4 %17, i64 16, i1 false), !tbaa.struct !23
  %157 = getelementptr inbounds %struct.nk_colorf, ptr %18, i32 0, i32 3
  store float 0.000000e+00, ptr %157, align 4, !tbaa !24
  %158 = load i32, ptr %14, align 4, !tbaa !9
  %159 = icmp eq i32 %158, 1
  br i1 %159, label %160, label %1441

160:                                              ; preds = %141
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #6
  store float 1.000000e+00, ptr %20, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #6
  store i64 0, ptr %21, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #6
  %161 = load ptr, ptr %9, align 8, !tbaa !5
  %162 = getelementptr inbounds %struct.nk_draw_list, ptr %161, i32 0, i32 7
  %163 = load i32, ptr %162, align 4, !tbaa !26
  %164 = zext i32 %163 to i64
  store i64 %164, ptr %23, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #6
  %165 = load i32, ptr %16, align 4, !tbaa !9
  %166 = icmp ne i32 %165, 0
  br i1 %166, label %167, label %170

167:                                              ; preds = %160
  %168 = load i64, ptr %15, align 8, !tbaa !22
  %169 = mul i64 %168, 18
  br label %173

170:                                              ; preds = %160
  %171 = load i64, ptr %15, align 8, !tbaa !22
  %172 = mul i64 %171, 12
  br label %173

173:                                              ; preds = %170, %167
  %174 = phi i64 [ %169, %167 ], [ %172, %170 ]
  store i64 %174, ptr %24, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #6
  %175 = load i32, ptr %16, align 4, !tbaa !9
  %176 = icmp ne i32 %175, 0
  br i1 %176, label %177, label %180

177:                                              ; preds = %173
  %178 = load i32, ptr %11, align 4, !tbaa !9
  %179 = mul i32 %178, 4
  br label %183

180:                                              ; preds = %173
  %181 = load i32, ptr %11, align 4, !tbaa !9
  %182 = mul i32 %181, 3
  br label %183

183:                                              ; preds = %180, %177
  %184 = phi i32 [ %179, %177 ], [ %182, %180 ]
  %185 = zext i32 %184 to i64
  store i64 %185, ptr %25, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #6
  %186 = load ptr, ptr %9, align 8, !tbaa !5
  %187 = load i64, ptr %25, align 8, !tbaa !22
  %188 = call ptr @nk_draw_list_alloc_vertices(ptr noundef %186, i64 noundef %187)
  store ptr %188, ptr %26, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #6
  %189 = load ptr, ptr %9, align 8, !tbaa !5
  %190 = load i64, ptr %24, align 8, !tbaa !22
  %191 = call ptr @nk_draw_list_alloc_elements(ptr noundef %189, i64 noundef %190)
  store ptr %191, ptr %27, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #6
  %192 = load ptr, ptr %26, align 8, !tbaa !5
  %193 = icmp ne ptr %192, null
  br i1 %193, label %194, label %197

194:                                              ; preds = %183
  %195 = load ptr, ptr %27, align 8, !tbaa !5
  %196 = icmp ne ptr %195, null
  br i1 %196, label %198, label %197

197:                                              ; preds = %194, %183
  store i32 1, ptr %19, align 4
  br label %1438

198:                                              ; preds = %194
  %199 = load ptr, ptr %26, align 8, !tbaa !5
  %200 = load ptr, ptr %9, align 8, !tbaa !5
  %201 = getelementptr inbounds %struct.nk_draw_list, ptr %200, i32 0, i32 4
  %202 = load ptr, ptr %201, align 8, !tbaa !27
  %203 = getelementptr inbounds %struct.nk_buffer, ptr %202, i32 0, i32 3
  %204 = getelementptr inbounds %struct.nk_memory, ptr %203, i32 0, i32 0
  %205 = load ptr, ptr %204, align 8, !tbaa !28
  %206 = ptrtoint ptr %199 to i64
  %207 = ptrtoint ptr %205 to i64
  %208 = sub i64 %206, %207
  store i64 %208, ptr %22, align 8, !tbaa !22
  %209 = load ptr, ptr %9, align 8, !tbaa !5
  %210 = getelementptr inbounds %struct.nk_draw_list, ptr %209, i32 0, i32 4
  %211 = load ptr, ptr %210, align 8, !tbaa !27
  call void @nk_buffer_mark(ptr noundef %211, i32 noundef 0)
  %212 = load i32, ptr %16, align 4, !tbaa !9
  %213 = icmp ne i32 %212, 0
  %214 = zext i1 %213 to i64
  %215 = select i1 %213, i32 5, i32 3
  %216 = sext i32 %215 to i64
  %217 = mul i64 8, %216
  %218 = load i32, ptr %11, align 4, !tbaa !9
  %219 = zext i32 %218 to i64
  %220 = mul i64 %217, %219
  store i64 %220, ptr %28, align 8, !tbaa !22
  %221 = load ptr, ptr %9, align 8, !tbaa !5
  %222 = getelementptr inbounds %struct.nk_draw_list, ptr %221, i32 0, i32 4
  %223 = load ptr, ptr %222, align 8, !tbaa !27
  %224 = load i64, ptr %28, align 8, !tbaa !22
  %225 = call ptr @nk_buffer_alloc(ptr noundef %223, i32 noundef 0, i64 noundef %224, i64 noundef 4)
  store ptr %225, ptr %29, align 8, !tbaa !5
  %226 = load ptr, ptr %29, align 8, !tbaa !5
  %227 = icmp ne ptr %226, null
  br i1 %227, label %229, label %228

228:                                              ; preds = %198
  store i32 1, ptr %19, align 4
  br label %1438

229:                                              ; preds = %198
  %230 = load ptr, ptr %29, align 8, !tbaa !5
  %231 = load i32, ptr %11, align 4, !tbaa !9
  %232 = zext i32 %231 to i64
  %233 = getelementptr inbounds %struct.nk_vec2, ptr %230, i64 %232
  store ptr %233, ptr %30, align 8, !tbaa !5
  %234 = load ptr, ptr %9, align 8, !tbaa !5
  %235 = getelementptr inbounds %struct.nk_draw_list, ptr %234, i32 0, i32 4
  %236 = load ptr, ptr %235, align 8, !tbaa !27
  %237 = getelementptr inbounds %struct.nk_buffer, ptr %236, i32 0, i32 3
  %238 = getelementptr inbounds %struct.nk_memory, ptr %237, i32 0, i32 0
  %239 = load ptr, ptr %238, align 8, !tbaa !28
  %240 = load i64, ptr %22, align 8, !tbaa !22
  %241 = getelementptr inbounds i8, ptr %239, i64 %240
  store ptr %241, ptr %26, align 8, !tbaa !5
  store i64 0, ptr %21, align 8, !tbaa !22
  br label %242

242:                                              ; preds = %320, %229
  %243 = load i64, ptr %21, align 8, !tbaa !22
  %244 = load i64, ptr %15, align 8, !tbaa !22
  %245 = icmp ult i64 %243, %244
  br i1 %245, label %246, label %323

246:                                              ; preds = %242
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #6
  %247 = load i64, ptr %21, align 8, !tbaa !22
  %248 = add i64 %247, 1
  %249 = load i32, ptr %11, align 4, !tbaa !9
  %250 = zext i32 %249 to i64
  %251 = icmp eq i64 %248, %250
  br i1 %251, label %252, label %253

252:                                              ; preds = %246
  br label %256

253:                                              ; preds = %246
  %254 = load i64, ptr %21, align 8, !tbaa !22
  %255 = add i64 %254, 1
  br label %256

256:                                              ; preds = %253, %252
  %257 = phi i64 [ 0, %252 ], [ %255, %253 ]
  store i64 %257, ptr %31, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #6
  %258 = load ptr, ptr %10, align 8, !tbaa !5
  %259 = load i64, ptr %31, align 8, !tbaa !22
  %260 = getelementptr inbounds %struct.nk_vec2, ptr %258, i64 %259
  %261 = getelementptr inbounds %struct.nk_vec2, ptr %260, i32 0, i32 0
  %262 = load float, ptr %261, align 4, !tbaa !32
  %263 = load ptr, ptr %10, align 8, !tbaa !5
  %264 = load i64, ptr %21, align 8, !tbaa !22
  %265 = getelementptr inbounds %struct.nk_vec2, ptr %263, i64 %264
  %266 = getelementptr inbounds %struct.nk_vec2, ptr %265, i32 0, i32 0
  %267 = load float, ptr %266, align 4, !tbaa !32
  %268 = fsub float %262, %267
  %269 = load ptr, ptr %10, align 8, !tbaa !5
  %270 = load i64, ptr %31, align 8, !tbaa !22
  %271 = getelementptr inbounds %struct.nk_vec2, ptr %269, i64 %270
  %272 = getelementptr inbounds %struct.nk_vec2, ptr %271, i32 0, i32 1
  %273 = load float, ptr %272, align 4, !tbaa !33
  %274 = load ptr, ptr %10, align 8, !tbaa !5
  %275 = load i64, ptr %21, align 8, !tbaa !22
  %276 = getelementptr inbounds %struct.nk_vec2, ptr %274, i64 %275
  %277 = getelementptr inbounds %struct.nk_vec2, ptr %276, i32 0, i32 1
  %278 = load float, ptr %277, align 4, !tbaa !33
  %279 = fsub float %273, %278
  %280 = call <2 x float> @nk_vec2(float noundef %268, float noundef %279)
  store <2 x float> %280, ptr %32, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #6
  %281 = getelementptr inbounds %struct.nk_vec2, ptr %32, i32 0, i32 0
  %282 = load float, ptr %281, align 4, !tbaa !32
  %283 = getelementptr inbounds %struct.nk_vec2, ptr %32, i32 0, i32 0
  %284 = load float, ptr %283, align 4, !tbaa !32
  %285 = getelementptr inbounds %struct.nk_vec2, ptr %32, i32 0, i32 1
  %286 = load float, ptr %285, align 4, !tbaa !33
  %287 = getelementptr inbounds %struct.nk_vec2, ptr %32, i32 0, i32 1
  %288 = load float, ptr %287, align 4, !tbaa !33
  %289 = fmul float %286, %288
  %290 = call float @llvm.fmuladd.f32(float %282, float %284, float %289)
  store float %290, ptr %33, align 4, !tbaa !11
  %291 = load float, ptr %33, align 4, !tbaa !11
  %292 = fcmp une float %291, 0.000000e+00
  br i1 %292, label %293, label %296

293:                                              ; preds = %256
  %294 = load float, ptr %33, align 4, !tbaa !11
  %295 = call float @nk_inv_sqrt(float noundef %294)
  store float %295, ptr %33, align 4, !tbaa !11
  br label %297

296:                                              ; preds = %256
  store float 1.000000e+00, ptr %33, align 4, !tbaa !11
  br label %297

297:                                              ; preds = %296, %293
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #6
  %298 = getelementptr inbounds %struct.nk_vec2, ptr %32, i32 0, i32 0
  %299 = load float, ptr %298, align 4, !tbaa !32
  %300 = load float, ptr %33, align 4, !tbaa !11
  %301 = fmul float %299, %300
  %302 = getelementptr inbounds %struct.nk_vec2, ptr %32, i32 0, i32 1
  %303 = load float, ptr %302, align 4, !tbaa !33
  %304 = load float, ptr %33, align 4, !tbaa !11
  %305 = fmul float %303, %304
  %306 = call <2 x float> @nk_vec2(float noundef %301, float noundef %305)
  store <2 x float> %306, ptr %34, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %32, ptr align 4 %34, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #6
  %307 = getelementptr inbounds %struct.nk_vec2, ptr %32, i32 0, i32 1
  %308 = load float, ptr %307, align 4, !tbaa !33
  %309 = load ptr, ptr %29, align 8, !tbaa !5
  %310 = load i64, ptr %21, align 8, !tbaa !22
  %311 = getelementptr inbounds %struct.nk_vec2, ptr %309, i64 %310
  %312 = getelementptr inbounds %struct.nk_vec2, ptr %311, i32 0, i32 0
  store float %308, ptr %312, align 4, !tbaa !32
  %313 = getelementptr inbounds %struct.nk_vec2, ptr %32, i32 0, i32 0
  %314 = load float, ptr %313, align 4, !tbaa !32
  %315 = fneg float %314
  %316 = load ptr, ptr %29, align 8, !tbaa !5
  %317 = load i64, ptr %21, align 8, !tbaa !22
  %318 = getelementptr inbounds %struct.nk_vec2, ptr %316, i64 %317
  %319 = getelementptr inbounds %struct.nk_vec2, ptr %318, i32 0, i32 1
  store float %315, ptr %319, align 4, !tbaa !33
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #6
  br label %320

320:                                              ; preds = %297
  %321 = load i64, ptr %21, align 8, !tbaa !22
  %322 = add i64 %321, 1
  store i64 %322, ptr %21, align 8, !tbaa !22
  br label %242, !llvm.loop !35

323:                                              ; preds = %242
  %324 = load i32, ptr %12, align 4, !tbaa !9
  %325 = icmp ne i32 %324, 0
  br i1 %325, label %337, label %326

326:                                              ; preds = %323
  %327 = load ptr, ptr %29, align 8, !tbaa !5
  %328 = load i32, ptr %11, align 4, !tbaa !9
  %329 = sub i32 %328, 1
  %330 = zext i32 %329 to i64
  %331 = getelementptr inbounds %struct.nk_vec2, ptr %327, i64 %330
  %332 = load ptr, ptr %29, align 8, !tbaa !5
  %333 = load i32, ptr %11, align 4, !tbaa !9
  %334 = sub i32 %333, 2
  %335 = zext i32 %334 to i64
  %336 = getelementptr inbounds %struct.nk_vec2, ptr %332, i64 %335
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %331, ptr align 4 %336, i64 8, i1 false), !tbaa.struct !34
  br label %337

337:                                              ; preds = %326, %323
  %338 = load i32, ptr %16, align 4, !tbaa !9
  %339 = icmp ne i32 %338, 0
  br i1 %339, label %785, label %340

340:                                              ; preds = %337
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %36) #6
  %341 = load i32, ptr %12, align 4, !tbaa !9
  %342 = icmp ne i32 %341, 0
  br i1 %342, label %495, label %343

343:                                              ; preds = %340
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #6
  %344 = load ptr, ptr %30, align 8, !tbaa !5
  %345 = getelementptr inbounds %struct.nk_vec2, ptr %344, i64 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #6
  %346 = load ptr, ptr %10, align 8, !tbaa !5
  %347 = getelementptr inbounds %struct.nk_vec2, ptr %346, i64 0
  %348 = getelementptr inbounds %struct.nk_vec2, ptr %347, i32 0, i32 0
  %349 = load float, ptr %348, align 4, !tbaa !32
  %350 = load ptr, ptr %29, align 8, !tbaa !5
  %351 = getelementptr inbounds %struct.nk_vec2, ptr %350, i64 0
  %352 = getelementptr inbounds %struct.nk_vec2, ptr %351, i32 0, i32 0
  %353 = load float, ptr %352, align 4, !tbaa !32
  %354 = fmul float %353, 1.000000e+00
  %355 = load ptr, ptr %29, align 8, !tbaa !5
  %356 = getelementptr inbounds %struct.nk_vec2, ptr %355, i64 0
  %357 = getelementptr inbounds %struct.nk_vec2, ptr %356, i32 0, i32 1
  %358 = load float, ptr %357, align 4, !tbaa !33
  %359 = fmul float %358, 1.000000e+00
  %360 = call <2 x float> @nk_vec2(float noundef %354, float noundef %359)
  store <2 x float> %360, ptr %39, align 4
  %361 = getelementptr inbounds %struct.nk_vec2, ptr %39, i32 0, i32 0
  %362 = load float, ptr %361, align 4, !tbaa !32
  %363 = fadd float %349, %362
  %364 = load ptr, ptr %10, align 8, !tbaa !5
  %365 = getelementptr inbounds %struct.nk_vec2, ptr %364, i64 0
  %366 = getelementptr inbounds %struct.nk_vec2, ptr %365, i32 0, i32 1
  %367 = load float, ptr %366, align 4, !tbaa !33
  %368 = load ptr, ptr %29, align 8, !tbaa !5
  %369 = getelementptr inbounds %struct.nk_vec2, ptr %368, i64 0
  %370 = getelementptr inbounds %struct.nk_vec2, ptr %369, i32 0, i32 0
  %371 = load float, ptr %370, align 4, !tbaa !32
  %372 = fmul float %371, 1.000000e+00
  %373 = load ptr, ptr %29, align 8, !tbaa !5
  %374 = getelementptr inbounds %struct.nk_vec2, ptr %373, i64 0
  %375 = getelementptr inbounds %struct.nk_vec2, ptr %374, i32 0, i32 1
  %376 = load float, ptr %375, align 4, !tbaa !33
  %377 = fmul float %376, 1.000000e+00
  %378 = call <2 x float> @nk_vec2(float noundef %372, float noundef %377)
  store <2 x float> %378, ptr %40, align 4
  %379 = getelementptr inbounds %struct.nk_vec2, ptr %40, i32 0, i32 1
  %380 = load float, ptr %379, align 4, !tbaa !33
  %381 = fadd float %367, %380
  %382 = call <2 x float> @nk_vec2(float noundef %363, float noundef %381)
  store <2 x float> %382, ptr %38, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %345, ptr align 4 %38, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #6
  %383 = load ptr, ptr %30, align 8, !tbaa !5
  %384 = getelementptr inbounds %struct.nk_vec2, ptr %383, i64 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %41) #6
  %385 = load ptr, ptr %10, align 8, !tbaa !5
  %386 = getelementptr inbounds %struct.nk_vec2, ptr %385, i64 0
  %387 = getelementptr inbounds %struct.nk_vec2, ptr %386, i32 0, i32 0
  %388 = load float, ptr %387, align 4, !tbaa !32
  %389 = load ptr, ptr %29, align 8, !tbaa !5
  %390 = getelementptr inbounds %struct.nk_vec2, ptr %389, i64 0
  %391 = getelementptr inbounds %struct.nk_vec2, ptr %390, i32 0, i32 0
  %392 = load float, ptr %391, align 4, !tbaa !32
  %393 = fmul float %392, 1.000000e+00
  %394 = load ptr, ptr %29, align 8, !tbaa !5
  %395 = getelementptr inbounds %struct.nk_vec2, ptr %394, i64 0
  %396 = getelementptr inbounds %struct.nk_vec2, ptr %395, i32 0, i32 1
  %397 = load float, ptr %396, align 4, !tbaa !33
  %398 = fmul float %397, 1.000000e+00
  %399 = call <2 x float> @nk_vec2(float noundef %393, float noundef %398)
  store <2 x float> %399, ptr %42, align 4
  %400 = getelementptr inbounds %struct.nk_vec2, ptr %42, i32 0, i32 0
  %401 = load float, ptr %400, align 4, !tbaa !32
  %402 = fsub float %388, %401
  %403 = load ptr, ptr %10, align 8, !tbaa !5
  %404 = getelementptr inbounds %struct.nk_vec2, ptr %403, i64 0
  %405 = getelementptr inbounds %struct.nk_vec2, ptr %404, i32 0, i32 1
  %406 = load float, ptr %405, align 4, !tbaa !33
  %407 = load ptr, ptr %29, align 8, !tbaa !5
  %408 = getelementptr inbounds %struct.nk_vec2, ptr %407, i64 0
  %409 = getelementptr inbounds %struct.nk_vec2, ptr %408, i32 0, i32 0
  %410 = load float, ptr %409, align 4, !tbaa !32
  %411 = fmul float %410, 1.000000e+00
  %412 = load ptr, ptr %29, align 8, !tbaa !5
  %413 = getelementptr inbounds %struct.nk_vec2, ptr %412, i64 0
  %414 = getelementptr inbounds %struct.nk_vec2, ptr %413, i32 0, i32 1
  %415 = load float, ptr %414, align 4, !tbaa !33
  %416 = fmul float %415, 1.000000e+00
  %417 = call <2 x float> @nk_vec2(float noundef %411, float noundef %416)
  store <2 x float> %417, ptr %43, align 4
  %418 = getelementptr inbounds %struct.nk_vec2, ptr %43, i32 0, i32 1
  %419 = load float, ptr %418, align 4, !tbaa !33
  %420 = fsub float %406, %419
  %421 = call <2 x float> @nk_vec2(float noundef %402, float noundef %420)
  store <2 x float> %421, ptr %41, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %384, ptr align 4 %41, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #6
  %422 = load ptr, ptr %29, align 8, !tbaa !5
  %423 = load i32, ptr %11, align 4, !tbaa !9
  %424 = sub i32 %423, 1
  %425 = zext i32 %424 to i64
  %426 = getelementptr inbounds %struct.nk_vec2, ptr %422, i64 %425
  %427 = getelementptr inbounds %struct.nk_vec2, ptr %426, i32 0, i32 0
  %428 = load float, ptr %427, align 4, !tbaa !32
  %429 = fmul float %428, 1.000000e+00
  %430 = load ptr, ptr %29, align 8, !tbaa !5
  %431 = load i32, ptr %11, align 4, !tbaa !9
  %432 = sub i32 %431, 1
  %433 = zext i32 %432 to i64
  %434 = getelementptr inbounds %struct.nk_vec2, ptr %430, i64 %433
  %435 = getelementptr inbounds %struct.nk_vec2, ptr %434, i32 0, i32 1
  %436 = load float, ptr %435, align 4, !tbaa !33
  %437 = fmul float %436, 1.000000e+00
  %438 = call <2 x float> @nk_vec2(float noundef %429, float noundef %437)
  store <2 x float> %438, ptr %44, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %37, ptr align 4 %44, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #6
  %439 = load ptr, ptr %30, align 8, !tbaa !5
  %440 = load i32, ptr %11, align 4, !tbaa !9
  %441 = sub i32 %440, 1
  %442 = mul i32 %441, 2
  %443 = add i32 %442, 0
  %444 = zext i32 %443 to i64
  %445 = getelementptr inbounds %struct.nk_vec2, ptr %439, i64 %444
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #6
  %446 = load ptr, ptr %10, align 8, !tbaa !5
  %447 = load i32, ptr %11, align 4, !tbaa !9
  %448 = sub i32 %447, 1
  %449 = zext i32 %448 to i64
  %450 = getelementptr inbounds %struct.nk_vec2, ptr %446, i64 %449
  %451 = getelementptr inbounds %struct.nk_vec2, ptr %450, i32 0, i32 0
  %452 = load float, ptr %451, align 4, !tbaa !32
  %453 = getelementptr inbounds %struct.nk_vec2, ptr %37, i32 0, i32 0
  %454 = load float, ptr %453, align 4, !tbaa !32
  %455 = fadd float %452, %454
  %456 = load ptr, ptr %10, align 8, !tbaa !5
  %457 = load i32, ptr %11, align 4, !tbaa !9
  %458 = sub i32 %457, 1
  %459 = zext i32 %458 to i64
  %460 = getelementptr inbounds %struct.nk_vec2, ptr %456, i64 %459
  %461 = getelementptr inbounds %struct.nk_vec2, ptr %460, i32 0, i32 1
  %462 = load float, ptr %461, align 4, !tbaa !33
  %463 = getelementptr inbounds %struct.nk_vec2, ptr %37, i32 0, i32 1
  %464 = load float, ptr %463, align 4, !tbaa !33
  %465 = fadd float %462, %464
  %466 = call <2 x float> @nk_vec2(float noundef %455, float noundef %465)
  store <2 x float> %466, ptr %45, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %445, ptr align 4 %45, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #6
  %467 = load ptr, ptr %30, align 8, !tbaa !5
  %468 = load i32, ptr %11, align 4, !tbaa !9
  %469 = sub i32 %468, 1
  %470 = mul i32 %469, 2
  %471 = add i32 %470, 1
  %472 = zext i32 %471 to i64
  %473 = getelementptr inbounds %struct.nk_vec2, ptr %467, i64 %472
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #6
  %474 = load ptr, ptr %10, align 8, !tbaa !5
  %475 = load i32, ptr %11, align 4, !tbaa !9
  %476 = sub i32 %475, 1
  %477 = zext i32 %476 to i64
  %478 = getelementptr inbounds %struct.nk_vec2, ptr %474, i64 %477
  %479 = getelementptr inbounds %struct.nk_vec2, ptr %478, i32 0, i32 0
  %480 = load float, ptr %479, align 4, !tbaa !32
  %481 = getelementptr inbounds %struct.nk_vec2, ptr %37, i32 0, i32 0
  %482 = load float, ptr %481, align 4, !tbaa !32
  %483 = fsub float %480, %482
  %484 = load ptr, ptr %10, align 8, !tbaa !5
  %485 = load i32, ptr %11, align 4, !tbaa !9
  %486 = sub i32 %485, 1
  %487 = zext i32 %486 to i64
  %488 = getelementptr inbounds %struct.nk_vec2, ptr %484, i64 %487
  %489 = getelementptr inbounds %struct.nk_vec2, ptr %488, i32 0, i32 1
  %490 = load float, ptr %489, align 4, !tbaa !33
  %491 = getelementptr inbounds %struct.nk_vec2, ptr %37, i32 0, i32 1
  %492 = load float, ptr %491, align 4, !tbaa !33
  %493 = fsub float %490, %492
  %494 = call <2 x float> @nk_vec2(float noundef %483, float noundef %493)
  store <2 x float> %494, ptr %46, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %473, ptr align 4 %46, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #6
  br label %495

495:                                              ; preds = %343, %340
  %496 = load i64, ptr %23, align 8, !tbaa !22
  store i64 %496, ptr %35, align 8, !tbaa !22
  store i64 0, ptr %21, align 8, !tbaa !22
  br label %497

497:                                              ; preds = %724, %495
  %498 = load i64, ptr %21, align 8, !tbaa !22
  %499 = load i64, ptr %15, align 8, !tbaa !22
  %500 = icmp ult i64 %498, %499
  br i1 %500, label %501, label %727

501:                                              ; preds = %497
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %48) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %49) #6
  %502 = load i64, ptr %21, align 8, !tbaa !22
  %503 = add i64 %502, 1
  %504 = load i32, ptr %11, align 4, !tbaa !9
  %505 = zext i32 %504 to i64
  %506 = icmp eq i64 %503, %505
  br i1 %506, label %507, label %508

507:                                              ; preds = %501
  br label %511

508:                                              ; preds = %501
  %509 = load i64, ptr %21, align 8, !tbaa !22
  %510 = add i64 %509, 1
  br label %511

511:                                              ; preds = %508, %507
  %512 = phi i64 [ 0, %507 ], [ %510, %508 ]
  store i64 %512, ptr %49, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %50) #6
  %513 = load i64, ptr %21, align 8, !tbaa !22
  %514 = add i64 %513, 1
  %515 = load i32, ptr %11, align 4, !tbaa !9
  %516 = zext i32 %515 to i64
  %517 = icmp eq i64 %514, %516
  br i1 %517, label %518, label %520

518:                                              ; preds = %511
  %519 = load i64, ptr %23, align 8, !tbaa !22
  br label %523

520:                                              ; preds = %511
  %521 = load i64, ptr %35, align 8, !tbaa !22
  %522 = add i64 %521, 3
  br label %523

523:                                              ; preds = %520, %518
  %524 = phi i64 [ %519, %518 ], [ %522, %520 ]
  store i64 %524, ptr %50, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %51) #6
  %525 = load ptr, ptr %29, align 8, !tbaa !5
  %526 = load i64, ptr %21, align 8, !tbaa !22
  %527 = getelementptr inbounds %struct.nk_vec2, ptr %525, i64 %526
  %528 = getelementptr inbounds %struct.nk_vec2, ptr %527, i32 0, i32 0
  %529 = load float, ptr %528, align 4, !tbaa !32
  %530 = load ptr, ptr %29, align 8, !tbaa !5
  %531 = load i64, ptr %49, align 8, !tbaa !22
  %532 = getelementptr inbounds %struct.nk_vec2, ptr %530, i64 %531
  %533 = getelementptr inbounds %struct.nk_vec2, ptr %532, i32 0, i32 0
  %534 = load float, ptr %533, align 4, !tbaa !32
  %535 = fadd float %529, %534
  %536 = load ptr, ptr %29, align 8, !tbaa !5
  %537 = load i64, ptr %21, align 8, !tbaa !22
  %538 = getelementptr inbounds %struct.nk_vec2, ptr %536, i64 %537
  %539 = getelementptr inbounds %struct.nk_vec2, ptr %538, i32 0, i32 1
  %540 = load float, ptr %539, align 4, !tbaa !33
  %541 = load ptr, ptr %29, align 8, !tbaa !5
  %542 = load i64, ptr %49, align 8, !tbaa !22
  %543 = getelementptr inbounds %struct.nk_vec2, ptr %541, i64 %542
  %544 = getelementptr inbounds %struct.nk_vec2, ptr %543, i32 0, i32 1
  %545 = load float, ptr %544, align 4, !tbaa !33
  %546 = fadd float %540, %545
  %547 = call <2 x float> @nk_vec2(float noundef %535, float noundef %546)
  store <2 x float> %547, ptr %52, align 4
  %548 = getelementptr inbounds %struct.nk_vec2, ptr %52, i32 0, i32 0
  %549 = load float, ptr %548, align 4, !tbaa !32
  %550 = fmul float %549, 5.000000e-01
  %551 = load ptr, ptr %29, align 8, !tbaa !5
  %552 = load i64, ptr %21, align 8, !tbaa !22
  %553 = getelementptr inbounds %struct.nk_vec2, ptr %551, i64 %552
  %554 = getelementptr inbounds %struct.nk_vec2, ptr %553, i32 0, i32 0
  %555 = load float, ptr %554, align 4, !tbaa !32
  %556 = load ptr, ptr %29, align 8, !tbaa !5
  %557 = load i64, ptr %49, align 8, !tbaa !22
  %558 = getelementptr inbounds %struct.nk_vec2, ptr %556, i64 %557
  %559 = getelementptr inbounds %struct.nk_vec2, ptr %558, i32 0, i32 0
  %560 = load float, ptr %559, align 4, !tbaa !32
  %561 = fadd float %555, %560
  %562 = load ptr, ptr %29, align 8, !tbaa !5
  %563 = load i64, ptr %21, align 8, !tbaa !22
  %564 = getelementptr inbounds %struct.nk_vec2, ptr %562, i64 %563
  %565 = getelementptr inbounds %struct.nk_vec2, ptr %564, i32 0, i32 1
  %566 = load float, ptr %565, align 4, !tbaa !33
  %567 = load ptr, ptr %29, align 8, !tbaa !5
  %568 = load i64, ptr %49, align 8, !tbaa !22
  %569 = getelementptr inbounds %struct.nk_vec2, ptr %567, i64 %568
  %570 = getelementptr inbounds %struct.nk_vec2, ptr %569, i32 0, i32 1
  %571 = load float, ptr %570, align 4, !tbaa !33
  %572 = fadd float %566, %571
  %573 = call <2 x float> @nk_vec2(float noundef %561, float noundef %572)
  store <2 x float> %573, ptr %53, align 4
  %574 = getelementptr inbounds %struct.nk_vec2, ptr %53, i32 0, i32 1
  %575 = load float, ptr %574, align 4, !tbaa !33
  %576 = fmul float %575, 5.000000e-01
  %577 = call <2 x float> @nk_vec2(float noundef %550, float noundef %576)
  store <2 x float> %577, ptr %51, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %47, ptr align 4 %51, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %51) #6
  %578 = getelementptr inbounds %struct.nk_vec2, ptr %47, i32 0, i32 0
  %579 = load float, ptr %578, align 4, !tbaa !32
  %580 = getelementptr inbounds %struct.nk_vec2, ptr %47, i32 0, i32 0
  %581 = load float, ptr %580, align 4, !tbaa !32
  %582 = getelementptr inbounds %struct.nk_vec2, ptr %47, i32 0, i32 1
  %583 = load float, ptr %582, align 4, !tbaa !33
  %584 = getelementptr inbounds %struct.nk_vec2, ptr %47, i32 0, i32 1
  %585 = load float, ptr %584, align 4, !tbaa !33
  %586 = fmul float %583, %585
  %587 = call float @llvm.fmuladd.f32(float %579, float %581, float %586)
  store float %587, ptr %48, align 4, !tbaa !11
  %588 = load float, ptr %48, align 4, !tbaa !11
  %589 = fcmp ogt float %588, 0x3EB0C6F7A0000000
  br i1 %589, label %590, label %609

590:                                              ; preds = %523
  call void @llvm.lifetime.start.p0(i64 4, ptr %54) #6
  %591 = load float, ptr %48, align 4, !tbaa !11
  %592 = fdiv float 1.000000e+00, %591
  store float %592, ptr %54, align 4, !tbaa !11
  %593 = load float, ptr %54, align 4, !tbaa !11
  %594 = fcmp olt float 1.000000e+02, %593
  br i1 %594, label %595, label %596

595:                                              ; preds = %590
  br label %598

596:                                              ; preds = %590
  %597 = load float, ptr %54, align 4, !tbaa !11
  br label %598

598:                                              ; preds = %596, %595
  %599 = phi float [ 1.000000e+02, %595 ], [ %597, %596 ]
  store float %599, ptr %54, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 8, ptr %55) #6
  %600 = getelementptr inbounds %struct.nk_vec2, ptr %47, i32 0, i32 0
  %601 = load float, ptr %600, align 4, !tbaa !32
  %602 = load float, ptr %54, align 4, !tbaa !11
  %603 = fmul float %601, %602
  %604 = getelementptr inbounds %struct.nk_vec2, ptr %47, i32 0, i32 1
  %605 = load float, ptr %604, align 4, !tbaa !33
  %606 = load float, ptr %54, align 4, !tbaa !11
  %607 = fmul float %605, %606
  %608 = call <2 x float> @nk_vec2(float noundef %603, float noundef %607)
  store <2 x float> %608, ptr %55, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %47, ptr align 4 %55, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %55) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #6
  br label %609

609:                                              ; preds = %598, %523
  call void @llvm.lifetime.start.p0(i64 8, ptr %56) #6
  %610 = getelementptr inbounds %struct.nk_vec2, ptr %47, i32 0, i32 0
  %611 = load float, ptr %610, align 4, !tbaa !32
  %612 = fmul float %611, 1.000000e+00
  %613 = getelementptr inbounds %struct.nk_vec2, ptr %47, i32 0, i32 1
  %614 = load float, ptr %613, align 4, !tbaa !33
  %615 = fmul float %614, 1.000000e+00
  %616 = call <2 x float> @nk_vec2(float noundef %612, float noundef %615)
  store <2 x float> %616, ptr %56, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %47, ptr align 4 %56, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %56) #6
  %617 = load ptr, ptr %30, align 8, !tbaa !5
  %618 = load i64, ptr %49, align 8, !tbaa !22
  %619 = mul i64 %618, 2
  %620 = add i64 %619, 0
  %621 = getelementptr inbounds %struct.nk_vec2, ptr %617, i64 %620
  call void @llvm.lifetime.start.p0(i64 8, ptr %57) #6
  %622 = load ptr, ptr %10, align 8, !tbaa !5
  %623 = load i64, ptr %49, align 8, !tbaa !22
  %624 = getelementptr inbounds %struct.nk_vec2, ptr %622, i64 %623
  %625 = getelementptr inbounds %struct.nk_vec2, ptr %624, i32 0, i32 0
  %626 = load float, ptr %625, align 4, !tbaa !32
  %627 = getelementptr inbounds %struct.nk_vec2, ptr %47, i32 0, i32 0
  %628 = load float, ptr %627, align 4, !tbaa !32
  %629 = fadd float %626, %628
  %630 = load ptr, ptr %10, align 8, !tbaa !5
  %631 = load i64, ptr %49, align 8, !tbaa !22
  %632 = getelementptr inbounds %struct.nk_vec2, ptr %630, i64 %631
  %633 = getelementptr inbounds %struct.nk_vec2, ptr %632, i32 0, i32 1
  %634 = load float, ptr %633, align 4, !tbaa !33
  %635 = getelementptr inbounds %struct.nk_vec2, ptr %47, i32 0, i32 1
  %636 = load float, ptr %635, align 4, !tbaa !33
  %637 = fadd float %634, %636
  %638 = call <2 x float> @nk_vec2(float noundef %629, float noundef %637)
  store <2 x float> %638, ptr %57, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %621, ptr align 4 %57, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %57) #6
  %639 = load ptr, ptr %30, align 8, !tbaa !5
  %640 = load i64, ptr %49, align 8, !tbaa !22
  %641 = mul i64 %640, 2
  %642 = add i64 %641, 1
  %643 = getelementptr inbounds %struct.nk_vec2, ptr %639, i64 %642
  call void @llvm.lifetime.start.p0(i64 8, ptr %58) #6
  %644 = load ptr, ptr %10, align 8, !tbaa !5
  %645 = load i64, ptr %49, align 8, !tbaa !22
  %646 = getelementptr inbounds %struct.nk_vec2, ptr %644, i64 %645
  %647 = getelementptr inbounds %struct.nk_vec2, ptr %646, i32 0, i32 0
  %648 = load float, ptr %647, align 4, !tbaa !32
  %649 = getelementptr inbounds %struct.nk_vec2, ptr %47, i32 0, i32 0
  %650 = load float, ptr %649, align 4, !tbaa !32
  %651 = fsub float %648, %650
  %652 = load ptr, ptr %10, align 8, !tbaa !5
  %653 = load i64, ptr %49, align 8, !tbaa !22
  %654 = getelementptr inbounds %struct.nk_vec2, ptr %652, i64 %653
  %655 = getelementptr inbounds %struct.nk_vec2, ptr %654, i32 0, i32 1
  %656 = load float, ptr %655, align 4, !tbaa !33
  %657 = getelementptr inbounds %struct.nk_vec2, ptr %47, i32 0, i32 1
  %658 = load float, ptr %657, align 4, !tbaa !33
  %659 = fsub float %656, %658
  %660 = call <2 x float> @nk_vec2(float noundef %651, float noundef %659)
  store <2 x float> %660, ptr %58, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %643, ptr align 4 %58, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %58) #6
  %661 = load i64, ptr %50, align 8, !tbaa !22
  %662 = add i64 %661, 0
  %663 = trunc i64 %662 to i16
  %664 = load ptr, ptr %27, align 8, !tbaa !5
  %665 = getelementptr inbounds i16, ptr %664, i64 0
  store i16 %663, ptr %665, align 2, !tbaa !37
  %666 = load i64, ptr %35, align 8, !tbaa !22
  %667 = add i64 %666, 0
  %668 = trunc i64 %667 to i16
  %669 = load ptr, ptr %27, align 8, !tbaa !5
  %670 = getelementptr inbounds i16, ptr %669, i64 1
  store i16 %668, ptr %670, align 2, !tbaa !37
  %671 = load i64, ptr %35, align 8, !tbaa !22
  %672 = add i64 %671, 2
  %673 = trunc i64 %672 to i16
  %674 = load ptr, ptr %27, align 8, !tbaa !5
  %675 = getelementptr inbounds i16, ptr %674, i64 2
  store i16 %673, ptr %675, align 2, !tbaa !37
  %676 = load i64, ptr %35, align 8, !tbaa !22
  %677 = add i64 %676, 2
  %678 = trunc i64 %677 to i16
  %679 = load ptr, ptr %27, align 8, !tbaa !5
  %680 = getelementptr inbounds i16, ptr %679, i64 3
  store i16 %678, ptr %680, align 2, !tbaa !37
  %681 = load i64, ptr %50, align 8, !tbaa !22
  %682 = add i64 %681, 2
  %683 = trunc i64 %682 to i16
  %684 = load ptr, ptr %27, align 8, !tbaa !5
  %685 = getelementptr inbounds i16, ptr %684, i64 4
  store i16 %683, ptr %685, align 2, !tbaa !37
  %686 = load i64, ptr %50, align 8, !tbaa !22
  %687 = add i64 %686, 0
  %688 = trunc i64 %687 to i16
  %689 = load ptr, ptr %27, align 8, !tbaa !5
  %690 = getelementptr inbounds i16, ptr %689, i64 5
  store i16 %688, ptr %690, align 2, !tbaa !37
  %691 = load i64, ptr %50, align 8, !tbaa !22
  %692 = add i64 %691, 1
  %693 = trunc i64 %692 to i16
  %694 = load ptr, ptr %27, align 8, !tbaa !5
  %695 = getelementptr inbounds i16, ptr %694, i64 6
  store i16 %693, ptr %695, align 2, !tbaa !37
  %696 = load i64, ptr %35, align 8, !tbaa !22
  %697 = add i64 %696, 1
  %698 = trunc i64 %697 to i16
  %699 = load ptr, ptr %27, align 8, !tbaa !5
  %700 = getelementptr inbounds i16, ptr %699, i64 7
  store i16 %698, ptr %700, align 2, !tbaa !37
  %701 = load i64, ptr %35, align 8, !tbaa !22
  %702 = add i64 %701, 0
  %703 = trunc i64 %702 to i16
  %704 = load ptr, ptr %27, align 8, !tbaa !5
  %705 = getelementptr inbounds i16, ptr %704, i64 8
  store i16 %703, ptr %705, align 2, !tbaa !37
  %706 = load i64, ptr %35, align 8, !tbaa !22
  %707 = add i64 %706, 0
  %708 = trunc i64 %707 to i16
  %709 = load ptr, ptr %27, align 8, !tbaa !5
  %710 = getelementptr inbounds i16, ptr %709, i64 9
  store i16 %708, ptr %710, align 2, !tbaa !37
  %711 = load i64, ptr %50, align 8, !tbaa !22
  %712 = add i64 %711, 0
  %713 = trunc i64 %712 to i16
  %714 = load ptr, ptr %27, align 8, !tbaa !5
  %715 = getelementptr inbounds i16, ptr %714, i64 10
  store i16 %713, ptr %715, align 2, !tbaa !37
  %716 = load i64, ptr %50, align 8, !tbaa !22
  %717 = add i64 %716, 1
  %718 = trunc i64 %717 to i16
  %719 = load ptr, ptr %27, align 8, !tbaa !5
  %720 = getelementptr inbounds i16, ptr %719, i64 11
  store i16 %718, ptr %720, align 2, !tbaa !37
  %721 = load ptr, ptr %27, align 8, !tbaa !5
  %722 = getelementptr inbounds i16, ptr %721, i64 12
  store ptr %722, ptr %27, align 8, !tbaa !5
  %723 = load i64, ptr %50, align 8, !tbaa !22
  store i64 %723, ptr %35, align 8, !tbaa !22
  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 4, ptr %48) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #6
  br label %724

724:                                              ; preds = %609
  %725 = load i64, ptr %21, align 8, !tbaa !22
  %726 = add i64 %725, 1
  store i64 %726, ptr %21, align 8, !tbaa !22
  br label %497, !llvm.loop !39

727:                                              ; preds = %497
  store i64 0, ptr %36, align 8, !tbaa !22
  br label %728

728:                                              ; preds = %781, %727
  %729 = load i64, ptr %36, align 8, !tbaa !22
  %730 = load i32, ptr %11, align 4, !tbaa !9
  %731 = zext i32 %730 to i64
  %732 = icmp ult i64 %729, %731
  br i1 %732, label %733, label %784

733:                                              ; preds = %728
  call void @llvm.lifetime.start.p0(i64 8, ptr %59) #6
  %734 = load ptr, ptr %9, align 8, !tbaa !5
  %735 = getelementptr inbounds %struct.nk_draw_list, ptr %734, i32 0, i32 2
  %736 = getelementptr inbounds %struct.nk_convert_config, ptr %735, i32 0, i32 6
  %737 = getelementptr inbounds %struct.nk_draw_null_texture, ptr %736, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %59, ptr align 8 %737, i64 8, i1 false), !tbaa.struct !34
  %738 = load ptr, ptr %26, align 8, !tbaa !5
  %739 = load ptr, ptr %9, align 8, !tbaa !5
  %740 = getelementptr inbounds %struct.nk_draw_list, ptr %739, i32 0, i32 2
  %741 = load ptr, ptr %10, align 8, !tbaa !5
  %742 = load i64, ptr %36, align 8, !tbaa !22
  %743 = getelementptr inbounds %struct.nk_vec2, ptr %741, i64 %742
  %744 = load <2 x float>, ptr %743, align 4
  %745 = load <2 x float>, ptr %59, align 4
  %746 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %17, i32 0, i32 0
  %747 = load <2 x float>, ptr %746, align 4
  %748 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %17, i32 0, i32 1
  %749 = load <2 x float>, ptr %748, align 4
  %750 = call ptr @nk_draw_vertex(ptr noundef %738, ptr noundef %740, <2 x float> %744, <2 x float> %745, <2 x float> %747, <2 x float> %749)
  store ptr %750, ptr %26, align 8, !tbaa !5
  %751 = load ptr, ptr %26, align 8, !tbaa !5
  %752 = load ptr, ptr %9, align 8, !tbaa !5
  %753 = getelementptr inbounds %struct.nk_draw_list, ptr %752, i32 0, i32 2
  %754 = load ptr, ptr %30, align 8, !tbaa !5
  %755 = load i64, ptr %36, align 8, !tbaa !22
  %756 = mul i64 %755, 2
  %757 = add i64 %756, 0
  %758 = getelementptr inbounds %struct.nk_vec2, ptr %754, i64 %757
  %759 = load <2 x float>, ptr %758, align 4
  %760 = load <2 x float>, ptr %59, align 4
  %761 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %18, i32 0, i32 0
  %762 = load <2 x float>, ptr %761, align 4
  %763 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %18, i32 0, i32 1
  %764 = load <2 x float>, ptr %763, align 4
  %765 = call ptr @nk_draw_vertex(ptr noundef %751, ptr noundef %753, <2 x float> %759, <2 x float> %760, <2 x float> %762, <2 x float> %764)
  store ptr %765, ptr %26, align 8, !tbaa !5
  %766 = load ptr, ptr %26, align 8, !tbaa !5
  %767 = load ptr, ptr %9, align 8, !tbaa !5
  %768 = getelementptr inbounds %struct.nk_draw_list, ptr %767, i32 0, i32 2
  %769 = load ptr, ptr %30, align 8, !tbaa !5
  %770 = load i64, ptr %36, align 8, !tbaa !22
  %771 = mul i64 %770, 2
  %772 = add i64 %771, 1
  %773 = getelementptr inbounds %struct.nk_vec2, ptr %769, i64 %772
  %774 = load <2 x float>, ptr %773, align 4
  %775 = load <2 x float>, ptr %59, align 4
  %776 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %18, i32 0, i32 0
  %777 = load <2 x float>, ptr %776, align 4
  %778 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %18, i32 0, i32 1
  %779 = load <2 x float>, ptr %778, align 4
  %780 = call ptr @nk_draw_vertex(ptr noundef %766, ptr noundef %768, <2 x float> %774, <2 x float> %775, <2 x float> %777, <2 x float> %779)
  store ptr %780, ptr %26, align 8, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 8, ptr %59) #6
  br label %781

781:                                              ; preds = %733
  %782 = load i64, ptr %36, align 8, !tbaa !22
  %783 = add i64 %782, 1
  store i64 %783, ptr %36, align 8, !tbaa !22
  br label %728, !llvm.loop !40

784:                                              ; preds = %728
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #6
  br label %1434

785:                                              ; preds = %337
  call void @llvm.lifetime.start.p0(i64 8, ptr %60) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %61) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %62) #6
  %786 = load float, ptr %13, align 4, !tbaa !11
  %787 = fsub float %786, 1.000000e+00
  %788 = fmul float %787, 5.000000e-01
  store float %788, ptr %62, align 4, !tbaa !11
  %789 = load i32, ptr %12, align 4, !tbaa !9
  %790 = icmp ne i32 %789, 0
  br i1 %790, label %1040, label %791

791:                                              ; preds = %785
  call void @llvm.lifetime.start.p0(i64 8, ptr %63) #6
  %792 = load ptr, ptr %29, align 8, !tbaa !5
  %793 = getelementptr inbounds %struct.nk_vec2, ptr %792, i64 0
  %794 = getelementptr inbounds %struct.nk_vec2, ptr %793, i32 0, i32 0
  %795 = load float, ptr %794, align 4, !tbaa !32
  %796 = load float, ptr %62, align 4, !tbaa !11
  %797 = fadd float %796, 1.000000e+00
  %798 = fmul float %795, %797
  %799 = load ptr, ptr %29, align 8, !tbaa !5
  %800 = getelementptr inbounds %struct.nk_vec2, ptr %799, i64 0
  %801 = getelementptr inbounds %struct.nk_vec2, ptr %800, i32 0, i32 1
  %802 = load float, ptr %801, align 4, !tbaa !33
  %803 = load float, ptr %62, align 4, !tbaa !11
  %804 = fadd float %803, 1.000000e+00
  %805 = fmul float %802, %804
  %806 = call <2 x float> @nk_vec2(float noundef %798, float noundef %805)
  store <2 x float> %806, ptr %63, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr %64) #6
  %807 = load ptr, ptr %29, align 8, !tbaa !5
  %808 = getelementptr inbounds %struct.nk_vec2, ptr %807, i64 0
  %809 = getelementptr inbounds %struct.nk_vec2, ptr %808, i32 0, i32 0
  %810 = load float, ptr %809, align 4, !tbaa !32
  %811 = load float, ptr %62, align 4, !tbaa !11
  %812 = fmul float %810, %811
  %813 = load ptr, ptr %29, align 8, !tbaa !5
  %814 = getelementptr inbounds %struct.nk_vec2, ptr %813, i64 0
  %815 = getelementptr inbounds %struct.nk_vec2, ptr %814, i32 0, i32 1
  %816 = load float, ptr %815, align 4, !tbaa !33
  %817 = load float, ptr %62, align 4, !tbaa !11
  %818 = fmul float %816, %817
  %819 = call <2 x float> @nk_vec2(float noundef %812, float noundef %818)
  store <2 x float> %819, ptr %64, align 4
  %820 = load ptr, ptr %30, align 8, !tbaa !5
  %821 = getelementptr inbounds %struct.nk_vec2, ptr %820, i64 0
  call void @llvm.lifetime.start.p0(i64 8, ptr %65) #6
  %822 = load ptr, ptr %10, align 8, !tbaa !5
  %823 = getelementptr inbounds %struct.nk_vec2, ptr %822, i64 0
  %824 = getelementptr inbounds %struct.nk_vec2, ptr %823, i32 0, i32 0
  %825 = load float, ptr %824, align 4, !tbaa !32
  %826 = getelementptr inbounds %struct.nk_vec2, ptr %63, i32 0, i32 0
  %827 = load float, ptr %826, align 4, !tbaa !32
  %828 = fadd float %825, %827
  %829 = load ptr, ptr %10, align 8, !tbaa !5
  %830 = getelementptr inbounds %struct.nk_vec2, ptr %829, i64 0
  %831 = getelementptr inbounds %struct.nk_vec2, ptr %830, i32 0, i32 1
  %832 = load float, ptr %831, align 4, !tbaa !33
  %833 = getelementptr inbounds %struct.nk_vec2, ptr %63, i32 0, i32 1
  %834 = load float, ptr %833, align 4, !tbaa !33
  %835 = fadd float %832, %834
  %836 = call <2 x float> @nk_vec2(float noundef %828, float noundef %835)
  store <2 x float> %836, ptr %65, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %821, ptr align 4 %65, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %65) #6
  %837 = load ptr, ptr %30, align 8, !tbaa !5
  %838 = getelementptr inbounds %struct.nk_vec2, ptr %837, i64 1
  call void @llvm.lifetime.start.p0(i64 8, ptr %66) #6
  %839 = load ptr, ptr %10, align 8, !tbaa !5
  %840 = getelementptr inbounds %struct.nk_vec2, ptr %839, i64 0
  %841 = getelementptr inbounds %struct.nk_vec2, ptr %840, i32 0, i32 0
  %842 = load float, ptr %841, align 4, !tbaa !32
  %843 = getelementptr inbounds %struct.nk_vec2, ptr %64, i32 0, i32 0
  %844 = load float, ptr %843, align 4, !tbaa !32
  %845 = fadd float %842, %844
  %846 = load ptr, ptr %10, align 8, !tbaa !5
  %847 = getelementptr inbounds %struct.nk_vec2, ptr %846, i64 0
  %848 = getelementptr inbounds %struct.nk_vec2, ptr %847, i32 0, i32 1
  %849 = load float, ptr %848, align 4, !tbaa !33
  %850 = getelementptr inbounds %struct.nk_vec2, ptr %64, i32 0, i32 1
  %851 = load float, ptr %850, align 4, !tbaa !33
  %852 = fadd float %849, %851
  %853 = call <2 x float> @nk_vec2(float noundef %845, float noundef %852)
  store <2 x float> %853, ptr %66, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %838, ptr align 4 %66, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %66) #6
  %854 = load ptr, ptr %30, align 8, !tbaa !5
  %855 = getelementptr inbounds %struct.nk_vec2, ptr %854, i64 2
  call void @llvm.lifetime.start.p0(i64 8, ptr %67) #6
  %856 = load ptr, ptr %10, align 8, !tbaa !5
  %857 = getelementptr inbounds %struct.nk_vec2, ptr %856, i64 0
  %858 = getelementptr inbounds %struct.nk_vec2, ptr %857, i32 0, i32 0
  %859 = load float, ptr %858, align 4, !tbaa !32
  %860 = getelementptr inbounds %struct.nk_vec2, ptr %64, i32 0, i32 0
  %861 = load float, ptr %860, align 4, !tbaa !32
  %862 = fsub float %859, %861
  %863 = load ptr, ptr %10, align 8, !tbaa !5
  %864 = getelementptr inbounds %struct.nk_vec2, ptr %863, i64 0
  %865 = getelementptr inbounds %struct.nk_vec2, ptr %864, i32 0, i32 1
  %866 = load float, ptr %865, align 4, !tbaa !33
  %867 = getelementptr inbounds %struct.nk_vec2, ptr %64, i32 0, i32 1
  %868 = load float, ptr %867, align 4, !tbaa !33
  %869 = fsub float %866, %868
  %870 = call <2 x float> @nk_vec2(float noundef %862, float noundef %869)
  store <2 x float> %870, ptr %67, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %855, ptr align 4 %67, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %67) #6
  %871 = load ptr, ptr %30, align 8, !tbaa !5
  %872 = getelementptr inbounds %struct.nk_vec2, ptr %871, i64 3
  call void @llvm.lifetime.start.p0(i64 8, ptr %68) #6
  %873 = load ptr, ptr %10, align 8, !tbaa !5
  %874 = getelementptr inbounds %struct.nk_vec2, ptr %873, i64 0
  %875 = getelementptr inbounds %struct.nk_vec2, ptr %874, i32 0, i32 0
  %876 = load float, ptr %875, align 4, !tbaa !32
  %877 = getelementptr inbounds %struct.nk_vec2, ptr %63, i32 0, i32 0
  %878 = load float, ptr %877, align 4, !tbaa !32
  %879 = fsub float %876, %878
  %880 = load ptr, ptr %10, align 8, !tbaa !5
  %881 = getelementptr inbounds %struct.nk_vec2, ptr %880, i64 0
  %882 = getelementptr inbounds %struct.nk_vec2, ptr %881, i32 0, i32 1
  %883 = load float, ptr %882, align 4, !tbaa !33
  %884 = getelementptr inbounds %struct.nk_vec2, ptr %63, i32 0, i32 1
  %885 = load float, ptr %884, align 4, !tbaa !33
  %886 = fsub float %883, %885
  %887 = call <2 x float> @nk_vec2(float noundef %879, float noundef %886)
  store <2 x float> %887, ptr %68, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %872, ptr align 4 %68, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %68) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %69) #6
  %888 = load ptr, ptr %29, align 8, !tbaa !5
  %889 = load i32, ptr %11, align 4, !tbaa !9
  %890 = sub i32 %889, 1
  %891 = zext i32 %890 to i64
  %892 = getelementptr inbounds %struct.nk_vec2, ptr %888, i64 %891
  %893 = getelementptr inbounds %struct.nk_vec2, ptr %892, i32 0, i32 0
  %894 = load float, ptr %893, align 4, !tbaa !32
  %895 = load float, ptr %62, align 4, !tbaa !11
  %896 = fadd float %895, 1.000000e+00
  %897 = fmul float %894, %896
  %898 = load ptr, ptr %29, align 8, !tbaa !5
  %899 = load i32, ptr %11, align 4, !tbaa !9
  %900 = sub i32 %899, 1
  %901 = zext i32 %900 to i64
  %902 = getelementptr inbounds %struct.nk_vec2, ptr %898, i64 %901
  %903 = getelementptr inbounds %struct.nk_vec2, ptr %902, i32 0, i32 1
  %904 = load float, ptr %903, align 4, !tbaa !33
  %905 = load float, ptr %62, align 4, !tbaa !11
  %906 = fadd float %905, 1.000000e+00
  %907 = fmul float %904, %906
  %908 = call <2 x float> @nk_vec2(float noundef %897, float noundef %907)
  store <2 x float> %908, ptr %69, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %63, ptr align 4 %69, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %69) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %70) #6
  %909 = load ptr, ptr %29, align 8, !tbaa !5
  %910 = load i32, ptr %11, align 4, !tbaa !9
  %911 = sub i32 %910, 1
  %912 = zext i32 %911 to i64
  %913 = getelementptr inbounds %struct.nk_vec2, ptr %909, i64 %912
  %914 = getelementptr inbounds %struct.nk_vec2, ptr %913, i32 0, i32 0
  %915 = load float, ptr %914, align 4, !tbaa !32
  %916 = load float, ptr %62, align 4, !tbaa !11
  %917 = fmul float %915, %916
  %918 = load ptr, ptr %29, align 8, !tbaa !5
  %919 = load i32, ptr %11, align 4, !tbaa !9
  %920 = sub i32 %919, 1
  %921 = zext i32 %920 to i64
  %922 = getelementptr inbounds %struct.nk_vec2, ptr %918, i64 %921
  %923 = getelementptr inbounds %struct.nk_vec2, ptr %922, i32 0, i32 1
  %924 = load float, ptr %923, align 4, !tbaa !33
  %925 = load float, ptr %62, align 4, !tbaa !11
  %926 = fmul float %924, %925
  %927 = call <2 x float> @nk_vec2(float noundef %917, float noundef %926)
  store <2 x float> %927, ptr %70, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %64, ptr align 4 %70, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %70) #6
  %928 = load ptr, ptr %30, align 8, !tbaa !5
  %929 = load i32, ptr %11, align 4, !tbaa !9
  %930 = sub i32 %929, 1
  %931 = mul i32 %930, 4
  %932 = add i32 %931, 0
  %933 = zext i32 %932 to i64
  %934 = getelementptr inbounds %struct.nk_vec2, ptr %928, i64 %933
  call void @llvm.lifetime.start.p0(i64 8, ptr %71) #6
  %935 = load ptr, ptr %10, align 8, !tbaa !5
  %936 = load i32, ptr %11, align 4, !tbaa !9
  %937 = sub i32 %936, 1
  %938 = zext i32 %937 to i64
  %939 = getelementptr inbounds %struct.nk_vec2, ptr %935, i64 %938
  %940 = getelementptr inbounds %struct.nk_vec2, ptr %939, i32 0, i32 0
  %941 = load float, ptr %940, align 4, !tbaa !32
  %942 = getelementptr inbounds %struct.nk_vec2, ptr %63, i32 0, i32 0
  %943 = load float, ptr %942, align 4, !tbaa !32
  %944 = fadd float %941, %943
  %945 = load ptr, ptr %10, align 8, !tbaa !5
  %946 = load i32, ptr %11, align 4, !tbaa !9
  %947 = sub i32 %946, 1
  %948 = zext i32 %947 to i64
  %949 = getelementptr inbounds %struct.nk_vec2, ptr %945, i64 %948
  %950 = getelementptr inbounds %struct.nk_vec2, ptr %949, i32 0, i32 1
  %951 = load float, ptr %950, align 4, !tbaa !33
  %952 = getelementptr inbounds %struct.nk_vec2, ptr %63, i32 0, i32 1
  %953 = load float, ptr %952, align 4, !tbaa !33
  %954 = fadd float %951, %953
  %955 = call <2 x float> @nk_vec2(float noundef %944, float noundef %954)
  store <2 x float> %955, ptr %71, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %934, ptr align 4 %71, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %71) #6
  %956 = load ptr, ptr %30, align 8, !tbaa !5
  %957 = load i32, ptr %11, align 4, !tbaa !9
  %958 = sub i32 %957, 1
  %959 = mul i32 %958, 4
  %960 = add i32 %959, 1
  %961 = zext i32 %960 to i64
  %962 = getelementptr inbounds %struct.nk_vec2, ptr %956, i64 %961
  call void @llvm.lifetime.start.p0(i64 8, ptr %72) #6
  %963 = load ptr, ptr %10, align 8, !tbaa !5
  %964 = load i32, ptr %11, align 4, !tbaa !9
  %965 = sub i32 %964, 1
  %966 = zext i32 %965 to i64
  %967 = getelementptr inbounds %struct.nk_vec2, ptr %963, i64 %966
  %968 = getelementptr inbounds %struct.nk_vec2, ptr %967, i32 0, i32 0
  %969 = load float, ptr %968, align 4, !tbaa !32
  %970 = getelementptr inbounds %struct.nk_vec2, ptr %64, i32 0, i32 0
  %971 = load float, ptr %970, align 4, !tbaa !32
  %972 = fadd float %969, %971
  %973 = load ptr, ptr %10, align 8, !tbaa !5
  %974 = load i32, ptr %11, align 4, !tbaa !9
  %975 = sub i32 %974, 1
  %976 = zext i32 %975 to i64
  %977 = getelementptr inbounds %struct.nk_vec2, ptr %973, i64 %976
  %978 = getelementptr inbounds %struct.nk_vec2, ptr %977, i32 0, i32 1
  %979 = load float, ptr %978, align 4, !tbaa !33
  %980 = getelementptr inbounds %struct.nk_vec2, ptr %64, i32 0, i32 1
  %981 = load float, ptr %980, align 4, !tbaa !33
  %982 = fadd float %979, %981
  %983 = call <2 x float> @nk_vec2(float noundef %972, float noundef %982)
  store <2 x float> %983, ptr %72, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %962, ptr align 4 %72, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %72) #6
  %984 = load ptr, ptr %30, align 8, !tbaa !5
  %985 = load i32, ptr %11, align 4, !tbaa !9
  %986 = sub i32 %985, 1
  %987 = mul i32 %986, 4
  %988 = add i32 %987, 2
  %989 = zext i32 %988 to i64
  %990 = getelementptr inbounds %struct.nk_vec2, ptr %984, i64 %989
  call void @llvm.lifetime.start.p0(i64 8, ptr %73) #6
  %991 = load ptr, ptr %10, align 8, !tbaa !5
  %992 = load i32, ptr %11, align 4, !tbaa !9
  %993 = sub i32 %992, 1
  %994 = zext i32 %993 to i64
  %995 = getelementptr inbounds %struct.nk_vec2, ptr %991, i64 %994
  %996 = getelementptr inbounds %struct.nk_vec2, ptr %995, i32 0, i32 0
  %997 = load float, ptr %996, align 4, !tbaa !32
  %998 = getelementptr inbounds %struct.nk_vec2, ptr %64, i32 0, i32 0
  %999 = load float, ptr %998, align 4, !tbaa !32
  %1000 = fsub float %997, %999
  %1001 = load ptr, ptr %10, align 8, !tbaa !5
  %1002 = load i32, ptr %11, align 4, !tbaa !9
  %1003 = sub i32 %1002, 1
  %1004 = zext i32 %1003 to i64
  %1005 = getelementptr inbounds %struct.nk_vec2, ptr %1001, i64 %1004
  %1006 = getelementptr inbounds %struct.nk_vec2, ptr %1005, i32 0, i32 1
  %1007 = load float, ptr %1006, align 4, !tbaa !33
  %1008 = getelementptr inbounds %struct.nk_vec2, ptr %64, i32 0, i32 1
  %1009 = load float, ptr %1008, align 4, !tbaa !33
  %1010 = fsub float %1007, %1009
  %1011 = call <2 x float> @nk_vec2(float noundef %1000, float noundef %1010)
  store <2 x float> %1011, ptr %73, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %990, ptr align 4 %73, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %73) #6
  %1012 = load ptr, ptr %30, align 8, !tbaa !5
  %1013 = load i32, ptr %11, align 4, !tbaa !9
  %1014 = sub i32 %1013, 1
  %1015 = mul i32 %1014, 4
  %1016 = add i32 %1015, 3
  %1017 = zext i32 %1016 to i64
  %1018 = getelementptr inbounds %struct.nk_vec2, ptr %1012, i64 %1017
  call void @llvm.lifetime.start.p0(i64 8, ptr %74) #6
  %1019 = load ptr, ptr %10, align 8, !tbaa !5
  %1020 = load i32, ptr %11, align 4, !tbaa !9
  %1021 = sub i32 %1020, 1
  %1022 = zext i32 %1021 to i64
  %1023 = getelementptr inbounds %struct.nk_vec2, ptr %1019, i64 %1022
  %1024 = getelementptr inbounds %struct.nk_vec2, ptr %1023, i32 0, i32 0
  %1025 = load float, ptr %1024, align 4, !tbaa !32
  %1026 = getelementptr inbounds %struct.nk_vec2, ptr %63, i32 0, i32 0
  %1027 = load float, ptr %1026, align 4, !tbaa !32
  %1028 = fsub float %1025, %1027
  %1029 = load ptr, ptr %10, align 8, !tbaa !5
  %1030 = load i32, ptr %11, align 4, !tbaa !9
  %1031 = sub i32 %1030, 1
  %1032 = zext i32 %1031 to i64
  %1033 = getelementptr inbounds %struct.nk_vec2, ptr %1029, i64 %1032
  %1034 = getelementptr inbounds %struct.nk_vec2, ptr %1033, i32 0, i32 1
  %1035 = load float, ptr %1034, align 4, !tbaa !33
  %1036 = getelementptr inbounds %struct.nk_vec2, ptr %63, i32 0, i32 1
  %1037 = load float, ptr %1036, align 4, !tbaa !33
  %1038 = fsub float %1035, %1037
  %1039 = call <2 x float> @nk_vec2(float noundef %1028, float noundef %1038)
  store <2 x float> %1039, ptr %74, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1018, ptr align 4 %74, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %74) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %64) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %63) #6
  br label %1040

1040:                                             ; preds = %791, %785
  %1041 = load i64, ptr %23, align 8, !tbaa !22
  store i64 %1041, ptr %60, align 8, !tbaa !22
  store i64 0, ptr %21, align 8, !tbaa !22
  br label %1042

1042:                                             ; preds = %1356, %1040
  %1043 = load i64, ptr %21, align 8, !tbaa !22
  %1044 = load i64, ptr %15, align 8, !tbaa !22
  %1045 = icmp ult i64 %1043, %1044
  br i1 %1045, label %1046, label %1359

1046:                                             ; preds = %1042
  call void @llvm.lifetime.start.p0(i64 8, ptr %75) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %76) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %77) #6
  %1047 = load i64, ptr %21, align 8, !tbaa !22
  %1048 = add i64 %1047, 1
  %1049 = load i32, ptr %11, align 4, !tbaa !9
  %1050 = zext i32 %1049 to i64
  %1051 = icmp eq i64 %1048, %1050
  br i1 %1051, label %1052, label %1053

1052:                                             ; preds = %1046
  br label %1056

1053:                                             ; preds = %1046
  %1054 = load i64, ptr %21, align 8, !tbaa !22
  %1055 = add i64 %1054, 1
  br label %1056

1056:                                             ; preds = %1053, %1052
  %1057 = phi i64 [ 0, %1052 ], [ %1055, %1053 ]
  store i64 %1057, ptr %77, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %78) #6
  %1058 = load i64, ptr %21, align 8, !tbaa !22
  %1059 = add i64 %1058, 1
  %1060 = load i32, ptr %11, align 4, !tbaa !9
  %1061 = zext i32 %1060 to i64
  %1062 = icmp eq i64 %1059, %1061
  br i1 %1062, label %1063, label %1065

1063:                                             ; preds = %1056
  %1064 = load i64, ptr %23, align 8, !tbaa !22
  br label %1068

1065:                                             ; preds = %1056
  %1066 = load i64, ptr %60, align 8, !tbaa !22
  %1067 = add i64 %1066, 4
  br label %1068

1068:                                             ; preds = %1065, %1063
  %1069 = phi i64 [ %1064, %1063 ], [ %1067, %1065 ]
  store i64 %1069, ptr %78, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %79) #6
  %1070 = load ptr, ptr %29, align 8, !tbaa !5
  %1071 = load i64, ptr %21, align 8, !tbaa !22
  %1072 = getelementptr inbounds %struct.nk_vec2, ptr %1070, i64 %1071
  %1073 = getelementptr inbounds %struct.nk_vec2, ptr %1072, i32 0, i32 0
  %1074 = load float, ptr %1073, align 4, !tbaa !32
  %1075 = load ptr, ptr %29, align 8, !tbaa !5
  %1076 = load i64, ptr %77, align 8, !tbaa !22
  %1077 = getelementptr inbounds %struct.nk_vec2, ptr %1075, i64 %1076
  %1078 = getelementptr inbounds %struct.nk_vec2, ptr %1077, i32 0, i32 0
  %1079 = load float, ptr %1078, align 4, !tbaa !32
  %1080 = fadd float %1074, %1079
  %1081 = load ptr, ptr %29, align 8, !tbaa !5
  %1082 = load i64, ptr %21, align 8, !tbaa !22
  %1083 = getelementptr inbounds %struct.nk_vec2, ptr %1081, i64 %1082
  %1084 = getelementptr inbounds %struct.nk_vec2, ptr %1083, i32 0, i32 1
  %1085 = load float, ptr %1084, align 4, !tbaa !33
  %1086 = load ptr, ptr %29, align 8, !tbaa !5
  %1087 = load i64, ptr %77, align 8, !tbaa !22
  %1088 = getelementptr inbounds %struct.nk_vec2, ptr %1086, i64 %1087
  %1089 = getelementptr inbounds %struct.nk_vec2, ptr %1088, i32 0, i32 1
  %1090 = load float, ptr %1089, align 4, !tbaa !33
  %1091 = fadd float %1085, %1090
  %1092 = call <2 x float> @nk_vec2(float noundef %1080, float noundef %1091)
  store <2 x float> %1092, ptr %80, align 4
  %1093 = getelementptr inbounds %struct.nk_vec2, ptr %80, i32 0, i32 0
  %1094 = load float, ptr %1093, align 4, !tbaa !32
  %1095 = fmul float %1094, 5.000000e-01
  %1096 = load ptr, ptr %29, align 8, !tbaa !5
  %1097 = load i64, ptr %21, align 8, !tbaa !22
  %1098 = getelementptr inbounds %struct.nk_vec2, ptr %1096, i64 %1097
  %1099 = getelementptr inbounds %struct.nk_vec2, ptr %1098, i32 0, i32 0
  %1100 = load float, ptr %1099, align 4, !tbaa !32
  %1101 = load ptr, ptr %29, align 8, !tbaa !5
  %1102 = load i64, ptr %77, align 8, !tbaa !22
  %1103 = getelementptr inbounds %struct.nk_vec2, ptr %1101, i64 %1102
  %1104 = getelementptr inbounds %struct.nk_vec2, ptr %1103, i32 0, i32 0
  %1105 = load float, ptr %1104, align 4, !tbaa !32
  %1106 = fadd float %1100, %1105
  %1107 = load ptr, ptr %29, align 8, !tbaa !5
  %1108 = load i64, ptr %21, align 8, !tbaa !22
  %1109 = getelementptr inbounds %struct.nk_vec2, ptr %1107, i64 %1108
  %1110 = getelementptr inbounds %struct.nk_vec2, ptr %1109, i32 0, i32 1
  %1111 = load float, ptr %1110, align 4, !tbaa !33
  %1112 = load ptr, ptr %29, align 8, !tbaa !5
  %1113 = load i64, ptr %77, align 8, !tbaa !22
  %1114 = getelementptr inbounds %struct.nk_vec2, ptr %1112, i64 %1113
  %1115 = getelementptr inbounds %struct.nk_vec2, ptr %1114, i32 0, i32 1
  %1116 = load float, ptr %1115, align 4, !tbaa !33
  %1117 = fadd float %1111, %1116
  %1118 = call <2 x float> @nk_vec2(float noundef %1106, float noundef %1117)
  store <2 x float> %1118, ptr %81, align 4
  %1119 = getelementptr inbounds %struct.nk_vec2, ptr %81, i32 0, i32 1
  %1120 = load float, ptr %1119, align 4, !tbaa !33
  %1121 = fmul float %1120, 5.000000e-01
  %1122 = call <2 x float> @nk_vec2(float noundef %1095, float noundef %1121)
  store <2 x float> %1122, ptr %79, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %82) #6
  %1123 = getelementptr inbounds %struct.nk_vec2, ptr %79, i32 0, i32 0
  %1124 = load float, ptr %1123, align 4, !tbaa !32
  %1125 = getelementptr inbounds %struct.nk_vec2, ptr %79, i32 0, i32 0
  %1126 = load float, ptr %1125, align 4, !tbaa !32
  %1127 = getelementptr inbounds %struct.nk_vec2, ptr %79, i32 0, i32 1
  %1128 = load float, ptr %1127, align 4, !tbaa !33
  %1129 = getelementptr inbounds %struct.nk_vec2, ptr %79, i32 0, i32 1
  %1130 = load float, ptr %1129, align 4, !tbaa !33
  %1131 = fmul float %1128, %1130
  %1132 = call float @llvm.fmuladd.f32(float %1124, float %1126, float %1131)
  store float %1132, ptr %82, align 4, !tbaa !11
  %1133 = load float, ptr %82, align 4, !tbaa !11
  %1134 = fcmp ogt float %1133, 0x3EB0C6F7A0000000
  br i1 %1134, label %1135, label %1154

1135:                                             ; preds = %1068
  call void @llvm.lifetime.start.p0(i64 4, ptr %83) #6
  %1136 = load float, ptr %82, align 4, !tbaa !11
  %1137 = fdiv float 1.000000e+00, %1136
  store float %1137, ptr %83, align 4, !tbaa !11
  %1138 = load float, ptr %83, align 4, !tbaa !11
  %1139 = fcmp olt float 1.000000e+02, %1138
  br i1 %1139, label %1140, label %1141

1140:                                             ; preds = %1135
  br label %1143

1141:                                             ; preds = %1135
  %1142 = load float, ptr %83, align 4, !tbaa !11
  br label %1143

1143:                                             ; preds = %1141, %1140
  %1144 = phi float [ 1.000000e+02, %1140 ], [ %1142, %1141 ]
  store float %1144, ptr %83, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 8, ptr %84) #6
  %1145 = getelementptr inbounds %struct.nk_vec2, ptr %79, i32 0, i32 0
  %1146 = load float, ptr %1145, align 4, !tbaa !32
  %1147 = load float, ptr %83, align 4, !tbaa !11
  %1148 = fmul float %1146, %1147
  %1149 = getelementptr inbounds %struct.nk_vec2, ptr %79, i32 0, i32 1
  %1150 = load float, ptr %1149, align 4, !tbaa !33
  %1151 = load float, ptr %83, align 4, !tbaa !11
  %1152 = fmul float %1150, %1151
  %1153 = call <2 x float> @nk_vec2(float noundef %1148, float noundef %1152)
  store <2 x float> %1153, ptr %84, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %79, ptr align 4 %84, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %84) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %83) #6
  br label %1154

1154:                                             ; preds = %1143, %1068
  call void @llvm.lifetime.start.p0(i64 8, ptr %85) #6
  %1155 = getelementptr inbounds %struct.nk_vec2, ptr %79, i32 0, i32 0
  %1156 = load float, ptr %1155, align 4, !tbaa !32
  %1157 = load float, ptr %62, align 4, !tbaa !11
  %1158 = fadd float %1157, 1.000000e+00
  %1159 = fmul float %1156, %1158
  %1160 = getelementptr inbounds %struct.nk_vec2, ptr %79, i32 0, i32 1
  %1161 = load float, ptr %1160, align 4, !tbaa !33
  %1162 = load float, ptr %62, align 4, !tbaa !11
  %1163 = fadd float %1162, 1.000000e+00
  %1164 = fmul float %1161, %1163
  %1165 = call <2 x float> @nk_vec2(float noundef %1159, float noundef %1164)
  store <2 x float> %1165, ptr %85, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %75, ptr align 4 %85, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %85) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %86) #6
  %1166 = getelementptr inbounds %struct.nk_vec2, ptr %79, i32 0, i32 0
  %1167 = load float, ptr %1166, align 4, !tbaa !32
  %1168 = load float, ptr %62, align 4, !tbaa !11
  %1169 = fmul float %1167, %1168
  %1170 = getelementptr inbounds %struct.nk_vec2, ptr %79, i32 0, i32 1
  %1171 = load float, ptr %1170, align 4, !tbaa !33
  %1172 = load float, ptr %62, align 4, !tbaa !11
  %1173 = fmul float %1171, %1172
  %1174 = call <2 x float> @nk_vec2(float noundef %1169, float noundef %1173)
  store <2 x float> %1174, ptr %86, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %76, ptr align 4 %86, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %86) #6
  %1175 = load ptr, ptr %30, align 8, !tbaa !5
  %1176 = load i64, ptr %77, align 8, !tbaa !22
  %1177 = mul i64 %1176, 4
  %1178 = add i64 %1177, 0
  %1179 = getelementptr inbounds %struct.nk_vec2, ptr %1175, i64 %1178
  call void @llvm.lifetime.start.p0(i64 8, ptr %87) #6
  %1180 = load ptr, ptr %10, align 8, !tbaa !5
  %1181 = load i64, ptr %77, align 8, !tbaa !22
  %1182 = getelementptr inbounds %struct.nk_vec2, ptr %1180, i64 %1181
  %1183 = getelementptr inbounds %struct.nk_vec2, ptr %1182, i32 0, i32 0
  %1184 = load float, ptr %1183, align 4, !tbaa !32
  %1185 = getelementptr inbounds %struct.nk_vec2, ptr %75, i32 0, i32 0
  %1186 = load float, ptr %1185, align 4, !tbaa !32
  %1187 = fadd float %1184, %1186
  %1188 = load ptr, ptr %10, align 8, !tbaa !5
  %1189 = load i64, ptr %77, align 8, !tbaa !22
  %1190 = getelementptr inbounds %struct.nk_vec2, ptr %1188, i64 %1189
  %1191 = getelementptr inbounds %struct.nk_vec2, ptr %1190, i32 0, i32 1
  %1192 = load float, ptr %1191, align 4, !tbaa !33
  %1193 = getelementptr inbounds %struct.nk_vec2, ptr %75, i32 0, i32 1
  %1194 = load float, ptr %1193, align 4, !tbaa !33
  %1195 = fadd float %1192, %1194
  %1196 = call <2 x float> @nk_vec2(float noundef %1187, float noundef %1195)
  store <2 x float> %1196, ptr %87, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1179, ptr align 4 %87, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %87) #6
  %1197 = load ptr, ptr %30, align 8, !tbaa !5
  %1198 = load i64, ptr %77, align 8, !tbaa !22
  %1199 = mul i64 %1198, 4
  %1200 = add i64 %1199, 1
  %1201 = getelementptr inbounds %struct.nk_vec2, ptr %1197, i64 %1200
  call void @llvm.lifetime.start.p0(i64 8, ptr %88) #6
  %1202 = load ptr, ptr %10, align 8, !tbaa !5
  %1203 = load i64, ptr %77, align 8, !tbaa !22
  %1204 = getelementptr inbounds %struct.nk_vec2, ptr %1202, i64 %1203
  %1205 = getelementptr inbounds %struct.nk_vec2, ptr %1204, i32 0, i32 0
  %1206 = load float, ptr %1205, align 4, !tbaa !32
  %1207 = getelementptr inbounds %struct.nk_vec2, ptr %76, i32 0, i32 0
  %1208 = load float, ptr %1207, align 4, !tbaa !32
  %1209 = fadd float %1206, %1208
  %1210 = load ptr, ptr %10, align 8, !tbaa !5
  %1211 = load i64, ptr %77, align 8, !tbaa !22
  %1212 = getelementptr inbounds %struct.nk_vec2, ptr %1210, i64 %1211
  %1213 = getelementptr inbounds %struct.nk_vec2, ptr %1212, i32 0, i32 1
  %1214 = load float, ptr %1213, align 4, !tbaa !33
  %1215 = getelementptr inbounds %struct.nk_vec2, ptr %76, i32 0, i32 1
  %1216 = load float, ptr %1215, align 4, !tbaa !33
  %1217 = fadd float %1214, %1216
  %1218 = call <2 x float> @nk_vec2(float noundef %1209, float noundef %1217)
  store <2 x float> %1218, ptr %88, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1201, ptr align 4 %88, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %88) #6
  %1219 = load ptr, ptr %30, align 8, !tbaa !5
  %1220 = load i64, ptr %77, align 8, !tbaa !22
  %1221 = mul i64 %1220, 4
  %1222 = add i64 %1221, 2
  %1223 = getelementptr inbounds %struct.nk_vec2, ptr %1219, i64 %1222
  call void @llvm.lifetime.start.p0(i64 8, ptr %89) #6
  %1224 = load ptr, ptr %10, align 8, !tbaa !5
  %1225 = load i64, ptr %77, align 8, !tbaa !22
  %1226 = getelementptr inbounds %struct.nk_vec2, ptr %1224, i64 %1225
  %1227 = getelementptr inbounds %struct.nk_vec2, ptr %1226, i32 0, i32 0
  %1228 = load float, ptr %1227, align 4, !tbaa !32
  %1229 = getelementptr inbounds %struct.nk_vec2, ptr %76, i32 0, i32 0
  %1230 = load float, ptr %1229, align 4, !tbaa !32
  %1231 = fsub float %1228, %1230
  %1232 = load ptr, ptr %10, align 8, !tbaa !5
  %1233 = load i64, ptr %77, align 8, !tbaa !22
  %1234 = getelementptr inbounds %struct.nk_vec2, ptr %1232, i64 %1233
  %1235 = getelementptr inbounds %struct.nk_vec2, ptr %1234, i32 0, i32 1
  %1236 = load float, ptr %1235, align 4, !tbaa !33
  %1237 = getelementptr inbounds %struct.nk_vec2, ptr %76, i32 0, i32 1
  %1238 = load float, ptr %1237, align 4, !tbaa !33
  %1239 = fsub float %1236, %1238
  %1240 = call <2 x float> @nk_vec2(float noundef %1231, float noundef %1239)
  store <2 x float> %1240, ptr %89, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1223, ptr align 4 %89, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %89) #6
  %1241 = load ptr, ptr %30, align 8, !tbaa !5
  %1242 = load i64, ptr %77, align 8, !tbaa !22
  %1243 = mul i64 %1242, 4
  %1244 = add i64 %1243, 3
  %1245 = getelementptr inbounds %struct.nk_vec2, ptr %1241, i64 %1244
  call void @llvm.lifetime.start.p0(i64 8, ptr %90) #6
  %1246 = load ptr, ptr %10, align 8, !tbaa !5
  %1247 = load i64, ptr %77, align 8, !tbaa !22
  %1248 = getelementptr inbounds %struct.nk_vec2, ptr %1246, i64 %1247
  %1249 = getelementptr inbounds %struct.nk_vec2, ptr %1248, i32 0, i32 0
  %1250 = load float, ptr %1249, align 4, !tbaa !32
  %1251 = getelementptr inbounds %struct.nk_vec2, ptr %75, i32 0, i32 0
  %1252 = load float, ptr %1251, align 4, !tbaa !32
  %1253 = fsub float %1250, %1252
  %1254 = load ptr, ptr %10, align 8, !tbaa !5
  %1255 = load i64, ptr %77, align 8, !tbaa !22
  %1256 = getelementptr inbounds %struct.nk_vec2, ptr %1254, i64 %1255
  %1257 = getelementptr inbounds %struct.nk_vec2, ptr %1256, i32 0, i32 1
  %1258 = load float, ptr %1257, align 4, !tbaa !33
  %1259 = getelementptr inbounds %struct.nk_vec2, ptr %75, i32 0, i32 1
  %1260 = load float, ptr %1259, align 4, !tbaa !33
  %1261 = fsub float %1258, %1260
  %1262 = call <2 x float> @nk_vec2(float noundef %1253, float noundef %1261)
  store <2 x float> %1262, ptr %90, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %1245, ptr align 4 %90, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %90) #6
  %1263 = load i64, ptr %78, align 8, !tbaa !22
  %1264 = add i64 %1263, 1
  %1265 = trunc i64 %1264 to i16
  %1266 = load ptr, ptr %27, align 8, !tbaa !5
  %1267 = getelementptr inbounds i16, ptr %1266, i64 0
  store i16 %1265, ptr %1267, align 2, !tbaa !37
  %1268 = load i64, ptr %60, align 8, !tbaa !22
  %1269 = add i64 %1268, 1
  %1270 = trunc i64 %1269 to i16
  %1271 = load ptr, ptr %27, align 8, !tbaa !5
  %1272 = getelementptr inbounds i16, ptr %1271, i64 1
  store i16 %1270, ptr %1272, align 2, !tbaa !37
  %1273 = load i64, ptr %60, align 8, !tbaa !22
  %1274 = add i64 %1273, 2
  %1275 = trunc i64 %1274 to i16
  %1276 = load ptr, ptr %27, align 8, !tbaa !5
  %1277 = getelementptr inbounds i16, ptr %1276, i64 2
  store i16 %1275, ptr %1277, align 2, !tbaa !37
  %1278 = load i64, ptr %60, align 8, !tbaa !22
  %1279 = add i64 %1278, 2
  %1280 = trunc i64 %1279 to i16
  %1281 = load ptr, ptr %27, align 8, !tbaa !5
  %1282 = getelementptr inbounds i16, ptr %1281, i64 3
  store i16 %1280, ptr %1282, align 2, !tbaa !37
  %1283 = load i64, ptr %78, align 8, !tbaa !22
  %1284 = add i64 %1283, 2
  %1285 = trunc i64 %1284 to i16
  %1286 = load ptr, ptr %27, align 8, !tbaa !5
  %1287 = getelementptr inbounds i16, ptr %1286, i64 4
  store i16 %1285, ptr %1287, align 2, !tbaa !37
  %1288 = load i64, ptr %78, align 8, !tbaa !22
  %1289 = add i64 %1288, 1
  %1290 = trunc i64 %1289 to i16
  %1291 = load ptr, ptr %27, align 8, !tbaa !5
  %1292 = getelementptr inbounds i16, ptr %1291, i64 5
  store i16 %1290, ptr %1292, align 2, !tbaa !37
  %1293 = load i64, ptr %78, align 8, !tbaa !22
  %1294 = add i64 %1293, 1
  %1295 = trunc i64 %1294 to i16
  %1296 = load ptr, ptr %27, align 8, !tbaa !5
  %1297 = getelementptr inbounds i16, ptr %1296, i64 6
  store i16 %1295, ptr %1297, align 2, !tbaa !37
  %1298 = load i64, ptr %60, align 8, !tbaa !22
  %1299 = add i64 %1298, 1
  %1300 = trunc i64 %1299 to i16
  %1301 = load ptr, ptr %27, align 8, !tbaa !5
  %1302 = getelementptr inbounds i16, ptr %1301, i64 7
  store i16 %1300, ptr %1302, align 2, !tbaa !37
  %1303 = load i64, ptr %60, align 8, !tbaa !22
  %1304 = add i64 %1303, 0
  %1305 = trunc i64 %1304 to i16
  %1306 = load ptr, ptr %27, align 8, !tbaa !5
  %1307 = getelementptr inbounds i16, ptr %1306, i64 8
  store i16 %1305, ptr %1307, align 2, !tbaa !37
  %1308 = load i64, ptr %60, align 8, !tbaa !22
  %1309 = add i64 %1308, 0
  %1310 = trunc i64 %1309 to i16
  %1311 = load ptr, ptr %27, align 8, !tbaa !5
  %1312 = getelementptr inbounds i16, ptr %1311, i64 9
  store i16 %1310, ptr %1312, align 2, !tbaa !37
  %1313 = load i64, ptr %78, align 8, !tbaa !22
  %1314 = add i64 %1313, 0
  %1315 = trunc i64 %1314 to i16
  %1316 = load ptr, ptr %27, align 8, !tbaa !5
  %1317 = getelementptr inbounds i16, ptr %1316, i64 10
  store i16 %1315, ptr %1317, align 2, !tbaa !37
  %1318 = load i64, ptr %78, align 8, !tbaa !22
  %1319 = add i64 %1318, 1
  %1320 = trunc i64 %1319 to i16
  %1321 = load ptr, ptr %27, align 8, !tbaa !5
  %1322 = getelementptr inbounds i16, ptr %1321, i64 11
  store i16 %1320, ptr %1322, align 2, !tbaa !37
  %1323 = load i64, ptr %78, align 8, !tbaa !22
  %1324 = add i64 %1323, 2
  %1325 = trunc i64 %1324 to i16
  %1326 = load ptr, ptr %27, align 8, !tbaa !5
  %1327 = getelementptr inbounds i16, ptr %1326, i64 12
  store i16 %1325, ptr %1327, align 2, !tbaa !37
  %1328 = load i64, ptr %60, align 8, !tbaa !22
  %1329 = add i64 %1328, 2
  %1330 = trunc i64 %1329 to i16
  %1331 = load ptr, ptr %27, align 8, !tbaa !5
  %1332 = getelementptr inbounds i16, ptr %1331, i64 13
  store i16 %1330, ptr %1332, align 2, !tbaa !37
  %1333 = load i64, ptr %60, align 8, !tbaa !22
  %1334 = add i64 %1333, 3
  %1335 = trunc i64 %1334 to i16
  %1336 = load ptr, ptr %27, align 8, !tbaa !5
  %1337 = getelementptr inbounds i16, ptr %1336, i64 14
  store i16 %1335, ptr %1337, align 2, !tbaa !37
  %1338 = load i64, ptr %60, align 8, !tbaa !22
  %1339 = add i64 %1338, 3
  %1340 = trunc i64 %1339 to i16
  %1341 = load ptr, ptr %27, align 8, !tbaa !5
  %1342 = getelementptr inbounds i16, ptr %1341, i64 15
  store i16 %1340, ptr %1342, align 2, !tbaa !37
  %1343 = load i64, ptr %78, align 8, !tbaa !22
  %1344 = add i64 %1343, 3
  %1345 = trunc i64 %1344 to i16
  %1346 = load ptr, ptr %27, align 8, !tbaa !5
  %1347 = getelementptr inbounds i16, ptr %1346, i64 16
  store i16 %1345, ptr %1347, align 2, !tbaa !37
  %1348 = load i64, ptr %78, align 8, !tbaa !22
  %1349 = add i64 %1348, 2
  %1350 = trunc i64 %1349 to i16
  %1351 = load ptr, ptr %27, align 8, !tbaa !5
  %1352 = getelementptr inbounds i16, ptr %1351, i64 17
  store i16 %1350, ptr %1352, align 2, !tbaa !37
  %1353 = load ptr, ptr %27, align 8, !tbaa !5
  %1354 = getelementptr inbounds i16, ptr %1353, i64 18
  store ptr %1354, ptr %27, align 8, !tbaa !5
  %1355 = load i64, ptr %78, align 8, !tbaa !22
  store i64 %1355, ptr %60, align 8, !tbaa !22
  call void @llvm.lifetime.end.p0(i64 4, ptr %82) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %79) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %78) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %77) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %76) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %75) #6
  br label %1356

1356:                                             ; preds = %1154
  %1357 = load i64, ptr %21, align 8, !tbaa !22
  %1358 = add i64 %1357, 1
  store i64 %1358, ptr %21, align 8, !tbaa !22
  br label %1042, !llvm.loop !41

1359:                                             ; preds = %1042
  store i64 0, ptr %61, align 8, !tbaa !22
  br label %1360

1360:                                             ; preds = %1430, %1359
  %1361 = load i64, ptr %61, align 8, !tbaa !22
  %1362 = load i32, ptr %11, align 4, !tbaa !9
  %1363 = zext i32 %1362 to i64
  %1364 = icmp ult i64 %1361, %1363
  br i1 %1364, label %1365, label %1433

1365:                                             ; preds = %1360
  call void @llvm.lifetime.start.p0(i64 8, ptr %91) #6
  %1366 = load ptr, ptr %9, align 8, !tbaa !5
  %1367 = getelementptr inbounds %struct.nk_draw_list, ptr %1366, i32 0, i32 2
  %1368 = getelementptr inbounds %struct.nk_convert_config, ptr %1367, i32 0, i32 6
  %1369 = getelementptr inbounds %struct.nk_draw_null_texture, ptr %1368, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %91, ptr align 8 %1369, i64 8, i1 false), !tbaa.struct !34
  %1370 = load ptr, ptr %26, align 8, !tbaa !5
  %1371 = load ptr, ptr %9, align 8, !tbaa !5
  %1372 = getelementptr inbounds %struct.nk_draw_list, ptr %1371, i32 0, i32 2
  %1373 = load ptr, ptr %30, align 8, !tbaa !5
  %1374 = load i64, ptr %61, align 8, !tbaa !22
  %1375 = mul i64 %1374, 4
  %1376 = add i64 %1375, 0
  %1377 = getelementptr inbounds %struct.nk_vec2, ptr %1373, i64 %1376
  %1378 = load <2 x float>, ptr %1377, align 4
  %1379 = load <2 x float>, ptr %91, align 4
  %1380 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %18, i32 0, i32 0
  %1381 = load <2 x float>, ptr %1380, align 4
  %1382 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %18, i32 0, i32 1
  %1383 = load <2 x float>, ptr %1382, align 4
  %1384 = call ptr @nk_draw_vertex(ptr noundef %1370, ptr noundef %1372, <2 x float> %1378, <2 x float> %1379, <2 x float> %1381, <2 x float> %1383)
  store ptr %1384, ptr %26, align 8, !tbaa !5
  %1385 = load ptr, ptr %26, align 8, !tbaa !5
  %1386 = load ptr, ptr %9, align 8, !tbaa !5
  %1387 = getelementptr inbounds %struct.nk_draw_list, ptr %1386, i32 0, i32 2
  %1388 = load ptr, ptr %30, align 8, !tbaa !5
  %1389 = load i64, ptr %61, align 8, !tbaa !22
  %1390 = mul i64 %1389, 4
  %1391 = add i64 %1390, 1
  %1392 = getelementptr inbounds %struct.nk_vec2, ptr %1388, i64 %1391
  %1393 = load <2 x float>, ptr %1392, align 4
  %1394 = load <2 x float>, ptr %91, align 4
  %1395 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %17, i32 0, i32 0
  %1396 = load <2 x float>, ptr %1395, align 4
  %1397 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %17, i32 0, i32 1
  %1398 = load <2 x float>, ptr %1397, align 4
  %1399 = call ptr @nk_draw_vertex(ptr noundef %1385, ptr noundef %1387, <2 x float> %1393, <2 x float> %1394, <2 x float> %1396, <2 x float> %1398)
  store ptr %1399, ptr %26, align 8, !tbaa !5
  %1400 = load ptr, ptr %26, align 8, !tbaa !5
  %1401 = load ptr, ptr %9, align 8, !tbaa !5
  %1402 = getelementptr inbounds %struct.nk_draw_list, ptr %1401, i32 0, i32 2
  %1403 = load ptr, ptr %30, align 8, !tbaa !5
  %1404 = load i64, ptr %61, align 8, !tbaa !22
  %1405 = mul i64 %1404, 4
  %1406 = add i64 %1405, 2
  %1407 = getelementptr inbounds %struct.nk_vec2, ptr %1403, i64 %1406
  %1408 = load <2 x float>, ptr %1407, align 4
  %1409 = load <2 x float>, ptr %91, align 4
  %1410 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %17, i32 0, i32 0
  %1411 = load <2 x float>, ptr %1410, align 4
  %1412 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %17, i32 0, i32 1
  %1413 = load <2 x float>, ptr %1412, align 4
  %1414 = call ptr @nk_draw_vertex(ptr noundef %1400, ptr noundef %1402, <2 x float> %1408, <2 x float> %1409, <2 x float> %1411, <2 x float> %1413)
  store ptr %1414, ptr %26, align 8, !tbaa !5
  %1415 = load ptr, ptr %26, align 8, !tbaa !5
  %1416 = load ptr, ptr %9, align 8, !tbaa !5
  %1417 = getelementptr inbounds %struct.nk_draw_list, ptr %1416, i32 0, i32 2
  %1418 = load ptr, ptr %30, align 8, !tbaa !5
  %1419 = load i64, ptr %61, align 8, !tbaa !22
  %1420 = mul i64 %1419, 4
  %1421 = add i64 %1420, 3
  %1422 = getelementptr inbounds %struct.nk_vec2, ptr %1418, i64 %1421
  %1423 = load <2 x float>, ptr %1422, align 4
  %1424 = load <2 x float>, ptr %91, align 4
  %1425 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %18, i32 0, i32 0
  %1426 = load <2 x float>, ptr %1425, align 4
  %1427 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %18, i32 0, i32 1
  %1428 = load <2 x float>, ptr %1427, align 4
  %1429 = call ptr @nk_draw_vertex(ptr noundef %1415, ptr noundef %1417, <2 x float> %1423, <2 x float> %1424, <2 x float> %1426, <2 x float> %1428)
  store ptr %1429, ptr %26, align 8, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 8, ptr %91) #6
  br label %1430

1430:                                             ; preds = %1365
  %1431 = load i64, ptr %61, align 8, !tbaa !22
  %1432 = add i64 %1431, 1
  store i64 %1432, ptr %61, align 8, !tbaa !22
  br label %1360, !llvm.loop !42

1433:                                             ; preds = %1360
  call void @llvm.lifetime.end.p0(i64 4, ptr %62) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %61) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %60) #6
  br label %1434

1434:                                             ; preds = %1433, %784
  %1435 = load ptr, ptr %9, align 8, !tbaa !5
  %1436 = getelementptr inbounds %struct.nk_draw_list, ptr %1435, i32 0, i32 4
  %1437 = load ptr, ptr %1436, align 8, !tbaa !27
  call void @nk_buffer_reset(ptr noundef %1437, i32 noundef 0)
  store i32 0, ptr %19, align 4
  br label %1438

1438:                                             ; preds = %1434, %228, %197
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #6
  call void @llvm.lifetime.end.p0(i64 8, 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 8, 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 4, ptr %20) #6
  %1439 = load i32, ptr %19, align 4
  switch i32 %1439, label %1654 [
    i32 0, label %1440
  ]

1440:                                             ; preds = %1438
  br label %1653

1441:                                             ; preds = %141
  call void @llvm.lifetime.start.p0(i64 8, ptr %92) #6
  store i64 0, ptr %92, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %93) #6
  %1442 = load ptr, ptr %9, align 8, !tbaa !5
  %1443 = getelementptr inbounds %struct.nk_draw_list, ptr %1442, i32 0, i32 7
  %1444 = load i32, ptr %1443, align 4, !tbaa !26
  %1445 = zext i32 %1444 to i64
  store i64 %1445, ptr %93, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %94) #6
  %1446 = load i64, ptr %15, align 8, !tbaa !22
  %1447 = mul i64 %1446, 6
  store i64 %1447, ptr %94, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %95) #6
  %1448 = load i64, ptr %15, align 8, !tbaa !22
  %1449 = mul i64 %1448, 4
  store i64 %1449, ptr %95, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %96) #6
  %1450 = load ptr, ptr %9, align 8, !tbaa !5
  %1451 = load i64, ptr %95, align 8, !tbaa !22
  %1452 = call ptr @nk_draw_list_alloc_vertices(ptr noundef %1450, i64 noundef %1451)
  store ptr %1452, ptr %96, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %97) #6
  %1453 = load ptr, ptr %9, align 8, !tbaa !5
  %1454 = load i64, ptr %94, align 8, !tbaa !22
  %1455 = call ptr @nk_draw_list_alloc_elements(ptr noundef %1453, i64 noundef %1454)
  store ptr %1455, ptr %97, align 8, !tbaa !5
  %1456 = load ptr, ptr %96, align 8, !tbaa !5
  %1457 = icmp ne ptr %1456, null
  br i1 %1457, label %1458, label %1461

1458:                                             ; preds = %1441
  %1459 = load ptr, ptr %97, align 8, !tbaa !5
  %1460 = icmp ne ptr %1459, null
  br i1 %1460, label %1462, label %1461

1461:                                             ; preds = %1458, %1441
  store i32 1, ptr %19, align 4
  br label %1650

1462:                                             ; preds = %1458
  store i64 0, ptr %92, align 8, !tbaa !22
  br label %1463

1463:                                             ; preds = %1646, %1462
  %1464 = load i64, ptr %92, align 8, !tbaa !22
  %1465 = load i64, ptr %15, align 8, !tbaa !22
  %1466 = icmp ult i64 %1464, %1465
  br i1 %1466, label %1467, label %1649

1467:                                             ; preds = %1463
  call void @llvm.lifetime.start.p0(i64 4, ptr %98) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %99) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %100) #6
  %1468 = load ptr, ptr %9, align 8, !tbaa !5
  %1469 = getelementptr inbounds %struct.nk_draw_list, ptr %1468, i32 0, i32 2
  %1470 = getelementptr inbounds %struct.nk_convert_config, ptr %1469, i32 0, i32 6
  %1471 = getelementptr inbounds %struct.nk_draw_null_texture, ptr %1470, i32 0, i32 1
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %100, ptr align 8 %1471, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.start.p0(i64 8, ptr %101) #6
  %1472 = load i64, ptr %92, align 8, !tbaa !22
  %1473 = add i64 %1472, 1
  %1474 = load i32, ptr %11, align 4, !tbaa !9
  %1475 = zext i32 %1474 to i64
  %1476 = icmp eq i64 %1473, %1475
  br i1 %1476, label %1477, label %1478

1477:                                             ; preds = %1467
  br label %1481

1478:                                             ; preds = %1467
  %1479 = load i64, ptr %92, align 8, !tbaa !22
  %1480 = add i64 %1479, 1
  br label %1481

1481:                                             ; preds = %1478, %1477
  %1482 = phi i64 [ 0, %1477 ], [ %1480, %1478 ]
  store i64 %1482, ptr %101, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %102) #6
  %1483 = load ptr, ptr %10, align 8, !tbaa !5
  %1484 = load i64, ptr %92, align 8, !tbaa !22
  %1485 = getelementptr inbounds %struct.nk_vec2, ptr %1483, i64 %1484
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %102, ptr align 4 %1485, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.start.p0(i64 8, ptr %103) #6
  %1486 = load ptr, ptr %10, align 8, !tbaa !5
  %1487 = load i64, ptr %101, align 8, !tbaa !22
  %1488 = getelementptr inbounds %struct.nk_vec2, ptr %1486, i64 %1487
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %103, ptr align 4 %1488, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.start.p0(i64 8, ptr %104) #6
  %1489 = getelementptr inbounds %struct.nk_vec2, ptr %103, i32 0, i32 0
  %1490 = load float, ptr %1489, align 4, !tbaa !32
  %1491 = getelementptr inbounds %struct.nk_vec2, ptr %102, i32 0, i32 0
  %1492 = load float, ptr %1491, align 4, !tbaa !32
  %1493 = fsub float %1490, %1492
  %1494 = getelementptr inbounds %struct.nk_vec2, ptr %103, i32 0, i32 1
  %1495 = load float, ptr %1494, align 4, !tbaa !33
  %1496 = getelementptr inbounds %struct.nk_vec2, ptr %102, i32 0, i32 1
  %1497 = load float, ptr %1496, align 4, !tbaa !33
  %1498 = fsub float %1495, %1497
  %1499 = call <2 x float> @nk_vec2(float noundef %1493, float noundef %1498)
  store <2 x float> %1499, ptr %104, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %105) #6
  %1500 = getelementptr inbounds %struct.nk_vec2, ptr %104, i32 0, i32 0
  %1501 = load float, ptr %1500, align 4, !tbaa !32
  %1502 = getelementptr inbounds %struct.nk_vec2, ptr %104, i32 0, i32 0
  %1503 = load float, ptr %1502, align 4, !tbaa !32
  %1504 = getelementptr inbounds %struct.nk_vec2, ptr %104, i32 0, i32 1
  %1505 = load float, ptr %1504, align 4, !tbaa !33
  %1506 = getelementptr inbounds %struct.nk_vec2, ptr %104, i32 0, i32 1
  %1507 = load float, ptr %1506, align 4, !tbaa !33
  %1508 = fmul float %1505, %1507
  %1509 = call float @llvm.fmuladd.f32(float %1501, float %1503, float %1508)
  store float %1509, ptr %105, align 4, !tbaa !11
  %1510 = load float, ptr %105, align 4, !tbaa !11
  %1511 = fcmp une float %1510, 0.000000e+00
  br i1 %1511, label %1512, label %1515

1512:                                             ; preds = %1481
  %1513 = load float, ptr %105, align 4, !tbaa !11
  %1514 = call float @nk_inv_sqrt(float noundef %1513)
  store float %1514, ptr %105, align 4, !tbaa !11
  br label %1516

1515:                                             ; preds = %1481
  store float 1.000000e+00, ptr %105, align 4, !tbaa !11
  br label %1516

1516:                                             ; preds = %1515, %1512
  call void @llvm.lifetime.start.p0(i64 8, ptr %106) #6
  %1517 = getelementptr inbounds %struct.nk_vec2, ptr %104, i32 0, i32 0
  %1518 = load float, ptr %1517, align 4, !tbaa !32
  %1519 = load float, ptr %105, align 4, !tbaa !11
  %1520 = fmul float %1518, %1519
  %1521 = getelementptr inbounds %struct.nk_vec2, ptr %104, i32 0, i32 1
  %1522 = load float, ptr %1521, align 4, !tbaa !33
  %1523 = load float, ptr %105, align 4, !tbaa !11
  %1524 = fmul float %1522, %1523
  %1525 = call <2 x float> @nk_vec2(float noundef %1520, float noundef %1524)
  store <2 x float> %1525, ptr %106, align 4
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %104, ptr align 4 %106, i64 8, i1 false), !tbaa.struct !34
  call void @llvm.lifetime.end.p0(i64 8, ptr %106) #6
  %1526 = getelementptr inbounds %struct.nk_vec2, ptr %104, i32 0, i32 0
  %1527 = load float, ptr %1526, align 4, !tbaa !32
  %1528 = load float, ptr %13, align 4, !tbaa !11
  %1529 = fmul float %1528, 5.000000e-01
  %1530 = fmul float %1527, %1529
  store float %1530, ptr %98, align 4, !tbaa !11
  %1531 = getelementptr inbounds %struct.nk_vec2, ptr %104, i32 0, i32 1
  %1532 = load float, ptr %1531, align 4, !tbaa !33
  %1533 = load float, ptr %13, align 4, !tbaa !11
  %1534 = fmul float %1533, 5.000000e-01
  %1535 = fmul float %1532, %1534
  store float %1535, ptr %99, align 4, !tbaa !11
  %1536 = load ptr, ptr %96, align 8, !tbaa !5
  %1537 = load ptr, ptr %9, align 8, !tbaa !5
  %1538 = getelementptr inbounds %struct.nk_draw_list, ptr %1537, i32 0, i32 2
  %1539 = getelementptr inbounds %struct.nk_vec2, ptr %102, i32 0, i32 0
  %1540 = load float, ptr %1539, align 4, !tbaa !32
  %1541 = load float, ptr %99, align 4, !tbaa !11
  %1542 = fadd float %1540, %1541
  %1543 = getelementptr inbounds %struct.nk_vec2, ptr %102, i32 0, i32 1
  %1544 = load float, ptr %1543, align 4, !tbaa !33
  %1545 = load float, ptr %98, align 4, !tbaa !11
  %1546 = fsub float %1544, %1545
  %1547 = call <2 x float> @nk_vec2(float noundef %1542, float noundef %1546)
  store <2 x float> %1547, ptr %107, align 4
  %1548 = load <2 x float>, ptr %107, align 4
  %1549 = load <2 x float>, ptr %100, align 4
  %1550 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %17, i32 0, i32 0
  %1551 = load <2 x float>, ptr %1550, align 4
  %1552 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %17, i32 0, i32 1
  %1553 = load <2 x float>, ptr %1552, align 4
  %1554 = call ptr @nk_draw_vertex(ptr noundef %1536, ptr noundef %1538, <2 x float> %1548, <2 x float> %1549, <2 x float> %1551, <2 x float> %1553)
  store ptr %1554, ptr %96, align 8, !tbaa !5
  %1555 = load ptr, ptr %96, align 8, !tbaa !5
  %1556 = load ptr, ptr %9, align 8, !tbaa !5
  %1557 = getelementptr inbounds %struct.nk_draw_list, ptr %1556, i32 0, i32 2
  %1558 = getelementptr inbounds %struct.nk_vec2, ptr %103, i32 0, i32 0
  %1559 = load float, ptr %1558, align 4, !tbaa !32
  %1560 = load float, ptr %99, align 4, !tbaa !11
  %1561 = fadd float %1559, %1560
  %1562 = getelementptr inbounds %struct.nk_vec2, ptr %103, i32 0, i32 1
  %1563 = load float, ptr %1562, align 4, !tbaa !33
  %1564 = load float, ptr %98, align 4, !tbaa !11
  %1565 = fsub float %1563, %1564
  %1566 = call <2 x float> @nk_vec2(float noundef %1561, float noundef %1565)
  store <2 x float> %1566, ptr %108, align 4
  %1567 = load <2 x float>, ptr %108, align 4
  %1568 = load <2 x float>, ptr %100, align 4
  %1569 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %17, i32 0, i32 0
  %1570 = load <2 x float>, ptr %1569, align 4
  %1571 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %17, i32 0, i32 1
  %1572 = load <2 x float>, ptr %1571, align 4
  %1573 = call ptr @nk_draw_vertex(ptr noundef %1555, ptr noundef %1557, <2 x float> %1567, <2 x float> %1568, <2 x float> %1570, <2 x float> %1572)
  store ptr %1573, ptr %96, align 8, !tbaa !5
  %1574 = load ptr, ptr %96, align 8, !tbaa !5
  %1575 = load ptr, ptr %9, align 8, !tbaa !5
  %1576 = getelementptr inbounds %struct.nk_draw_list, ptr %1575, i32 0, i32 2
  %1577 = getelementptr inbounds %struct.nk_vec2, ptr %103, i32 0, i32 0
  %1578 = load float, ptr %1577, align 4, !tbaa !32
  %1579 = load float, ptr %99, align 4, !tbaa !11
  %1580 = fsub float %1578, %1579
  %1581 = getelementptr inbounds %struct.nk_vec2, ptr %103, i32 0, i32 1
  %1582 = load float, ptr %1581, align 4, !tbaa !33
  %1583 = load float, ptr %98, align 4, !tbaa !11
  %1584 = fadd float %1582, %1583
  %1585 = call <2 x float> @nk_vec2(float noundef %1580, float noundef %1584)
  store <2 x float> %1585, ptr %109, align 4
  %1586 = load <2 x float>, ptr %109, align 4
  %1587 = load <2 x float>, ptr %100, align 4
  %1588 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %17, i32 0, i32 0
  %1589 = load <2 x float>, ptr %1588, align 4
  %1590 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %17, i32 0, i32 1
  %1591 = load <2 x float>, ptr %1590, align 4
  %1592 = call ptr @nk_draw_vertex(ptr noundef %1574, ptr noundef %1576, <2 x float> %1586, <2 x float> %1587, <2 x float> %1589, <2 x float> %1591)
  store ptr %1592, ptr %96, align 8, !tbaa !5
  %1593 = load ptr, ptr %96, align 8, !tbaa !5
  %1594 = load ptr, ptr %9, align 8, !tbaa !5
  %1595 = getelementptr inbounds %struct.nk_draw_list, ptr %1594, i32 0, i32 2
  %1596 = getelementptr inbounds %struct.nk_vec2, ptr %102, i32 0, i32 0
  %1597 = load float, ptr %1596, align 4, !tbaa !32
  %1598 = load float, ptr %99, align 4, !tbaa !11
  %1599 = fsub float %1597, %1598
  %1600 = getelementptr inbounds %struct.nk_vec2, ptr %102, i32 0, i32 1
  %1601 = load float, ptr %1600, align 4, !tbaa !33
  %1602 = load float, ptr %98, align 4, !tbaa !11
  %1603 = fadd float %1601, %1602
  %1604 = call <2 x float> @nk_vec2(float noundef %1599, float noundef %1603)
  store <2 x float> %1604, ptr %110, align 4
  %1605 = load <2 x float>, ptr %110, align 4
  %1606 = load <2 x float>, ptr %100, align 4
  %1607 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %17, i32 0, i32 0
  %1608 = load <2 x float>, ptr %1607, align 4
  %1609 = getelementptr inbounds { <2 x float>, <2 x float> }, ptr %17, i32 0, i32 1
  %1610 = load <2 x float>, ptr %1609, align 4
  %1611 = call ptr @nk_draw_vertex(ptr noundef %1593, ptr noundef %1595, <2 x float> %1605, <2 x float> %1606, <2 x float> %1608, <2 x float> %1610)
  store ptr %1611, ptr %96, align 8, !tbaa !5
  %1612 = load i64, ptr %93, align 8, !tbaa !22
  %1613 = add i64 %1612, 0
  %1614 = trunc i64 %1613 to i16
  %1615 = load ptr, ptr %97, align 8, !tbaa !5
  %1616 = getelementptr inbounds i16, ptr %1615, i64 0
  store i16 %1614, ptr %1616, align 2, !tbaa !37
  %1617 = load i64, ptr %93, align 8, !tbaa !22
  %1618 = add i64 %1617, 1
  %1619 = trunc i64 %1618 to i16
  %1620 = load ptr, ptr %97, align 8, !tbaa !5
  %1621 = getelementptr inbounds i16, ptr %1620, i64 1
  store i16 %1619, ptr %1621, align 2, !tbaa !37
  %1622 = load i64, ptr %93, align 8, !tbaa !22
  %1623 = add i64 %1622, 2
  %1624 = trunc i64 %1623 to i16
  %1625 = load ptr, ptr %97, align 8, !tbaa !5
  %1626 = getelementptr inbounds i16, ptr %1625, i64 2
  store i16 %1624, ptr %1626, align 2, !tbaa !37
  %1627 = load i64, ptr %93, align 8, !tbaa !22
  %1628 = add i64 %1627, 0
  %1629 = trunc i64 %1628 to i16
  %1630 = load ptr, ptr %97, align 8, !tbaa !5
  %1631 = getelementptr inbounds i16, ptr %1630, i64 3
  store i16 %1629, ptr %1631, align 2, !tbaa !37
  %1632 = load i64, ptr %93, align 8, !tbaa !22
  %1633 = add i64 %1632, 2
  %1634 = trunc i64 %1633 to i16
  %1635 = load ptr, ptr %97, align 8, !tbaa !5
  %1636 = getelementptr inbounds i16, ptr %1635, i64 4
  store i16 %1634, ptr %1636, align 2, !tbaa !37
  %1637 = load i64, ptr %93, align 8, !tbaa !22
  %1638 = add i64 %1637, 3
  %1639 = trunc i64 %1638 to i16
  %1640 = load ptr, ptr %97, align 8, !tbaa !5
  %1641 = getelementptr inbounds i16, ptr %1640, i64 5
  store i16 %1639, ptr %1641, align 2, !tbaa !37
  %1642 = load ptr, ptr %97, align 8, !tbaa !5
  %1643 = getelementptr inbounds i16, ptr %1642, i64 6
  store ptr %1643, ptr %97, align 8, !tbaa !5
  %1644 = load i64, ptr %93, align 8, !tbaa !22
  %1645 = add i64 %1644, 4
  store i64 %1645, ptr %93, align 8, !tbaa !22
  call void @llvm.lifetime.end.p0(i64 4, ptr %105) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %104) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %103) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %102) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %101) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %100) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %99) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %98) #6
  br label %1646

1646:                                             ; preds = %1516
  %1647 = load i64, ptr %92, align 8, !tbaa !22
  %1648 = add i64 %1647, 1
  store i64 %1648, ptr %92, align 8, !tbaa !22
  br label %1463, !llvm.loop !43

1649:                                             ; preds = %1463
  store i32 0, ptr %19, align 4
  br label %1650

1650:                                             ; preds = %1649, %1461
  call void @llvm.lifetime.end.p0(i64 8, ptr %97) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %96) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %95) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %94) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %93) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %92) #6
  %1651 = load i32, ptr %19, align 4
  switch i32 %1651, label %1654 [
    i32 0, label %1652
  ]

1652:                                             ; preds = %1650
  br label %1653

1653:                                             ; preds = %1652, %1440
  store i32 0, ptr %19, align 4
  br label %1654

1654:                                             ; preds = %1653, %1650, %1438, %121
  call void @llvm.lifetime.end.p0(i64 16, ptr %18) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %17) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #6
  %1655 = load i32, ptr %19, align 4
  switch i32 %1655, label %1657 [
    i32 0, label %1656
    i32 1, label %1656
  ]

1656:                                             ; preds = %1654, %1654
  ret void

1657:                                             ; preds = %1654
  unreachable
}

; Function Attrs: nounwind uwtable
declare hidden ptr @nk_draw_list_alloc_vertices(ptr noundef, i64 noundef) #5

; Function Attrs: nounwind uwtable
declare hidden ptr @nk_draw_list_alloc_elements(ptr noundef, i64 noundef) #5

; Function Attrs: nounwind uwtable
declare hidden float @nk_inv_sqrt(float noundef) #5

; Function Attrs: nounwind uwtable
declare hidden ptr @nk_draw_vertex(ptr noundef, ptr noundef, <2 x float>, <2 x float>, <2 x float>, <2 x float>) #2

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !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 = !{!"int", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"float", !7, i64 0}
!13 = !{!14, !7, i64 3}
!14 = !{!"nk_color", !7, i64 0, !7, i64 1, !7, i64 2, !7, i64 3}
!15 = !{!16, !12, i64 112}
!16 = !{!"nk_draw_list", !17, i64 0, !7, i64 16, !18, i64 112, !6, i64 176, !6, i64 184, !6, i64 192, !10, i64 200, !10, i64 204, !10, i64 208, !21, i64 216, !10, i64 224, !10, i64 228, !10, i64 232, !10, i64 236}
!17 = !{!"nk_rect", !12, i64 0, !12, i64 4, !12, i64 8, !12, i64 12}
!18 = !{!"nk_convert_config", !12, i64 0, !10, i64 4, !10, i64 8, !10, i64 12, !10, i64 16, !10, i64 20, !19, i64 24, !6, i64 40, !21, i64 48, !21, i64 56}
!19 = !{!"nk_draw_null_texture", !7, i64 0, !20, i64 8}
!20 = !{!"nk_vec2", !12, i64 0, !12, i64 4}
!21 = !{!"long", !7, i64 0}
!22 = !{!21, !21, i64 0}
!23 = !{i64 0, i64 4, !11, i64 4, i64 4, !11, i64 8, i64 4, !11, i64 12, i64 4, !11}
!24 = !{!25, !12, i64 12}
!25 = !{!"nk_colorf", !12, i64 0, !12, i64 4, !12, i64 8, !12, i64 12}
!26 = !{!16, !10, i64 204}
!27 = !{!16, !6, i64 184}
!28 = !{!29, !6, i64 64}
!29 = !{!"nk_buffer", !7, i64 0, !30, i64 32, !10, i64 56, !31, i64 64, !12, i64 80, !21, i64 88, !21, i64 96, !21, i64 104, !21, i64 112}
!30 = !{!"nk_allocator", !7, i64 0, !6, i64 8, !6, i64 16}
!31 = !{!"nk_memory", !6, i64 0, !21, i64 8}
!32 = !{!20, !12, i64 0}
!33 = !{!20, !12, i64 4}
!34 = !{i64 0, i64 4, !11, i64 4, i64 4, !11}
!35 = distinct !{!35, !36}
!36 = !{!"llvm.loop.mustprogress"}
!37 = !{!38, !38, i64 0}
!38 = !{!"short", !7, i64 0}
!39 = distinct !{!39, !36}
!40 = distinct !{!40, !36}
!41 = distinct !{!41, !36}
!42 = distinct !{!42, !36}
!43 = distinct !{!43, !36}


; 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.nk_colorf = type { float, float, float, float }
%struct.nk_vec2 = type { float, float }

@.str.2 = external hidden unnamed_addr constant [103 x i8], align 1
@.str.26 = external hidden unnamed_addr constant [5 x i8], align 1
@__PRETTY_FUNCTION__.nk_draw_list_stroke_poly_line = external hidden unnamed_addr constant [175 x i8], align 1

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

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

; Function Attrs: nounwind uwtable
declare dso_local <2 x float> @nk_vec2(float noundef, float noundef) local_unnamed_addr #1

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

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

; Function Attrs: nounwind uwtable
declare dso_local void @nk_color_fv(ptr noundef, i32) local_unnamed_addr #4

; Function Attrs: nounwind uwtable
declare hidden ptr @nk_buffer_alloc(ptr noundef, i32 noundef, i64 noundef, i64 noundef) local_unnamed_addr #4

; Function Attrs: nounwind uwtable
declare dso_local void @nk_buffer_mark(ptr noundef, i32 noundef) local_unnamed_addr #4

; Function Attrs: nounwind uwtable
declare dso_local void @nk_buffer_reset(ptr noundef, i32 noundef) local_unnamed_addr #4

; Function Attrs: nounwind uwtable
define dso_local void @nk_draw_list_stroke_poly_line(ptr noundef %0, ptr nocapture noundef readonly %1, i32 noundef %2, i32 %3, i32 noundef %4, float noundef %5, i32 noundef %6) local_unnamed_addr #1 {
  %8 = alloca %struct.nk_colorf, align 8
  %.sroa.2.0.extract.shift = lshr i32 %3, 24
  %.sroa.2.0.extract.trunc = trunc nuw i32 %.sroa.2.0.extract.shift to i8
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %8) #6
  %.not = icmp eq ptr %0, null
  br i1 %.not, label %9, label %10

9:                                                ; preds = %7
  tail call void @__assert_fail(ptr noundef nonnull @.str.26, ptr noundef nonnull @.str.2, i32 noundef 9632, ptr noundef nonnull @__PRETTY_FUNCTION__.nk_draw_list_stroke_poly_line) #7
  unreachable

10:                                               ; preds = %7
  %11 = icmp ult i32 %2, 2
  br i1 %11, label %.critedge630, label %12

12:                                               ; preds = %10
  %13 = uitofp i8 %.sroa.2.0.extract.trunc to float
  %14 = getelementptr inbounds i8, ptr %0, i64 112
  %15 = load float, ptr %14, align 8, !tbaa !5
  %16 = fmul float %15, %13
  %17 = fptoui float %16 to i8
  %18 = zext i32 %2 to i64
  %.not627 = icmp eq i32 %4, 0
  %19 = add i32 %2, -1
  %20 = zext i32 %19 to i64
  %.0 = select i1 %.not627, i64 %20, i64 %18
  %21 = fcmp ogt float %5, 1.000000e+00
  %22 = uitofp i8 %17 to float
  %23 = fmul float %15, %22
  %24 = fptoui float %23 to i8
  %.sroa.2.0.insert.ext = zext i8 %24 to i32
  %.sroa.2.0.insert.shift = shl nuw i32 %.sroa.2.0.insert.ext, 24
  %.sroa.0596.0.insert.ext = and i32 %3, 16777215
  %.sroa.0596.0.insert.insert = or disjoint i32 %.sroa.2.0.insert.shift, %.sroa.0596.0.insert.ext
  call void @nk_color_fv(ptr noundef nonnull %8, i32 %.sroa.0596.0.insert.insert)
  %.sroa.0455.0.copyload = load <2 x float>, ptr %8, align 8
  %.sroa.7.0..sroa_idx = getelementptr inbounds i8, ptr %8, i64 8
  %.sroa.7.0.copyload = load <2 x float>, ptr %.sroa.7.0..sroa_idx, align 8
  %.sroa.7.12.vec.insert = insertelement <2 x float> %.sroa.7.0.copyload, float 0.000000e+00, i64 1
  %25 = icmp eq i32 %6, 1
  %26 = getelementptr inbounds i8, ptr %0, i64 204
  %27 = load i32, ptr %26, align 4, !tbaa !17
  br i1 %25, label %28, label %436

28:                                               ; preds = %12
  %29 = zext i32 %27 to i64
  %.v = select i1 %21, i64 18, i64 12
  %30 = mul nuw nsw i64 %.v, %.0
  %31 = shl i32 %2, 2
  %32 = mul i32 %2, 3
  %33 = select i1 %21, i32 %31, i32 %32
  %34 = zext i32 %33 to i64
  %35 = call ptr @nk_draw_list_alloc_vertices(ptr noundef nonnull %0, i64 noundef %34)
  %36 = call ptr @nk_draw_list_alloc_elements(ptr noundef nonnull %0, i64 noundef %30)
  %37 = icmp ne ptr %35, null
  %38 = icmp ne ptr %36, null
  %or.cond4 = select i1 %37, i1 %38, i1 false
  br i1 %or.cond4, label %39, label %.critedge630

39:                                               ; preds = %28
  %40 = getelementptr inbounds i8, ptr %0, i64 184
  %41 = load ptr, ptr %40, align 8, !tbaa !18
  %42 = getelementptr inbounds i8, ptr %41, i64 64
  %43 = load ptr, ptr %42, align 8, !tbaa !19
  call void @nk_buffer_mark(ptr noundef %41, i32 noundef 0)
  %44 = select i1 %21, i64 40, i64 24
  %45 = mul nuw nsw i64 %44, %18
  %46 = load ptr, ptr %40, align 8, !tbaa !18
  %47 = call ptr @nk_buffer_alloc(ptr noundef %46, i32 noundef 0, i64 noundef %45, i64 noundef 4)
  %.not628 = icmp eq ptr %47, null
  br i1 %.not628, label %.critedge630, label %.lr.ph640.preheader

.lr.ph640.preheader:                              ; preds = %39
  %48 = ptrtoint ptr %35 to i64
  %49 = ptrtoint ptr %43 to i64
  %50 = sub i64 %48, %49
  %51 = getelementptr inbounds %struct.nk_vec2, ptr %47, i64 %18
  %52 = load ptr, ptr %40, align 8, !tbaa !18
  %53 = getelementptr inbounds i8, ptr %52, i64 64
  %54 = load ptr, ptr %53, align 8, !tbaa !19
  %55 = getelementptr inbounds i8, ptr %54, i64 %50
  br label %.lr.ph640

.lr.ph640:                                        ; preds = %.lr.ph640.preheader, %75
  %.0599639 = phi i64 [ %56, %75 ], [ 0, %.lr.ph640.preheader ]
  %56 = add nuw nsw i64 %.0599639, 1
  %57 = icmp eq i64 %56, %18
  %58 = select i1 %57, i64 0, i64 %56
  %59 = getelementptr inbounds %struct.nk_vec2, ptr %1, i64 %58
  %60 = load float, ptr %59, align 4, !tbaa !23
  %61 = getelementptr inbounds %struct.nk_vec2, ptr %1, i64 %.0599639
  %62 = load float, ptr %61, align 4, !tbaa !23
  %63 = fsub float %60, %62
  %64 = getelementptr inbounds i8, ptr %59, i64 4
  %65 = load float, ptr %64, align 4, !tbaa !24
  %66 = getelementptr inbounds i8, ptr %61, i64 4
  %67 = load float, ptr %66, align 4, !tbaa !24
  %68 = fsub float %65, %67
  %69 = call <2 x float> @nk_vec2(float noundef %63, float noundef %68)
  %.sroa.0298.0.vec.extract = extractelement <2 x float> %69, i64 0
  %.sroa.0298.4.vec.extract = extractelement <2 x float> %69, i64 1
  %70 = fmul float %.sroa.0298.4.vec.extract, %.sroa.0298.4.vec.extract
  %71 = call float @llvm.fmuladd.f32(float %.sroa.0298.0.vec.extract, float %.sroa.0298.0.vec.extract, float %70)
  %72 = fcmp une float %71, 0.000000e+00
  br i1 %72, label %73, label %75

73:                                               ; preds = %.lr.ph640
  %74 = call float @nk_inv_sqrt(float noundef %71)
  br label %75

75:                                               ; preds = %.lr.ph640, %73
  %.0606 = phi float [ %74, %73 ], [ 1.000000e+00, %.lr.ph640 ]
  %76 = fmul float %.sroa.0298.0.vec.extract, %.0606
  %77 = fmul float %.sroa.0298.4.vec.extract, %.0606
  %78 = call <2 x float> @nk_vec2(float noundef %76, float noundef %77)
  %.sroa.0298.4.vec.extract310 = extractelement <2 x float> %78, i64 1
  %79 = getelementptr inbounds %struct.nk_vec2, ptr %47, i64 %.0599639
  store float %.sroa.0298.4.vec.extract310, ptr %79, align 4, !tbaa !23
  %.sroa.0298.0.vec.extract304 = extractelement <2 x float> %78, i64 0
  %80 = fneg float %.sroa.0298.0.vec.extract304
  %81 = getelementptr inbounds i8, ptr %79, i64 4
  store float %80, ptr %81, align 4, !tbaa !24
  %exitcond659.not = icmp eq i64 %56, %.0
  br i1 %exitcond659.not, label %._crit_edge, label %.lr.ph640, !llvm.loop !25

._crit_edge:                                      ; preds = %75
  br i1 %.not627, label %82, label %.thread

82:                                               ; preds = %._crit_edge
  %83 = getelementptr inbounds %struct.nk_vec2, ptr %47, i64 %20
  %84 = add i32 %2, -2
  %85 = zext i32 %84 to i64
  %86 = getelementptr inbounds %struct.nk_vec2, ptr %47, i64 %85
  %87 = load i64, ptr %86, align 4
  store i64 %87, ptr %83, align 4
  br i1 %21, label %226, label %90

.thread:                                          ; preds = %._crit_edge
  br i1 %21, label %.thread632, label %.lr.ph644.preheader

.lr.ph644.preheader:                              ; preds = %90, %.thread
  br label %.lr.ph644

.thread632:                                       ; preds = %.thread
  %88 = fadd float %5, -1.000000e+00
  %89 = fmul float %88, 5.000000e-01
  br label %.lr.ph651

90:                                               ; preds = %82
  %91 = load float, ptr %1, align 4, !tbaa !23
  %92 = load float, ptr %47, align 4, !tbaa !23
  %93 = getelementptr inbounds i8, ptr %47, i64 4
  %94 = load float, ptr %93, align 4, !tbaa !24
  %95 = call <2 x float> @nk_vec2(float noundef %92, float noundef %94)
  %.sroa.0274.0.vec.extract = extractelement <2 x float> %95, i64 0
  %96 = fadd float %91, %.sroa.0274.0.vec.extract
  %97 = getelementptr inbounds i8, ptr %1, i64 4
  %98 = load float, ptr %97, align 4, !tbaa !24
  %99 = load float, ptr %47, align 4, !tbaa !23
  %100 = load float, ptr %93, align 4, !tbaa !24
  %101 = call <2 x float> @nk_vec2(float noundef %99, float noundef %100)
  %.sroa.0273.4.vec.extract = extractelement <2 x float> %101, i64 1
  %102 = fadd float %98, %.sroa.0273.4.vec.extract
  %103 = call <2 x float> @nk_vec2(float noundef %96, float noundef %102)
  store <2 x float> %103, ptr %51, align 4
  %104 = getelementptr inbounds i8, ptr %51, i64 8
  %105 = load float, ptr %1, align 4, !tbaa !23
  %106 = load float, ptr %47, align 4, !tbaa !23
  %107 = load float, ptr %93, align 4, !tbaa !24
  %108 = call <2 x float> @nk_vec2(float noundef %106, float noundef %107)
  %.sroa.0271.0.vec.extract = extractelement <2 x float> %108, i64 0
  %109 = fsub float %105, %.sroa.0271.0.vec.extract
  %110 = load float, ptr %97, align 4, !tbaa !24
  %111 = load float, ptr %47, align 4, !tbaa !23
  %112 = load float, ptr %93, align 4, !tbaa !24
  %113 = call <2 x float> @nk_vec2(float noundef %111, float noundef %112)
  %.sroa.0270.4.vec.extract = extractelement <2 x float> %113, i64 1
  %114 = fsub float %110, %.sroa.0270.4.vec.extract
  %115 = call <2 x float> @nk_vec2(float noundef %109, float noundef %114)
  store <2 x float> %115, ptr %104, align 4
  %116 = load float, ptr %83, align 4, !tbaa !23
  %117 = getelementptr inbounds i8, ptr %83, i64 4
  %118 = load float, ptr %117, align 4, !tbaa !24
  %119 = call <2 x float> @nk_vec2(float noundef %116, float noundef %118)
  %120 = shl i32 %19, 1
  %121 = zext i32 %120 to i64
  %122 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %121
  %123 = getelementptr inbounds %struct.nk_vec2, ptr %1, i64 %20
  %124 = load float, ptr %123, align 4, !tbaa !23
  %.sroa.0276.0.vec.extract = extractelement <2 x float> %119, i64 0
  %125 = fadd float %124, %.sroa.0276.0.vec.extract
  %126 = getelementptr inbounds i8, ptr %123, i64 4
  %127 = load float, ptr %126, align 4, !tbaa !24
  %.sroa.0276.4.vec.extract = extractelement <2 x float> %119, i64 1
  %128 = fadd float %.sroa.0276.4.vec.extract, %127
  %129 = call <2 x float> @nk_vec2(float noundef %125, float noundef %128)
  store <2 x float> %129, ptr %122, align 4
  %130 = or disjoint i32 %120, 1
  %131 = zext i32 %130 to i64
  %132 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %131
  %133 = load float, ptr %123, align 4, !tbaa !23
  %134 = fsub float %133, %.sroa.0276.0.vec.extract
  %135 = load float, ptr %126, align 4, !tbaa !24
  %136 = fsub float %135, %.sroa.0276.4.vec.extract
  %137 = call <2 x float> @nk_vec2(float noundef %134, float noundef %136)
  store <2 x float> %137, ptr %132, align 4
  br label %.lr.ph644.preheader

.preheader633:                                    ; preds = %175
  %138 = getelementptr inbounds i8, ptr %0, i64 144
  %umax = call i64 @llvm.umax.i64(i64 %18, i64 1)
  br label %211

.lr.ph644:                                        ; preds = %.lr.ph644.preheader, %175
  %.1600643 = phi i64 [ %139, %175 ], [ 0, %.lr.ph644.preheader ]
  %.0604642 = phi ptr [ %210, %175 ], [ %36, %.lr.ph644.preheader ]
  %.0607641 = phi i64 [ %143, %175 ], [ %29, %.lr.ph644.preheader ]
  %139 = add nuw nsw i64 %.1600643, 1
  %140 = icmp eq i64 %139, %18
  %141 = select i1 %140, i64 0, i64 %139
  %142 = add i64 %.0607641, 3
  %143 = select i1 %140, i64 %29, i64 %142
  %144 = getelementptr inbounds %struct.nk_vec2, ptr %47, i64 %.1600643
  %145 = load float, ptr %144, align 4, !tbaa !23
  %146 = getelementptr inbounds %struct.nk_vec2, ptr %47, i64 %141
  %147 = load float, ptr %146, align 4, !tbaa !23
  %148 = fadd float %145, %147
  %149 = getelementptr inbounds i8, ptr %144, i64 4
  %150 = load float, ptr %149, align 4, !tbaa !24
  %151 = getelementptr inbounds i8, ptr %146, i64 4
  %152 = load float, ptr %151, align 4, !tbaa !24
  %153 = fadd float %150, %152
  %154 = call <2 x float> @nk_vec2(float noundef %148, float noundef %153)
  %.sroa.0225.0.vec.extract = extractelement <2 x float> %154, i64 0
  %155 = fmul float %.sroa.0225.0.vec.extract, 5.000000e-01
  %156 = load float, ptr %144, align 4, !tbaa !23
  %157 = load float, ptr %146, align 4, !tbaa !23
  %158 = fadd float %156, %157
  %159 = load float, ptr %149, align 4, !tbaa !24
  %160 = load float, ptr %151, align 4, !tbaa !24
  %161 = fadd float %159, %160
  %162 = call <2 x float> @nk_vec2(float noundef %158, float noundef %161)
  %.sroa.0224.4.vec.extract = extractelement <2 x float> %162, i64 1
  %163 = fmul float %.sroa.0224.4.vec.extract, 5.000000e-01
  %164 = call <2 x float> @nk_vec2(float noundef %155, float noundef %163)
  %.sroa.0246.0.vec.extract = extractelement <2 x float> %164, i64 0
  %.sroa.0246.4.vec.extract = extractelement <2 x float> %164, i64 1
  %165 = fmul float %.sroa.0246.4.vec.extract, %.sroa.0246.4.vec.extract
  %166 = call float @llvm.fmuladd.f32(float %.sroa.0246.0.vec.extract, float %.sroa.0246.0.vec.extract, float %165)
  %167 = fcmp ogt float %166, 0x3EB0C6F7A0000000
  br i1 %167, label %168, label %175

168:                                              ; preds = %.lr.ph644
  %169 = fdiv float 1.000000e+00, %166
  %170 = fcmp ogt float %169, 1.000000e+02
  %171 = select i1 %170, float 1.000000e+02, float %169
  %172 = fmul float %.sroa.0246.0.vec.extract, %171
  %173 = fmul float %.sroa.0246.4.vec.extract, %171
  %174 = call <2 x float> @nk_vec2(float noundef %172, float noundef %173)
  %.pre666 = extractelement <2 x float> %174, i64 0
  %.pre667 = extractelement <2 x float> %174, i64 1
  br label %175

175:                                              ; preds = %168, %.lr.ph644
  %.sroa.0246.4.vec.extract262.pre-phi = phi float [ %.pre667, %168 ], [ %.sroa.0246.4.vec.extract, %.lr.ph644 ]
  %.sroa.0246.0.vec.extract252.pre-phi = phi float [ %.pre666, %168 ], [ %.sroa.0246.0.vec.extract, %.lr.ph644 ]
  %176 = call <2 x float> @nk_vec2(float noundef %.sroa.0246.0.vec.extract252.pre-phi, float noundef %.sroa.0246.4.vec.extract262.pre-phi)
  %177 = shl nuw nsw i64 %141, 1
  %178 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %177
  %179 = getelementptr inbounds %struct.nk_vec2, ptr %1, i64 %141
  %180 = load float, ptr %179, align 4, !tbaa !23
  %.sroa.0246.0.vec.extract254 = extractelement <2 x float> %176, i64 0
  %181 = fadd float %180, %.sroa.0246.0.vec.extract254
  %182 = getelementptr inbounds i8, ptr %179, i64 4
  %183 = load float, ptr %182, align 4, !tbaa !24
  %.sroa.0246.4.vec.extract264 = extractelement <2 x float> %176, i64 1
  %184 = fadd float %.sroa.0246.4.vec.extract264, %183
  %185 = call <2 x float> @nk_vec2(float noundef %181, float noundef %184)
  store <2 x float> %185, ptr %178, align 4
  %186 = or disjoint i64 %177, 1
  %187 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %186
  %188 = load float, ptr %179, align 4, !tbaa !23
  %189 = fsub float %188, %.sroa.0246.0.vec.extract254
  %190 = load float, ptr %182, align 4, !tbaa !24
  %191 = fsub float %190, %.sroa.0246.4.vec.extract264
  %192 = call <2 x float> @nk_vec2(float noundef %189, float noundef %191)
  store <2 x float> %192, ptr %187, align 4
  %193 = trunc i64 %143 to i16
  store i16 %193, ptr %.0604642, align 2, !tbaa !27
  %194 = trunc i64 %.0607641 to i16
  %195 = getelementptr inbounds i8, ptr %.0604642, i64 2
  store i16 %194, ptr %195, align 2, !tbaa !27
  %196 = add i16 %194, 2
  %197 = getelementptr inbounds i8, ptr %.0604642, i64 4
  store i16 %196, ptr %197, align 2, !tbaa !27
  %198 = getelementptr inbounds i8, ptr %.0604642, i64 6
  store i16 %196, ptr %198, align 2, !tbaa !27
  %199 = add i16 %193, 2
  %200 = getelementptr inbounds i8, ptr %.0604642, i64 8
  store i16 %199, ptr %200, align 2, !tbaa !27
  %201 = getelementptr inbounds i8, ptr %.0604642, i64 10
  store i16 %193, ptr %201, align 2, !tbaa !27
  %202 = add i16 %193, 1
  %203 = getelementptr inbounds i8, ptr %.0604642, i64 12
  store i16 %202, ptr %203, align 2, !tbaa !27
  %204 = add i16 %194, 1
  %205 = getelementptr inbounds i8, ptr %.0604642, i64 14
  store i16 %204, ptr %205, align 2, !tbaa !27
  %206 = getelementptr inbounds i8, ptr %.0604642, i64 16
  store i16 %194, ptr %206, align 2, !tbaa !27
  %207 = getelementptr inbounds i8, ptr %.0604642, i64 18
  store i16 %194, ptr %207, align 2, !tbaa !27
  %208 = getelementptr inbounds i8, ptr %.0604642, i64 20
  store i16 %193, ptr %208, align 2, !tbaa !27
  %209 = getelementptr inbounds i8, ptr %.0604642, i64 22
  store i16 %202, ptr %209, align 2, !tbaa !27
  %210 = getelementptr inbounds i8, ptr %.0604642, i64 24
  %exitcond660.not = icmp eq i64 %139, %.0
  br i1 %exitcond660.not, label %.preheader633, label %.lr.ph644, !llvm.loop !29

211:                                              ; preds = %.preheader633, %211
  %.0602646 = phi ptr [ %55, %.preheader633 ], [ %224, %211 ]
  %.0608645 = phi i64 [ 0, %.preheader633 ], [ %225, %211 ]
  %.sroa.0213.0.copyload = load <2 x float>, ptr %138, align 8
  %212 = getelementptr inbounds %struct.nk_vec2, ptr %1, i64 %.0608645
  %213 = load <2 x float>, ptr %212, align 4
  %214 = load <2 x float>, ptr %8, align 8
  %215 = load <2 x float>, ptr %.sroa.7.0..sroa_idx, align 8
  %216 = call ptr @nk_draw_vertex(ptr noundef %.0602646, ptr noundef nonnull %14, <2 x float> %213, <2 x float> %.sroa.0213.0.copyload, <2 x float> %214, <2 x float> %215)
  %217 = shl nuw nsw i64 %.0608645, 1
  %218 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %217
  %219 = load <2 x float>, ptr %218, align 4
  %220 = call ptr @nk_draw_vertex(ptr noundef %216, ptr noundef nonnull %14, <2 x float> %219, <2 x float> %.sroa.0213.0.copyload, <2 x float> %.sroa.0455.0.copyload, <2 x float> %.sroa.7.12.vec.insert)
  %221 = or disjoint i64 %217, 1
  %222 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %221
  %223 = load <2 x float>, ptr %222, align 4
  %224 = call ptr @nk_draw_vertex(ptr noundef %220, ptr noundef nonnull %14, <2 x float> %223, <2 x float> %.sroa.0213.0.copyload, <2 x float> %.sroa.0455.0.copyload, <2 x float> %.sroa.7.12.vec.insert)
  %225 = add nuw nsw i64 %.0608645, 1
  %exitcond661.not = icmp eq i64 %225, %umax
  br i1 %exitcond661.not, label %.critedge, label %211, !llvm.loop !30

226:                                              ; preds = %82
  %227 = fadd float %5, -1.000000e+00
  %228 = fmul float %227, 5.000000e-01
  %229 = load float, ptr %47, align 4, !tbaa !23
  %230 = fadd float %228, 1.000000e+00
  %231 = fmul float %230, %229
  %232 = getelementptr inbounds i8, ptr %47, i64 4
  %233 = load float, ptr %232, align 4, !tbaa !24
  %234 = fmul float %230, %233
  %235 = call <2 x float> @nk_vec2(float noundef %231, float noundef %234)
  %236 = load float, ptr %47, align 4, !tbaa !23
  %237 = fmul float %228, %236
  %238 = load float, ptr %232, align 4, !tbaa !24
  %239 = fmul float %228, %238
  %240 = call <2 x float> @nk_vec2(float noundef %237, float noundef %239)
  %241 = load float, ptr %1, align 4, !tbaa !23
  %.sroa.0172.0.vec.extract = extractelement <2 x float> %235, i64 0
  %242 = fadd float %.sroa.0172.0.vec.extract, %241
  %243 = getelementptr inbounds i8, ptr %1, i64 4
  %244 = load float, ptr %243, align 4, !tbaa !24
  %.sroa.0172.4.vec.extract = extractelement <2 x float> %235, i64 1
  %245 = fadd float %.sroa.0172.4.vec.extract, %244
  %246 = call <2 x float> @nk_vec2(float noundef %242, float noundef %245)
  store <2 x float> %246, ptr %51, align 4
  %247 = getelementptr inbounds i8, ptr %51, i64 8
  %248 = load float, ptr %1, align 4, !tbaa !23
  %.sroa.0159.0.vec.extract = extractelement <2 x float> %240, i64 0
  %249 = fadd float %.sroa.0159.0.vec.extract, %248
  %250 = load float, ptr %243, align 4, !tbaa !24
  %.sroa.0159.4.vec.extract = extractelement <2 x float> %240, i64 1
  %251 = fadd float %.sroa.0159.4.vec.extract, %250
  %252 = call <2 x float> @nk_vec2(float noundef %249, float noundef %251)
  store <2 x float> %252, ptr %247, align 4
  %253 = getelementptr inbounds i8, ptr %51, i64 16
  %254 = load float, ptr %1, align 4, !tbaa !23
  %255 = fsub float %254, %.sroa.0159.0.vec.extract
  %256 = load float, ptr %243, align 4, !tbaa !24
  %257 = fsub float %256, %.sroa.0159.4.vec.extract
  %258 = call <2 x float> @nk_vec2(float noundef %255, float noundef %257)
  store <2 x float> %258, ptr %253, align 4
  %259 = getelementptr inbounds i8, ptr %51, i64 24
  %260 = load float, ptr %1, align 4, !tbaa !23
  %261 = fsub float %260, %.sroa.0172.0.vec.extract
  %262 = load float, ptr %243, align 4, !tbaa !24
  %263 = fsub float %262, %.sroa.0172.4.vec.extract
  %264 = call <2 x float> @nk_vec2(float noundef %261, float noundef %263)
  store <2 x float> %264, ptr %259, align 4
  %265 = load float, ptr %83, align 4, !tbaa !23
  %266 = fmul float %230, %265
  %267 = getelementptr inbounds i8, ptr %83, i64 4
  %268 = load float, ptr %267, align 4, !tbaa !24
  %269 = fmul float %230, %268
  %270 = call <2 x float> @nk_vec2(float noundef %266, float noundef %269)
  %271 = load float, ptr %83, align 4, !tbaa !23
  %272 = fmul float %228, %271
  %273 = load float, ptr %267, align 4, !tbaa !24
  %274 = fmul float %228, %273
  %275 = call <2 x float> @nk_vec2(float noundef %272, float noundef %274)
  %276 = shl i32 %19, 2
  %277 = zext i32 %276 to i64
  %278 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %277
  %279 = getelementptr inbounds %struct.nk_vec2, ptr %1, i64 %20
  %280 = load float, ptr %279, align 4, !tbaa !23
  %.sroa.0172.0.vec.extract176 = extractelement <2 x float> %270, i64 0
  %281 = fadd float %.sroa.0172.0.vec.extract176, %280
  %282 = getelementptr inbounds i8, ptr %279, i64 4
  %283 = load float, ptr %282, align 4, !tbaa !24
  %.sroa.0172.4.vec.extract182 = extractelement <2 x float> %270, i64 1
  %284 = fadd float %.sroa.0172.4.vec.extract182, %283
  %285 = call <2 x float> @nk_vec2(float noundef %281, float noundef %284)
  store <2 x float> %285, ptr %278, align 4
  %286 = or disjoint i32 %276, 1
  %287 = zext i32 %286 to i64
  %288 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %287
  %289 = load float, ptr %279, align 4, !tbaa !23
  %.sroa.0159.0.vec.extract163 = extractelement <2 x float> %275, i64 0
  %290 = fadd float %.sroa.0159.0.vec.extract163, %289
  %291 = load float, ptr %282, align 4, !tbaa !24
  %.sroa.0159.4.vec.extract169 = extractelement <2 x float> %275, i64 1
  %292 = fadd float %.sroa.0159.4.vec.extract169, %291
  %293 = call <2 x float> @nk_vec2(float noundef %290, float noundef %292)
  store <2 x float> %293, ptr %288, align 4
  %294 = or disjoint i32 %276, 2
  %295 = zext i32 %294 to i64
  %296 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %295
  %297 = load float, ptr %279, align 4, !tbaa !23
  %298 = fsub float %297, %.sroa.0159.0.vec.extract163
  %299 = load float, ptr %282, align 4, !tbaa !24
  %300 = fsub float %299, %.sroa.0159.4.vec.extract169
  %301 = call <2 x float> @nk_vec2(float noundef %298, float noundef %300)
  store <2 x float> %301, ptr %296, align 4
  %302 = or disjoint i32 %276, 3
  %303 = zext i32 %302 to i64
  %304 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %303
  %305 = load float, ptr %279, align 4, !tbaa !23
  %306 = fsub float %305, %.sroa.0172.0.vec.extract176
  %307 = load float, ptr %282, align 4, !tbaa !24
  %308 = fsub float %307, %.sroa.0172.4.vec.extract182
  %309 = call <2 x float> @nk_vec2(float noundef %306, float noundef %308)
  store <2 x float> %309, ptr %304, align 4
  br label %.lr.ph651

.lr.ph651:                                        ; preds = %226, %.thread632
  %310 = phi float [ %89, %.thread632 ], [ %228, %226 ]
  %311 = fadd float %310, 1.000000e+00
  br label %313

.preheader:                                       ; preds = %350
  %312 = getelementptr inbounds i8, ptr %0, i64 144
  %umax663 = call i64 @llvm.umax.i64(i64 %18, i64 1)
  br label %413

313:                                              ; preds = %.lr.ph651, %350
  %.2649 = phi i64 [ 0, %.lr.ph651 ], [ %314, %350 ]
  %.1605648 = phi ptr [ %36, %.lr.ph651 ], [ %412, %350 ]
  %.0609647 = phi i64 [ %29, %.lr.ph651 ], [ %318, %350 ]
  %314 = add nuw nsw i64 %.2649, 1
  %315 = icmp eq i64 %314, %18
  %316 = select i1 %315, i64 0, i64 %314
  %317 = add i64 %.0609647, 4
  %318 = select i1 %315, i64 %29, i64 %317
  %319 = getelementptr inbounds %struct.nk_vec2, ptr %47, i64 %.2649
  %320 = load float, ptr %319, align 4, !tbaa !23
  %321 = getelementptr inbounds %struct.nk_vec2, ptr %47, i64 %316
  %322 = load float, ptr %321, align 4, !tbaa !23
  %323 = fadd float %320, %322
  %324 = getelementptr inbounds i8, ptr %319, i64 4
  %325 = load float, ptr %324, align 4, !tbaa !24
  %326 = getelementptr inbounds i8, ptr %321, i64 4
  %327 = load float, ptr %326, align 4, !tbaa !24
  %328 = fadd float %325, %327
  %329 = call <2 x float> @nk_vec2(float noundef %323, float noundef %328)
  %.sroa.095.0.vec.extract = extractelement <2 x float> %329, i64 0
  %330 = fmul float %.sroa.095.0.vec.extract, 5.000000e-01
  %331 = load float, ptr %319, align 4, !tbaa !23
  %332 = load float, ptr %321, align 4, !tbaa !23
  %333 = fadd float %331, %332
  %334 = load float, ptr %324, align 4, !tbaa !24
  %335 = load float, ptr %326, align 4, !tbaa !24
  %336 = fadd float %334, %335
  %337 = call <2 x float> @nk_vec2(float noundef %333, float noundef %336)
  %.sroa.094.4.vec.extract = extractelement <2 x float> %337, i64 1
  %338 = fmul float %.sroa.094.4.vec.extract, 5.000000e-01
  %339 = call <2 x float> @nk_vec2(float noundef %330, float noundef %338)
  %.sroa.096.0.vec.extract = extractelement <2 x float> %339, i64 0
  %.sroa.096.4.vec.extract = extractelement <2 x float> %339, i64 1
  %340 = fmul float %.sroa.096.4.vec.extract, %.sroa.096.4.vec.extract
  %341 = call float @llvm.fmuladd.f32(float %.sroa.096.0.vec.extract, float %.sroa.096.0.vec.extract, float %340)
  %342 = fcmp ogt float %341, 0x3EB0C6F7A0000000
  br i1 %342, label %343, label %350

343:                                              ; preds = %313
  %344 = fdiv float 1.000000e+00, %341
  %345 = fcmp ogt float %344, 1.000000e+02
  %346 = select i1 %345, float 1.000000e+02, float %344
  %347 = fmul float %.sroa.096.0.vec.extract, %346
  %348 = fmul float %.sroa.096.4.vec.extract, %346
  %349 = call <2 x float> @nk_vec2(float noundef %347, float noundef %348)
  %.pre = extractelement <2 x float> %349, i64 0
  %.pre665 = extractelement <2 x float> %349, i64 1
  br label %350

350:                                              ; preds = %343, %313
  %.sroa.096.4.vec.extract110.pre-phi = phi float [ %.pre665, %343 ], [ %.sroa.096.4.vec.extract, %313 ]
  %.sroa.096.0.vec.extract102.pre-phi = phi float [ %.pre, %343 ], [ %.sroa.096.0.vec.extract, %313 ]
  %351 = fmul float %311, %.sroa.096.0.vec.extract102.pre-phi
  %352 = fmul float %311, %.sroa.096.4.vec.extract110.pre-phi
  %353 = call <2 x float> @nk_vec2(float noundef %351, float noundef %352)
  %354 = fmul float %310, %.sroa.096.0.vec.extract102.pre-phi
  %355 = fmul float %310, %.sroa.096.4.vec.extract110.pre-phi
  %356 = call <2 x float> @nk_vec2(float noundef %354, float noundef %355)
  %357 = shl nuw nsw i64 %316, 2
  %358 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %357
  %359 = getelementptr inbounds %struct.nk_vec2, ptr %1, i64 %316
  %360 = load float, ptr %359, align 4, !tbaa !23
  %.sroa.0144.0.vec.extract = extractelement <2 x float> %353, i64 0
  %361 = fadd float %.sroa.0144.0.vec.extract, %360
  %362 = getelementptr inbounds i8, ptr %359, i64 4
  %363 = load float, ptr %362, align 4, !tbaa !24
  %.sroa.0144.4.vec.extract = extractelement <2 x float> %353, i64 1
  %364 = fadd float %.sroa.0144.4.vec.extract, %363
  %365 = call <2 x float> @nk_vec2(float noundef %361, float noundef %364)
  store <2 x float> %365, ptr %358, align 4
  %366 = or disjoint i64 %357, 1
  %367 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %366
  %368 = load float, ptr %359, align 4, !tbaa !23
  %.sroa.0139.0.vec.extract = extractelement <2 x float> %356, i64 0
  %369 = fadd float %.sroa.0139.0.vec.extract, %368
  %370 = load float, ptr %362, align 4, !tbaa !24
  %.sroa.0139.4.vec.extract = extractelement <2 x float> %356, i64 1
  %371 = fadd float %.sroa.0139.4.vec.extract, %370
  %372 = call <2 x float> @nk_vec2(float noundef %369, float noundef %371)
  store <2 x float> %372, ptr %367, align 4
  %373 = or disjoint i64 %357, 2
  %374 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %373
  %375 = load float, ptr %359, align 4, !tbaa !23
  %376 = fsub float %375, %.sroa.0139.0.vec.extract
  %377 = load float, ptr %362, align 4, !tbaa !24
  %378 = fsub float %377, %.sroa.0139.4.vec.extract
  %379 = call <2 x float> @nk_vec2(float noundef %376, float noundef %378)
  store <2 x float> %379, ptr %374, align 4
  %380 = or disjoint i64 %357, 3
  %381 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %380
  %382 = load float, ptr %359, align 4, !tbaa !23
  %383 = fsub float %382, %.sroa.0144.0.vec.extract
  %384 = load float, ptr %362, align 4, !tbaa !24
  %385 = fsub float %384, %.sroa.0144.4.vec.extract
  %386 = call <2 x float> @nk_vec2(float noundef %383, float noundef %385)
  store <2 x float> %386, ptr %381, align 4
  %387 = trunc i64 %318 to i16
  %388 = add i16 %387, 1
  store i16 %388, ptr %.1605648, align 2, !tbaa !27
  %389 = trunc i64 %.0609647 to i16
  %390 = add i16 %389, 1
  %391 = getelementptr inbounds i8, ptr %.1605648, i64 2
  store i16 %390, ptr %391, align 2, !tbaa !27
  %392 = add i16 %389, 2
  %393 = getelementptr inbounds i8, ptr %.1605648, i64 4
  store i16 %392, ptr %393, align 2, !tbaa !27
  %394 = getelementptr inbounds i8, ptr %.1605648, i64 6
  store i16 %392, ptr %394, align 2, !tbaa !27
  %395 = add i16 %387, 2
  %396 = getelementptr inbounds i8, ptr %.1605648, i64 8
  store i16 %395, ptr %396, align 2, !tbaa !27
  %397 = getelementptr inbounds i8, ptr %.1605648, i64 10
  store i16 %388, ptr %397, align 2, !tbaa !27
  %398 = getelementptr inbounds i8, ptr %.1605648, i64 12
  store i16 %388, ptr %398, align 2, !tbaa !27
  %399 = getelementptr inbounds i8, ptr %.1605648, i64 14
  store i16 %390, ptr %399, align 2, !tbaa !27
  %400 = getelementptr inbounds i8, ptr %.1605648, i64 16
  store i16 %389, ptr %400, align 2, !tbaa !27
  %401 = getelementptr inbounds i8, ptr %.1605648, i64 18
  store i16 %389, ptr %401, align 2, !tbaa !27
  %402 = getelementptr inbounds i8, ptr %.1605648, i64 20
  store i16 %387, ptr %402, align 2, !tbaa !27
  %403 = getelementptr inbounds i8, ptr %.1605648, i64 22
  store i16 %388, ptr %403, align 2, !tbaa !27
  %404 = getelementptr inbounds i8, ptr %.1605648, i64 24
  store i16 %395, ptr %404, align 2, !tbaa !27
  %405 = getelementptr inbounds i8, ptr %.1605648, i64 26
  store i16 %392, ptr %405, align 2, !tbaa !27
  %406 = add i16 %389, 3
  %407 = getelementptr inbounds i8, ptr %.1605648, i64 28
  store i16 %406, ptr %407, align 2, !tbaa !27
  %408 = getelementptr inbounds i8, ptr %.1605648, i64 30
  store i16 %406, ptr %408, align 2, !tbaa !27
  %409 = add i16 %387, 3
  %410 = getelementptr inbounds i8, ptr %.1605648, i64 32
  store i16 %409, ptr %410, align 2, !tbaa !27
  %411 = getelementptr inbounds i8, ptr %.1605648, i64 34
  store i16 %395, ptr %411, align 2, !tbaa !27
  %412 = getelementptr inbounds i8, ptr %.1605648, i64 36
  %exitcond662.not = icmp eq i64 %314, %.0
  br i1 %exitcond662.not, label %.preheader, label %313, !llvm.loop !31

413:                                              ; preds = %.preheader, %413
  %.1603653 = phi ptr [ %55, %.preheader ], [ %433, %413 ]
  %.0612652 = phi i64 [ 0, %.preheader ], [ %434, %413 ]
  %.sroa.077.0.copyload = load <2 x float>, ptr %312, align 8
  %414 = shl nuw nsw i64 %.0612652, 2
  %415 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %414
  %416 = load <2 x float>, ptr %415, align 4
  %417 = call ptr @nk_draw_vertex(ptr noundef %.1603653, ptr noundef nonnull %14, <2 x float> %416, <2 x float> %.sroa.077.0.copyload, <2 x float> %.sroa.0455.0.copyload, <2 x float> %.sroa.7.12.vec.insert)
  %418 = or disjoint i64 %414, 1
  %419 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %418
  %420 = load <2 x float>, ptr %419, align 4
  %421 = load <2 x float>, ptr %8, align 8
  %422 = load <2 x float>, ptr %.sroa.7.0..sroa_idx, align 8
  %423 = call ptr @nk_draw_vertex(ptr noundef %417, ptr noundef nonnull %14, <2 x float> %420, <2 x float> %.sroa.077.0.copyload, <2 x float> %421, <2 x float> %422)
  %424 = or disjoint i64 %414, 2
  %425 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %424
  %426 = load <2 x float>, ptr %425, align 4
  %427 = load <2 x float>, ptr %8, align 8
  %428 = load <2 x float>, ptr %.sroa.7.0..sroa_idx, align 8
  %429 = call ptr @nk_draw_vertex(ptr noundef %423, ptr noundef nonnull %14, <2 x float> %426, <2 x float> %.sroa.077.0.copyload, <2 x float> %427, <2 x float> %428)
  %430 = or disjoint i64 %414, 3
  %431 = getelementptr inbounds %struct.nk_vec2, ptr %51, i64 %430
  %432 = load <2 x float>, ptr %431, align 4
  %433 = call ptr @nk_draw_vertex(ptr noundef %429, ptr noundef nonnull %14, <2 x float> %432, <2 x float> %.sroa.077.0.copyload, <2 x float> %.sroa.0455.0.copyload, <2 x float> %.sroa.7.12.vec.insert)
  %434 = add nuw nsw i64 %.0612652, 1
  %exitcond664.not = icmp eq i64 %434, %umax663
  br i1 %exitcond664.not, label %.critedge, label %413, !llvm.loop !32

.critedge:                                        ; preds = %211, %413
  %435 = load ptr, ptr %40, align 8, !tbaa !18
  call void @nk_buffer_reset(ptr noundef %435, i32 noundef 0)
  br label %.critedge630

436:                                              ; preds = %12
  %437 = mul nuw nsw i64 %.0, 6
  %438 = shl nuw nsw i64 %.0, 2
  %439 = call ptr @nk_draw_list_alloc_vertices(ptr noundef nonnull %0, i64 noundef %438)
  %440 = call ptr @nk_draw_list_alloc_elements(ptr noundef nonnull %0, i64 noundef %437)
  %441 = icmp ne ptr %439, null
  %442 = icmp ne ptr %440, null
  %or.cond6 = select i1 %441, i1 %442, i1 false
  br i1 %or.cond6, label %.lr.ph, label %.critedge630

.lr.ph:                                           ; preds = %436
  %443 = trunc i32 %27 to i16
  %444 = getelementptr inbounds i8, ptr %0, i64 144
  %445 = fmul float %5, 5.000000e-01
  br label %446

446:                                              ; preds = %.lr.ph, %460
  %.0610638 = phi ptr [ %440, %.lr.ph ], [ %498, %460 ]
  %.0611637 = phi ptr [ %439, %.lr.ph ], [ %489, %460 ]
  %.0613636 = phi i16 [ %443, %.lr.ph ], [ %499, %460 ]
  %.0614635 = phi i64 [ 0, %.lr.ph ], [ %447, %460 ]
  %.sroa.038.0.copyload = load <2 x float>, ptr %444, align 8
  %447 = add nuw nsw i64 %.0614635, 1
  %448 = icmp eq i64 %447, %18
  %449 = select i1 %448, i64 0, i64 %447
  %450 = getelementptr inbounds %struct.nk_vec2, ptr %1, i64 %.0614635
  %.sroa.032.0.copyload = load float, ptr %450, align 4, !tbaa !33
  %.sroa.635.0..sroa_idx = getelementptr inbounds i8, ptr %450, i64 4
  %.sroa.635.0.copyload = load float, ptr %.sroa.635.0..sroa_idx, align 4, !tbaa !33
  %451 = getelementptr inbounds %struct.nk_vec2, ptr %1, i64 %449
  %.sroa.027.0.copyload = load float, ptr %451, align 4, !tbaa !33
  %.sroa.6.0..sroa_idx = getelementptr inbounds i8, ptr %451, i64 4
  %.sroa.6.0.copyload = load float, ptr %.sroa.6.0..sroa_idx, align 4, !tbaa !33
  %452 = fsub float %.sroa.027.0.copyload, %.sroa.032.0.copyload
  %453 = fsub float %.sroa.6.0.copyload, %.sroa.635.0.copyload
  %454 = call <2 x float> @nk_vec2(float noundef %452, float noundef %453)
  %.sroa.014.0.vec.extract = extractelement <2 x float> %454, i64 0
  %.sroa.014.4.vec.extract = extractelement <2 x float> %454, i64 1
  %455 = fmul float %.sroa.014.4.vec.extract, %.sroa.014.4.vec.extract
  %456 = call float @llvm.fmuladd.f32(float %.sroa.014.0.vec.extract, float %.sroa.014.0.vec.extract, float %455)
  %457 = fcmp une float %456, 0.000000e+00
  br i1 %457, label %458, label %460

458:                                              ; preds = %446
  %459 = call float @nk_inv_sqrt(float noundef %456)
  br label %460

460:                                              ; preds = %446, %458
  %.0601 = phi float [ %459, %458 ], [ 1.000000e+00, %446 ]
  %461 = fmul float %.sroa.014.0.vec.extract, %.0601
  %462 = fmul float %.sroa.014.4.vec.extract, %.0601
  %463 = call <2 x float> @nk_vec2(float noundef %461, float noundef %462)
  %.sroa.014.0.vec.extract20 = extractelement <2 x float> %463, i64 0
  %464 = fmul float %445, %.sroa.014.0.vec.extract20
  %.sroa.014.4.vec.extract26 = extractelement <2 x float> %463, i64 1
  %465 = fmul float %445, %.sroa.014.4.vec.extract26
  %466 = fadd float %.sroa.032.0.copyload, %465
  %467 = fsub float %.sroa.635.0.copyload, %464
  %468 = call <2 x float> @nk_vec2(float noundef %466, float noundef %467)
  %469 = load <2 x float>, ptr %8, align 8
  %470 = load <2 x float>, ptr %.sroa.7.0..sroa_idx, align 8
  %471 = call ptr @nk_draw_vertex(ptr noundef %.0611637, ptr noundef nonnull %14, <2 x float> %468, <2 x float> %.sroa.038.0.copyload, <2 x float> %469, <2 x float> %470)
  %472 = fadd float %.sroa.027.0.copyload, %465
  %473 = fsub float %.sroa.6.0.copyload, %464
  %474 = call <2 x float> @nk_vec2(float noundef %472, float noundef %473)
  %475 = load <2 x float>, ptr %8, align 8
  %476 = load <2 x float>, ptr %.sroa.7.0..sroa_idx, align 8
  %477 = call ptr @nk_draw_vertex(ptr noundef %471, ptr noundef nonnull %14, <2 x float> %474, <2 x float> %.sroa.038.0.copyload, <2 x float> %475, <2 x float> %476)
  %478 = fsub float %.sroa.027.0.copyload, %465
  %479 = fadd float %.sroa.6.0.copyload, %464
  %480 = call <2 x float> @nk_vec2(float noundef %478, float noundef %479)
  %481 = load <2 x float>, ptr %8, align 8
  %482 = load <2 x float>, ptr %.sroa.7.0..sroa_idx, align 8
  %483 = call ptr @nk_draw_vertex(ptr noundef %477, ptr noundef nonnull %14, <2 x float> %480, <2 x float> %.sroa.038.0.copyload, <2 x float> %481, <2 x float> %482)
  %484 = fsub float %.sroa.032.0.copyload, %465
  %485 = fadd float %.sroa.635.0.copyload, %464
  %486 = call <2 x float> @nk_vec2(float noundef %484, float noundef %485)
  %487 = load <2 x float>, ptr %8, align 8
  %488 = load <2 x float>, ptr %.sroa.7.0..sroa_idx, align 8
  %489 = call ptr @nk_draw_vertex(ptr noundef %483, ptr noundef nonnull %14, <2 x float> %486, <2 x float> %.sroa.038.0.copyload, <2 x float> %487, <2 x float> %488)
  store i16 %.0613636, ptr %.0610638, align 2, !tbaa !27
  %490 = add i16 %.0613636, 1
  %491 = getelementptr inbounds i8, ptr %.0610638, i64 2
  store i16 %490, ptr %491, align 2, !tbaa !27
  %492 = add i16 %.0613636, 2
  %493 = getelementptr inbounds i8, ptr %.0610638, i64 4
  store i16 %492, ptr %493, align 2, !tbaa !27
  %494 = getelementptr inbounds i8, ptr %.0610638, i64 6
  store i16 %.0613636, ptr %494, align 2, !tbaa !27
  %495 = getelementptr inbounds i8, ptr %.0610638, i64 8
  store i16 %492, ptr %495, align 2, !tbaa !27
  %496 = add i16 %.0613636, 3
  %497 = getelementptr inbounds i8, ptr %.0610638, i64 10
  store i16 %496, ptr %497, align 2, !tbaa !27
  %498 = getelementptr inbounds i8, ptr %.0610638, i64 12
  %499 = add i16 %.0613636, 4
  %exitcond.not = icmp eq i64 %447, %.0
  br i1 %exitcond.not, label %.critedge630, label %446, !llvm.loop !34

.critedge630:                                     ; preds = %460, %436, %.critedge, %28, %39, %10
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %8) #6
  ret void
}

; Function Attrs: nounwind uwtable
declare hidden ptr @nk_draw_list_alloc_vertices(ptr noundef, i64 noundef) local_unnamed_addr #4

; Function Attrs: nounwind uwtable
declare hidden ptr @nk_draw_list_alloc_elements(ptr noundef, i64 noundef) local_unnamed_addr #4

; Function Attrs: nounwind uwtable
declare hidden float @nk_inv_sqrt(float noundef) local_unnamed_addr #4

; Function Attrs: nounwind uwtable
declare hidden ptr @nk_draw_vertex(ptr noundef, ptr noundef, <2 x float>, <2 x float>, <2 x float>, <2 x float>) local_unnamed_addr #1

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i64 @llvm.umax.i64(i64, i64) #5

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !8, i64 112}
!6 = !{!"nk_draw_list", !7, i64 0, !9, i64 16, !11, i64 112, !15, i64 176, !15, i64 184, !15, i64 192, !12, i64 200, !12, i64 204, !12, i64 208, !16, i64 216, !12, i64 224, !12, i64 228, !12, i64 232, !12, i64 236}
!7 = !{!"nk_rect", !8, i64 0, !8, i64 4, !8, i64 8, !8, i64 12}
!8 = !{!"float", !9, i64 0}
!9 = !{!"omnipotent char", !10, i64 0}
!10 = !{!"Simple C/C++ TBAA"}
!11 = !{!"nk_convert_config", !8, i64 0, !12, i64 4, !12, i64 8, !12, i64 12, !12, i64 16, !12, i64 20, !13, i64 24, !15, i64 40, !16, i64 48, !16, i64 56}
!12 = !{!"int", !9, i64 0}
!13 = !{!"nk_draw_null_texture", !9, i64 0, !14, i64 8}
!14 = !{!"nk_vec2", !8, i64 0, !8, i64 4}
!15 = !{!"any pointer", !9, i64 0}
!16 = !{!"long", !9, i64 0}
!17 = !{!6, !12, i64 204}
!18 = !{!6, !15, i64 184}
!19 = !{!20, !15, i64 64}
!20 = !{!"nk_buffer", !9, i64 0, !21, i64 32, !12, i64 56, !22, i64 64, !8, i64 80, !16, i64 88, !16, i64 96, !16, i64 104, !16, i64 112}
!21 = !{!"nk_allocator", !9, i64 0, !15, i64 8, !15, i64 16}
!22 = !{!"nk_memory", !15, i64 0, !16, i64 8}
!23 = !{!14, !8, i64 0}
!24 = !{!14, !8, i64 4}
!25 = distinct !{!25, !26}
!26 = !{!"llvm.loop.mustprogress"}
!27 = !{!28, !28, i64 0}
!28 = !{!"short", !9, i64 0}
!29 = distinct !{!29, !26}
!30 = distinct !{!30, !26}
!31 = distinct !{!31, !26}
!32 = distinct !{!32, !26}
!33 = !{!8, !8, i64 0}
!34 = distinct !{!34, !26}


; Effective O3 passes: AggressiveInstCombinePass,BDCEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,JumpThreadingPass,LICMPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,PostOrderFunctionAttrsPass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass