; LLVM IR from MIT-SPARK/Kimera-VIO :: third_party/triangle/src (triangle)

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

@plus1mod3 = external dso_local global [3 x i32], align 4
@minus1mod3 = external dso_local global [3 x i32], align 4
@.str.59 = external hidden unnamed_addr constant [26 x i8], align 1
@.str.60 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.61 = external hidden unnamed_addr constant [14 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

declare i32 @printf(ptr noundef, ...) #1

; Function Attrs: 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 void @printtriangle(ptr noundef, ptr noundef, ptr noundef) #2

; Function Attrs: nounwind uwtable
declare dso_local void @maketriangle(ptr noundef, ptr noundef, ptr noundef) #2

; Function Attrs: nounwind uwtable
declare dso_local float @counterclockwise(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #2

; Function Attrs: nounwind uwtable
declare dso_local float @incircle(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #2

; Function Attrs: nounwind uwtable
define dso_local void @mergehulls(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, ptr noundef %4, ptr noundef %5, i32 noundef %6) #2 {
  %8 = alloca ptr, align 8
  %9 = alloca ptr, align 8
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca i32, align 4
  %15 = alloca %struct.otri, align 8
  %16 = alloca %struct.otri, align 8
  %17 = alloca %struct.otri, align 8
  %18 = alloca %struct.otri, align 8
  %19 = alloca %struct.otri, align 8
  %20 = alloca %struct.otri, align 8
  %21 = alloca %struct.otri, align 8
  %22 = alloca %struct.otri, align 8
  %23 = alloca ptr, align 8
  %24 = alloca ptr, align 8
  %25 = alloca ptr, align 8
  %26 = alloca ptr, align 8
  %27 = alloca ptr, align 8
  %28 = alloca ptr, align 8
  %29 = alloca ptr, align 8
  %30 = alloca ptr, align 8
  %31 = alloca ptr, align 8
  %32 = alloca ptr, align 8
  %33 = alloca ptr, align 8
  %34 = alloca ptr, align 8
  %35 = alloca ptr, align 8
  %36 = alloca ptr, align 8
  %37 = alloca i32, align 4
  %38 = alloca i32, align 4
  %39 = alloca i32, align 4
  %40 = alloca i32, align 4
  %41 = alloca ptr, align 8
  store ptr %0, ptr %8, align 8, !tbaa !5
  store ptr %1, ptr %9, align 8, !tbaa !5
  store ptr %2, ptr %10, align 8, !tbaa !5
  store ptr %3, ptr %11, align 8, !tbaa !5
  store ptr %4, ptr %12, align 8, !tbaa !5
  store ptr %5, ptr %13, align 8, !tbaa !5
  store i32 %6, ptr %14, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 16, ptr %15) #3
  call void @llvm.lifetime.start.p0(i64 16, ptr %16) #3
  call void @llvm.lifetime.start.p0(i64 16, ptr %17) #3
  call void @llvm.lifetime.start.p0(i64 16, ptr %18) #3
  call void @llvm.lifetime.start.p0(i64 16, ptr %19) #3
  call void @llvm.lifetime.start.p0(i64 16, ptr %20) #3
  call void @llvm.lifetime.start.p0(i64 16, ptr %21) #3
  call void @llvm.lifetime.start.p0(i64 16, ptr %22) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %36) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %40) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %41) #3
  %42 = load ptr, ptr %11, align 8, !tbaa !5
  %43 = getelementptr inbounds %struct.otri, ptr %42, i32 0, i32 0
  %44 = load ptr, ptr %43, align 8, !tbaa !11
  %45 = load ptr, ptr %11, align 8, !tbaa !5
  %46 = getelementptr inbounds %struct.otri, ptr %45, i32 0, i32 1
  %47 = load i32, ptr %46, align 8, !tbaa !13
  %48 = sext i32 %47 to i64
  %49 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %48
  %50 = load i32, ptr %49, align 4, !tbaa !9
  %51 = add nsw i32 %50, 3
  %52 = sext i32 %51 to i64
  %53 = getelementptr inbounds ptr, ptr %44, i64 %52
  %54 = load ptr, ptr %53, align 8, !tbaa !5
  store ptr %54, ptr %23, align 8, !tbaa !5
  %55 = load ptr, ptr %11, align 8, !tbaa !5
  %56 = getelementptr inbounds %struct.otri, ptr %55, i32 0, i32 0
  %57 = load ptr, ptr %56, align 8, !tbaa !11
  %58 = load ptr, ptr %11, align 8, !tbaa !5
  %59 = getelementptr inbounds %struct.otri, ptr %58, i32 0, i32 1
  %60 = load i32, ptr %59, align 8, !tbaa !13
  %61 = add nsw i32 %60, 3
  %62 = sext i32 %61 to i64
  %63 = getelementptr inbounds ptr, ptr %57, i64 %62
  %64 = load ptr, ptr %63, align 8, !tbaa !5
  store ptr %64, ptr %25, align 8, !tbaa !5
  %65 = load ptr, ptr %12, align 8, !tbaa !5
  %66 = getelementptr inbounds %struct.otri, ptr %65, i32 0, i32 0
  %67 = load ptr, ptr %66, align 8, !tbaa !11
  %68 = load ptr, ptr %12, align 8, !tbaa !5
  %69 = getelementptr inbounds %struct.otri, ptr %68, i32 0, i32 1
  %70 = load i32, ptr %69, align 8, !tbaa !13
  %71 = sext i32 %70 to i64
  %72 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %71
  %73 = load i32, ptr %72, align 4, !tbaa !9
  %74 = add nsw i32 %73, 3
  %75 = sext i32 %74 to i64
  %76 = getelementptr inbounds ptr, ptr %67, i64 %75
  %77 = load ptr, ptr %76, align 8, !tbaa !5
  store ptr %77, ptr %24, align 8, !tbaa !5
  %78 = load ptr, ptr %12, align 8, !tbaa !5
  %79 = getelementptr inbounds %struct.otri, ptr %78, i32 0, i32 0
  %80 = load ptr, ptr %79, align 8, !tbaa !11
  %81 = load ptr, ptr %12, align 8, !tbaa !5
  %82 = getelementptr inbounds %struct.otri, ptr %81, i32 0, i32 1
  %83 = load i32, ptr %82, align 8, !tbaa !13
  %84 = add nsw i32 %83, 3
  %85 = sext i32 %84 to i64
  %86 = getelementptr inbounds ptr, ptr %80, i64 %85
  %87 = load ptr, ptr %86, align 8, !tbaa !5
  store ptr %87, ptr %26, align 8, !tbaa !5
  %88 = load ptr, ptr %9, align 8, !tbaa !5
  %89 = getelementptr inbounds %struct.behavior, ptr %88, i32 0, i32 25
  %90 = load i32, ptr %89, align 4, !tbaa !14
  %91 = icmp ne i32 %90, 0
  br i1 %91, label %92, label %416

92:                                               ; preds = %7
  %93 = load i32, ptr %14, align 4, !tbaa !9
  %94 = icmp eq i32 %93, 1
  br i1 %94, label %95, label %416

95:                                               ; preds = %92
  %96 = load ptr, ptr %10, align 8, !tbaa !5
  %97 = getelementptr inbounds %struct.otri, ptr %96, i32 0, i32 0
  %98 = load ptr, ptr %97, align 8, !tbaa !11
  %99 = load ptr, ptr %10, align 8, !tbaa !5
  %100 = getelementptr inbounds %struct.otri, ptr %99, i32 0, i32 1
  %101 = load i32, ptr %100, align 8, !tbaa !13
  %102 = sext i32 %101 to i64
  %103 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %102
  %104 = load i32, ptr %103, align 4, !tbaa !9
  %105 = add nsw i32 %104, 3
  %106 = sext i32 %105 to i64
  %107 = getelementptr inbounds ptr, ptr %98, i64 %106
  %108 = load ptr, ptr %107, align 8, !tbaa !5
  store ptr %108, ptr %27, align 8, !tbaa !5
  %109 = load ptr, ptr %10, align 8, !tbaa !5
  %110 = getelementptr inbounds %struct.otri, ptr %109, i32 0, i32 0
  %111 = load ptr, ptr %110, align 8, !tbaa !11
  %112 = load ptr, ptr %10, align 8, !tbaa !5
  %113 = getelementptr inbounds %struct.otri, ptr %112, i32 0, i32 1
  %114 = load i32, ptr %113, align 8, !tbaa !13
  %115 = add nsw i32 %114, 3
  %116 = sext i32 %115 to i64
  %117 = getelementptr inbounds ptr, ptr %111, i64 %116
  %118 = load ptr, ptr %117, align 8, !tbaa !5
  store ptr %118, ptr %29, align 8, !tbaa !5
  %119 = load ptr, ptr %13, align 8, !tbaa !5
  %120 = getelementptr inbounds %struct.otri, ptr %119, i32 0, i32 0
  %121 = load ptr, ptr %120, align 8, !tbaa !11
  %122 = load ptr, ptr %13, align 8, !tbaa !5
  %123 = getelementptr inbounds %struct.otri, ptr %122, i32 0, i32 1
  %124 = load i32, ptr %123, align 8, !tbaa !13
  %125 = sext i32 %124 to i64
  %126 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %125
  %127 = load i32, ptr %126, align 4, !tbaa !9
  %128 = add nsw i32 %127, 3
  %129 = sext i32 %128 to i64
  %130 = getelementptr inbounds ptr, ptr %121, i64 %129
  %131 = load ptr, ptr %130, align 8, !tbaa !5
  store ptr %131, ptr %28, align 8, !tbaa !5
  %132 = load ptr, ptr %13, align 8, !tbaa !5
  %133 = getelementptr inbounds %struct.otri, ptr %132, i32 0, i32 0
  %134 = load ptr, ptr %133, align 8, !tbaa !11
  %135 = load ptr, ptr %13, align 8, !tbaa !5
  %136 = getelementptr inbounds %struct.otri, ptr %135, i32 0, i32 1
  %137 = load i32, ptr %136, align 8, !tbaa !13
  %138 = add nsw i32 %137, 3
  %139 = sext i32 %138 to i64
  %140 = getelementptr inbounds ptr, ptr %134, i64 %139
  %141 = load ptr, ptr %140, align 8, !tbaa !5
  store ptr %141, ptr %30, align 8, !tbaa !5
  br label %142

142:                                              ; preds = %150, %95
  %143 = load ptr, ptr %29, align 8, !tbaa !5
  %144 = getelementptr inbounds float, ptr %143, i64 1
  %145 = load float, ptr %144, align 4, !tbaa !17
  %146 = load ptr, ptr %27, align 8, !tbaa !5
  %147 = getelementptr inbounds float, ptr %146, i64 1
  %148 = load float, ptr %147, align 4, !tbaa !17
  %149 = fcmp olt float %145, %148
  br i1 %149, label %150, label %195

150:                                              ; preds = %142
  %151 = load ptr, ptr %10, align 8, !tbaa !5
  %152 = getelementptr inbounds %struct.otri, ptr %151, i32 0, i32 1
  %153 = load i32, ptr %152, align 8, !tbaa !13
  %154 = sext i32 %153 to i64
  %155 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %154
  %156 = load i32, ptr %155, align 4, !tbaa !9
  %157 = load ptr, ptr %10, align 8, !tbaa !5
  %158 = getelementptr inbounds %struct.otri, ptr %157, i32 0, i32 1
  store i32 %156, ptr %158, align 8, !tbaa !13
  %159 = load ptr, ptr %10, align 8, !tbaa !5
  %160 = getelementptr inbounds %struct.otri, ptr %159, i32 0, i32 0
  %161 = load ptr, ptr %160, align 8, !tbaa !11
  %162 = load ptr, ptr %10, align 8, !tbaa !5
  %163 = getelementptr inbounds %struct.otri, ptr %162, i32 0, i32 1
  %164 = load i32, ptr %163, align 8, !tbaa !13
  %165 = sext i32 %164 to i64
  %166 = getelementptr inbounds ptr, ptr %161, i64 %165
  %167 = load ptr, ptr %166, align 8, !tbaa !5
  store ptr %167, ptr %41, align 8, !tbaa !5
  %168 = load ptr, ptr %41, align 8, !tbaa !5
  %169 = ptrtoint ptr %168 to i64
  %170 = and i64 %169, 3
  %171 = trunc i64 %170 to i32
  %172 = load ptr, ptr %10, align 8, !tbaa !5
  %173 = getelementptr inbounds %struct.otri, ptr %172, i32 0, i32 1
  store i32 %171, ptr %173, align 8, !tbaa !13
  %174 = load ptr, ptr %41, align 8, !tbaa !5
  %175 = ptrtoint ptr %174 to i64
  %176 = load ptr, ptr %10, align 8, !tbaa !5
  %177 = getelementptr inbounds %struct.otri, ptr %176, i32 0, i32 1
  %178 = load i32, ptr %177, align 8, !tbaa !13
  %179 = sext i32 %178 to i64
  %180 = xor i64 %175, %179
  %181 = inttoptr i64 %180 to ptr
  %182 = load ptr, ptr %10, align 8, !tbaa !5
  %183 = getelementptr inbounds %struct.otri, ptr %182, i32 0, i32 0
  store ptr %181, ptr %183, align 8, !tbaa !11
  %184 = load ptr, ptr %29, align 8, !tbaa !5
  store ptr %184, ptr %27, align 8, !tbaa !5
  %185 = load ptr, ptr %10, align 8, !tbaa !5
  %186 = getelementptr inbounds %struct.otri, ptr %185, i32 0, i32 0
  %187 = load ptr, ptr %186, align 8, !tbaa !11
  %188 = load ptr, ptr %10, align 8, !tbaa !5
  %189 = getelementptr inbounds %struct.otri, ptr %188, i32 0, i32 1
  %190 = load i32, ptr %189, align 8, !tbaa !13
  %191 = add nsw i32 %190, 3
  %192 = sext i32 %191 to i64
  %193 = getelementptr inbounds ptr, ptr %187, i64 %192
  %194 = load ptr, ptr %193, align 8, !tbaa !5
  store ptr %194, ptr %29, align 8, !tbaa !5
  br label %142, !llvm.loop !18

195:                                              ; preds = %142
  %196 = load ptr, ptr %11, align 8, !tbaa !5
  %197 = getelementptr inbounds %struct.otri, ptr %196, i32 0, i32 0
  %198 = load ptr, ptr %197, align 8, !tbaa !11
  %199 = load ptr, ptr %11, align 8, !tbaa !5
  %200 = getelementptr inbounds %struct.otri, ptr %199, i32 0, i32 1
  %201 = load i32, ptr %200, align 8, !tbaa !13
  %202 = sext i32 %201 to i64
  %203 = getelementptr inbounds ptr, ptr %198, i64 %202
  %204 = load ptr, ptr %203, align 8, !tbaa !5
  store ptr %204, ptr %41, align 8, !tbaa !5
  %205 = load ptr, ptr %41, align 8, !tbaa !5
  %206 = ptrtoint ptr %205 to i64
  %207 = and i64 %206, 3
  %208 = trunc i64 %207 to i32
  %209 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  store i32 %208, ptr %209, align 8, !tbaa !13
  %210 = load ptr, ptr %41, align 8, !tbaa !5
  %211 = ptrtoint ptr %210 to i64
  %212 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %213 = load i32, ptr %212, align 8, !tbaa !13
  %214 = sext i32 %213 to i64
  %215 = xor i64 %211, %214
  %216 = inttoptr i64 %215 to ptr
  %217 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  store ptr %216, ptr %217, align 8, !tbaa !11
  %218 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  %219 = load ptr, ptr %218, align 8, !tbaa !11
  %220 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %221 = load i32, ptr %220, align 8, !tbaa !13
  %222 = add nsw i32 %221, 3
  %223 = sext i32 %222 to i64
  %224 = getelementptr inbounds ptr, ptr %219, i64 %223
  %225 = load ptr, ptr %224, align 8, !tbaa !5
  store ptr %225, ptr %36, align 8, !tbaa !5
  br label %226

226:                                              ; preds = %234, %195
  %227 = load ptr, ptr %36, align 8, !tbaa !5
  %228 = getelementptr inbounds float, ptr %227, i64 1
  %229 = load float, ptr %228, align 4, !tbaa !17
  %230 = load ptr, ptr %23, align 8, !tbaa !5
  %231 = getelementptr inbounds float, ptr %230, i64 1
  %232 = load float, ptr %231, align 4, !tbaa !17
  %233 = fcmp ogt float %229, %232
  br i1 %233, label %234, label %278

234:                                              ; preds = %226
  %235 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  %236 = load ptr, ptr %235, align 8, !tbaa !11
  %237 = load ptr, ptr %11, align 8, !tbaa !5
  %238 = getelementptr inbounds %struct.otri, ptr %237, i32 0, i32 0
  store ptr %236, ptr %238, align 8, !tbaa !11
  %239 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %240 = load i32, ptr %239, align 8, !tbaa !13
  %241 = sext i32 %240 to i64
  %242 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %241
  %243 = load i32, ptr %242, align 4, !tbaa !9
  %244 = load ptr, ptr %11, align 8, !tbaa !5
  %245 = getelementptr inbounds %struct.otri, ptr %244, i32 0, i32 1
  store i32 %243, ptr %245, align 8, !tbaa !13
  %246 = load ptr, ptr %23, align 8, !tbaa !5
  store ptr %246, ptr %25, align 8, !tbaa !5
  %247 = load ptr, ptr %36, align 8, !tbaa !5
  store ptr %247, ptr %23, align 8, !tbaa !5
  %248 = load ptr, ptr %11, align 8, !tbaa !5
  %249 = getelementptr inbounds %struct.otri, ptr %248, i32 0, i32 0
  %250 = load ptr, ptr %249, align 8, !tbaa !11
  %251 = load ptr, ptr %11, align 8, !tbaa !5
  %252 = getelementptr inbounds %struct.otri, ptr %251, i32 0, i32 1
  %253 = load i32, ptr %252, align 8, !tbaa !13
  %254 = sext i32 %253 to i64
  %255 = getelementptr inbounds ptr, ptr %250, i64 %254
  %256 = load ptr, ptr %255, align 8, !tbaa !5
  store ptr %256, ptr %41, align 8, !tbaa !5
  %257 = load ptr, ptr %41, align 8, !tbaa !5
  %258 = ptrtoint ptr %257 to i64
  %259 = and i64 %258, 3
  %260 = trunc i64 %259 to i32
  %261 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  store i32 %260, ptr %261, align 8, !tbaa !13
  %262 = load ptr, ptr %41, align 8, !tbaa !5
  %263 = ptrtoint ptr %262 to i64
  %264 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %265 = load i32, ptr %264, align 8, !tbaa !13
  %266 = sext i32 %265 to i64
  %267 = xor i64 %263, %266
  %268 = inttoptr i64 %267 to ptr
  %269 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  store ptr %268, ptr %269, align 8, !tbaa !11
  %270 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  %271 = load ptr, ptr %270, align 8, !tbaa !11
  %272 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %273 = load i32, ptr %272, align 8, !tbaa !13
  %274 = add nsw i32 %273, 3
  %275 = sext i32 %274 to i64
  %276 = getelementptr inbounds ptr, ptr %271, i64 %275
  %277 = load ptr, ptr %276, align 8, !tbaa !5
  store ptr %277, ptr %36, align 8, !tbaa !5
  br label %226, !llvm.loop !20

278:                                              ; preds = %226
  br label %279

279:                                              ; preds = %287, %278
  %280 = load ptr, ptr %26, align 8, !tbaa !5
  %281 = getelementptr inbounds float, ptr %280, i64 1
  %282 = load float, ptr %281, align 4, !tbaa !17
  %283 = load ptr, ptr %24, align 8, !tbaa !5
  %284 = getelementptr inbounds float, ptr %283, i64 1
  %285 = load float, ptr %284, align 4, !tbaa !17
  %286 = fcmp olt float %282, %285
  br i1 %286, label %287, label %332

287:                                              ; preds = %279
  %288 = load ptr, ptr %12, align 8, !tbaa !5
  %289 = getelementptr inbounds %struct.otri, ptr %288, i32 0, i32 1
  %290 = load i32, ptr %289, align 8, !tbaa !13
  %291 = sext i32 %290 to i64
  %292 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %291
  %293 = load i32, ptr %292, align 4, !tbaa !9
  %294 = load ptr, ptr %12, align 8, !tbaa !5
  %295 = getelementptr inbounds %struct.otri, ptr %294, i32 0, i32 1
  store i32 %293, ptr %295, align 8, !tbaa !13
  %296 = load ptr, ptr %12, align 8, !tbaa !5
  %297 = getelementptr inbounds %struct.otri, ptr %296, i32 0, i32 0
  %298 = load ptr, ptr %297, align 8, !tbaa !11
  %299 = load ptr, ptr %12, align 8, !tbaa !5
  %300 = getelementptr inbounds %struct.otri, ptr %299, i32 0, i32 1
  %301 = load i32, ptr %300, align 8, !tbaa !13
  %302 = sext i32 %301 to i64
  %303 = getelementptr inbounds ptr, ptr %298, i64 %302
  %304 = load ptr, ptr %303, align 8, !tbaa !5
  store ptr %304, ptr %41, align 8, !tbaa !5
  %305 = load ptr, ptr %41, align 8, !tbaa !5
  %306 = ptrtoint ptr %305 to i64
  %307 = and i64 %306, 3
  %308 = trunc i64 %307 to i32
  %309 = load ptr, ptr %12, align 8, !tbaa !5
  %310 = getelementptr inbounds %struct.otri, ptr %309, i32 0, i32 1
  store i32 %308, ptr %310, align 8, !tbaa !13
  %311 = load ptr, ptr %41, align 8, !tbaa !5
  %312 = ptrtoint ptr %311 to i64
  %313 = load ptr, ptr %12, align 8, !tbaa !5
  %314 = getelementptr inbounds %struct.otri, ptr %313, i32 0, i32 1
  %315 = load i32, ptr %314, align 8, !tbaa !13
  %316 = sext i32 %315 to i64
  %317 = xor i64 %312, %316
  %318 = inttoptr i64 %317 to ptr
  %319 = load ptr, ptr %12, align 8, !tbaa !5
  %320 = getelementptr inbounds %struct.otri, ptr %319, i32 0, i32 0
  store ptr %318, ptr %320, align 8, !tbaa !11
  %321 = load ptr, ptr %26, align 8, !tbaa !5
  store ptr %321, ptr %24, align 8, !tbaa !5
  %322 = load ptr, ptr %12, align 8, !tbaa !5
  %323 = getelementptr inbounds %struct.otri, ptr %322, i32 0, i32 0
  %324 = load ptr, ptr %323, align 8, !tbaa !11
  %325 = load ptr, ptr %12, align 8, !tbaa !5
  %326 = getelementptr inbounds %struct.otri, ptr %325, i32 0, i32 1
  %327 = load i32, ptr %326, align 8, !tbaa !13
  %328 = add nsw i32 %327, 3
  %329 = sext i32 %328 to i64
  %330 = getelementptr inbounds ptr, ptr %324, i64 %329
  %331 = load ptr, ptr %330, align 8, !tbaa !5
  store ptr %331, ptr %26, align 8, !tbaa !5
  br label %279, !llvm.loop !21

332:                                              ; preds = %279
  %333 = load ptr, ptr %13, align 8, !tbaa !5
  %334 = getelementptr inbounds %struct.otri, ptr %333, i32 0, i32 0
  %335 = load ptr, ptr %334, align 8, !tbaa !11
  %336 = load ptr, ptr %13, align 8, !tbaa !5
  %337 = getelementptr inbounds %struct.otri, ptr %336, i32 0, i32 1
  %338 = load i32, ptr %337, align 8, !tbaa !13
  %339 = sext i32 %338 to i64
  %340 = getelementptr inbounds ptr, ptr %335, i64 %339
  %341 = load ptr, ptr %340, align 8, !tbaa !5
  store ptr %341, ptr %41, align 8, !tbaa !5
  %342 = load ptr, ptr %41, align 8, !tbaa !5
  %343 = ptrtoint ptr %342 to i64
  %344 = and i64 %343, 3
  %345 = trunc i64 %344 to i32
  %346 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  store i32 %345, ptr %346, align 8, !tbaa !13
  %347 = load ptr, ptr %41, align 8, !tbaa !5
  %348 = ptrtoint ptr %347 to i64
  %349 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %350 = load i32, ptr %349, align 8, !tbaa !13
  %351 = sext i32 %350 to i64
  %352 = xor i64 %348, %351
  %353 = inttoptr i64 %352 to ptr
  %354 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  store ptr %353, ptr %354, align 8, !tbaa !11
  %355 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  %356 = load ptr, ptr %355, align 8, !tbaa !11
  %357 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %358 = load i32, ptr %357, align 8, !tbaa !13
  %359 = add nsw i32 %358, 3
  %360 = sext i32 %359 to i64
  %361 = getelementptr inbounds ptr, ptr %356, i64 %360
  %362 = load ptr, ptr %361, align 8, !tbaa !5
  store ptr %362, ptr %36, align 8, !tbaa !5
  br label %363

363:                                              ; preds = %371, %332
  %364 = load ptr, ptr %36, align 8, !tbaa !5
  %365 = getelementptr inbounds float, ptr %364, i64 1
  %366 = load float, ptr %365, align 4, !tbaa !17
  %367 = load ptr, ptr %28, align 8, !tbaa !5
  %368 = getelementptr inbounds float, ptr %367, i64 1
  %369 = load float, ptr %368, align 4, !tbaa !17
  %370 = fcmp ogt float %366, %369
  br i1 %370, label %371, label %415

371:                                              ; preds = %363
  %372 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  %373 = load ptr, ptr %372, align 8, !tbaa !11
  %374 = load ptr, ptr %13, align 8, !tbaa !5
  %375 = getelementptr inbounds %struct.otri, ptr %374, i32 0, i32 0
  store ptr %373, ptr %375, align 8, !tbaa !11
  %376 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %377 = load i32, ptr %376, align 8, !tbaa !13
  %378 = sext i32 %377 to i64
  %379 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %378
  %380 = load i32, ptr %379, align 4, !tbaa !9
  %381 = load ptr, ptr %13, align 8, !tbaa !5
  %382 = getelementptr inbounds %struct.otri, ptr %381, i32 0, i32 1
  store i32 %380, ptr %382, align 8, !tbaa !13
  %383 = load ptr, ptr %28, align 8, !tbaa !5
  store ptr %383, ptr %30, align 8, !tbaa !5
  %384 = load ptr, ptr %36, align 8, !tbaa !5
  store ptr %384, ptr %28, align 8, !tbaa !5
  %385 = load ptr, ptr %13, align 8, !tbaa !5
  %386 = getelementptr inbounds %struct.otri, ptr %385, i32 0, i32 0
  %387 = load ptr, ptr %386, align 8, !tbaa !11
  %388 = load ptr, ptr %13, align 8, !tbaa !5
  %389 = getelementptr inbounds %struct.otri, ptr %388, i32 0, i32 1
  %390 = load i32, ptr %389, align 8, !tbaa !13
  %391 = sext i32 %390 to i64
  %392 = getelementptr inbounds ptr, ptr %387, i64 %391
  %393 = load ptr, ptr %392, align 8, !tbaa !5
  store ptr %393, ptr %41, align 8, !tbaa !5
  %394 = load ptr, ptr %41, align 8, !tbaa !5
  %395 = ptrtoint ptr %394 to i64
  %396 = and i64 %395, 3
  %397 = trunc i64 %396 to i32
  %398 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  store i32 %397, ptr %398, align 8, !tbaa !13
  %399 = load ptr, ptr %41, align 8, !tbaa !5
  %400 = ptrtoint ptr %399 to i64
  %401 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %402 = load i32, ptr %401, align 8, !tbaa !13
  %403 = sext i32 %402 to i64
  %404 = xor i64 %400, %403
  %405 = inttoptr i64 %404 to ptr
  %406 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  store ptr %405, ptr %406, align 8, !tbaa !11
  %407 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  %408 = load ptr, ptr %407, align 8, !tbaa !11
  %409 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %410 = load i32, ptr %409, align 8, !tbaa !13
  %411 = add nsw i32 %410, 3
  %412 = sext i32 %411 to i64
  %413 = getelementptr inbounds ptr, ptr %408, i64 %412
  %414 = load ptr, ptr %413, align 8, !tbaa !5
  store ptr %414, ptr %36, align 8, !tbaa !5
  br label %363, !llvm.loop !22

415:                                              ; preds = %363
  br label %416

416:                                              ; preds = %415, %92, %7
  br label %417

417:                                              ; preds = %526, %416
  store i32 0, ptr %37, align 4, !tbaa !9
  %418 = load ptr, ptr %8, align 8, !tbaa !5
  %419 = load ptr, ptr %9, align 8, !tbaa !5
  %420 = load ptr, ptr %23, align 8, !tbaa !5
  %421 = load ptr, ptr %25, align 8, !tbaa !5
  %422 = load ptr, ptr %24, align 8, !tbaa !5
  %423 = call float @counterclockwise(ptr noundef %418, ptr noundef %419, ptr noundef %420, ptr noundef %421, ptr noundef %422)
  %424 = fpext float %423 to double
  %425 = fcmp ogt double %424, 0.000000e+00
  br i1 %425, label %426, label %471

426:                                              ; preds = %417
  %427 = load ptr, ptr %11, align 8, !tbaa !5
  %428 = getelementptr inbounds %struct.otri, ptr %427, i32 0, i32 1
  %429 = load i32, ptr %428, align 8, !tbaa !13
  %430 = sext i32 %429 to i64
  %431 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %430
  %432 = load i32, ptr %431, align 4, !tbaa !9
  %433 = load ptr, ptr %11, align 8, !tbaa !5
  %434 = getelementptr inbounds %struct.otri, ptr %433, i32 0, i32 1
  store i32 %432, ptr %434, align 8, !tbaa !13
  %435 = load ptr, ptr %11, align 8, !tbaa !5
  %436 = getelementptr inbounds %struct.otri, ptr %435, i32 0, i32 0
  %437 = load ptr, ptr %436, align 8, !tbaa !11
  %438 = load ptr, ptr %11, align 8, !tbaa !5
  %439 = getelementptr inbounds %struct.otri, ptr %438, i32 0, i32 1
  %440 = load i32, ptr %439, align 8, !tbaa !13
  %441 = sext i32 %440 to i64
  %442 = getelementptr inbounds ptr, ptr %437, i64 %441
  %443 = load ptr, ptr %442, align 8, !tbaa !5
  store ptr %443, ptr %41, align 8, !tbaa !5
  %444 = load ptr, ptr %41, align 8, !tbaa !5
  %445 = ptrtoint ptr %444 to i64
  %446 = and i64 %445, 3
  %447 = trunc i64 %446 to i32
  %448 = load ptr, ptr %11, align 8, !tbaa !5
  %449 = getelementptr inbounds %struct.otri, ptr %448, i32 0, i32 1
  store i32 %447, ptr %449, align 8, !tbaa !13
  %450 = load ptr, ptr %41, align 8, !tbaa !5
  %451 = ptrtoint ptr %450 to i64
  %452 = load ptr, ptr %11, align 8, !tbaa !5
  %453 = getelementptr inbounds %struct.otri, ptr %452, i32 0, i32 1
  %454 = load i32, ptr %453, align 8, !tbaa !13
  %455 = sext i32 %454 to i64
  %456 = xor i64 %451, %455
  %457 = inttoptr i64 %456 to ptr
  %458 = load ptr, ptr %11, align 8, !tbaa !5
  %459 = getelementptr inbounds %struct.otri, ptr %458, i32 0, i32 0
  store ptr %457, ptr %459, align 8, !tbaa !11
  %460 = load ptr, ptr %25, align 8, !tbaa !5
  store ptr %460, ptr %23, align 8, !tbaa !5
  %461 = load ptr, ptr %11, align 8, !tbaa !5
  %462 = getelementptr inbounds %struct.otri, ptr %461, i32 0, i32 0
  %463 = load ptr, ptr %462, align 8, !tbaa !11
  %464 = load ptr, ptr %11, align 8, !tbaa !5
  %465 = getelementptr inbounds %struct.otri, ptr %464, i32 0, i32 1
  %466 = load i32, ptr %465, align 8, !tbaa !13
  %467 = add nsw i32 %466, 3
  %468 = sext i32 %467 to i64
  %469 = getelementptr inbounds ptr, ptr %463, i64 %468
  %470 = load ptr, ptr %469, align 8, !tbaa !5
  store ptr %470, ptr %25, align 8, !tbaa !5
  store i32 1, ptr %37, align 4, !tbaa !9
  br label %471

471:                                              ; preds = %426, %417
  %472 = load ptr, ptr %8, align 8, !tbaa !5
  %473 = load ptr, ptr %9, align 8, !tbaa !5
  %474 = load ptr, ptr %26, align 8, !tbaa !5
  %475 = load ptr, ptr %24, align 8, !tbaa !5
  %476 = load ptr, ptr %23, align 8, !tbaa !5
  %477 = call float @counterclockwise(ptr noundef %472, ptr noundef %473, ptr noundef %474, ptr noundef %475, ptr noundef %476)
  %478 = fpext float %477 to double
  %479 = fcmp ogt double %478, 0.000000e+00
  br i1 %479, label %480, label %525

480:                                              ; preds = %471
  %481 = load ptr, ptr %12, align 8, !tbaa !5
  %482 = getelementptr inbounds %struct.otri, ptr %481, i32 0, i32 1
  %483 = load i32, ptr %482, align 8, !tbaa !13
  %484 = sext i32 %483 to i64
  %485 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %484
  %486 = load i32, ptr %485, align 4, !tbaa !9
  %487 = load ptr, ptr %12, align 8, !tbaa !5
  %488 = getelementptr inbounds %struct.otri, ptr %487, i32 0, i32 1
  store i32 %486, ptr %488, align 8, !tbaa !13
  %489 = load ptr, ptr %12, align 8, !tbaa !5
  %490 = getelementptr inbounds %struct.otri, ptr %489, i32 0, i32 0
  %491 = load ptr, ptr %490, align 8, !tbaa !11
  %492 = load ptr, ptr %12, align 8, !tbaa !5
  %493 = getelementptr inbounds %struct.otri, ptr %492, i32 0, i32 1
  %494 = load i32, ptr %493, align 8, !tbaa !13
  %495 = sext i32 %494 to i64
  %496 = getelementptr inbounds ptr, ptr %491, i64 %495
  %497 = load ptr, ptr %496, align 8, !tbaa !5
  store ptr %497, ptr %41, align 8, !tbaa !5
  %498 = load ptr, ptr %41, align 8, !tbaa !5
  %499 = ptrtoint ptr %498 to i64
  %500 = and i64 %499, 3
  %501 = trunc i64 %500 to i32
  %502 = load ptr, ptr %12, align 8, !tbaa !5
  %503 = getelementptr inbounds %struct.otri, ptr %502, i32 0, i32 1
  store i32 %501, ptr %503, align 8, !tbaa !13
  %504 = load ptr, ptr %41, align 8, !tbaa !5
  %505 = ptrtoint ptr %504 to i64
  %506 = load ptr, ptr %12, align 8, !tbaa !5
  %507 = getelementptr inbounds %struct.otri, ptr %506, i32 0, i32 1
  %508 = load i32, ptr %507, align 8, !tbaa !13
  %509 = sext i32 %508 to i64
  %510 = xor i64 %505, %509
  %511 = inttoptr i64 %510 to ptr
  %512 = load ptr, ptr %12, align 8, !tbaa !5
  %513 = getelementptr inbounds %struct.otri, ptr %512, i32 0, i32 0
  store ptr %511, ptr %513, align 8, !tbaa !11
  %514 = load ptr, ptr %26, align 8, !tbaa !5
  store ptr %514, ptr %24, align 8, !tbaa !5
  %515 = load ptr, ptr %12, align 8, !tbaa !5
  %516 = getelementptr inbounds %struct.otri, ptr %515, i32 0, i32 0
  %517 = load ptr, ptr %516, align 8, !tbaa !11
  %518 = load ptr, ptr %12, align 8, !tbaa !5
  %519 = getelementptr inbounds %struct.otri, ptr %518, i32 0, i32 1
  %520 = load i32, ptr %519, align 8, !tbaa !13
  %521 = add nsw i32 %520, 3
  %522 = sext i32 %521 to i64
  %523 = getelementptr inbounds ptr, ptr %517, i64 %522
  %524 = load ptr, ptr %523, align 8, !tbaa !5
  store ptr %524, ptr %26, align 8, !tbaa !5
  store i32 1, ptr %37, align 4, !tbaa !9
  br label %525

525:                                              ; preds = %480, %471
  br label %526

526:                                              ; preds = %525
  %527 = load i32, ptr %37, align 4, !tbaa !9
  %528 = icmp ne i32 %527, 0
  br i1 %528, label %417, label %529, !llvm.loop !23

529:                                              ; preds = %526
  %530 = load ptr, ptr %11, align 8, !tbaa !5
  %531 = getelementptr inbounds %struct.otri, ptr %530, i32 0, i32 0
  %532 = load ptr, ptr %531, align 8, !tbaa !11
  %533 = load ptr, ptr %11, align 8, !tbaa !5
  %534 = getelementptr inbounds %struct.otri, ptr %533, i32 0, i32 1
  %535 = load i32, ptr %534, align 8, !tbaa !13
  %536 = sext i32 %535 to i64
  %537 = getelementptr inbounds ptr, ptr %532, i64 %536
  %538 = load ptr, ptr %537, align 8, !tbaa !5
  store ptr %538, ptr %41, align 8, !tbaa !5
  %539 = load ptr, ptr %41, align 8, !tbaa !5
  %540 = ptrtoint ptr %539 to i64
  %541 = and i64 %540, 3
  %542 = trunc i64 %541 to i32
  %543 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  store i32 %542, ptr %543, align 8, !tbaa !13
  %544 = load ptr, ptr %41, align 8, !tbaa !5
  %545 = ptrtoint ptr %544 to i64
  %546 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %547 = load i32, ptr %546, align 8, !tbaa !13
  %548 = sext i32 %547 to i64
  %549 = xor i64 %545, %548
  %550 = inttoptr i64 %549 to ptr
  %551 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  store ptr %550, ptr %551, align 8, !tbaa !11
  %552 = load ptr, ptr %12, align 8, !tbaa !5
  %553 = getelementptr inbounds %struct.otri, ptr %552, i32 0, i32 0
  %554 = load ptr, ptr %553, align 8, !tbaa !11
  %555 = load ptr, ptr %12, align 8, !tbaa !5
  %556 = getelementptr inbounds %struct.otri, ptr %555, i32 0, i32 1
  %557 = load i32, ptr %556, align 8, !tbaa !13
  %558 = sext i32 %557 to i64
  %559 = getelementptr inbounds ptr, ptr %554, i64 %558
  %560 = load ptr, ptr %559, align 8, !tbaa !5
  store ptr %560, ptr %41, align 8, !tbaa !5
  %561 = load ptr, ptr %41, align 8, !tbaa !5
  %562 = ptrtoint ptr %561 to i64
  %563 = and i64 %562, 3
  %564 = trunc i64 %563 to i32
  %565 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  store i32 %564, ptr %565, align 8, !tbaa !13
  %566 = load ptr, ptr %41, align 8, !tbaa !5
  %567 = ptrtoint ptr %566 to i64
  %568 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %569 = load i32, ptr %568, align 8, !tbaa !13
  %570 = sext i32 %569 to i64
  %571 = xor i64 %567, %570
  %572 = inttoptr i64 %571 to ptr
  %573 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  store ptr %572, ptr %573, align 8, !tbaa !11
  %574 = load ptr, ptr %8, align 8, !tbaa !5
  %575 = load ptr, ptr %9, align 8, !tbaa !5
  call void @maketriangle(ptr noundef %574, ptr noundef %575, ptr noundef %17)
  %576 = load ptr, ptr %11, align 8, !tbaa !5
  %577 = getelementptr inbounds %struct.otri, ptr %576, i32 0, i32 0
  %578 = load ptr, ptr %577, align 8, !tbaa !11
  %579 = ptrtoint ptr %578 to i64
  %580 = load ptr, ptr %11, align 8, !tbaa !5
  %581 = getelementptr inbounds %struct.otri, ptr %580, i32 0, i32 1
  %582 = load i32, ptr %581, align 8, !tbaa !13
  %583 = sext i32 %582 to i64
  %584 = or i64 %579, %583
  %585 = inttoptr i64 %584 to ptr
  %586 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %587 = load ptr, ptr %586, align 8, !tbaa !11
  %588 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %589 = load i32, ptr %588, align 8, !tbaa !13
  %590 = sext i32 %589 to i64
  %591 = getelementptr inbounds ptr, ptr %587, i64 %590
  store ptr %585, ptr %591, align 8, !tbaa !5
  %592 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %593 = load ptr, ptr %592, align 8, !tbaa !11
  %594 = ptrtoint ptr %593 to i64
  %595 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %596 = load i32, ptr %595, align 8, !tbaa !13
  %597 = sext i32 %596 to i64
  %598 = or i64 %594, %597
  %599 = inttoptr i64 %598 to ptr
  %600 = load ptr, ptr %11, align 8, !tbaa !5
  %601 = getelementptr inbounds %struct.otri, ptr %600, i32 0, i32 0
  %602 = load ptr, ptr %601, align 8, !tbaa !11
  %603 = load ptr, ptr %11, align 8, !tbaa !5
  %604 = getelementptr inbounds %struct.otri, ptr %603, i32 0, i32 1
  %605 = load i32, ptr %604, align 8, !tbaa !13
  %606 = sext i32 %605 to i64
  %607 = getelementptr inbounds ptr, ptr %602, i64 %606
  store ptr %599, ptr %607, align 8, !tbaa !5
  %608 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %609 = load i32, ptr %608, align 8, !tbaa !13
  %610 = sext i32 %609 to i64
  %611 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %610
  %612 = load i32, ptr %611, align 4, !tbaa !9
  %613 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  store i32 %612, ptr %613, align 8, !tbaa !13
  %614 = load ptr, ptr %12, align 8, !tbaa !5
  %615 = getelementptr inbounds %struct.otri, ptr %614, i32 0, i32 0
  %616 = load ptr, ptr %615, align 8, !tbaa !11
  %617 = ptrtoint ptr %616 to i64
  %618 = load ptr, ptr %12, align 8, !tbaa !5
  %619 = getelementptr inbounds %struct.otri, ptr %618, i32 0, i32 1
  %620 = load i32, ptr %619, align 8, !tbaa !13
  %621 = sext i32 %620 to i64
  %622 = or i64 %617, %621
  %623 = inttoptr i64 %622 to ptr
  %624 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %625 = load ptr, ptr %624, align 8, !tbaa !11
  %626 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %627 = load i32, ptr %626, align 8, !tbaa !13
  %628 = sext i32 %627 to i64
  %629 = getelementptr inbounds ptr, ptr %625, i64 %628
  store ptr %623, ptr %629, align 8, !tbaa !5
  %630 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %631 = load ptr, ptr %630, align 8, !tbaa !11
  %632 = ptrtoint ptr %631 to i64
  %633 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %634 = load i32, ptr %633, align 8, !tbaa !13
  %635 = sext i32 %634 to i64
  %636 = or i64 %632, %635
  %637 = inttoptr i64 %636 to ptr
  %638 = load ptr, ptr %12, align 8, !tbaa !5
  %639 = getelementptr inbounds %struct.otri, ptr %638, i32 0, i32 0
  %640 = load ptr, ptr %639, align 8, !tbaa !11
  %641 = load ptr, ptr %12, align 8, !tbaa !5
  %642 = getelementptr inbounds %struct.otri, ptr %641, i32 0, i32 1
  %643 = load i32, ptr %642, align 8, !tbaa !13
  %644 = sext i32 %643 to i64
  %645 = getelementptr inbounds ptr, ptr %640, i64 %644
  store ptr %637, ptr %645, align 8, !tbaa !5
  %646 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %647 = load i32, ptr %646, align 8, !tbaa !13
  %648 = sext i32 %647 to i64
  %649 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %648
  %650 = load i32, ptr %649, align 4, !tbaa !9
  %651 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  store i32 %650, ptr %651, align 8, !tbaa !13
  %652 = load ptr, ptr %24, align 8, !tbaa !5
  %653 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %654 = load ptr, ptr %653, align 8, !tbaa !11
  %655 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %656 = load i32, ptr %655, align 8, !tbaa !13
  %657 = sext i32 %656 to i64
  %658 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %657
  %659 = load i32, ptr %658, align 4, !tbaa !9
  %660 = add nsw i32 %659, 3
  %661 = sext i32 %660 to i64
  %662 = getelementptr inbounds ptr, ptr %654, i64 %661
  store ptr %652, ptr %662, align 8, !tbaa !5
  %663 = load ptr, ptr %23, align 8, !tbaa !5
  %664 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %665 = load ptr, ptr %664, align 8, !tbaa !11
  %666 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %667 = load i32, ptr %666, align 8, !tbaa !13
  %668 = sext i32 %667 to i64
  %669 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %668
  %670 = load i32, ptr %669, align 4, !tbaa !9
  %671 = add nsw i32 %670, 3
  %672 = sext i32 %671 to i64
  %673 = getelementptr inbounds ptr, ptr %665, i64 %672
  store ptr %663, ptr %673, align 8, !tbaa !5
  %674 = load ptr, ptr %9, align 8, !tbaa !5
  %675 = getelementptr inbounds %struct.behavior, ptr %674, i32 0, i32 29
  %676 = load i32, ptr %675, align 4, !tbaa !24
  %677 = icmp sgt i32 %676, 2
  br i1 %677, label %678, label %682

678:                                              ; preds = %529
  %679 = call i32 (ptr, ...) @printf(ptr noundef @.str.59)
  %680 = load ptr, ptr %8, align 8, !tbaa !5
  %681 = load ptr, ptr %9, align 8, !tbaa !5
  call void @printtriangle(ptr noundef %680, ptr noundef %681, ptr noundef %17)
  br label %682

682:                                              ; preds = %678, %529
  %683 = load ptr, ptr %10, align 8, !tbaa !5
  %684 = getelementptr inbounds %struct.otri, ptr %683, i32 0, i32 0
  %685 = load ptr, ptr %684, align 8, !tbaa !11
  %686 = load ptr, ptr %10, align 8, !tbaa !5
  %687 = getelementptr inbounds %struct.otri, ptr %686, i32 0, i32 1
  %688 = load i32, ptr %687, align 8, !tbaa !13
  %689 = sext i32 %688 to i64
  %690 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %689
  %691 = load i32, ptr %690, align 4, !tbaa !9
  %692 = add nsw i32 %691, 3
  %693 = sext i32 %692 to i64
  %694 = getelementptr inbounds ptr, ptr %685, i64 %693
  %695 = load ptr, ptr %694, align 8, !tbaa !5
  store ptr %695, ptr %27, align 8, !tbaa !5
  %696 = load ptr, ptr %23, align 8, !tbaa !5
  %697 = load ptr, ptr %27, align 8, !tbaa !5
  %698 = icmp eq ptr %696, %697
  br i1 %698, label %699, label %711

699:                                              ; preds = %682
  %700 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %701 = load ptr, ptr %700, align 8, !tbaa !11
  %702 = load ptr, ptr %10, align 8, !tbaa !5
  %703 = getelementptr inbounds %struct.otri, ptr %702, i32 0, i32 0
  store ptr %701, ptr %703, align 8, !tbaa !11
  %704 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %705 = load i32, ptr %704, align 8, !tbaa !13
  %706 = sext i32 %705 to i64
  %707 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %706
  %708 = load i32, ptr %707, align 4, !tbaa !9
  %709 = load ptr, ptr %10, align 8, !tbaa !5
  %710 = getelementptr inbounds %struct.otri, ptr %709, i32 0, i32 1
  store i32 %708, ptr %710, align 8, !tbaa !13
  br label %711

711:                                              ; preds = %699, %682
  %712 = load ptr, ptr %13, align 8, !tbaa !5
  %713 = getelementptr inbounds %struct.otri, ptr %712, i32 0, i32 0
  %714 = load ptr, ptr %713, align 8, !tbaa !11
  %715 = load ptr, ptr %13, align 8, !tbaa !5
  %716 = getelementptr inbounds %struct.otri, ptr %715, i32 0, i32 1
  %717 = load i32, ptr %716, align 8, !tbaa !13
  %718 = sext i32 %717 to i64
  %719 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %718
  %720 = load i32, ptr %719, align 4, !tbaa !9
  %721 = add nsw i32 %720, 3
  %722 = sext i32 %721 to i64
  %723 = getelementptr inbounds ptr, ptr %714, i64 %722
  %724 = load ptr, ptr %723, align 8, !tbaa !5
  store ptr %724, ptr %28, align 8, !tbaa !5
  %725 = load ptr, ptr %24, align 8, !tbaa !5
  %726 = load ptr, ptr %28, align 8, !tbaa !5
  %727 = icmp eq ptr %725, %726
  br i1 %727, label %728, label %740

728:                                              ; preds = %711
  %729 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %730 = load ptr, ptr %729, align 8, !tbaa !11
  %731 = load ptr, ptr %13, align 8, !tbaa !5
  %732 = getelementptr inbounds %struct.otri, ptr %731, i32 0, i32 0
  store ptr %730, ptr %732, align 8, !tbaa !11
  %733 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %734 = load i32, ptr %733, align 8, !tbaa !13
  %735 = sext i32 %734 to i64
  %736 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %735
  %737 = load i32, ptr %736, align 4, !tbaa !9
  %738 = load ptr, ptr %13, align 8, !tbaa !5
  %739 = getelementptr inbounds %struct.otri, ptr %738, i32 0, i32 1
  store i32 %737, ptr %739, align 8, !tbaa !13
  br label %740

740:                                              ; preds = %728, %711
  %741 = load ptr, ptr %23, align 8, !tbaa !5
  store ptr %741, ptr %31, align 8, !tbaa !5
  %742 = load ptr, ptr %24, align 8, !tbaa !5
  store ptr %742, ptr %32, align 8, !tbaa !5
  %743 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  %744 = load ptr, ptr %743, align 8, !tbaa !11
  %745 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %746 = load i32, ptr %745, align 8, !tbaa !13
  %747 = add nsw i32 %746, 3
  %748 = sext i32 %747 to i64
  %749 = getelementptr inbounds ptr, ptr %744, i64 %748
  %750 = load ptr, ptr %749, align 8, !tbaa !5
  store ptr %750, ptr %33, align 8, !tbaa !5
  %751 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  %752 = load ptr, ptr %751, align 8, !tbaa !11
  %753 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %754 = load i32, ptr %753, align 8, !tbaa !13
  %755 = add nsw i32 %754, 3
  %756 = sext i32 %755 to i64
  %757 = getelementptr inbounds ptr, ptr %752, i64 %756
  %758 = load ptr, ptr %757, align 8, !tbaa !5
  store ptr %758, ptr %34, align 8, !tbaa !5
  br label %759

759:                                              ; preds = %1919, %740
  br label %760

760:                                              ; preds = %759
  %761 = load ptr, ptr %8, align 8, !tbaa !5
  %762 = load ptr, ptr %9, align 8, !tbaa !5
  %763 = load ptr, ptr %33, align 8, !tbaa !5
  %764 = load ptr, ptr %31, align 8, !tbaa !5
  %765 = load ptr, ptr %32, align 8, !tbaa !5
  %766 = call float @counterclockwise(ptr noundef %761, ptr noundef %762, ptr noundef %763, ptr noundef %764, ptr noundef %765)
  %767 = fpext float %766 to double
  %768 = fcmp ole double %767, 0.000000e+00
  %769 = zext i1 %768 to i32
  store i32 %769, ptr %39, align 4, !tbaa !9
  %770 = load ptr, ptr %8, align 8, !tbaa !5
  %771 = load ptr, ptr %9, align 8, !tbaa !5
  %772 = load ptr, ptr %34, align 8, !tbaa !5
  %773 = load ptr, ptr %31, align 8, !tbaa !5
  %774 = load ptr, ptr %32, align 8, !tbaa !5
  %775 = call float @counterclockwise(ptr noundef %770, ptr noundef %771, ptr noundef %772, ptr noundef %773, ptr noundef %774)
  %776 = fpext float %775 to double
  %777 = fcmp ole double %776, 0.000000e+00
  %778 = zext i1 %777 to i32
  store i32 %778, ptr %40, align 4, !tbaa !9
  %779 = load i32, ptr %39, align 4, !tbaa !9
  %780 = icmp ne i32 %779, 0
  br i1 %780, label %781, label %1106

781:                                              ; preds = %760
  %782 = load i32, ptr %40, align 4, !tbaa !9
  %783 = icmp ne i32 %782, 0
  br i1 %783, label %784, label %1106

784:                                              ; preds = %781
  %785 = load ptr, ptr %8, align 8, !tbaa !5
  %786 = load ptr, ptr %9, align 8, !tbaa !5
  call void @maketriangle(ptr noundef %785, ptr noundef %786, ptr noundef %18)
  %787 = load ptr, ptr %31, align 8, !tbaa !5
  %788 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %789 = load ptr, ptr %788, align 8, !tbaa !11
  %790 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %791 = load i32, ptr %790, align 8, !tbaa !13
  %792 = sext i32 %791 to i64
  %793 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %792
  %794 = load i32, ptr %793, align 4, !tbaa !9
  %795 = add nsw i32 %794, 3
  %796 = sext i32 %795 to i64
  %797 = getelementptr inbounds ptr, ptr %789, i64 %796
  store ptr %787, ptr %797, align 8, !tbaa !5
  %798 = load ptr, ptr %32, align 8, !tbaa !5
  %799 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %800 = load ptr, ptr %799, align 8, !tbaa !11
  %801 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %802 = load i32, ptr %801, align 8, !tbaa !13
  %803 = sext i32 %802 to i64
  %804 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %803
  %805 = load i32, ptr %804, align 4, !tbaa !9
  %806 = add nsw i32 %805, 3
  %807 = sext i32 %806 to i64
  %808 = getelementptr inbounds ptr, ptr %800, i64 %807
  store ptr %798, ptr %808, align 8, !tbaa !5
  %809 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %810 = load ptr, ptr %809, align 8, !tbaa !11
  %811 = ptrtoint ptr %810 to i64
  %812 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %813 = load i32, ptr %812, align 8, !tbaa !13
  %814 = sext i32 %813 to i64
  %815 = or i64 %811, %814
  %816 = inttoptr i64 %815 to ptr
  %817 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %818 = load ptr, ptr %817, align 8, !tbaa !11
  %819 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %820 = load i32, ptr %819, align 8, !tbaa !13
  %821 = sext i32 %820 to i64
  %822 = getelementptr inbounds ptr, ptr %818, i64 %821
  store ptr %816, ptr %822, align 8, !tbaa !5
  %823 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %824 = load ptr, ptr %823, align 8, !tbaa !11
  %825 = ptrtoint ptr %824 to i64
  %826 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %827 = load i32, ptr %826, align 8, !tbaa !13
  %828 = sext i32 %827 to i64
  %829 = or i64 %825, %828
  %830 = inttoptr i64 %829 to ptr
  %831 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %832 = load ptr, ptr %831, align 8, !tbaa !11
  %833 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %834 = load i32, ptr %833, align 8, !tbaa !13
  %835 = sext i32 %834 to i64
  %836 = getelementptr inbounds ptr, ptr %832, i64 %835
  store ptr %830, ptr %836, align 8, !tbaa !5
  %837 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %838 = load i32, ptr %837, align 8, !tbaa !13
  %839 = sext i32 %838 to i64
  %840 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %839
  %841 = load i32, ptr %840, align 4, !tbaa !9
  %842 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  store i32 %841, ptr %842, align 8, !tbaa !13
  %843 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  %844 = load ptr, ptr %843, align 8, !tbaa !11
  %845 = ptrtoint ptr %844 to i64
  %846 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %847 = load i32, ptr %846, align 8, !tbaa !13
  %848 = sext i32 %847 to i64
  %849 = or i64 %845, %848
  %850 = inttoptr i64 %849 to ptr
  %851 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %852 = load ptr, ptr %851, align 8, !tbaa !11
  %853 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %854 = load i32, ptr %853, align 8, !tbaa !13
  %855 = sext i32 %854 to i64
  %856 = getelementptr inbounds ptr, ptr %852, i64 %855
  store ptr %850, ptr %856, align 8, !tbaa !5
  %857 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %858 = load ptr, ptr %857, align 8, !tbaa !11
  %859 = ptrtoint ptr %858 to i64
  %860 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %861 = load i32, ptr %860, align 8, !tbaa !13
  %862 = sext i32 %861 to i64
  %863 = or i64 %859, %862
  %864 = inttoptr i64 %863 to ptr
  %865 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  %866 = load ptr, ptr %865, align 8, !tbaa !11
  %867 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %868 = load i32, ptr %867, align 8, !tbaa !13
  %869 = sext i32 %868 to i64
  %870 = getelementptr inbounds ptr, ptr %866, i64 %869
  store ptr %864, ptr %870, align 8, !tbaa !5
  %871 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %872 = load i32, ptr %871, align 8, !tbaa !13
  %873 = sext i32 %872 to i64
  %874 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %873
  %875 = load i32, ptr %874, align 4, !tbaa !9
  %876 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  store i32 %875, ptr %876, align 8, !tbaa !13
  %877 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  %878 = load ptr, ptr %877, align 8, !tbaa !11
  %879 = ptrtoint ptr %878 to i64
  %880 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %881 = load i32, ptr %880, align 8, !tbaa !13
  %882 = sext i32 %881 to i64
  %883 = or i64 %879, %882
  %884 = inttoptr i64 %883 to ptr
  %885 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %886 = load ptr, ptr %885, align 8, !tbaa !11
  %887 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %888 = load i32, ptr %887, align 8, !tbaa !13
  %889 = sext i32 %888 to i64
  %890 = getelementptr inbounds ptr, ptr %886, i64 %889
  store ptr %884, ptr %890, align 8, !tbaa !5
  %891 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %892 = load ptr, ptr %891, align 8, !tbaa !11
  %893 = ptrtoint ptr %892 to i64
  %894 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %895 = load i32, ptr %894, align 8, !tbaa !13
  %896 = sext i32 %895 to i64
  %897 = or i64 %893, %896
  %898 = inttoptr i64 %897 to ptr
  %899 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  %900 = load ptr, ptr %899, align 8, !tbaa !11
  %901 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %902 = load i32, ptr %901, align 8, !tbaa !13
  %903 = sext i32 %902 to i64
  %904 = getelementptr inbounds ptr, ptr %900, i64 %903
  store ptr %898, ptr %904, align 8, !tbaa !5
  %905 = load ptr, ptr %9, align 8, !tbaa !5
  %906 = getelementptr inbounds %struct.behavior, ptr %905, i32 0, i32 29
  %907 = load i32, ptr %906, align 4, !tbaa !24
  %908 = icmp sgt i32 %907, 2
  br i1 %908, label %909, label %913

909:                                              ; preds = %784
  %910 = call i32 (ptr, ...) @printf(ptr noundef @.str.60)
  %911 = load ptr, ptr %8, align 8, !tbaa !5
  %912 = load ptr, ptr %9, align 8, !tbaa !5
  call void @printtriangle(ptr noundef %911, ptr noundef %912, ptr noundef %18)
  br label %913

913:                                              ; preds = %909, %784
  %914 = load ptr, ptr %9, align 8, !tbaa !5
  %915 = getelementptr inbounds %struct.behavior, ptr %914, i32 0, i32 25
  %916 = load i32, ptr %915, align 4, !tbaa !14
  %917 = icmp ne i32 %916, 0
  br i1 %917, label %918, label %1105

918:                                              ; preds = %913
  %919 = load i32, ptr %14, align 4, !tbaa !9
  %920 = icmp eq i32 %919, 1
  br i1 %920, label %921, label %1105

921:                                              ; preds = %918
  %922 = load ptr, ptr %10, align 8, !tbaa !5
  %923 = getelementptr inbounds %struct.otri, ptr %922, i32 0, i32 0
  %924 = load ptr, ptr %923, align 8, !tbaa !11
  %925 = load ptr, ptr %10, align 8, !tbaa !5
  %926 = getelementptr inbounds %struct.otri, ptr %925, i32 0, i32 1
  %927 = load i32, ptr %926, align 8, !tbaa !13
  %928 = sext i32 %927 to i64
  %929 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %928
  %930 = load i32, ptr %929, align 4, !tbaa !9
  %931 = add nsw i32 %930, 3
  %932 = sext i32 %931 to i64
  %933 = getelementptr inbounds ptr, ptr %924, i64 %932
  %934 = load ptr, ptr %933, align 8, !tbaa !5
  store ptr %934, ptr %27, align 8, !tbaa !5
  %935 = load ptr, ptr %10, align 8, !tbaa !5
  %936 = getelementptr inbounds %struct.otri, ptr %935, i32 0, i32 0
  %937 = load ptr, ptr %936, align 8, !tbaa !11
  %938 = load ptr, ptr %10, align 8, !tbaa !5
  %939 = getelementptr inbounds %struct.otri, ptr %938, i32 0, i32 1
  %940 = load i32, ptr %939, align 8, !tbaa !13
  %941 = add nsw i32 %940, 3
  %942 = sext i32 %941 to i64
  %943 = getelementptr inbounds ptr, ptr %937, i64 %942
  %944 = load ptr, ptr %943, align 8, !tbaa !5
  store ptr %944, ptr %29, align 8, !tbaa !5
  %945 = load ptr, ptr %13, align 8, !tbaa !5
  %946 = getelementptr inbounds %struct.otri, ptr %945, i32 0, i32 0
  %947 = load ptr, ptr %946, align 8, !tbaa !11
  %948 = load ptr, ptr %13, align 8, !tbaa !5
  %949 = getelementptr inbounds %struct.otri, ptr %948, i32 0, i32 1
  %950 = load i32, ptr %949, align 8, !tbaa !13
  %951 = sext i32 %950 to i64
  %952 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %951
  %953 = load i32, ptr %952, align 4, !tbaa !9
  %954 = add nsw i32 %953, 3
  %955 = sext i32 %954 to i64
  %956 = getelementptr inbounds ptr, ptr %947, i64 %955
  %957 = load ptr, ptr %956, align 8, !tbaa !5
  store ptr %957, ptr %28, align 8, !tbaa !5
  %958 = load ptr, ptr %13, align 8, !tbaa !5
  %959 = getelementptr inbounds %struct.otri, ptr %958, i32 0, i32 0
  %960 = load ptr, ptr %959, align 8, !tbaa !11
  %961 = load ptr, ptr %13, align 8, !tbaa !5
  %962 = getelementptr inbounds %struct.otri, ptr %961, i32 0, i32 1
  %963 = load i32, ptr %962, align 8, !tbaa !13
  %964 = add nsw i32 %963, 3
  %965 = sext i32 %964 to i64
  %966 = getelementptr inbounds ptr, ptr %960, i64 %965
  %967 = load ptr, ptr %966, align 8, !tbaa !5
  store ptr %967, ptr %30, align 8, !tbaa !5
  %968 = load ptr, ptr %10, align 8, !tbaa !5
  %969 = getelementptr inbounds %struct.otri, ptr %968, i32 0, i32 0
  %970 = load ptr, ptr %969, align 8, !tbaa !11
  %971 = load ptr, ptr %10, align 8, !tbaa !5
  %972 = getelementptr inbounds %struct.otri, ptr %971, i32 0, i32 1
  %973 = load i32, ptr %972, align 8, !tbaa !13
  %974 = sext i32 %973 to i64
  %975 = getelementptr inbounds ptr, ptr %970, i64 %974
  %976 = load ptr, ptr %975, align 8, !tbaa !5
  store ptr %976, ptr %41, align 8, !tbaa !5
  %977 = load ptr, ptr %41, align 8, !tbaa !5
  %978 = ptrtoint ptr %977 to i64
  %979 = and i64 %978, 3
  %980 = trunc i64 %979 to i32
  %981 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  store i32 %980, ptr %981, align 8, !tbaa !13
  %982 = load ptr, ptr %41, align 8, !tbaa !5
  %983 = ptrtoint ptr %982 to i64
  %984 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %985 = load i32, ptr %984, align 8, !tbaa !13
  %986 = sext i32 %985 to i64
  %987 = xor i64 %983, %986
  %988 = inttoptr i64 %987 to ptr
  %989 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  store ptr %988, ptr %989, align 8, !tbaa !11
  %990 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  %991 = load ptr, ptr %990, align 8, !tbaa !11
  %992 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %993 = load i32, ptr %992, align 8, !tbaa !13
  %994 = add nsw i32 %993, 3
  %995 = sext i32 %994 to i64
  %996 = getelementptr inbounds ptr, ptr %991, i64 %995
  %997 = load ptr, ptr %996, align 8, !tbaa !5
  store ptr %997, ptr %36, align 8, !tbaa !5
  br label %998

998:                                              ; preds = %1006, %921
  %999 = load ptr, ptr %36, align 8, !tbaa !5
  %1000 = getelementptr inbounds float, ptr %999, i64 0
  %1001 = load float, ptr %1000, align 4, !tbaa !17
  %1002 = load ptr, ptr %27, align 8, !tbaa !5
  %1003 = getelementptr inbounds float, ptr %1002, i64 0
  %1004 = load float, ptr %1003, align 4, !tbaa !17
  %1005 = fcmp olt float %1001, %1004
  br i1 %1005, label %1006, label %1050

1006:                                             ; preds = %998
  %1007 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  %1008 = load ptr, ptr %1007, align 8, !tbaa !11
  %1009 = load ptr, ptr %10, align 8, !tbaa !5
  %1010 = getelementptr inbounds %struct.otri, ptr %1009, i32 0, i32 0
  store ptr %1008, ptr %1010, align 8, !tbaa !11
  %1011 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %1012 = load i32, ptr %1011, align 8, !tbaa !13
  %1013 = sext i32 %1012 to i64
  %1014 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %1013
  %1015 = load i32, ptr %1014, align 4, !tbaa !9
  %1016 = load ptr, ptr %10, align 8, !tbaa !5
  %1017 = getelementptr inbounds %struct.otri, ptr %1016, i32 0, i32 1
  store i32 %1015, ptr %1017, align 8, !tbaa !13
  %1018 = load ptr, ptr %27, align 8, !tbaa !5
  store ptr %1018, ptr %29, align 8, !tbaa !5
  %1019 = load ptr, ptr %36, align 8, !tbaa !5
  store ptr %1019, ptr %27, align 8, !tbaa !5
  %1020 = load ptr, ptr %10, align 8, !tbaa !5
  %1021 = getelementptr inbounds %struct.otri, ptr %1020, i32 0, i32 0
  %1022 = load ptr, ptr %1021, align 8, !tbaa !11
  %1023 = load ptr, ptr %10, align 8, !tbaa !5
  %1024 = getelementptr inbounds %struct.otri, ptr %1023, i32 0, i32 1
  %1025 = load i32, ptr %1024, align 8, !tbaa !13
  %1026 = sext i32 %1025 to i64
  %1027 = getelementptr inbounds ptr, ptr %1022, i64 %1026
  %1028 = load ptr, ptr %1027, align 8, !tbaa !5
  store ptr %1028, ptr %41, align 8, !tbaa !5
  %1029 = load ptr, ptr %41, align 8, !tbaa !5
  %1030 = ptrtoint ptr %1029 to i64
  %1031 = and i64 %1030, 3
  %1032 = trunc i64 %1031 to i32
  %1033 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  store i32 %1032, ptr %1033, align 8, !tbaa !13
  %1034 = load ptr, ptr %41, align 8, !tbaa !5
  %1035 = ptrtoint ptr %1034 to i64
  %1036 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %1037 = load i32, ptr %1036, align 8, !tbaa !13
  %1038 = sext i32 %1037 to i64
  %1039 = xor i64 %1035, %1038
  %1040 = inttoptr i64 %1039 to ptr
  %1041 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  store ptr %1040, ptr %1041, align 8, !tbaa !11
  %1042 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 0
  %1043 = load ptr, ptr %1042, align 8, !tbaa !11
  %1044 = getelementptr inbounds %struct.otri, ptr %22, i32 0, i32 1
  %1045 = load i32, ptr %1044, align 8, !tbaa !13
  %1046 = add nsw i32 %1045, 3
  %1047 = sext i32 %1046 to i64
  %1048 = getelementptr inbounds ptr, ptr %1043, i64 %1047
  %1049 = load ptr, ptr %1048, align 8, !tbaa !5
  store ptr %1049, ptr %36, align 8, !tbaa !5
  br label %998, !llvm.loop !25

1050:                                             ; preds = %998
  br label %1051

1051:                                             ; preds = %1059, %1050
  %1052 = load ptr, ptr %30, align 8, !tbaa !5
  %1053 = getelementptr inbounds float, ptr %1052, i64 0
  %1054 = load float, ptr %1053, align 4, !tbaa !17
  %1055 = load ptr, ptr %28, align 8, !tbaa !5
  %1056 = getelementptr inbounds float, ptr %1055, i64 0
  %1057 = load float, ptr %1056, align 4, !tbaa !17
  %1058 = fcmp ogt float %1054, %1057
  br i1 %1058, label %1059, label %1104

1059:                                             ; preds = %1051
  %1060 = load ptr, ptr %13, align 8, !tbaa !5
  %1061 = getelementptr inbounds %struct.otri, ptr %1060, i32 0, i32 1
  %1062 = load i32, ptr %1061, align 8, !tbaa !13
  %1063 = sext i32 %1062 to i64
  %1064 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %1063
  %1065 = load i32, ptr %1064, align 4, !tbaa !9
  %1066 = load ptr, ptr %13, align 8, !tbaa !5
  %1067 = getelementptr inbounds %struct.otri, ptr %1066, i32 0, i32 1
  store i32 %1065, ptr %1067, align 8, !tbaa !13
  %1068 = load ptr, ptr %13, align 8, !tbaa !5
  %1069 = getelementptr inbounds %struct.otri, ptr %1068, i32 0, i32 0
  %1070 = load ptr, ptr %1069, align 8, !tbaa !11
  %1071 = load ptr, ptr %13, align 8, !tbaa !5
  %1072 = getelementptr inbounds %struct.otri, ptr %1071, i32 0, i32 1
  %1073 = load i32, ptr %1072, align 8, !tbaa !13
  %1074 = sext i32 %1073 to i64
  %1075 = getelementptr inbounds ptr, ptr %1070, i64 %1074
  %1076 = load ptr, ptr %1075, align 8, !tbaa !5
  store ptr %1076, ptr %41, align 8, !tbaa !5
  %1077 = load ptr, ptr %41, align 8, !tbaa !5
  %1078 = ptrtoint ptr %1077 to i64
  %1079 = and i64 %1078, 3
  %1080 = trunc i64 %1079 to i32
  %1081 = load ptr, ptr %13, align 8, !tbaa !5
  %1082 = getelementptr inbounds %struct.otri, ptr %1081, i32 0, i32 1
  store i32 %1080, ptr %1082, align 8, !tbaa !13
  %1083 = load ptr, ptr %41, align 8, !tbaa !5
  %1084 = ptrtoint ptr %1083 to i64
  %1085 = load ptr, ptr %13, align 8, !tbaa !5
  %1086 = getelementptr inbounds %struct.otri, ptr %1085, i32 0, i32 1
  %1087 = load i32, ptr %1086, align 8, !tbaa !13
  %1088 = sext i32 %1087 to i64
  %1089 = xor i64 %1084, %1088
  %1090 = inttoptr i64 %1089 to ptr
  %1091 = load ptr, ptr %13, align 8, !tbaa !5
  %1092 = getelementptr inbounds %struct.otri, ptr %1091, i32 0, i32 0
  store ptr %1090, ptr %1092, align 8, !tbaa !11
  %1093 = load ptr, ptr %30, align 8, !tbaa !5
  store ptr %1093, ptr %28, align 8, !tbaa !5
  %1094 = load ptr, ptr %13, align 8, !tbaa !5
  %1095 = getelementptr inbounds %struct.otri, ptr %1094, i32 0, i32 0
  %1096 = load ptr, ptr %1095, align 8, !tbaa !11
  %1097 = load ptr, ptr %13, align 8, !tbaa !5
  %1098 = getelementptr inbounds %struct.otri, ptr %1097, i32 0, i32 1
  %1099 = load i32, ptr %1098, align 8, !tbaa !13
  %1100 = add nsw i32 %1099, 3
  %1101 = sext i32 %1100 to i64
  %1102 = getelementptr inbounds ptr, ptr %1096, i64 %1101
  %1103 = load ptr, ptr %1102, align 8, !tbaa !5
  store ptr %1103, ptr %30, align 8, !tbaa !5
  br label %1051, !llvm.loop !26

1104:                                             ; preds = %1051
  br label %1105

1105:                                             ; preds = %1104, %918, %913
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #3
  call void @llvm.lifetime.end.p0(i64 16, ptr %22) #3
  call void @llvm.lifetime.end.p0(i64 16, ptr %21) #3
  call void @llvm.lifetime.end.p0(i64 16, ptr %20) #3
  call void @llvm.lifetime.end.p0(i64 16, ptr %19) #3
  call void @llvm.lifetime.end.p0(i64 16, ptr %18) #3
  call void @llvm.lifetime.end.p0(i64 16, ptr %17) #3
  call void @llvm.lifetime.end.p0(i64 16, ptr %16) #3
  call void @llvm.lifetime.end.p0(i64 16, ptr %15) #3
  ret void

1106:                                             ; preds = %781, %760
  %1107 = load i32, ptr %39, align 4, !tbaa !9
  %1108 = icmp ne i32 %1107, 0
  br i1 %1108, label %1422, label %1109

1109:                                             ; preds = %1106
  %1110 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  %1111 = load ptr, ptr %1110, align 8, !tbaa !11
  %1112 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  store ptr %1111, ptr %1112, align 8, !tbaa !11
  %1113 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %1114 = load i32, ptr %1113, align 8, !tbaa !13
  %1115 = sext i32 %1114 to i64
  %1116 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %1115
  %1117 = load i32, ptr %1116, align 4, !tbaa !9
  %1118 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  store i32 %1117, ptr %1118, align 8, !tbaa !13
  %1119 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1120 = load ptr, ptr %1119, align 8, !tbaa !11
  %1121 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1122 = load i32, ptr %1121, align 8, !tbaa !13
  %1123 = sext i32 %1122 to i64
  %1124 = getelementptr inbounds ptr, ptr %1120, i64 %1123
  %1125 = load ptr, ptr %1124, align 8, !tbaa !5
  store ptr %1125, ptr %41, align 8, !tbaa !5
  %1126 = load ptr, ptr %41, align 8, !tbaa !5
  %1127 = ptrtoint ptr %1126 to i64
  %1128 = and i64 %1127, 3
  %1129 = trunc i64 %1128 to i32
  %1130 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  store i32 %1129, ptr %1130, align 8, !tbaa !13
  %1131 = load ptr, ptr %41, align 8, !tbaa !5
  %1132 = ptrtoint ptr %1131 to i64
  %1133 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1134 = load i32, ptr %1133, align 8, !tbaa !13
  %1135 = sext i32 %1134 to i64
  %1136 = xor i64 %1132, %1135
  %1137 = inttoptr i64 %1136 to ptr
  %1138 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  store ptr %1137, ptr %1138, align 8, !tbaa !11
  %1139 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1140 = load ptr, ptr %1139, align 8, !tbaa !11
  %1141 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1142 = load i32, ptr %1141, align 8, !tbaa !13
  %1143 = add nsw i32 %1142, 3
  %1144 = sext i32 %1143 to i64
  %1145 = getelementptr inbounds ptr, ptr %1140, i64 %1144
  %1146 = load ptr, ptr %1145, align 8, !tbaa !5
  store ptr %1146, ptr %35, align 8, !tbaa !5
  %1147 = load ptr, ptr %35, align 8, !tbaa !5
  %1148 = icmp ne ptr %1147, null
  br i1 %1148, label %1149, label %1421

1149:                                             ; preds = %1109
  %1150 = load ptr, ptr %8, align 8, !tbaa !5
  %1151 = load ptr, ptr %9, align 8, !tbaa !5
  %1152 = load ptr, ptr %31, align 8, !tbaa !5
  %1153 = load ptr, ptr %32, align 8, !tbaa !5
  %1154 = load ptr, ptr %33, align 8, !tbaa !5
  %1155 = load ptr, ptr %35, align 8, !tbaa !5
  %1156 = call float @incircle(ptr noundef %1150, ptr noundef %1151, ptr noundef %1152, ptr noundef %1153, ptr noundef %1154, ptr noundef %1155)
  %1157 = fpext float %1156 to double
  %1158 = fcmp ogt double %1157, 0.000000e+00
  %1159 = zext i1 %1158 to i32
  store i32 %1159, ptr %38, align 4, !tbaa !9
  br label %1160

1160:                                             ; preds = %1419, %1149
  %1161 = load i32, ptr %38, align 4, !tbaa !9
  %1162 = icmp ne i32 %1161, 0
  br i1 %1162, label %1163, label %1420

1163:                                             ; preds = %1160
  %1164 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1165 = load i32, ptr %1164, align 8, !tbaa !13
  %1166 = sext i32 %1165 to i64
  %1167 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %1166
  %1168 = load i32, ptr %1167, align 4, !tbaa !9
  %1169 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  store i32 %1168, ptr %1169, align 8, !tbaa !13
  %1170 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1171 = load ptr, ptr %1170, align 8, !tbaa !11
  %1172 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1173 = load i32, ptr %1172, align 8, !tbaa !13
  %1174 = sext i32 %1173 to i64
  %1175 = getelementptr inbounds ptr, ptr %1171, i64 %1174
  %1176 = load ptr, ptr %1175, align 8, !tbaa !5
  store ptr %1176, ptr %41, align 8, !tbaa !5
  %1177 = load ptr, ptr %41, align 8, !tbaa !5
  %1178 = ptrtoint ptr %1177 to i64
  %1179 = and i64 %1178, 3
  %1180 = trunc i64 %1179 to i32
  %1181 = getelementptr inbounds %struct.otri, ptr %20, i32 0, i32 1
  store i32 %1180, ptr %1181, align 8, !tbaa !13
  %1182 = load ptr, ptr %41, align 8, !tbaa !5
  %1183 = ptrtoint ptr %1182 to i64
  %1184 = getelementptr inbounds %struct.otri, ptr %20, i32 0, i32 1
  %1185 = load i32, ptr %1184, align 8, !tbaa !13
  %1186 = sext i32 %1185 to i64
  %1187 = xor i64 %1183, %1186
  %1188 = inttoptr i64 %1187 to ptr
  %1189 = getelementptr inbounds %struct.otri, ptr %20, i32 0, i32 0
  store ptr %1188, ptr %1189, align 8, !tbaa !11
  %1190 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1191 = load i32, ptr %1190, align 8, !tbaa !13
  %1192 = sext i32 %1191 to i64
  %1193 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %1192
  %1194 = load i32, ptr %1193, align 4, !tbaa !9
  %1195 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  store i32 %1194, ptr %1195, align 8, !tbaa !13
  %1196 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1197 = load ptr, ptr %1196, align 8, !tbaa !11
  %1198 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1199 = load i32, ptr %1198, align 8, !tbaa !13
  %1200 = sext i32 %1199 to i64
  %1201 = getelementptr inbounds ptr, ptr %1197, i64 %1200
  %1202 = load ptr, ptr %1201, align 8, !tbaa !5
  store ptr %1202, ptr %41, align 8, !tbaa !5
  %1203 = load ptr, ptr %41, align 8, !tbaa !5
  %1204 = ptrtoint ptr %1203 to i64
  %1205 = and i64 %1204, 3
  %1206 = trunc i64 %1205 to i32
  %1207 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 1
  store i32 %1206, ptr %1207, align 8, !tbaa !13
  %1208 = load ptr, ptr %41, align 8, !tbaa !5
  %1209 = ptrtoint ptr %1208 to i64
  %1210 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 1
  %1211 = load i32, ptr %1210, align 8, !tbaa !13
  %1212 = sext i32 %1211 to i64
  %1213 = xor i64 %1209, %1212
  %1214 = inttoptr i64 %1213 to ptr
  %1215 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 0
  store ptr %1214, ptr %1215, align 8, !tbaa !11
  %1216 = getelementptr inbounds %struct.otri, ptr %20, i32 0, i32 0
  %1217 = load ptr, ptr %1216, align 8, !tbaa !11
  %1218 = ptrtoint ptr %1217 to i64
  %1219 = getelementptr inbounds %struct.otri, ptr %20, i32 0, i32 1
  %1220 = load i32, ptr %1219, align 8, !tbaa !13
  %1221 = sext i32 %1220 to i64
  %1222 = or i64 %1218, %1221
  %1223 = inttoptr i64 %1222 to ptr
  %1224 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1225 = load ptr, ptr %1224, align 8, !tbaa !11
  %1226 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1227 = load i32, ptr %1226, align 8, !tbaa !13
  %1228 = sext i32 %1227 to i64
  %1229 = getelementptr inbounds ptr, ptr %1225, i64 %1228
  store ptr %1223, ptr %1229, align 8, !tbaa !5
  %1230 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1231 = load ptr, ptr %1230, align 8, !tbaa !11
  %1232 = ptrtoint ptr %1231 to i64
  %1233 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1234 = load i32, ptr %1233, align 8, !tbaa !13
  %1235 = sext i32 %1234 to i64
  %1236 = or i64 %1232, %1235
  %1237 = inttoptr i64 %1236 to ptr
  %1238 = getelementptr inbounds %struct.otri, ptr %20, i32 0, i32 0
  %1239 = load ptr, ptr %1238, align 8, !tbaa !11
  %1240 = getelementptr inbounds %struct.otri, ptr %20, i32 0, i32 1
  %1241 = load i32, ptr %1240, align 8, !tbaa !13
  %1242 = sext i32 %1241 to i64
  %1243 = getelementptr inbounds ptr, ptr %1239, i64 %1242
  store ptr %1237, ptr %1243, align 8, !tbaa !5
  %1244 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 0
  %1245 = load ptr, ptr %1244, align 8, !tbaa !11
  %1246 = ptrtoint ptr %1245 to i64
  %1247 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 1
  %1248 = load i32, ptr %1247, align 8, !tbaa !13
  %1249 = sext i32 %1248 to i64
  %1250 = or i64 %1246, %1249
  %1251 = inttoptr i64 %1250 to ptr
  %1252 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  %1253 = load ptr, ptr %1252, align 8, !tbaa !11
  %1254 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %1255 = load i32, ptr %1254, align 8, !tbaa !13
  %1256 = sext i32 %1255 to i64
  %1257 = getelementptr inbounds ptr, ptr %1253, i64 %1256
  store ptr %1251, ptr %1257, align 8, !tbaa !5
  %1258 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  %1259 = load ptr, ptr %1258, align 8, !tbaa !11
  %1260 = ptrtoint ptr %1259 to i64
  %1261 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %1262 = load i32, ptr %1261, align 8, !tbaa !13
  %1263 = sext i32 %1262 to i64
  %1264 = or i64 %1260, %1263
  %1265 = inttoptr i64 %1264 to ptr
  %1266 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 0
  %1267 = load ptr, ptr %1266, align 8, !tbaa !11
  %1268 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 1
  %1269 = load i32, ptr %1268, align 8, !tbaa !13
  %1270 = sext i32 %1269 to i64
  %1271 = getelementptr inbounds ptr, ptr %1267, i64 %1270
  store ptr %1265, ptr %1271, align 8, !tbaa !5
  %1272 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %1273 = load i32, ptr %1272, align 8, !tbaa !13
  %1274 = sext i32 %1273 to i64
  %1275 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %1274
  %1276 = load i32, ptr %1275, align 4, !tbaa !9
  %1277 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  store i32 %1276, ptr %1277, align 8, !tbaa !13
  %1278 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  %1279 = load ptr, ptr %1278, align 8, !tbaa !11
  %1280 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %1281 = load i32, ptr %1280, align 8, !tbaa !13
  %1282 = sext i32 %1281 to i64
  %1283 = getelementptr inbounds ptr, ptr %1279, i64 %1282
  %1284 = load ptr, ptr %1283, align 8, !tbaa !5
  store ptr %1284, ptr %41, align 8, !tbaa !5
  %1285 = load ptr, ptr %41, align 8, !tbaa !5
  %1286 = ptrtoint ptr %1285 to i64
  %1287 = and i64 %1286, 3
  %1288 = trunc i64 %1287 to i32
  %1289 = getelementptr inbounds %struct.otri, ptr %21, i32 0, i32 1
  store i32 %1288, ptr %1289, align 8, !tbaa !13
  %1290 = load ptr, ptr %41, align 8, !tbaa !5
  %1291 = ptrtoint ptr %1290 to i64
  %1292 = getelementptr inbounds %struct.otri, ptr %21, i32 0, i32 1
  %1293 = load i32, ptr %1292, align 8, !tbaa !13
  %1294 = sext i32 %1293 to i64
  %1295 = xor i64 %1291, %1294
  %1296 = inttoptr i64 %1295 to ptr
  %1297 = getelementptr inbounds %struct.otri, ptr %21, i32 0, i32 0
  store ptr %1296, ptr %1297, align 8, !tbaa !11
  %1298 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1299 = load i32, ptr %1298, align 8, !tbaa !13
  %1300 = sext i32 %1299 to i64
  %1301 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %1300
  %1302 = load i32, ptr %1301, align 4, !tbaa !9
  %1303 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  store i32 %1302, ptr %1303, align 8, !tbaa !13
  %1304 = getelementptr inbounds %struct.otri, ptr %21, i32 0, i32 0
  %1305 = load ptr, ptr %1304, align 8, !tbaa !11
  %1306 = ptrtoint ptr %1305 to i64
  %1307 = getelementptr inbounds %struct.otri, ptr %21, i32 0, i32 1
  %1308 = load i32, ptr %1307, align 8, !tbaa !13
  %1309 = sext i32 %1308 to i64
  %1310 = or i64 %1306, %1309
  %1311 = inttoptr i64 %1310 to ptr
  %1312 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1313 = load ptr, ptr %1312, align 8, !tbaa !11
  %1314 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1315 = load i32, ptr %1314, align 8, !tbaa !13
  %1316 = sext i32 %1315 to i64
  %1317 = getelementptr inbounds ptr, ptr %1313, i64 %1316
  store ptr %1311, ptr %1317, align 8, !tbaa !5
  %1318 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1319 = load ptr, ptr %1318, align 8, !tbaa !11
  %1320 = ptrtoint ptr %1319 to i64
  %1321 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1322 = load i32, ptr %1321, align 8, !tbaa !13
  %1323 = sext i32 %1322 to i64
  %1324 = or i64 %1320, %1323
  %1325 = inttoptr i64 %1324 to ptr
  %1326 = getelementptr inbounds %struct.otri, ptr %21, i32 0, i32 0
  %1327 = load ptr, ptr %1326, align 8, !tbaa !11
  %1328 = getelementptr inbounds %struct.otri, ptr %21, i32 0, i32 1
  %1329 = load i32, ptr %1328, align 8, !tbaa !13
  %1330 = sext i32 %1329 to i64
  %1331 = getelementptr inbounds ptr, ptr %1327, i64 %1330
  store ptr %1325, ptr %1331, align 8, !tbaa !5
  %1332 = load ptr, ptr %31, align 8, !tbaa !5
  %1333 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  %1334 = load ptr, ptr %1333, align 8, !tbaa !11
  %1335 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %1336 = load i32, ptr %1335, align 8, !tbaa !13
  %1337 = sext i32 %1336 to i64
  %1338 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %1337
  %1339 = load i32, ptr %1338, align 4, !tbaa !9
  %1340 = add nsw i32 %1339, 3
  %1341 = sext i32 %1340 to i64
  %1342 = getelementptr inbounds ptr, ptr %1334, i64 %1341
  store ptr %1332, ptr %1342, align 8, !tbaa !5
  %1343 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  %1344 = load ptr, ptr %1343, align 8, !tbaa !11
  %1345 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %1346 = load i32, ptr %1345, align 8, !tbaa !13
  %1347 = sext i32 %1346 to i64
  %1348 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %1347
  %1349 = load i32, ptr %1348, align 4, !tbaa !9
  %1350 = add nsw i32 %1349, 3
  %1351 = sext i32 %1350 to i64
  %1352 = getelementptr inbounds ptr, ptr %1344, i64 %1351
  store ptr null, ptr %1352, align 8, !tbaa !5
  %1353 = load ptr, ptr %35, align 8, !tbaa !5
  %1354 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  %1355 = load ptr, ptr %1354, align 8, !tbaa !11
  %1356 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %1357 = load i32, ptr %1356, align 8, !tbaa !13
  %1358 = add nsw i32 %1357, 3
  %1359 = sext i32 %1358 to i64
  %1360 = getelementptr inbounds ptr, ptr %1355, i64 %1359
  store ptr %1353, ptr %1360, align 8, !tbaa !5
  %1361 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1362 = load ptr, ptr %1361, align 8, !tbaa !11
  %1363 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1364 = load i32, ptr %1363, align 8, !tbaa !13
  %1365 = sext i32 %1364 to i64
  %1366 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %1365
  %1367 = load i32, ptr %1366, align 4, !tbaa !9
  %1368 = add nsw i32 %1367, 3
  %1369 = sext i32 %1368 to i64
  %1370 = getelementptr inbounds ptr, ptr %1362, i64 %1369
  store ptr null, ptr %1370, align 8, !tbaa !5
  %1371 = load ptr, ptr %33, align 8, !tbaa !5
  %1372 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1373 = load ptr, ptr %1372, align 8, !tbaa !11
  %1374 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1375 = load i32, ptr %1374, align 8, !tbaa !13
  %1376 = sext i32 %1375 to i64
  %1377 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %1376
  %1378 = load i32, ptr %1377, align 4, !tbaa !9
  %1379 = add nsw i32 %1378, 3
  %1380 = sext i32 %1379 to i64
  %1381 = getelementptr inbounds ptr, ptr %1373, i64 %1380
  store ptr %1371, ptr %1381, align 8, !tbaa !5
  %1382 = load ptr, ptr %35, align 8, !tbaa !5
  %1383 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1384 = load ptr, ptr %1383, align 8, !tbaa !11
  %1385 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1386 = load i32, ptr %1385, align 8, !tbaa !13
  %1387 = add nsw i32 %1386, 3
  %1388 = sext i32 %1387 to i64
  %1389 = getelementptr inbounds ptr, ptr %1384, i64 %1388
  store ptr %1382, ptr %1389, align 8, !tbaa !5
  %1390 = load ptr, ptr %35, align 8, !tbaa !5
  store ptr %1390, ptr %33, align 8, !tbaa !5
  %1391 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 0
  %1392 = load ptr, ptr %1391, align 8, !tbaa !11
  %1393 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  store ptr %1392, ptr %1393, align 8, !tbaa !11
  %1394 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 1
  %1395 = load i32, ptr %1394, align 8, !tbaa !13
  %1396 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  store i32 %1395, ptr %1396, align 8, !tbaa !13
  %1397 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1398 = load ptr, ptr %1397, align 8, !tbaa !11
  %1399 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1400 = load i32, ptr %1399, align 8, !tbaa !13
  %1401 = add nsw i32 %1400, 3
  %1402 = sext i32 %1401 to i64
  %1403 = getelementptr inbounds ptr, ptr %1398, i64 %1402
  %1404 = load ptr, ptr %1403, align 8, !tbaa !5
  store ptr %1404, ptr %35, align 8, !tbaa !5
  %1405 = load ptr, ptr %35, align 8, !tbaa !5
  %1406 = icmp ne ptr %1405, null
  br i1 %1406, label %1407, label %1418

1407:                                             ; preds = %1163
  %1408 = load ptr, ptr %8, align 8, !tbaa !5
  %1409 = load ptr, ptr %9, align 8, !tbaa !5
  %1410 = load ptr, ptr %31, align 8, !tbaa !5
  %1411 = load ptr, ptr %32, align 8, !tbaa !5
  %1412 = load ptr, ptr %33, align 8, !tbaa !5
  %1413 = load ptr, ptr %35, align 8, !tbaa !5
  %1414 = call float @incircle(ptr noundef %1408, ptr noundef %1409, ptr noundef %1410, ptr noundef %1411, ptr noundef %1412, ptr noundef %1413)
  %1415 = fpext float %1414 to double
  %1416 = fcmp ogt double %1415, 0.000000e+00
  %1417 = zext i1 %1416 to i32
  store i32 %1417, ptr %38, align 4, !tbaa !9
  br label %1419

1418:                                             ; preds = %1163
  store i32 0, ptr %38, align 4, !tbaa !9
  br label %1419

1419:                                             ; preds = %1418, %1407
  br label %1160, !llvm.loop !27

1420:                                             ; preds = %1160
  br label %1421

1421:                                             ; preds = %1420, %1109
  br label %1422

1422:                                             ; preds = %1421, %1106
  %1423 = load i32, ptr %40, align 4, !tbaa !9
  %1424 = icmp ne i32 %1423, 0
  br i1 %1424, label %1738, label %1425

1425:                                             ; preds = %1422
  %1426 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  %1427 = load ptr, ptr %1426, align 8, !tbaa !11
  %1428 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  store ptr %1427, ptr %1428, align 8, !tbaa !11
  %1429 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %1430 = load i32, ptr %1429, align 8, !tbaa !13
  %1431 = sext i32 %1430 to i64
  %1432 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %1431
  %1433 = load i32, ptr %1432, align 4, !tbaa !9
  %1434 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  store i32 %1433, ptr %1434, align 8, !tbaa !13
  %1435 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1436 = load ptr, ptr %1435, align 8, !tbaa !11
  %1437 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1438 = load i32, ptr %1437, align 8, !tbaa !13
  %1439 = sext i32 %1438 to i64
  %1440 = getelementptr inbounds ptr, ptr %1436, i64 %1439
  %1441 = load ptr, ptr %1440, align 8, !tbaa !5
  store ptr %1441, ptr %41, align 8, !tbaa !5
  %1442 = load ptr, ptr %41, align 8, !tbaa !5
  %1443 = ptrtoint ptr %1442 to i64
  %1444 = and i64 %1443, 3
  %1445 = trunc i64 %1444 to i32
  %1446 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  store i32 %1445, ptr %1446, align 8, !tbaa !13
  %1447 = load ptr, ptr %41, align 8, !tbaa !5
  %1448 = ptrtoint ptr %1447 to i64
  %1449 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1450 = load i32, ptr %1449, align 8, !tbaa !13
  %1451 = sext i32 %1450 to i64
  %1452 = xor i64 %1448, %1451
  %1453 = inttoptr i64 %1452 to ptr
  %1454 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  store ptr %1453, ptr %1454, align 8, !tbaa !11
  %1455 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1456 = load ptr, ptr %1455, align 8, !tbaa !11
  %1457 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1458 = load i32, ptr %1457, align 8, !tbaa !13
  %1459 = add nsw i32 %1458, 3
  %1460 = sext i32 %1459 to i64
  %1461 = getelementptr inbounds ptr, ptr %1456, i64 %1460
  %1462 = load ptr, ptr %1461, align 8, !tbaa !5
  store ptr %1462, ptr %35, align 8, !tbaa !5
  %1463 = load ptr, ptr %35, align 8, !tbaa !5
  %1464 = icmp ne ptr %1463, null
  br i1 %1464, label %1465, label %1737

1465:                                             ; preds = %1425
  %1466 = load ptr, ptr %8, align 8, !tbaa !5
  %1467 = load ptr, ptr %9, align 8, !tbaa !5
  %1468 = load ptr, ptr %31, align 8, !tbaa !5
  %1469 = load ptr, ptr %32, align 8, !tbaa !5
  %1470 = load ptr, ptr %34, align 8, !tbaa !5
  %1471 = load ptr, ptr %35, align 8, !tbaa !5
  %1472 = call float @incircle(ptr noundef %1466, ptr noundef %1467, ptr noundef %1468, ptr noundef %1469, ptr noundef %1470, ptr noundef %1471)
  %1473 = fpext float %1472 to double
  %1474 = fcmp ogt double %1473, 0.000000e+00
  %1475 = zext i1 %1474 to i32
  store i32 %1475, ptr %38, align 4, !tbaa !9
  br label %1476

1476:                                             ; preds = %1735, %1465
  %1477 = load i32, ptr %38, align 4, !tbaa !9
  %1478 = icmp ne i32 %1477, 0
  br i1 %1478, label %1479, label %1736

1479:                                             ; preds = %1476
  %1480 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1481 = load i32, ptr %1480, align 8, !tbaa !13
  %1482 = sext i32 %1481 to i64
  %1483 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %1482
  %1484 = load i32, ptr %1483, align 4, !tbaa !9
  %1485 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  store i32 %1484, ptr %1485, align 8, !tbaa !13
  %1486 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1487 = load ptr, ptr %1486, align 8, !tbaa !11
  %1488 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1489 = load i32, ptr %1488, align 8, !tbaa !13
  %1490 = sext i32 %1489 to i64
  %1491 = getelementptr inbounds ptr, ptr %1487, i64 %1490
  %1492 = load ptr, ptr %1491, align 8, !tbaa !5
  store ptr %1492, ptr %41, align 8, !tbaa !5
  %1493 = load ptr, ptr %41, align 8, !tbaa !5
  %1494 = ptrtoint ptr %1493 to i64
  %1495 = and i64 %1494, 3
  %1496 = trunc i64 %1495 to i32
  %1497 = getelementptr inbounds %struct.otri, ptr %20, i32 0, i32 1
  store i32 %1496, ptr %1497, align 8, !tbaa !13
  %1498 = load ptr, ptr %41, align 8, !tbaa !5
  %1499 = ptrtoint ptr %1498 to i64
  %1500 = getelementptr inbounds %struct.otri, ptr %20, i32 0, i32 1
  %1501 = load i32, ptr %1500, align 8, !tbaa !13
  %1502 = sext i32 %1501 to i64
  %1503 = xor i64 %1499, %1502
  %1504 = inttoptr i64 %1503 to ptr
  %1505 = getelementptr inbounds %struct.otri, ptr %20, i32 0, i32 0
  store ptr %1504, ptr %1505, align 8, !tbaa !11
  %1506 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1507 = load i32, ptr %1506, align 8, !tbaa !13
  %1508 = sext i32 %1507 to i64
  %1509 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %1508
  %1510 = load i32, ptr %1509, align 4, !tbaa !9
  %1511 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  store i32 %1510, ptr %1511, align 8, !tbaa !13
  %1512 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1513 = load ptr, ptr %1512, align 8, !tbaa !11
  %1514 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1515 = load i32, ptr %1514, align 8, !tbaa !13
  %1516 = sext i32 %1515 to i64
  %1517 = getelementptr inbounds ptr, ptr %1513, i64 %1516
  %1518 = load ptr, ptr %1517, align 8, !tbaa !5
  store ptr %1518, ptr %41, align 8, !tbaa !5
  %1519 = load ptr, ptr %41, align 8, !tbaa !5
  %1520 = ptrtoint ptr %1519 to i64
  %1521 = and i64 %1520, 3
  %1522 = trunc i64 %1521 to i32
  %1523 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 1
  store i32 %1522, ptr %1523, align 8, !tbaa !13
  %1524 = load ptr, ptr %41, align 8, !tbaa !5
  %1525 = ptrtoint ptr %1524 to i64
  %1526 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 1
  %1527 = load i32, ptr %1526, align 8, !tbaa !13
  %1528 = sext i32 %1527 to i64
  %1529 = xor i64 %1525, %1528
  %1530 = inttoptr i64 %1529 to ptr
  %1531 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 0
  store ptr %1530, ptr %1531, align 8, !tbaa !11
  %1532 = getelementptr inbounds %struct.otri, ptr %20, i32 0, i32 0
  %1533 = load ptr, ptr %1532, align 8, !tbaa !11
  %1534 = ptrtoint ptr %1533 to i64
  %1535 = getelementptr inbounds %struct.otri, ptr %20, i32 0, i32 1
  %1536 = load i32, ptr %1535, align 8, !tbaa !13
  %1537 = sext i32 %1536 to i64
  %1538 = or i64 %1534, %1537
  %1539 = inttoptr i64 %1538 to ptr
  %1540 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1541 = load ptr, ptr %1540, align 8, !tbaa !11
  %1542 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1543 = load i32, ptr %1542, align 8, !tbaa !13
  %1544 = sext i32 %1543 to i64
  %1545 = getelementptr inbounds ptr, ptr %1541, i64 %1544
  store ptr %1539, ptr %1545, align 8, !tbaa !5
  %1546 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1547 = load ptr, ptr %1546, align 8, !tbaa !11
  %1548 = ptrtoint ptr %1547 to i64
  %1549 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1550 = load i32, ptr %1549, align 8, !tbaa !13
  %1551 = sext i32 %1550 to i64
  %1552 = or i64 %1548, %1551
  %1553 = inttoptr i64 %1552 to ptr
  %1554 = getelementptr inbounds %struct.otri, ptr %20, i32 0, i32 0
  %1555 = load ptr, ptr %1554, align 8, !tbaa !11
  %1556 = getelementptr inbounds %struct.otri, ptr %20, i32 0, i32 1
  %1557 = load i32, ptr %1556, align 8, !tbaa !13
  %1558 = sext i32 %1557 to i64
  %1559 = getelementptr inbounds ptr, ptr %1555, i64 %1558
  store ptr %1553, ptr %1559, align 8, !tbaa !5
  %1560 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 0
  %1561 = load ptr, ptr %1560, align 8, !tbaa !11
  %1562 = ptrtoint ptr %1561 to i64
  %1563 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 1
  %1564 = load i32, ptr %1563, align 8, !tbaa !13
  %1565 = sext i32 %1564 to i64
  %1566 = or i64 %1562, %1565
  %1567 = inttoptr i64 %1566 to ptr
  %1568 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  %1569 = load ptr, ptr %1568, align 8, !tbaa !11
  %1570 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %1571 = load i32, ptr %1570, align 8, !tbaa !13
  %1572 = sext i32 %1571 to i64
  %1573 = getelementptr inbounds ptr, ptr %1569, i64 %1572
  store ptr %1567, ptr %1573, align 8, !tbaa !5
  %1574 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  %1575 = load ptr, ptr %1574, align 8, !tbaa !11
  %1576 = ptrtoint ptr %1575 to i64
  %1577 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %1578 = load i32, ptr %1577, align 8, !tbaa !13
  %1579 = sext i32 %1578 to i64
  %1580 = or i64 %1576, %1579
  %1581 = inttoptr i64 %1580 to ptr
  %1582 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 0
  %1583 = load ptr, ptr %1582, align 8, !tbaa !11
  %1584 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 1
  %1585 = load i32, ptr %1584, align 8, !tbaa !13
  %1586 = sext i32 %1585 to i64
  %1587 = getelementptr inbounds ptr, ptr %1583, i64 %1586
  store ptr %1581, ptr %1587, align 8, !tbaa !5
  %1588 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %1589 = load i32, ptr %1588, align 8, !tbaa !13
  %1590 = sext i32 %1589 to i64
  %1591 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %1590
  %1592 = load i32, ptr %1591, align 4, !tbaa !9
  %1593 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  store i32 %1592, ptr %1593, align 8, !tbaa !13
  %1594 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  %1595 = load ptr, ptr %1594, align 8, !tbaa !11
  %1596 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %1597 = load i32, ptr %1596, align 8, !tbaa !13
  %1598 = sext i32 %1597 to i64
  %1599 = getelementptr inbounds ptr, ptr %1595, i64 %1598
  %1600 = load ptr, ptr %1599, align 8, !tbaa !5
  store ptr %1600, ptr %41, align 8, !tbaa !5
  %1601 = load ptr, ptr %41, align 8, !tbaa !5
  %1602 = ptrtoint ptr %1601 to i64
  %1603 = and i64 %1602, 3
  %1604 = trunc i64 %1603 to i32
  %1605 = getelementptr inbounds %struct.otri, ptr %21, i32 0, i32 1
  store i32 %1604, ptr %1605, align 8, !tbaa !13
  %1606 = load ptr, ptr %41, align 8, !tbaa !5
  %1607 = ptrtoint ptr %1606 to i64
  %1608 = getelementptr inbounds %struct.otri, ptr %21, i32 0, i32 1
  %1609 = load i32, ptr %1608, align 8, !tbaa !13
  %1610 = sext i32 %1609 to i64
  %1611 = xor i64 %1607, %1610
  %1612 = inttoptr i64 %1611 to ptr
  %1613 = getelementptr inbounds %struct.otri, ptr %21, i32 0, i32 0
  store ptr %1612, ptr %1613, align 8, !tbaa !11
  %1614 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1615 = load i32, ptr %1614, align 8, !tbaa !13
  %1616 = sext i32 %1615 to i64
  %1617 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %1616
  %1618 = load i32, ptr %1617, align 4, !tbaa !9
  %1619 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  store i32 %1618, ptr %1619, align 8, !tbaa !13
  %1620 = getelementptr inbounds %struct.otri, ptr %21, i32 0, i32 0
  %1621 = load ptr, ptr %1620, align 8, !tbaa !11
  %1622 = ptrtoint ptr %1621 to i64
  %1623 = getelementptr inbounds %struct.otri, ptr %21, i32 0, i32 1
  %1624 = load i32, ptr %1623, align 8, !tbaa !13
  %1625 = sext i32 %1624 to i64
  %1626 = or i64 %1622, %1625
  %1627 = inttoptr i64 %1626 to ptr
  %1628 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1629 = load ptr, ptr %1628, align 8, !tbaa !11
  %1630 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1631 = load i32, ptr %1630, align 8, !tbaa !13
  %1632 = sext i32 %1631 to i64
  %1633 = getelementptr inbounds ptr, ptr %1629, i64 %1632
  store ptr %1627, ptr %1633, align 8, !tbaa !5
  %1634 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1635 = load ptr, ptr %1634, align 8, !tbaa !11
  %1636 = ptrtoint ptr %1635 to i64
  %1637 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1638 = load i32, ptr %1637, align 8, !tbaa !13
  %1639 = sext i32 %1638 to i64
  %1640 = or i64 %1636, %1639
  %1641 = inttoptr i64 %1640 to ptr
  %1642 = getelementptr inbounds %struct.otri, ptr %21, i32 0, i32 0
  %1643 = load ptr, ptr %1642, align 8, !tbaa !11
  %1644 = getelementptr inbounds %struct.otri, ptr %21, i32 0, i32 1
  %1645 = load i32, ptr %1644, align 8, !tbaa !13
  %1646 = sext i32 %1645 to i64
  %1647 = getelementptr inbounds ptr, ptr %1643, i64 %1646
  store ptr %1641, ptr %1647, align 8, !tbaa !5
  %1648 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  %1649 = load ptr, ptr %1648, align 8, !tbaa !11
  %1650 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %1651 = load i32, ptr %1650, align 8, !tbaa !13
  %1652 = sext i32 %1651 to i64
  %1653 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %1652
  %1654 = load i32, ptr %1653, align 4, !tbaa !9
  %1655 = add nsw i32 %1654, 3
  %1656 = sext i32 %1655 to i64
  %1657 = getelementptr inbounds ptr, ptr %1649, i64 %1656
  store ptr null, ptr %1657, align 8, !tbaa !5
  %1658 = load ptr, ptr %32, align 8, !tbaa !5
  %1659 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  %1660 = load ptr, ptr %1659, align 8, !tbaa !11
  %1661 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %1662 = load i32, ptr %1661, align 8, !tbaa !13
  %1663 = sext i32 %1662 to i64
  %1664 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %1663
  %1665 = load i32, ptr %1664, align 4, !tbaa !9
  %1666 = add nsw i32 %1665, 3
  %1667 = sext i32 %1666 to i64
  %1668 = getelementptr inbounds ptr, ptr %1660, i64 %1667
  store ptr %1658, ptr %1668, align 8, !tbaa !5
  %1669 = load ptr, ptr %35, align 8, !tbaa !5
  %1670 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  %1671 = load ptr, ptr %1670, align 8, !tbaa !11
  %1672 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %1673 = load i32, ptr %1672, align 8, !tbaa !13
  %1674 = add nsw i32 %1673, 3
  %1675 = sext i32 %1674 to i64
  %1676 = getelementptr inbounds ptr, ptr %1671, i64 %1675
  store ptr %1669, ptr %1676, align 8, !tbaa !5
  %1677 = load ptr, ptr %34, align 8, !tbaa !5
  %1678 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1679 = load ptr, ptr %1678, align 8, !tbaa !11
  %1680 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1681 = load i32, ptr %1680, align 8, !tbaa !13
  %1682 = sext i32 %1681 to i64
  %1683 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %1682
  %1684 = load i32, ptr %1683, align 4, !tbaa !9
  %1685 = add nsw i32 %1684, 3
  %1686 = sext i32 %1685 to i64
  %1687 = getelementptr inbounds ptr, ptr %1679, i64 %1686
  store ptr %1677, ptr %1687, align 8, !tbaa !5
  %1688 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1689 = load ptr, ptr %1688, align 8, !tbaa !11
  %1690 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1691 = load i32, ptr %1690, align 8, !tbaa !13
  %1692 = sext i32 %1691 to i64
  %1693 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %1692
  %1694 = load i32, ptr %1693, align 4, !tbaa !9
  %1695 = add nsw i32 %1694, 3
  %1696 = sext i32 %1695 to i64
  %1697 = getelementptr inbounds ptr, ptr %1689, i64 %1696
  store ptr null, ptr %1697, align 8, !tbaa !5
  %1698 = load ptr, ptr %35, align 8, !tbaa !5
  %1699 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1700 = load ptr, ptr %1699, align 8, !tbaa !11
  %1701 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1702 = load i32, ptr %1701, align 8, !tbaa !13
  %1703 = add nsw i32 %1702, 3
  %1704 = sext i32 %1703 to i64
  %1705 = getelementptr inbounds ptr, ptr %1700, i64 %1704
  store ptr %1698, ptr %1705, align 8, !tbaa !5
  %1706 = load ptr, ptr %35, align 8, !tbaa !5
  store ptr %1706, ptr %34, align 8, !tbaa !5
  %1707 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 0
  %1708 = load ptr, ptr %1707, align 8, !tbaa !11
  %1709 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  store ptr %1708, ptr %1709, align 8, !tbaa !11
  %1710 = getelementptr inbounds %struct.otri, ptr %19, i32 0, i32 1
  %1711 = load i32, ptr %1710, align 8, !tbaa !13
  %1712 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  store i32 %1711, ptr %1712, align 8, !tbaa !13
  %1713 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 0
  %1714 = load ptr, ptr %1713, align 8, !tbaa !11
  %1715 = getelementptr inbounds %struct.otri, ptr %18, i32 0, i32 1
  %1716 = load i32, ptr %1715, align 8, !tbaa !13
  %1717 = add nsw i32 %1716, 3
  %1718 = sext i32 %1717 to i64
  %1719 = getelementptr inbounds ptr, ptr %1714, i64 %1718
  %1720 = load ptr, ptr %1719, align 8, !tbaa !5
  store ptr %1720, ptr %35, align 8, !tbaa !5
  %1721 = load ptr, ptr %35, align 8, !tbaa !5
  %1722 = icmp ne ptr %1721, null
  br i1 %1722, label %1723, label %1734

1723:                                             ; preds = %1479
  %1724 = load ptr, ptr %8, align 8, !tbaa !5
  %1725 = load ptr, ptr %9, align 8, !tbaa !5
  %1726 = load ptr, ptr %31, align 8, !tbaa !5
  %1727 = load ptr, ptr %32, align 8, !tbaa !5
  %1728 = load ptr, ptr %34, align 8, !tbaa !5
  %1729 = load ptr, ptr %35, align 8, !tbaa !5
  %1730 = call float @incircle(ptr noundef %1724, ptr noundef %1725, ptr noundef %1726, ptr noundef %1727, ptr noundef %1728, ptr noundef %1729)
  %1731 = fpext float %1730 to double
  %1732 = fcmp ogt double %1731, 0.000000e+00
  %1733 = zext i1 %1732 to i32
  store i32 %1733, ptr %38, align 4, !tbaa !9
  br label %1735

1734:                                             ; preds = %1479
  store i32 0, ptr %38, align 4, !tbaa !9
  br label %1735

1735:                                             ; preds = %1734, %1723
  br label %1476, !llvm.loop !28

1736:                                             ; preds = %1476
  br label %1737

1737:                                             ; preds = %1736, %1425
  br label %1738

1738:                                             ; preds = %1737, %1422
  %1739 = load i32, ptr %39, align 4, !tbaa !9
  %1740 = icmp ne i32 %1739, 0
  br i1 %1740, label %1754, label %1741

1741:                                             ; preds = %1738
  %1742 = load i32, ptr %40, align 4, !tbaa !9
  %1743 = icmp ne i32 %1742, 0
  br i1 %1743, label %1832, label %1744

1744:                                             ; preds = %1741
  %1745 = load ptr, ptr %8, align 8, !tbaa !5
  %1746 = load ptr, ptr %9, align 8, !tbaa !5
  %1747 = load ptr, ptr %33, align 8, !tbaa !5
  %1748 = load ptr, ptr %31, align 8, !tbaa !5
  %1749 = load ptr, ptr %32, align 8, !tbaa !5
  %1750 = load ptr, ptr %34, align 8, !tbaa !5
  %1751 = call float @incircle(ptr noundef %1745, ptr noundef %1746, ptr noundef %1747, ptr noundef %1748, ptr noundef %1749, ptr noundef %1750)
  %1752 = fpext float %1751 to double
  %1753 = fcmp ogt double %1752, 0.000000e+00
  br i1 %1753, label %1754, label %1832

1754:                                             ; preds = %1744, %1738
  %1755 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  %1756 = load ptr, ptr %1755, align 8, !tbaa !11
  %1757 = ptrtoint ptr %1756 to i64
  %1758 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %1759 = load i32, ptr %1758, align 8, !tbaa !13
  %1760 = sext i32 %1759 to i64
  %1761 = or i64 %1757, %1760
  %1762 = inttoptr i64 %1761 to ptr
  %1763 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %1764 = load ptr, ptr %1763, align 8, !tbaa !11
  %1765 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %1766 = load i32, ptr %1765, align 8, !tbaa !13
  %1767 = sext i32 %1766 to i64
  %1768 = getelementptr inbounds ptr, ptr %1764, i64 %1767
  store ptr %1762, ptr %1768, align 8, !tbaa !5
  %1769 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %1770 = load ptr, ptr %1769, align 8, !tbaa !11
  %1771 = ptrtoint ptr %1770 to i64
  %1772 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %1773 = load i32, ptr %1772, align 8, !tbaa !13
  %1774 = sext i32 %1773 to i64
  %1775 = or i64 %1771, %1774
  %1776 = inttoptr i64 %1775 to ptr
  %1777 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  %1778 = load ptr, ptr %1777, align 8, !tbaa !11
  %1779 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %1780 = load i32, ptr %1779, align 8, !tbaa !13
  %1781 = sext i32 %1780 to i64
  %1782 = getelementptr inbounds ptr, ptr %1778, i64 %1781
  store ptr %1776, ptr %1782, align 8, !tbaa !5
  %1783 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  %1784 = load ptr, ptr %1783, align 8, !tbaa !11
  %1785 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  store ptr %1784, ptr %1785, align 8, !tbaa !11
  %1786 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %1787 = load i32, ptr %1786, align 8, !tbaa !13
  %1788 = sext i32 %1787 to i64
  %1789 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %1788
  %1790 = load i32, ptr %1789, align 4, !tbaa !9
  %1791 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  store i32 %1790, ptr %1791, align 8, !tbaa !13
  %1792 = load ptr, ptr %31, align 8, !tbaa !5
  %1793 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %1794 = load ptr, ptr %1793, align 8, !tbaa !11
  %1795 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %1796 = load i32, ptr %1795, align 8, !tbaa !13
  %1797 = sext i32 %1796 to i64
  %1798 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %1797
  %1799 = load i32, ptr %1798, align 4, !tbaa !9
  %1800 = add nsw i32 %1799, 3
  %1801 = sext i32 %1800 to i64
  %1802 = getelementptr inbounds ptr, ptr %1794, i64 %1801
  store ptr %1792, ptr %1802, align 8, !tbaa !5
  %1803 = load ptr, ptr %34, align 8, !tbaa !5
  store ptr %1803, ptr %32, align 8, !tbaa !5
  %1804 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %1805 = load ptr, ptr %1804, align 8, !tbaa !11
  %1806 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %1807 = load i32, ptr %1806, align 8, !tbaa !13
  %1808 = sext i32 %1807 to i64
  %1809 = getelementptr inbounds ptr, ptr %1805, i64 %1808
  %1810 = load ptr, ptr %1809, align 8, !tbaa !5
  store ptr %1810, ptr %41, align 8, !tbaa !5
  %1811 = load ptr, ptr %41, align 8, !tbaa !5
  %1812 = ptrtoint ptr %1811 to i64
  %1813 = and i64 %1812, 3
  %1814 = trunc i64 %1813 to i32
  %1815 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  store i32 %1814, ptr %1815, align 8, !tbaa !13
  %1816 = load ptr, ptr %41, align 8, !tbaa !5
  %1817 = ptrtoint ptr %1816 to i64
  %1818 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %1819 = load i32, ptr %1818, align 8, !tbaa !13
  %1820 = sext i32 %1819 to i64
  %1821 = xor i64 %1817, %1820
  %1822 = inttoptr i64 %1821 to ptr
  %1823 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  store ptr %1822, ptr %1823, align 8, !tbaa !11
  %1824 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 0
  %1825 = load ptr, ptr %1824, align 8, !tbaa !11
  %1826 = getelementptr inbounds %struct.otri, ptr %16, i32 0, i32 1
  %1827 = load i32, ptr %1826, align 8, !tbaa !13
  %1828 = add nsw i32 %1827, 3
  %1829 = sext i32 %1828 to i64
  %1830 = getelementptr inbounds ptr, ptr %1825, i64 %1829
  %1831 = load ptr, ptr %1830, align 8, !tbaa !5
  store ptr %1831, ptr %34, align 8, !tbaa !5
  br label %1910

1832:                                             ; preds = %1744, %1741
  %1833 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  %1834 = load ptr, ptr %1833, align 8, !tbaa !11
  %1835 = ptrtoint ptr %1834 to i64
  %1836 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %1837 = load i32, ptr %1836, align 8, !tbaa !13
  %1838 = sext i32 %1837 to i64
  %1839 = or i64 %1835, %1838
  %1840 = inttoptr i64 %1839 to ptr
  %1841 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %1842 = load ptr, ptr %1841, align 8, !tbaa !11
  %1843 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %1844 = load i32, ptr %1843, align 8, !tbaa !13
  %1845 = sext i32 %1844 to i64
  %1846 = getelementptr inbounds ptr, ptr %1842, i64 %1845
  store ptr %1840, ptr %1846, align 8, !tbaa !5
  %1847 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %1848 = load ptr, ptr %1847, align 8, !tbaa !11
  %1849 = ptrtoint ptr %1848 to i64
  %1850 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %1851 = load i32, ptr %1850, align 8, !tbaa !13
  %1852 = sext i32 %1851 to i64
  %1853 = or i64 %1849, %1852
  %1854 = inttoptr i64 %1853 to ptr
  %1855 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  %1856 = load ptr, ptr %1855, align 8, !tbaa !11
  %1857 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %1858 = load i32, ptr %1857, align 8, !tbaa !13
  %1859 = sext i32 %1858 to i64
  %1860 = getelementptr inbounds ptr, ptr %1856, i64 %1859
  store ptr %1854, ptr %1860, align 8, !tbaa !5
  %1861 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  %1862 = load ptr, ptr %1861, align 8, !tbaa !11
  %1863 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  store ptr %1862, ptr %1863, align 8, !tbaa !11
  %1864 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %1865 = load i32, ptr %1864, align 8, !tbaa !13
  %1866 = sext i32 %1865 to i64
  %1867 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %1866
  %1868 = load i32, ptr %1867, align 4, !tbaa !9
  %1869 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  store i32 %1868, ptr %1869, align 8, !tbaa !13
  %1870 = load ptr, ptr %32, align 8, !tbaa !5
  %1871 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %1872 = load ptr, ptr %1871, align 8, !tbaa !11
  %1873 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %1874 = load i32, ptr %1873, align 8, !tbaa !13
  %1875 = sext i32 %1874 to i64
  %1876 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %1875
  %1877 = load i32, ptr %1876, align 4, !tbaa !9
  %1878 = add nsw i32 %1877, 3
  %1879 = sext i32 %1878 to i64
  %1880 = getelementptr inbounds ptr, ptr %1872, i64 %1879
  store ptr %1870, ptr %1880, align 8, !tbaa !5
  %1881 = load ptr, ptr %33, align 8, !tbaa !5
  store ptr %1881, ptr %31, align 8, !tbaa !5
  %1882 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 0
  %1883 = load ptr, ptr %1882, align 8, !tbaa !11
  %1884 = getelementptr inbounds %struct.otri, ptr %17, i32 0, i32 1
  %1885 = load i32, ptr %1884, align 8, !tbaa !13
  %1886 = sext i32 %1885 to i64
  %1887 = getelementptr inbounds ptr, ptr %1883, i64 %1886
  %1888 = load ptr, ptr %1887, align 8, !tbaa !5
  store ptr %1888, ptr %41, align 8, !tbaa !5
  %1889 = load ptr, ptr %41, align 8, !tbaa !5
  %1890 = ptrtoint ptr %1889 to i64
  %1891 = and i64 %1890, 3
  %1892 = trunc i64 %1891 to i32
  %1893 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  store i32 %1892, ptr %1893, align 8, !tbaa !13
  %1894 = load ptr, ptr %41, align 8, !tbaa !5
  %1895 = ptrtoint ptr %1894 to i64
  %1896 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %1897 = load i32, ptr %1896, align 8, !tbaa !13
  %1898 = sext i32 %1897 to i64
  %1899 = xor i64 %1895, %1898
  %1900 = inttoptr i64 %1899 to ptr
  %1901 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  store ptr %1900, ptr %1901, align 8, !tbaa !11
  %1902 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 0
  %1903 = load ptr, ptr %1902, align 8, !tbaa !11
  %1904 = getelementptr inbounds %struct.otri, ptr %15, i32 0, i32 1
  %1905 = load i32, ptr %1904, align 8, !tbaa !13
  %1906 = add nsw i32 %1905, 3
  %1907 = sext i32 %1906 to i64
  %1908 = getelementptr inbounds ptr, ptr %1903, i64 %1907
  %1909 = load ptr, ptr %1908, align 8, !tbaa !5
  store ptr %1909, ptr %33, align 8, !tbaa !5
  br label %1910

1910:                                             ; preds = %1832, %1754
  %1911 = load ptr, ptr %9, align 8, !tbaa !5
  %1912 = getelementptr inbounds %struct.behavior, ptr %1911, i32 0, i32 29
  %1913 = load i32, ptr %1912, align 4, !tbaa !24
  %1914 = icmp sgt i32 %1913, 2
  br i1 %1914, label %1915, label %1919

1915:                                             ; preds = %1910
  %1916 = call i32 (ptr, ...) @printf(ptr noundef @.str.61)
  %1917 = load ptr, ptr %8, align 8, !tbaa !5
  %1918 = load ptr, ptr %9, align 8, !tbaa !5
  call void @printtriangle(ptr noundef %1917, ptr noundef %1918, ptr noundef %17)
  br label %1919

1919:                                             ; preds = %1915, %1910
  br label %759
}

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { 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 #3 = { 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, !6, i64 0}
!12 = !{!"otri", !6, i64 0, !10, i64 8}
!13 = !{!12, !10, i64 8}
!14 = !{!15, !10, i64 100}
!15 = !{!"behavior", !10, i64 0, !10, i64 4, !10, i64 8, !10, i64 12, !10, i64 16, !10, i64 20, !10, i64 24, !10, i64 28, !10, i64 32, !10, i64 36, !10, i64 40, !10, i64 44, !10, i64 48, !10, i64 52, !10, i64 56, !10, i64 60, !10, i64 64, !10, i64 68, !10, i64 72, !10, i64 76, !10, i64 80, !10, i64 84, !10, i64 88, !10, i64 92, !10, i64 96, !10, i64 100, !10, i64 104, !10, i64 108, !10, i64 112, !10, i64 116, !10, i64 120, !10, i64 124, !10, i64 128, !10, i64 132, !16, i64 136, !16, i64 140, !16, i64 144, !16, i64 148}
!16 = !{!"float", !7, i64 0}
!17 = !{!16, !16, i64 0}
!18 = distinct !{!18, !19}
!19 = !{!"llvm.loop.mustprogress"}
!20 = distinct !{!20, !19}
!21 = distinct !{!21, !19}
!22 = distinct !{!22, !19}
!23 = distinct !{!23, !19}
!24 = !{!15, !10, i64 116}
!25 = distinct !{!25, !19}
!26 = distinct !{!26, !19}
!27 = distinct !{!27, !19}
!28 = distinct !{!28, !19}


; 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.otri = type { ptr, i32 }

@plus1mod3 = external dso_local local_unnamed_addr global [3 x i32], align 4
@minus1mod3 = external dso_local local_unnamed_addr global [3 x i32], align 4
@.str.59 = external hidden unnamed_addr constant [26 x i8], align 1
@.str.60 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.61 = external hidden unnamed_addr constant [14 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: nofree nounwind
declare noundef i32 @printf(ptr nocapture noundef readonly, ...) local_unnamed_addr #1

; 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 void @printtriangle(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare dso_local void @maketriangle(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare dso_local float @counterclockwise(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare dso_local float @incircle(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
define dso_local void @mergehulls(ptr noundef %0, ptr noundef %1, ptr nocapture noundef %2, ptr nocapture noundef %3, ptr nocapture noundef %4, ptr nocapture noundef %5, i32 noundef %6) local_unnamed_addr #2 {
  %8 = alloca %struct.otri, align 8
  %9 = alloca %struct.otri, align 8
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %8) #3
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %9) #3
  %10 = load ptr, ptr %3, align 8, !tbaa !5
  %11 = getelementptr inbounds i8, ptr %3, i64 8
  %12 = load i32, ptr %11, align 8, !tbaa !11
  %13 = sext i32 %12 to i64
  %14 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %13
  %15 = load i32, ptr %14, align 4, !tbaa !12
  %16 = sext i32 %15 to i64
  %17 = getelementptr ptr, ptr %10, i64 %16
  %18 = getelementptr i8, ptr %17, i64 24
  %19 = load ptr, ptr %18, align 8, !tbaa !13
  %20 = getelementptr ptr, ptr %10, i64 %13
  %21 = getelementptr i8, ptr %20, i64 24
  %22 = load ptr, ptr %21, align 8, !tbaa !13
  %23 = load ptr, ptr %4, align 8, !tbaa !5
  %24 = getelementptr inbounds i8, ptr %4, i64 8
  %25 = load i32, ptr %24, align 8, !tbaa !11
  %26 = sext i32 %25 to i64
  %27 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %26
  %28 = load i32, ptr %27, align 4, !tbaa !12
  %29 = sext i32 %28 to i64
  %30 = getelementptr ptr, ptr %23, i64 %29
  %31 = getelementptr i8, ptr %30, i64 24
  %32 = load ptr, ptr %31, align 8, !tbaa !13
  %33 = getelementptr ptr, ptr %23, i64 %26
  %34 = getelementptr i8, ptr %33, i64 24
  %35 = load ptr, ptr %34, align 8, !tbaa !13
  %36 = getelementptr inbounds i8, ptr %1, i64 100
  %37 = load i32, ptr %36, align 4, !tbaa !14
  %38 = icmp ne i32 %37, 0
  %39 = icmp eq i32 %6, 1
  %or.cond = and i1 %39, %38
  br i1 %or.cond, label %40, label %.loopexit496.preheader

40:                                               ; preds = %7
  %41 = load ptr, ptr %2, align 8, !tbaa !5
  %42 = getelementptr inbounds i8, ptr %2, i64 8
  %43 = load i32, ptr %42, align 8, !tbaa !11
  %44 = sext i32 %43 to i64
  %45 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %44
  %46 = load i32, ptr %45, align 4, !tbaa !12
  %47 = sext i32 %46 to i64
  %48 = getelementptr ptr, ptr %41, i64 %47
  %49 = getelementptr i8, ptr %48, i64 24
  %50 = load ptr, ptr %49, align 8, !tbaa !13
  %51 = getelementptr ptr, ptr %41, i64 %44
  %52 = load ptr, ptr %5, align 8, !tbaa !5
  %53 = getelementptr inbounds i8, ptr %5, i64 8
  %54 = load i32, ptr %53, align 8, !tbaa !11
  %55 = sext i32 %54 to i64
  %56 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %55
  %57 = load i32, ptr %56, align 4, !tbaa !12
  %58 = sext i32 %57 to i64
  %59 = getelementptr ptr, ptr %52, i64 %58
  %60 = getelementptr i8, ptr %59, i64 24
  %61 = load ptr, ptr %60, align 8, !tbaa !13
  %.0422.in498 = getelementptr inbounds i8, ptr %51, i64 24
  %.0422499 = load ptr, ptr %.0422.in498, align 8, !tbaa !13
  %62 = getelementptr inbounds i8, ptr %.0422499, i64 4
  %63 = load float, ptr %62, align 4, !tbaa !17
  %64 = getelementptr inbounds i8, ptr %50, i64 4
  %65 = load float, ptr %64, align 4, !tbaa !17
  %66 = fcmp olt float %63, %65
  br i1 %66, label %.lr.ph, label %._crit_edge

.lr.ph:                                           ; preds = %40, %.lr.ph
  %67 = phi float [ %84, %.lr.ph ], [ %63, %40 ]
  %68 = phi ptr [ %80, %.lr.ph ], [ %41, %40 ]
  %69 = phi i32 [ %78, %.lr.ph ], [ %43, %40 ]
  %70 = sext i32 %69 to i64
  %71 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %70
  %72 = load i32, ptr %71, align 4, !tbaa !12
  %73 = sext i32 %72 to i64
  %74 = getelementptr inbounds ptr, ptr %68, i64 %73
  %75 = load ptr, ptr %74, align 8, !tbaa !13
  %76 = ptrtoint ptr %75 to i64
  %77 = trunc i64 %76 to i32
  %78 = and i32 %77, 3
  store i32 %78, ptr %42, align 8, !tbaa !11
  %79 = and i64 %76, -4
  %80 = inttoptr i64 %79 to ptr
  store ptr %80, ptr %2, align 8, !tbaa !5
  %81 = and i64 %76, 3
  %82 = getelementptr inbounds ptr, ptr %80, i64 %81
  %.0422.in = getelementptr inbounds i8, ptr %82, i64 24
  %.0422 = load ptr, ptr %.0422.in, align 8, !tbaa !13
  %83 = getelementptr inbounds i8, ptr %.0422, i64 4
  %84 = load float, ptr %83, align 4, !tbaa !17
  %85 = fcmp olt float %84, %67
  br i1 %85, label %.lr.ph, label %._crit_edge.loopexit, !llvm.loop !18

._crit_edge.loopexit:                             ; preds = %.lr.ph
  %.pre = load ptr, ptr %3, align 8, !tbaa !5
  %.pre580 = load i32, ptr %11, align 8, !tbaa !11
  %.pre581 = sext i32 %.pre580 to i64
  br label %._crit_edge

._crit_edge:                                      ; preds = %._crit_edge.loopexit, %40
  %.pre-phi = phi i64 [ %.pre581, %._crit_edge.loopexit ], [ %13, %40 ]
  %86 = phi ptr [ %.pre, %._crit_edge.loopexit ], [ %10, %40 ]
  %87 = getelementptr inbounds ptr, ptr %86, i64 %.pre-phi
  %88 = load ptr, ptr %87, align 8, !tbaa !13
  %89 = ptrtoint ptr %88 to i64
  %90 = and i64 %89, 3
  %91 = and i64 %89, -4
  %92 = inttoptr i64 %91 to ptr
  %93 = getelementptr inbounds ptr, ptr %92, i64 %90
  %.0404.in502 = getelementptr inbounds i8, ptr %93, i64 24
  %.0404503 = load ptr, ptr %.0404.in502, align 8, !tbaa !13
  %94 = getelementptr inbounds i8, ptr %.0404503, i64 4
  %95 = load float, ptr %94, align 4, !tbaa !17
  %96 = getelementptr inbounds i8, ptr %19, i64 4
  %97 = load float, ptr %96, align 4, !tbaa !17
  %98 = fcmp ogt float %95, %97
  br i1 %98, label %.lr.ph509, label %.preheader497

.preheader497:                                    ; preds = %.lr.ph509, %._crit_edge
  %.0439.lcssa = phi ptr [ %19, %._crit_edge ], [ %.0404507, %.lr.ph509 ]
  %.0431.lcssa = phi ptr [ %22, %._crit_edge ], [ %.0439506, %.lr.ph509 ]
  %99 = getelementptr inbounds i8, ptr %35, i64 4
  %100 = load float, ptr %99, align 4, !tbaa !17
  %101 = getelementptr inbounds i8, ptr %32, i64 4
  %102 = load float, ptr %101, align 4, !tbaa !17
  %103 = fcmp olt float %100, %102
  br i1 %103, label %.lr.ph512, label %._crit_edge513

.lr.ph512:                                        ; preds = %.preheader497
  %.promoted516 = load i32, ptr %24, align 8, !tbaa !11
  %.promoted517 = load ptr, ptr %4, align 8, !tbaa !5
  br label %118

.lr.ph509:                                        ; preds = %._crit_edge, %.lr.ph509
  %104 = phi float [ %116, %.lr.ph509 ], [ %95, %._crit_edge ]
  %.0404507 = phi ptr [ %.0404, %.lr.ph509 ], [ %.0404503, %._crit_edge ]
  %.0439506 = phi ptr [ %.0404507, %.lr.ph509 ], [ %19, %._crit_edge ]
  %.sroa.0.0505 = phi ptr [ %113, %.lr.ph509 ], [ %92, %._crit_edge ]
  %.sroa.17.0504 = phi i64 [ %111, %.lr.ph509 ], [ %90, %._crit_edge ]
  store ptr %.sroa.0.0505, ptr %3, align 8, !tbaa !5
  %105 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %.sroa.17.0504
  %106 = load i32, ptr %105, align 4, !tbaa !12
  store i32 %106, ptr %11, align 8, !tbaa !11
  %107 = sext i32 %106 to i64
  %108 = getelementptr inbounds ptr, ptr %.sroa.0.0505, i64 %107
  %109 = load ptr, ptr %108, align 8, !tbaa !13
  %110 = ptrtoint ptr %109 to i64
  %111 = and i64 %110, 3
  %112 = and i64 %110, -4
  %113 = inttoptr i64 %112 to ptr
  %114 = getelementptr inbounds ptr, ptr %113, i64 %111
  %.0404.in = getelementptr inbounds i8, ptr %114, i64 24
  %.0404 = load ptr, ptr %.0404.in, align 8, !tbaa !13
  %115 = getelementptr inbounds i8, ptr %.0404, i64 4
  %116 = load float, ptr %115, align 4, !tbaa !17
  %117 = fcmp ogt float %116, %104
  br i1 %117, label %.lr.ph509, label %.preheader497, !llvm.loop !20

118:                                              ; preds = %.lr.ph512, %118
  %119 = phi float [ %100, %.lr.ph512 ], [ %138, %118 ]
  %120 = phi ptr [ %.promoted517, %.lr.ph512 ], [ %132, %118 ]
  %121 = phi i32 [ %.promoted516, %.lr.ph512 ], [ %130, %118 ]
  %.0427511 = phi ptr [ %35, %.lr.ph512 ], [ %136, %118 ]
  %122 = sext i32 %121 to i64
  %123 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %122
  %124 = load i32, ptr %123, align 4, !tbaa !12
  %125 = sext i32 %124 to i64
  %126 = getelementptr inbounds ptr, ptr %120, i64 %125
  %127 = load ptr, ptr %126, align 8, !tbaa !13
  %128 = ptrtoint ptr %127 to i64
  %129 = trunc i64 %128 to i32
  %130 = and i32 %129, 3
  store i32 %130, ptr %24, align 8, !tbaa !11
  %131 = and i64 %128, -4
  %132 = inttoptr i64 %131 to ptr
  store ptr %132, ptr %4, align 8, !tbaa !5
  %133 = and i64 %128, 3
  %134 = getelementptr inbounds ptr, ptr %132, i64 %133
  %135 = getelementptr inbounds i8, ptr %134, i64 24
  %136 = load ptr, ptr %135, align 8, !tbaa !13
  %137 = getelementptr inbounds i8, ptr %136, i64 4
  %138 = load float, ptr %137, align 4, !tbaa !17
  %139 = fcmp olt float %138, %119
  br i1 %139, label %118, label %._crit_edge513, !llvm.loop !21

._crit_edge513:                                   ; preds = %118, %.preheader497
  %.0435.lcssa = phi ptr [ %32, %.preheader497 ], [ %.0427511, %118 ]
  %.0427.lcssa = phi ptr [ %35, %.preheader497 ], [ %136, %118 ]
  %140 = load ptr, ptr %5, align 8, !tbaa !5
  %141 = load i32, ptr %53, align 8, !tbaa !11
  %142 = sext i32 %141 to i64
  %143 = getelementptr inbounds ptr, ptr %140, i64 %142
  %144 = load ptr, ptr %143, align 8, !tbaa !13
  %145 = ptrtoint ptr %144 to i64
  %146 = and i64 %145, 3
  %147 = and i64 %145, -4
  %148 = inttoptr i64 %147 to ptr
  %149 = getelementptr inbounds ptr, ptr %148, i64 %146
  %.1405.in518 = getelementptr inbounds i8, ptr %149, i64 24
  %.1405519 = load ptr, ptr %.1405.in518, align 8, !tbaa !13
  %150 = getelementptr inbounds i8, ptr %.1405519, i64 4
  %151 = load float, ptr %150, align 4, !tbaa !17
  %152 = getelementptr inbounds i8, ptr %61, i64 4
  %153 = load float, ptr %152, align 4, !tbaa !17
  %154 = fcmp ogt float %151, %153
  br i1 %154, label %.lr.ph524, label %.loopexit496.preheader

.lr.ph524:                                        ; preds = %._crit_edge513, %.lr.ph524
  %155 = phi float [ %167, %.lr.ph524 ], [ %151, %._crit_edge513 ]
  %.sroa.0.1521 = phi ptr [ %164, %.lr.ph524 ], [ %148, %._crit_edge513 ]
  %.sroa.17.1520 = phi i64 [ %162, %.lr.ph524 ], [ %146, %._crit_edge513 ]
  store ptr %.sroa.0.1521, ptr %5, align 8, !tbaa !5
  %156 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %.sroa.17.1520
  %157 = load i32, ptr %156, align 4, !tbaa !12
  store i32 %157, ptr %53, align 8, !tbaa !11
  %158 = sext i32 %157 to i64
  %159 = getelementptr inbounds ptr, ptr %.sroa.0.1521, i64 %158
  %160 = load ptr, ptr %159, align 8, !tbaa !13
  %161 = ptrtoint ptr %160 to i64
  %162 = and i64 %161, 3
  %163 = and i64 %161, -4
  %164 = inttoptr i64 %163 to ptr
  %165 = getelementptr inbounds ptr, ptr %164, i64 %162
  %.1405.in = getelementptr inbounds i8, ptr %165, i64 24
  %.1405 = load ptr, ptr %.1405.in, align 8, !tbaa !13
  %166 = getelementptr inbounds i8, ptr %.1405, i64 4
  %167 = load float, ptr %166, align 4, !tbaa !17
  %168 = fcmp ogt float %167, %155
  br i1 %168, label %.lr.ph524, label %.loopexit496.preheader, !llvm.loop !22

.loopexit496.preheader:                           ; preds = %.lr.ph524, %._crit_edge513, %7
  %.2441.ph = phi ptr [ %.0439.lcssa, %._crit_edge513 ], [ %19, %7 ], [ %.0439.lcssa, %.lr.ph524 ]
  %.2437.ph = phi ptr [ %.0435.lcssa, %._crit_edge513 ], [ %32, %7 ], [ %.0435.lcssa, %.lr.ph524 ]
  %.2433.ph = phi ptr [ %.0431.lcssa, %._crit_edge513 ], [ %22, %7 ], [ %.0431.lcssa, %.lr.ph524 ]
  %.2429.ph = phi ptr [ %.0427.lcssa, %._crit_edge513 ], [ %35, %7 ], [ %.0427.lcssa, %.lr.ph524 ]
  br label %.loopexit496

.loopexit496:                                     ; preds = %.loopexit496.preheader, %210
  %.2441 = phi ptr [ %.3442, %210 ], [ %.2441.ph, %.loopexit496.preheader ]
  %.2437 = phi ptr [ %.3438, %210 ], [ %.2437.ph, %.loopexit496.preheader ]
  %.2433 = phi ptr [ %.3434, %210 ], [ %.2433.ph, %.loopexit496.preheader ]
  %.2429 = phi ptr [ %.3430, %210 ], [ %.2429.ph, %.loopexit496.preheader ]
  %169 = tail call float @counterclockwise(ptr noundef %0, ptr noundef %1, ptr noundef %.2441, ptr noundef %.2433, ptr noundef %.2437)
  %170 = fcmp ogt float %169, 0.000000e+00
  br i1 %170, label %171, label %189

171:                                              ; preds = %.loopexit496
  %172 = load i32, ptr %11, align 8, !tbaa !11
  %173 = sext i32 %172 to i64
  %174 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %173
  %175 = load i32, ptr %174, align 4, !tbaa !12
  %176 = load ptr, ptr %3, align 8, !tbaa !5
  %177 = sext i32 %175 to i64
  %178 = getelementptr inbounds ptr, ptr %176, i64 %177
  %179 = load ptr, ptr %178, align 8, !tbaa !13
  %180 = ptrtoint ptr %179 to i64
  %181 = trunc i64 %180 to i32
  %182 = and i32 %181, 3
  store i32 %182, ptr %11, align 8, !tbaa !11
  %183 = and i64 %180, -4
  %184 = inttoptr i64 %183 to ptr
  store ptr %184, ptr %3, align 8, !tbaa !5
  %185 = and i64 %180, 3
  %186 = getelementptr inbounds ptr, ptr %184, i64 %185
  %187 = getelementptr inbounds i8, ptr %186, i64 24
  %188 = load ptr, ptr %187, align 8, !tbaa !13
  br label %189

189:                                              ; preds = %171, %.loopexit496
  %.3442 = phi ptr [ %.2433, %171 ], [ %.2441, %.loopexit496 ]
  %.3434 = phi ptr [ %188, %171 ], [ %.2433, %.loopexit496 ]
  %.0402 = phi i32 [ 1, %171 ], [ 0, %.loopexit496 ]
  %190 = tail call float @counterclockwise(ptr noundef %0, ptr noundef %1, ptr noundef %.2429, ptr noundef %.2437, ptr noundef %.3442)
  %191 = fcmp ogt float %190, 0.000000e+00
  br i1 %191, label %192, label %210

192:                                              ; preds = %189
  %193 = load i32, ptr %24, align 8, !tbaa !11
  %194 = sext i32 %193 to i64
  %195 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %194
  %196 = load i32, ptr %195, align 4, !tbaa !12
  %197 = load ptr, ptr %4, align 8, !tbaa !5
  %198 = sext i32 %196 to i64
  %199 = getelementptr inbounds ptr, ptr %197, i64 %198
  %200 = load ptr, ptr %199, align 8, !tbaa !13
  %201 = ptrtoint ptr %200 to i64
  %202 = trunc i64 %201 to i32
  %203 = and i32 %202, 3
  store i32 %203, ptr %24, align 8, !tbaa !11
  %204 = and i64 %201, -4
  %205 = inttoptr i64 %204 to ptr
  store ptr %205, ptr %4, align 8, !tbaa !5
  %206 = and i64 %201, 3
  %207 = getelementptr inbounds ptr, ptr %205, i64 %206
  %208 = getelementptr inbounds i8, ptr %207, i64 24
  %209 = load ptr, ptr %208, align 8, !tbaa !13
  br label %210

210:                                              ; preds = %189, %192
  %.3438 = phi ptr [ %.2429, %192 ], [ %.2437, %189 ]
  %.3430 = phi ptr [ %209, %192 ], [ %.2429, %189 ]
  %.1403 = phi i32 [ 1, %192 ], [ %.0402, %189 ]
  %.not = icmp eq i32 %.1403, 0
  br i1 %.not, label %211, label %.loopexit496, !llvm.loop !23

211:                                              ; preds = %210
  %212 = load ptr, ptr %3, align 8, !tbaa !5
  %213 = load i32, ptr %11, align 8, !tbaa !11
  %214 = sext i32 %213 to i64
  %215 = getelementptr inbounds ptr, ptr %212, i64 %214
  %216 = load ptr, ptr %215, align 8, !tbaa !13
  %217 = ptrtoint ptr %216 to i64
  %218 = trunc i64 %217 to i32
  %219 = and i32 %218, 3
  %220 = and i64 %217, -4
  %221 = inttoptr i64 %220 to ptr
  %222 = load ptr, ptr %4, align 8, !tbaa !5
  %223 = load i32, ptr %24, align 8, !tbaa !11
  %224 = sext i32 %223 to i64
  %225 = getelementptr inbounds ptr, ptr %222, i64 %224
  %226 = load ptr, ptr %225, align 8, !tbaa !13
  %227 = ptrtoint ptr %226 to i64
  %228 = trunc i64 %227 to i32
  %229 = and i32 %228, 3
  %230 = and i64 %227, -4
  %231 = inttoptr i64 %230 to ptr
  call void @maketriangle(ptr noundef %0, ptr noundef %1, ptr noundef nonnull %8)
  %232 = load ptr, ptr %3, align 8, !tbaa !5
  %233 = ptrtoint ptr %232 to i64
  %234 = load i32, ptr %11, align 8, !tbaa !11
  %235 = sext i32 %234 to i64
  %236 = or i64 %235, %233
  %237 = inttoptr i64 %236 to ptr
  %238 = load ptr, ptr %8, align 8, !tbaa !5
  %239 = getelementptr inbounds i8, ptr %8, i64 8
  %240 = load i32, ptr %239, align 8, !tbaa !11
  %241 = sext i32 %240 to i64
  %242 = getelementptr inbounds ptr, ptr %238, i64 %241
  store ptr %237, ptr %242, align 8, !tbaa !13
  %243 = load ptr, ptr %8, align 8, !tbaa !5
  %244 = ptrtoint ptr %243 to i64
  %245 = or i64 %244, %241
  %246 = inttoptr i64 %245 to ptr
  %247 = load ptr, ptr %3, align 8, !tbaa !5
  %248 = getelementptr inbounds ptr, ptr %247, i64 %235
  store ptr %246, ptr %248, align 8, !tbaa !13
  %249 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %241
  %250 = load i32, ptr %249, align 4, !tbaa !12
  %251 = load ptr, ptr %4, align 8, !tbaa !5
  %252 = ptrtoint ptr %251 to i64
  %253 = load i32, ptr %24, align 8, !tbaa !11
  %254 = sext i32 %253 to i64
  %255 = or i64 %254, %252
  %256 = inttoptr i64 %255 to ptr
  %257 = load ptr, ptr %8, align 8, !tbaa !5
  %258 = sext i32 %250 to i64
  %259 = getelementptr inbounds ptr, ptr %257, i64 %258
  store ptr %256, ptr %259, align 8, !tbaa !13
  %260 = load ptr, ptr %8, align 8, !tbaa !5
  %261 = ptrtoint ptr %260 to i64
  %262 = or i64 %261, %258
  %263 = inttoptr i64 %262 to ptr
  %264 = load ptr, ptr %4, align 8, !tbaa !5
  %265 = getelementptr inbounds ptr, ptr %264, i64 %254
  store ptr %263, ptr %265, align 8, !tbaa !13
  %266 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %258
  %267 = load i32, ptr %266, align 4, !tbaa !12
  store i32 %267, ptr %239, align 8, !tbaa !11
  %268 = load ptr, ptr %8, align 8, !tbaa !5
  %269 = sext i32 %267 to i64
  %270 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %269
  %271 = load i32, ptr %270, align 4, !tbaa !12
  %272 = sext i32 %271 to i64
  %273 = getelementptr ptr, ptr %268, i64 %272
  %274 = getelementptr i8, ptr %273, i64 24
  store ptr %.3438, ptr %274, align 8, !tbaa !13
  %275 = load ptr, ptr %8, align 8, !tbaa !5
  %276 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %269
  %277 = load i32, ptr %276, align 4, !tbaa !12
  %278 = sext i32 %277 to i64
  %279 = getelementptr ptr, ptr %275, i64 %278
  %280 = getelementptr i8, ptr %279, i64 24
  store ptr %.3442, ptr %280, align 8, !tbaa !13
  %281 = getelementptr inbounds i8, ptr %1, i64 116
  %282 = load i32, ptr %281, align 4, !tbaa !24
  %283 = icmp sgt i32 %282, 2
  br i1 %283, label %284, label %286

284:                                              ; preds = %211
  %285 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.59)
  call void @printtriangle(ptr noundef %0, ptr noundef nonnull %1, ptr noundef nonnull %8)
  br label %286

286:                                              ; preds = %284, %211
  %287 = load ptr, ptr %2, align 8, !tbaa !5
  %288 = getelementptr inbounds i8, ptr %2, i64 8
  %289 = load i32, ptr %288, align 8, !tbaa !11
  %290 = sext i32 %289 to i64
  %291 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %290
  %292 = load i32, ptr %291, align 4, !tbaa !12
  %293 = sext i32 %292 to i64
  %294 = getelementptr ptr, ptr %287, i64 %293
  %295 = getelementptr i8, ptr %294, i64 24
  %296 = load ptr, ptr %295, align 8, !tbaa !13
  %297 = icmp eq ptr %.3442, %296
  br i1 %297, label %298, label %304

298:                                              ; preds = %286
  %299 = load ptr, ptr %8, align 8, !tbaa !5
  store ptr %299, ptr %2, align 8, !tbaa !5
  %300 = load i32, ptr %239, align 8, !tbaa !11
  %301 = sext i32 %300 to i64
  %302 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %301
  %303 = load i32, ptr %302, align 4, !tbaa !12
  store i32 %303, ptr %288, align 8, !tbaa !11
  br label %304

304:                                              ; preds = %298, %286
  %305 = load ptr, ptr %5, align 8, !tbaa !5
  %306 = getelementptr inbounds i8, ptr %5, i64 8
  %307 = load i32, ptr %306, align 8, !tbaa !11
  %308 = sext i32 %307 to i64
  %309 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %308
  %310 = load i32, ptr %309, align 4, !tbaa !12
  %311 = sext i32 %310 to i64
  %312 = getelementptr ptr, ptr %305, i64 %311
  %313 = getelementptr i8, ptr %312, i64 24
  %314 = load ptr, ptr %313, align 8, !tbaa !13
  %315 = icmp eq ptr %.3438, %314
  br i1 %315, label %316, label %322

316:                                              ; preds = %304
  %317 = load ptr, ptr %8, align 8, !tbaa !5
  store ptr %317, ptr %5, align 8, !tbaa !5
  %318 = load i32, ptr %239, align 8, !tbaa !11
  %319 = sext i32 %318 to i64
  %320 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %319
  %321 = load i32, ptr %320, align 4, !tbaa !12
  store i32 %321, ptr %306, align 8, !tbaa !11
  br label %322

322:                                              ; preds = %316, %304
  %323 = and i64 %217, 3
  %324 = getelementptr inbounds ptr, ptr %221, i64 %323
  %325 = getelementptr inbounds i8, ptr %324, i64 24
  %326 = load ptr, ptr %325, align 8, !tbaa !13
  %327 = and i64 %227, 3
  %328 = getelementptr inbounds ptr, ptr %231, i64 %327
  %329 = getelementptr inbounds i8, ptr %328, i64 24
  %330 = load ptr, ptr %329, align 8, !tbaa !13
  %331 = call float @counterclockwise(ptr noundef %0, ptr noundef nonnull %1, ptr noundef %326, ptr noundef %.3442, ptr noundef %.3438)
  %332 = fcmp ole float %331, 0.000000e+00
  %333 = call float @counterclockwise(ptr noundef %0, ptr noundef nonnull %1, ptr noundef %330, ptr noundef %.3442, ptr noundef %.3438)
  %334 = fcmp ole float %333, 0.000000e+00
  %or.cond3543 = select i1 %332, i1 %334, i1 false
  br i1 %or.cond3543, label %._crit_edge560, label %.lr.ph559

.lr.ph559:                                        ; preds = %322
  %335 = getelementptr inbounds i8, ptr %9, i64 8
  br label %466

._crit_edge560:                                   ; preds = %747, %322
  %.sroa.0197.0.lcssa = phi ptr [ %231, %322 ], [ %.sroa.0197.1, %747 ]
  %.sroa.18.0.lcssa = phi i32 [ %229, %322 ], [ %.sroa.18.3, %747 ]
  %.0419.lcssa = phi ptr [ %.3442, %322 ], [ %.1420, %747 ]
  %.0417.lcssa = phi ptr [ %.3438, %322 ], [ %.1418, %747 ]
  %.sroa.0228.0.lcssa = phi ptr [ %221, %322 ], [ %.sroa.0228.1, %747 ]
  %.sroa.18242.0.lcssa = phi i32 [ %219, %322 ], [ %.sroa.18242.3, %747 ]
  call void @maketriangle(ptr noundef %0, ptr noundef nonnull %1, ptr noundef nonnull %9)
  %336 = load ptr, ptr %9, align 8, !tbaa !5
  %337 = getelementptr inbounds i8, ptr %9, i64 8
  %338 = load i32, ptr %337, align 8, !tbaa !11
  %339 = sext i32 %338 to i64
  %340 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %339
  %341 = load i32, ptr %340, align 4, !tbaa !12
  %342 = sext i32 %341 to i64
  %343 = getelementptr ptr, ptr %336, i64 %342
  %344 = getelementptr i8, ptr %343, i64 24
  store ptr %.0419.lcssa, ptr %344, align 8, !tbaa !13
  %345 = load ptr, ptr %9, align 8, !tbaa !5
  %346 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %339
  %347 = load i32, ptr %346, align 4, !tbaa !12
  %348 = sext i32 %347 to i64
  %349 = getelementptr ptr, ptr %345, i64 %348
  %350 = getelementptr i8, ptr %349, i64 24
  store ptr %.0417.lcssa, ptr %350, align 8, !tbaa !13
  %351 = load ptr, ptr %8, align 8, !tbaa !5
  %352 = ptrtoint ptr %351 to i64
  %353 = load i32, ptr %239, align 8, !tbaa !11
  %354 = sext i32 %353 to i64
  %355 = or i64 %354, %352
  %356 = inttoptr i64 %355 to ptr
  %357 = load ptr, ptr %9, align 8, !tbaa !5
  %358 = getelementptr inbounds ptr, ptr %357, i64 %339
  store ptr %356, ptr %358, align 8, !tbaa !13
  %359 = load ptr, ptr %9, align 8, !tbaa !5
  %360 = ptrtoint ptr %359 to i64
  %361 = or i64 %360, %339
  %362 = inttoptr i64 %361 to ptr
  %363 = load ptr, ptr %8, align 8, !tbaa !5
  %364 = getelementptr inbounds ptr, ptr %363, i64 %354
  store ptr %362, ptr %364, align 8, !tbaa !13
  %365 = ptrtoint ptr %.sroa.0197.0.lcssa to i64
  %366 = sext i32 %.sroa.18.0.lcssa to i64
  %367 = or i64 %366, %365
  %368 = inttoptr i64 %367 to ptr
  %369 = load ptr, ptr %9, align 8, !tbaa !5
  %370 = getelementptr inbounds ptr, ptr %369, i64 %342
  store ptr %368, ptr %370, align 8, !tbaa !13
  %371 = load ptr, ptr %9, align 8, !tbaa !5
  %372 = ptrtoint ptr %371 to i64
  %373 = or i64 %372, %342
  %374 = inttoptr i64 %373 to ptr
  %375 = getelementptr inbounds ptr, ptr %.sroa.0197.0.lcssa, i64 %366
  store ptr %374, ptr %375, align 8, !tbaa !13
  %376 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %342
  %377 = load i32, ptr %376, align 4, !tbaa !12
  store i32 %377, ptr %337, align 8, !tbaa !11
  %378 = ptrtoint ptr %.sroa.0228.0.lcssa to i64
  %379 = sext i32 %.sroa.18242.0.lcssa to i64
  %380 = or i64 %379, %378
  %381 = inttoptr i64 %380 to ptr
  %382 = load ptr, ptr %9, align 8, !tbaa !5
  %383 = sext i32 %377 to i64
  %384 = getelementptr inbounds ptr, ptr %382, i64 %383
  store ptr %381, ptr %384, align 8, !tbaa !13
  %385 = load ptr, ptr %9, align 8, !tbaa !5
  %386 = ptrtoint ptr %385 to i64
  %387 = or i64 %386, %383
  %388 = inttoptr i64 %387 to ptr
  %389 = getelementptr inbounds ptr, ptr %.sroa.0228.0.lcssa, i64 %379
  store ptr %388, ptr %389, align 8, !tbaa !13
  %390 = load i32, ptr %281, align 4, !tbaa !24
  %391 = icmp sgt i32 %390, 2
  br i1 %391, label %392, label %394

392:                                              ; preds = %._crit_edge560
  %393 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.60)
  call void @printtriangle(ptr noundef %0, ptr noundef nonnull %1, ptr noundef nonnull %9)
  br label %394

394:                                              ; preds = %392, %._crit_edge560
  %395 = load i32, ptr %36, align 4, !tbaa !14
  %396 = icmp ne i32 %395, 0
  %or.cond5 = and i1 %39, %396
  br i1 %or.cond5, label %397, label %.loopexit

397:                                              ; preds = %394
  %398 = load ptr, ptr %2, align 8, !tbaa !5
  %399 = load i32, ptr %288, align 8, !tbaa !11
  %400 = sext i32 %399 to i64
  %401 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %400
  %402 = load i32, ptr %401, align 4, !tbaa !12
  %403 = sext i32 %402 to i64
  %404 = getelementptr ptr, ptr %398, i64 %403
  %405 = getelementptr i8, ptr %404, i64 24
  %406 = load ptr, ptr %405, align 8, !tbaa !13
  %407 = load ptr, ptr %5, align 8, !tbaa !5
  %408 = load i32, ptr %306, align 8, !tbaa !11
  %409 = sext i32 %408 to i64
  %410 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %409
  %411 = load i32, ptr %410, align 4, !tbaa !12
  %412 = sext i32 %411 to i64
  %413 = getelementptr ptr, ptr %407, i64 %412
  %414 = getelementptr i8, ptr %413, i64 24
  %415 = load ptr, ptr %414, align 8, !tbaa !13
  %416 = getelementptr ptr, ptr %407, i64 %409
  %417 = getelementptr i8, ptr %416, i64 24
  %418 = load ptr, ptr %417, align 8, !tbaa !13
  %419 = getelementptr inbounds ptr, ptr %398, i64 %400
  %420 = load ptr, ptr %419, align 8, !tbaa !13
  %421 = ptrtoint ptr %420 to i64
  %422 = and i64 %421, 3
  %423 = and i64 %421, -4
  %424 = inttoptr i64 %423 to ptr
  %425 = getelementptr inbounds ptr, ptr %424, i64 %422
  %.2406.in567 = getelementptr inbounds i8, ptr %425, i64 24
  %.2406568 = load ptr, ptr %.2406.in567, align 8, !tbaa !13
  %426 = load float, ptr %.2406568, align 4, !tbaa !17
  %427 = load float, ptr %406, align 4, !tbaa !17
  %428 = fcmp olt float %426, %427
  br i1 %428, label %.lr.ph573, label %.preheader

.preheader:                                       ; preds = %.lr.ph573, %397
  %429 = load float, ptr %418, align 4, !tbaa !17
  %430 = load float, ptr %415, align 4, !tbaa !17
  %431 = fcmp ogt float %429, %430
  br i1 %431, label %.lr.ph575, label %.loopexit

.lr.ph575:                                        ; preds = %.preheader
  %.promoted576 = load i32, ptr %306, align 8, !tbaa !11
  %.promoted577 = load ptr, ptr %5, align 8, !tbaa !5
  br label %445

.lr.ph573:                                        ; preds = %397, %.lr.ph573
  %432 = phi float [ %443, %.lr.ph573 ], [ %426, %397 ]
  %.sroa.0.2570 = phi ptr [ %441, %.lr.ph573 ], [ %424, %397 ]
  %.sroa.17.2569 = phi i64 [ %439, %.lr.ph573 ], [ %422, %397 ]
  store ptr %.sroa.0.2570, ptr %2, align 8, !tbaa !5
  %433 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %.sroa.17.2569
  %434 = load i32, ptr %433, align 4, !tbaa !12
  store i32 %434, ptr %288, align 8, !tbaa !11
  %435 = sext i32 %434 to i64
  %436 = getelementptr inbounds ptr, ptr %.sroa.0.2570, i64 %435
  %437 = load ptr, ptr %436, align 8, !tbaa !13
  %438 = ptrtoint ptr %437 to i64
  %439 = and i64 %438, 3
  %440 = and i64 %438, -4
  %441 = inttoptr i64 %440 to ptr
  %442 = getelementptr inbounds ptr, ptr %441, i64 %439
  %.2406.in = getelementptr inbounds i8, ptr %442, i64 24
  %.2406 = load ptr, ptr %.2406.in, align 8, !tbaa !13
  %443 = load float, ptr %.2406, align 4, !tbaa !17
  %444 = fcmp olt float %443, %432
  br i1 %444, label %.lr.ph573, label %.preheader, !llvm.loop !25

445:                                              ; preds = %.lr.ph575, %445
  %446 = phi float [ %429, %.lr.ph575 ], [ %464, %445 ]
  %447 = phi ptr [ %.promoted577, %.lr.ph575 ], [ %459, %445 ]
  %448 = phi i32 [ %.promoted576, %.lr.ph575 ], [ %457, %445 ]
  %449 = sext i32 %448 to i64
  %450 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %449
  %451 = load i32, ptr %450, align 4, !tbaa !12
  %452 = sext i32 %451 to i64
  %453 = getelementptr inbounds ptr, ptr %447, i64 %452
  %454 = load ptr, ptr %453, align 8, !tbaa !13
  %455 = ptrtoint ptr %454 to i64
  %456 = trunc i64 %455 to i32
  %457 = and i32 %456, 3
  store i32 %457, ptr %306, align 8, !tbaa !11
  %458 = and i64 %455, -4
  %459 = inttoptr i64 %458 to ptr
  store ptr %459, ptr %5, align 8, !tbaa !5
  %460 = and i64 %455, 3
  %461 = getelementptr inbounds ptr, ptr %459, i64 %460
  %462 = getelementptr inbounds i8, ptr %461, i64 24
  %463 = load ptr, ptr %462, align 8, !tbaa !13
  %464 = load float, ptr %463, align 4, !tbaa !17
  %465 = fcmp ogt float %464, %446
  br i1 %465, label %445, label %.loopexit, !llvm.loop !26

.loopexit:                                        ; preds = %445, %.preheader, %394
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %9) #3
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %8) #3
  ret void

466:                                              ; preds = %.lr.ph559, %747
  %467 = phi i1 [ %334, %.lr.ph559 ], [ %751, %747 ]
  %468 = phi i1 [ %332, %.lr.ph559 ], [ %749, %747 ]
  %.sroa.18242.0557 = phi i32 [ %219, %.lr.ph559 ], [ %.sroa.18242.3, %747 ]
  %.sroa.0228.0556 = phi ptr [ %221, %.lr.ph559 ], [ %.sroa.0228.1, %747 ]
  %.0409555 = phi ptr [ %330, %.lr.ph559 ], [ %.3412, %747 ]
  %.0413554 = phi ptr [ %326, %.lr.ph559 ], [ %.3416, %747 ]
  %.0417550 = phi ptr [ %.3438, %.lr.ph559 ], [ %.1418, %747 ]
  %.0419546 = phi ptr [ %.3442, %.lr.ph559 ], [ %.1420, %747 ]
  %.sroa.18.0545 = phi i32 [ %229, %.lr.ph559 ], [ %.sroa.18.3, %747 ]
  %.sroa.0197.0544 = phi ptr [ %231, %.lr.ph559 ], [ %.sroa.0197.1, %747 ]
  br i1 %468, label %.thread490, label %469

469:                                              ; preds = %466
  store ptr %.sroa.0228.0556, ptr %9, align 8, !tbaa !5
  %470 = sext i32 %.sroa.18242.0557 to i64
  %471 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %470
  %472 = load i32, ptr %471, align 4, !tbaa !12
  %473 = sext i32 %472 to i64
  %474 = getelementptr inbounds ptr, ptr %.sroa.0228.0556, i64 %473
  %475 = load ptr, ptr %474, align 8, !tbaa !13
  %476 = ptrtoint ptr %475 to i64
  %477 = trunc i64 %476 to i32
  %478 = and i32 %477, 3
  store i32 %478, ptr %335, align 8, !tbaa !11
  %479 = and i64 %476, -4
  %480 = inttoptr i64 %479 to ptr
  store ptr %480, ptr %9, align 8, !tbaa !5
  %481 = and i64 %476, 3
  %482 = getelementptr inbounds ptr, ptr %480, i64 %481
  %483 = getelementptr inbounds i8, ptr %482, i64 24
  %484 = load ptr, ptr %483, align 8, !tbaa !13
  %.not447 = icmp eq ptr %484, null
  br i1 %.not447, label %.thread475, label %485

485:                                              ; preds = %469
  %486 = call float @incircle(ptr noundef %0, ptr noundef %1, ptr noundef %.0419546, ptr noundef %.0417550, ptr noundef %.0413554, ptr noundef nonnull %484)
  %487 = fcmp ule float %486, 0.000000e+00
  br i1 %487, label %._crit_edge531, label %.lr.ph530

.lr.ph530:                                        ; preds = %485
  %488 = ptrtoint ptr %.sroa.0228.0556 to i64
  br label %489

489:                                              ; preds = %.lr.ph530, %568
  %.sroa.18242.1528 = phi i32 [ %.sroa.18242.0557, %.lr.ph530 ], [ %523, %568 ]
  %.0407527 = phi ptr [ %484, %.lr.ph530 ], [ %567, %568 ]
  %.1414526 = phi ptr [ %.0413554, %.lr.ph530 ], [ %.0407527, %568 ]
  %490 = load i32, ptr %335, align 8, !tbaa !11
  %491 = sext i32 %490 to i64
  %492 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %491
  %493 = load i32, ptr %492, align 4, !tbaa !12
  %494 = load ptr, ptr %9, align 8, !tbaa !5
  %495 = sext i32 %493 to i64
  %496 = getelementptr inbounds ptr, ptr %494, i64 %495
  %497 = load ptr, ptr %496, align 8, !tbaa !13
  %498 = ptrtoint ptr %497 to i64
  %499 = and i64 %498, 3
  %500 = and i64 %498, -4
  %501 = inttoptr i64 %500 to ptr
  %502 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %495
  %503 = load i32, ptr %502, align 4, !tbaa !12
  %504 = sext i32 %503 to i64
  %505 = getelementptr inbounds ptr, ptr %494, i64 %504
  %506 = load ptr, ptr %505, align 8, !tbaa !13
  %507 = ptrtoint ptr %506 to i64
  %508 = trunc i64 %507 to i32
  %509 = and i32 %508, 3
  %510 = and i64 %507, 3
  %511 = and i64 %507, -4
  %512 = inttoptr i64 %511 to ptr
  store ptr %497, ptr %505, align 8, !tbaa !13
  %513 = ptrtoint ptr %494 to i64
  %514 = or i64 %513, %504
  %515 = inttoptr i64 %514 to ptr
  %516 = getelementptr inbounds ptr, ptr %501, i64 %499
  store ptr %515, ptr %516, align 8, !tbaa !13
  %517 = sext i32 %.sroa.18242.1528 to i64
  %518 = getelementptr inbounds ptr, ptr %.sroa.0228.0556, i64 %517
  store ptr %506, ptr %518, align 8, !tbaa !13
  %519 = or i64 %517, %488
  %520 = inttoptr i64 %519 to ptr
  %521 = getelementptr inbounds ptr, ptr %512, i64 %510
  store ptr %520, ptr %521, align 8, !tbaa !13
  %522 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %517
  %523 = load i32, ptr %522, align 4, !tbaa !12
  %524 = sext i32 %523 to i64
  %525 = getelementptr inbounds ptr, ptr %.sroa.0228.0556, i64 %524
  %526 = load ptr, ptr %525, align 8, !tbaa !13
  %527 = ptrtoint ptr %526 to i64
  %528 = and i64 %527, 3
  %529 = and i64 %527, -4
  %530 = inttoptr i64 %529 to ptr
  %531 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %504
  %532 = load i32, ptr %531, align 4, !tbaa !12
  %533 = load ptr, ptr %9, align 8, !tbaa !5
  %534 = sext i32 %532 to i64
  %535 = getelementptr inbounds ptr, ptr %533, i64 %534
  store ptr %526, ptr %535, align 8, !tbaa !13
  %536 = ptrtoint ptr %533 to i64
  %537 = or i64 %536, %534
  %538 = inttoptr i64 %537 to ptr
  %539 = getelementptr inbounds ptr, ptr %530, i64 %528
  store ptr %538, ptr %539, align 8, !tbaa !13
  %540 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %524
  %541 = load i32, ptr %540, align 4, !tbaa !12
  %542 = add nsw i32 %541, 3
  %543 = sext i32 %542 to i64
  %544 = getelementptr inbounds ptr, ptr %.sroa.0228.0556, i64 %543
  store ptr %.0419546, ptr %544, align 8, !tbaa !13
  %545 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %524
  %546 = load i32, ptr %545, align 4, !tbaa !12
  %547 = add nsw i32 %546, 3
  %548 = sext i32 %547 to i64
  %549 = getelementptr inbounds ptr, ptr %.sroa.0228.0556, i64 %548
  store ptr null, ptr %549, align 8, !tbaa !13
  %550 = add nsw i32 %523, 3
  %551 = sext i32 %550 to i64
  %552 = getelementptr inbounds ptr, ptr %.sroa.0228.0556, i64 %551
  store ptr %.0407527, ptr %552, align 8, !tbaa !13
  %553 = load ptr, ptr %9, align 8, !tbaa !5
  %554 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %534
  %555 = load i32, ptr %554, align 4, !tbaa !12
  %556 = sext i32 %555 to i64
  %557 = getelementptr ptr, ptr %553, i64 %556
  %558 = getelementptr i8, ptr %557, i64 24
  store ptr null, ptr %558, align 8, !tbaa !13
  %559 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %534
  %560 = load i32, ptr %559, align 4, !tbaa !12
  %561 = sext i32 %560 to i64
  %562 = getelementptr ptr, ptr %553, i64 %561
  %563 = getelementptr i8, ptr %562, i64 24
  store ptr %.1414526, ptr %563, align 8, !tbaa !13
  %564 = getelementptr ptr, ptr %553, i64 %534
  %565 = getelementptr i8, ptr %564, i64 24
  store ptr %.0407527, ptr %565, align 8, !tbaa !13
  store ptr %512, ptr %9, align 8, !tbaa !5
  store i32 %509, ptr %335, align 8, !tbaa !11
  %566 = getelementptr inbounds i8, ptr %521, i64 24
  %567 = load ptr, ptr %566, align 8, !tbaa !13
  %.not449 = icmp eq ptr %567, null
  br i1 %.not449, label %._crit_edge531, label %568

568:                                              ; preds = %489
  %569 = call float @incircle(ptr noundef %0, ptr noundef %1, ptr noundef %.0419546, ptr noundef %.0417550, ptr noundef nonnull %.0407527, ptr noundef nonnull %567)
  %570 = fcmp ule float %569, 0.000000e+00
  br i1 %570, label %._crit_edge531, label %489, !llvm.loop !27

._crit_edge531:                                   ; preds = %489, %568, %485
  %.1414.lcssa = phi ptr [ %.0413554, %485 ], [ %.0407527, %568 ], [ %.0407527, %489 ]
  %.sroa.18242.1.lcssa = phi i32 [ %.sroa.18242.0557, %485 ], [ %523, %568 ], [ %523, %489 ]
  br i1 %467, label %.thread472, label %571

.thread490:                                       ; preds = %466
  br i1 %467, label %.thread469.thread493, label %571

.thread475:                                       ; preds = %469
  br i1 %467, label %.thread472, label %571

571:                                              ; preds = %.thread490, %.thread475, %._crit_edge531
  %.sroa.18242.2483 = phi i32 [ %.sroa.18242.0557, %.thread475 ], [ %.sroa.18242.1.lcssa, %._crit_edge531 ], [ %.sroa.18242.0557, %.thread490 ]
  %.2415479 = phi ptr [ %.0413554, %.thread475 ], [ %.1414.lcssa, %._crit_edge531 ], [ %.0413554, %.thread490 ]
  store ptr %.sroa.0197.0544, ptr %9, align 8, !tbaa !5
  %572 = sext i32 %.sroa.18.0545 to i64
  %573 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %572
  %574 = load i32, ptr %573, align 4, !tbaa !12
  %575 = sext i32 %574 to i64
  %576 = getelementptr inbounds ptr, ptr %.sroa.0197.0544, i64 %575
  %577 = load ptr, ptr %576, align 8, !tbaa !13
  %578 = ptrtoint ptr %577 to i64
  %579 = trunc i64 %578 to i32
  %580 = and i32 %579, 3
  store i32 %580, ptr %335, align 8, !tbaa !11
  %581 = and i64 %578, -4
  %582 = inttoptr i64 %581 to ptr
  store ptr %582, ptr %9, align 8, !tbaa !5
  %583 = and i64 %578, 3
  %584 = getelementptr inbounds ptr, ptr %582, i64 %583
  %585 = getelementptr inbounds i8, ptr %584, i64 24
  %586 = load ptr, ptr %585, align 8, !tbaa !13
  %.not450 = icmp eq ptr %586, null
  br i1 %.not450, label %.thread, label %587

587:                                              ; preds = %571
  %588 = call float @incircle(ptr noundef %0, ptr noundef %1, ptr noundef %.0419546, ptr noundef %.0417550, ptr noundef %.0409555, ptr noundef nonnull %586)
  %589 = fcmp ule float %588, 0.000000e+00
  br i1 %589, label %._crit_edge540.thread, label %.lr.ph539

.lr.ph539:                                        ; preds = %587
  %590 = ptrtoint ptr %.sroa.0197.0544 to i64
  br label %591

591:                                              ; preds = %.lr.ph539, %670
  %.1408537 = phi ptr [ %586, %.lr.ph539 ], [ %669, %670 ]
  %.1410536 = phi ptr [ %.0409555, %.lr.ph539 ], [ %.1408537, %670 ]
  %.sroa.18.1535 = phi i32 [ %.sroa.18.0545, %.lr.ph539 ], [ %625, %670 ]
  %592 = load i32, ptr %335, align 8, !tbaa !11
  %593 = sext i32 %592 to i64
  %594 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %593
  %595 = load i32, ptr %594, align 4, !tbaa !12
  %596 = load ptr, ptr %9, align 8, !tbaa !5
  %597 = sext i32 %595 to i64
  %598 = getelementptr inbounds ptr, ptr %596, i64 %597
  %599 = load ptr, ptr %598, align 8, !tbaa !13
  %600 = ptrtoint ptr %599 to i64
  %601 = and i64 %600, 3
  %602 = and i64 %600, -4
  %603 = inttoptr i64 %602 to ptr
  %604 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %597
  %605 = load i32, ptr %604, align 4, !tbaa !12
  %606 = sext i32 %605 to i64
  %607 = getelementptr inbounds ptr, ptr %596, i64 %606
  %608 = load ptr, ptr %607, align 8, !tbaa !13
  %609 = ptrtoint ptr %608 to i64
  %610 = trunc i64 %609 to i32
  %611 = and i32 %610, 3
  %612 = and i64 %609, 3
  %613 = and i64 %609, -4
  %614 = inttoptr i64 %613 to ptr
  store ptr %599, ptr %607, align 8, !tbaa !13
  %615 = ptrtoint ptr %596 to i64
  %616 = or i64 %615, %606
  %617 = inttoptr i64 %616 to ptr
  %618 = getelementptr inbounds ptr, ptr %603, i64 %601
  store ptr %617, ptr %618, align 8, !tbaa !13
  %619 = sext i32 %.sroa.18.1535 to i64
  %620 = getelementptr inbounds ptr, ptr %.sroa.0197.0544, i64 %619
  store ptr %608, ptr %620, align 8, !tbaa !13
  %621 = or i64 %619, %590
  %622 = inttoptr i64 %621 to ptr
  %623 = getelementptr inbounds ptr, ptr %614, i64 %612
  store ptr %622, ptr %623, align 8, !tbaa !13
  %624 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %619
  %625 = load i32, ptr %624, align 4, !tbaa !12
  %626 = sext i32 %625 to i64
  %627 = getelementptr inbounds ptr, ptr %.sroa.0197.0544, i64 %626
  %628 = load ptr, ptr %627, align 8, !tbaa !13
  %629 = ptrtoint ptr %628 to i64
  %630 = and i64 %629, 3
  %631 = and i64 %629, -4
  %632 = inttoptr i64 %631 to ptr
  %633 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %606
  %634 = load i32, ptr %633, align 4, !tbaa !12
  %635 = load ptr, ptr %9, align 8, !tbaa !5
  %636 = sext i32 %634 to i64
  %637 = getelementptr inbounds ptr, ptr %635, i64 %636
  store ptr %628, ptr %637, align 8, !tbaa !13
  %638 = ptrtoint ptr %635 to i64
  %639 = or i64 %638, %636
  %640 = inttoptr i64 %639 to ptr
  %641 = getelementptr inbounds ptr, ptr %632, i64 %630
  store ptr %640, ptr %641, align 8, !tbaa !13
  %642 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %626
  %643 = load i32, ptr %642, align 4, !tbaa !12
  %644 = add nsw i32 %643, 3
  %645 = sext i32 %644 to i64
  %646 = getelementptr inbounds ptr, ptr %.sroa.0197.0544, i64 %645
  store ptr null, ptr %646, align 8, !tbaa !13
  %647 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %626
  %648 = load i32, ptr %647, align 4, !tbaa !12
  %649 = add nsw i32 %648, 3
  %650 = sext i32 %649 to i64
  %651 = getelementptr inbounds ptr, ptr %.sroa.0197.0544, i64 %650
  store ptr %.0417550, ptr %651, align 8, !tbaa !13
  %652 = add nsw i32 %625, 3
  %653 = sext i32 %652 to i64
  %654 = getelementptr inbounds ptr, ptr %.sroa.0197.0544, i64 %653
  store ptr %.1408537, ptr %654, align 8, !tbaa !13
  %655 = load ptr, ptr %9, align 8, !tbaa !5
  %656 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %636
  %657 = load i32, ptr %656, align 4, !tbaa !12
  %658 = sext i32 %657 to i64
  %659 = getelementptr ptr, ptr %655, i64 %658
  %660 = getelementptr i8, ptr %659, i64 24
  store ptr %.1410536, ptr %660, align 8, !tbaa !13
  %661 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %636
  %662 = load i32, ptr %661, align 4, !tbaa !12
  %663 = sext i32 %662 to i64
  %664 = getelementptr ptr, ptr %655, i64 %663
  %665 = getelementptr i8, ptr %664, i64 24
  store ptr null, ptr %665, align 8, !tbaa !13
  %666 = getelementptr ptr, ptr %655, i64 %636
  %667 = getelementptr i8, ptr %666, i64 24
  store ptr %.1408537, ptr %667, align 8, !tbaa !13
  store ptr %614, ptr %9, align 8, !tbaa !5
  store i32 %611, ptr %335, align 8, !tbaa !11
  %668 = getelementptr inbounds i8, ptr %623, i64 24
  %669 = load ptr, ptr %668, align 8, !tbaa !13
  %.not452 = icmp eq ptr %669, null
  br i1 %.not452, label %._crit_edge540, label %670

670:                                              ; preds = %591
  %671 = call float @incircle(ptr noundef %0, ptr noundef %1, ptr noundef %.0419546, ptr noundef %.0417550, ptr noundef nonnull %.1408537, ptr noundef nonnull %669)
  %672 = fcmp ule float %671, 0.000000e+00
  br i1 %672, label %._crit_edge540, label %591, !llvm.loop !28

._crit_edge540:                                   ; preds = %591, %670
  br i1 %468, label %.thread469.thread493, label %673

._crit_edge540.thread:                            ; preds = %587
  br i1 %468, label %.thread469.thread493, label %.thread462

.thread:                                          ; preds = %571
  br i1 %468, label %.thread469.thread493, label %.thread462

673:                                              ; preds = %._crit_edge540
  br i1 %467, label %.thread472, label %.thread462

.thread462:                                       ; preds = %._crit_edge540.thread, %.thread, %673
  %.sroa.18.2458467 = phi i32 [ %625, %673 ], [ %.sroa.18.0545, %.thread ], [ %.sroa.18.0545, %._crit_edge540.thread ]
  %.2411460465 = phi ptr [ %.1408537, %673 ], [ %.0409555, %.thread ], [ %.0409555, %._crit_edge540.thread ]
  %674 = call float @incircle(ptr noundef %0, ptr noundef %1, ptr noundef %.2415479, ptr noundef %.0419546, ptr noundef %.0417550, ptr noundef %.2411460465)
  %675 = fcmp ogt float %674, 0.000000e+00
  br i1 %675, label %.thread469.thread493, label %.thread472

.thread469.thread493:                             ; preds = %._crit_edge540.thread, %.thread490, %.thread, %.thread462, %._crit_edge540
  %.sroa.18242.2482 = phi i32 [ %.sroa.18242.2483, %.thread ], [ %.sroa.18242.2483, %.thread462 ], [ %.sroa.18242.2483, %._crit_edge540 ], [ %.sroa.18242.0557, %.thread490 ], [ %.sroa.18242.2483, %._crit_edge540.thread ]
  %.2415478 = phi ptr [ %.2415479, %.thread ], [ %.2415479, %.thread462 ], [ %.2415479, %._crit_edge540 ], [ %.0413554, %.thread490 ], [ %.2415479, %._crit_edge540.thread ]
  %.2411461 = phi ptr [ %.0409555, %.thread ], [ %.2411460465, %.thread462 ], [ %.1408537, %._crit_edge540 ], [ %.0409555, %.thread490 ], [ %.0409555, %._crit_edge540.thread ]
  %.sroa.18.2459 = phi i32 [ %.sroa.18.0545, %.thread ], [ %.sroa.18.2458467, %.thread462 ], [ %625, %._crit_edge540 ], [ %.sroa.18.0545, %.thread490 ], [ %.sroa.18.0545, %._crit_edge540.thread ]
  %676 = ptrtoint ptr %.sroa.0197.0544 to i64
  %677 = sext i32 %.sroa.18.2459 to i64
  %678 = or i64 %677, %676
  %679 = inttoptr i64 %678 to ptr
  %680 = load ptr, ptr %8, align 8, !tbaa !5
  %681 = load i32, ptr %239, align 8, !tbaa !11
  %682 = sext i32 %681 to i64
  %683 = getelementptr inbounds ptr, ptr %680, i64 %682
  store ptr %679, ptr %683, align 8, !tbaa !13
  %684 = load ptr, ptr %8, align 8, !tbaa !5
  %685 = ptrtoint ptr %684 to i64
  %686 = or i64 %685, %682
  %687 = inttoptr i64 %686 to ptr
  %688 = getelementptr inbounds ptr, ptr %.sroa.0197.0544, i64 %677
  store ptr %687, ptr %688, align 8, !tbaa !13
  store ptr %.sroa.0197.0544, ptr %8, align 8, !tbaa !5
  %689 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %677
  %690 = load i32, ptr %689, align 4, !tbaa !12
  store i32 %690, ptr %239, align 8, !tbaa !11
  %691 = sext i32 %690 to i64
  %692 = getelementptr inbounds [3 x i32], ptr @minus1mod3, i64 0, i64 %691
  %693 = load i32, ptr %692, align 4, !tbaa !12
  %694 = add nsw i32 %693, 3
  %695 = sext i32 %694 to i64
  %696 = getelementptr inbounds ptr, ptr %.sroa.0197.0544, i64 %695
  store ptr %.0419546, ptr %696, align 8, !tbaa !13
  %697 = load ptr, ptr %8, align 8, !tbaa !5
  %698 = getelementptr inbounds ptr, ptr %697, i64 %691
  %699 = load ptr, ptr %698, align 8, !tbaa !13
  %700 = ptrtoint ptr %699 to i64
  %701 = trunc i64 %700 to i32
  %702 = and i32 %701, 3
  %703 = and i64 %700, -4
  %704 = inttoptr i64 %703 to ptr
  %705 = and i64 %700, 3
  %706 = getelementptr inbounds ptr, ptr %704, i64 %705
  %707 = getelementptr inbounds i8, ptr %706, i64 24
  %708 = load ptr, ptr %707, align 8, !tbaa !13
  br label %742

.thread472:                                       ; preds = %._crit_edge531, %.thread475, %.thread462, %673
  %.sroa.18242.2485 = phi i32 [ %.sroa.18242.2483, %.thread462 ], [ %.sroa.18242.2483, %673 ], [ %.sroa.18242.0557, %.thread475 ], [ %.sroa.18242.1.lcssa, %._crit_edge531 ]
  %.2415481 = phi ptr [ %.2415479, %.thread462 ], [ %.2415479, %673 ], [ %.0413554, %.thread475 ], [ %.1414.lcssa, %._crit_edge531 ]
  %.sroa.18.2458468 = phi i32 [ %.sroa.18.2458467, %.thread462 ], [ %625, %673 ], [ %.sroa.18.0545, %.thread475 ], [ %.sroa.18.0545, %._crit_edge531 ]
  %.2411460466 = phi ptr [ %.2411460465, %.thread462 ], [ %.1408537, %673 ], [ %.0409555, %.thread475 ], [ %.0409555, %._crit_edge531 ]
  %709 = ptrtoint ptr %.sroa.0228.0556 to i64
  %710 = sext i32 %.sroa.18242.2485 to i64
  %711 = or i64 %710, %709
  %712 = inttoptr i64 %711 to ptr
  %713 = load ptr, ptr %8, align 8, !tbaa !5
  %714 = load i32, ptr %239, align 8, !tbaa !11
  %715 = sext i32 %714 to i64
  %716 = getelementptr inbounds ptr, ptr %713, i64 %715
  store ptr %712, ptr %716, align 8, !tbaa !13
  %717 = load ptr, ptr %8, align 8, !tbaa !5
  %718 = ptrtoint ptr %717 to i64
  %719 = or i64 %718, %715
  %720 = inttoptr i64 %719 to ptr
  %721 = getelementptr inbounds ptr, ptr %.sroa.0228.0556, i64 %710
  store ptr %720, ptr %721, align 8, !tbaa !13
  store ptr %.sroa.0228.0556, ptr %8, align 8, !tbaa !5
  %722 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %710
  %723 = load i32, ptr %722, align 4, !tbaa !12
  store i32 %723, ptr %239, align 8, !tbaa !11
  %724 = sext i32 %723 to i64
  %725 = getelementptr inbounds [3 x i32], ptr @plus1mod3, i64 0, i64 %724
  %726 = load i32, ptr %725, align 4, !tbaa !12
  %727 = add nsw i32 %726, 3
  %728 = sext i32 %727 to i64
  %729 = getelementptr inbounds ptr, ptr %.sroa.0228.0556, i64 %728
  store ptr %.0417550, ptr %729, align 8, !tbaa !13
  %730 = load ptr, ptr %8, align 8, !tbaa !5
  %731 = getelementptr inbounds ptr, ptr %730, i64 %724
  %732 = load ptr, ptr %731, align 8, !tbaa !13
  %733 = ptrtoint ptr %732 to i64
  %734 = trunc i64 %733 to i32
  %735 = and i32 %734, 3
  %736 = and i64 %733, -4
  %737 = inttoptr i64 %736 to ptr
  %738 = and i64 %733, 3
  %739 = getelementptr inbounds ptr, ptr %737, i64 %738
  %740 = getelementptr inbounds i8, ptr %739, i64 24
  %741 = load ptr, ptr %740, align 8, !tbaa !13
  br label %742

742:                                              ; preds = %.thread472, %.thread469.thread493
  %.sroa.0197.1 = phi ptr [ %704, %.thread469.thread493 ], [ %.sroa.0197.0544, %.thread472 ]
  %.sroa.18.3 = phi i32 [ %702, %.thread469.thread493 ], [ %.sroa.18.2458468, %.thread472 ]
  %.1420 = phi ptr [ %.0419546, %.thread469.thread493 ], [ %.2415481, %.thread472 ]
  %.1418 = phi ptr [ %.2411461, %.thread469.thread493 ], [ %.0417550, %.thread472 ]
  %.3416 = phi ptr [ %.2415478, %.thread469.thread493 ], [ %741, %.thread472 ]
  %.3412 = phi ptr [ %708, %.thread469.thread493 ], [ %.2411460466, %.thread472 ]
  %.sroa.0228.1 = phi ptr [ %.sroa.0228.0556, %.thread469.thread493 ], [ %737, %.thread472 ]
  %.sroa.18242.3 = phi i32 [ %.sroa.18242.2482, %.thread469.thread493 ], [ %735, %.thread472 ]
  %743 = load i32, ptr %281, align 4, !tbaa !24
  %744 = icmp sgt i32 %743, 2
  br i1 %744, label %745, label %747

745:                                              ; preds = %742
  %746 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.61)
  call void @printtriangle(ptr noundef %0, ptr noundef nonnull %1, ptr noundef nonnull %8)
  br label %747

747:                                              ; preds = %745, %742
  %748 = call float @counterclockwise(ptr noundef %0, ptr noundef nonnull %1, ptr noundef %.3416, ptr noundef %.1420, ptr noundef %.1418)
  %749 = fcmp ole float %748, 0.000000e+00
  %750 = call float @counterclockwise(ptr noundef %0, ptr noundef nonnull %1, ptr noundef %.3412, ptr noundef %.1420, ptr noundef %.1418)
  %751 = fcmp ole float %750, 0.000000e+00
  %or.cond3 = select i1 %749, i1 %751, i1 false
  br i1 %or.cond3, label %._crit_edge560, label %466
}

attributes #0 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { nofree nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { 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 #3 = { 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, !7, i64 0}
!6 = !{!"otri", !7, i64 0, !10, i64 8}
!7 = !{!"any pointer", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"int", !8, i64 0}
!11 = !{!6, !10, i64 8}
!12 = !{!10, !10, i64 0}
!13 = !{!7, !7, i64 0}
!14 = !{!15, !10, i64 100}
!15 = !{!"behavior", !10, i64 0, !10, i64 4, !10, i64 8, !10, i64 12, !10, i64 16, !10, i64 20, !10, i64 24, !10, i64 28, !10, i64 32, !10, i64 36, !10, i64 40, !10, i64 44, !10, i64 48, !10, i64 52, !10, i64 56, !10, i64 60, !10, i64 64, !10, i64 68, !10, i64 72, !10, i64 76, !10, i64 80, !10, i64 84, !10, i64 88, !10, i64 92, !10, i64 96, !10, i64 100, !10, i64 104, !10, i64 108, !10, i64 112, !10, i64 116, !10, i64 120, !10, i64 124, !10, i64 128, !10, i64 132, !16, i64 136, !16, i64 140, !16, i64 144, !16, i64 148}
!16 = !{!"float", !8, i64 0}
!17 = !{!16, !16, i64 0}
!18 = distinct !{!18, !19}
!19 = !{!"llvm.loop.mustprogress"}
!20 = distinct !{!20, !19}
!21 = distinct !{!21, !19}
!22 = distinct !{!22, !19}
!23 = distinct !{!23, !19}
!24 = !{!15, !10, i64 116}
!25 = distinct !{!25, !19}
!26 = distinct !{!26, !19}
!27 = distinct !{!27, !19}
!28 = distinct !{!28, !19}


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