; LLVM IR from louk78/crypto_project :: bignum (bignum_divide)

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

@NUMS = external dso_local global [11 x %struct.bignum], align 16

; Function Attrs: nounwind uwtable
declare dso_local ptr @bignum_alloc() #0

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

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

; Function Attrs: nounwind uwtable
declare dso_local void @bignum_free(ptr noundef) #0

; Function Attrs: nounwind uwtable
declare dso_local i32 @bignum_iszero(ptr noundef) #0

; Function Attrs: nounwind uwtable
declare dso_local i32 @bignum_isless(ptr noundef, ptr noundef) #0

; Function Attrs: nounwind allocsize(1)
declare ptr @realloc(ptr noundef, i64 noundef) #2

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

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

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

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

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

; Function Attrs: nounwind uwtable
define dso_local void @bignum_divide(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3) #0 {
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca ptr, align 8
  %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 ptr, align 8
  %15 = alloca i32, align 4
  %16 = alloca i64, align 8
  %17 = alloca i64, align 8
  %18 = alloca i64, align 8
  %19 = alloca i64, align 8
  %20 = alloca i32, align 4
  %21 = alloca i32, align 4
  %22 = alloca i32, align 4
  %23 = alloca i32, align 4
  %24 = alloca i32, align 4
  store ptr %0, ptr %5, align 8, !tbaa !5
  store ptr %1, ptr %6, align 8, !tbaa !5
  store ptr %2, ptr %7, align 8, !tbaa !5
  store ptr %3, ptr %8, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #3
  %25 = call ptr @bignum_alloc()
  store ptr %25, ptr %9, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #3
  %26 = call ptr @bignum_alloc()
  store ptr %26, ptr %10, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #3
  %27 = call ptr @bignum_alloc()
  store ptr %27, ptr %11, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #3
  %28 = call ptr @bignum_alloc()
  store ptr %28, ptr %12, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #3
  %29 = call ptr @bignum_alloc()
  store ptr %29, ptr %13, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #3
  %30 = call ptr @bignum_alloc()
  store ptr %30, ptr %14, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #3
  store i32 0, ptr %15, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #3
  store i64 1, ptr %16, align 8, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #3
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #3
  store i32 0, ptr %24, align 4, !tbaa !9
  %31 = load ptr, ptr %7, align 8, !tbaa !5
  %32 = load ptr, ptr %8, align 8, !tbaa !5
  %33 = call i32 @bignum_isless(ptr noundef %31, ptr noundef %32)
  %34 = icmp ne i32 %33, 0
  br i1 %34, label %35, label %40

35:                                               ; preds = %4
  %36 = load ptr, ptr %5, align 8, !tbaa !5
  %37 = getelementptr inbounds %struct.bignum, ptr %36, i32 0, i32 0
  store i32 0, ptr %37, align 8, !tbaa !13
  %38 = load ptr, ptr %7, align 8, !tbaa !5
  %39 = load ptr, ptr %6, align 8, !tbaa !5
  call void @bignum_copy(ptr noundef %38, ptr noundef %39)
  br label %631

40:                                               ; preds = %4
  %41 = load ptr, ptr %7, align 8, !tbaa !5
  %42 = call i32 @bignum_iszero(ptr noundef %41)
  %43 = icmp ne i32 %42, 0
  br i1 %43, label %44, label %48

44:                                               ; preds = %40
  %45 = load ptr, ptr %5, align 8, !tbaa !5
  %46 = getelementptr inbounds %struct.bignum, ptr %45, i32 0, i32 0
  store i32 0, ptr %46, align 8, !tbaa !13
  %47 = load ptr, ptr %6, align 8, !tbaa !5
  call void @bignum_fromint(ptr noundef %47, i32 noundef 0)
  br label %630

48:                                               ; preds = %40
  %49 = load ptr, ptr %8, align 8, !tbaa !5
  %50 = getelementptr inbounds %struct.bignum, ptr %49, i32 0, i32 0
  %51 = load i32, ptr %50, align 8, !tbaa !13
  %52 = icmp eq i32 %51, 1
  br i1 %52, label %53, label %148

53:                                               ; preds = %48
  %54 = load ptr, ptr %5, align 8, !tbaa !5
  %55 = getelementptr inbounds %struct.bignum, ptr %54, i32 0, i32 1
  %56 = load i32, ptr %55, align 4, !tbaa !15
  %57 = load ptr, ptr %7, align 8, !tbaa !5
  %58 = getelementptr inbounds %struct.bignum, ptr %57, i32 0, i32 0
  %59 = load i32, ptr %58, align 8, !tbaa !13
  %60 = icmp slt i32 %56, %59
  br i1 %60, label %61, label %78

61:                                               ; preds = %53
  %62 = load ptr, ptr %7, align 8, !tbaa !5
  %63 = getelementptr inbounds %struct.bignum, ptr %62, i32 0, i32 0
  %64 = load i32, ptr %63, align 8, !tbaa !13
  %65 = load ptr, ptr %5, align 8, !tbaa !5
  %66 = getelementptr inbounds %struct.bignum, ptr %65, i32 0, i32 1
  store i32 %64, ptr %66, align 4, !tbaa !15
  %67 = load ptr, ptr %5, align 8, !tbaa !5
  %68 = getelementptr inbounds %struct.bignum, ptr %67, i32 0, i32 2
  %69 = load ptr, ptr %68, align 8, !tbaa !16
  %70 = load ptr, ptr %5, align 8, !tbaa !5
  %71 = getelementptr inbounds %struct.bignum, ptr %70, i32 0, i32 1
  %72 = load i32, ptr %71, align 4, !tbaa !15
  %73 = sext i32 %72 to i64
  %74 = mul i64 %73, 4
  %75 = call ptr @realloc(ptr noundef %69, i64 noundef %74) #4
  %76 = load ptr, ptr %5, align 8, !tbaa !5
  %77 = getelementptr inbounds %struct.bignum, ptr %76, i32 0, i32 2
  store ptr %75, ptr %77, align 8, !tbaa !16
  br label %78

78:                                               ; preds = %61, %53
  %79 = load ptr, ptr %7, align 8, !tbaa !5
  %80 = getelementptr inbounds %struct.bignum, ptr %79, i32 0, i32 0
  %81 = load i32, ptr %80, align 8, !tbaa !13
  %82 = sub nsw i32 %81, 1
  store i32 %82, ptr %22, align 4, !tbaa !9
  br label %83

83:                                               ; preds = %139, %78
  %84 = load i32, ptr %22, align 4, !tbaa !9
  %85 = icmp sge i32 %84, 0
  br i1 %85, label %86, label %142

86:                                               ; preds = %83
  %87 = load i32, ptr %15, align 4, !tbaa !9
  %88 = zext i32 %87 to i64
  %89 = mul i64 %88, 4294967296
  %90 = load ptr, ptr %7, align 8, !tbaa !5
  %91 = getelementptr inbounds %struct.bignum, ptr %90, i32 0, i32 2
  %92 = load ptr, ptr %91, align 8, !tbaa !16
  %93 = load i32, ptr %22, align 4, !tbaa !9
  %94 = sext i32 %93 to i64
  %95 = getelementptr inbounds i32, ptr %92, i64 %94
  %96 = load i32, ptr %95, align 4, !tbaa !9
  %97 = zext i32 %96 to i64
  %98 = add i64 %89, %97
  store i64 %98, ptr %18, align 8, !tbaa !11
  %99 = load i64, ptr %18, align 8, !tbaa !11
  %100 = load ptr, ptr %8, align 8, !tbaa !5
  %101 = getelementptr inbounds %struct.bignum, ptr %100, i32 0, i32 2
  %102 = load ptr, ptr %101, align 8, !tbaa !16
  %103 = getelementptr inbounds i32, ptr %102, i64 0
  %104 = load i32, ptr %103, align 4, !tbaa !9
  %105 = zext i32 %104 to i64
  %106 = udiv i64 %99, %105
  store i64 %106, ptr %17, align 8, !tbaa !11
  %107 = load i64, ptr %17, align 8, !tbaa !11
  %108 = trunc i64 %107 to i32
  %109 = load ptr, ptr %5, align 8, !tbaa !5
  %110 = getelementptr inbounds %struct.bignum, ptr %109, i32 0, i32 2
  %111 = load ptr, ptr %110, align 8, !tbaa !16
  %112 = load i32, ptr %22, align 4, !tbaa !9
  %113 = sext i32 %112 to i64
  %114 = getelementptr inbounds i32, ptr %111, i64 %113
  store i32 %108, ptr %114, align 4, !tbaa !9
  %115 = load ptr, ptr %5, align 8, !tbaa !5
  %116 = getelementptr inbounds %struct.bignum, ptr %115, i32 0, i32 2
  %117 = load ptr, ptr %116, align 8, !tbaa !16
  %118 = load i32, ptr %22, align 4, !tbaa !9
  %119 = sext i32 %118 to i64
  %120 = getelementptr inbounds i32, ptr %117, i64 %119
  %121 = load i32, ptr %120, align 4, !tbaa !9
  %122 = icmp ne i32 %121, 0
  br i1 %122, label %123, label %129

123:                                              ; preds = %86
  %124 = load i32, ptr %24, align 4, !tbaa !9
  %125 = icmp eq i32 %124, 0
  br i1 %125, label %126, label %129

126:                                              ; preds = %123
  %127 = load i32, ptr %22, align 4, !tbaa !9
  %128 = add nsw i32 %127, 1
  store i32 %128, ptr %24, align 4, !tbaa !9
  br label %129

129:                                              ; preds = %126, %123, %86
  %130 = load i64, ptr %18, align 8, !tbaa !11
  %131 = load ptr, ptr %8, align 8, !tbaa !5
  %132 = getelementptr inbounds %struct.bignum, ptr %131, i32 0, i32 2
  %133 = load ptr, ptr %132, align 8, !tbaa !16
  %134 = getelementptr inbounds i32, ptr %133, i64 0
  %135 = load i32, ptr %134, align 4, !tbaa !9
  %136 = zext i32 %135 to i64
  %137 = urem i64 %130, %136
  %138 = trunc i64 %137 to i32
  store i32 %138, ptr %15, align 4, !tbaa !9
  br label %139

139:                                              ; preds = %129
  %140 = load i32, ptr %22, align 4, !tbaa !9
  %141 = add nsw i32 %140, -1
  store i32 %141, ptr %22, align 4, !tbaa !9
  br label %83, !llvm.loop !17

142:                                              ; preds = %83
  %143 = load ptr, ptr %6, align 8, !tbaa !5
  %144 = load i32, ptr %15, align 4, !tbaa !9
  call void @bignum_fromint(ptr noundef %143, i32 noundef %144)
  %145 = load i32, ptr %24, align 4, !tbaa !9
  %146 = load ptr, ptr %5, align 8, !tbaa !5
  %147 = getelementptr inbounds %struct.bignum, ptr %146, i32 0, i32 0
  store i32 %145, ptr %147, align 8, !tbaa !13
  br label %629

148:                                              ; preds = %48
  %149 = load ptr, ptr %7, align 8, !tbaa !5
  %150 = getelementptr inbounds %struct.bignum, ptr %149, i32 0, i32 0
  %151 = load i32, ptr %150, align 8, !tbaa !13
  %152 = add nsw i32 %151, 1
  store i32 %152, ptr %20, align 4, !tbaa !9
  %153 = load ptr, ptr %8, align 8, !tbaa !5
  %154 = getelementptr inbounds %struct.bignum, ptr %153, i32 0, i32 0
  %155 = load i32, ptr %154, align 8, !tbaa !13
  store i32 %155, ptr %21, align 4, !tbaa !9
  %156 = load ptr, ptr %5, align 8, !tbaa !5
  %157 = getelementptr inbounds %struct.bignum, ptr %156, i32 0, i32 1
  %158 = load i32, ptr %157, align 4, !tbaa !15
  %159 = load i32, ptr %20, align 4, !tbaa !9
  %160 = load i32, ptr %21, align 4, !tbaa !9
  %161 = sub nsw i32 %159, %160
  %162 = icmp slt i32 %158, %161
  br i1 %162, label %163, label %180

163:                                              ; preds = %148
  %164 = load i32, ptr %20, align 4, !tbaa !9
  %165 = load i32, ptr %21, align 4, !tbaa !9
  %166 = sub nsw i32 %164, %165
  %167 = load ptr, ptr %5, align 8, !tbaa !5
  %168 = getelementptr inbounds %struct.bignum, ptr %167, i32 0, i32 1
  store i32 %166, ptr %168, align 4, !tbaa !15
  %169 = load ptr, ptr %5, align 8, !tbaa !5
  %170 = getelementptr inbounds %struct.bignum, ptr %169, i32 0, i32 2
  %171 = load ptr, ptr %170, align 8, !tbaa !16
  %172 = load i32, ptr %20, align 4, !tbaa !9
  %173 = load i32, ptr %21, align 4, !tbaa !9
  %174 = sub nsw i32 %172, %173
  %175 = sext i32 %174 to i64
  %176 = mul i64 %175, 4
  %177 = call ptr @realloc(ptr noundef %171, i64 noundef %176) #4
  %178 = load ptr, ptr %5, align 8, !tbaa !5
  %179 = getelementptr inbounds %struct.bignum, ptr %178, i32 0, i32 2
  store ptr %177, ptr %179, align 8, !tbaa !16
  br label %180

180:                                              ; preds = %163, %148
  %181 = load ptr, ptr %7, align 8, !tbaa !5
  %182 = load ptr, ptr %10, align 8, !tbaa !5
  call void @bignum_copy(ptr noundef %181, ptr noundef %182)
  %183 = load ptr, ptr %8, align 8, !tbaa !5
  %184 = load ptr, ptr %9, align 8, !tbaa !5
  call void @bignum_copy(ptr noundef %183, ptr noundef %184)
  br label %185

185:                                              ; preds = %198, %180
  %186 = load ptr, ptr %9, align 8, !tbaa !5
  %187 = getelementptr inbounds %struct.bignum, ptr %186, i32 0, i32 2
  %188 = load ptr, ptr %187, align 8, !tbaa !16
  %189 = load ptr, ptr %9, align 8, !tbaa !5
  %190 = getelementptr inbounds %struct.bignum, ptr %189, i32 0, i32 0
  %191 = load i32, ptr %190, align 8, !tbaa !13
  %192 = sub nsw i32 %191, 1
  %193 = sext i32 %192 to i64
  %194 = getelementptr inbounds i32, ptr %188, i64 %193
  %195 = load i32, ptr %194, align 4, !tbaa !9
  %196 = zext i32 %195 to i64
  %197 = icmp ult i64 %196, 2147483648
  br i1 %197, label %198, label %202

198:                                              ; preds = %185
  %199 = load i64, ptr %16, align 8, !tbaa !11
  %200 = mul i64 %199, 2
  store i64 %200, ptr %16, align 8, !tbaa !11
  %201 = load ptr, ptr %9, align 8, !tbaa !5
  call void @bignum_imultiply(ptr noundef %201, ptr noundef getelementptr inbounds ([11 x %struct.bignum], ptr @NUMS, i64 0, i64 2))
  br label %185, !llvm.loop !19

202:                                              ; preds = %185
  %203 = load i64, ptr %16, align 8, !tbaa !11
  %204 = icmp ugt i64 %203, 1
  br i1 %204, label %205, label %211

205:                                              ; preds = %202
  %206 = load ptr, ptr %11, align 8, !tbaa !5
  %207 = load i64, ptr %16, align 8, !tbaa !11
  %208 = trunc i64 %207 to i32
  call void @bignum_fromint(ptr noundef %206, i32 noundef %208)
  %209 = load ptr, ptr %10, align 8, !tbaa !5
  %210 = load ptr, ptr %11, align 8, !tbaa !5
  call void @bignum_imultiply(ptr noundef %209, ptr noundef %210)
  br label %211

211:                                              ; preds = %205, %202
  %212 = load ptr, ptr %10, align 8, !tbaa !5
  %213 = getelementptr inbounds %struct.bignum, ptr %212, i32 0, i32 0
  %214 = load i32, ptr %213, align 8, !tbaa !13
  %215 = load i32, ptr %20, align 4, !tbaa !9
  %216 = icmp ne i32 %214, %215
  br i1 %216, label %217, label %254

217:                                              ; preds = %211
  %218 = load ptr, ptr %10, align 8, !tbaa !5
  %219 = getelementptr inbounds %struct.bignum, ptr %218, i32 0, i32 0
  %220 = load i32, ptr %219, align 8, !tbaa !13
  %221 = add nsw i32 %220, 1
  store i32 %221, ptr %219, align 8, !tbaa !13
  %222 = load ptr, ptr %10, align 8, !tbaa !5
  %223 = getelementptr inbounds %struct.bignum, ptr %222, i32 0, i32 0
  %224 = load i32, ptr %223, align 8, !tbaa !13
  %225 = load ptr, ptr %10, align 8, !tbaa !5
  %226 = getelementptr inbounds %struct.bignum, ptr %225, i32 0, i32 1
  %227 = load i32, ptr %226, align 4, !tbaa !15
  %228 = icmp sgt i32 %224, %227
  br i1 %228, label %229, label %246

229:                                              ; preds = %217
  %230 = load ptr, ptr %10, align 8, !tbaa !5
  %231 = getelementptr inbounds %struct.bignum, ptr %230, i32 0, i32 0
  %232 = load i32, ptr %231, align 8, !tbaa !13
  %233 = load ptr, ptr %10, align 8, !tbaa !5
  %234 = getelementptr inbounds %struct.bignum, ptr %233, i32 0, i32 1
  store i32 %232, ptr %234, align 4, !tbaa !15
  %235 = load ptr, ptr %10, align 8, !tbaa !5
  %236 = getelementptr inbounds %struct.bignum, ptr %235, i32 0, i32 2
  %237 = load ptr, ptr %236, align 8, !tbaa !16
  %238 = load ptr, ptr %10, align 8, !tbaa !5
  %239 = getelementptr inbounds %struct.bignum, ptr %238, i32 0, i32 1
  %240 = load i32, ptr %239, align 4, !tbaa !15
  %241 = sext i32 %240 to i64
  %242 = mul i64 %241, 4
  %243 = call ptr @realloc(ptr noundef %237, i64 noundef %242) #4
  %244 = load ptr, ptr %10, align 8, !tbaa !5
  %245 = getelementptr inbounds %struct.bignum, ptr %244, i32 0, i32 2
  store ptr %243, ptr %245, align 8, !tbaa !16
  br label %246

246:                                              ; preds = %229, %217
  %247 = load ptr, ptr %10, align 8, !tbaa !5
  %248 = getelementptr inbounds %struct.bignum, ptr %247, i32 0, i32 2
  %249 = load ptr, ptr %248, align 8, !tbaa !16
  %250 = load i32, ptr %20, align 4, !tbaa !9
  %251 = sub nsw i32 %250, 1
  %252 = sext i32 %251 to i64
  %253 = getelementptr inbounds i32, ptr %249, i64 %252
  store i32 0, ptr %253, align 4, !tbaa !9
  br label %254

254:                                              ; preds = %246, %211
  %255 = load i32, ptr %20, align 4, !tbaa !9
  %256 = load i32, ptr %21, align 4, !tbaa !9
  %257 = sub nsw i32 %255, %256
  %258 = sub nsw i32 %257, 1
  store i32 %258, ptr %22, align 4, !tbaa !9
  br label %259

259:                                              ; preds = %531, %254
  %260 = load i32, ptr %22, align 4, !tbaa !9
  %261 = icmp sge i32 %260, 0
  br i1 %261, label %262, label %534

262:                                              ; preds = %259
  %263 = load ptr, ptr %10, align 8, !tbaa !5
  %264 = getelementptr inbounds %struct.bignum, ptr %263, i32 0, i32 2
  %265 = load ptr, ptr %264, align 8, !tbaa !16
  %266 = load i32, ptr %22, align 4, !tbaa !9
  %267 = load i32, ptr %21, align 4, !tbaa !9
  %268 = add nsw i32 %266, %267
  %269 = sext i32 %268 to i64
  %270 = getelementptr inbounds i32, ptr %265, i64 %269
  %271 = load i32, ptr %270, align 4, !tbaa !9
  %272 = zext i32 %271 to i64
  %273 = mul i64 4294967296, %272
  %274 = load ptr, ptr %10, align 8, !tbaa !5
  %275 = getelementptr inbounds %struct.bignum, ptr %274, i32 0, i32 2
  %276 = load ptr, ptr %275, align 8, !tbaa !16
  %277 = load i32, ptr %22, align 4, !tbaa !9
  %278 = load i32, ptr %21, align 4, !tbaa !9
  %279 = add nsw i32 %277, %278
  %280 = sub nsw i32 %279, 1
  %281 = sext i32 %280 to i64
  %282 = getelementptr inbounds i32, ptr %276, i64 %281
  %283 = load i32, ptr %282, align 4, !tbaa !9
  %284 = zext i32 %283 to i64
  %285 = add i64 %273, %284
  store i64 %285, ptr %18, align 8, !tbaa !11
  %286 = load i64, ptr %18, align 8, !tbaa !11
  %287 = load ptr, ptr %9, align 8, !tbaa !5
  %288 = getelementptr inbounds %struct.bignum, ptr %287, i32 0, i32 2
  %289 = load ptr, ptr %288, align 8, !tbaa !16
  %290 = load i32, ptr %21, align 4, !tbaa !9
  %291 = sub nsw i32 %290, 1
  %292 = sext i32 %291 to i64
  %293 = getelementptr inbounds i32, ptr %289, i64 %292
  %294 = load i32, ptr %293, align 4, !tbaa !9
  %295 = zext i32 %294 to i64
  %296 = udiv i64 %286, %295
  store i64 %296, ptr %17, align 8, !tbaa !11
  %297 = load i64, ptr %17, align 8, !tbaa !11
  %298 = icmp uge i64 %297, 4294967296
  br i1 %298, label %299, label %300

299:                                              ; preds = %262
  store i64 4294967295, ptr %17, align 8, !tbaa !11
  br label %300

300:                                              ; preds = %299, %262
  %301 = load i64, ptr %18, align 8, !tbaa !11
  %302 = load ptr, ptr %9, align 8, !tbaa !5
  %303 = getelementptr inbounds %struct.bignum, ptr %302, i32 0, i32 2
  %304 = load ptr, ptr %303, align 8, !tbaa !16
  %305 = load i32, ptr %21, align 4, !tbaa !9
  %306 = sub nsw i32 %305, 1
  %307 = sext i32 %306 to i64
  %308 = getelementptr inbounds i32, ptr %304, i64 %307
  %309 = load i32, ptr %308, align 4, !tbaa !9
  %310 = zext i32 %309 to i64
  %311 = urem i64 %301, %310
  store i64 %311, ptr %19, align 8, !tbaa !11
  br label %312

312:                                              ; preds = %344, %300
  %313 = load i64, ptr %19, align 8, !tbaa !11
  %314 = icmp ult i64 %313, 4294967296
  br i1 %314, label %315, label %342

315:                                              ; preds = %312
  %316 = load i64, ptr %17, align 8, !tbaa !11
  %317 = load ptr, ptr %9, align 8, !tbaa !5
  %318 = getelementptr inbounds %struct.bignum, ptr %317, i32 0, i32 2
  %319 = load ptr, ptr %318, align 8, !tbaa !16
  %320 = load i32, ptr %21, align 4, !tbaa !9
  %321 = sub nsw i32 %320, 2
  %322 = sext i32 %321 to i64
  %323 = getelementptr inbounds i32, ptr %319, i64 %322
  %324 = load i32, ptr %323, align 4, !tbaa !9
  %325 = zext i32 %324 to i64
  %326 = mul i64 %316, %325
  %327 = load i64, ptr %19, align 8, !tbaa !11
  %328 = mul i64 4294967296, %327
  %329 = load ptr, ptr %10, align 8, !tbaa !5
  %330 = getelementptr inbounds %struct.bignum, ptr %329, i32 0, i32 2
  %331 = load ptr, ptr %330, align 8, !tbaa !16
  %332 = load i32, ptr %22, align 4, !tbaa !9
  %333 = load i32, ptr %21, align 4, !tbaa !9
  %334 = add nsw i32 %332, %333
  %335 = sub nsw i32 %334, 2
  %336 = sext i32 %335 to i64
  %337 = getelementptr inbounds i32, ptr %331, i64 %336
  %338 = load i32, ptr %337, align 4, !tbaa !9
  %339 = zext i32 %338 to i64
  %340 = add i64 %328, %339
  %341 = icmp ugt i64 %326, %340
  br label %342

342:                                              ; preds = %315, %312
  %343 = phi i1 [ false, %312 ], [ %341, %315 ]
  br i1 %343, label %344, label %358

344:                                              ; preds = %342
  %345 = load i64, ptr %17, align 8, !tbaa !11
  %346 = add i64 %345, -1
  store i64 %346, ptr %17, align 8, !tbaa !11
  %347 = load ptr, ptr %9, align 8, !tbaa !5
  %348 = getelementptr inbounds %struct.bignum, ptr %347, i32 0, i32 2
  %349 = load ptr, ptr %348, align 8, !tbaa !16
  %350 = load i32, ptr %21, align 4, !tbaa !9
  %351 = sub nsw i32 %350, 1
  %352 = sext i32 %351 to i64
  %353 = getelementptr inbounds i32, ptr %349, i64 %352
  %354 = load i32, ptr %353, align 4, !tbaa !9
  %355 = zext i32 %354 to i64
  %356 = load i64, ptr %19, align 8, !tbaa !11
  %357 = add i64 %356, %355
  store i64 %357, ptr %19, align 8, !tbaa !11
  br label %312, !llvm.loop !20

358:                                              ; preds = %342
  %359 = load i64, ptr %17, align 8, !tbaa !11
  %360 = urem i64 %359, 4294967296
  %361 = trunc i64 %360 to i32
  %362 = load ptr, ptr %14, align 8, !tbaa !5
  %363 = getelementptr inbounds %struct.bignum, ptr %362, i32 0, i32 2
  %364 = load ptr, ptr %363, align 8, !tbaa !16
  %365 = getelementptr inbounds i32, ptr %364, i64 0
  store i32 %361, ptr %365, align 4, !tbaa !9
  %366 = load i64, ptr %17, align 8, !tbaa !11
  %367 = udiv i64 %366, 4294967296
  %368 = trunc i64 %367 to i32
  %369 = load ptr, ptr %14, align 8, !tbaa !5
  %370 = getelementptr inbounds %struct.bignum, ptr %369, i32 0, i32 2
  %371 = load ptr, ptr %370, align 8, !tbaa !16
  %372 = getelementptr inbounds i32, ptr %371, i64 1
  store i32 %368, ptr %372, align 4, !tbaa !9
  %373 = load ptr, ptr %14, align 8, !tbaa !5
  %374 = getelementptr inbounds %struct.bignum, ptr %373, i32 0, i32 2
  %375 = load ptr, ptr %374, align 8, !tbaa !16
  %376 = getelementptr inbounds i32, ptr %375, i64 1
  %377 = load i32, ptr %376, align 4, !tbaa !9
  %378 = icmp ne i32 %377, 0
  br i1 %378, label %379, label %382

379:                                              ; preds = %358
  %380 = load ptr, ptr %14, align 8, !tbaa !5
  %381 = getelementptr inbounds %struct.bignum, ptr %380, i32 0, i32 0
  store i32 2, ptr %381, align 8, !tbaa !13
  br label %385

382:                                              ; preds = %358
  %383 = load ptr, ptr %14, align 8, !tbaa !5
  %384 = getelementptr inbounds %struct.bignum, ptr %383, i32 0, i32 0
  store i32 1, ptr %384, align 8, !tbaa !13
  br label %385

385:                                              ; preds = %382, %379
  %386 = load ptr, ptr %12, align 8, !tbaa !5
  %387 = load ptr, ptr %9, align 8, !tbaa !5
  %388 = load ptr, ptr %14, align 8, !tbaa !5
  call void @bignum_multiply(ptr noundef %386, ptr noundef %387, ptr noundef %388)
  %389 = load i32, ptr %21, align 4, !tbaa !9
  %390 = add nsw i32 %389, 1
  %391 = load ptr, ptr %13, align 8, !tbaa !5
  %392 = getelementptr inbounds %struct.bignum, ptr %391, i32 0, i32 1
  %393 = load i32, ptr %392, align 4, !tbaa !15
  %394 = icmp sgt i32 %390, %393
  br i1 %394, label %395, label %411

395:                                              ; preds = %385
  %396 = load i32, ptr %21, align 4, !tbaa !9
  %397 = add nsw i32 %396, 1
  %398 = load ptr, ptr %13, align 8, !tbaa !5
  %399 = getelementptr inbounds %struct.bignum, ptr %398, i32 0, i32 1
  store i32 %397, ptr %399, align 4, !tbaa !15
  %400 = load ptr, ptr %13, align 8, !tbaa !5
  %401 = getelementptr inbounds %struct.bignum, ptr %400, i32 0, i32 2
  %402 = load ptr, ptr %401, align 8, !tbaa !16
  %403 = load ptr, ptr %13, align 8, !tbaa !5
  %404 = getelementptr inbounds %struct.bignum, ptr %403, i32 0, i32 1
  %405 = load i32, ptr %404, align 4, !tbaa !15
  %406 = sext i32 %405 to i64
  %407 = mul i64 %406, 4
  %408 = call ptr @realloc(ptr noundef %402, i64 noundef %407) #4
  %409 = load ptr, ptr %13, align 8, !tbaa !5
  %410 = getelementptr inbounds %struct.bignum, ptr %409, i32 0, i32 2
  store ptr %408, ptr %410, align 8, !tbaa !16
  br label %411

411:                                              ; preds = %395, %385
  %412 = load ptr, ptr %13, align 8, !tbaa !5
  %413 = getelementptr inbounds %struct.bignum, ptr %412, i32 0, i32 0
  store i32 0, ptr %413, align 8, !tbaa !13
  store i32 0, ptr %23, align 4, !tbaa !9
  br label %414

414:                                              ; preds = %448, %411
  %415 = load i32, ptr %23, align 4, !tbaa !9
  %416 = load i32, ptr %21, align 4, !tbaa !9
  %417 = icmp sle i32 %415, %416
  br i1 %417, label %418, label %451

418:                                              ; preds = %414
  %419 = load ptr, ptr %10, align 8, !tbaa !5
  %420 = getelementptr inbounds %struct.bignum, ptr %419, i32 0, i32 2
  %421 = load ptr, ptr %420, align 8, !tbaa !16
  %422 = load i32, ptr %22, align 4, !tbaa !9
  %423 = load i32, ptr %23, align 4, !tbaa !9
  %424 = add nsw i32 %422, %423
  %425 = sext i32 %424 to i64
  %426 = getelementptr inbounds i32, ptr %421, i64 %425
  %427 = load i32, ptr %426, align 4, !tbaa !9
  %428 = load ptr, ptr %13, align 8, !tbaa !5
  %429 = getelementptr inbounds %struct.bignum, ptr %428, i32 0, i32 2
  %430 = load ptr, ptr %429, align 8, !tbaa !16
  %431 = load i32, ptr %23, align 4, !tbaa !9
  %432 = sext i32 %431 to i64
  %433 = getelementptr inbounds i32, ptr %430, i64 %432
  store i32 %427, ptr %433, align 4, !tbaa !9
  %434 = load ptr, ptr %13, align 8, !tbaa !5
  %435 = getelementptr inbounds %struct.bignum, ptr %434, i32 0, i32 2
  %436 = load ptr, ptr %435, align 8, !tbaa !16
  %437 = load i32, ptr %23, align 4, !tbaa !9
  %438 = sext i32 %437 to i64
  %439 = getelementptr inbounds i32, ptr %436, i64 %438
  %440 = load i32, ptr %439, align 4, !tbaa !9
  %441 = icmp ne i32 %440, 0
  br i1 %441, label %442, label %447

442:                                              ; preds = %418
  %443 = load i32, ptr %23, align 4, !tbaa !9
  %444 = add nsw i32 %443, 1
  %445 = load ptr, ptr %13, align 8, !tbaa !5
  %446 = getelementptr inbounds %struct.bignum, ptr %445, i32 0, i32 0
  store i32 %444, ptr %446, align 8, !tbaa !13
  br label %447

447:                                              ; preds = %442, %418
  br label %448

448:                                              ; preds = %447
  %449 = load i32, ptr %23, align 4, !tbaa !9
  %450 = add nsw i32 %449, 1
  store i32 %450, ptr %23, align 4, !tbaa !9
  br label %414, !llvm.loop !21

451:                                              ; preds = %414
  %452 = load ptr, ptr %13, align 8, !tbaa !5
  %453 = load ptr, ptr %12, align 8, !tbaa !5
  %454 = call i32 @bignum_isless(ptr noundef %452, ptr noundef %453)
  %455 = icmp ne i32 %454, 0
  br i1 %455, label %456, label %461

456:                                              ; preds = %451
  %457 = load ptr, ptr %13, align 8, !tbaa !5
  %458 = load ptr, ptr %9, align 8, !tbaa !5
  call void @bignum_iadd(ptr noundef %457, ptr noundef %458)
  %459 = load i64, ptr %17, align 8, !tbaa !11
  %460 = add i64 %459, -1
  store i64 %460, ptr %17, align 8, !tbaa !11
  br label %461

461:                                              ; preds = %456, %451
  %462 = load ptr, ptr %13, align 8, !tbaa !5
  %463 = load ptr, ptr %12, align 8, !tbaa !5
  call void @bignum_isubtract(ptr noundef %462, ptr noundef %463)
  store i32 0, ptr %23, align 4, !tbaa !9
  br label %464

464:                                              ; preds = %486, %461
  %465 = load i32, ptr %23, align 4, !tbaa !9
  %466 = load ptr, ptr %13, align 8, !tbaa !5
  %467 = getelementptr inbounds %struct.bignum, ptr %466, i32 0, i32 0
  %468 = load i32, ptr %467, align 8, !tbaa !13
  %469 = icmp slt i32 %465, %468
  br i1 %469, label %470, label %489

470:                                              ; preds = %464
  %471 = load ptr, ptr %13, align 8, !tbaa !5
  %472 = getelementptr inbounds %struct.bignum, ptr %471, i32 0, i32 2
  %473 = load ptr, ptr %472, align 8, !tbaa !16
  %474 = load i32, ptr %23, align 4, !tbaa !9
  %475 = sext i32 %474 to i64
  %476 = getelementptr inbounds i32, ptr %473, i64 %475
  %477 = load i32, ptr %476, align 4, !tbaa !9
  %478 = load ptr, ptr %10, align 8, !tbaa !5
  %479 = getelementptr inbounds %struct.bignum, ptr %478, i32 0, i32 2
  %480 = load ptr, ptr %479, align 8, !tbaa !16
  %481 = load i32, ptr %22, align 4, !tbaa !9
  %482 = load i32, ptr %23, align 4, !tbaa !9
  %483 = add nsw i32 %481, %482
  %484 = sext i32 %483 to i64
  %485 = getelementptr inbounds i32, ptr %480, i64 %484
  store i32 %477, ptr %485, align 4, !tbaa !9
  br label %486

486:                                              ; preds = %470
  %487 = load i32, ptr %23, align 4, !tbaa !9
  %488 = add nsw i32 %487, 1
  store i32 %488, ptr %23, align 4, !tbaa !9
  br label %464, !llvm.loop !22

489:                                              ; preds = %464
  %490 = load ptr, ptr %13, align 8, !tbaa !5
  %491 = getelementptr inbounds %struct.bignum, ptr %490, i32 0, i32 0
  %492 = load i32, ptr %491, align 8, !tbaa !13
  store i32 %492, ptr %23, align 4, !tbaa !9
  br label %493

493:                                              ; preds = %506, %489
  %494 = load i32, ptr %23, align 4, !tbaa !9
  %495 = load i32, ptr %21, align 4, !tbaa !9
  %496 = icmp sle i32 %494, %495
  br i1 %496, label %497, label %509

497:                                              ; preds = %493
  %498 = load ptr, ptr %10, align 8, !tbaa !5
  %499 = getelementptr inbounds %struct.bignum, ptr %498, i32 0, i32 2
  %500 = load ptr, ptr %499, align 8, !tbaa !16
  %501 = load i32, ptr %22, align 4, !tbaa !9
  %502 = load i32, ptr %23, align 4, !tbaa !9
  %503 = add nsw i32 %501, %502
  %504 = sext i32 %503 to i64
  %505 = getelementptr inbounds i32, ptr %500, i64 %504
  store i32 0, ptr %505, align 4, !tbaa !9
  br label %506

506:                                              ; preds = %497
  %507 = load i32, ptr %23, align 4, !tbaa !9
  %508 = add nsw i32 %507, 1
  store i32 %508, ptr %23, align 4, !tbaa !9
  br label %493, !llvm.loop !23

509:                                              ; preds = %493
  %510 = load i64, ptr %17, align 8, !tbaa !11
  %511 = trunc i64 %510 to i32
  %512 = load ptr, ptr %5, align 8, !tbaa !5
  %513 = getelementptr inbounds %struct.bignum, ptr %512, i32 0, i32 2
  %514 = load ptr, ptr %513, align 8, !tbaa !16
  %515 = load i32, ptr %22, align 4, !tbaa !9
  %516 = sext i32 %515 to i64
  %517 = getelementptr inbounds i32, ptr %514, i64 %516
  store i32 %511, ptr %517, align 4, !tbaa !9
  %518 = load ptr, ptr %5, align 8, !tbaa !5
  %519 = getelementptr inbounds %struct.bignum, ptr %518, i32 0, i32 2
  %520 = load ptr, ptr %519, align 8, !tbaa !16
  %521 = load i32, ptr %22, align 4, !tbaa !9
  %522 = sext i32 %521 to i64
  %523 = getelementptr inbounds i32, ptr %520, i64 %522
  %524 = load i32, ptr %523, align 4, !tbaa !9
  %525 = icmp ne i32 %524, 0
  br i1 %525, label %526, label %530

526:                                              ; preds = %509
  %527 = load i32, ptr %22, align 4, !tbaa !9
  %528 = load ptr, ptr %5, align 8, !tbaa !5
  %529 = getelementptr inbounds %struct.bignum, ptr %528, i32 0, i32 0
  store i32 %527, ptr %529, align 8, !tbaa !13
  br label %530

530:                                              ; preds = %526, %509
  br label %531

531:                                              ; preds = %530
  %532 = load i32, ptr %22, align 4, !tbaa !9
  %533 = add nsw i32 %532, -1
  store i32 %533, ptr %22, align 4, !tbaa !9
  br label %259, !llvm.loop !24

534:                                              ; preds = %259
  %535 = load ptr, ptr %5, align 8, !tbaa !5
  %536 = getelementptr inbounds %struct.bignum, ptr %535, i32 0, i32 2
  %537 = load ptr, ptr %536, align 8, !tbaa !16
  %538 = load ptr, ptr %7, align 8, !tbaa !5
  %539 = getelementptr inbounds %struct.bignum, ptr %538, i32 0, i32 0
  %540 = load i32, ptr %539, align 8, !tbaa !13
  %541 = load ptr, ptr %8, align 8, !tbaa !5
  %542 = getelementptr inbounds %struct.bignum, ptr %541, i32 0, i32 0
  %543 = load i32, ptr %542, align 8, !tbaa !13
  %544 = sub nsw i32 %540, %543
  %545 = sext i32 %544 to i64
  %546 = getelementptr inbounds i32, ptr %537, i64 %545
  %547 = load i32, ptr %546, align 4, !tbaa !9
  %548 = icmp eq i32 %547, 0
  br i1 %548, label %549, label %559

549:                                              ; preds = %534
  %550 = load ptr, ptr %7, align 8, !tbaa !5
  %551 = getelementptr inbounds %struct.bignum, ptr %550, i32 0, i32 0
  %552 = load i32, ptr %551, align 8, !tbaa !13
  %553 = load ptr, ptr %8, align 8, !tbaa !5
  %554 = getelementptr inbounds %struct.bignum, ptr %553, i32 0, i32 0
  %555 = load i32, ptr %554, align 8, !tbaa !13
  %556 = sub nsw i32 %552, %555
  %557 = load ptr, ptr %5, align 8, !tbaa !5
  %558 = getelementptr inbounds %struct.bignum, ptr %557, i32 0, i32 0
  store i32 %556, ptr %558, align 8, !tbaa !13
  br label %570

559:                                              ; preds = %534
  %560 = load ptr, ptr %7, align 8, !tbaa !5
  %561 = getelementptr inbounds %struct.bignum, ptr %560, i32 0, i32 0
  %562 = load i32, ptr %561, align 8, !tbaa !13
  %563 = load ptr, ptr %8, align 8, !tbaa !5
  %564 = getelementptr inbounds %struct.bignum, ptr %563, i32 0, i32 0
  %565 = load i32, ptr %564, align 8, !tbaa !13
  %566 = sub nsw i32 %562, %565
  %567 = add nsw i32 %566, 1
  %568 = load ptr, ptr %5, align 8, !tbaa !5
  %569 = getelementptr inbounds %struct.bignum, ptr %568, i32 0, i32 0
  store i32 %567, ptr %569, align 8, !tbaa !13
  br label %570

570:                                              ; preds = %559, %549
  store i32 0, ptr %15, align 4, !tbaa !9
  %571 = load ptr, ptr %10, align 8, !tbaa !5
  %572 = getelementptr inbounds %struct.bignum, ptr %571, i32 0, i32 0
  %573 = load i32, ptr %572, align 8, !tbaa !13
  %574 = sub nsw i32 %573, 1
  store i32 %574, ptr %22, align 4, !tbaa !9
  br label %575

575:                                              ; preds = %620, %570
  %576 = load i32, ptr %22, align 4, !tbaa !9
  %577 = icmp sge i32 %576, 0
  br i1 %577, label %578, label %623

578:                                              ; preds = %575
  %579 = load i32, ptr %15, align 4, !tbaa !9
  %580 = zext i32 %579 to i64
  %581 = mul i64 %580, 4294967296
  %582 = load ptr, ptr %10, align 8, !tbaa !5
  %583 = getelementptr inbounds %struct.bignum, ptr %582, i32 0, i32 2
  %584 = load ptr, ptr %583, align 8, !tbaa !16
  %585 = load i32, ptr %22, align 4, !tbaa !9
  %586 = sext i32 %585 to i64
  %587 = getelementptr inbounds i32, ptr %584, i64 %586
  %588 = load i32, ptr %587, align 4, !tbaa !9
  %589 = zext i32 %588 to i64
  %590 = add i64 %581, %589
  store i64 %590, ptr %18, align 8, !tbaa !11
  %591 = load i64, ptr %18, align 8, !tbaa !11
  %592 = load i64, ptr %16, align 8, !tbaa !11
  %593 = udiv i64 %591, %592
  %594 = trunc i64 %593 to i32
  %595 = load ptr, ptr %10, align 8, !tbaa !5
  %596 = getelementptr inbounds %struct.bignum, ptr %595, i32 0, i32 2
  %597 = load ptr, ptr %596, align 8, !tbaa !16
  %598 = load i32, ptr %22, align 4, !tbaa !9
  %599 = sext i32 %598 to i64
  %600 = getelementptr inbounds i32, ptr %597, i64 %599
  store i32 %594, ptr %600, align 4, !tbaa !9
  %601 = load ptr, ptr %10, align 8, !tbaa !5
  %602 = getelementptr inbounds %struct.bignum, ptr %601, i32 0, i32 2
  %603 = load ptr, ptr %602, align 8, !tbaa !16
  %604 = load i32, ptr %22, align 4, !tbaa !9
  %605 = sext i32 %604 to i64
  %606 = getelementptr inbounds i32, ptr %603, i64 %605
  %607 = load i32, ptr %606, align 4, !tbaa !9
  %608 = icmp ne i32 %607, 0
  br i1 %608, label %609, label %615

609:                                              ; preds = %578
  %610 = load i32, ptr %24, align 4, !tbaa !9
  %611 = icmp eq i32 %610, 0
  br i1 %611, label %612, label %615

612:                                              ; preds = %609
  %613 = load i32, ptr %22, align 4, !tbaa !9
  %614 = add nsw i32 %613, 1
  store i32 %614, ptr %24, align 4, !tbaa !9
  br label %615

615:                                              ; preds = %612, %609, %578
  %616 = load i64, ptr %18, align 8, !tbaa !11
  %617 = load i64, ptr %16, align 8, !tbaa !11
  %618 = urem i64 %616, %617
  %619 = trunc i64 %618 to i32
  store i32 %619, ptr %15, align 4, !tbaa !9
  br label %620

620:                                              ; preds = %615
  %621 = load i32, ptr %22, align 4, !tbaa !9
  %622 = add nsw i32 %621, -1
  store i32 %622, ptr %22, align 4, !tbaa !9
  br label %575, !llvm.loop !25

623:                                              ; preds = %575
  %624 = load i32, ptr %24, align 4, !tbaa !9
  %625 = load ptr, ptr %10, align 8, !tbaa !5
  %626 = getelementptr inbounds %struct.bignum, ptr %625, i32 0, i32 0
  store i32 %624, ptr %626, align 8, !tbaa !13
  %627 = load ptr, ptr %10, align 8, !tbaa !5
  %628 = load ptr, ptr %6, align 8, !tbaa !5
  call void @bignum_copy(ptr noundef %627, ptr noundef %628)
  br label %629

629:                                              ; preds = %623, %142
  br label %630

630:                                              ; preds = %629, %44
  br label %631

631:                                              ; preds = %630, %35
  %632 = load ptr, ptr %11, align 8, !tbaa !5
  call void @bignum_free(ptr noundef %632)
  %633 = load ptr, ptr %12, align 8, !tbaa !5
  call void @bignum_free(ptr noundef %633)
  %634 = load ptr, ptr %13, align 8, !tbaa !5
  call void @bignum_free(ptr noundef %634)
  %635 = load ptr, ptr %10, align 8, !tbaa !5
  call void @bignum_free(ptr noundef %635)
  %636 = load ptr, ptr %9, align 8, !tbaa !5
  call void @bignum_free(ptr noundef %636)
  %637 = load ptr, ptr %14, align 8, !tbaa !5
  call void @bignum_free(ptr noundef %637)
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %14) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #3
  ret void
}

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

attributes #0 = { 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 #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { nounwind allocsize(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 #3 = { nounwind }
attributes #4 = { nounwind allocsize(1) }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"int", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"long", !7, i64 0}
!13 = !{!14, !10, i64 0}
!14 = !{!"", !10, i64 0, !10, i64 4, !6, i64 8}
!15 = !{!14, !10, i64 4}
!16 = !{!14, !6, i64 8}
!17 = distinct !{!17, !18}
!18 = !{!"llvm.loop.mustprogress"}
!19 = distinct !{!19, !18}
!20 = distinct !{!20, !18}
!21 = distinct !{!21, !18}
!22 = distinct !{!22, !18}
!23 = distinct !{!23, !18}
!24 = distinct !{!24, !18}
!25 = distinct !{!25, !18}


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

@NUMS = external dso_local global [11 x %struct.bignum], align 16

; Function Attrs: nounwind uwtable
declare dso_local ptr @bignum_alloc() local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare dso_local void @bignum_free(ptr noundef) local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare dso_local i32 @bignum_iszero(ptr noundef) local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare dso_local i32 @bignum_isless(ptr noundef, ptr noundef) local_unnamed_addr #0

; Function Attrs: mustprogress nounwind willreturn allockind("realloc") allocsize(1) memory(argmem: readwrite, inaccessiblemem: readwrite)
declare noalias noundef ptr @realloc(ptr allocptr nocapture noundef, i64 noundef) local_unnamed_addr #1

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

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

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

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

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

; Function Attrs: nounwind uwtable
define dso_local void @bignum_divide(ptr nocapture noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3) local_unnamed_addr #0 {
  %5 = tail call ptr @bignum_alloc()
  %6 = tail call ptr @bignum_alloc()
  %7 = tail call ptr @bignum_alloc()
  %8 = tail call ptr @bignum_alloc()
  %9 = tail call ptr @bignum_alloc()
  %10 = tail call ptr @bignum_alloc()
  %11 = tail call i32 @bignum_isless(ptr noundef %2, ptr noundef %3)
  %.not = icmp eq i32 %11, 0
  br i1 %.not, label %13, label %12

12:                                               ; preds = %4
  store i32 0, ptr %0, align 8, !tbaa !5
  tail call void @bignum_copy(ptr noundef %2, ptr noundef %1)
  br label %273

13:                                               ; preds = %4
  %14 = tail call i32 @bignum_iszero(ptr noundef %2)
  %.not218 = icmp eq i32 %14, 0
  br i1 %.not218, label %16, label %15

15:                                               ; preds = %13
  store i32 0, ptr %0, align 8, !tbaa !5
  tail call void @bignum_fromint(ptr noundef %1, i32 noundef 0)
  br label %273

16:                                               ; preds = %13
  %17 = load i32, ptr %3, align 8, !tbaa !5
  %18 = icmp eq i32 %17, 1
  br i1 %18, label %19, label %59

19:                                               ; preds = %16
  %20 = getelementptr inbounds i8, ptr %0, i64 4
  %21 = load i32, ptr %20, align 4, !tbaa !11
  %22 = load i32, ptr %2, align 8, !tbaa !5
  %23 = icmp slt i32 %21, %22
  br i1 %23, label %24, label %30

24:                                               ; preds = %19
  store i32 %22, ptr %20, align 4, !tbaa !11
  %25 = getelementptr inbounds i8, ptr %0, i64 8
  %26 = load ptr, ptr %25, align 8, !tbaa !12
  %27 = sext i32 %22 to i64
  %28 = shl nsw i64 %27, 2
  %29 = tail call ptr @realloc(ptr noundef %26, i64 noundef %28) #4
  store ptr %29, ptr %25, align 8, !tbaa !12
  %.pre295 = load i32, ptr %2, align 8, !tbaa !5
  br label %30

30:                                               ; preds = %24, %19
  %31 = phi i32 [ %.pre295, %24 ], [ %22, %19 ]
  %32 = icmp sgt i32 %31, 0
  br i1 %32, label %.lr.ph268, label %._crit_edge269

.lr.ph268:                                        ; preds = %30
  %33 = getelementptr inbounds i8, ptr %2, i64 8
  %34 = load ptr, ptr %33, align 8, !tbaa !12
  %35 = getelementptr inbounds i8, ptr %3, i64 8
  %36 = load ptr, ptr %35, align 8, !tbaa !12
  %37 = getelementptr inbounds i8, ptr %0, i64 8
  %38 = load ptr, ptr %37, align 8, !tbaa !12
  %39 = zext nneg i32 %31 to i64
  %.pre296 = load i32, ptr %36, align 4, !tbaa !13
  br label %40

40:                                               ; preds = %.lr.ph268, %40
  %41 = phi i32 [ %.pre296, %.lr.ph268 ], [ %54, %40 ]
  %indvars.iv289 = phi i64 [ %39, %.lr.ph268 ], [ %indvars.iv.next290, %40 ]
  %.0266 = phi i32 [ 0, %.lr.ph268 ], [ %spec.select, %40 ]
  %.0205264 = phi i64 [ 0, %.lr.ph268 ], [ %56, %40 ]
  %indvars.iv.next290 = add nsw i64 %indvars.iv289, -1
  %42 = shl nuw i64 %.0205264, 32
  %43 = getelementptr inbounds i32, ptr %34, i64 %indvars.iv.next290
  %44 = load i32, ptr %43, align 4, !tbaa !13
  %45 = zext i32 %44 to i64
  %46 = or disjoint i64 %42, %45
  %47 = zext i32 %41 to i64
  %48 = udiv i64 %46, %47
  %49 = trunc i64 %48 to i32
  %50 = getelementptr inbounds i32, ptr %38, i64 %indvars.iv.next290
  store i32 %49, ptr %50, align 4, !tbaa !13
  %51 = icmp ne i32 %49, 0
  %52 = icmp eq i32 %.0266, 0
  %or.cond = select i1 %51, i1 %52, i1 false
  %53 = trunc nuw nsw i64 %indvars.iv289 to i32
  %spec.select = select i1 %or.cond, i32 %53, i32 %.0266
  %54 = load i32, ptr %36, align 4, !tbaa !13
  %55 = zext i32 %54 to i64
  %56 = urem i64 %46, %55
  %57 = icmp ugt i64 %indvars.iv289, 1
  br i1 %57, label %40, label %._crit_edge269.loopexit, !llvm.loop !14

._crit_edge269.loopexit:                          ; preds = %40
  %58 = trunc nuw i64 %56 to i32
  br label %._crit_edge269

._crit_edge269:                                   ; preds = %._crit_edge269.loopexit, %30
  %.0205.lcssa = phi i32 [ 0, %30 ], [ %58, %._crit_edge269.loopexit ]
  %.0.lcssa = phi i32 [ 0, %30 ], [ %spec.select, %._crit_edge269.loopexit ]
  tail call void @bignum_fromint(ptr noundef %1, i32 noundef %.0205.lcssa)
  store i32 %.0.lcssa, ptr %0, align 8, !tbaa !5
  br label %273

59:                                               ; preds = %16
  %60 = load i32, ptr %2, align 8, !tbaa !5
  %61 = add nsw i32 %60, 1
  %62 = getelementptr inbounds i8, ptr %0, i64 4
  %63 = load i32, ptr %62, align 4, !tbaa !11
  %64 = sub nsw i32 %61, %17
  %65 = icmp slt i32 %63, %64
  br i1 %65, label %66, label %72

66:                                               ; preds = %59
  store i32 %64, ptr %62, align 4, !tbaa !11
  %67 = getelementptr inbounds i8, ptr %0, i64 8
  %68 = load ptr, ptr %67, align 8, !tbaa !12
  %69 = sext i32 %64 to i64
  %70 = shl nsw i64 %69, 2
  %71 = tail call ptr @realloc(ptr noundef %68, i64 noundef %70) #4
  store ptr %71, ptr %67, align 8, !tbaa !12
  br label %72

72:                                               ; preds = %66, %59
  tail call void @bignum_copy(ptr noundef nonnull %2, ptr noundef %6)
  tail call void @bignum_copy(ptr noundef nonnull %3, ptr noundef %5)
  %73 = getelementptr inbounds i8, ptr %5, i64 8
  %74 = load ptr, ptr %73, align 8, !tbaa !12
  %75 = load i32, ptr %5, align 8, !tbaa !5
  %76 = sext i32 %75 to i64
  %77 = getelementptr i32, ptr %74, i64 %76
  %78 = getelementptr i8, ptr %77, i64 -4
  %79 = load i32, ptr %78, align 4, !tbaa !13
  %80 = icmp sgt i32 %79, -1
  br i1 %80, label %.lr.ph, label %._crit_edge.thread

.lr.ph:                                           ; preds = %72, %.lr.ph
  %.0207231 = phi i64 [ %81, %.lr.ph ], [ 1, %72 ]
  %81 = shl i64 %.0207231, 1
  tail call void @bignum_imultiply(ptr noundef nonnull %5, ptr noundef nonnull getelementptr inbounds (i8, ptr @NUMS, i64 32))
  %82 = load ptr, ptr %73, align 8, !tbaa !12
  %83 = load i32, ptr %5, align 8, !tbaa !5
  %84 = sext i32 %83 to i64
  %85 = getelementptr i32, ptr %82, i64 %84
  %86 = getelementptr i8, ptr %85, i64 -4
  %87 = load i32, ptr %86, align 4, !tbaa !13
  %88 = icmp sgt i32 %87, -1
  br i1 %88, label %.lr.ph, label %._crit_edge, !llvm.loop !16

._crit_edge:                                      ; preds = %.lr.ph
  %.not307 = icmp eq i64 %81, 0
  br i1 %.not307, label %._crit_edge.thread, label %89

89:                                               ; preds = %._crit_edge
  %90 = trunc i64 %81 to i32
  tail call void @bignum_fromint(ptr noundef %7, i32 noundef %90)
  tail call void @bignum_imultiply(ptr noundef %6, ptr noundef %7)
  br label %._crit_edge.thread

._crit_edge.thread:                               ; preds = %72, %89, %._crit_edge
  %.0207.lcssa300 = phi i64 [ %81, %89 ], [ %81, %._crit_edge ], [ 1, %72 ]
  %91 = load i32, ptr %6, align 8, !tbaa !5
  %.not219 = icmp eq i32 %91, %61
  br i1 %.not219, label %106, label %92

92:                                               ; preds = %._crit_edge.thread
  %93 = add nsw i32 %91, 1
  store i32 %93, ptr %6, align 8, !tbaa !5
  %94 = getelementptr inbounds i8, ptr %6, i64 4
  %95 = load i32, ptr %94, align 4, !tbaa !11
  %.not220 = icmp slt i32 %91, %95
  br i1 %.not220, label %._crit_edge292, label %96

._crit_edge292:                                   ; preds = %92
  %.phi.trans.insert = getelementptr inbounds i8, ptr %6, i64 8
  %.pre = load ptr, ptr %.phi.trans.insert, align 8, !tbaa !12
  br label %102

96:                                               ; preds = %92
  store i32 %93, ptr %94, align 4, !tbaa !11
  %97 = getelementptr inbounds i8, ptr %6, i64 8
  %98 = load ptr, ptr %97, align 8, !tbaa !12
  %99 = sext i32 %93 to i64
  %100 = shl nsw i64 %99, 2
  %101 = tail call ptr @realloc(ptr noundef %98, i64 noundef %100) #4
  store ptr %101, ptr %97, align 8, !tbaa !12
  br label %102

102:                                              ; preds = %._crit_edge292, %96
  %103 = phi ptr [ %.pre, %._crit_edge292 ], [ %101, %96 ]
  %104 = sext i32 %60 to i64
  %105 = getelementptr inbounds i32, ptr %103, i64 %104
  store i32 0, ptr %105, align 4, !tbaa !13
  br label %106

106:                                              ; preds = %102, %._crit_edge.thread
  %107 = icmp sgt i32 %64, 0
  br i1 %107, label %.lr.ph255, label %.._crit_edge256_crit_edge

.._crit_edge256_crit_edge:                        ; preds = %106
  %.phi.trans.insert293 = getelementptr inbounds i8, ptr %0, i64 8
  %.pre294 = load ptr, ptr %.phi.trans.insert293, align 8, !tbaa !12
  br label %._crit_edge256

.lr.ph255:                                        ; preds = %106
  %108 = getelementptr inbounds i8, ptr %6, i64 8
  %109 = sext i32 %17 to i64
  %110 = getelementptr inbounds i8, ptr %10, i64 8
  %111 = getelementptr inbounds i8, ptr %9, i64 4
  %112 = add i32 %17, 1
  %113 = getelementptr inbounds i8, ptr %9, i64 8
  %114 = sext i32 %112 to i64
  %115 = shl nsw i64 %114, 2
  %.not224239 = icmp slt i32 %17, 0
  %116 = getelementptr inbounds i8, ptr %0, i64 8
  %117 = zext nneg i32 %64 to i64
  %wide.trip.count = zext i32 %112 to i64
  %118 = shl nuw nsw i64 %wide.trip.count, 2
  %scevgep313 = getelementptr i8, ptr %9, i64 4
  %119 = add nuw nsw i64 %117, %wide.trip.count
  %120 = shl nuw nsw i64 %119, 2
  %121 = add nsw i64 %120, -4
  %min.iters.check = icmp ult i32 %112, 12
  %n.vec = and i64 %wide.trip.count, 4294967288
  %cmp.n = icmp eq i64 %n.vec, %wide.trip.count
  %xtraiter = and i64 %wide.trip.count, 1
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  %122 = add nsw i64 %wide.trip.count, -1
  br label %.lr.ph235

.lr.ph235:                                        ; preds = %244, %.lr.ph255
  %indvar314 = phi i64 [ %indvar.next315, %244 ], [ 0, %.lr.ph255 ]
  %indvars.iv282 = phi i64 [ %indvars.iv.next283, %244 ], [ %117, %.lr.ph255 ]
  %indvar = phi i32 [ %indvar.next, %244 ], [ 0, %.lr.ph255 ]
  %123 = shl i64 %indvar314, 2
  %124 = sub i64 %121, %123
  %125 = add i32 %17, %indvar
  %126 = sub i32 %60, %125
  %indvars.iv.next283 = add nsw i64 %indvars.iv282, -1
  %127 = load ptr, ptr %73, align 8, !tbaa !12
  %128 = getelementptr i32, ptr %127, i64 %109
  %129 = getelementptr i8, ptr %128, i64 -4
  %130 = load i32, ptr %129, align 4, !tbaa !13
  %131 = zext i32 %130 to i64
  %132 = load ptr, ptr %108, align 8, !tbaa !12
  %133 = getelementptr i32, ptr %132, i64 %indvars.iv.next283
  %134 = getelementptr i32, ptr %133, i64 %109
  %135 = load i32, ptr %134, align 4, !tbaa !13
  %136 = zext i32 %135 to i64
  %137 = shl nuw i64 %136, 32
  %138 = getelementptr i8, ptr %134, i64 -4
  %139 = load i32, ptr %138, align 4, !tbaa !13
  %140 = zext i32 %139 to i64
  %141 = or disjoint i64 %137, %140
  %142 = udiv i64 %141, %131
  %spec.store.select = tail call i64 @llvm.umin.i64(i64 %142, i64 4294967295)
  %143 = urem i64 %141, %131
  %144 = getelementptr i8, ptr %128, i64 -8
  %145 = load i32, ptr %144, align 4, !tbaa !13
  %146 = zext i32 %145 to i64
  %147 = getelementptr i8, ptr %134, i64 -8
  %148 = load i32, ptr %147, align 4, !tbaa !13
  %149 = zext i32 %148 to i64
  br label %150

150:                                              ; preds = %.lr.ph235, %155
  %.0208233 = phi i64 [ %143, %.lr.ph235 ], [ %157, %155 ]
  %.0209232 = phi i64 [ %spec.store.select, %.lr.ph235 ], [ %156, %155 ]
  %151 = mul i64 %.0209232, %146
  %152 = shl nuw i64 %.0208233, 32
  %153 = or disjoint i64 %152, %149
  %154 = icmp ugt i64 %151, %153
  br i1 %154, label %155, label %.critedge

155:                                              ; preds = %150
  %156 = add i64 %.0209232, -1
  %157 = add nuw nsw i64 %.0208233, %131
  %158 = icmp ult i64 %157, 4294967296
  br i1 %158, label %150, label %.critedge, !llvm.loop !17

.critedge:                                        ; preds = %150, %155
  %.0209.lcssa.ph = phi i64 [ %.0209232, %150 ], [ %156, %155 ]
  %159 = trunc i64 %.0209.lcssa.ph to i32
  %160 = load ptr, ptr %110, align 8, !tbaa !12
  store i32 %159, ptr %160, align 4, !tbaa !13
  %161 = lshr i64 %.0209.lcssa.ph, 32
  %162 = trunc nuw i64 %161 to i32
  %163 = getelementptr inbounds i8, ptr %160, i64 4
  store i32 %162, ptr %163, align 4, !tbaa !13
  %.not221 = icmp ult i64 %.0209.lcssa.ph, 4294967296
  %. = select i1 %.not221, i32 1, i32 2
  store i32 %., ptr %10, align 8, !tbaa !5
  tail call void @bignum_multiply(ptr noundef %8, ptr noundef nonnull %5, ptr noundef nonnull %10)
  %164 = load i32, ptr %111, align 4, !tbaa !11
  %.not223 = icmp slt i32 %17, %164
  br i1 %.not223, label %168, label %165

165:                                              ; preds = %.critedge
  store i32 %112, ptr %111, align 4, !tbaa !11
  %166 = load ptr, ptr %113, align 8, !tbaa !12
  %167 = tail call ptr @realloc(ptr noundef %166, i64 noundef %115) #4
  store ptr %167, ptr %113, align 8, !tbaa !12
  br label %168

168:                                              ; preds = %165, %.critedge
  store i32 0, ptr %9, align 8, !tbaa !5
  br i1 %.not224239, label %._crit_edge243, label %.lr.ph242

.lr.ph242:                                        ; preds = %168
  %169 = load ptr, ptr %108, align 8, !tbaa !12
  %170 = load ptr, ptr %113, align 8, !tbaa !12
  %invariant.gep = getelementptr i32, ptr %169, i64 %indvars.iv.next283
  br i1 %min.iters.check, label %scalar.ph.preheader, label %vector.memcheck

vector.memcheck:                                  ; preds = %.lr.ph242
  %scevgep312 = getelementptr i8, ptr %170, i64 %118
  %scevgep316 = getelementptr i8, ptr %169, i64 %124
  %bound0 = icmp ult ptr %170, %scevgep313
  %bound1 = icmp ult ptr %9, %scevgep312
  %found.conflict = and i1 %bound0, %bound1
  %bound0317 = icmp ult ptr %170, %scevgep316
  %bound1318 = icmp ult ptr %invariant.gep, %scevgep312
  %found.conflict319 = and i1 %bound0317, %bound1318
  %conflict.rdx = or i1 %found.conflict, %found.conflict319
  %bound0320 = icmp ult ptr %9, %scevgep316
  %bound1321 = icmp ult ptr %invariant.gep, %scevgep313
  %found.conflict322 = and i1 %bound0320, %bound1321
  %conflict.rdx323 = or i1 %conflict.rdx, %found.conflict322
  br i1 %conflict.rdx323, label %scalar.ph.preheader, label %vector.body

vector.body:                                      ; preds = %vector.memcheck, %pred.store.continue339
  %index = phi i64 [ %index.next, %pred.store.continue339 ], [ 0, %vector.memcheck ]
  %vec.ind = phi <4 x i64> [ %vec.ind.next, %pred.store.continue339 ], [ <i64 0, i64 1, i64 2, i64 3>, %vector.memcheck ]
  %171 = getelementptr i32, ptr %invariant.gep, i64 %index
  %172 = getelementptr i8, ptr %171, i64 16
  %wide.load = load <4 x i32>, ptr %171, align 4, !tbaa !13, !alias.scope !18
  %wide.load325 = load <4 x i32>, ptr %172, align 4, !tbaa !13, !alias.scope !18
  %173 = getelementptr inbounds i32, ptr %170, i64 %index
  %174 = getelementptr inbounds i8, ptr %173, i64 16
  store <4 x i32> %wide.load, ptr %173, align 4, !tbaa !13, !alias.scope !21, !noalias !23
  store <4 x i32> %wide.load325, ptr %174, align 4, !tbaa !13, !alias.scope !21, !noalias !23
  %175 = icmp ne <4 x i32> %wide.load, zeroinitializer
  %176 = icmp ne <4 x i32> %wide.load325, zeroinitializer
  %177 = add nuw nsw <4 x i64> %vec.ind, <i64 1, i64 1, i64 1, i64 1>
  %178 = add <4 x i64> %vec.ind, <i64 5, i64 5, i64 5, i64 5>
  %179 = extractelement <4 x i1> %175, i64 0
  br i1 %179, label %pred.store.if, label %pred.store.continue

pred.store.if:                                    ; preds = %vector.body
  %180 = bitcast <4 x i64> %177 to <8 x i32>
  %181 = extractelement <8 x i32> %180, i64 0
  store i32 %181, ptr %9, align 8, !tbaa !5, !alias.scope !25, !noalias !18
  br label %pred.store.continue

pred.store.continue:                              ; preds = %pred.store.if, %vector.body
  %182 = extractelement <4 x i1> %175, i64 1
  br i1 %182, label %pred.store.if326, label %pred.store.continue327

pred.store.if326:                                 ; preds = %pred.store.continue
  %183 = bitcast <4 x i64> %177 to <8 x i32>
  %184 = extractelement <8 x i32> %183, i64 2
  store i32 %184, ptr %9, align 8, !tbaa !5, !alias.scope !25, !noalias !18
  br label %pred.store.continue327

pred.store.continue327:                           ; preds = %pred.store.if326, %pred.store.continue
  %185 = extractelement <4 x i1> %175, i64 2
  br i1 %185, label %pred.store.if328, label %pred.store.continue329

pred.store.if328:                                 ; preds = %pred.store.continue327
  %186 = bitcast <4 x i64> %177 to <8 x i32>
  %187 = extractelement <8 x i32> %186, i64 4
  store i32 %187, ptr %9, align 8, !tbaa !5, !alias.scope !25, !noalias !18
  br label %pred.store.continue329

pred.store.continue329:                           ; preds = %pred.store.if328, %pred.store.continue327
  %188 = extractelement <4 x i1> %175, i64 3
  br i1 %188, label %pred.store.if330, label %pred.store.continue331

pred.store.if330:                                 ; preds = %pred.store.continue329
  %189 = bitcast <4 x i64> %177 to <8 x i32>
  %190 = extractelement <8 x i32> %189, i64 6
  store i32 %190, ptr %9, align 8, !tbaa !5, !alias.scope !25, !noalias !18
  br label %pred.store.continue331

pred.store.continue331:                           ; preds = %pred.store.if330, %pred.store.continue329
  %191 = extractelement <4 x i1> %176, i64 0
  br i1 %191, label %pred.store.if332, label %pred.store.continue333

pred.store.if332:                                 ; preds = %pred.store.continue331
  %192 = bitcast <4 x i64> %178 to <8 x i32>
  %193 = extractelement <8 x i32> %192, i64 0
  store i32 %193, ptr %9, align 8, !tbaa !5, !alias.scope !25, !noalias !18
  br label %pred.store.continue333

pred.store.continue333:                           ; preds = %pred.store.if332, %pred.store.continue331
  %194 = extractelement <4 x i1> %176, i64 1
  br i1 %194, label %pred.store.if334, label %pred.store.continue335

pred.store.if334:                                 ; preds = %pred.store.continue333
  %195 = bitcast <4 x i64> %178 to <8 x i32>
  %196 = extractelement <8 x i32> %195, i64 2
  store i32 %196, ptr %9, align 8, !tbaa !5, !alias.scope !25, !noalias !18
  br label %pred.store.continue335

pred.store.continue335:                           ; preds = %pred.store.if334, %pred.store.continue333
  %197 = extractelement <4 x i1> %176, i64 2
  br i1 %197, label %pred.store.if336, label %pred.store.continue337

pred.store.if336:                                 ; preds = %pred.store.continue335
  %198 = bitcast <4 x i64> %178 to <8 x i32>
  %199 = extractelement <8 x i32> %198, i64 4
  store i32 %199, ptr %9, align 8, !tbaa !5, !alias.scope !25, !noalias !18
  br label %pred.store.continue337

pred.store.continue337:                           ; preds = %pred.store.if336, %pred.store.continue335
  %200 = extractelement <4 x i1> %176, i64 3
  br i1 %200, label %pred.store.if338, label %pred.store.continue339

pred.store.if338:                                 ; preds = %pred.store.continue337
  %201 = bitcast <4 x i64> %178 to <8 x i32>
  %202 = extractelement <8 x i32> %201, i64 6
  store i32 %202, ptr %9, align 8, !tbaa !5, !alias.scope !25, !noalias !18
  br label %pred.store.continue339

pred.store.continue339:                           ; preds = %pred.store.if338, %pred.store.continue337
  %index.next = add nuw i64 %index, 8
  %vec.ind.next = add <4 x i64> %vec.ind, <i64 8, i64 8, i64 8, i64 8>
  %203 = icmp eq i64 %index.next, %n.vec
  br i1 %203, label %middle.block, label %vector.body, !llvm.loop !26

middle.block:                                     ; preds = %pred.store.continue339
  br i1 %cmp.n, label %._crit_edge243, label %scalar.ph.preheader

scalar.ph.preheader:                              ; preds = %middle.block, %vector.memcheck, %.lr.ph242
  %indvars.iv.ph = phi i64 [ 0, %vector.memcheck ], [ 0, %.lr.ph242 ], [ %n.vec, %middle.block ]
  br i1 %lcmp.mod.not, label %scalar.ph.prol.loopexit, label %scalar.ph.prol

scalar.ph.prol:                                   ; preds = %scalar.ph.preheader
  %gep.prol = getelementptr i32, ptr %invariant.gep, i64 %indvars.iv.ph
  %204 = load i32, ptr %gep.prol, align 4, !tbaa !13
  %205 = getelementptr inbounds i32, ptr %170, i64 %indvars.iv.ph
  store i32 %204, ptr %205, align 4, !tbaa !13
  %.not228.prol = icmp eq i32 %204, 0
  %.pre298.prol = or disjoint i64 %indvars.iv.ph, 1
  br i1 %.not228.prol, label %scalar.ph.prol.loopexit, label %206

206:                                              ; preds = %scalar.ph.prol
  %207 = trunc nuw nsw i64 %.pre298.prol to i32
  store i32 %207, ptr %9, align 8, !tbaa !5
  br label %scalar.ph.prol.loopexit

scalar.ph.prol.loopexit:                          ; preds = %scalar.ph.prol, %206, %scalar.ph.preheader
  %indvars.iv.unr = phi i64 [ %indvars.iv.ph, %scalar.ph.preheader ], [ %.pre298.prol, %206 ], [ %.pre298.prol, %scalar.ph.prol ]
  %208 = icmp eq i64 %indvars.iv.ph, %122
  br i1 %208, label %._crit_edge243, label %scalar.ph

scalar.ph:                                        ; preds = %scalar.ph.prol.loopexit, %._crit_edge297.1
  %indvars.iv = phi i64 [ %.pre298.1, %._crit_edge297.1 ], [ %indvars.iv.unr, %scalar.ph.prol.loopexit ]
  %gep = getelementptr i32, ptr %invariant.gep, i64 %indvars.iv
  %209 = load i32, ptr %gep, align 4, !tbaa !13
  %210 = getelementptr inbounds i32, ptr %170, i64 %indvars.iv
  store i32 %209, ptr %210, align 4, !tbaa !13
  %.not228 = icmp eq i32 %209, 0
  %.pre298 = add nuw nsw i64 %indvars.iv, 1
  br i1 %.not228, label %._crit_edge297, label %211

211:                                              ; preds = %scalar.ph
  %212 = trunc nsw i64 %.pre298 to i32
  store i32 %212, ptr %9, align 8, !tbaa !5
  br label %._crit_edge297

._crit_edge297:                                   ; preds = %scalar.ph, %211
  %gep.1 = getelementptr i32, ptr %invariant.gep, i64 %.pre298
  %213 = load i32, ptr %gep.1, align 4, !tbaa !13
  %214 = getelementptr inbounds i32, ptr %170, i64 %.pre298
  store i32 %213, ptr %214, align 4, !tbaa !13
  %.not228.1 = icmp eq i32 %213, 0
  %.pre298.1 = add nuw nsw i64 %indvars.iv, 2
  br i1 %.not228.1, label %._crit_edge297.1, label %215

215:                                              ; preds = %._crit_edge297
  %216 = trunc nsw i64 %.pre298.1 to i32
  store i32 %216, ptr %9, align 8, !tbaa !5
  br label %._crit_edge297.1

._crit_edge297.1:                                 ; preds = %215, %._crit_edge297
  %exitcond.not.1 = icmp eq i64 %.pre298.1, %wide.trip.count
  br i1 %exitcond.not.1, label %._crit_edge243, label %scalar.ph, !llvm.loop !29

._crit_edge243:                                   ; preds = %scalar.ph.prol.loopexit, %._crit_edge297.1, %middle.block, %168
  %217 = tail call i32 @bignum_isless(ptr noundef nonnull %9, ptr noundef %8)
  %.not225 = icmp eq i32 %217, 0
  br i1 %.not225, label %220, label %218

218:                                              ; preds = %._crit_edge243
  tail call void @bignum_iadd(ptr noundef nonnull %9, ptr noundef nonnull %5)
  %219 = add i64 %.0209.lcssa.ph, -1
  br label %220

220:                                              ; preds = %218, %._crit_edge243
  %.1210 = phi i64 [ %219, %218 ], [ %.0209.lcssa.ph, %._crit_edge243 ]
  tail call void @bignum_isubtract(ptr noundef nonnull %9, ptr noundef %8)
  %221 = load i32, ptr %9, align 8, !tbaa !5
  %222 = icmp sgt i32 %221, 0
  br i1 %222, label %.lr.ph246, label %.preheader

.lr.ph246:                                        ; preds = %220
  %223 = load ptr, ptr %113, align 8, !tbaa !12
  %224 = load ptr, ptr %108, align 8, !tbaa !12
  %invariant.gep305 = getelementptr i32, ptr %224, i64 %indvars.iv.next283
  br label %233

.preheader:                                       ; preds = %233, %220
  %.lcssa = phi i32 [ %221, %220 ], [ %236, %233 ]
  %.not226248 = icmp sgt i32 %.lcssa, %17
  br i1 %.not226248, label %._crit_edge251, label %.lr.ph250

.lr.ph250:                                        ; preds = %.preheader
  %225 = load ptr, ptr %108, align 8, !tbaa !12
  %226 = add i32 %.lcssa, %126
  %227 = sext i32 %226 to i64
  %228 = shl nsw i64 %227, 2
  %scevgep = getelementptr i8, ptr %225, i64 %228
  %229 = sub i32 %17, %.lcssa
  %230 = zext i32 %229 to i64
  %231 = shl nuw nsw i64 %230, 2
  %232 = add nuw nsw i64 %231, 4
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 4 dereferenceable(1) %scevgep, i8 0, i64 %232, i1 false), !tbaa !13
  br label %._crit_edge251

233:                                              ; preds = %.lr.ph246, %233
  %indvars.iv276 = phi i64 [ 0, %.lr.ph246 ], [ %indvars.iv.next277, %233 ]
  %234 = getelementptr inbounds i32, ptr %223, i64 %indvars.iv276
  %235 = load i32, ptr %234, align 4, !tbaa !13
  %gep306 = getelementptr i32, ptr %invariant.gep305, i64 %indvars.iv276
  store i32 %235, ptr %gep306, align 4, !tbaa !13
  %indvars.iv.next277 = add nuw nsw i64 %indvars.iv276, 1
  %236 = load i32, ptr %9, align 8, !tbaa !5
  %237 = sext i32 %236 to i64
  %238 = icmp slt i64 %indvars.iv.next277, %237
  br i1 %238, label %233, label %.preheader, !llvm.loop !30

._crit_edge251:                                   ; preds = %.lr.ph250, %.preheader
  %239 = trunc i64 %.1210 to i32
  %240 = load ptr, ptr %116, align 8, !tbaa !12
  %241 = getelementptr inbounds i32, ptr %240, i64 %indvars.iv.next283
  store i32 %239, ptr %241, align 4, !tbaa !13
  %.not227 = icmp eq i32 %239, 0
  br i1 %.not227, label %244, label %242

242:                                              ; preds = %._crit_edge251
  %243 = trunc nsw i64 %indvars.iv.next283 to i32
  store i32 %243, ptr %0, align 8, !tbaa !5
  br label %244

244:                                              ; preds = %._crit_edge251, %242
  %indvar.next = add nuw nsw i32 %indvar, 1
  %exitcond285.not = icmp eq i32 %indvar.next, %64
  %indvar.next315 = add i64 %indvar314, 1
  br i1 %exitcond285.not, label %._crit_edge256, label %.lr.ph235, !llvm.loop !31

._crit_edge256:                                   ; preds = %244, %.._crit_edge256_crit_edge
  %245 = phi ptr [ %.pre294, %.._crit_edge256_crit_edge ], [ %240, %244 ]
  %246 = load i32, ptr %2, align 8, !tbaa !5
  %247 = load i32, ptr %3, align 8, !tbaa !5
  %248 = sub nsw i32 %246, %247
  %249 = sext i32 %248 to i64
  %250 = getelementptr inbounds i32, ptr %245, i64 %249
  %251 = load i32, ptr %250, align 4, !tbaa !13
  %252 = icmp ne i32 %251, 0
  %253 = zext i1 %252 to i32
  %storemerge = add nsw i32 %248, %253
  store i32 %storemerge, ptr %0, align 8, !tbaa !5
  %254 = load i32, ptr %6, align 8, !tbaa !5
  %255 = icmp sgt i32 %254, 0
  br i1 %255, label %.lr.ph261, label %._crit_edge262

.lr.ph261:                                        ; preds = %._crit_edge256
  %256 = getelementptr inbounds i8, ptr %6, i64 8
  %257 = load ptr, ptr %256, align 8, !tbaa !12
  %258 = add i64 %.0207.lcssa300, -1
  %259 = zext nneg i32 %254 to i64
  br label %260

260:                                              ; preds = %.lr.ph261, %260
  %indvars.iv286 = phi i64 [ %259, %.lr.ph261 ], [ %indvars.iv.next287, %260 ]
  %.2259 = phi i32 [ 0, %.lr.ph261 ], [ %spec.select229, %260 ]
  %.1206257 = phi i64 [ 0, %.lr.ph261 ], [ %271, %260 ]
  %indvars.iv.next287 = add nsw i64 %indvars.iv286, -1
  %261 = shl i64 %.1206257, 32
  %262 = getelementptr inbounds i32, ptr %257, i64 %indvars.iv.next287
  %263 = load i32, ptr %262, align 4, !tbaa !13
  %264 = zext i32 %263 to i64
  %265 = or disjoint i64 %261, %264
  %266 = udiv i64 %265, %.0207.lcssa300
  %267 = trunc i64 %266 to i32
  store i32 %267, ptr %262, align 4, !tbaa !13
  %268 = icmp ne i32 %267, 0
  %269 = icmp eq i32 %.2259, 0
  %or.cond3 = select i1 %268, i1 %269, i1 false
  %270 = trunc nuw nsw i64 %indvars.iv286 to i32
  %spec.select229 = select i1 %or.cond3, i32 %270, i32 %.2259
  %271 = and i64 %265, %258
  %272 = icmp ugt i64 %indvars.iv286, 1
  br i1 %272, label %260, label %._crit_edge262, !llvm.loop !32

._crit_edge262:                                   ; preds = %260, %._crit_edge256
  %.2.lcssa = phi i32 [ 0, %._crit_edge256 ], [ %spec.select229, %260 ]
  store i32 %.2.lcssa, ptr %6, align 8, !tbaa !5
  tail call void @bignum_copy(ptr noundef nonnull %6, ptr noundef %1)
  br label %273

273:                                              ; preds = %15, %._crit_edge262, %._crit_edge269, %12
  tail call void @bignum_free(ptr noundef %7)
  tail call void @bignum_free(ptr noundef %8)
  tail call void @bignum_free(ptr noundef %9)
  tail call void @bignum_free(ptr noundef %6)
  tail call void @bignum_free(ptr noundef %5)
  tail call void @bignum_free(ptr noundef %10)
  ret void
}

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

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

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #3

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

!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 = !{!"", !7, i64 0, !7, i64 4, !10, i64 8}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"any pointer", !8, i64 0}
!11 = !{!6, !7, i64 4}
!12 = !{!6, !10, i64 8}
!13 = !{!7, !7, i64 0}
!14 = distinct !{!14, !15}
!15 = !{!"llvm.loop.mustprogress"}
!16 = distinct !{!16, !15}
!17 = distinct !{!17, !15}
!18 = !{!19}
!19 = distinct !{!19, !20}
!20 = distinct !{!20, !"LVerDomain"}
!21 = !{!22}
!22 = distinct !{!22, !20}
!23 = !{!24, !19}
!24 = distinct !{!24, !20}
!25 = !{!24}
!26 = distinct !{!26, !15, !27, !28}
!27 = !{!"llvm.loop.isvectorized", i32 1}
!28 = !{!"llvm.loop.unroll.runtime.disable"}
!29 = distinct !{!29, !15, !27}
!30 = distinct !{!30, !15}
!31 = distinct !{!31, !15}
!32 = distinct !{!32, !15}


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