; LLVM IR from cryspen/libcrux :: sys/hacl/c/src (Hacl_GenericField64)

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

@.str = external hidden unnamed_addr constant [70 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [86 x i8], align 1

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

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

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

; Function Attrs: noreturn nounwind
declare void @exit(i32 noundef) #2

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

; Function Attrs: nounwind uwtable
declare dso_local i32 @Hacl_GenericField64_field_get_len(ptr noundef) #4

declare void @Hacl_Bignum_Montgomery_bn_from_mont_u64(i32 noundef, ptr noundef, i64 noundef, ptr noundef, ptr noundef) #1

declare void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef, ptr noundef, i64 noundef, ptr noundef, ptr noundef, ptr noundef) #1

declare void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef, ptr noundef, i64 noundef, ptr noundef, ptr noundef) #1

; Function Attrs: nounwind uwtable
define dso_local void @Hacl_GenericField64_exp_consttime(ptr noundef %0, ptr noundef %1, i32 noundef %2, ptr noundef %3, ptr noundef %4) #4 {
  %6 = alloca ptr, align 8
  %7 = alloca ptr, align 8
  %8 = alloca i32, align 4
  %9 = alloca ptr, align 8
  %10 = alloca ptr, align 8
  %11 = alloca i32, align 4
  %12 = alloca %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, align 8
  %13 = alloca ptr, align 8
  %14 = alloca i64, align 8
  %15 = alloca ptr, align 8
  %16 = alloca i64, align 8
  %17 = alloca i64, align 8
  %18 = alloca ptr, align 8
  %19 = alloca ptr, align 8
  %20 = alloca i32, align 4
  %21 = alloca i32, align 4
  %22 = alloca i32, align 4
  %23 = alloca i32, align 4
  %24 = alloca i64, align 8
  %25 = alloca i64, align 8
  %26 = alloca i64, align 8
  %27 = alloca i32, align 4
  %28 = alloca i64, align 8
  %29 = alloca ptr, align 8
  %30 = alloca ptr, align 8
  %31 = alloca i64, align 8
  %32 = alloca i32, align 4
  %33 = alloca i64, align 8
  %34 = alloca i32, align 4
  %35 = alloca ptr, align 8
  %36 = alloca i64, align 8
  %37 = alloca i64, align 8
  %38 = alloca i64, align 8
  %39 = alloca ptr, align 8
  %40 = alloca ptr, align 8
  %41 = alloca ptr, align 8
  %42 = alloca ptr, align 8
  %43 = alloca i32, align 4
  %44 = alloca ptr, align 8
  %45 = alloca ptr, align 8
  %46 = alloca ptr, align 8
  %47 = alloca ptr, align 8
  %48 = alloca ptr, align 8
  %49 = alloca ptr, align 8
  %50 = alloca ptr, align 8
  %51 = alloca ptr, align 8
  %52 = alloca ptr, align 8
  %53 = alloca ptr, align 8
  %54 = alloca ptr, align 8
  %55 = alloca ptr, align 8
  %56 = alloca ptr, align 8
  %57 = alloca ptr, align 8
  %58 = alloca ptr, align 8
  %59 = alloca ptr, align 8
  %60 = alloca ptr, align 8
  %61 = alloca ptr, align 8
  %62 = alloca ptr, align 8
  %63 = alloca ptr, align 8
  %64 = alloca ptr, align 8
  %65 = alloca ptr, align 8
  %66 = alloca ptr, align 8
  %67 = alloca ptr, align 8
  %68 = alloca ptr, align 8
  %69 = alloca ptr, align 8
  %70 = alloca ptr, align 8
  %71 = alloca ptr, align 8
  %72 = alloca i32, align 4
  %73 = alloca i64, align 8
  %74 = alloca i32, align 4
  %75 = alloca i64, align 8
  %76 = alloca ptr, align 8
  %77 = alloca i32, align 4
  %78 = alloca ptr, align 8
  %79 = alloca i64, align 8
  %80 = alloca i64, align 8
  %81 = alloca ptr, align 8
  %82 = alloca i32, align 4
  %83 = alloca ptr, align 8
  %84 = alloca i64, align 8
  %85 = alloca i64, align 8
  %86 = alloca ptr, align 8
  %87 = alloca i32, align 4
  %88 = alloca ptr, align 8
  %89 = alloca i64, align 8
  %90 = alloca i64, align 8
  %91 = alloca ptr, align 8
  %92 = alloca i32, align 4
  %93 = alloca ptr, align 8
  %94 = alloca i64, align 8
  %95 = alloca i64, align 8
  %96 = alloca ptr, align 8
  %97 = alloca i32, align 4
  %98 = alloca ptr, align 8
  %99 = alloca i64, align 8
  %100 = alloca i64, align 8
  %101 = alloca ptr, align 8
  %102 = alloca i32, align 4
  %103 = alloca ptr, align 8
  %104 = alloca i64, align 8
  %105 = alloca i64, align 8
  %106 = alloca ptr, align 8
  %107 = alloca i32, align 4
  %108 = alloca ptr, align 8
  %109 = alloca i64, align 8
  %110 = alloca i64, align 8
  %111 = alloca ptr, align 8
  %112 = alloca i32, align 4
  %113 = alloca ptr, align 8
  %114 = alloca i64, align 8
  %115 = alloca i64, align 8
  %116 = alloca ptr, align 8
  %117 = alloca i32, align 4
  %118 = alloca ptr, align 8
  %119 = alloca i64, align 8
  %120 = alloca i64, align 8
  %121 = alloca ptr, align 8
  %122 = alloca i32, align 4
  %123 = alloca ptr, align 8
  %124 = alloca i64, align 8
  %125 = alloca i64, align 8
  %126 = alloca ptr, align 8
  %127 = alloca i32, align 4
  %128 = alloca ptr, align 8
  %129 = alloca i64, align 8
  %130 = alloca i64, align 8
  %131 = alloca ptr, align 8
  %132 = alloca i32, align 4
  %133 = alloca ptr, align 8
  %134 = alloca i64, align 8
  %135 = alloca i64, align 8
  %136 = alloca ptr, align 8
  %137 = alloca i32, align 4
  %138 = alloca ptr, align 8
  %139 = alloca i64, align 8
  %140 = alloca i64, align 8
  %141 = alloca ptr, align 8
  %142 = alloca i32, align 4
  %143 = alloca ptr, align 8
  %144 = alloca i64, align 8
  %145 = alloca i64, align 8
  %146 = alloca ptr, align 8
  %147 = alloca i32, align 4
  %148 = alloca ptr, align 8
  %149 = alloca i64, align 8
  %150 = alloca ptr, align 8
  %151 = alloca ptr, align 8
  %152 = alloca i64, align 8
  %153 = alloca i32, align 4
  %154 = alloca i32, align 4
  %155 = alloca ptr, align 8
  %156 = alloca ptr, align 8
  %157 = alloca ptr, align 8
  %158 = alloca ptr, align 8
  %159 = alloca i32, align 4
  %160 = alloca i64, align 8
  %161 = alloca i32, align 4
  %162 = alloca i64, align 8
  %163 = alloca ptr, align 8
  %164 = alloca i32, align 4
  %165 = alloca ptr, align 8
  %166 = alloca i64, align 8
  %167 = alloca i64, align 8
  %168 = alloca ptr, align 8
  %169 = alloca i32, align 4
  %170 = alloca ptr, align 8
  %171 = alloca i64, align 8
  %172 = alloca i64, align 8
  %173 = alloca ptr, align 8
  %174 = alloca i32, align 4
  %175 = alloca ptr, align 8
  %176 = alloca i64, align 8
  %177 = alloca i64, align 8
  %178 = alloca ptr, align 8
  %179 = alloca i32, align 4
  %180 = alloca ptr, align 8
  %181 = alloca i64, align 8
  %182 = alloca i64, align 8
  %183 = alloca ptr, align 8
  %184 = alloca i32, align 4
  %185 = alloca ptr, align 8
  %186 = alloca i64, align 8
  %187 = alloca i64, align 8
  %188 = alloca ptr, align 8
  %189 = alloca i32, align 4
  %190 = alloca ptr, align 8
  %191 = alloca i64, align 8
  %192 = alloca i64, align 8
  %193 = alloca ptr, align 8
  %194 = alloca i32, align 4
  %195 = alloca ptr, align 8
  %196 = alloca i64, align 8
  %197 = alloca i64, align 8
  %198 = alloca ptr, align 8
  %199 = alloca i32, align 4
  %200 = alloca ptr, align 8
  %201 = alloca i64, align 8
  %202 = alloca i64, align 8
  %203 = alloca ptr, align 8
  %204 = alloca i32, align 4
  %205 = alloca ptr, align 8
  %206 = alloca i64, align 8
  %207 = alloca i64, align 8
  %208 = alloca ptr, align 8
  %209 = alloca i32, align 4
  %210 = alloca ptr, align 8
  %211 = alloca i64, align 8
  %212 = alloca i64, align 8
  %213 = alloca ptr, align 8
  %214 = alloca i32, align 4
  %215 = alloca ptr, align 8
  %216 = alloca i64, align 8
  %217 = alloca i64, align 8
  %218 = alloca ptr, align 8
  %219 = alloca i32, align 4
  %220 = alloca ptr, align 8
  %221 = alloca i64, align 8
  %222 = alloca i64, align 8
  %223 = alloca ptr, align 8
  %224 = alloca i32, align 4
  %225 = alloca ptr, align 8
  %226 = alloca i64, align 8
  %227 = alloca i64, align 8
  %228 = alloca ptr, align 8
  %229 = alloca i32, align 4
  %230 = alloca ptr, align 8
  %231 = alloca i64, align 8
  %232 = alloca i64, align 8
  %233 = alloca ptr, align 8
  %234 = alloca i32, align 4
  %235 = alloca ptr, align 8
  %236 = alloca i64, align 8
  %237 = alloca ptr, align 8
  store ptr %0, ptr %6, align 8, !tbaa !5
  store ptr %1, ptr %7, align 8, !tbaa !5
  store i32 %2, ptr %8, align 4, !tbaa !9
  store ptr %3, ptr %9, align 8, !tbaa !5
  store ptr %4, ptr %10, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #9
  %238 = load ptr, ptr %6, align 8, !tbaa !5
  %239 = call i32 @Hacl_GenericField64_field_get_len(ptr noundef %238)
  store i32 %239, ptr %11, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 32, ptr %12) #9
  %240 = load ptr, ptr %6, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %12, ptr align 8 %240, i64 32, i1 false), !tbaa.struct !11
  br label %241

241:                                              ; preds = %5
  %242 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 0
  %243 = load i32, ptr %242, align 8, !tbaa !14
  %244 = zext i32 %243 to i64
  %245 = icmp ugt i64 %244, 2305843009213693951
  br i1 %245, label %246, label %248

246:                                              ; preds = %241
  %247 = call i32 (ptr, ...) @printf(ptr noundef @.str, ptr noundef @.str.1, i32 noundef 281)
  call void @exit(i32 noundef 253) #10
  unreachable

248:                                              ; preds = %241
  br label %249

249:                                              ; preds = %248
  br label %250

250:                                              ; preds = %249
  %251 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 0
  %252 = load i32, ptr %251, align 8, !tbaa !14
  %253 = zext i32 %252 to i64
  %254 = call ptr @llvm.stacksave.p0()
  store ptr %254, ptr %13, align 8
  %255 = alloca i64, i64 %253, align 16
  store i64 %253, ptr %14, align 8
  %256 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 0
  %257 = load i32, ptr %256, align 8, !tbaa !14
  %258 = zext i32 %257 to i64
  %259 = mul i64 %258, 8
  call void @llvm.memset.p0.i64(ptr align 16 %255, i8 0, i64 %259, i1 false)
  %260 = load ptr, ptr %7, align 8, !tbaa !5
  %261 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 0
  %262 = load i32, ptr %261, align 8, !tbaa !14
  %263 = zext i32 %262 to i64
  %264 = mul i64 %263, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %255, ptr align 8 %260, i64 %264, i1 false)
  %265 = load i32, ptr %8, align 4, !tbaa !9
  %266 = icmp ult i32 %265, 200
  br i1 %266, label %267, label %445

267:                                              ; preds = %250
  br label %268

268:                                              ; preds = %267
  %269 = load i32, ptr %11, align 4, !tbaa !9
  %270 = load i32, ptr %11, align 4, !tbaa !9
  %271 = add i32 %269, %270
  %272 = zext i32 %271 to i64
  %273 = icmp ugt i64 %272, 2305843009213693951
  br i1 %273, label %274, label %276

274:                                              ; preds = %268
  %275 = call i32 (ptr, ...) @printf(ptr noundef @.str, ptr noundef @.str.1, i32 noundef 287)
  call void @exit(i32 noundef 253) #10
  unreachable

276:                                              ; preds = %268
  br label %277

277:                                              ; preds = %276
  br label %278

278:                                              ; preds = %277
  %279 = load i32, ptr %11, align 4, !tbaa !9
  %280 = load i32, ptr %11, align 4, !tbaa !9
  %281 = add i32 %279, %280
  %282 = zext i32 %281 to i64
  %283 = call ptr @llvm.stacksave.p0()
  store ptr %283, ptr %15, align 8
  %284 = alloca i64, i64 %282, align 16
  store i64 %282, ptr %16, align 8
  %285 = load i32, ptr %11, align 4, !tbaa !9
  %286 = load i32, ptr %11, align 4, !tbaa !9
  %287 = add i32 %285, %286
  %288 = zext i32 %287 to i64
  %289 = mul i64 %288, 8
  call void @llvm.memset.p0.i64(ptr align 16 %284, i8 0, i64 %289, i1 false)
  %290 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 1
  %291 = load ptr, ptr %290, align 8, !tbaa !16
  %292 = load i32, ptr %11, align 4, !tbaa !9
  %293 = zext i32 %292 to i64
  %294 = mul i64 %293, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %284, ptr align 8 %291, i64 %294, i1 false)
  %295 = load i32, ptr %11, align 4, !tbaa !9
  %296 = zext i32 %295 to i64
  %297 = getelementptr inbounds i64, ptr %284, i64 %296
  %298 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 3
  %299 = load ptr, ptr %298, align 8, !tbaa !17
  %300 = load i32, ptr %11, align 4, !tbaa !9
  %301 = zext i32 %300 to i64
  %302 = mul i64 %301, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %297, ptr align 8 %299, i64 %302, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #9
  store i64 0, ptr %17, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #9
  store ptr %284, ptr %18, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #9
  %303 = load i32, ptr %11, align 4, !tbaa !9
  %304 = zext i32 %303 to i64
  %305 = getelementptr inbounds i64, ptr %284, i64 %304
  store ptr %305, ptr %19, align 8, !tbaa !5
  %306 = load i32, ptr %11, align 4, !tbaa !9
  %307 = load ptr, ptr %18, align 8, !tbaa !5
  %308 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %309 = load i64, ptr %308, align 8, !tbaa !18
  %310 = load ptr, ptr %19, align 8, !tbaa !5
  %311 = load ptr, ptr %10, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_from_mont_u64(i32 noundef %306, ptr noundef %307, i64 noundef %309, ptr noundef %310, ptr noundef %311)
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #9
  store i32 0, ptr %20, align 4, !tbaa !9
  br label %312

312:                                              ; preds = %396, %278
  %313 = load i32, ptr %20, align 4, !tbaa !9
  %314 = load i32, ptr %8, align 4, !tbaa !9
  %315 = icmp ult i32 %313, %314
  br i1 %315, label %317, label %316

316:                                              ; preds = %312
  store i32 6, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #9
  br label %399

317:                                              ; preds = %312
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #9
  %318 = load i32, ptr %8, align 4, !tbaa !9
  %319 = load i32, ptr %20, align 4, !tbaa !9
  %320 = sub i32 %318, %319
  %321 = sub i32 %320, 1
  %322 = udiv i32 %321, 64
  store i32 %322, ptr %22, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #9
  %323 = load i32, ptr %8, align 4, !tbaa !9
  %324 = load i32, ptr %20, align 4, !tbaa !9
  %325 = sub i32 %323, %324
  %326 = sub i32 %325, 1
  %327 = urem i32 %326, 64
  store i32 %327, ptr %23, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #9
  %328 = load ptr, ptr %9, align 8, !tbaa !5
  %329 = load i32, ptr %22, align 4, !tbaa !9
  %330 = zext i32 %329 to i64
  %331 = getelementptr inbounds i64, ptr %328, i64 %330
  %332 = load i64, ptr %331, align 8, !tbaa !12
  store i64 %332, ptr %24, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #9
  %333 = load i64, ptr %24, align 8, !tbaa !12
  %334 = load i32, ptr %23, align 4, !tbaa !9
  %335 = zext i32 %334 to i64
  %336 = lshr i64 %333, %335
  %337 = and i64 %336, 1
  store i64 %337, ptr %25, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #9
  %338 = load i64, ptr %25, align 8, !tbaa !12
  %339 = load i64, ptr %17, align 8, !tbaa !12
  %340 = xor i64 %338, %339
  store i64 %340, ptr %26, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #9
  store i32 0, ptr %27, align 4, !tbaa !9
  br label %341

341:                                              ; preds = %380, %317
  %342 = load i32, ptr %27, align 4, !tbaa !9
  %343 = load i32, ptr %11, align 4, !tbaa !9
  %344 = icmp ult i32 %342, %343
  br i1 %344, label %346, label %345

345:                                              ; preds = %341
  store i32 9, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #9
  br label %383

346:                                              ; preds = %341
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #9
  %347 = load i64, ptr %26, align 8, !tbaa !12
  %348 = sub i64 0, %347
  %349 = load ptr, ptr %10, align 8, !tbaa !5
  %350 = load i32, ptr %27, align 4, !tbaa !9
  %351 = zext i32 %350 to i64
  %352 = getelementptr inbounds i64, ptr %349, i64 %351
  %353 = load i64, ptr %352, align 8, !tbaa !12
  %354 = load i32, ptr %27, align 4, !tbaa !9
  %355 = zext i32 %354 to i64
  %356 = getelementptr inbounds i64, ptr %255, i64 %355
  %357 = load i64, ptr %356, align 8, !tbaa !12
  %358 = xor i64 %353, %357
  %359 = and i64 %348, %358
  store i64 %359, ptr %28, align 8, !tbaa !12
  %360 = load ptr, ptr %10, align 8, !tbaa !5
  %361 = load i32, ptr %27, align 4, !tbaa !9
  %362 = zext i32 %361 to i64
  %363 = getelementptr inbounds i64, ptr %360, i64 %362
  %364 = load i64, ptr %363, align 8, !tbaa !12
  %365 = load i64, ptr %28, align 8, !tbaa !12
  %366 = xor i64 %364, %365
  %367 = load ptr, ptr %10, align 8, !tbaa !5
  %368 = load i32, ptr %27, align 4, !tbaa !9
  %369 = zext i32 %368 to i64
  %370 = getelementptr inbounds i64, ptr %367, i64 %369
  store i64 %366, ptr %370, align 8, !tbaa !12
  %371 = load i32, ptr %27, align 4, !tbaa !9
  %372 = zext i32 %371 to i64
  %373 = getelementptr inbounds i64, ptr %255, i64 %372
  %374 = load i64, ptr %373, align 8, !tbaa !12
  %375 = load i64, ptr %28, align 8, !tbaa !12
  %376 = xor i64 %374, %375
  %377 = load i32, ptr %27, align 4, !tbaa !9
  %378 = zext i32 %377 to i64
  %379 = getelementptr inbounds i64, ptr %255, i64 %378
  store i64 %376, ptr %379, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #9
  br label %380

380:                                              ; preds = %346
  %381 = load i32, ptr %27, align 4, !tbaa !9
  %382 = add i32 %381, 1
  store i32 %382, ptr %27, align 4, !tbaa !9
  br label %341, !llvm.loop !19

383:                                              ; preds = %345
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #9
  store ptr %284, ptr %29, align 8, !tbaa !5
  %384 = load i32, ptr %11, align 4, !tbaa !9
  %385 = load ptr, ptr %29, align 8, !tbaa !5
  %386 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %387 = load i64, ptr %386, align 8, !tbaa !18
  %388 = load ptr, ptr %10, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %384, ptr noundef %385, i64 noundef %387, ptr noundef %255, ptr noundef %388, ptr noundef %255)
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #9
  store ptr %284, ptr %30, align 8, !tbaa !5
  %389 = load i32, ptr %11, align 4, !tbaa !9
  %390 = load ptr, ptr %30, align 8, !tbaa !5
  %391 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %392 = load i64, ptr %391, align 8, !tbaa !18
  %393 = load ptr, ptr %10, align 8, !tbaa !5
  %394 = load ptr, ptr %10, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %389, ptr noundef %390, i64 noundef %392, ptr noundef %393, ptr noundef %394)
  %395 = load i64, ptr %25, align 8, !tbaa !12
  store i64 %395, ptr %17, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #9
  br label %396

396:                                              ; preds = %383
  %397 = load i32, ptr %20, align 4, !tbaa !9
  %398 = add i32 %397, 1
  store i32 %398, ptr %20, align 4, !tbaa !9
  br label %312, !llvm.loop !21

399:                                              ; preds = %316
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #9
  %400 = load i64, ptr %17, align 8, !tbaa !12
  store i64 %400, ptr %31, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #9
  store i32 0, ptr %32, align 4, !tbaa !9
  br label %401

401:                                              ; preds = %440, %399
  %402 = load i32, ptr %32, align 4, !tbaa !9
  %403 = load i32, ptr %11, align 4, !tbaa !9
  %404 = icmp ult i32 %402, %403
  br i1 %404, label %406, label %405

405:                                              ; preds = %401
  store i32 12, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #9
  br label %443

406:                                              ; preds = %401
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #9
  %407 = load i64, ptr %31, align 8, !tbaa !12
  %408 = sub i64 0, %407
  %409 = load ptr, ptr %10, align 8, !tbaa !5
  %410 = load i32, ptr %32, align 4, !tbaa !9
  %411 = zext i32 %410 to i64
  %412 = getelementptr inbounds i64, ptr %409, i64 %411
  %413 = load i64, ptr %412, align 8, !tbaa !12
  %414 = load i32, ptr %32, align 4, !tbaa !9
  %415 = zext i32 %414 to i64
  %416 = getelementptr inbounds i64, ptr %255, i64 %415
  %417 = load i64, ptr %416, align 8, !tbaa !12
  %418 = xor i64 %413, %417
  %419 = and i64 %408, %418
  store i64 %419, ptr %33, align 8, !tbaa !12
  %420 = load ptr, ptr %10, align 8, !tbaa !5
  %421 = load i32, ptr %32, align 4, !tbaa !9
  %422 = zext i32 %421 to i64
  %423 = getelementptr inbounds i64, ptr %420, i64 %422
  %424 = load i64, ptr %423, align 8, !tbaa !12
  %425 = load i64, ptr %33, align 8, !tbaa !12
  %426 = xor i64 %424, %425
  %427 = load ptr, ptr %10, align 8, !tbaa !5
  %428 = load i32, ptr %32, align 4, !tbaa !9
  %429 = zext i32 %428 to i64
  %430 = getelementptr inbounds i64, ptr %427, i64 %429
  store i64 %426, ptr %430, align 8, !tbaa !12
  %431 = load i32, ptr %32, align 4, !tbaa !9
  %432 = zext i32 %431 to i64
  %433 = getelementptr inbounds i64, ptr %255, i64 %432
  %434 = load i64, ptr %433, align 8, !tbaa !12
  %435 = load i64, ptr %33, align 8, !tbaa !12
  %436 = xor i64 %434, %435
  %437 = load i32, ptr %32, align 4, !tbaa !9
  %438 = zext i32 %437 to i64
  %439 = getelementptr inbounds i64, ptr %255, i64 %438
  store i64 %436, ptr %439, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #9
  br label %440

440:                                              ; preds = %406
  %441 = load i32, ptr %32, align 4, !tbaa !9
  %442 = add i32 %441, 1
  store i32 %442, ptr %32, align 4, !tbaa !9
  br label %401, !llvm.loop !22

443:                                              ; preds = %405
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #9
  %444 = load ptr, ptr %15, align 8
  call void @llvm.stackrestore.p0(ptr %444)
  br label %2341

445:                                              ; preds = %250
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #9
  %446 = load i32, ptr %8, align 4, !tbaa !9
  %447 = icmp eq i32 %446, 0
  br i1 %447, label %448, label %449

448:                                              ; preds = %445
  store i32 1, ptr %34, align 4, !tbaa !9
  br label %454

449:                                              ; preds = %445
  %450 = load i32, ptr %8, align 4, !tbaa !9
  %451 = sub i32 %450, 1
  %452 = udiv i32 %451, 64
  %453 = add i32 %452, 1
  store i32 %453, ptr %34, align 4, !tbaa !9
  br label %454

454:                                              ; preds = %449, %448
  br label %455

455:                                              ; preds = %454
  %456 = load i32, ptr %11, align 4, !tbaa !9
  %457 = load i32, ptr %11, align 4, !tbaa !9
  %458 = add i32 %456, %457
  %459 = zext i32 %458 to i64
  %460 = icmp ugt i64 %459, 2305843009213693951
  br i1 %460, label %461, label %463

461:                                              ; preds = %455
  %462 = call i32 (ptr, ...) @printf(ptr noundef @.str, ptr noundef @.str.1, i32 noundef 334)
  call void @exit(i32 noundef 253) #10
  unreachable

463:                                              ; preds = %455
  br label %464

464:                                              ; preds = %463
  br label %465

465:                                              ; preds = %464
  %466 = load i32, ptr %11, align 4, !tbaa !9
  %467 = load i32, ptr %11, align 4, !tbaa !9
  %468 = add i32 %466, %467
  %469 = zext i32 %468 to i64
  %470 = call ptr @llvm.stacksave.p0()
  store ptr %470, ptr %35, align 8
  %471 = alloca i64, i64 %469, align 16
  store i64 %469, ptr %36, align 8
  %472 = load i32, ptr %11, align 4, !tbaa !9
  %473 = load i32, ptr %11, align 4, !tbaa !9
  %474 = add i32 %472, %473
  %475 = zext i32 %474 to i64
  %476 = mul i64 %475, 8
  call void @llvm.memset.p0.i64(ptr align 16 %471, i8 0, i64 %476, i1 false)
  %477 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 1
  %478 = load ptr, ptr %477, align 8, !tbaa !16
  %479 = load i32, ptr %11, align 4, !tbaa !9
  %480 = zext i32 %479 to i64
  %481 = mul i64 %480, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %471, ptr align 8 %478, i64 %481, i1 false)
  %482 = load i32, ptr %11, align 4, !tbaa !9
  %483 = zext i32 %482 to i64
  %484 = getelementptr inbounds i64, ptr %471, i64 %483
  %485 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 3
  %486 = load ptr, ptr %485, align 8, !tbaa !17
  %487 = load i32, ptr %11, align 4, !tbaa !9
  %488 = zext i32 %487 to i64
  %489 = mul i64 %488, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %484, ptr align 8 %486, i64 %489, i1 false)
  br label %490

490:                                              ; preds = %465
  %491 = load i32, ptr %11, align 4, !tbaa !9
  %492 = mul i32 16, %491
  %493 = zext i32 %492 to i64
  %494 = icmp ugt i64 %493, 2305843009213693951
  br i1 %494, label %495, label %497

495:                                              ; preds = %490
  %496 = call i32 (ptr, ...) @printf(ptr noundef @.str, ptr noundef @.str.1, i32 noundef 339)
  call void @exit(i32 noundef 253) #10
  unreachable

497:                                              ; preds = %490
  br label %498

498:                                              ; preds = %497
  br label %499

499:                                              ; preds = %498
  %500 = load i32, ptr %11, align 4, !tbaa !9
  %501 = mul i32 16, %500
  %502 = zext i32 %501 to i64
  %503 = alloca i64, i64 %502, align 16
  store i64 %502, ptr %37, align 8
  %504 = load i32, ptr %11, align 4, !tbaa !9
  %505 = mul i32 16, %504
  %506 = zext i32 %505 to i64
  %507 = mul i64 %506, 8
  call void @llvm.memset.p0.i64(ptr align 16 %503, i8 0, i64 %507, i1 false)
  br label %508

508:                                              ; preds = %499
  %509 = load i32, ptr %11, align 4, !tbaa !9
  %510 = zext i32 %509 to i64
  %511 = icmp ugt i64 %510, 2305843009213693951
  br i1 %511, label %512, label %514

512:                                              ; preds = %508
  %513 = call i32 (ptr, ...) @printf(ptr noundef @.str, ptr noundef @.str.1, i32 noundef 342)
  call void @exit(i32 noundef 253) #10
  unreachable

514:                                              ; preds = %508
  br label %515

515:                                              ; preds = %514
  br label %516

516:                                              ; preds = %515
  %517 = load i32, ptr %11, align 4, !tbaa !9
  %518 = zext i32 %517 to i64
  %519 = alloca i64, i64 %518, align 16
  store i64 %518, ptr %38, align 8
  %520 = load i32, ptr %11, align 4, !tbaa !9
  %521 = zext i32 %520 to i64
  %522 = mul i64 %521, 8
  call void @llvm.memset.p0.i64(ptr align 16 %519, i8 0, i64 %522, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #9
  store ptr %503, ptr %39, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #9
  %523 = load i32, ptr %11, align 4, !tbaa !9
  %524 = zext i32 %523 to i64
  %525 = getelementptr inbounds i64, ptr %503, i64 %524
  store ptr %525, ptr %40, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %41) #9
  store ptr %471, ptr %41, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %42) #9
  %526 = load i32, ptr %11, align 4, !tbaa !9
  %527 = zext i32 %526 to i64
  %528 = getelementptr inbounds i64, ptr %471, i64 %527
  store ptr %528, ptr %42, align 8, !tbaa !5
  %529 = load i32, ptr %11, align 4, !tbaa !9
  %530 = load ptr, ptr %41, align 8, !tbaa !5
  %531 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %532 = load i64, ptr %531, align 8, !tbaa !18
  %533 = load ptr, ptr %42, align 8, !tbaa !5
  %534 = load ptr, ptr %39, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_from_mont_u64(i32 noundef %529, ptr noundef %530, i64 noundef %532, ptr noundef %533, ptr noundef %534)
  %535 = load ptr, ptr %40, align 8, !tbaa !5
  %536 = load i32, ptr %11, align 4, !tbaa !9
  %537 = zext i32 %536 to i64
  %538 = mul i64 %537, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %535, ptr align 16 %255, i64 %538, i1 false)
  br label %539

539:                                              ; preds = %516
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #9
  store i32 0, ptr %43, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #9
  %540 = load i32, ptr %43, align 4, !tbaa !9
  %541 = add i32 %540, 1
  %542 = load i32, ptr %11, align 4, !tbaa !9
  %543 = mul i32 %541, %542
  %544 = zext i32 %543 to i64
  %545 = getelementptr inbounds i64, ptr %503, i64 %544
  store ptr %545, ptr %44, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #9
  store ptr %471, ptr %45, align 8, !tbaa !5
  %546 = load i32, ptr %11, align 4, !tbaa !9
  %547 = load ptr, ptr %45, align 8, !tbaa !5
  %548 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %549 = load i64, ptr %548, align 8, !tbaa !18
  %550 = load ptr, ptr %44, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %546, ptr noundef %547, i64 noundef %549, ptr noundef %550, ptr noundef %519)
  %551 = load i32, ptr %43, align 4, !tbaa !9
  %552 = mul i32 2, %551
  %553 = add i32 %552, 2
  %554 = load i32, ptr %11, align 4, !tbaa !9
  %555 = mul i32 %553, %554
  %556 = zext i32 %555 to i64
  %557 = getelementptr inbounds i64, ptr %503, i64 %556
  %558 = load i32, ptr %11, align 4, !tbaa !9
  %559 = zext i32 %558 to i64
  %560 = mul i64 %559, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %557, ptr align 16 %519, i64 %560, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #9
  %561 = load i32, ptr %43, align 4, !tbaa !9
  %562 = mul i32 2, %561
  %563 = add i32 %562, 2
  %564 = load i32, ptr %11, align 4, !tbaa !9
  %565 = mul i32 %563, %564
  %566 = zext i32 %565 to i64
  %567 = getelementptr inbounds i64, ptr %503, i64 %566
  store ptr %567, ptr %46, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #9
  store ptr %471, ptr %47, align 8, !tbaa !5
  %568 = load i32, ptr %11, align 4, !tbaa !9
  %569 = load ptr, ptr %47, align 8, !tbaa !5
  %570 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %571 = load i64, ptr %570, align 8, !tbaa !18
  %572 = load ptr, ptr %46, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %568, ptr noundef %569, i64 noundef %571, ptr noundef %255, ptr noundef %572, ptr noundef %519)
  %573 = load i32, ptr %43, align 4, !tbaa !9
  %574 = mul i32 2, %573
  %575 = add i32 %574, 3
  %576 = load i32, ptr %11, align 4, !tbaa !9
  %577 = mul i32 %575, %576
  %578 = zext i32 %577 to i64
  %579 = getelementptr inbounds i64, ptr %503, i64 %578
  %580 = load i32, ptr %11, align 4, !tbaa !9
  %581 = zext i32 %580 to i64
  %582 = mul i64 %581, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %579, ptr align 16 %519, i64 %582, i1 false)
  %583 = load i32, ptr %43, align 4, !tbaa !9
  %584 = add i32 %583, 1
  store i32 %584, ptr %43, align 4, !tbaa !9
  %585 = load i32, ptr %43, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %48) #9
  %586 = load i32, ptr %43, align 4, !tbaa !9
  %587 = add i32 %586, 1
  %588 = load i32, ptr %11, align 4, !tbaa !9
  %589 = mul i32 %587, %588
  %590 = zext i32 %589 to i64
  %591 = getelementptr inbounds i64, ptr %503, i64 %590
  store ptr %591, ptr %48, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %49) #9
  store ptr %471, ptr %49, align 8, !tbaa !5
  %592 = load i32, ptr %11, align 4, !tbaa !9
  %593 = load ptr, ptr %49, align 8, !tbaa !5
  %594 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %595 = load i64, ptr %594, align 8, !tbaa !18
  %596 = load ptr, ptr %48, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %592, ptr noundef %593, i64 noundef %595, ptr noundef %596, ptr noundef %519)
  %597 = load i32, ptr %43, align 4, !tbaa !9
  %598 = mul i32 2, %597
  %599 = add i32 %598, 2
  %600 = load i32, ptr %11, align 4, !tbaa !9
  %601 = mul i32 %599, %600
  %602 = zext i32 %601 to i64
  %603 = getelementptr inbounds i64, ptr %503, i64 %602
  %604 = load i32, ptr %11, align 4, !tbaa !9
  %605 = zext i32 %604 to i64
  %606 = mul i64 %605, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %603, ptr align 16 %519, i64 %606, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr %50) #9
  %607 = load i32, ptr %43, align 4, !tbaa !9
  %608 = mul i32 2, %607
  %609 = add i32 %608, 2
  %610 = load i32, ptr %11, align 4, !tbaa !9
  %611 = mul i32 %609, %610
  %612 = zext i32 %611 to i64
  %613 = getelementptr inbounds i64, ptr %503, i64 %612
  store ptr %613, ptr %50, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %51) #9
  store ptr %471, ptr %51, align 8, !tbaa !5
  %614 = load i32, ptr %11, align 4, !tbaa !9
  %615 = load ptr, ptr %51, align 8, !tbaa !5
  %616 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %617 = load i64, ptr %616, align 8, !tbaa !18
  %618 = load ptr, ptr %50, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %614, ptr noundef %615, i64 noundef %617, ptr noundef %255, ptr noundef %618, ptr noundef %519)
  %619 = load i32, ptr %43, align 4, !tbaa !9
  %620 = mul i32 2, %619
  %621 = add i32 %620, 3
  %622 = load i32, ptr %11, align 4, !tbaa !9
  %623 = mul i32 %621, %622
  %624 = zext i32 %623 to i64
  %625 = getelementptr inbounds i64, ptr %503, i64 %624
  %626 = load i32, ptr %11, align 4, !tbaa !9
  %627 = zext i32 %626 to i64
  %628 = mul i64 %627, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %625, ptr align 16 %519, i64 %628, i1 false)
  %629 = load i32, ptr %43, align 4, !tbaa !9
  %630 = add i32 %629, 1
  store i32 %630, ptr %43, align 4, !tbaa !9
  %631 = load i32, ptr %43, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %51) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %50) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %49) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %48) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %52) #9
  %632 = load i32, ptr %43, align 4, !tbaa !9
  %633 = add i32 %632, 1
  %634 = load i32, ptr %11, align 4, !tbaa !9
  %635 = mul i32 %633, %634
  %636 = zext i32 %635 to i64
  %637 = getelementptr inbounds i64, ptr %503, i64 %636
  store ptr %637, ptr %52, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %53) #9
  store ptr %471, ptr %53, align 8, !tbaa !5
  %638 = load i32, ptr %11, align 4, !tbaa !9
  %639 = load ptr, ptr %53, align 8, !tbaa !5
  %640 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %641 = load i64, ptr %640, align 8, !tbaa !18
  %642 = load ptr, ptr %52, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %638, ptr noundef %639, i64 noundef %641, ptr noundef %642, ptr noundef %519)
  %643 = load i32, ptr %43, align 4, !tbaa !9
  %644 = mul i32 2, %643
  %645 = add i32 %644, 2
  %646 = load i32, ptr %11, align 4, !tbaa !9
  %647 = mul i32 %645, %646
  %648 = zext i32 %647 to i64
  %649 = getelementptr inbounds i64, ptr %503, i64 %648
  %650 = load i32, ptr %11, align 4, !tbaa !9
  %651 = zext i32 %650 to i64
  %652 = mul i64 %651, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %649, ptr align 16 %519, i64 %652, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr %54) #9
  %653 = load i32, ptr %43, align 4, !tbaa !9
  %654 = mul i32 2, %653
  %655 = add i32 %654, 2
  %656 = load i32, ptr %11, align 4, !tbaa !9
  %657 = mul i32 %655, %656
  %658 = zext i32 %657 to i64
  %659 = getelementptr inbounds i64, ptr %503, i64 %658
  store ptr %659, ptr %54, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %55) #9
  store ptr %471, ptr %55, align 8, !tbaa !5
  %660 = load i32, ptr %11, align 4, !tbaa !9
  %661 = load ptr, ptr %55, align 8, !tbaa !5
  %662 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %663 = load i64, ptr %662, align 8, !tbaa !18
  %664 = load ptr, ptr %54, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %660, ptr noundef %661, i64 noundef %663, ptr noundef %255, ptr noundef %664, ptr noundef %519)
  %665 = load i32, ptr %43, align 4, !tbaa !9
  %666 = mul i32 2, %665
  %667 = add i32 %666, 3
  %668 = load i32, ptr %11, align 4, !tbaa !9
  %669 = mul i32 %667, %668
  %670 = zext i32 %669 to i64
  %671 = getelementptr inbounds i64, ptr %503, i64 %670
  %672 = load i32, ptr %11, align 4, !tbaa !9
  %673 = zext i32 %672 to i64
  %674 = mul i64 %673, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %671, ptr align 16 %519, i64 %674, i1 false)
  %675 = load i32, ptr %43, align 4, !tbaa !9
  %676 = add i32 %675, 1
  store i32 %676, ptr %43, align 4, !tbaa !9
  %677 = load i32, ptr %43, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %55) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %54) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %53) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %52) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %56) #9
  %678 = load i32, ptr %43, align 4, !tbaa !9
  %679 = add i32 %678, 1
  %680 = load i32, ptr %11, align 4, !tbaa !9
  %681 = mul i32 %679, %680
  %682 = zext i32 %681 to i64
  %683 = getelementptr inbounds i64, ptr %503, i64 %682
  store ptr %683, ptr %56, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %57) #9
  store ptr %471, ptr %57, align 8, !tbaa !5
  %684 = load i32, ptr %11, align 4, !tbaa !9
  %685 = load ptr, ptr %57, align 8, !tbaa !5
  %686 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %687 = load i64, ptr %686, align 8, !tbaa !18
  %688 = load ptr, ptr %56, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %684, ptr noundef %685, i64 noundef %687, ptr noundef %688, ptr noundef %519)
  %689 = load i32, ptr %43, align 4, !tbaa !9
  %690 = mul i32 2, %689
  %691 = add i32 %690, 2
  %692 = load i32, ptr %11, align 4, !tbaa !9
  %693 = mul i32 %691, %692
  %694 = zext i32 %693 to i64
  %695 = getelementptr inbounds i64, ptr %503, i64 %694
  %696 = load i32, ptr %11, align 4, !tbaa !9
  %697 = zext i32 %696 to i64
  %698 = mul i64 %697, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %695, ptr align 16 %519, i64 %698, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr %58) #9
  %699 = load i32, ptr %43, align 4, !tbaa !9
  %700 = mul i32 2, %699
  %701 = add i32 %700, 2
  %702 = load i32, ptr %11, align 4, !tbaa !9
  %703 = mul i32 %701, %702
  %704 = zext i32 %703 to i64
  %705 = getelementptr inbounds i64, ptr %503, i64 %704
  store ptr %705, ptr %58, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %59) #9
  store ptr %471, ptr %59, align 8, !tbaa !5
  %706 = load i32, ptr %11, align 4, !tbaa !9
  %707 = load ptr, ptr %59, align 8, !tbaa !5
  %708 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %709 = load i64, ptr %708, align 8, !tbaa !18
  %710 = load ptr, ptr %58, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %706, ptr noundef %707, i64 noundef %709, ptr noundef %255, ptr noundef %710, ptr noundef %519)
  %711 = load i32, ptr %43, align 4, !tbaa !9
  %712 = mul i32 2, %711
  %713 = add i32 %712, 3
  %714 = load i32, ptr %11, align 4, !tbaa !9
  %715 = mul i32 %713, %714
  %716 = zext i32 %715 to i64
  %717 = getelementptr inbounds i64, ptr %503, i64 %716
  %718 = load i32, ptr %11, align 4, !tbaa !9
  %719 = zext i32 %718 to i64
  %720 = mul i64 %719, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %717, ptr align 16 %519, i64 %720, i1 false)
  %721 = load i32, ptr %43, align 4, !tbaa !9
  %722 = add i32 %721, 1
  store i32 %722, ptr %43, align 4, !tbaa !9
  %723 = load i32, ptr %43, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %59) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %58) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %57) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %56) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %60) #9
  %724 = load i32, ptr %43, align 4, !tbaa !9
  %725 = add i32 %724, 1
  %726 = load i32, ptr %11, align 4, !tbaa !9
  %727 = mul i32 %725, %726
  %728 = zext i32 %727 to i64
  %729 = getelementptr inbounds i64, ptr %503, i64 %728
  store ptr %729, ptr %60, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %61) #9
  store ptr %471, ptr %61, align 8, !tbaa !5
  %730 = load i32, ptr %11, align 4, !tbaa !9
  %731 = load ptr, ptr %61, align 8, !tbaa !5
  %732 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %733 = load i64, ptr %732, align 8, !tbaa !18
  %734 = load ptr, ptr %60, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %730, ptr noundef %731, i64 noundef %733, ptr noundef %734, ptr noundef %519)
  %735 = load i32, ptr %43, align 4, !tbaa !9
  %736 = mul i32 2, %735
  %737 = add i32 %736, 2
  %738 = load i32, ptr %11, align 4, !tbaa !9
  %739 = mul i32 %737, %738
  %740 = zext i32 %739 to i64
  %741 = getelementptr inbounds i64, ptr %503, i64 %740
  %742 = load i32, ptr %11, align 4, !tbaa !9
  %743 = zext i32 %742 to i64
  %744 = mul i64 %743, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %741, ptr align 16 %519, i64 %744, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr %62) #9
  %745 = load i32, ptr %43, align 4, !tbaa !9
  %746 = mul i32 2, %745
  %747 = add i32 %746, 2
  %748 = load i32, ptr %11, align 4, !tbaa !9
  %749 = mul i32 %747, %748
  %750 = zext i32 %749 to i64
  %751 = getelementptr inbounds i64, ptr %503, i64 %750
  store ptr %751, ptr %62, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %63) #9
  store ptr %471, ptr %63, align 8, !tbaa !5
  %752 = load i32, ptr %11, align 4, !tbaa !9
  %753 = load ptr, ptr %63, align 8, !tbaa !5
  %754 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %755 = load i64, ptr %754, align 8, !tbaa !18
  %756 = load ptr, ptr %62, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %752, ptr noundef %753, i64 noundef %755, ptr noundef %255, ptr noundef %756, ptr noundef %519)
  %757 = load i32, ptr %43, align 4, !tbaa !9
  %758 = mul i32 2, %757
  %759 = add i32 %758, 3
  %760 = load i32, ptr %11, align 4, !tbaa !9
  %761 = mul i32 %759, %760
  %762 = zext i32 %761 to i64
  %763 = getelementptr inbounds i64, ptr %503, i64 %762
  %764 = load i32, ptr %11, align 4, !tbaa !9
  %765 = zext i32 %764 to i64
  %766 = mul i64 %765, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %763, ptr align 16 %519, i64 %766, i1 false)
  %767 = load i32, ptr %43, align 4, !tbaa !9
  %768 = add i32 %767, 1
  store i32 %768, ptr %43, align 4, !tbaa !9
  %769 = load i32, ptr %43, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %63) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %62) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %61) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %60) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %64) #9
  %770 = load i32, ptr %43, align 4, !tbaa !9
  %771 = add i32 %770, 1
  %772 = load i32, ptr %11, align 4, !tbaa !9
  %773 = mul i32 %771, %772
  %774 = zext i32 %773 to i64
  %775 = getelementptr inbounds i64, ptr %503, i64 %774
  store ptr %775, ptr %64, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %65) #9
  store ptr %471, ptr %65, align 8, !tbaa !5
  %776 = load i32, ptr %11, align 4, !tbaa !9
  %777 = load ptr, ptr %65, align 8, !tbaa !5
  %778 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %779 = load i64, ptr %778, align 8, !tbaa !18
  %780 = load ptr, ptr %64, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %776, ptr noundef %777, i64 noundef %779, ptr noundef %780, ptr noundef %519)
  %781 = load i32, ptr %43, align 4, !tbaa !9
  %782 = mul i32 2, %781
  %783 = add i32 %782, 2
  %784 = load i32, ptr %11, align 4, !tbaa !9
  %785 = mul i32 %783, %784
  %786 = zext i32 %785 to i64
  %787 = getelementptr inbounds i64, ptr %503, i64 %786
  %788 = load i32, ptr %11, align 4, !tbaa !9
  %789 = zext i32 %788 to i64
  %790 = mul i64 %789, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %787, ptr align 16 %519, i64 %790, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr %66) #9
  %791 = load i32, ptr %43, align 4, !tbaa !9
  %792 = mul i32 2, %791
  %793 = add i32 %792, 2
  %794 = load i32, ptr %11, align 4, !tbaa !9
  %795 = mul i32 %793, %794
  %796 = zext i32 %795 to i64
  %797 = getelementptr inbounds i64, ptr %503, i64 %796
  store ptr %797, ptr %66, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %67) #9
  store ptr %471, ptr %67, align 8, !tbaa !5
  %798 = load i32, ptr %11, align 4, !tbaa !9
  %799 = load ptr, ptr %67, align 8, !tbaa !5
  %800 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %801 = load i64, ptr %800, align 8, !tbaa !18
  %802 = load ptr, ptr %66, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %798, ptr noundef %799, i64 noundef %801, ptr noundef %255, ptr noundef %802, ptr noundef %519)
  %803 = load i32, ptr %43, align 4, !tbaa !9
  %804 = mul i32 2, %803
  %805 = add i32 %804, 3
  %806 = load i32, ptr %11, align 4, !tbaa !9
  %807 = mul i32 %805, %806
  %808 = zext i32 %807 to i64
  %809 = getelementptr inbounds i64, ptr %503, i64 %808
  %810 = load i32, ptr %11, align 4, !tbaa !9
  %811 = zext i32 %810 to i64
  %812 = mul i64 %811, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %809, ptr align 16 %519, i64 %812, i1 false)
  %813 = load i32, ptr %43, align 4, !tbaa !9
  %814 = add i32 %813, 1
  store i32 %814, ptr %43, align 4, !tbaa !9
  %815 = load i32, ptr %43, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %67) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %66) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %65) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %64) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %68) #9
  %816 = load i32, ptr %43, align 4, !tbaa !9
  %817 = add i32 %816, 1
  %818 = load i32, ptr %11, align 4, !tbaa !9
  %819 = mul i32 %817, %818
  %820 = zext i32 %819 to i64
  %821 = getelementptr inbounds i64, ptr %503, i64 %820
  store ptr %821, ptr %68, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %69) #9
  store ptr %471, ptr %69, align 8, !tbaa !5
  %822 = load i32, ptr %11, align 4, !tbaa !9
  %823 = load ptr, ptr %69, align 8, !tbaa !5
  %824 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %825 = load i64, ptr %824, align 8, !tbaa !18
  %826 = load ptr, ptr %68, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %822, ptr noundef %823, i64 noundef %825, ptr noundef %826, ptr noundef %519)
  %827 = load i32, ptr %43, align 4, !tbaa !9
  %828 = mul i32 2, %827
  %829 = add i32 %828, 2
  %830 = load i32, ptr %11, align 4, !tbaa !9
  %831 = mul i32 %829, %830
  %832 = zext i32 %831 to i64
  %833 = getelementptr inbounds i64, ptr %503, i64 %832
  %834 = load i32, ptr %11, align 4, !tbaa !9
  %835 = zext i32 %834 to i64
  %836 = mul i64 %835, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %833, ptr align 16 %519, i64 %836, i1 false)
  call void @llvm.lifetime.start.p0(i64 8, ptr %70) #9
  %837 = load i32, ptr %43, align 4, !tbaa !9
  %838 = mul i32 2, %837
  %839 = add i32 %838, 2
  %840 = load i32, ptr %11, align 4, !tbaa !9
  %841 = mul i32 %839, %840
  %842 = zext i32 %841 to i64
  %843 = getelementptr inbounds i64, ptr %503, i64 %842
  store ptr %843, ptr %70, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %71) #9
  store ptr %471, ptr %71, align 8, !tbaa !5
  %844 = load i32, ptr %11, align 4, !tbaa !9
  %845 = load ptr, ptr %71, align 8, !tbaa !5
  %846 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %847 = load i64, ptr %846, align 8, !tbaa !18
  %848 = load ptr, ptr %70, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %844, ptr noundef %845, i64 noundef %847, ptr noundef %255, ptr noundef %848, ptr noundef %519)
  %849 = load i32, ptr %43, align 4, !tbaa !9
  %850 = mul i32 2, %849
  %851 = add i32 %850, 3
  %852 = load i32, ptr %11, align 4, !tbaa !9
  %853 = mul i32 %851, %852
  %854 = zext i32 %853 to i64
  %855 = getelementptr inbounds i64, ptr %503, i64 %854
  %856 = load i32, ptr %11, align 4, !tbaa !9
  %857 = zext i32 %856 to i64
  %858 = mul i64 %857, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %855, ptr align 16 %519, i64 %858, i1 false)
  %859 = load i32, ptr %43, align 4, !tbaa !9
  %860 = add i32 %859, 1
  store i32 %860, ptr %43, align 4, !tbaa !9
  %861 = load i32, ptr %43, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %71) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %70) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %69) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %68) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #9
  br label %862

862:                                              ; preds = %539
  br label %863

863:                                              ; preds = %862
  %864 = load i32, ptr %8, align 4, !tbaa !9
  %865 = urem i32 %864, 4
  %866 = icmp ne i32 %865, 0
  br i1 %866, label %867, label %1576

867:                                              ; preds = %863
  call void @llvm.lifetime.start.p0(i64 4, ptr %72) #9
  %868 = load i32, ptr %8, align 4, !tbaa !9
  %869 = udiv i32 %868, 4
  %870 = mul i32 %869, 4
  store i32 %870, ptr %72, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %73) #9
  %871 = load i32, ptr %34, align 4, !tbaa !9
  %872 = load ptr, ptr %9, align 8, !tbaa !5
  %873 = load i32, ptr %72, align 4, !tbaa !9
  %874 = call i64 @Hacl_Bignum_Lib_bn_get_bits_u64(i32 noundef %871, ptr noundef %872, i32 noundef %873, i32 noundef 4)
  store i64 %874, ptr %73, align 8, !tbaa !12
  %875 = load ptr, ptr %10, align 8, !tbaa !5
  %876 = load i32, ptr %11, align 4, !tbaa !9
  %877 = mul i32 0, %876
  %878 = zext i32 %877 to i64
  %879 = getelementptr inbounds i64, ptr %503, i64 %878
  %880 = load i32, ptr %11, align 4, !tbaa !9
  %881 = zext i32 %880 to i64
  %882 = mul i64 %881, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %875, ptr align 8 %879, i64 %882, i1 false)
  br label %883

883:                                              ; preds = %867
  call void @llvm.lifetime.start.p0(i64 4, ptr %74) #9
  store i32 0, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %75) #9
  %884 = load i64, ptr %73, align 8, !tbaa !12
  %885 = load i32, ptr %74, align 4, !tbaa !9
  %886 = add i32 %885, 1
  %887 = zext i32 %886 to i64
  %888 = call i64 @FStar_UInt64_eq_mask(i64 noundef %884, i64 noundef %887)
  store i64 %888, ptr %75, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %76) #9
  %889 = load i32, ptr %74, align 4, !tbaa !9
  %890 = add i32 %889, 1
  %891 = load i32, ptr %11, align 4, !tbaa !9
  %892 = mul i32 %890, %891
  %893 = zext i32 %892 to i64
  %894 = getelementptr inbounds i64, ptr %503, i64 %893
  store ptr %894, ptr %76, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %77) #9
  store i32 0, ptr %77, align 4, !tbaa !9
  br label %895

895:                                              ; preds = %923, %883
  %896 = load i32, ptr %77, align 4, !tbaa !9
  %897 = load i32, ptr %11, align 4, !tbaa !9
  %898 = icmp ult i32 %896, %897
  br i1 %898, label %900, label %899

899:                                              ; preds = %895
  store i32 25, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %77) #9
  br label %926

900:                                              ; preds = %895
  call void @llvm.lifetime.start.p0(i64 8, ptr %78) #9
  %901 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %901, ptr %78, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %79) #9
  %902 = load i64, ptr %75, align 8, !tbaa !12
  %903 = load ptr, ptr %76, align 8, !tbaa !5
  %904 = load i32, ptr %77, align 4, !tbaa !9
  %905 = zext i32 %904 to i64
  %906 = getelementptr inbounds i64, ptr %903, i64 %905
  %907 = load i64, ptr %906, align 8, !tbaa !12
  %908 = and i64 %902, %907
  %909 = load i64, ptr %75, align 8, !tbaa !12
  %910 = xor i64 %909, -1
  %911 = load ptr, ptr %10, align 8, !tbaa !5
  %912 = load i32, ptr %77, align 4, !tbaa !9
  %913 = zext i32 %912 to i64
  %914 = getelementptr inbounds i64, ptr %911, i64 %913
  %915 = load i64, ptr %914, align 8, !tbaa !12
  %916 = and i64 %910, %915
  %917 = or i64 %908, %916
  store i64 %917, ptr %79, align 8, !tbaa !12
  %918 = load i64, ptr %79, align 8, !tbaa !12
  %919 = load ptr, ptr %78, align 8, !tbaa !5
  %920 = load i32, ptr %77, align 4, !tbaa !9
  %921 = zext i32 %920 to i64
  %922 = getelementptr inbounds i64, ptr %919, i64 %921
  store i64 %918, ptr %922, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %79) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %78) #9
  br label %923

923:                                              ; preds = %900
  %924 = load i32, ptr %77, align 4, !tbaa !9
  %925 = add i32 %924, 1
  store i32 %925, ptr %77, align 4, !tbaa !9
  br label %895, !llvm.loop !23

926:                                              ; preds = %899
  %927 = load i32, ptr %74, align 4, !tbaa !9
  %928 = add i32 %927, 1
  store i32 %928, ptr %74, align 4, !tbaa !9
  %929 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %76) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %75) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %80) #9
  %930 = load i64, ptr %73, align 8, !tbaa !12
  %931 = load i32, ptr %74, align 4, !tbaa !9
  %932 = add i32 %931, 1
  %933 = zext i32 %932 to i64
  %934 = call i64 @FStar_UInt64_eq_mask(i64 noundef %930, i64 noundef %933)
  store i64 %934, ptr %80, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %81) #9
  %935 = load i32, ptr %74, align 4, !tbaa !9
  %936 = add i32 %935, 1
  %937 = load i32, ptr %11, align 4, !tbaa !9
  %938 = mul i32 %936, %937
  %939 = zext i32 %938 to i64
  %940 = getelementptr inbounds i64, ptr %503, i64 %939
  store ptr %940, ptr %81, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %82) #9
  store i32 0, ptr %82, align 4, !tbaa !9
  br label %941

941:                                              ; preds = %969, %926
  %942 = load i32, ptr %82, align 4, !tbaa !9
  %943 = load i32, ptr %11, align 4, !tbaa !9
  %944 = icmp ult i32 %942, %943
  br i1 %944, label %946, label %945

945:                                              ; preds = %941
  store i32 28, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %82) #9
  br label %972

946:                                              ; preds = %941
  call void @llvm.lifetime.start.p0(i64 8, ptr %83) #9
  %947 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %947, ptr %83, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %84) #9
  %948 = load i64, ptr %80, align 8, !tbaa !12
  %949 = load ptr, ptr %81, align 8, !tbaa !5
  %950 = load i32, ptr %82, align 4, !tbaa !9
  %951 = zext i32 %950 to i64
  %952 = getelementptr inbounds i64, ptr %949, i64 %951
  %953 = load i64, ptr %952, align 8, !tbaa !12
  %954 = and i64 %948, %953
  %955 = load i64, ptr %80, align 8, !tbaa !12
  %956 = xor i64 %955, -1
  %957 = load ptr, ptr %10, align 8, !tbaa !5
  %958 = load i32, ptr %82, align 4, !tbaa !9
  %959 = zext i32 %958 to i64
  %960 = getelementptr inbounds i64, ptr %957, i64 %959
  %961 = load i64, ptr %960, align 8, !tbaa !12
  %962 = and i64 %956, %961
  %963 = or i64 %954, %962
  store i64 %963, ptr %84, align 8, !tbaa !12
  %964 = load i64, ptr %84, align 8, !tbaa !12
  %965 = load ptr, ptr %83, align 8, !tbaa !5
  %966 = load i32, ptr %82, align 4, !tbaa !9
  %967 = zext i32 %966 to i64
  %968 = getelementptr inbounds i64, ptr %965, i64 %967
  store i64 %964, ptr %968, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %84) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %83) #9
  br label %969

969:                                              ; preds = %946
  %970 = load i32, ptr %82, align 4, !tbaa !9
  %971 = add i32 %970, 1
  store i32 %971, ptr %82, align 4, !tbaa !9
  br label %941, !llvm.loop !24

972:                                              ; preds = %945
  %973 = load i32, ptr %74, align 4, !tbaa !9
  %974 = add i32 %973, 1
  store i32 %974, ptr %74, align 4, !tbaa !9
  %975 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %81) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %80) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %85) #9
  %976 = load i64, ptr %73, align 8, !tbaa !12
  %977 = load i32, ptr %74, align 4, !tbaa !9
  %978 = add i32 %977, 1
  %979 = zext i32 %978 to i64
  %980 = call i64 @FStar_UInt64_eq_mask(i64 noundef %976, i64 noundef %979)
  store i64 %980, ptr %85, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %86) #9
  %981 = load i32, ptr %74, align 4, !tbaa !9
  %982 = add i32 %981, 1
  %983 = load i32, ptr %11, align 4, !tbaa !9
  %984 = mul i32 %982, %983
  %985 = zext i32 %984 to i64
  %986 = getelementptr inbounds i64, ptr %503, i64 %985
  store ptr %986, ptr %86, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %87) #9
  store i32 0, ptr %87, align 4, !tbaa !9
  br label %987

987:                                              ; preds = %1015, %972
  %988 = load i32, ptr %87, align 4, !tbaa !9
  %989 = load i32, ptr %11, align 4, !tbaa !9
  %990 = icmp ult i32 %988, %989
  br i1 %990, label %992, label %991

991:                                              ; preds = %987
  store i32 31, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %87) #9
  br label %1018

992:                                              ; preds = %987
  call void @llvm.lifetime.start.p0(i64 8, ptr %88) #9
  %993 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %993, ptr %88, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %89) #9
  %994 = load i64, ptr %85, align 8, !tbaa !12
  %995 = load ptr, ptr %86, align 8, !tbaa !5
  %996 = load i32, ptr %87, align 4, !tbaa !9
  %997 = zext i32 %996 to i64
  %998 = getelementptr inbounds i64, ptr %995, i64 %997
  %999 = load i64, ptr %998, align 8, !tbaa !12
  %1000 = and i64 %994, %999
  %1001 = load i64, ptr %85, align 8, !tbaa !12
  %1002 = xor i64 %1001, -1
  %1003 = load ptr, ptr %10, align 8, !tbaa !5
  %1004 = load i32, ptr %87, align 4, !tbaa !9
  %1005 = zext i32 %1004 to i64
  %1006 = getelementptr inbounds i64, ptr %1003, i64 %1005
  %1007 = load i64, ptr %1006, align 8, !tbaa !12
  %1008 = and i64 %1002, %1007
  %1009 = or i64 %1000, %1008
  store i64 %1009, ptr %89, align 8, !tbaa !12
  %1010 = load i64, ptr %89, align 8, !tbaa !12
  %1011 = load ptr, ptr %88, align 8, !tbaa !5
  %1012 = load i32, ptr %87, align 4, !tbaa !9
  %1013 = zext i32 %1012 to i64
  %1014 = getelementptr inbounds i64, ptr %1011, i64 %1013
  store i64 %1010, ptr %1014, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %89) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %88) #9
  br label %1015

1015:                                             ; preds = %992
  %1016 = load i32, ptr %87, align 4, !tbaa !9
  %1017 = add i32 %1016, 1
  store i32 %1017, ptr %87, align 4, !tbaa !9
  br label %987, !llvm.loop !25

1018:                                             ; preds = %991
  %1019 = load i32, ptr %74, align 4, !tbaa !9
  %1020 = add i32 %1019, 1
  store i32 %1020, ptr %74, align 4, !tbaa !9
  %1021 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %86) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %85) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %90) #9
  %1022 = load i64, ptr %73, align 8, !tbaa !12
  %1023 = load i32, ptr %74, align 4, !tbaa !9
  %1024 = add i32 %1023, 1
  %1025 = zext i32 %1024 to i64
  %1026 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1022, i64 noundef %1025)
  store i64 %1026, ptr %90, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %91) #9
  %1027 = load i32, ptr %74, align 4, !tbaa !9
  %1028 = add i32 %1027, 1
  %1029 = load i32, ptr %11, align 4, !tbaa !9
  %1030 = mul i32 %1028, %1029
  %1031 = zext i32 %1030 to i64
  %1032 = getelementptr inbounds i64, ptr %503, i64 %1031
  store ptr %1032, ptr %91, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %92) #9
  store i32 0, ptr %92, align 4, !tbaa !9
  br label %1033

1033:                                             ; preds = %1061, %1018
  %1034 = load i32, ptr %92, align 4, !tbaa !9
  %1035 = load i32, ptr %11, align 4, !tbaa !9
  %1036 = icmp ult i32 %1034, %1035
  br i1 %1036, label %1038, label %1037

1037:                                             ; preds = %1033
  store i32 34, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %92) #9
  br label %1064

1038:                                             ; preds = %1033
  call void @llvm.lifetime.start.p0(i64 8, ptr %93) #9
  %1039 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %1039, ptr %93, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %94) #9
  %1040 = load i64, ptr %90, align 8, !tbaa !12
  %1041 = load ptr, ptr %91, align 8, !tbaa !5
  %1042 = load i32, ptr %92, align 4, !tbaa !9
  %1043 = zext i32 %1042 to i64
  %1044 = getelementptr inbounds i64, ptr %1041, i64 %1043
  %1045 = load i64, ptr %1044, align 8, !tbaa !12
  %1046 = and i64 %1040, %1045
  %1047 = load i64, ptr %90, align 8, !tbaa !12
  %1048 = xor i64 %1047, -1
  %1049 = load ptr, ptr %10, align 8, !tbaa !5
  %1050 = load i32, ptr %92, align 4, !tbaa !9
  %1051 = zext i32 %1050 to i64
  %1052 = getelementptr inbounds i64, ptr %1049, i64 %1051
  %1053 = load i64, ptr %1052, align 8, !tbaa !12
  %1054 = and i64 %1048, %1053
  %1055 = or i64 %1046, %1054
  store i64 %1055, ptr %94, align 8, !tbaa !12
  %1056 = load i64, ptr %94, align 8, !tbaa !12
  %1057 = load ptr, ptr %93, align 8, !tbaa !5
  %1058 = load i32, ptr %92, align 4, !tbaa !9
  %1059 = zext i32 %1058 to i64
  %1060 = getelementptr inbounds i64, ptr %1057, i64 %1059
  store i64 %1056, ptr %1060, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %94) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %93) #9
  br label %1061

1061:                                             ; preds = %1038
  %1062 = load i32, ptr %92, align 4, !tbaa !9
  %1063 = add i32 %1062, 1
  store i32 %1063, ptr %92, align 4, !tbaa !9
  br label %1033, !llvm.loop !26

1064:                                             ; preds = %1037
  %1065 = load i32, ptr %74, align 4, !tbaa !9
  %1066 = add i32 %1065, 1
  store i32 %1066, ptr %74, align 4, !tbaa !9
  %1067 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %91) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %90) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %95) #9
  %1068 = load i64, ptr %73, align 8, !tbaa !12
  %1069 = load i32, ptr %74, align 4, !tbaa !9
  %1070 = add i32 %1069, 1
  %1071 = zext i32 %1070 to i64
  %1072 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1068, i64 noundef %1071)
  store i64 %1072, ptr %95, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %96) #9
  %1073 = load i32, ptr %74, align 4, !tbaa !9
  %1074 = add i32 %1073, 1
  %1075 = load i32, ptr %11, align 4, !tbaa !9
  %1076 = mul i32 %1074, %1075
  %1077 = zext i32 %1076 to i64
  %1078 = getelementptr inbounds i64, ptr %503, i64 %1077
  store ptr %1078, ptr %96, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %97) #9
  store i32 0, ptr %97, align 4, !tbaa !9
  br label %1079

1079:                                             ; preds = %1107, %1064
  %1080 = load i32, ptr %97, align 4, !tbaa !9
  %1081 = load i32, ptr %11, align 4, !tbaa !9
  %1082 = icmp ult i32 %1080, %1081
  br i1 %1082, label %1084, label %1083

1083:                                             ; preds = %1079
  store i32 37, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %97) #9
  br label %1110

1084:                                             ; preds = %1079
  call void @llvm.lifetime.start.p0(i64 8, ptr %98) #9
  %1085 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %1085, ptr %98, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %99) #9
  %1086 = load i64, ptr %95, align 8, !tbaa !12
  %1087 = load ptr, ptr %96, align 8, !tbaa !5
  %1088 = load i32, ptr %97, align 4, !tbaa !9
  %1089 = zext i32 %1088 to i64
  %1090 = getelementptr inbounds i64, ptr %1087, i64 %1089
  %1091 = load i64, ptr %1090, align 8, !tbaa !12
  %1092 = and i64 %1086, %1091
  %1093 = load i64, ptr %95, align 8, !tbaa !12
  %1094 = xor i64 %1093, -1
  %1095 = load ptr, ptr %10, align 8, !tbaa !5
  %1096 = load i32, ptr %97, align 4, !tbaa !9
  %1097 = zext i32 %1096 to i64
  %1098 = getelementptr inbounds i64, ptr %1095, i64 %1097
  %1099 = load i64, ptr %1098, align 8, !tbaa !12
  %1100 = and i64 %1094, %1099
  %1101 = or i64 %1092, %1100
  store i64 %1101, ptr %99, align 8, !tbaa !12
  %1102 = load i64, ptr %99, align 8, !tbaa !12
  %1103 = load ptr, ptr %98, align 8, !tbaa !5
  %1104 = load i32, ptr %97, align 4, !tbaa !9
  %1105 = zext i32 %1104 to i64
  %1106 = getelementptr inbounds i64, ptr %1103, i64 %1105
  store i64 %1102, ptr %1106, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %99) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %98) #9
  br label %1107

1107:                                             ; preds = %1084
  %1108 = load i32, ptr %97, align 4, !tbaa !9
  %1109 = add i32 %1108, 1
  store i32 %1109, ptr %97, align 4, !tbaa !9
  br label %1079, !llvm.loop !27

1110:                                             ; preds = %1083
  %1111 = load i32, ptr %74, align 4, !tbaa !9
  %1112 = add i32 %1111, 1
  store i32 %1112, ptr %74, align 4, !tbaa !9
  %1113 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %96) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %95) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %100) #9
  %1114 = load i64, ptr %73, align 8, !tbaa !12
  %1115 = load i32, ptr %74, align 4, !tbaa !9
  %1116 = add i32 %1115, 1
  %1117 = zext i32 %1116 to i64
  %1118 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1114, i64 noundef %1117)
  store i64 %1118, ptr %100, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %101) #9
  %1119 = load i32, ptr %74, align 4, !tbaa !9
  %1120 = add i32 %1119, 1
  %1121 = load i32, ptr %11, align 4, !tbaa !9
  %1122 = mul i32 %1120, %1121
  %1123 = zext i32 %1122 to i64
  %1124 = getelementptr inbounds i64, ptr %503, i64 %1123
  store ptr %1124, ptr %101, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %102) #9
  store i32 0, ptr %102, align 4, !tbaa !9
  br label %1125

1125:                                             ; preds = %1153, %1110
  %1126 = load i32, ptr %102, align 4, !tbaa !9
  %1127 = load i32, ptr %11, align 4, !tbaa !9
  %1128 = icmp ult i32 %1126, %1127
  br i1 %1128, label %1130, label %1129

1129:                                             ; preds = %1125
  store i32 40, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %102) #9
  br label %1156

1130:                                             ; preds = %1125
  call void @llvm.lifetime.start.p0(i64 8, ptr %103) #9
  %1131 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %1131, ptr %103, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %104) #9
  %1132 = load i64, ptr %100, align 8, !tbaa !12
  %1133 = load ptr, ptr %101, align 8, !tbaa !5
  %1134 = load i32, ptr %102, align 4, !tbaa !9
  %1135 = zext i32 %1134 to i64
  %1136 = getelementptr inbounds i64, ptr %1133, i64 %1135
  %1137 = load i64, ptr %1136, align 8, !tbaa !12
  %1138 = and i64 %1132, %1137
  %1139 = load i64, ptr %100, align 8, !tbaa !12
  %1140 = xor i64 %1139, -1
  %1141 = load ptr, ptr %10, align 8, !tbaa !5
  %1142 = load i32, ptr %102, align 4, !tbaa !9
  %1143 = zext i32 %1142 to i64
  %1144 = getelementptr inbounds i64, ptr %1141, i64 %1143
  %1145 = load i64, ptr %1144, align 8, !tbaa !12
  %1146 = and i64 %1140, %1145
  %1147 = or i64 %1138, %1146
  store i64 %1147, ptr %104, align 8, !tbaa !12
  %1148 = load i64, ptr %104, align 8, !tbaa !12
  %1149 = load ptr, ptr %103, align 8, !tbaa !5
  %1150 = load i32, ptr %102, align 4, !tbaa !9
  %1151 = zext i32 %1150 to i64
  %1152 = getelementptr inbounds i64, ptr %1149, i64 %1151
  store i64 %1148, ptr %1152, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %104) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %103) #9
  br label %1153

1153:                                             ; preds = %1130
  %1154 = load i32, ptr %102, align 4, !tbaa !9
  %1155 = add i32 %1154, 1
  store i32 %1155, ptr %102, align 4, !tbaa !9
  br label %1125, !llvm.loop !28

1156:                                             ; preds = %1129
  %1157 = load i32, ptr %74, align 4, !tbaa !9
  %1158 = add i32 %1157, 1
  store i32 %1158, ptr %74, align 4, !tbaa !9
  %1159 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %101) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %100) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %105) #9
  %1160 = load i64, ptr %73, align 8, !tbaa !12
  %1161 = load i32, ptr %74, align 4, !tbaa !9
  %1162 = add i32 %1161, 1
  %1163 = zext i32 %1162 to i64
  %1164 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1160, i64 noundef %1163)
  store i64 %1164, ptr %105, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %106) #9
  %1165 = load i32, ptr %74, align 4, !tbaa !9
  %1166 = add i32 %1165, 1
  %1167 = load i32, ptr %11, align 4, !tbaa !9
  %1168 = mul i32 %1166, %1167
  %1169 = zext i32 %1168 to i64
  %1170 = getelementptr inbounds i64, ptr %503, i64 %1169
  store ptr %1170, ptr %106, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %107) #9
  store i32 0, ptr %107, align 4, !tbaa !9
  br label %1171

1171:                                             ; preds = %1199, %1156
  %1172 = load i32, ptr %107, align 4, !tbaa !9
  %1173 = load i32, ptr %11, align 4, !tbaa !9
  %1174 = icmp ult i32 %1172, %1173
  br i1 %1174, label %1176, label %1175

1175:                                             ; preds = %1171
  store i32 43, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %107) #9
  br label %1202

1176:                                             ; preds = %1171
  call void @llvm.lifetime.start.p0(i64 8, ptr %108) #9
  %1177 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %1177, ptr %108, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %109) #9
  %1178 = load i64, ptr %105, align 8, !tbaa !12
  %1179 = load ptr, ptr %106, align 8, !tbaa !5
  %1180 = load i32, ptr %107, align 4, !tbaa !9
  %1181 = zext i32 %1180 to i64
  %1182 = getelementptr inbounds i64, ptr %1179, i64 %1181
  %1183 = load i64, ptr %1182, align 8, !tbaa !12
  %1184 = and i64 %1178, %1183
  %1185 = load i64, ptr %105, align 8, !tbaa !12
  %1186 = xor i64 %1185, -1
  %1187 = load ptr, ptr %10, align 8, !tbaa !5
  %1188 = load i32, ptr %107, align 4, !tbaa !9
  %1189 = zext i32 %1188 to i64
  %1190 = getelementptr inbounds i64, ptr %1187, i64 %1189
  %1191 = load i64, ptr %1190, align 8, !tbaa !12
  %1192 = and i64 %1186, %1191
  %1193 = or i64 %1184, %1192
  store i64 %1193, ptr %109, align 8, !tbaa !12
  %1194 = load i64, ptr %109, align 8, !tbaa !12
  %1195 = load ptr, ptr %108, align 8, !tbaa !5
  %1196 = load i32, ptr %107, align 4, !tbaa !9
  %1197 = zext i32 %1196 to i64
  %1198 = getelementptr inbounds i64, ptr %1195, i64 %1197
  store i64 %1194, ptr %1198, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %109) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %108) #9
  br label %1199

1199:                                             ; preds = %1176
  %1200 = load i32, ptr %107, align 4, !tbaa !9
  %1201 = add i32 %1200, 1
  store i32 %1201, ptr %107, align 4, !tbaa !9
  br label %1171, !llvm.loop !29

1202:                                             ; preds = %1175
  %1203 = load i32, ptr %74, align 4, !tbaa !9
  %1204 = add i32 %1203, 1
  store i32 %1204, ptr %74, align 4, !tbaa !9
  %1205 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %106) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %105) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %110) #9
  %1206 = load i64, ptr %73, align 8, !tbaa !12
  %1207 = load i32, ptr %74, align 4, !tbaa !9
  %1208 = add i32 %1207, 1
  %1209 = zext i32 %1208 to i64
  %1210 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1206, i64 noundef %1209)
  store i64 %1210, ptr %110, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %111) #9
  %1211 = load i32, ptr %74, align 4, !tbaa !9
  %1212 = add i32 %1211, 1
  %1213 = load i32, ptr %11, align 4, !tbaa !9
  %1214 = mul i32 %1212, %1213
  %1215 = zext i32 %1214 to i64
  %1216 = getelementptr inbounds i64, ptr %503, i64 %1215
  store ptr %1216, ptr %111, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %112) #9
  store i32 0, ptr %112, align 4, !tbaa !9
  br label %1217

1217:                                             ; preds = %1245, %1202
  %1218 = load i32, ptr %112, align 4, !tbaa !9
  %1219 = load i32, ptr %11, align 4, !tbaa !9
  %1220 = icmp ult i32 %1218, %1219
  br i1 %1220, label %1222, label %1221

1221:                                             ; preds = %1217
  store i32 46, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %112) #9
  br label %1248

1222:                                             ; preds = %1217
  call void @llvm.lifetime.start.p0(i64 8, ptr %113) #9
  %1223 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %1223, ptr %113, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %114) #9
  %1224 = load i64, ptr %110, align 8, !tbaa !12
  %1225 = load ptr, ptr %111, align 8, !tbaa !5
  %1226 = load i32, ptr %112, align 4, !tbaa !9
  %1227 = zext i32 %1226 to i64
  %1228 = getelementptr inbounds i64, ptr %1225, i64 %1227
  %1229 = load i64, ptr %1228, align 8, !tbaa !12
  %1230 = and i64 %1224, %1229
  %1231 = load i64, ptr %110, align 8, !tbaa !12
  %1232 = xor i64 %1231, -1
  %1233 = load ptr, ptr %10, align 8, !tbaa !5
  %1234 = load i32, ptr %112, align 4, !tbaa !9
  %1235 = zext i32 %1234 to i64
  %1236 = getelementptr inbounds i64, ptr %1233, i64 %1235
  %1237 = load i64, ptr %1236, align 8, !tbaa !12
  %1238 = and i64 %1232, %1237
  %1239 = or i64 %1230, %1238
  store i64 %1239, ptr %114, align 8, !tbaa !12
  %1240 = load i64, ptr %114, align 8, !tbaa !12
  %1241 = load ptr, ptr %113, align 8, !tbaa !5
  %1242 = load i32, ptr %112, align 4, !tbaa !9
  %1243 = zext i32 %1242 to i64
  %1244 = getelementptr inbounds i64, ptr %1241, i64 %1243
  store i64 %1240, ptr %1244, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %114) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %113) #9
  br label %1245

1245:                                             ; preds = %1222
  %1246 = load i32, ptr %112, align 4, !tbaa !9
  %1247 = add i32 %1246, 1
  store i32 %1247, ptr %112, align 4, !tbaa !9
  br label %1217, !llvm.loop !30

1248:                                             ; preds = %1221
  %1249 = load i32, ptr %74, align 4, !tbaa !9
  %1250 = add i32 %1249, 1
  store i32 %1250, ptr %74, align 4, !tbaa !9
  %1251 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %111) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %110) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %115) #9
  %1252 = load i64, ptr %73, align 8, !tbaa !12
  %1253 = load i32, ptr %74, align 4, !tbaa !9
  %1254 = add i32 %1253, 1
  %1255 = zext i32 %1254 to i64
  %1256 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1252, i64 noundef %1255)
  store i64 %1256, ptr %115, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %116) #9
  %1257 = load i32, ptr %74, align 4, !tbaa !9
  %1258 = add i32 %1257, 1
  %1259 = load i32, ptr %11, align 4, !tbaa !9
  %1260 = mul i32 %1258, %1259
  %1261 = zext i32 %1260 to i64
  %1262 = getelementptr inbounds i64, ptr %503, i64 %1261
  store ptr %1262, ptr %116, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %117) #9
  store i32 0, ptr %117, align 4, !tbaa !9
  br label %1263

1263:                                             ; preds = %1291, %1248
  %1264 = load i32, ptr %117, align 4, !tbaa !9
  %1265 = load i32, ptr %11, align 4, !tbaa !9
  %1266 = icmp ult i32 %1264, %1265
  br i1 %1266, label %1268, label %1267

1267:                                             ; preds = %1263
  store i32 49, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %117) #9
  br label %1294

1268:                                             ; preds = %1263
  call void @llvm.lifetime.start.p0(i64 8, ptr %118) #9
  %1269 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %1269, ptr %118, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %119) #9
  %1270 = load i64, ptr %115, align 8, !tbaa !12
  %1271 = load ptr, ptr %116, align 8, !tbaa !5
  %1272 = load i32, ptr %117, align 4, !tbaa !9
  %1273 = zext i32 %1272 to i64
  %1274 = getelementptr inbounds i64, ptr %1271, i64 %1273
  %1275 = load i64, ptr %1274, align 8, !tbaa !12
  %1276 = and i64 %1270, %1275
  %1277 = load i64, ptr %115, align 8, !tbaa !12
  %1278 = xor i64 %1277, -1
  %1279 = load ptr, ptr %10, align 8, !tbaa !5
  %1280 = load i32, ptr %117, align 4, !tbaa !9
  %1281 = zext i32 %1280 to i64
  %1282 = getelementptr inbounds i64, ptr %1279, i64 %1281
  %1283 = load i64, ptr %1282, align 8, !tbaa !12
  %1284 = and i64 %1278, %1283
  %1285 = or i64 %1276, %1284
  store i64 %1285, ptr %119, align 8, !tbaa !12
  %1286 = load i64, ptr %119, align 8, !tbaa !12
  %1287 = load ptr, ptr %118, align 8, !tbaa !5
  %1288 = load i32, ptr %117, align 4, !tbaa !9
  %1289 = zext i32 %1288 to i64
  %1290 = getelementptr inbounds i64, ptr %1287, i64 %1289
  store i64 %1286, ptr %1290, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %119) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %118) #9
  br label %1291

1291:                                             ; preds = %1268
  %1292 = load i32, ptr %117, align 4, !tbaa !9
  %1293 = add i32 %1292, 1
  store i32 %1293, ptr %117, align 4, !tbaa !9
  br label %1263, !llvm.loop !31

1294:                                             ; preds = %1267
  %1295 = load i32, ptr %74, align 4, !tbaa !9
  %1296 = add i32 %1295, 1
  store i32 %1296, ptr %74, align 4, !tbaa !9
  %1297 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %116) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %115) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %120) #9
  %1298 = load i64, ptr %73, align 8, !tbaa !12
  %1299 = load i32, ptr %74, align 4, !tbaa !9
  %1300 = add i32 %1299, 1
  %1301 = zext i32 %1300 to i64
  %1302 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1298, i64 noundef %1301)
  store i64 %1302, ptr %120, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %121) #9
  %1303 = load i32, ptr %74, align 4, !tbaa !9
  %1304 = add i32 %1303, 1
  %1305 = load i32, ptr %11, align 4, !tbaa !9
  %1306 = mul i32 %1304, %1305
  %1307 = zext i32 %1306 to i64
  %1308 = getelementptr inbounds i64, ptr %503, i64 %1307
  store ptr %1308, ptr %121, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %122) #9
  store i32 0, ptr %122, align 4, !tbaa !9
  br label %1309

1309:                                             ; preds = %1337, %1294
  %1310 = load i32, ptr %122, align 4, !tbaa !9
  %1311 = load i32, ptr %11, align 4, !tbaa !9
  %1312 = icmp ult i32 %1310, %1311
  br i1 %1312, label %1314, label %1313

1313:                                             ; preds = %1309
  store i32 52, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %122) #9
  br label %1340

1314:                                             ; preds = %1309
  call void @llvm.lifetime.start.p0(i64 8, ptr %123) #9
  %1315 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %1315, ptr %123, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %124) #9
  %1316 = load i64, ptr %120, align 8, !tbaa !12
  %1317 = load ptr, ptr %121, align 8, !tbaa !5
  %1318 = load i32, ptr %122, align 4, !tbaa !9
  %1319 = zext i32 %1318 to i64
  %1320 = getelementptr inbounds i64, ptr %1317, i64 %1319
  %1321 = load i64, ptr %1320, align 8, !tbaa !12
  %1322 = and i64 %1316, %1321
  %1323 = load i64, ptr %120, align 8, !tbaa !12
  %1324 = xor i64 %1323, -1
  %1325 = load ptr, ptr %10, align 8, !tbaa !5
  %1326 = load i32, ptr %122, align 4, !tbaa !9
  %1327 = zext i32 %1326 to i64
  %1328 = getelementptr inbounds i64, ptr %1325, i64 %1327
  %1329 = load i64, ptr %1328, align 8, !tbaa !12
  %1330 = and i64 %1324, %1329
  %1331 = or i64 %1322, %1330
  store i64 %1331, ptr %124, align 8, !tbaa !12
  %1332 = load i64, ptr %124, align 8, !tbaa !12
  %1333 = load ptr, ptr %123, align 8, !tbaa !5
  %1334 = load i32, ptr %122, align 4, !tbaa !9
  %1335 = zext i32 %1334 to i64
  %1336 = getelementptr inbounds i64, ptr %1333, i64 %1335
  store i64 %1332, ptr %1336, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %124) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %123) #9
  br label %1337

1337:                                             ; preds = %1314
  %1338 = load i32, ptr %122, align 4, !tbaa !9
  %1339 = add i32 %1338, 1
  store i32 %1339, ptr %122, align 4, !tbaa !9
  br label %1309, !llvm.loop !32

1340:                                             ; preds = %1313
  %1341 = load i32, ptr %74, align 4, !tbaa !9
  %1342 = add i32 %1341, 1
  store i32 %1342, ptr %74, align 4, !tbaa !9
  %1343 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %121) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %120) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %125) #9
  %1344 = load i64, ptr %73, align 8, !tbaa !12
  %1345 = load i32, ptr %74, align 4, !tbaa !9
  %1346 = add i32 %1345, 1
  %1347 = zext i32 %1346 to i64
  %1348 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1344, i64 noundef %1347)
  store i64 %1348, ptr %125, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %126) #9
  %1349 = load i32, ptr %74, align 4, !tbaa !9
  %1350 = add i32 %1349, 1
  %1351 = load i32, ptr %11, align 4, !tbaa !9
  %1352 = mul i32 %1350, %1351
  %1353 = zext i32 %1352 to i64
  %1354 = getelementptr inbounds i64, ptr %503, i64 %1353
  store ptr %1354, ptr %126, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %127) #9
  store i32 0, ptr %127, align 4, !tbaa !9
  br label %1355

1355:                                             ; preds = %1383, %1340
  %1356 = load i32, ptr %127, align 4, !tbaa !9
  %1357 = load i32, ptr %11, align 4, !tbaa !9
  %1358 = icmp ult i32 %1356, %1357
  br i1 %1358, label %1360, label %1359

1359:                                             ; preds = %1355
  store i32 55, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %127) #9
  br label %1386

1360:                                             ; preds = %1355
  call void @llvm.lifetime.start.p0(i64 8, ptr %128) #9
  %1361 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %1361, ptr %128, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %129) #9
  %1362 = load i64, ptr %125, align 8, !tbaa !12
  %1363 = load ptr, ptr %126, align 8, !tbaa !5
  %1364 = load i32, ptr %127, align 4, !tbaa !9
  %1365 = zext i32 %1364 to i64
  %1366 = getelementptr inbounds i64, ptr %1363, i64 %1365
  %1367 = load i64, ptr %1366, align 8, !tbaa !12
  %1368 = and i64 %1362, %1367
  %1369 = load i64, ptr %125, align 8, !tbaa !12
  %1370 = xor i64 %1369, -1
  %1371 = load ptr, ptr %10, align 8, !tbaa !5
  %1372 = load i32, ptr %127, align 4, !tbaa !9
  %1373 = zext i32 %1372 to i64
  %1374 = getelementptr inbounds i64, ptr %1371, i64 %1373
  %1375 = load i64, ptr %1374, align 8, !tbaa !12
  %1376 = and i64 %1370, %1375
  %1377 = or i64 %1368, %1376
  store i64 %1377, ptr %129, align 8, !tbaa !12
  %1378 = load i64, ptr %129, align 8, !tbaa !12
  %1379 = load ptr, ptr %128, align 8, !tbaa !5
  %1380 = load i32, ptr %127, align 4, !tbaa !9
  %1381 = zext i32 %1380 to i64
  %1382 = getelementptr inbounds i64, ptr %1379, i64 %1381
  store i64 %1378, ptr %1382, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %129) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %128) #9
  br label %1383

1383:                                             ; preds = %1360
  %1384 = load i32, ptr %127, align 4, !tbaa !9
  %1385 = add i32 %1384, 1
  store i32 %1385, ptr %127, align 4, !tbaa !9
  br label %1355, !llvm.loop !33

1386:                                             ; preds = %1359
  %1387 = load i32, ptr %74, align 4, !tbaa !9
  %1388 = add i32 %1387, 1
  store i32 %1388, ptr %74, align 4, !tbaa !9
  %1389 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %126) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %125) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %130) #9
  %1390 = load i64, ptr %73, align 8, !tbaa !12
  %1391 = load i32, ptr %74, align 4, !tbaa !9
  %1392 = add i32 %1391, 1
  %1393 = zext i32 %1392 to i64
  %1394 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1390, i64 noundef %1393)
  store i64 %1394, ptr %130, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %131) #9
  %1395 = load i32, ptr %74, align 4, !tbaa !9
  %1396 = add i32 %1395, 1
  %1397 = load i32, ptr %11, align 4, !tbaa !9
  %1398 = mul i32 %1396, %1397
  %1399 = zext i32 %1398 to i64
  %1400 = getelementptr inbounds i64, ptr %503, i64 %1399
  store ptr %1400, ptr %131, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %132) #9
  store i32 0, ptr %132, align 4, !tbaa !9
  br label %1401

1401:                                             ; preds = %1429, %1386
  %1402 = load i32, ptr %132, align 4, !tbaa !9
  %1403 = load i32, ptr %11, align 4, !tbaa !9
  %1404 = icmp ult i32 %1402, %1403
  br i1 %1404, label %1406, label %1405

1405:                                             ; preds = %1401
  store i32 58, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %132) #9
  br label %1432

1406:                                             ; preds = %1401
  call void @llvm.lifetime.start.p0(i64 8, ptr %133) #9
  %1407 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %1407, ptr %133, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %134) #9
  %1408 = load i64, ptr %130, align 8, !tbaa !12
  %1409 = load ptr, ptr %131, align 8, !tbaa !5
  %1410 = load i32, ptr %132, align 4, !tbaa !9
  %1411 = zext i32 %1410 to i64
  %1412 = getelementptr inbounds i64, ptr %1409, i64 %1411
  %1413 = load i64, ptr %1412, align 8, !tbaa !12
  %1414 = and i64 %1408, %1413
  %1415 = load i64, ptr %130, align 8, !tbaa !12
  %1416 = xor i64 %1415, -1
  %1417 = load ptr, ptr %10, align 8, !tbaa !5
  %1418 = load i32, ptr %132, align 4, !tbaa !9
  %1419 = zext i32 %1418 to i64
  %1420 = getelementptr inbounds i64, ptr %1417, i64 %1419
  %1421 = load i64, ptr %1420, align 8, !tbaa !12
  %1422 = and i64 %1416, %1421
  %1423 = or i64 %1414, %1422
  store i64 %1423, ptr %134, align 8, !tbaa !12
  %1424 = load i64, ptr %134, align 8, !tbaa !12
  %1425 = load ptr, ptr %133, align 8, !tbaa !5
  %1426 = load i32, ptr %132, align 4, !tbaa !9
  %1427 = zext i32 %1426 to i64
  %1428 = getelementptr inbounds i64, ptr %1425, i64 %1427
  store i64 %1424, ptr %1428, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %134) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %133) #9
  br label %1429

1429:                                             ; preds = %1406
  %1430 = load i32, ptr %132, align 4, !tbaa !9
  %1431 = add i32 %1430, 1
  store i32 %1431, ptr %132, align 4, !tbaa !9
  br label %1401, !llvm.loop !34

1432:                                             ; preds = %1405
  %1433 = load i32, ptr %74, align 4, !tbaa !9
  %1434 = add i32 %1433, 1
  store i32 %1434, ptr %74, align 4, !tbaa !9
  %1435 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %131) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %130) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %135) #9
  %1436 = load i64, ptr %73, align 8, !tbaa !12
  %1437 = load i32, ptr %74, align 4, !tbaa !9
  %1438 = add i32 %1437, 1
  %1439 = zext i32 %1438 to i64
  %1440 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1436, i64 noundef %1439)
  store i64 %1440, ptr %135, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %136) #9
  %1441 = load i32, ptr %74, align 4, !tbaa !9
  %1442 = add i32 %1441, 1
  %1443 = load i32, ptr %11, align 4, !tbaa !9
  %1444 = mul i32 %1442, %1443
  %1445 = zext i32 %1444 to i64
  %1446 = getelementptr inbounds i64, ptr %503, i64 %1445
  store ptr %1446, ptr %136, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %137) #9
  store i32 0, ptr %137, align 4, !tbaa !9
  br label %1447

1447:                                             ; preds = %1475, %1432
  %1448 = load i32, ptr %137, align 4, !tbaa !9
  %1449 = load i32, ptr %11, align 4, !tbaa !9
  %1450 = icmp ult i32 %1448, %1449
  br i1 %1450, label %1452, label %1451

1451:                                             ; preds = %1447
  store i32 61, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %137) #9
  br label %1478

1452:                                             ; preds = %1447
  call void @llvm.lifetime.start.p0(i64 8, ptr %138) #9
  %1453 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %1453, ptr %138, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %139) #9
  %1454 = load i64, ptr %135, align 8, !tbaa !12
  %1455 = load ptr, ptr %136, align 8, !tbaa !5
  %1456 = load i32, ptr %137, align 4, !tbaa !9
  %1457 = zext i32 %1456 to i64
  %1458 = getelementptr inbounds i64, ptr %1455, i64 %1457
  %1459 = load i64, ptr %1458, align 8, !tbaa !12
  %1460 = and i64 %1454, %1459
  %1461 = load i64, ptr %135, align 8, !tbaa !12
  %1462 = xor i64 %1461, -1
  %1463 = load ptr, ptr %10, align 8, !tbaa !5
  %1464 = load i32, ptr %137, align 4, !tbaa !9
  %1465 = zext i32 %1464 to i64
  %1466 = getelementptr inbounds i64, ptr %1463, i64 %1465
  %1467 = load i64, ptr %1466, align 8, !tbaa !12
  %1468 = and i64 %1462, %1467
  %1469 = or i64 %1460, %1468
  store i64 %1469, ptr %139, align 8, !tbaa !12
  %1470 = load i64, ptr %139, align 8, !tbaa !12
  %1471 = load ptr, ptr %138, align 8, !tbaa !5
  %1472 = load i32, ptr %137, align 4, !tbaa !9
  %1473 = zext i32 %1472 to i64
  %1474 = getelementptr inbounds i64, ptr %1471, i64 %1473
  store i64 %1470, ptr %1474, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %139) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %138) #9
  br label %1475

1475:                                             ; preds = %1452
  %1476 = load i32, ptr %137, align 4, !tbaa !9
  %1477 = add i32 %1476, 1
  store i32 %1477, ptr %137, align 4, !tbaa !9
  br label %1447, !llvm.loop !35

1478:                                             ; preds = %1451
  %1479 = load i32, ptr %74, align 4, !tbaa !9
  %1480 = add i32 %1479, 1
  store i32 %1480, ptr %74, align 4, !tbaa !9
  %1481 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %136) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %135) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %140) #9
  %1482 = load i64, ptr %73, align 8, !tbaa !12
  %1483 = load i32, ptr %74, align 4, !tbaa !9
  %1484 = add i32 %1483, 1
  %1485 = zext i32 %1484 to i64
  %1486 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1482, i64 noundef %1485)
  store i64 %1486, ptr %140, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %141) #9
  %1487 = load i32, ptr %74, align 4, !tbaa !9
  %1488 = add i32 %1487, 1
  %1489 = load i32, ptr %11, align 4, !tbaa !9
  %1490 = mul i32 %1488, %1489
  %1491 = zext i32 %1490 to i64
  %1492 = getelementptr inbounds i64, ptr %503, i64 %1491
  store ptr %1492, ptr %141, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %142) #9
  store i32 0, ptr %142, align 4, !tbaa !9
  br label %1493

1493:                                             ; preds = %1521, %1478
  %1494 = load i32, ptr %142, align 4, !tbaa !9
  %1495 = load i32, ptr %11, align 4, !tbaa !9
  %1496 = icmp ult i32 %1494, %1495
  br i1 %1496, label %1498, label %1497

1497:                                             ; preds = %1493
  store i32 64, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %142) #9
  br label %1524

1498:                                             ; preds = %1493
  call void @llvm.lifetime.start.p0(i64 8, ptr %143) #9
  %1499 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %1499, ptr %143, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %144) #9
  %1500 = load i64, ptr %140, align 8, !tbaa !12
  %1501 = load ptr, ptr %141, align 8, !tbaa !5
  %1502 = load i32, ptr %142, align 4, !tbaa !9
  %1503 = zext i32 %1502 to i64
  %1504 = getelementptr inbounds i64, ptr %1501, i64 %1503
  %1505 = load i64, ptr %1504, align 8, !tbaa !12
  %1506 = and i64 %1500, %1505
  %1507 = load i64, ptr %140, align 8, !tbaa !12
  %1508 = xor i64 %1507, -1
  %1509 = load ptr, ptr %10, align 8, !tbaa !5
  %1510 = load i32, ptr %142, align 4, !tbaa !9
  %1511 = zext i32 %1510 to i64
  %1512 = getelementptr inbounds i64, ptr %1509, i64 %1511
  %1513 = load i64, ptr %1512, align 8, !tbaa !12
  %1514 = and i64 %1508, %1513
  %1515 = or i64 %1506, %1514
  store i64 %1515, ptr %144, align 8, !tbaa !12
  %1516 = load i64, ptr %144, align 8, !tbaa !12
  %1517 = load ptr, ptr %143, align 8, !tbaa !5
  %1518 = load i32, ptr %142, align 4, !tbaa !9
  %1519 = zext i32 %1518 to i64
  %1520 = getelementptr inbounds i64, ptr %1517, i64 %1519
  store i64 %1516, ptr %1520, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %144) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %143) #9
  br label %1521

1521:                                             ; preds = %1498
  %1522 = load i32, ptr %142, align 4, !tbaa !9
  %1523 = add i32 %1522, 1
  store i32 %1523, ptr %142, align 4, !tbaa !9
  br label %1493, !llvm.loop !36

1524:                                             ; preds = %1497
  %1525 = load i32, ptr %74, align 4, !tbaa !9
  %1526 = add i32 %1525, 1
  store i32 %1526, ptr %74, align 4, !tbaa !9
  %1527 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %141) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %140) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %145) #9
  %1528 = load i64, ptr %73, align 8, !tbaa !12
  %1529 = load i32, ptr %74, align 4, !tbaa !9
  %1530 = add i32 %1529, 1
  %1531 = zext i32 %1530 to i64
  %1532 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1528, i64 noundef %1531)
  store i64 %1532, ptr %145, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %146) #9
  %1533 = load i32, ptr %74, align 4, !tbaa !9
  %1534 = add i32 %1533, 1
  %1535 = load i32, ptr %11, align 4, !tbaa !9
  %1536 = mul i32 %1534, %1535
  %1537 = zext i32 %1536 to i64
  %1538 = getelementptr inbounds i64, ptr %503, i64 %1537
  store ptr %1538, ptr %146, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %147) #9
  store i32 0, ptr %147, align 4, !tbaa !9
  br label %1539

1539:                                             ; preds = %1567, %1524
  %1540 = load i32, ptr %147, align 4, !tbaa !9
  %1541 = load i32, ptr %11, align 4, !tbaa !9
  %1542 = icmp ult i32 %1540, %1541
  br i1 %1542, label %1544, label %1543

1543:                                             ; preds = %1539
  store i32 67, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %147) #9
  br label %1570

1544:                                             ; preds = %1539
  call void @llvm.lifetime.start.p0(i64 8, ptr %148) #9
  %1545 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %1545, ptr %148, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %149) #9
  %1546 = load i64, ptr %145, align 8, !tbaa !12
  %1547 = load ptr, ptr %146, align 8, !tbaa !5
  %1548 = load i32, ptr %147, align 4, !tbaa !9
  %1549 = zext i32 %1548 to i64
  %1550 = getelementptr inbounds i64, ptr %1547, i64 %1549
  %1551 = load i64, ptr %1550, align 8, !tbaa !12
  %1552 = and i64 %1546, %1551
  %1553 = load i64, ptr %145, align 8, !tbaa !12
  %1554 = xor i64 %1553, -1
  %1555 = load ptr, ptr %10, align 8, !tbaa !5
  %1556 = load i32, ptr %147, align 4, !tbaa !9
  %1557 = zext i32 %1556 to i64
  %1558 = getelementptr inbounds i64, ptr %1555, i64 %1557
  %1559 = load i64, ptr %1558, align 8, !tbaa !12
  %1560 = and i64 %1554, %1559
  %1561 = or i64 %1552, %1560
  store i64 %1561, ptr %149, align 8, !tbaa !12
  %1562 = load i64, ptr %149, align 8, !tbaa !12
  %1563 = load ptr, ptr %148, align 8, !tbaa !5
  %1564 = load i32, ptr %147, align 4, !tbaa !9
  %1565 = zext i32 %1564 to i64
  %1566 = getelementptr inbounds i64, ptr %1563, i64 %1565
  store i64 %1562, ptr %1566, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %149) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %148) #9
  br label %1567

1567:                                             ; preds = %1544
  %1568 = load i32, ptr %147, align 4, !tbaa !9
  %1569 = add i32 %1568, 1
  store i32 %1569, ptr %147, align 4, !tbaa !9
  br label %1539, !llvm.loop !37

1570:                                             ; preds = %1543
  %1571 = load i32, ptr %74, align 4, !tbaa !9
  %1572 = add i32 %1571, 1
  store i32 %1572, ptr %74, align 4, !tbaa !9
  %1573 = load i32, ptr %74, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %146) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %145) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %74) #9
  br label %1574

1574:                                             ; preds = %1570
  br label %1575

1575:                                             ; preds = %1574
  call void @llvm.lifetime.end.p0(i64 8, ptr %73) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %72) #9
  br label %1586

1576:                                             ; preds = %863
  call void @llvm.lifetime.start.p0(i64 8, ptr %150) #9
  store ptr %471, ptr %150, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %151) #9
  %1577 = load i32, ptr %11, align 4, !tbaa !9
  %1578 = zext i32 %1577 to i64
  %1579 = getelementptr inbounds i64, ptr %471, i64 %1578
  store ptr %1579, ptr %151, align 8, !tbaa !5
  %1580 = load i32, ptr %11, align 4, !tbaa !9
  %1581 = load ptr, ptr %150, align 8, !tbaa !5
  %1582 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %1583 = load i64, ptr %1582, align 8, !tbaa !18
  %1584 = load ptr, ptr %151, align 8, !tbaa !5
  %1585 = load ptr, ptr %10, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_from_mont_u64(i32 noundef %1580, ptr noundef %1581, i64 noundef %1583, ptr noundef %1584, ptr noundef %1585)
  call void @llvm.lifetime.end.p0(i64 8, ptr %151) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %150) #9
  br label %1586

1586:                                             ; preds = %1576, %1575
  br label %1587

1587:                                             ; preds = %1586
  %1588 = load i32, ptr %11, align 4, !tbaa !9
  %1589 = zext i32 %1588 to i64
  %1590 = icmp ugt i64 %1589, 2305843009213693951
  br i1 %1590, label %1591, label %1593

1591:                                             ; preds = %1587
  %1592 = call i32 (ptr, ...) @printf(ptr noundef @.str, ptr noundef @.str.1, i32 noundef 387)
  call void @exit(i32 noundef 253) #10
  unreachable

1593:                                             ; preds = %1587
  br label %1594

1594:                                             ; preds = %1593
  br label %1595

1595:                                             ; preds = %1594
  %1596 = load i32, ptr %11, align 4, !tbaa !9
  %1597 = zext i32 %1596 to i64
  %1598 = alloca i64, i64 %1597, align 16
  store i64 %1597, ptr %152, align 8
  %1599 = load i32, ptr %11, align 4, !tbaa !9
  %1600 = zext i32 %1599 to i64
  %1601 = mul i64 %1600, 8
  call void @llvm.memset.p0.i64(ptr align 16 %1598, i8 0, i64 %1601, i1 false)
  call void @llvm.lifetime.start.p0(i64 4, ptr %153) #9
  store i32 0, ptr %153, align 4, !tbaa !9
  br label %1602

1602:                                             ; preds = %2336, %1595
  %1603 = load i32, ptr %153, align 4, !tbaa !9
  %1604 = load i32, ptr %8, align 4, !tbaa !9
  %1605 = udiv i32 %1604, 4
  %1606 = icmp ult i32 %1603, %1605
  br i1 %1606, label %1608, label %1607

1607:                                             ; preds = %1602
  store i32 72, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %153) #9
  br label %2339

1608:                                             ; preds = %1602
  br label %1609

1609:                                             ; preds = %1608
  call void @llvm.lifetime.start.p0(i64 4, ptr %154) #9
  store i32 0, ptr %154, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %155) #9
  store ptr %471, ptr %155, align 8, !tbaa !5
  %1610 = load i32, ptr %11, align 4, !tbaa !9
  %1611 = load ptr, ptr %155, align 8, !tbaa !5
  %1612 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %1613 = load i64, ptr %1612, align 8, !tbaa !18
  %1614 = load ptr, ptr %10, align 8, !tbaa !5
  %1615 = load ptr, ptr %10, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %1610, ptr noundef %1611, i64 noundef %1613, ptr noundef %1614, ptr noundef %1615)
  %1616 = load i32, ptr %154, align 4, !tbaa !9
  %1617 = add i32 %1616, 1
  store i32 %1617, ptr %154, align 4, !tbaa !9
  %1618 = load i32, ptr %154, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %155) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %156) #9
  store ptr %471, ptr %156, align 8, !tbaa !5
  %1619 = load i32, ptr %11, align 4, !tbaa !9
  %1620 = load ptr, ptr %156, align 8, !tbaa !5
  %1621 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %1622 = load i64, ptr %1621, align 8, !tbaa !18
  %1623 = load ptr, ptr %10, align 8, !tbaa !5
  %1624 = load ptr, ptr %10, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %1619, ptr noundef %1620, i64 noundef %1622, ptr noundef %1623, ptr noundef %1624)
  %1625 = load i32, ptr %154, align 4, !tbaa !9
  %1626 = add i32 %1625, 1
  store i32 %1626, ptr %154, align 4, !tbaa !9
  %1627 = load i32, ptr %154, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %156) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %157) #9
  store ptr %471, ptr %157, align 8, !tbaa !5
  %1628 = load i32, ptr %11, align 4, !tbaa !9
  %1629 = load ptr, ptr %157, align 8, !tbaa !5
  %1630 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %1631 = load i64, ptr %1630, align 8, !tbaa !18
  %1632 = load ptr, ptr %10, align 8, !tbaa !5
  %1633 = load ptr, ptr %10, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %1628, ptr noundef %1629, i64 noundef %1631, ptr noundef %1632, ptr noundef %1633)
  %1634 = load i32, ptr %154, align 4, !tbaa !9
  %1635 = add i32 %1634, 1
  store i32 %1635, ptr %154, align 4, !tbaa !9
  %1636 = load i32, ptr %154, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %157) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %158) #9
  store ptr %471, ptr %158, align 8, !tbaa !5
  %1637 = load i32, ptr %11, align 4, !tbaa !9
  %1638 = load ptr, ptr %158, align 8, !tbaa !5
  %1639 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %1640 = load i64, ptr %1639, align 8, !tbaa !18
  %1641 = load ptr, ptr %10, align 8, !tbaa !5
  %1642 = load ptr, ptr %10, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %1637, ptr noundef %1638, i64 noundef %1640, ptr noundef %1641, ptr noundef %1642)
  %1643 = load i32, ptr %154, align 4, !tbaa !9
  %1644 = add i32 %1643, 1
  store i32 %1644, ptr %154, align 4, !tbaa !9
  %1645 = load i32, ptr %154, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %158) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %154) #9
  br label %1646

1646:                                             ; preds = %1609
  br label %1647

1647:                                             ; preds = %1646
  call void @llvm.lifetime.start.p0(i64 4, ptr %159) #9
  %1648 = load i32, ptr %8, align 4, !tbaa !9
  %1649 = load i32, ptr %8, align 4, !tbaa !9
  %1650 = urem i32 %1649, 4
  %1651 = sub i32 %1648, %1650
  %1652 = load i32, ptr %153, align 4, !tbaa !9
  %1653 = mul i32 4, %1652
  %1654 = sub i32 %1651, %1653
  %1655 = sub i32 %1654, 4
  store i32 %1655, ptr %159, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %160) #9
  %1656 = load i32, ptr %34, align 4, !tbaa !9
  %1657 = load ptr, ptr %9, align 8, !tbaa !5
  %1658 = load i32, ptr %159, align 4, !tbaa !9
  %1659 = call i64 @Hacl_Bignum_Lib_bn_get_bits_u64(i32 noundef %1656, ptr noundef %1657, i32 noundef %1658, i32 noundef 4)
  store i64 %1659, ptr %160, align 8, !tbaa !12
  %1660 = load i32, ptr %11, align 4, !tbaa !9
  %1661 = mul i32 0, %1660
  %1662 = zext i32 %1661 to i64
  %1663 = getelementptr inbounds i64, ptr %503, i64 %1662
  %1664 = load i32, ptr %11, align 4, !tbaa !9
  %1665 = zext i32 %1664 to i64
  %1666 = mul i64 %1665, 8
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %1598, ptr align 8 %1663, i64 %1666, i1 false)
  br label %1667

1667:                                             ; preds = %1647
  call void @llvm.lifetime.start.p0(i64 4, ptr %161) #9
  store i32 0, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %162) #9
  %1668 = load i64, ptr %160, align 8, !tbaa !12
  %1669 = load i32, ptr %161, align 4, !tbaa !9
  %1670 = add i32 %1669, 1
  %1671 = zext i32 %1670 to i64
  %1672 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1668, i64 noundef %1671)
  store i64 %1672, ptr %162, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %163) #9
  %1673 = load i32, ptr %161, align 4, !tbaa !9
  %1674 = add i32 %1673, 1
  %1675 = load i32, ptr %11, align 4, !tbaa !9
  %1676 = mul i32 %1674, %1675
  %1677 = zext i32 %1676 to i64
  %1678 = getelementptr inbounds i64, ptr %503, i64 %1677
  store ptr %1678, ptr %163, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %164) #9
  store i32 0, ptr %164, align 4, !tbaa !9
  br label %1679

1679:                                             ; preds = %1705, %1667
  %1680 = load i32, ptr %164, align 4, !tbaa !9
  %1681 = load i32, ptr %11, align 4, !tbaa !9
  %1682 = icmp ult i32 %1680, %1681
  br i1 %1682, label %1684, label %1683

1683:                                             ; preds = %1679
  store i32 79, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %164) #9
  br label %1708

1684:                                             ; preds = %1679
  call void @llvm.lifetime.start.p0(i64 8, ptr %165) #9
  store ptr %1598, ptr %165, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %166) #9
  %1685 = load i64, ptr %162, align 8, !tbaa !12
  %1686 = load ptr, ptr %163, align 8, !tbaa !5
  %1687 = load i32, ptr %164, align 4, !tbaa !9
  %1688 = zext i32 %1687 to i64
  %1689 = getelementptr inbounds i64, ptr %1686, i64 %1688
  %1690 = load i64, ptr %1689, align 8, !tbaa !12
  %1691 = and i64 %1685, %1690
  %1692 = load i64, ptr %162, align 8, !tbaa !12
  %1693 = xor i64 %1692, -1
  %1694 = load i32, ptr %164, align 4, !tbaa !9
  %1695 = zext i32 %1694 to i64
  %1696 = getelementptr inbounds i64, ptr %1598, i64 %1695
  %1697 = load i64, ptr %1696, align 8, !tbaa !12
  %1698 = and i64 %1693, %1697
  %1699 = or i64 %1691, %1698
  store i64 %1699, ptr %166, align 8, !tbaa !12
  %1700 = load i64, ptr %166, align 8, !tbaa !12
  %1701 = load ptr, ptr %165, align 8, !tbaa !5
  %1702 = load i32, ptr %164, align 4, !tbaa !9
  %1703 = zext i32 %1702 to i64
  %1704 = getelementptr inbounds i64, ptr %1701, i64 %1703
  store i64 %1700, ptr %1704, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %166) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %165) #9
  br label %1705

1705:                                             ; preds = %1684
  %1706 = load i32, ptr %164, align 4, !tbaa !9
  %1707 = add i32 %1706, 1
  store i32 %1707, ptr %164, align 4, !tbaa !9
  br label %1679, !llvm.loop !38

1708:                                             ; preds = %1683
  %1709 = load i32, ptr %161, align 4, !tbaa !9
  %1710 = add i32 %1709, 1
  store i32 %1710, ptr %161, align 4, !tbaa !9
  %1711 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %163) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %162) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %167) #9
  %1712 = load i64, ptr %160, align 8, !tbaa !12
  %1713 = load i32, ptr %161, align 4, !tbaa !9
  %1714 = add i32 %1713, 1
  %1715 = zext i32 %1714 to i64
  %1716 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1712, i64 noundef %1715)
  store i64 %1716, ptr %167, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %168) #9
  %1717 = load i32, ptr %161, align 4, !tbaa !9
  %1718 = add i32 %1717, 1
  %1719 = load i32, ptr %11, align 4, !tbaa !9
  %1720 = mul i32 %1718, %1719
  %1721 = zext i32 %1720 to i64
  %1722 = getelementptr inbounds i64, ptr %503, i64 %1721
  store ptr %1722, ptr %168, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %169) #9
  store i32 0, ptr %169, align 4, !tbaa !9
  br label %1723

1723:                                             ; preds = %1749, %1708
  %1724 = load i32, ptr %169, align 4, !tbaa !9
  %1725 = load i32, ptr %11, align 4, !tbaa !9
  %1726 = icmp ult i32 %1724, %1725
  br i1 %1726, label %1728, label %1727

1727:                                             ; preds = %1723
  store i32 82, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %169) #9
  br label %1752

1728:                                             ; preds = %1723
  call void @llvm.lifetime.start.p0(i64 8, ptr %170) #9
  store ptr %1598, ptr %170, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %171) #9
  %1729 = load i64, ptr %167, align 8, !tbaa !12
  %1730 = load ptr, ptr %168, align 8, !tbaa !5
  %1731 = load i32, ptr %169, align 4, !tbaa !9
  %1732 = zext i32 %1731 to i64
  %1733 = getelementptr inbounds i64, ptr %1730, i64 %1732
  %1734 = load i64, ptr %1733, align 8, !tbaa !12
  %1735 = and i64 %1729, %1734
  %1736 = load i64, ptr %167, align 8, !tbaa !12
  %1737 = xor i64 %1736, -1
  %1738 = load i32, ptr %169, align 4, !tbaa !9
  %1739 = zext i32 %1738 to i64
  %1740 = getelementptr inbounds i64, ptr %1598, i64 %1739
  %1741 = load i64, ptr %1740, align 8, !tbaa !12
  %1742 = and i64 %1737, %1741
  %1743 = or i64 %1735, %1742
  store i64 %1743, ptr %171, align 8, !tbaa !12
  %1744 = load i64, ptr %171, align 8, !tbaa !12
  %1745 = load ptr, ptr %170, align 8, !tbaa !5
  %1746 = load i32, ptr %169, align 4, !tbaa !9
  %1747 = zext i32 %1746 to i64
  %1748 = getelementptr inbounds i64, ptr %1745, i64 %1747
  store i64 %1744, ptr %1748, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %171) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %170) #9
  br label %1749

1749:                                             ; preds = %1728
  %1750 = load i32, ptr %169, align 4, !tbaa !9
  %1751 = add i32 %1750, 1
  store i32 %1751, ptr %169, align 4, !tbaa !9
  br label %1723, !llvm.loop !39

1752:                                             ; preds = %1727
  %1753 = load i32, ptr %161, align 4, !tbaa !9
  %1754 = add i32 %1753, 1
  store i32 %1754, ptr %161, align 4, !tbaa !9
  %1755 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %168) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %167) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %172) #9
  %1756 = load i64, ptr %160, align 8, !tbaa !12
  %1757 = load i32, ptr %161, align 4, !tbaa !9
  %1758 = add i32 %1757, 1
  %1759 = zext i32 %1758 to i64
  %1760 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1756, i64 noundef %1759)
  store i64 %1760, ptr %172, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %173) #9
  %1761 = load i32, ptr %161, align 4, !tbaa !9
  %1762 = add i32 %1761, 1
  %1763 = load i32, ptr %11, align 4, !tbaa !9
  %1764 = mul i32 %1762, %1763
  %1765 = zext i32 %1764 to i64
  %1766 = getelementptr inbounds i64, ptr %503, i64 %1765
  store ptr %1766, ptr %173, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %174) #9
  store i32 0, ptr %174, align 4, !tbaa !9
  br label %1767

1767:                                             ; preds = %1793, %1752
  %1768 = load i32, ptr %174, align 4, !tbaa !9
  %1769 = load i32, ptr %11, align 4, !tbaa !9
  %1770 = icmp ult i32 %1768, %1769
  br i1 %1770, label %1772, label %1771

1771:                                             ; preds = %1767
  store i32 85, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %174) #9
  br label %1796

1772:                                             ; preds = %1767
  call void @llvm.lifetime.start.p0(i64 8, ptr %175) #9
  store ptr %1598, ptr %175, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %176) #9
  %1773 = load i64, ptr %172, align 8, !tbaa !12
  %1774 = load ptr, ptr %173, align 8, !tbaa !5
  %1775 = load i32, ptr %174, align 4, !tbaa !9
  %1776 = zext i32 %1775 to i64
  %1777 = getelementptr inbounds i64, ptr %1774, i64 %1776
  %1778 = load i64, ptr %1777, align 8, !tbaa !12
  %1779 = and i64 %1773, %1778
  %1780 = load i64, ptr %172, align 8, !tbaa !12
  %1781 = xor i64 %1780, -1
  %1782 = load i32, ptr %174, align 4, !tbaa !9
  %1783 = zext i32 %1782 to i64
  %1784 = getelementptr inbounds i64, ptr %1598, i64 %1783
  %1785 = load i64, ptr %1784, align 8, !tbaa !12
  %1786 = and i64 %1781, %1785
  %1787 = or i64 %1779, %1786
  store i64 %1787, ptr %176, align 8, !tbaa !12
  %1788 = load i64, ptr %176, align 8, !tbaa !12
  %1789 = load ptr, ptr %175, align 8, !tbaa !5
  %1790 = load i32, ptr %174, align 4, !tbaa !9
  %1791 = zext i32 %1790 to i64
  %1792 = getelementptr inbounds i64, ptr %1789, i64 %1791
  store i64 %1788, ptr %1792, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %176) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %175) #9
  br label %1793

1793:                                             ; preds = %1772
  %1794 = load i32, ptr %174, align 4, !tbaa !9
  %1795 = add i32 %1794, 1
  store i32 %1795, ptr %174, align 4, !tbaa !9
  br label %1767, !llvm.loop !40

1796:                                             ; preds = %1771
  %1797 = load i32, ptr %161, align 4, !tbaa !9
  %1798 = add i32 %1797, 1
  store i32 %1798, ptr %161, align 4, !tbaa !9
  %1799 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %173) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %172) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %177) #9
  %1800 = load i64, ptr %160, align 8, !tbaa !12
  %1801 = load i32, ptr %161, align 4, !tbaa !9
  %1802 = add i32 %1801, 1
  %1803 = zext i32 %1802 to i64
  %1804 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1800, i64 noundef %1803)
  store i64 %1804, ptr %177, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %178) #9
  %1805 = load i32, ptr %161, align 4, !tbaa !9
  %1806 = add i32 %1805, 1
  %1807 = load i32, ptr %11, align 4, !tbaa !9
  %1808 = mul i32 %1806, %1807
  %1809 = zext i32 %1808 to i64
  %1810 = getelementptr inbounds i64, ptr %503, i64 %1809
  store ptr %1810, ptr %178, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %179) #9
  store i32 0, ptr %179, align 4, !tbaa !9
  br label %1811

1811:                                             ; preds = %1837, %1796
  %1812 = load i32, ptr %179, align 4, !tbaa !9
  %1813 = load i32, ptr %11, align 4, !tbaa !9
  %1814 = icmp ult i32 %1812, %1813
  br i1 %1814, label %1816, label %1815

1815:                                             ; preds = %1811
  store i32 88, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %179) #9
  br label %1840

1816:                                             ; preds = %1811
  call void @llvm.lifetime.start.p0(i64 8, ptr %180) #9
  store ptr %1598, ptr %180, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %181) #9
  %1817 = load i64, ptr %177, align 8, !tbaa !12
  %1818 = load ptr, ptr %178, align 8, !tbaa !5
  %1819 = load i32, ptr %179, align 4, !tbaa !9
  %1820 = zext i32 %1819 to i64
  %1821 = getelementptr inbounds i64, ptr %1818, i64 %1820
  %1822 = load i64, ptr %1821, align 8, !tbaa !12
  %1823 = and i64 %1817, %1822
  %1824 = load i64, ptr %177, align 8, !tbaa !12
  %1825 = xor i64 %1824, -1
  %1826 = load i32, ptr %179, align 4, !tbaa !9
  %1827 = zext i32 %1826 to i64
  %1828 = getelementptr inbounds i64, ptr %1598, i64 %1827
  %1829 = load i64, ptr %1828, align 8, !tbaa !12
  %1830 = and i64 %1825, %1829
  %1831 = or i64 %1823, %1830
  store i64 %1831, ptr %181, align 8, !tbaa !12
  %1832 = load i64, ptr %181, align 8, !tbaa !12
  %1833 = load ptr, ptr %180, align 8, !tbaa !5
  %1834 = load i32, ptr %179, align 4, !tbaa !9
  %1835 = zext i32 %1834 to i64
  %1836 = getelementptr inbounds i64, ptr %1833, i64 %1835
  store i64 %1832, ptr %1836, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %181) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %180) #9
  br label %1837

1837:                                             ; preds = %1816
  %1838 = load i32, ptr %179, align 4, !tbaa !9
  %1839 = add i32 %1838, 1
  store i32 %1839, ptr %179, align 4, !tbaa !9
  br label %1811, !llvm.loop !41

1840:                                             ; preds = %1815
  %1841 = load i32, ptr %161, align 4, !tbaa !9
  %1842 = add i32 %1841, 1
  store i32 %1842, ptr %161, align 4, !tbaa !9
  %1843 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %178) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %177) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %182) #9
  %1844 = load i64, ptr %160, align 8, !tbaa !12
  %1845 = load i32, ptr %161, align 4, !tbaa !9
  %1846 = add i32 %1845, 1
  %1847 = zext i32 %1846 to i64
  %1848 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1844, i64 noundef %1847)
  store i64 %1848, ptr %182, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %183) #9
  %1849 = load i32, ptr %161, align 4, !tbaa !9
  %1850 = add i32 %1849, 1
  %1851 = load i32, ptr %11, align 4, !tbaa !9
  %1852 = mul i32 %1850, %1851
  %1853 = zext i32 %1852 to i64
  %1854 = getelementptr inbounds i64, ptr %503, i64 %1853
  store ptr %1854, ptr %183, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %184) #9
  store i32 0, ptr %184, align 4, !tbaa !9
  br label %1855

1855:                                             ; preds = %1881, %1840
  %1856 = load i32, ptr %184, align 4, !tbaa !9
  %1857 = load i32, ptr %11, align 4, !tbaa !9
  %1858 = icmp ult i32 %1856, %1857
  br i1 %1858, label %1860, label %1859

1859:                                             ; preds = %1855
  store i32 91, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %184) #9
  br label %1884

1860:                                             ; preds = %1855
  call void @llvm.lifetime.start.p0(i64 8, ptr %185) #9
  store ptr %1598, ptr %185, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %186) #9
  %1861 = load i64, ptr %182, align 8, !tbaa !12
  %1862 = load ptr, ptr %183, align 8, !tbaa !5
  %1863 = load i32, ptr %184, align 4, !tbaa !9
  %1864 = zext i32 %1863 to i64
  %1865 = getelementptr inbounds i64, ptr %1862, i64 %1864
  %1866 = load i64, ptr %1865, align 8, !tbaa !12
  %1867 = and i64 %1861, %1866
  %1868 = load i64, ptr %182, align 8, !tbaa !12
  %1869 = xor i64 %1868, -1
  %1870 = load i32, ptr %184, align 4, !tbaa !9
  %1871 = zext i32 %1870 to i64
  %1872 = getelementptr inbounds i64, ptr %1598, i64 %1871
  %1873 = load i64, ptr %1872, align 8, !tbaa !12
  %1874 = and i64 %1869, %1873
  %1875 = or i64 %1867, %1874
  store i64 %1875, ptr %186, align 8, !tbaa !12
  %1876 = load i64, ptr %186, align 8, !tbaa !12
  %1877 = load ptr, ptr %185, align 8, !tbaa !5
  %1878 = load i32, ptr %184, align 4, !tbaa !9
  %1879 = zext i32 %1878 to i64
  %1880 = getelementptr inbounds i64, ptr %1877, i64 %1879
  store i64 %1876, ptr %1880, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %186) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %185) #9
  br label %1881

1881:                                             ; preds = %1860
  %1882 = load i32, ptr %184, align 4, !tbaa !9
  %1883 = add i32 %1882, 1
  store i32 %1883, ptr %184, align 4, !tbaa !9
  br label %1855, !llvm.loop !42

1884:                                             ; preds = %1859
  %1885 = load i32, ptr %161, align 4, !tbaa !9
  %1886 = add i32 %1885, 1
  store i32 %1886, ptr %161, align 4, !tbaa !9
  %1887 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %183) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %182) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %187) #9
  %1888 = load i64, ptr %160, align 8, !tbaa !12
  %1889 = load i32, ptr %161, align 4, !tbaa !9
  %1890 = add i32 %1889, 1
  %1891 = zext i32 %1890 to i64
  %1892 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1888, i64 noundef %1891)
  store i64 %1892, ptr %187, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %188) #9
  %1893 = load i32, ptr %161, align 4, !tbaa !9
  %1894 = add i32 %1893, 1
  %1895 = load i32, ptr %11, align 4, !tbaa !9
  %1896 = mul i32 %1894, %1895
  %1897 = zext i32 %1896 to i64
  %1898 = getelementptr inbounds i64, ptr %503, i64 %1897
  store ptr %1898, ptr %188, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %189) #9
  store i32 0, ptr %189, align 4, !tbaa !9
  br label %1899

1899:                                             ; preds = %1925, %1884
  %1900 = load i32, ptr %189, align 4, !tbaa !9
  %1901 = load i32, ptr %11, align 4, !tbaa !9
  %1902 = icmp ult i32 %1900, %1901
  br i1 %1902, label %1904, label %1903

1903:                                             ; preds = %1899
  store i32 94, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %189) #9
  br label %1928

1904:                                             ; preds = %1899
  call void @llvm.lifetime.start.p0(i64 8, ptr %190) #9
  store ptr %1598, ptr %190, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %191) #9
  %1905 = load i64, ptr %187, align 8, !tbaa !12
  %1906 = load ptr, ptr %188, align 8, !tbaa !5
  %1907 = load i32, ptr %189, align 4, !tbaa !9
  %1908 = zext i32 %1907 to i64
  %1909 = getelementptr inbounds i64, ptr %1906, i64 %1908
  %1910 = load i64, ptr %1909, align 8, !tbaa !12
  %1911 = and i64 %1905, %1910
  %1912 = load i64, ptr %187, align 8, !tbaa !12
  %1913 = xor i64 %1912, -1
  %1914 = load i32, ptr %189, align 4, !tbaa !9
  %1915 = zext i32 %1914 to i64
  %1916 = getelementptr inbounds i64, ptr %1598, i64 %1915
  %1917 = load i64, ptr %1916, align 8, !tbaa !12
  %1918 = and i64 %1913, %1917
  %1919 = or i64 %1911, %1918
  store i64 %1919, ptr %191, align 8, !tbaa !12
  %1920 = load i64, ptr %191, align 8, !tbaa !12
  %1921 = load ptr, ptr %190, align 8, !tbaa !5
  %1922 = load i32, ptr %189, align 4, !tbaa !9
  %1923 = zext i32 %1922 to i64
  %1924 = getelementptr inbounds i64, ptr %1921, i64 %1923
  store i64 %1920, ptr %1924, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %191) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %190) #9
  br label %1925

1925:                                             ; preds = %1904
  %1926 = load i32, ptr %189, align 4, !tbaa !9
  %1927 = add i32 %1926, 1
  store i32 %1927, ptr %189, align 4, !tbaa !9
  br label %1899, !llvm.loop !43

1928:                                             ; preds = %1903
  %1929 = load i32, ptr %161, align 4, !tbaa !9
  %1930 = add i32 %1929, 1
  store i32 %1930, ptr %161, align 4, !tbaa !9
  %1931 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %188) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %187) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %192) #9
  %1932 = load i64, ptr %160, align 8, !tbaa !12
  %1933 = load i32, ptr %161, align 4, !tbaa !9
  %1934 = add i32 %1933, 1
  %1935 = zext i32 %1934 to i64
  %1936 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1932, i64 noundef %1935)
  store i64 %1936, ptr %192, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %193) #9
  %1937 = load i32, ptr %161, align 4, !tbaa !9
  %1938 = add i32 %1937, 1
  %1939 = load i32, ptr %11, align 4, !tbaa !9
  %1940 = mul i32 %1938, %1939
  %1941 = zext i32 %1940 to i64
  %1942 = getelementptr inbounds i64, ptr %503, i64 %1941
  store ptr %1942, ptr %193, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %194) #9
  store i32 0, ptr %194, align 4, !tbaa !9
  br label %1943

1943:                                             ; preds = %1969, %1928
  %1944 = load i32, ptr %194, align 4, !tbaa !9
  %1945 = load i32, ptr %11, align 4, !tbaa !9
  %1946 = icmp ult i32 %1944, %1945
  br i1 %1946, label %1948, label %1947

1947:                                             ; preds = %1943
  store i32 97, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %194) #9
  br label %1972

1948:                                             ; preds = %1943
  call void @llvm.lifetime.start.p0(i64 8, ptr %195) #9
  store ptr %1598, ptr %195, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %196) #9
  %1949 = load i64, ptr %192, align 8, !tbaa !12
  %1950 = load ptr, ptr %193, align 8, !tbaa !5
  %1951 = load i32, ptr %194, align 4, !tbaa !9
  %1952 = zext i32 %1951 to i64
  %1953 = getelementptr inbounds i64, ptr %1950, i64 %1952
  %1954 = load i64, ptr %1953, align 8, !tbaa !12
  %1955 = and i64 %1949, %1954
  %1956 = load i64, ptr %192, align 8, !tbaa !12
  %1957 = xor i64 %1956, -1
  %1958 = load i32, ptr %194, align 4, !tbaa !9
  %1959 = zext i32 %1958 to i64
  %1960 = getelementptr inbounds i64, ptr %1598, i64 %1959
  %1961 = load i64, ptr %1960, align 8, !tbaa !12
  %1962 = and i64 %1957, %1961
  %1963 = or i64 %1955, %1962
  store i64 %1963, ptr %196, align 8, !tbaa !12
  %1964 = load i64, ptr %196, align 8, !tbaa !12
  %1965 = load ptr, ptr %195, align 8, !tbaa !5
  %1966 = load i32, ptr %194, align 4, !tbaa !9
  %1967 = zext i32 %1966 to i64
  %1968 = getelementptr inbounds i64, ptr %1965, i64 %1967
  store i64 %1964, ptr %1968, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %196) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %195) #9
  br label %1969

1969:                                             ; preds = %1948
  %1970 = load i32, ptr %194, align 4, !tbaa !9
  %1971 = add i32 %1970, 1
  store i32 %1971, ptr %194, align 4, !tbaa !9
  br label %1943, !llvm.loop !44

1972:                                             ; preds = %1947
  %1973 = load i32, ptr %161, align 4, !tbaa !9
  %1974 = add i32 %1973, 1
  store i32 %1974, ptr %161, align 4, !tbaa !9
  %1975 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %193) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %192) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %197) #9
  %1976 = load i64, ptr %160, align 8, !tbaa !12
  %1977 = load i32, ptr %161, align 4, !tbaa !9
  %1978 = add i32 %1977, 1
  %1979 = zext i32 %1978 to i64
  %1980 = call i64 @FStar_UInt64_eq_mask(i64 noundef %1976, i64 noundef %1979)
  store i64 %1980, ptr %197, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %198) #9
  %1981 = load i32, ptr %161, align 4, !tbaa !9
  %1982 = add i32 %1981, 1
  %1983 = load i32, ptr %11, align 4, !tbaa !9
  %1984 = mul i32 %1982, %1983
  %1985 = zext i32 %1984 to i64
  %1986 = getelementptr inbounds i64, ptr %503, i64 %1985
  store ptr %1986, ptr %198, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %199) #9
  store i32 0, ptr %199, align 4, !tbaa !9
  br label %1987

1987:                                             ; preds = %2013, %1972
  %1988 = load i32, ptr %199, align 4, !tbaa !9
  %1989 = load i32, ptr %11, align 4, !tbaa !9
  %1990 = icmp ult i32 %1988, %1989
  br i1 %1990, label %1992, label %1991

1991:                                             ; preds = %1987
  store i32 100, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %199) #9
  br label %2016

1992:                                             ; preds = %1987
  call void @llvm.lifetime.start.p0(i64 8, ptr %200) #9
  store ptr %1598, ptr %200, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %201) #9
  %1993 = load i64, ptr %197, align 8, !tbaa !12
  %1994 = load ptr, ptr %198, align 8, !tbaa !5
  %1995 = load i32, ptr %199, align 4, !tbaa !9
  %1996 = zext i32 %1995 to i64
  %1997 = getelementptr inbounds i64, ptr %1994, i64 %1996
  %1998 = load i64, ptr %1997, align 8, !tbaa !12
  %1999 = and i64 %1993, %1998
  %2000 = load i64, ptr %197, align 8, !tbaa !12
  %2001 = xor i64 %2000, -1
  %2002 = load i32, ptr %199, align 4, !tbaa !9
  %2003 = zext i32 %2002 to i64
  %2004 = getelementptr inbounds i64, ptr %1598, i64 %2003
  %2005 = load i64, ptr %2004, align 8, !tbaa !12
  %2006 = and i64 %2001, %2005
  %2007 = or i64 %1999, %2006
  store i64 %2007, ptr %201, align 8, !tbaa !12
  %2008 = load i64, ptr %201, align 8, !tbaa !12
  %2009 = load ptr, ptr %200, align 8, !tbaa !5
  %2010 = load i32, ptr %199, align 4, !tbaa !9
  %2011 = zext i32 %2010 to i64
  %2012 = getelementptr inbounds i64, ptr %2009, i64 %2011
  store i64 %2008, ptr %2012, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %201) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %200) #9
  br label %2013

2013:                                             ; preds = %1992
  %2014 = load i32, ptr %199, align 4, !tbaa !9
  %2015 = add i32 %2014, 1
  store i32 %2015, ptr %199, align 4, !tbaa !9
  br label %1987, !llvm.loop !45

2016:                                             ; preds = %1991
  %2017 = load i32, ptr %161, align 4, !tbaa !9
  %2018 = add i32 %2017, 1
  store i32 %2018, ptr %161, align 4, !tbaa !9
  %2019 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %198) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %197) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %202) #9
  %2020 = load i64, ptr %160, align 8, !tbaa !12
  %2021 = load i32, ptr %161, align 4, !tbaa !9
  %2022 = add i32 %2021, 1
  %2023 = zext i32 %2022 to i64
  %2024 = call i64 @FStar_UInt64_eq_mask(i64 noundef %2020, i64 noundef %2023)
  store i64 %2024, ptr %202, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %203) #9
  %2025 = load i32, ptr %161, align 4, !tbaa !9
  %2026 = add i32 %2025, 1
  %2027 = load i32, ptr %11, align 4, !tbaa !9
  %2028 = mul i32 %2026, %2027
  %2029 = zext i32 %2028 to i64
  %2030 = getelementptr inbounds i64, ptr %503, i64 %2029
  store ptr %2030, ptr %203, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %204) #9
  store i32 0, ptr %204, align 4, !tbaa !9
  br label %2031

2031:                                             ; preds = %2057, %2016
  %2032 = load i32, ptr %204, align 4, !tbaa !9
  %2033 = load i32, ptr %11, align 4, !tbaa !9
  %2034 = icmp ult i32 %2032, %2033
  br i1 %2034, label %2036, label %2035

2035:                                             ; preds = %2031
  store i32 103, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %204) #9
  br label %2060

2036:                                             ; preds = %2031
  call void @llvm.lifetime.start.p0(i64 8, ptr %205) #9
  store ptr %1598, ptr %205, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %206) #9
  %2037 = load i64, ptr %202, align 8, !tbaa !12
  %2038 = load ptr, ptr %203, align 8, !tbaa !5
  %2039 = load i32, ptr %204, align 4, !tbaa !9
  %2040 = zext i32 %2039 to i64
  %2041 = getelementptr inbounds i64, ptr %2038, i64 %2040
  %2042 = load i64, ptr %2041, align 8, !tbaa !12
  %2043 = and i64 %2037, %2042
  %2044 = load i64, ptr %202, align 8, !tbaa !12
  %2045 = xor i64 %2044, -1
  %2046 = load i32, ptr %204, align 4, !tbaa !9
  %2047 = zext i32 %2046 to i64
  %2048 = getelementptr inbounds i64, ptr %1598, i64 %2047
  %2049 = load i64, ptr %2048, align 8, !tbaa !12
  %2050 = and i64 %2045, %2049
  %2051 = or i64 %2043, %2050
  store i64 %2051, ptr %206, align 8, !tbaa !12
  %2052 = load i64, ptr %206, align 8, !tbaa !12
  %2053 = load ptr, ptr %205, align 8, !tbaa !5
  %2054 = load i32, ptr %204, align 4, !tbaa !9
  %2055 = zext i32 %2054 to i64
  %2056 = getelementptr inbounds i64, ptr %2053, i64 %2055
  store i64 %2052, ptr %2056, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %206) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %205) #9
  br label %2057

2057:                                             ; preds = %2036
  %2058 = load i32, ptr %204, align 4, !tbaa !9
  %2059 = add i32 %2058, 1
  store i32 %2059, ptr %204, align 4, !tbaa !9
  br label %2031, !llvm.loop !46

2060:                                             ; preds = %2035
  %2061 = load i32, ptr %161, align 4, !tbaa !9
  %2062 = add i32 %2061, 1
  store i32 %2062, ptr %161, align 4, !tbaa !9
  %2063 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %203) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %202) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %207) #9
  %2064 = load i64, ptr %160, align 8, !tbaa !12
  %2065 = load i32, ptr %161, align 4, !tbaa !9
  %2066 = add i32 %2065, 1
  %2067 = zext i32 %2066 to i64
  %2068 = call i64 @FStar_UInt64_eq_mask(i64 noundef %2064, i64 noundef %2067)
  store i64 %2068, ptr %207, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %208) #9
  %2069 = load i32, ptr %161, align 4, !tbaa !9
  %2070 = add i32 %2069, 1
  %2071 = load i32, ptr %11, align 4, !tbaa !9
  %2072 = mul i32 %2070, %2071
  %2073 = zext i32 %2072 to i64
  %2074 = getelementptr inbounds i64, ptr %503, i64 %2073
  store ptr %2074, ptr %208, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %209) #9
  store i32 0, ptr %209, align 4, !tbaa !9
  br label %2075

2075:                                             ; preds = %2101, %2060
  %2076 = load i32, ptr %209, align 4, !tbaa !9
  %2077 = load i32, ptr %11, align 4, !tbaa !9
  %2078 = icmp ult i32 %2076, %2077
  br i1 %2078, label %2080, label %2079

2079:                                             ; preds = %2075
  store i32 106, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %209) #9
  br label %2104

2080:                                             ; preds = %2075
  call void @llvm.lifetime.start.p0(i64 8, ptr %210) #9
  store ptr %1598, ptr %210, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %211) #9
  %2081 = load i64, ptr %207, align 8, !tbaa !12
  %2082 = load ptr, ptr %208, align 8, !tbaa !5
  %2083 = load i32, ptr %209, align 4, !tbaa !9
  %2084 = zext i32 %2083 to i64
  %2085 = getelementptr inbounds i64, ptr %2082, i64 %2084
  %2086 = load i64, ptr %2085, align 8, !tbaa !12
  %2087 = and i64 %2081, %2086
  %2088 = load i64, ptr %207, align 8, !tbaa !12
  %2089 = xor i64 %2088, -1
  %2090 = load i32, ptr %209, align 4, !tbaa !9
  %2091 = zext i32 %2090 to i64
  %2092 = getelementptr inbounds i64, ptr %1598, i64 %2091
  %2093 = load i64, ptr %2092, align 8, !tbaa !12
  %2094 = and i64 %2089, %2093
  %2095 = or i64 %2087, %2094
  store i64 %2095, ptr %211, align 8, !tbaa !12
  %2096 = load i64, ptr %211, align 8, !tbaa !12
  %2097 = load ptr, ptr %210, align 8, !tbaa !5
  %2098 = load i32, ptr %209, align 4, !tbaa !9
  %2099 = zext i32 %2098 to i64
  %2100 = getelementptr inbounds i64, ptr %2097, i64 %2099
  store i64 %2096, ptr %2100, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %211) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %210) #9
  br label %2101

2101:                                             ; preds = %2080
  %2102 = load i32, ptr %209, align 4, !tbaa !9
  %2103 = add i32 %2102, 1
  store i32 %2103, ptr %209, align 4, !tbaa !9
  br label %2075, !llvm.loop !47

2104:                                             ; preds = %2079
  %2105 = load i32, ptr %161, align 4, !tbaa !9
  %2106 = add i32 %2105, 1
  store i32 %2106, ptr %161, align 4, !tbaa !9
  %2107 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %208) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %207) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %212) #9
  %2108 = load i64, ptr %160, align 8, !tbaa !12
  %2109 = load i32, ptr %161, align 4, !tbaa !9
  %2110 = add i32 %2109, 1
  %2111 = zext i32 %2110 to i64
  %2112 = call i64 @FStar_UInt64_eq_mask(i64 noundef %2108, i64 noundef %2111)
  store i64 %2112, ptr %212, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %213) #9
  %2113 = load i32, ptr %161, align 4, !tbaa !9
  %2114 = add i32 %2113, 1
  %2115 = load i32, ptr %11, align 4, !tbaa !9
  %2116 = mul i32 %2114, %2115
  %2117 = zext i32 %2116 to i64
  %2118 = getelementptr inbounds i64, ptr %503, i64 %2117
  store ptr %2118, ptr %213, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %214) #9
  store i32 0, ptr %214, align 4, !tbaa !9
  br label %2119

2119:                                             ; preds = %2145, %2104
  %2120 = load i32, ptr %214, align 4, !tbaa !9
  %2121 = load i32, ptr %11, align 4, !tbaa !9
  %2122 = icmp ult i32 %2120, %2121
  br i1 %2122, label %2124, label %2123

2123:                                             ; preds = %2119
  store i32 109, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %214) #9
  br label %2148

2124:                                             ; preds = %2119
  call void @llvm.lifetime.start.p0(i64 8, ptr %215) #9
  store ptr %1598, ptr %215, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %216) #9
  %2125 = load i64, ptr %212, align 8, !tbaa !12
  %2126 = load ptr, ptr %213, align 8, !tbaa !5
  %2127 = load i32, ptr %214, align 4, !tbaa !9
  %2128 = zext i32 %2127 to i64
  %2129 = getelementptr inbounds i64, ptr %2126, i64 %2128
  %2130 = load i64, ptr %2129, align 8, !tbaa !12
  %2131 = and i64 %2125, %2130
  %2132 = load i64, ptr %212, align 8, !tbaa !12
  %2133 = xor i64 %2132, -1
  %2134 = load i32, ptr %214, align 4, !tbaa !9
  %2135 = zext i32 %2134 to i64
  %2136 = getelementptr inbounds i64, ptr %1598, i64 %2135
  %2137 = load i64, ptr %2136, align 8, !tbaa !12
  %2138 = and i64 %2133, %2137
  %2139 = or i64 %2131, %2138
  store i64 %2139, ptr %216, align 8, !tbaa !12
  %2140 = load i64, ptr %216, align 8, !tbaa !12
  %2141 = load ptr, ptr %215, align 8, !tbaa !5
  %2142 = load i32, ptr %214, align 4, !tbaa !9
  %2143 = zext i32 %2142 to i64
  %2144 = getelementptr inbounds i64, ptr %2141, i64 %2143
  store i64 %2140, ptr %2144, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %216) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %215) #9
  br label %2145

2145:                                             ; preds = %2124
  %2146 = load i32, ptr %214, align 4, !tbaa !9
  %2147 = add i32 %2146, 1
  store i32 %2147, ptr %214, align 4, !tbaa !9
  br label %2119, !llvm.loop !48

2148:                                             ; preds = %2123
  %2149 = load i32, ptr %161, align 4, !tbaa !9
  %2150 = add i32 %2149, 1
  store i32 %2150, ptr %161, align 4, !tbaa !9
  %2151 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %213) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %212) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %217) #9
  %2152 = load i64, ptr %160, align 8, !tbaa !12
  %2153 = load i32, ptr %161, align 4, !tbaa !9
  %2154 = add i32 %2153, 1
  %2155 = zext i32 %2154 to i64
  %2156 = call i64 @FStar_UInt64_eq_mask(i64 noundef %2152, i64 noundef %2155)
  store i64 %2156, ptr %217, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %218) #9
  %2157 = load i32, ptr %161, align 4, !tbaa !9
  %2158 = add i32 %2157, 1
  %2159 = load i32, ptr %11, align 4, !tbaa !9
  %2160 = mul i32 %2158, %2159
  %2161 = zext i32 %2160 to i64
  %2162 = getelementptr inbounds i64, ptr %503, i64 %2161
  store ptr %2162, ptr %218, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %219) #9
  store i32 0, ptr %219, align 4, !tbaa !9
  br label %2163

2163:                                             ; preds = %2189, %2148
  %2164 = load i32, ptr %219, align 4, !tbaa !9
  %2165 = load i32, ptr %11, align 4, !tbaa !9
  %2166 = icmp ult i32 %2164, %2165
  br i1 %2166, label %2168, label %2167

2167:                                             ; preds = %2163
  store i32 112, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %219) #9
  br label %2192

2168:                                             ; preds = %2163
  call void @llvm.lifetime.start.p0(i64 8, ptr %220) #9
  store ptr %1598, ptr %220, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %221) #9
  %2169 = load i64, ptr %217, align 8, !tbaa !12
  %2170 = load ptr, ptr %218, align 8, !tbaa !5
  %2171 = load i32, ptr %219, align 4, !tbaa !9
  %2172 = zext i32 %2171 to i64
  %2173 = getelementptr inbounds i64, ptr %2170, i64 %2172
  %2174 = load i64, ptr %2173, align 8, !tbaa !12
  %2175 = and i64 %2169, %2174
  %2176 = load i64, ptr %217, align 8, !tbaa !12
  %2177 = xor i64 %2176, -1
  %2178 = load i32, ptr %219, align 4, !tbaa !9
  %2179 = zext i32 %2178 to i64
  %2180 = getelementptr inbounds i64, ptr %1598, i64 %2179
  %2181 = load i64, ptr %2180, align 8, !tbaa !12
  %2182 = and i64 %2177, %2181
  %2183 = or i64 %2175, %2182
  store i64 %2183, ptr %221, align 8, !tbaa !12
  %2184 = load i64, ptr %221, align 8, !tbaa !12
  %2185 = load ptr, ptr %220, align 8, !tbaa !5
  %2186 = load i32, ptr %219, align 4, !tbaa !9
  %2187 = zext i32 %2186 to i64
  %2188 = getelementptr inbounds i64, ptr %2185, i64 %2187
  store i64 %2184, ptr %2188, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %221) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %220) #9
  br label %2189

2189:                                             ; preds = %2168
  %2190 = load i32, ptr %219, align 4, !tbaa !9
  %2191 = add i32 %2190, 1
  store i32 %2191, ptr %219, align 4, !tbaa !9
  br label %2163, !llvm.loop !49

2192:                                             ; preds = %2167
  %2193 = load i32, ptr %161, align 4, !tbaa !9
  %2194 = add i32 %2193, 1
  store i32 %2194, ptr %161, align 4, !tbaa !9
  %2195 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %218) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %217) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %222) #9
  %2196 = load i64, ptr %160, align 8, !tbaa !12
  %2197 = load i32, ptr %161, align 4, !tbaa !9
  %2198 = add i32 %2197, 1
  %2199 = zext i32 %2198 to i64
  %2200 = call i64 @FStar_UInt64_eq_mask(i64 noundef %2196, i64 noundef %2199)
  store i64 %2200, ptr %222, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %223) #9
  %2201 = load i32, ptr %161, align 4, !tbaa !9
  %2202 = add i32 %2201, 1
  %2203 = load i32, ptr %11, align 4, !tbaa !9
  %2204 = mul i32 %2202, %2203
  %2205 = zext i32 %2204 to i64
  %2206 = getelementptr inbounds i64, ptr %503, i64 %2205
  store ptr %2206, ptr %223, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %224) #9
  store i32 0, ptr %224, align 4, !tbaa !9
  br label %2207

2207:                                             ; preds = %2233, %2192
  %2208 = load i32, ptr %224, align 4, !tbaa !9
  %2209 = load i32, ptr %11, align 4, !tbaa !9
  %2210 = icmp ult i32 %2208, %2209
  br i1 %2210, label %2212, label %2211

2211:                                             ; preds = %2207
  store i32 115, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %224) #9
  br label %2236

2212:                                             ; preds = %2207
  call void @llvm.lifetime.start.p0(i64 8, ptr %225) #9
  store ptr %1598, ptr %225, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %226) #9
  %2213 = load i64, ptr %222, align 8, !tbaa !12
  %2214 = load ptr, ptr %223, align 8, !tbaa !5
  %2215 = load i32, ptr %224, align 4, !tbaa !9
  %2216 = zext i32 %2215 to i64
  %2217 = getelementptr inbounds i64, ptr %2214, i64 %2216
  %2218 = load i64, ptr %2217, align 8, !tbaa !12
  %2219 = and i64 %2213, %2218
  %2220 = load i64, ptr %222, align 8, !tbaa !12
  %2221 = xor i64 %2220, -1
  %2222 = load i32, ptr %224, align 4, !tbaa !9
  %2223 = zext i32 %2222 to i64
  %2224 = getelementptr inbounds i64, ptr %1598, i64 %2223
  %2225 = load i64, ptr %2224, align 8, !tbaa !12
  %2226 = and i64 %2221, %2225
  %2227 = or i64 %2219, %2226
  store i64 %2227, ptr %226, align 8, !tbaa !12
  %2228 = load i64, ptr %226, align 8, !tbaa !12
  %2229 = load ptr, ptr %225, align 8, !tbaa !5
  %2230 = load i32, ptr %224, align 4, !tbaa !9
  %2231 = zext i32 %2230 to i64
  %2232 = getelementptr inbounds i64, ptr %2229, i64 %2231
  store i64 %2228, ptr %2232, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %226) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %225) #9
  br label %2233

2233:                                             ; preds = %2212
  %2234 = load i32, ptr %224, align 4, !tbaa !9
  %2235 = add i32 %2234, 1
  store i32 %2235, ptr %224, align 4, !tbaa !9
  br label %2207, !llvm.loop !50

2236:                                             ; preds = %2211
  %2237 = load i32, ptr %161, align 4, !tbaa !9
  %2238 = add i32 %2237, 1
  store i32 %2238, ptr %161, align 4, !tbaa !9
  %2239 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %223) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %222) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %227) #9
  %2240 = load i64, ptr %160, align 8, !tbaa !12
  %2241 = load i32, ptr %161, align 4, !tbaa !9
  %2242 = add i32 %2241, 1
  %2243 = zext i32 %2242 to i64
  %2244 = call i64 @FStar_UInt64_eq_mask(i64 noundef %2240, i64 noundef %2243)
  store i64 %2244, ptr %227, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %228) #9
  %2245 = load i32, ptr %161, align 4, !tbaa !9
  %2246 = add i32 %2245, 1
  %2247 = load i32, ptr %11, align 4, !tbaa !9
  %2248 = mul i32 %2246, %2247
  %2249 = zext i32 %2248 to i64
  %2250 = getelementptr inbounds i64, ptr %503, i64 %2249
  store ptr %2250, ptr %228, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %229) #9
  store i32 0, ptr %229, align 4, !tbaa !9
  br label %2251

2251:                                             ; preds = %2277, %2236
  %2252 = load i32, ptr %229, align 4, !tbaa !9
  %2253 = load i32, ptr %11, align 4, !tbaa !9
  %2254 = icmp ult i32 %2252, %2253
  br i1 %2254, label %2256, label %2255

2255:                                             ; preds = %2251
  store i32 118, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %229) #9
  br label %2280

2256:                                             ; preds = %2251
  call void @llvm.lifetime.start.p0(i64 8, ptr %230) #9
  store ptr %1598, ptr %230, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %231) #9
  %2257 = load i64, ptr %227, align 8, !tbaa !12
  %2258 = load ptr, ptr %228, align 8, !tbaa !5
  %2259 = load i32, ptr %229, align 4, !tbaa !9
  %2260 = zext i32 %2259 to i64
  %2261 = getelementptr inbounds i64, ptr %2258, i64 %2260
  %2262 = load i64, ptr %2261, align 8, !tbaa !12
  %2263 = and i64 %2257, %2262
  %2264 = load i64, ptr %227, align 8, !tbaa !12
  %2265 = xor i64 %2264, -1
  %2266 = load i32, ptr %229, align 4, !tbaa !9
  %2267 = zext i32 %2266 to i64
  %2268 = getelementptr inbounds i64, ptr %1598, i64 %2267
  %2269 = load i64, ptr %2268, align 8, !tbaa !12
  %2270 = and i64 %2265, %2269
  %2271 = or i64 %2263, %2270
  store i64 %2271, ptr %231, align 8, !tbaa !12
  %2272 = load i64, ptr %231, align 8, !tbaa !12
  %2273 = load ptr, ptr %230, align 8, !tbaa !5
  %2274 = load i32, ptr %229, align 4, !tbaa !9
  %2275 = zext i32 %2274 to i64
  %2276 = getelementptr inbounds i64, ptr %2273, i64 %2275
  store i64 %2272, ptr %2276, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %231) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %230) #9
  br label %2277

2277:                                             ; preds = %2256
  %2278 = load i32, ptr %229, align 4, !tbaa !9
  %2279 = add i32 %2278, 1
  store i32 %2279, ptr %229, align 4, !tbaa !9
  br label %2251, !llvm.loop !51

2280:                                             ; preds = %2255
  %2281 = load i32, ptr %161, align 4, !tbaa !9
  %2282 = add i32 %2281, 1
  store i32 %2282, ptr %161, align 4, !tbaa !9
  %2283 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %228) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %227) #9
  call void @llvm.lifetime.start.p0(i64 8, ptr %232) #9
  %2284 = load i64, ptr %160, align 8, !tbaa !12
  %2285 = load i32, ptr %161, align 4, !tbaa !9
  %2286 = add i32 %2285, 1
  %2287 = zext i32 %2286 to i64
  %2288 = call i64 @FStar_UInt64_eq_mask(i64 noundef %2284, i64 noundef %2287)
  store i64 %2288, ptr %232, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %233) #9
  %2289 = load i32, ptr %161, align 4, !tbaa !9
  %2290 = add i32 %2289, 1
  %2291 = load i32, ptr %11, align 4, !tbaa !9
  %2292 = mul i32 %2290, %2291
  %2293 = zext i32 %2292 to i64
  %2294 = getelementptr inbounds i64, ptr %503, i64 %2293
  store ptr %2294, ptr %233, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %234) #9
  store i32 0, ptr %234, align 4, !tbaa !9
  br label %2295

2295:                                             ; preds = %2321, %2280
  %2296 = load i32, ptr %234, align 4, !tbaa !9
  %2297 = load i32, ptr %11, align 4, !tbaa !9
  %2298 = icmp ult i32 %2296, %2297
  br i1 %2298, label %2300, label %2299

2299:                                             ; preds = %2295
  store i32 121, ptr %21, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %234) #9
  br label %2324

2300:                                             ; preds = %2295
  call void @llvm.lifetime.start.p0(i64 8, ptr %235) #9
  store ptr %1598, ptr %235, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %236) #9
  %2301 = load i64, ptr %232, align 8, !tbaa !12
  %2302 = load ptr, ptr %233, align 8, !tbaa !5
  %2303 = load i32, ptr %234, align 4, !tbaa !9
  %2304 = zext i32 %2303 to i64
  %2305 = getelementptr inbounds i64, ptr %2302, i64 %2304
  %2306 = load i64, ptr %2305, align 8, !tbaa !12
  %2307 = and i64 %2301, %2306
  %2308 = load i64, ptr %232, align 8, !tbaa !12
  %2309 = xor i64 %2308, -1
  %2310 = load i32, ptr %234, align 4, !tbaa !9
  %2311 = zext i32 %2310 to i64
  %2312 = getelementptr inbounds i64, ptr %1598, i64 %2311
  %2313 = load i64, ptr %2312, align 8, !tbaa !12
  %2314 = and i64 %2309, %2313
  %2315 = or i64 %2307, %2314
  store i64 %2315, ptr %236, align 8, !tbaa !12
  %2316 = load i64, ptr %236, align 8, !tbaa !12
  %2317 = load ptr, ptr %235, align 8, !tbaa !5
  %2318 = load i32, ptr %234, align 4, !tbaa !9
  %2319 = zext i32 %2318 to i64
  %2320 = getelementptr inbounds i64, ptr %2317, i64 %2319
  store i64 %2316, ptr %2320, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 8, ptr %236) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %235) #9
  br label %2321

2321:                                             ; preds = %2300
  %2322 = load i32, ptr %234, align 4, !tbaa !9
  %2323 = add i32 %2322, 1
  store i32 %2323, ptr %234, align 4, !tbaa !9
  br label %2295, !llvm.loop !52

2324:                                             ; preds = %2299
  %2325 = load i32, ptr %161, align 4, !tbaa !9
  %2326 = add i32 %2325, 1
  store i32 %2326, ptr %161, align 4, !tbaa !9
  %2327 = load i32, ptr %161, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %233) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %232) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %161) #9
  br label %2328

2328:                                             ; preds = %2324
  br label %2329

2329:                                             ; preds = %2328
  call void @llvm.lifetime.start.p0(i64 8, ptr %237) #9
  store ptr %471, ptr %237, align 8, !tbaa !5
  %2330 = load i32, ptr %11, align 4, !tbaa !9
  %2331 = load ptr, ptr %237, align 8, !tbaa !5
  %2332 = getelementptr inbounds %struct.Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s, ptr %12, i32 0, i32 2
  %2333 = load i64, ptr %2332, align 8, !tbaa !18
  %2334 = load ptr, ptr %10, align 8, !tbaa !5
  %2335 = load ptr, ptr %10, align 8, !tbaa !5
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %2330, ptr noundef %2331, i64 noundef %2333, ptr noundef %2334, ptr noundef %1598, ptr noundef %2335)
  call void @llvm.lifetime.end.p0(i64 8, ptr %237) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %160) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %159) #9
  br label %2336

2336:                                             ; preds = %2329
  %2337 = load i32, ptr %153, align 4, !tbaa !9
  %2338 = add i32 %2337, 1
  store i32 %2338, ptr %153, align 4, !tbaa !9
  br label %1602, !llvm.loop !53

2339:                                             ; preds = %1607
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #9
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #9
  %2340 = load ptr, ptr %35, align 8
  call void @llvm.stackrestore.p0(ptr %2340)
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #9
  br label %2341

2341:                                             ; preds = %2339, %443
  %2342 = load ptr, ptr %13, align 8
  call void @llvm.stackrestore.p0(ptr %2342)
  call void @llvm.lifetime.end.p0(i64 32, ptr %12) #9
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #9
  ret void
}

; Function Attrs: nocallback nofree nosync nounwind willreturn
declare ptr @llvm.stacksave.p0() #5

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

; Function Attrs: nocallback nofree nosync nounwind willreturn
declare void @llvm.stackrestore.p0(ptr) #5

; Function Attrs: inlinehint nounwind uwtable
declare hidden i64 @Hacl_Bignum_Lib_bn_get_bits_u64(i32 noundef, ptr noundef, i32 noundef, i32 noundef) #7

; Function Attrs: noinline nounwind uwtable
declare hidden i64 @FStar_UInt64_eq_mask(i64 noundef, i64 noundef) #8

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"int", !7, i64 0}
!11 = !{i64 0, i64 4, !9, i64 8, i64 8, !5, i64 16, i64 8, !12, i64 24, i64 8, !5}
!12 = !{!13, !13, i64 0}
!13 = !{!"long", !7, i64 0}
!14 = !{!15, !10, i64 0}
!15 = !{!"Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s", !10, i64 0, !6, i64 8, !13, i64 16, !6, i64 24}
!16 = !{!15, !6, i64 8}
!17 = !{!15, !6, i64 24}
!18 = !{!15, !13, i64 16}
!19 = distinct !{!19, !20}
!20 = !{!"llvm.loop.mustprogress"}
!21 = distinct !{!21, !20}
!22 = distinct !{!22, !20}
!23 = distinct !{!23, !20}
!24 = distinct !{!24, !20}
!25 = distinct !{!25, !20}
!26 = distinct !{!26, !20}
!27 = distinct !{!27, !20}
!28 = distinct !{!28, !20}
!29 = distinct !{!29, !20}
!30 = distinct !{!30, !20}
!31 = distinct !{!31, !20}
!32 = distinct !{!32, !20}
!33 = distinct !{!33, !20}
!34 = distinct !{!34, !20}
!35 = distinct !{!35, !20}
!36 = distinct !{!36, !20}
!37 = distinct !{!37, !20}
!38 = distinct !{!38, !20}
!39 = distinct !{!39, !20}
!40 = distinct !{!40, !20}
!41 = distinct !{!41, !20}
!42 = distinct !{!42, !20}
!43 = distinct !{!43, !20}
!44 = distinct !{!44, !20}
!45 = distinct !{!45, !20}
!46 = distinct !{!46, !20}
!47 = distinct !{!47, !20}
!48 = distinct !{!48, !20}
!49 = distinct !{!49, !20}
!50 = distinct !{!50, !20}
!51 = distinct !{!51, !20}
!52 = distinct !{!52, !20}
!53 = distinct !{!53, !20}


; 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"

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

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

declare void @Hacl_Bignum_Montgomery_bn_from_mont_u64(i32 noundef, ptr noundef, i64 noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef, ptr noundef, i64 noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef, ptr noundef, i64 noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
define dso_local void @Hacl_GenericField64_exp_consttime(ptr noundef %0, ptr nocapture noundef readonly %1, i32 noundef %2, ptr noundef %3, ptr noundef %4) local_unnamed_addr #1 {
  %6 = tail call i32 @Hacl_GenericField64_field_get_len(ptr noundef %0)
  %.sroa.7588.0..sroa_idx = getelementptr inbounds i8, ptr %0, i64 8
  %.sroa.7588.0.copyload = load ptr, ptr %.sroa.7588.0..sroa_idx, align 8, !tbaa !5
  %.sroa.9.0..sroa_idx = getelementptr inbounds i8, ptr %0, i64 16
  %.sroa.9.0.copyload = load i64, ptr %.sroa.9.0..sroa_idx, align 8, !tbaa !9
  %.sroa.33.0..sroa_idx = getelementptr inbounds i8, ptr %0, i64 24
  %.sroa.33.0.copyload = load ptr, ptr %.sroa.33.0..sroa_idx, align 8, !tbaa !5
  %.sroa.0.0.copyload = load i32, ptr %0, align 8, !tbaa !11
  %7 = zext i32 %.sroa.0.0.copyload to i64
  %8 = alloca i64, i64 %7, align 16
  %9 = shl nuw nsw i64 %7, 3
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 16 %8, ptr align 8 %1, i64 %9, i1 false)
  %10 = icmp ult i32 %2, 200
  br i1 %10, label %11, label %76

11:                                               ; preds = %5
  %12 = shl i32 %6, 1
  %13 = zext i32 %12 to i64
  %14 = alloca i64, i64 %13, align 16
  %15 = shl nuw nsw i64 %13, 3
  call void @llvm.memset.p0.i64(ptr nonnull align 16 %14, i8 0, i64 %15, i1 false)
  %16 = zext i32 %6 to i64
  %17 = shl nuw nsw i64 %16, 3
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 16 %14, ptr align 8 %.sroa.7588.0.copyload, i64 %17, i1 false)
  %18 = getelementptr inbounds i64, ptr %14, i64 %16
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 8 %18, ptr align 8 %.sroa.33.0.copyload, i64 %17, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_from_mont_u64(i32 noundef %6, ptr noundef nonnull %14, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %18, ptr noundef %4) #7
  %.not1047 = icmp eq i32 %2, 0
  br i1 %.not1047, label %.preheader, label %.lr.ph1011

.lr.ph1011:                                       ; preds = %11
  %.not1048 = icmp eq i32 %6, 0
  %min.iters.check1767 = icmp ult i32 %6, 4
  %n.vec1770 = and i64 %16, 4294967292
  %cmp.n1781 = icmp eq i64 %n.vec1770, %16
  br label %33

.preheader:                                       ; preds = %._crit_edge1007, %11
  %.0.lcssa = phi i64 [ 0, %11 ], [ %43, %._crit_edge1007 ]
  %.not1049 = icmp eq i32 %6, 0
  br i1 %.not1049, label %._crit_edge1014, label %.lr.ph1013

.lr.ph1013:                                       ; preds = %.preheader
  %19 = sub nsw i64 0, %.0.lcssa
  %min.iters.check1784 = icmp ult i32 %6, 4
  br i1 %min.iters.check1784, label %scalar.ph1783.preheader, label %vector.ph1785

scalar.ph1783.preheader:                          ; preds = %middle.block1782, %.lr.ph1013
  %indvars.iv1203.ph = phi i64 [ 0, %.lr.ph1013 ], [ %n.vec1787, %middle.block1782 ]
  br label %scalar.ph1783

vector.ph1785:                                    ; preds = %.lr.ph1013
  %n.vec1787 = and i64 %16, 4294967292
  %broadcast.splatinsert1795 = insertelement <2 x i64> poison, i64 %19, i64 0
  %broadcast.splat1796 = shufflevector <2 x i64> %broadcast.splatinsert1795, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1789

vector.body1789:                                  ; preds = %vector.body1789, %vector.ph1785
  %index1790 = phi i64 [ 0, %vector.ph1785 ], [ %index.next1797, %vector.body1789 ]
  %20 = getelementptr inbounds i64, ptr %4, i64 %index1790
  %21 = getelementptr inbounds i8, ptr %20, i64 16
  %wide.load1791 = load <2 x i64>, ptr %20, align 8, !tbaa !9
  %wide.load1792 = load <2 x i64>, ptr %21, align 8, !tbaa !9
  %22 = getelementptr inbounds i64, ptr %8, i64 %index1790
  %23 = getelementptr inbounds i8, ptr %22, i64 16
  %wide.load1793 = load <2 x i64>, ptr %22, align 16, !tbaa !9
  %wide.load1794 = load <2 x i64>, ptr %23, align 16, !tbaa !9
  %24 = xor <2 x i64> %wide.load1793, %wide.load1791
  %25 = xor <2 x i64> %wide.load1794, %wide.load1792
  %26 = and <2 x i64> %24, %broadcast.splat1796
  %27 = and <2 x i64> %25, %broadcast.splat1796
  %28 = xor <2 x i64> %26, %wide.load1791
  %29 = xor <2 x i64> %27, %wide.load1792
  store <2 x i64> %28, ptr %20, align 8, !tbaa !9
  store <2 x i64> %29, ptr %21, align 8, !tbaa !9
  %30 = xor <2 x i64> %26, %wide.load1793
  %31 = xor <2 x i64> %27, %wide.load1794
  store <2 x i64> %30, ptr %22, align 16, !tbaa !9
  store <2 x i64> %31, ptr %23, align 16, !tbaa !9
  %index.next1797 = add nuw i64 %index1790, 4
  %32 = icmp eq i64 %index.next1797, %n.vec1787
  br i1 %32, label %middle.block1782, label %vector.body1789, !llvm.loop !13

middle.block1782:                                 ; preds = %vector.body1789
  %cmp.n1798 = icmp eq i64 %n.vec1787, %16
  br i1 %cmp.n1798, label %._crit_edge1014, label %scalar.ph1783.preheader

33:                                               ; preds = %.lr.ph1011, %._crit_edge1007
  %.01009 = phi i64 [ 0, %.lr.ph1011 ], [ %43, %._crit_edge1007 ]
  %.08471008 = phi i32 [ 0, %.lr.ph1011 ], [ %59, %._crit_edge1007 ]
  %34 = xor i32 %.08471008, -1
  %35 = add nsw i32 %34, %2
  %36 = lshr i32 %35, 6
  %37 = and i32 %35, 63
  %38 = zext nneg i32 %36 to i64
  %39 = getelementptr inbounds i64, ptr %3, i64 %38
  %40 = load i64, ptr %39, align 8, !tbaa !9
  %41 = zext nneg i32 %37 to i64
  %42 = lshr i64 %40, %41
  %43 = and i64 %42, 1
  br i1 %.not1048, label %._crit_edge1007, label %.lr.ph1006

.lr.ph1006:                                       ; preds = %33
  %44 = xor i64 %43, %.01009
  %45 = sub nsw i64 0, %44
  br i1 %min.iters.check1767, label %scalar.ph1766.preheader, label %vector.ph1768

scalar.ph1766.preheader:                          ; preds = %middle.block1765, %.lr.ph1006
  %indvars.iv1197.ph = phi i64 [ 0, %.lr.ph1006 ], [ %n.vec1770, %middle.block1765 ]
  br label %scalar.ph1766

vector.ph1768:                                    ; preds = %.lr.ph1006
  %broadcast.splatinsert1778 = insertelement <2 x i64> poison, i64 %45, i64 0
  %broadcast.splat1779 = shufflevector <2 x i64> %broadcast.splatinsert1778, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1772

vector.body1772:                                  ; preds = %vector.body1772, %vector.ph1768
  %index1773 = phi i64 [ 0, %vector.ph1768 ], [ %index.next1780, %vector.body1772 ]
  %46 = getelementptr inbounds i64, ptr %4, i64 %index1773
  %47 = getelementptr inbounds i8, ptr %46, i64 16
  %wide.load1774 = load <2 x i64>, ptr %46, align 8, !tbaa !9
  %wide.load1775 = load <2 x i64>, ptr %47, align 8, !tbaa !9
  %48 = getelementptr inbounds i64, ptr %8, i64 %index1773
  %49 = getelementptr inbounds i8, ptr %48, i64 16
  %wide.load1776 = load <2 x i64>, ptr %48, align 16, !tbaa !9
  %wide.load1777 = load <2 x i64>, ptr %49, align 16, !tbaa !9
  %50 = xor <2 x i64> %wide.load1776, %wide.load1774
  %51 = xor <2 x i64> %wide.load1777, %wide.load1775
  %52 = and <2 x i64> %50, %broadcast.splat1779
  %53 = and <2 x i64> %51, %broadcast.splat1779
  %54 = xor <2 x i64> %52, %wide.load1774
  %55 = xor <2 x i64> %53, %wide.load1775
  store <2 x i64> %54, ptr %46, align 8, !tbaa !9
  store <2 x i64> %55, ptr %47, align 8, !tbaa !9
  %56 = xor <2 x i64> %52, %wide.load1776
  %57 = xor <2 x i64> %53, %wide.load1777
  store <2 x i64> %56, ptr %48, align 16, !tbaa !9
  store <2 x i64> %57, ptr %49, align 16, !tbaa !9
  %index.next1780 = add nuw i64 %index1773, 4
  %58 = icmp eq i64 %index.next1780, %n.vec1770
  br i1 %58, label %middle.block1765, label %vector.body1772, !llvm.loop !17

middle.block1765:                                 ; preds = %vector.body1772
  br i1 %cmp.n1781, label %._crit_edge1007, label %scalar.ph1766.preheader

._crit_edge1007:                                  ; preds = %scalar.ph1766, %middle.block1765, %33
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %6, ptr noundef nonnull %14, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %8, ptr noundef %4, ptr noundef nonnull %8) #7
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %6, ptr noundef nonnull %14, i64 noundef %.sroa.9.0.copyload, ptr noundef %4, ptr noundef %4) #7
  %59 = add nuw i32 %.08471008, 1
  %exitcond1202.not = icmp eq i32 %59, %2
  br i1 %exitcond1202.not, label %.preheader, label %33, !llvm.loop !18

scalar.ph1766:                                    ; preds = %scalar.ph1766.preheader, %scalar.ph1766
  %indvars.iv1197 = phi i64 [ %indvars.iv.next1198, %scalar.ph1766 ], [ %indvars.iv1197.ph, %scalar.ph1766.preheader ]
  %60 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1197
  %61 = load i64, ptr %60, align 8, !tbaa !9
  %62 = getelementptr inbounds i64, ptr %8, i64 %indvars.iv1197
  %63 = load i64, ptr %62, align 8, !tbaa !9
  %64 = xor i64 %63, %61
  %65 = and i64 %64, %45
  %66 = xor i64 %65, %61
  store i64 %66, ptr %60, align 8, !tbaa !9
  %67 = xor i64 %65, %63
  store i64 %67, ptr %62, align 8, !tbaa !9
  %indvars.iv.next1198 = add nuw nsw i64 %indvars.iv1197, 1
  %exitcond1201.not = icmp eq i64 %indvars.iv.next1198, %16
  br i1 %exitcond1201.not, label %._crit_edge1007, label %scalar.ph1766, !llvm.loop !19

scalar.ph1783:                                    ; preds = %scalar.ph1783.preheader, %scalar.ph1783
  %indvars.iv1203 = phi i64 [ %indvars.iv.next1204, %scalar.ph1783 ], [ %indvars.iv1203.ph, %scalar.ph1783.preheader ]
  %68 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1203
  %69 = load i64, ptr %68, align 8, !tbaa !9
  %70 = getelementptr inbounds i64, ptr %8, i64 %indvars.iv1203
  %71 = load i64, ptr %70, align 8, !tbaa !9
  %72 = xor i64 %71, %69
  %73 = and i64 %72, %19
  %74 = xor i64 %73, %69
  store i64 %74, ptr %68, align 8, !tbaa !9
  %75 = xor i64 %73, %71
  store i64 %75, ptr %70, align 8, !tbaa !9
  %indvars.iv.next1204 = add nuw nsw i64 %indvars.iv1203, 1
  %exitcond1207.not = icmp eq i64 %indvars.iv.next1204, %16
  br i1 %exitcond1207.not, label %._crit_edge1014, label %scalar.ph1783, !llvm.loop !20

76:                                               ; preds = %5
  %77 = add i32 %2, -1
  %78 = lshr i32 %77, 6
  %79 = add nuw nsw i32 %78, 1
  %80 = shl i32 %6, 1
  %81 = zext i32 %80 to i64
  %82 = alloca i64, i64 %81, align 16
  %83 = shl nuw nsw i64 %81, 3
  call void @llvm.memset.p0.i64(ptr nonnull align 16 %82, i8 0, i64 %83, i1 false)
  %84 = zext i32 %6 to i64
  %85 = shl nuw nsw i64 %84, 3
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 16 %82, ptr align 8 %.sroa.7588.0.copyload, i64 %85, i1 false)
  %86 = getelementptr inbounds i64, ptr %82, i64 %84
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 8 %86, ptr align 8 %.sroa.33.0.copyload, i64 %85, i1 false)
  %87 = shl i32 %6, 4
  %88 = zext i32 %87 to i64
  %89 = alloca i64, i64 %88, align 16
  %90 = shl nuw nsw i64 %88, 3
  call void @llvm.memset.p0.i64(ptr nonnull align 16 %89, i8 0, i64 %90, i1 false)
  %91 = alloca i64, i64 %84, align 16
  call void @llvm.memset.p0.i64(ptr nonnull align 16 %91, i8 0, i64 %85, i1 false)
  %92 = getelementptr inbounds i64, ptr %89, i64 %84
  call void @Hacl_Bignum_Montgomery_bn_from_mont_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %86, ptr noundef nonnull %89) #7
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 8 %92, ptr nonnull align 16 %8, i64 %85, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %92, ptr noundef nonnull %91) #7
  %93 = getelementptr inbounds i64, ptr %89, i64 %81
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 16 %93, ptr nonnull align 16 %91, i64 %85, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %8, ptr noundef nonnull %93, ptr noundef nonnull %91) #7
  %94 = mul i32 %6, 3
  %95 = zext i32 %94 to i64
  %96 = getelementptr inbounds i64, ptr %89, i64 %95
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 8 %96, ptr nonnull align 16 %91, i64 %85, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %93, ptr noundef nonnull %91) #7
  %97 = shl i32 %6, 2
  %98 = zext i32 %97 to i64
  %99 = getelementptr inbounds i64, ptr %89, i64 %98
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 16 %99, ptr nonnull align 16 %91, i64 %85, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %8, ptr noundef nonnull %99, ptr noundef nonnull %91) #7
  %100 = mul i32 %6, 5
  %101 = zext i32 %100 to i64
  %102 = getelementptr inbounds i64, ptr %89, i64 %101
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 8 %102, ptr nonnull align 16 %91, i64 %85, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %96, ptr noundef nonnull %91) #7
  %103 = mul i32 %6, 6
  %104 = zext i32 %103 to i64
  %105 = getelementptr inbounds i64, ptr %89, i64 %104
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 16 %105, ptr nonnull align 16 %91, i64 %85, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %8, ptr noundef nonnull %105, ptr noundef nonnull %91) #7
  %106 = mul i32 %6, 7
  %107 = zext i32 %106 to i64
  %108 = getelementptr inbounds i64, ptr %89, i64 %107
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 8 %108, ptr nonnull align 16 %91, i64 %85, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %99, ptr noundef nonnull %91) #7
  %109 = shl i32 %6, 3
  %110 = zext i32 %109 to i64
  %111 = getelementptr inbounds i64, ptr %89, i64 %110
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 16 %111, ptr nonnull align 16 %91, i64 %85, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %8, ptr noundef nonnull %111, ptr noundef nonnull %91) #7
  %112 = mul i32 %6, 9
  %113 = zext i32 %112 to i64
  %114 = getelementptr inbounds i64, ptr %89, i64 %113
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 8 %114, ptr nonnull align 16 %91, i64 %85, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %102, ptr noundef nonnull %91) #7
  %115 = mul i32 %6, 10
  %116 = zext i32 %115 to i64
  %117 = getelementptr inbounds i64, ptr %89, i64 %116
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 16 %117, ptr nonnull align 16 %91, i64 %85, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %8, ptr noundef nonnull %117, ptr noundef nonnull %91) #7
  %118 = mul i32 %6, 11
  %119 = zext i32 %118 to i64
  %120 = getelementptr inbounds i64, ptr %89, i64 %119
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 8 %120, ptr nonnull align 16 %91, i64 %85, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %105, ptr noundef nonnull %91) #7
  %121 = mul i32 %6, 12
  %122 = zext i32 %121 to i64
  %123 = getelementptr inbounds i64, ptr %89, i64 %122
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 16 %123, ptr nonnull align 16 %91, i64 %85, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %8, ptr noundef nonnull %123, ptr noundef nonnull %91) #7
  %124 = mul i32 %6, 13
  %125 = zext i32 %124 to i64
  %126 = getelementptr inbounds i64, ptr %89, i64 %125
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 8 %126, ptr nonnull align 16 %91, i64 %85, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %108, ptr noundef nonnull %91) #7
  %127 = mul i32 %6, 14
  %128 = zext i32 %127 to i64
  %129 = getelementptr inbounds i64, ptr %89, i64 %128
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 16 %129, ptr nonnull align 16 %91, i64 %85, i1 false)
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %8, ptr noundef nonnull %129, ptr noundef nonnull %91) #7
  %130 = mul i32 %6, 15
  %131 = zext i32 %130 to i64
  %132 = getelementptr inbounds i64, ptr %89, i64 %131
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 8 %132, ptr nonnull align 16 %91, i64 %85, i1 false)
  %133 = and i32 %2, 3
  %.not = icmp eq i32 %133, 0
  br i1 %.not, label %451, label %134

134:                                              ; preds = %76
  %135 = and i32 %2, -4
  %136 = call i64 @Hacl_Bignum_Lib_bn_get_bits_u64(i32 noundef %79, ptr noundef %3, i32 noundef %135, i32 noundef 4)
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %4, ptr nonnull align 16 %89, i64 %85, i1 false)
  %137 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 1)
  %.not1015 = icmp eq i32 %6, 0
  br i1 %.not1015, label %._crit_edge.thread, label %.lr.ph

._crit_edge.thread:                               ; preds = %134
  %138 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 2)
  br label %._crit_edge888.thread

.lr.ph:                                           ; preds = %134
  %139 = xor i64 %137, -1
  %min.iters.check = icmp ult i32 %6, 4
  br i1 %min.iters.check, label %scalar.ph.preheader, label %vector.ph

scalar.ph.preheader:                              ; preds = %middle.block, %.lr.ph
  %indvars.iv.ph = phi i64 [ 0, %.lr.ph ], [ %n.vec, %middle.block ]
  br label %scalar.ph

vector.ph:                                        ; preds = %.lr.ph
  %n.vec = and i64 %84, 4294967292
  %broadcast.splatinsert = insertelement <2 x i64> poison, i64 %137, i64 0
  %broadcast.splat = shufflevector <2 x i64> %broadcast.splatinsert, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1212 = insertelement <2 x i64> poison, i64 %139, i64 0
  %broadcast.splat1213 = shufflevector <2 x i64> %broadcast.splatinsert1212, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %140 = getelementptr inbounds i64, ptr %92, i64 %index
  %141 = getelementptr inbounds i8, ptr %140, i64 16
  %wide.load = load <2 x i64>, ptr %140, align 8, !tbaa !9
  %wide.load1209 = load <2 x i64>, ptr %141, align 8, !tbaa !9
  %142 = and <2 x i64> %wide.load, %broadcast.splat
  %143 = and <2 x i64> %wide.load1209, %broadcast.splat
  %144 = getelementptr inbounds i64, ptr %4, i64 %index
  %145 = getelementptr inbounds i8, ptr %144, i64 16
  %wide.load1210 = load <2 x i64>, ptr %144, align 8, !tbaa !9
  %wide.load1211 = load <2 x i64>, ptr %145, align 8, !tbaa !9
  %146 = and <2 x i64> %wide.load1210, %broadcast.splat1213
  %147 = and <2 x i64> %wide.load1211, %broadcast.splat1213
  %148 = or <2 x i64> %146, %142
  %149 = or <2 x i64> %147, %143
  store <2 x i64> %148, ptr %144, align 8, !tbaa !9
  store <2 x i64> %149, ptr %145, align 8, !tbaa !9
  %index.next = add nuw i64 %index, 4
  %150 = icmp eq i64 %index.next, %n.vec
  br i1 %150, label %middle.block, label %vector.body, !llvm.loop !21

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %n.vec, %84
  br i1 %cmp.n, label %._crit_edge, label %scalar.ph.preheader

._crit_edge:                                      ; preds = %scalar.ph, %middle.block
  %151 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 2)
  br i1 %.not1015, label %._crit_edge888.thread, label %.lr.ph887

.lr.ph887:                                        ; preds = %._crit_edge
  %152 = xor i64 %151, -1
  %min.iters.check1216 = icmp ult i32 %6, 4
  br i1 %min.iters.check1216, label %scalar.ph1215.preheader, label %vector.ph1217

scalar.ph1215.preheader:                          ; preds = %middle.block1214, %.lr.ph887
  %indvars.iv1051.ph = phi i64 [ 0, %.lr.ph887 ], [ %n.vec1219, %middle.block1214 ]
  br label %scalar.ph1215

vector.ph1217:                                    ; preds = %.lr.ph887
  %n.vec1219 = and i64 %84, 4294967292
  %broadcast.splatinsert1225 = insertelement <2 x i64> poison, i64 %151, i64 0
  %broadcast.splat1226 = shufflevector <2 x i64> %broadcast.splatinsert1225, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1229 = insertelement <2 x i64> poison, i64 %152, i64 0
  %broadcast.splat1230 = shufflevector <2 x i64> %broadcast.splatinsert1229, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1221

vector.body1221:                                  ; preds = %vector.body1221, %vector.ph1217
  %index1222 = phi i64 [ 0, %vector.ph1217 ], [ %index.next1231, %vector.body1221 ]
  %153 = getelementptr inbounds i64, ptr %93, i64 %index1222
  %154 = getelementptr inbounds i8, ptr %153, i64 16
  %wide.load1223 = load <2 x i64>, ptr %153, align 16, !tbaa !9
  %wide.load1224 = load <2 x i64>, ptr %154, align 16, !tbaa !9
  %155 = and <2 x i64> %wide.load1223, %broadcast.splat1226
  %156 = and <2 x i64> %wide.load1224, %broadcast.splat1226
  %157 = getelementptr inbounds i64, ptr %4, i64 %index1222
  %158 = getelementptr inbounds i8, ptr %157, i64 16
  %wide.load1227 = load <2 x i64>, ptr %157, align 8, !tbaa !9
  %wide.load1228 = load <2 x i64>, ptr %158, align 8, !tbaa !9
  %159 = and <2 x i64> %wide.load1227, %broadcast.splat1230
  %160 = and <2 x i64> %wide.load1228, %broadcast.splat1230
  %161 = or <2 x i64> %159, %155
  %162 = or <2 x i64> %160, %156
  store <2 x i64> %161, ptr %157, align 8, !tbaa !9
  store <2 x i64> %162, ptr %158, align 8, !tbaa !9
  %index.next1231 = add nuw i64 %index1222, 4
  %163 = icmp eq i64 %index.next1231, %n.vec1219
  br i1 %163, label %middle.block1214, label %vector.body1221, !llvm.loop !22

middle.block1214:                                 ; preds = %vector.body1221
  %cmp.n1232 = icmp eq i64 %n.vec1219, %84
  br i1 %cmp.n1232, label %._crit_edge888, label %scalar.ph1215.preheader

scalar.ph:                                        ; preds = %scalar.ph.preheader, %scalar.ph
  %indvars.iv = phi i64 [ %indvars.iv.next, %scalar.ph ], [ %indvars.iv.ph, %scalar.ph.preheader ]
  %164 = getelementptr inbounds i64, ptr %92, i64 %indvars.iv
  %165 = load i64, ptr %164, align 8, !tbaa !9
  %166 = and i64 %165, %137
  %167 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv
  %168 = load i64, ptr %167, align 8, !tbaa !9
  %169 = and i64 %168, %139
  %170 = or i64 %169, %166
  store i64 %170, ptr %167, align 8, !tbaa !9
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %84
  br i1 %exitcond.not, label %._crit_edge, label %scalar.ph, !llvm.loop !23

._crit_edge888.thread:                            ; preds = %._crit_edge.thread, %._crit_edge
  %171 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 3)
  br label %._crit_edge892.thread

._crit_edge888:                                   ; preds = %scalar.ph1215, %middle.block1214
  %172 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 3)
  br i1 %.not1015, label %._crit_edge892.thread, label %.lr.ph891

.lr.ph891:                                        ; preds = %._crit_edge888
  %173 = xor i64 %172, -1
  %min.iters.check1235 = icmp ult i32 %6, 4
  br i1 %min.iters.check1235, label %scalar.ph1234.preheader, label %vector.ph1236

scalar.ph1234.preheader:                          ; preds = %middle.block1233, %.lr.ph891
  %indvars.iv1056.ph = phi i64 [ 0, %.lr.ph891 ], [ %n.vec1238, %middle.block1233 ]
  br label %scalar.ph1234

vector.ph1236:                                    ; preds = %.lr.ph891
  %n.vec1238 = and i64 %84, 4294967292
  %broadcast.splatinsert1244 = insertelement <2 x i64> poison, i64 %172, i64 0
  %broadcast.splat1245 = shufflevector <2 x i64> %broadcast.splatinsert1244, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1248 = insertelement <2 x i64> poison, i64 %173, i64 0
  %broadcast.splat1249 = shufflevector <2 x i64> %broadcast.splatinsert1248, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1240

vector.body1240:                                  ; preds = %vector.body1240, %vector.ph1236
  %index1241 = phi i64 [ 0, %vector.ph1236 ], [ %index.next1250, %vector.body1240 ]
  %174 = getelementptr inbounds i64, ptr %96, i64 %index1241
  %175 = getelementptr inbounds i8, ptr %174, i64 16
  %wide.load1242 = load <2 x i64>, ptr %174, align 8, !tbaa !9
  %wide.load1243 = load <2 x i64>, ptr %175, align 8, !tbaa !9
  %176 = and <2 x i64> %wide.load1242, %broadcast.splat1245
  %177 = and <2 x i64> %wide.load1243, %broadcast.splat1245
  %178 = getelementptr inbounds i64, ptr %4, i64 %index1241
  %179 = getelementptr inbounds i8, ptr %178, i64 16
  %wide.load1246 = load <2 x i64>, ptr %178, align 8, !tbaa !9
  %wide.load1247 = load <2 x i64>, ptr %179, align 8, !tbaa !9
  %180 = and <2 x i64> %wide.load1246, %broadcast.splat1249
  %181 = and <2 x i64> %wide.load1247, %broadcast.splat1249
  %182 = or <2 x i64> %180, %176
  %183 = or <2 x i64> %181, %177
  store <2 x i64> %182, ptr %178, align 8, !tbaa !9
  store <2 x i64> %183, ptr %179, align 8, !tbaa !9
  %index.next1250 = add nuw i64 %index1241, 4
  %184 = icmp eq i64 %index.next1250, %n.vec1238
  br i1 %184, label %middle.block1233, label %vector.body1240, !llvm.loop !24

middle.block1233:                                 ; preds = %vector.body1240
  %cmp.n1251 = icmp eq i64 %n.vec1238, %84
  br i1 %cmp.n1251, label %._crit_edge892, label %scalar.ph1234.preheader

scalar.ph1215:                                    ; preds = %scalar.ph1215.preheader, %scalar.ph1215
  %indvars.iv1051 = phi i64 [ %indvars.iv.next1052, %scalar.ph1215 ], [ %indvars.iv1051.ph, %scalar.ph1215.preheader ]
  %185 = getelementptr inbounds i64, ptr %93, i64 %indvars.iv1051
  %186 = load i64, ptr %185, align 8, !tbaa !9
  %187 = and i64 %186, %151
  %188 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1051
  %189 = load i64, ptr %188, align 8, !tbaa !9
  %190 = and i64 %189, %152
  %191 = or i64 %190, %187
  store i64 %191, ptr %188, align 8, !tbaa !9
  %indvars.iv.next1052 = add nuw nsw i64 %indvars.iv1051, 1
  %exitcond1055.not = icmp eq i64 %indvars.iv.next1052, %84
  br i1 %exitcond1055.not, label %._crit_edge888, label %scalar.ph1215, !llvm.loop !25

._crit_edge892.thread:                            ; preds = %._crit_edge888.thread, %._crit_edge888
  %192 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 4)
  br label %._crit_edge896.thread

._crit_edge892:                                   ; preds = %scalar.ph1234, %middle.block1233
  %193 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 4)
  br i1 %.not1015, label %._crit_edge896.thread, label %.lr.ph895

.lr.ph895:                                        ; preds = %._crit_edge892
  %194 = xor i64 %193, -1
  %min.iters.check1254 = icmp ult i32 %6, 4
  br i1 %min.iters.check1254, label %scalar.ph1253.preheader, label %vector.ph1255

scalar.ph1253.preheader:                          ; preds = %middle.block1252, %.lr.ph895
  %indvars.iv1061.ph = phi i64 [ 0, %.lr.ph895 ], [ %n.vec1257, %middle.block1252 ]
  br label %scalar.ph1253

vector.ph1255:                                    ; preds = %.lr.ph895
  %n.vec1257 = and i64 %84, 4294967292
  %broadcast.splatinsert1263 = insertelement <2 x i64> poison, i64 %193, i64 0
  %broadcast.splat1264 = shufflevector <2 x i64> %broadcast.splatinsert1263, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1267 = insertelement <2 x i64> poison, i64 %194, i64 0
  %broadcast.splat1268 = shufflevector <2 x i64> %broadcast.splatinsert1267, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1259

vector.body1259:                                  ; preds = %vector.body1259, %vector.ph1255
  %index1260 = phi i64 [ 0, %vector.ph1255 ], [ %index.next1269, %vector.body1259 ]
  %195 = getelementptr inbounds i64, ptr %99, i64 %index1260
  %196 = getelementptr inbounds i8, ptr %195, i64 16
  %wide.load1261 = load <2 x i64>, ptr %195, align 16, !tbaa !9
  %wide.load1262 = load <2 x i64>, ptr %196, align 16, !tbaa !9
  %197 = and <2 x i64> %wide.load1261, %broadcast.splat1264
  %198 = and <2 x i64> %wide.load1262, %broadcast.splat1264
  %199 = getelementptr inbounds i64, ptr %4, i64 %index1260
  %200 = getelementptr inbounds i8, ptr %199, i64 16
  %wide.load1265 = load <2 x i64>, ptr %199, align 8, !tbaa !9
  %wide.load1266 = load <2 x i64>, ptr %200, align 8, !tbaa !9
  %201 = and <2 x i64> %wide.load1265, %broadcast.splat1268
  %202 = and <2 x i64> %wide.load1266, %broadcast.splat1268
  %203 = or <2 x i64> %201, %197
  %204 = or <2 x i64> %202, %198
  store <2 x i64> %203, ptr %199, align 8, !tbaa !9
  store <2 x i64> %204, ptr %200, align 8, !tbaa !9
  %index.next1269 = add nuw i64 %index1260, 4
  %205 = icmp eq i64 %index.next1269, %n.vec1257
  br i1 %205, label %middle.block1252, label %vector.body1259, !llvm.loop !26

middle.block1252:                                 ; preds = %vector.body1259
  %cmp.n1270 = icmp eq i64 %n.vec1257, %84
  br i1 %cmp.n1270, label %._crit_edge896, label %scalar.ph1253.preheader

scalar.ph1234:                                    ; preds = %scalar.ph1234.preheader, %scalar.ph1234
  %indvars.iv1056 = phi i64 [ %indvars.iv.next1057, %scalar.ph1234 ], [ %indvars.iv1056.ph, %scalar.ph1234.preheader ]
  %206 = getelementptr inbounds i64, ptr %96, i64 %indvars.iv1056
  %207 = load i64, ptr %206, align 8, !tbaa !9
  %208 = and i64 %207, %172
  %209 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1056
  %210 = load i64, ptr %209, align 8, !tbaa !9
  %211 = and i64 %210, %173
  %212 = or i64 %211, %208
  store i64 %212, ptr %209, align 8, !tbaa !9
  %indvars.iv.next1057 = add nuw nsw i64 %indvars.iv1056, 1
  %exitcond1060.not = icmp eq i64 %indvars.iv.next1057, %84
  br i1 %exitcond1060.not, label %._crit_edge892, label %scalar.ph1234, !llvm.loop !27

._crit_edge896.thread:                            ; preds = %._crit_edge892.thread, %._crit_edge892
  %213 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 5)
  br label %._crit_edge900.thread

._crit_edge896:                                   ; preds = %scalar.ph1253, %middle.block1252
  %214 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 5)
  br i1 %.not1015, label %._crit_edge900.thread, label %.lr.ph899

.lr.ph899:                                        ; preds = %._crit_edge896
  %215 = xor i64 %214, -1
  %min.iters.check1273 = icmp ult i32 %6, 4
  br i1 %min.iters.check1273, label %scalar.ph1272.preheader, label %vector.ph1274

scalar.ph1272.preheader:                          ; preds = %middle.block1271, %.lr.ph899
  %indvars.iv1066.ph = phi i64 [ 0, %.lr.ph899 ], [ %n.vec1276, %middle.block1271 ]
  br label %scalar.ph1272

vector.ph1274:                                    ; preds = %.lr.ph899
  %n.vec1276 = and i64 %84, 4294967292
  %broadcast.splatinsert1282 = insertelement <2 x i64> poison, i64 %214, i64 0
  %broadcast.splat1283 = shufflevector <2 x i64> %broadcast.splatinsert1282, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1286 = insertelement <2 x i64> poison, i64 %215, i64 0
  %broadcast.splat1287 = shufflevector <2 x i64> %broadcast.splatinsert1286, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1278

vector.body1278:                                  ; preds = %vector.body1278, %vector.ph1274
  %index1279 = phi i64 [ 0, %vector.ph1274 ], [ %index.next1288, %vector.body1278 ]
  %216 = getelementptr inbounds i64, ptr %102, i64 %index1279
  %217 = getelementptr inbounds i8, ptr %216, i64 16
  %wide.load1280 = load <2 x i64>, ptr %216, align 8, !tbaa !9
  %wide.load1281 = load <2 x i64>, ptr %217, align 8, !tbaa !9
  %218 = and <2 x i64> %wide.load1280, %broadcast.splat1283
  %219 = and <2 x i64> %wide.load1281, %broadcast.splat1283
  %220 = getelementptr inbounds i64, ptr %4, i64 %index1279
  %221 = getelementptr inbounds i8, ptr %220, i64 16
  %wide.load1284 = load <2 x i64>, ptr %220, align 8, !tbaa !9
  %wide.load1285 = load <2 x i64>, ptr %221, align 8, !tbaa !9
  %222 = and <2 x i64> %wide.load1284, %broadcast.splat1287
  %223 = and <2 x i64> %wide.load1285, %broadcast.splat1287
  %224 = or <2 x i64> %222, %218
  %225 = or <2 x i64> %223, %219
  store <2 x i64> %224, ptr %220, align 8, !tbaa !9
  store <2 x i64> %225, ptr %221, align 8, !tbaa !9
  %index.next1288 = add nuw i64 %index1279, 4
  %226 = icmp eq i64 %index.next1288, %n.vec1276
  br i1 %226, label %middle.block1271, label %vector.body1278, !llvm.loop !28

middle.block1271:                                 ; preds = %vector.body1278
  %cmp.n1289 = icmp eq i64 %n.vec1276, %84
  br i1 %cmp.n1289, label %._crit_edge900, label %scalar.ph1272.preheader

scalar.ph1253:                                    ; preds = %scalar.ph1253.preheader, %scalar.ph1253
  %indvars.iv1061 = phi i64 [ %indvars.iv.next1062, %scalar.ph1253 ], [ %indvars.iv1061.ph, %scalar.ph1253.preheader ]
  %227 = getelementptr inbounds i64, ptr %99, i64 %indvars.iv1061
  %228 = load i64, ptr %227, align 8, !tbaa !9
  %229 = and i64 %228, %193
  %230 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1061
  %231 = load i64, ptr %230, align 8, !tbaa !9
  %232 = and i64 %231, %194
  %233 = or i64 %232, %229
  store i64 %233, ptr %230, align 8, !tbaa !9
  %indvars.iv.next1062 = add nuw nsw i64 %indvars.iv1061, 1
  %exitcond1065.not = icmp eq i64 %indvars.iv.next1062, %84
  br i1 %exitcond1065.not, label %._crit_edge896, label %scalar.ph1253, !llvm.loop !29

._crit_edge900.thread:                            ; preds = %._crit_edge896.thread, %._crit_edge896
  %234 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 6)
  br label %._crit_edge904.thread

._crit_edge900:                                   ; preds = %scalar.ph1272, %middle.block1271
  %235 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 6)
  br i1 %.not1015, label %._crit_edge904.thread, label %.lr.ph903

.lr.ph903:                                        ; preds = %._crit_edge900
  %236 = xor i64 %235, -1
  %min.iters.check1292 = icmp ult i32 %6, 4
  br i1 %min.iters.check1292, label %scalar.ph1291.preheader, label %vector.ph1293

scalar.ph1291.preheader:                          ; preds = %middle.block1290, %.lr.ph903
  %indvars.iv1071.ph = phi i64 [ 0, %.lr.ph903 ], [ %n.vec1295, %middle.block1290 ]
  br label %scalar.ph1291

vector.ph1293:                                    ; preds = %.lr.ph903
  %n.vec1295 = and i64 %84, 4294967292
  %broadcast.splatinsert1301 = insertelement <2 x i64> poison, i64 %235, i64 0
  %broadcast.splat1302 = shufflevector <2 x i64> %broadcast.splatinsert1301, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1305 = insertelement <2 x i64> poison, i64 %236, i64 0
  %broadcast.splat1306 = shufflevector <2 x i64> %broadcast.splatinsert1305, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1297

vector.body1297:                                  ; preds = %vector.body1297, %vector.ph1293
  %index1298 = phi i64 [ 0, %vector.ph1293 ], [ %index.next1307, %vector.body1297 ]
  %237 = getelementptr inbounds i64, ptr %105, i64 %index1298
  %238 = getelementptr inbounds i8, ptr %237, i64 16
  %wide.load1299 = load <2 x i64>, ptr %237, align 16, !tbaa !9
  %wide.load1300 = load <2 x i64>, ptr %238, align 16, !tbaa !9
  %239 = and <2 x i64> %wide.load1299, %broadcast.splat1302
  %240 = and <2 x i64> %wide.load1300, %broadcast.splat1302
  %241 = getelementptr inbounds i64, ptr %4, i64 %index1298
  %242 = getelementptr inbounds i8, ptr %241, i64 16
  %wide.load1303 = load <2 x i64>, ptr %241, align 8, !tbaa !9
  %wide.load1304 = load <2 x i64>, ptr %242, align 8, !tbaa !9
  %243 = and <2 x i64> %wide.load1303, %broadcast.splat1306
  %244 = and <2 x i64> %wide.load1304, %broadcast.splat1306
  %245 = or <2 x i64> %243, %239
  %246 = or <2 x i64> %244, %240
  store <2 x i64> %245, ptr %241, align 8, !tbaa !9
  store <2 x i64> %246, ptr %242, align 8, !tbaa !9
  %index.next1307 = add nuw i64 %index1298, 4
  %247 = icmp eq i64 %index.next1307, %n.vec1295
  br i1 %247, label %middle.block1290, label %vector.body1297, !llvm.loop !30

middle.block1290:                                 ; preds = %vector.body1297
  %cmp.n1308 = icmp eq i64 %n.vec1295, %84
  br i1 %cmp.n1308, label %._crit_edge904, label %scalar.ph1291.preheader

scalar.ph1272:                                    ; preds = %scalar.ph1272.preheader, %scalar.ph1272
  %indvars.iv1066 = phi i64 [ %indvars.iv.next1067, %scalar.ph1272 ], [ %indvars.iv1066.ph, %scalar.ph1272.preheader ]
  %248 = getelementptr inbounds i64, ptr %102, i64 %indvars.iv1066
  %249 = load i64, ptr %248, align 8, !tbaa !9
  %250 = and i64 %249, %214
  %251 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1066
  %252 = load i64, ptr %251, align 8, !tbaa !9
  %253 = and i64 %252, %215
  %254 = or i64 %253, %250
  store i64 %254, ptr %251, align 8, !tbaa !9
  %indvars.iv.next1067 = add nuw nsw i64 %indvars.iv1066, 1
  %exitcond1070.not = icmp eq i64 %indvars.iv.next1067, %84
  br i1 %exitcond1070.not, label %._crit_edge900, label %scalar.ph1272, !llvm.loop !31

._crit_edge904.thread:                            ; preds = %._crit_edge900.thread, %._crit_edge900
  %255 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 7)
  br label %._crit_edge908.thread

._crit_edge904:                                   ; preds = %scalar.ph1291, %middle.block1290
  %256 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 7)
  br i1 %.not1015, label %._crit_edge908.thread, label %.lr.ph907

.lr.ph907:                                        ; preds = %._crit_edge904
  %257 = xor i64 %256, -1
  %min.iters.check1311 = icmp ult i32 %6, 4
  br i1 %min.iters.check1311, label %scalar.ph1310.preheader, label %vector.ph1312

scalar.ph1310.preheader:                          ; preds = %middle.block1309, %.lr.ph907
  %indvars.iv1076.ph = phi i64 [ 0, %.lr.ph907 ], [ %n.vec1314, %middle.block1309 ]
  br label %scalar.ph1310

vector.ph1312:                                    ; preds = %.lr.ph907
  %n.vec1314 = and i64 %84, 4294967292
  %broadcast.splatinsert1320 = insertelement <2 x i64> poison, i64 %256, i64 0
  %broadcast.splat1321 = shufflevector <2 x i64> %broadcast.splatinsert1320, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1324 = insertelement <2 x i64> poison, i64 %257, i64 0
  %broadcast.splat1325 = shufflevector <2 x i64> %broadcast.splatinsert1324, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1316

vector.body1316:                                  ; preds = %vector.body1316, %vector.ph1312
  %index1317 = phi i64 [ 0, %vector.ph1312 ], [ %index.next1326, %vector.body1316 ]
  %258 = getelementptr inbounds i64, ptr %108, i64 %index1317
  %259 = getelementptr inbounds i8, ptr %258, i64 16
  %wide.load1318 = load <2 x i64>, ptr %258, align 8, !tbaa !9
  %wide.load1319 = load <2 x i64>, ptr %259, align 8, !tbaa !9
  %260 = and <2 x i64> %wide.load1318, %broadcast.splat1321
  %261 = and <2 x i64> %wide.load1319, %broadcast.splat1321
  %262 = getelementptr inbounds i64, ptr %4, i64 %index1317
  %263 = getelementptr inbounds i8, ptr %262, i64 16
  %wide.load1322 = load <2 x i64>, ptr %262, align 8, !tbaa !9
  %wide.load1323 = load <2 x i64>, ptr %263, align 8, !tbaa !9
  %264 = and <2 x i64> %wide.load1322, %broadcast.splat1325
  %265 = and <2 x i64> %wide.load1323, %broadcast.splat1325
  %266 = or <2 x i64> %264, %260
  %267 = or <2 x i64> %265, %261
  store <2 x i64> %266, ptr %262, align 8, !tbaa !9
  store <2 x i64> %267, ptr %263, align 8, !tbaa !9
  %index.next1326 = add nuw i64 %index1317, 4
  %268 = icmp eq i64 %index.next1326, %n.vec1314
  br i1 %268, label %middle.block1309, label %vector.body1316, !llvm.loop !32

middle.block1309:                                 ; preds = %vector.body1316
  %cmp.n1327 = icmp eq i64 %n.vec1314, %84
  br i1 %cmp.n1327, label %._crit_edge908, label %scalar.ph1310.preheader

scalar.ph1291:                                    ; preds = %scalar.ph1291.preheader, %scalar.ph1291
  %indvars.iv1071 = phi i64 [ %indvars.iv.next1072, %scalar.ph1291 ], [ %indvars.iv1071.ph, %scalar.ph1291.preheader ]
  %269 = getelementptr inbounds i64, ptr %105, i64 %indvars.iv1071
  %270 = load i64, ptr %269, align 8, !tbaa !9
  %271 = and i64 %270, %235
  %272 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1071
  %273 = load i64, ptr %272, align 8, !tbaa !9
  %274 = and i64 %273, %236
  %275 = or i64 %274, %271
  store i64 %275, ptr %272, align 8, !tbaa !9
  %indvars.iv.next1072 = add nuw nsw i64 %indvars.iv1071, 1
  %exitcond1075.not = icmp eq i64 %indvars.iv.next1072, %84
  br i1 %exitcond1075.not, label %._crit_edge904, label %scalar.ph1291, !llvm.loop !33

._crit_edge908.thread:                            ; preds = %._crit_edge904.thread, %._crit_edge904
  %276 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 8)
  br label %._crit_edge912.thread

._crit_edge908:                                   ; preds = %scalar.ph1310, %middle.block1309
  %277 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 8)
  br i1 %.not1015, label %._crit_edge912.thread, label %.lr.ph911

.lr.ph911:                                        ; preds = %._crit_edge908
  %278 = xor i64 %277, -1
  %min.iters.check1330 = icmp ult i32 %6, 4
  br i1 %min.iters.check1330, label %scalar.ph1329.preheader, label %vector.ph1331

scalar.ph1329.preheader:                          ; preds = %middle.block1328, %.lr.ph911
  %indvars.iv1081.ph = phi i64 [ 0, %.lr.ph911 ], [ %n.vec1333, %middle.block1328 ]
  br label %scalar.ph1329

vector.ph1331:                                    ; preds = %.lr.ph911
  %n.vec1333 = and i64 %84, 4294967292
  %broadcast.splatinsert1339 = insertelement <2 x i64> poison, i64 %277, i64 0
  %broadcast.splat1340 = shufflevector <2 x i64> %broadcast.splatinsert1339, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1343 = insertelement <2 x i64> poison, i64 %278, i64 0
  %broadcast.splat1344 = shufflevector <2 x i64> %broadcast.splatinsert1343, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1335

vector.body1335:                                  ; preds = %vector.body1335, %vector.ph1331
  %index1336 = phi i64 [ 0, %vector.ph1331 ], [ %index.next1345, %vector.body1335 ]
  %279 = getelementptr inbounds i64, ptr %111, i64 %index1336
  %280 = getelementptr inbounds i8, ptr %279, i64 16
  %wide.load1337 = load <2 x i64>, ptr %279, align 16, !tbaa !9
  %wide.load1338 = load <2 x i64>, ptr %280, align 16, !tbaa !9
  %281 = and <2 x i64> %wide.load1337, %broadcast.splat1340
  %282 = and <2 x i64> %wide.load1338, %broadcast.splat1340
  %283 = getelementptr inbounds i64, ptr %4, i64 %index1336
  %284 = getelementptr inbounds i8, ptr %283, i64 16
  %wide.load1341 = load <2 x i64>, ptr %283, align 8, !tbaa !9
  %wide.load1342 = load <2 x i64>, ptr %284, align 8, !tbaa !9
  %285 = and <2 x i64> %wide.load1341, %broadcast.splat1344
  %286 = and <2 x i64> %wide.load1342, %broadcast.splat1344
  %287 = or <2 x i64> %285, %281
  %288 = or <2 x i64> %286, %282
  store <2 x i64> %287, ptr %283, align 8, !tbaa !9
  store <2 x i64> %288, ptr %284, align 8, !tbaa !9
  %index.next1345 = add nuw i64 %index1336, 4
  %289 = icmp eq i64 %index.next1345, %n.vec1333
  br i1 %289, label %middle.block1328, label %vector.body1335, !llvm.loop !34

middle.block1328:                                 ; preds = %vector.body1335
  %cmp.n1346 = icmp eq i64 %n.vec1333, %84
  br i1 %cmp.n1346, label %._crit_edge912, label %scalar.ph1329.preheader

scalar.ph1310:                                    ; preds = %scalar.ph1310.preheader, %scalar.ph1310
  %indvars.iv1076 = phi i64 [ %indvars.iv.next1077, %scalar.ph1310 ], [ %indvars.iv1076.ph, %scalar.ph1310.preheader ]
  %290 = getelementptr inbounds i64, ptr %108, i64 %indvars.iv1076
  %291 = load i64, ptr %290, align 8, !tbaa !9
  %292 = and i64 %291, %256
  %293 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1076
  %294 = load i64, ptr %293, align 8, !tbaa !9
  %295 = and i64 %294, %257
  %296 = or i64 %295, %292
  store i64 %296, ptr %293, align 8, !tbaa !9
  %indvars.iv.next1077 = add nuw nsw i64 %indvars.iv1076, 1
  %exitcond1080.not = icmp eq i64 %indvars.iv.next1077, %84
  br i1 %exitcond1080.not, label %._crit_edge908, label %scalar.ph1310, !llvm.loop !35

._crit_edge912.thread:                            ; preds = %._crit_edge908.thread, %._crit_edge908
  %297 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 9)
  br label %._crit_edge916.thread

._crit_edge912:                                   ; preds = %scalar.ph1329, %middle.block1328
  %298 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 9)
  br i1 %.not1015, label %._crit_edge916.thread, label %.lr.ph915

.lr.ph915:                                        ; preds = %._crit_edge912
  %299 = xor i64 %298, -1
  %min.iters.check1349 = icmp ult i32 %6, 4
  br i1 %min.iters.check1349, label %scalar.ph1348.preheader, label %vector.ph1350

scalar.ph1348.preheader:                          ; preds = %middle.block1347, %.lr.ph915
  %indvars.iv1086.ph = phi i64 [ 0, %.lr.ph915 ], [ %n.vec1352, %middle.block1347 ]
  br label %scalar.ph1348

vector.ph1350:                                    ; preds = %.lr.ph915
  %n.vec1352 = and i64 %84, 4294967292
  %broadcast.splatinsert1358 = insertelement <2 x i64> poison, i64 %298, i64 0
  %broadcast.splat1359 = shufflevector <2 x i64> %broadcast.splatinsert1358, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1362 = insertelement <2 x i64> poison, i64 %299, i64 0
  %broadcast.splat1363 = shufflevector <2 x i64> %broadcast.splatinsert1362, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1354

vector.body1354:                                  ; preds = %vector.body1354, %vector.ph1350
  %index1355 = phi i64 [ 0, %vector.ph1350 ], [ %index.next1364, %vector.body1354 ]
  %300 = getelementptr inbounds i64, ptr %114, i64 %index1355
  %301 = getelementptr inbounds i8, ptr %300, i64 16
  %wide.load1356 = load <2 x i64>, ptr %300, align 8, !tbaa !9
  %wide.load1357 = load <2 x i64>, ptr %301, align 8, !tbaa !9
  %302 = and <2 x i64> %wide.load1356, %broadcast.splat1359
  %303 = and <2 x i64> %wide.load1357, %broadcast.splat1359
  %304 = getelementptr inbounds i64, ptr %4, i64 %index1355
  %305 = getelementptr inbounds i8, ptr %304, i64 16
  %wide.load1360 = load <2 x i64>, ptr %304, align 8, !tbaa !9
  %wide.load1361 = load <2 x i64>, ptr %305, align 8, !tbaa !9
  %306 = and <2 x i64> %wide.load1360, %broadcast.splat1363
  %307 = and <2 x i64> %wide.load1361, %broadcast.splat1363
  %308 = or <2 x i64> %306, %302
  %309 = or <2 x i64> %307, %303
  store <2 x i64> %308, ptr %304, align 8, !tbaa !9
  store <2 x i64> %309, ptr %305, align 8, !tbaa !9
  %index.next1364 = add nuw i64 %index1355, 4
  %310 = icmp eq i64 %index.next1364, %n.vec1352
  br i1 %310, label %middle.block1347, label %vector.body1354, !llvm.loop !36

middle.block1347:                                 ; preds = %vector.body1354
  %cmp.n1365 = icmp eq i64 %n.vec1352, %84
  br i1 %cmp.n1365, label %._crit_edge916, label %scalar.ph1348.preheader

scalar.ph1329:                                    ; preds = %scalar.ph1329.preheader, %scalar.ph1329
  %indvars.iv1081 = phi i64 [ %indvars.iv.next1082, %scalar.ph1329 ], [ %indvars.iv1081.ph, %scalar.ph1329.preheader ]
  %311 = getelementptr inbounds i64, ptr %111, i64 %indvars.iv1081
  %312 = load i64, ptr %311, align 8, !tbaa !9
  %313 = and i64 %312, %277
  %314 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1081
  %315 = load i64, ptr %314, align 8, !tbaa !9
  %316 = and i64 %315, %278
  %317 = or i64 %316, %313
  store i64 %317, ptr %314, align 8, !tbaa !9
  %indvars.iv.next1082 = add nuw nsw i64 %indvars.iv1081, 1
  %exitcond1085.not = icmp eq i64 %indvars.iv.next1082, %84
  br i1 %exitcond1085.not, label %._crit_edge912, label %scalar.ph1329, !llvm.loop !37

._crit_edge916.thread:                            ; preds = %._crit_edge912.thread, %._crit_edge912
  %318 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 10)
  br label %._crit_edge920.thread

._crit_edge916:                                   ; preds = %scalar.ph1348, %middle.block1347
  %319 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 10)
  br i1 %.not1015, label %._crit_edge920.thread, label %.lr.ph919

.lr.ph919:                                        ; preds = %._crit_edge916
  %320 = xor i64 %319, -1
  %min.iters.check1368 = icmp ult i32 %6, 4
  br i1 %min.iters.check1368, label %scalar.ph1367.preheader, label %vector.ph1369

scalar.ph1367.preheader:                          ; preds = %middle.block1366, %.lr.ph919
  %indvars.iv1091.ph = phi i64 [ 0, %.lr.ph919 ], [ %n.vec1371, %middle.block1366 ]
  br label %scalar.ph1367

vector.ph1369:                                    ; preds = %.lr.ph919
  %n.vec1371 = and i64 %84, 4294967292
  %broadcast.splatinsert1377 = insertelement <2 x i64> poison, i64 %319, i64 0
  %broadcast.splat1378 = shufflevector <2 x i64> %broadcast.splatinsert1377, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1381 = insertelement <2 x i64> poison, i64 %320, i64 0
  %broadcast.splat1382 = shufflevector <2 x i64> %broadcast.splatinsert1381, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1373

vector.body1373:                                  ; preds = %vector.body1373, %vector.ph1369
  %index1374 = phi i64 [ 0, %vector.ph1369 ], [ %index.next1383, %vector.body1373 ]
  %321 = getelementptr inbounds i64, ptr %117, i64 %index1374
  %322 = getelementptr inbounds i8, ptr %321, i64 16
  %wide.load1375 = load <2 x i64>, ptr %321, align 16, !tbaa !9
  %wide.load1376 = load <2 x i64>, ptr %322, align 16, !tbaa !9
  %323 = and <2 x i64> %wide.load1375, %broadcast.splat1378
  %324 = and <2 x i64> %wide.load1376, %broadcast.splat1378
  %325 = getelementptr inbounds i64, ptr %4, i64 %index1374
  %326 = getelementptr inbounds i8, ptr %325, i64 16
  %wide.load1379 = load <2 x i64>, ptr %325, align 8, !tbaa !9
  %wide.load1380 = load <2 x i64>, ptr %326, align 8, !tbaa !9
  %327 = and <2 x i64> %wide.load1379, %broadcast.splat1382
  %328 = and <2 x i64> %wide.load1380, %broadcast.splat1382
  %329 = or <2 x i64> %327, %323
  %330 = or <2 x i64> %328, %324
  store <2 x i64> %329, ptr %325, align 8, !tbaa !9
  store <2 x i64> %330, ptr %326, align 8, !tbaa !9
  %index.next1383 = add nuw i64 %index1374, 4
  %331 = icmp eq i64 %index.next1383, %n.vec1371
  br i1 %331, label %middle.block1366, label %vector.body1373, !llvm.loop !38

middle.block1366:                                 ; preds = %vector.body1373
  %cmp.n1384 = icmp eq i64 %n.vec1371, %84
  br i1 %cmp.n1384, label %._crit_edge920, label %scalar.ph1367.preheader

scalar.ph1348:                                    ; preds = %scalar.ph1348.preheader, %scalar.ph1348
  %indvars.iv1086 = phi i64 [ %indvars.iv.next1087, %scalar.ph1348 ], [ %indvars.iv1086.ph, %scalar.ph1348.preheader ]
  %332 = getelementptr inbounds i64, ptr %114, i64 %indvars.iv1086
  %333 = load i64, ptr %332, align 8, !tbaa !9
  %334 = and i64 %333, %298
  %335 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1086
  %336 = load i64, ptr %335, align 8, !tbaa !9
  %337 = and i64 %336, %299
  %338 = or i64 %337, %334
  store i64 %338, ptr %335, align 8, !tbaa !9
  %indvars.iv.next1087 = add nuw nsw i64 %indvars.iv1086, 1
  %exitcond1090.not = icmp eq i64 %indvars.iv.next1087, %84
  br i1 %exitcond1090.not, label %._crit_edge916, label %scalar.ph1348, !llvm.loop !39

._crit_edge920.thread:                            ; preds = %._crit_edge916.thread, %._crit_edge916
  %339 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 11)
  br label %._crit_edge924.thread

._crit_edge920:                                   ; preds = %scalar.ph1367, %middle.block1366
  %340 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 11)
  br i1 %.not1015, label %._crit_edge924.thread, label %.lr.ph923

.lr.ph923:                                        ; preds = %._crit_edge920
  %341 = xor i64 %340, -1
  %min.iters.check1387 = icmp ult i32 %6, 4
  br i1 %min.iters.check1387, label %scalar.ph1386.preheader, label %vector.ph1388

scalar.ph1386.preheader:                          ; preds = %middle.block1385, %.lr.ph923
  %indvars.iv1096.ph = phi i64 [ 0, %.lr.ph923 ], [ %n.vec1390, %middle.block1385 ]
  br label %scalar.ph1386

vector.ph1388:                                    ; preds = %.lr.ph923
  %n.vec1390 = and i64 %84, 4294967292
  %broadcast.splatinsert1396 = insertelement <2 x i64> poison, i64 %340, i64 0
  %broadcast.splat1397 = shufflevector <2 x i64> %broadcast.splatinsert1396, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1400 = insertelement <2 x i64> poison, i64 %341, i64 0
  %broadcast.splat1401 = shufflevector <2 x i64> %broadcast.splatinsert1400, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1392

vector.body1392:                                  ; preds = %vector.body1392, %vector.ph1388
  %index1393 = phi i64 [ 0, %vector.ph1388 ], [ %index.next1402, %vector.body1392 ]
  %342 = getelementptr inbounds i64, ptr %120, i64 %index1393
  %343 = getelementptr inbounds i8, ptr %342, i64 16
  %wide.load1394 = load <2 x i64>, ptr %342, align 8, !tbaa !9
  %wide.load1395 = load <2 x i64>, ptr %343, align 8, !tbaa !9
  %344 = and <2 x i64> %wide.load1394, %broadcast.splat1397
  %345 = and <2 x i64> %wide.load1395, %broadcast.splat1397
  %346 = getelementptr inbounds i64, ptr %4, i64 %index1393
  %347 = getelementptr inbounds i8, ptr %346, i64 16
  %wide.load1398 = load <2 x i64>, ptr %346, align 8, !tbaa !9
  %wide.load1399 = load <2 x i64>, ptr %347, align 8, !tbaa !9
  %348 = and <2 x i64> %wide.load1398, %broadcast.splat1401
  %349 = and <2 x i64> %wide.load1399, %broadcast.splat1401
  %350 = or <2 x i64> %348, %344
  %351 = or <2 x i64> %349, %345
  store <2 x i64> %350, ptr %346, align 8, !tbaa !9
  store <2 x i64> %351, ptr %347, align 8, !tbaa !9
  %index.next1402 = add nuw i64 %index1393, 4
  %352 = icmp eq i64 %index.next1402, %n.vec1390
  br i1 %352, label %middle.block1385, label %vector.body1392, !llvm.loop !40

middle.block1385:                                 ; preds = %vector.body1392
  %cmp.n1403 = icmp eq i64 %n.vec1390, %84
  br i1 %cmp.n1403, label %._crit_edge924, label %scalar.ph1386.preheader

scalar.ph1367:                                    ; preds = %scalar.ph1367.preheader, %scalar.ph1367
  %indvars.iv1091 = phi i64 [ %indvars.iv.next1092, %scalar.ph1367 ], [ %indvars.iv1091.ph, %scalar.ph1367.preheader ]
  %353 = getelementptr inbounds i64, ptr %117, i64 %indvars.iv1091
  %354 = load i64, ptr %353, align 8, !tbaa !9
  %355 = and i64 %354, %319
  %356 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1091
  %357 = load i64, ptr %356, align 8, !tbaa !9
  %358 = and i64 %357, %320
  %359 = or i64 %358, %355
  store i64 %359, ptr %356, align 8, !tbaa !9
  %indvars.iv.next1092 = add nuw nsw i64 %indvars.iv1091, 1
  %exitcond1095.not = icmp eq i64 %indvars.iv.next1092, %84
  br i1 %exitcond1095.not, label %._crit_edge920, label %scalar.ph1367, !llvm.loop !41

._crit_edge924.thread:                            ; preds = %._crit_edge920.thread, %._crit_edge920
  %360 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 12)
  br label %._crit_edge928.thread

._crit_edge924:                                   ; preds = %scalar.ph1386, %middle.block1385
  %361 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 12)
  br i1 %.not1015, label %._crit_edge928.thread, label %.lr.ph927

.lr.ph927:                                        ; preds = %._crit_edge924
  %362 = xor i64 %361, -1
  %min.iters.check1406 = icmp ult i32 %6, 4
  br i1 %min.iters.check1406, label %scalar.ph1405.preheader, label %vector.ph1407

scalar.ph1405.preheader:                          ; preds = %middle.block1404, %.lr.ph927
  %indvars.iv1101.ph = phi i64 [ 0, %.lr.ph927 ], [ %n.vec1409, %middle.block1404 ]
  br label %scalar.ph1405

vector.ph1407:                                    ; preds = %.lr.ph927
  %n.vec1409 = and i64 %84, 4294967292
  %broadcast.splatinsert1415 = insertelement <2 x i64> poison, i64 %361, i64 0
  %broadcast.splat1416 = shufflevector <2 x i64> %broadcast.splatinsert1415, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1419 = insertelement <2 x i64> poison, i64 %362, i64 0
  %broadcast.splat1420 = shufflevector <2 x i64> %broadcast.splatinsert1419, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1411

vector.body1411:                                  ; preds = %vector.body1411, %vector.ph1407
  %index1412 = phi i64 [ 0, %vector.ph1407 ], [ %index.next1421, %vector.body1411 ]
  %363 = getelementptr inbounds i64, ptr %123, i64 %index1412
  %364 = getelementptr inbounds i8, ptr %363, i64 16
  %wide.load1413 = load <2 x i64>, ptr %363, align 16, !tbaa !9
  %wide.load1414 = load <2 x i64>, ptr %364, align 16, !tbaa !9
  %365 = and <2 x i64> %wide.load1413, %broadcast.splat1416
  %366 = and <2 x i64> %wide.load1414, %broadcast.splat1416
  %367 = getelementptr inbounds i64, ptr %4, i64 %index1412
  %368 = getelementptr inbounds i8, ptr %367, i64 16
  %wide.load1417 = load <2 x i64>, ptr %367, align 8, !tbaa !9
  %wide.load1418 = load <2 x i64>, ptr %368, align 8, !tbaa !9
  %369 = and <2 x i64> %wide.load1417, %broadcast.splat1420
  %370 = and <2 x i64> %wide.load1418, %broadcast.splat1420
  %371 = or <2 x i64> %369, %365
  %372 = or <2 x i64> %370, %366
  store <2 x i64> %371, ptr %367, align 8, !tbaa !9
  store <2 x i64> %372, ptr %368, align 8, !tbaa !9
  %index.next1421 = add nuw i64 %index1412, 4
  %373 = icmp eq i64 %index.next1421, %n.vec1409
  br i1 %373, label %middle.block1404, label %vector.body1411, !llvm.loop !42

middle.block1404:                                 ; preds = %vector.body1411
  %cmp.n1422 = icmp eq i64 %n.vec1409, %84
  br i1 %cmp.n1422, label %._crit_edge928, label %scalar.ph1405.preheader

scalar.ph1386:                                    ; preds = %scalar.ph1386.preheader, %scalar.ph1386
  %indvars.iv1096 = phi i64 [ %indvars.iv.next1097, %scalar.ph1386 ], [ %indvars.iv1096.ph, %scalar.ph1386.preheader ]
  %374 = getelementptr inbounds i64, ptr %120, i64 %indvars.iv1096
  %375 = load i64, ptr %374, align 8, !tbaa !9
  %376 = and i64 %375, %340
  %377 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1096
  %378 = load i64, ptr %377, align 8, !tbaa !9
  %379 = and i64 %378, %341
  %380 = or i64 %379, %376
  store i64 %380, ptr %377, align 8, !tbaa !9
  %indvars.iv.next1097 = add nuw nsw i64 %indvars.iv1096, 1
  %exitcond1100.not = icmp eq i64 %indvars.iv.next1097, %84
  br i1 %exitcond1100.not, label %._crit_edge924, label %scalar.ph1386, !llvm.loop !43

._crit_edge928.thread:                            ; preds = %._crit_edge924.thread, %._crit_edge924
  %381 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 13)
  br label %._crit_edge932.thread

._crit_edge928:                                   ; preds = %scalar.ph1405, %middle.block1404
  %382 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 13)
  br i1 %.not1015, label %._crit_edge932.thread, label %.lr.ph931

.lr.ph931:                                        ; preds = %._crit_edge928
  %383 = xor i64 %382, -1
  %min.iters.check1425 = icmp ult i32 %6, 4
  br i1 %min.iters.check1425, label %scalar.ph1424.preheader, label %vector.ph1426

scalar.ph1424.preheader:                          ; preds = %middle.block1423, %.lr.ph931
  %indvars.iv1106.ph = phi i64 [ 0, %.lr.ph931 ], [ %n.vec1428, %middle.block1423 ]
  br label %scalar.ph1424

vector.ph1426:                                    ; preds = %.lr.ph931
  %n.vec1428 = and i64 %84, 4294967292
  %broadcast.splatinsert1434 = insertelement <2 x i64> poison, i64 %382, i64 0
  %broadcast.splat1435 = shufflevector <2 x i64> %broadcast.splatinsert1434, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1438 = insertelement <2 x i64> poison, i64 %383, i64 0
  %broadcast.splat1439 = shufflevector <2 x i64> %broadcast.splatinsert1438, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1430

vector.body1430:                                  ; preds = %vector.body1430, %vector.ph1426
  %index1431 = phi i64 [ 0, %vector.ph1426 ], [ %index.next1440, %vector.body1430 ]
  %384 = getelementptr inbounds i64, ptr %126, i64 %index1431
  %385 = getelementptr inbounds i8, ptr %384, i64 16
  %wide.load1432 = load <2 x i64>, ptr %384, align 8, !tbaa !9
  %wide.load1433 = load <2 x i64>, ptr %385, align 8, !tbaa !9
  %386 = and <2 x i64> %wide.load1432, %broadcast.splat1435
  %387 = and <2 x i64> %wide.load1433, %broadcast.splat1435
  %388 = getelementptr inbounds i64, ptr %4, i64 %index1431
  %389 = getelementptr inbounds i8, ptr %388, i64 16
  %wide.load1436 = load <2 x i64>, ptr %388, align 8, !tbaa !9
  %wide.load1437 = load <2 x i64>, ptr %389, align 8, !tbaa !9
  %390 = and <2 x i64> %wide.load1436, %broadcast.splat1439
  %391 = and <2 x i64> %wide.load1437, %broadcast.splat1439
  %392 = or <2 x i64> %390, %386
  %393 = or <2 x i64> %391, %387
  store <2 x i64> %392, ptr %388, align 8, !tbaa !9
  store <2 x i64> %393, ptr %389, align 8, !tbaa !9
  %index.next1440 = add nuw i64 %index1431, 4
  %394 = icmp eq i64 %index.next1440, %n.vec1428
  br i1 %394, label %middle.block1423, label %vector.body1430, !llvm.loop !44

middle.block1423:                                 ; preds = %vector.body1430
  %cmp.n1441 = icmp eq i64 %n.vec1428, %84
  br i1 %cmp.n1441, label %._crit_edge932, label %scalar.ph1424.preheader

scalar.ph1405:                                    ; preds = %scalar.ph1405.preheader, %scalar.ph1405
  %indvars.iv1101 = phi i64 [ %indvars.iv.next1102, %scalar.ph1405 ], [ %indvars.iv1101.ph, %scalar.ph1405.preheader ]
  %395 = getelementptr inbounds i64, ptr %123, i64 %indvars.iv1101
  %396 = load i64, ptr %395, align 8, !tbaa !9
  %397 = and i64 %396, %361
  %398 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1101
  %399 = load i64, ptr %398, align 8, !tbaa !9
  %400 = and i64 %399, %362
  %401 = or i64 %400, %397
  store i64 %401, ptr %398, align 8, !tbaa !9
  %indvars.iv.next1102 = add nuw nsw i64 %indvars.iv1101, 1
  %exitcond1105.not = icmp eq i64 %indvars.iv.next1102, %84
  br i1 %exitcond1105.not, label %._crit_edge928, label %scalar.ph1405, !llvm.loop !45

._crit_edge932.thread:                            ; preds = %._crit_edge928.thread, %._crit_edge928
  %402 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 14)
  br label %._crit_edge936.thread

._crit_edge932:                                   ; preds = %scalar.ph1424, %middle.block1423
  %403 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 14)
  br i1 %.not1015, label %._crit_edge936.thread, label %.lr.ph935

.lr.ph935:                                        ; preds = %._crit_edge932
  %404 = xor i64 %403, -1
  %min.iters.check1444 = icmp ult i32 %6, 4
  br i1 %min.iters.check1444, label %scalar.ph1443.preheader, label %vector.ph1445

scalar.ph1443.preheader:                          ; preds = %middle.block1442, %.lr.ph935
  %indvars.iv1111.ph = phi i64 [ 0, %.lr.ph935 ], [ %n.vec1447, %middle.block1442 ]
  br label %scalar.ph1443

vector.ph1445:                                    ; preds = %.lr.ph935
  %n.vec1447 = and i64 %84, 4294967292
  %broadcast.splatinsert1453 = insertelement <2 x i64> poison, i64 %403, i64 0
  %broadcast.splat1454 = shufflevector <2 x i64> %broadcast.splatinsert1453, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1457 = insertelement <2 x i64> poison, i64 %404, i64 0
  %broadcast.splat1458 = shufflevector <2 x i64> %broadcast.splatinsert1457, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1449

vector.body1449:                                  ; preds = %vector.body1449, %vector.ph1445
  %index1450 = phi i64 [ 0, %vector.ph1445 ], [ %index.next1459, %vector.body1449 ]
  %405 = getelementptr inbounds i64, ptr %129, i64 %index1450
  %406 = getelementptr inbounds i8, ptr %405, i64 16
  %wide.load1451 = load <2 x i64>, ptr %405, align 16, !tbaa !9
  %wide.load1452 = load <2 x i64>, ptr %406, align 16, !tbaa !9
  %407 = and <2 x i64> %wide.load1451, %broadcast.splat1454
  %408 = and <2 x i64> %wide.load1452, %broadcast.splat1454
  %409 = getelementptr inbounds i64, ptr %4, i64 %index1450
  %410 = getelementptr inbounds i8, ptr %409, i64 16
  %wide.load1455 = load <2 x i64>, ptr %409, align 8, !tbaa !9
  %wide.load1456 = load <2 x i64>, ptr %410, align 8, !tbaa !9
  %411 = and <2 x i64> %wide.load1455, %broadcast.splat1458
  %412 = and <2 x i64> %wide.load1456, %broadcast.splat1458
  %413 = or <2 x i64> %411, %407
  %414 = or <2 x i64> %412, %408
  store <2 x i64> %413, ptr %409, align 8, !tbaa !9
  store <2 x i64> %414, ptr %410, align 8, !tbaa !9
  %index.next1459 = add nuw i64 %index1450, 4
  %415 = icmp eq i64 %index.next1459, %n.vec1447
  br i1 %415, label %middle.block1442, label %vector.body1449, !llvm.loop !46

middle.block1442:                                 ; preds = %vector.body1449
  %cmp.n1460 = icmp eq i64 %n.vec1447, %84
  br i1 %cmp.n1460, label %._crit_edge936, label %scalar.ph1443.preheader

scalar.ph1424:                                    ; preds = %scalar.ph1424.preheader, %scalar.ph1424
  %indvars.iv1106 = phi i64 [ %indvars.iv.next1107, %scalar.ph1424 ], [ %indvars.iv1106.ph, %scalar.ph1424.preheader ]
  %416 = getelementptr inbounds i64, ptr %126, i64 %indvars.iv1106
  %417 = load i64, ptr %416, align 8, !tbaa !9
  %418 = and i64 %417, %382
  %419 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1106
  %420 = load i64, ptr %419, align 8, !tbaa !9
  %421 = and i64 %420, %383
  %422 = or i64 %421, %418
  store i64 %422, ptr %419, align 8, !tbaa !9
  %indvars.iv.next1107 = add nuw nsw i64 %indvars.iv1106, 1
  %exitcond1110.not = icmp eq i64 %indvars.iv.next1107, %84
  br i1 %exitcond1110.not, label %._crit_edge932, label %scalar.ph1424, !llvm.loop !47

._crit_edge936.thread:                            ; preds = %._crit_edge932.thread, %._crit_edge932
  %423 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 15)
  br label %.lr.ph1002

._crit_edge936:                                   ; preds = %scalar.ph1443, %middle.block1442
  %424 = call i64 @FStar_UInt64_eq_mask(i64 noundef %136, i64 noundef 15)
  br i1 %.not1015, label %.lr.ph1002, label %.lr.ph939

.lr.ph939:                                        ; preds = %._crit_edge936
  %425 = xor i64 %424, -1
  %min.iters.check1463 = icmp ult i32 %6, 4
  br i1 %min.iters.check1463, label %scalar.ph1462.preheader, label %vector.ph1464

scalar.ph1462.preheader:                          ; preds = %middle.block1461, %.lr.ph939
  %indvars.iv1116.ph = phi i64 [ 0, %.lr.ph939 ], [ %n.vec1466, %middle.block1461 ]
  br label %scalar.ph1462

vector.ph1464:                                    ; preds = %.lr.ph939
  %n.vec1466 = and i64 %84, 4294967292
  %broadcast.splatinsert1472 = insertelement <2 x i64> poison, i64 %424, i64 0
  %broadcast.splat1473 = shufflevector <2 x i64> %broadcast.splatinsert1472, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1476 = insertelement <2 x i64> poison, i64 %425, i64 0
  %broadcast.splat1477 = shufflevector <2 x i64> %broadcast.splatinsert1476, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1468

vector.body1468:                                  ; preds = %vector.body1468, %vector.ph1464
  %index1469 = phi i64 [ 0, %vector.ph1464 ], [ %index.next1478, %vector.body1468 ]
  %426 = getelementptr inbounds i64, ptr %132, i64 %index1469
  %427 = getelementptr inbounds i8, ptr %426, i64 16
  %wide.load1470 = load <2 x i64>, ptr %426, align 8, !tbaa !9
  %wide.load1471 = load <2 x i64>, ptr %427, align 8, !tbaa !9
  %428 = and <2 x i64> %wide.load1470, %broadcast.splat1473
  %429 = and <2 x i64> %wide.load1471, %broadcast.splat1473
  %430 = getelementptr inbounds i64, ptr %4, i64 %index1469
  %431 = getelementptr inbounds i8, ptr %430, i64 16
  %wide.load1474 = load <2 x i64>, ptr %430, align 8, !tbaa !9
  %wide.load1475 = load <2 x i64>, ptr %431, align 8, !tbaa !9
  %432 = and <2 x i64> %wide.load1474, %broadcast.splat1477
  %433 = and <2 x i64> %wide.load1475, %broadcast.splat1477
  %434 = or <2 x i64> %432, %428
  %435 = or <2 x i64> %433, %429
  store <2 x i64> %434, ptr %430, align 8, !tbaa !9
  store <2 x i64> %435, ptr %431, align 8, !tbaa !9
  %index.next1478 = add nuw i64 %index1469, 4
  %436 = icmp eq i64 %index.next1478, %n.vec1466
  br i1 %436, label %middle.block1461, label %vector.body1468, !llvm.loop !48

middle.block1461:                                 ; preds = %vector.body1468
  %cmp.n1479 = icmp eq i64 %n.vec1466, %84
  br i1 %cmp.n1479, label %.lr.ph1002, label %scalar.ph1462.preheader

scalar.ph1443:                                    ; preds = %scalar.ph1443.preheader, %scalar.ph1443
  %indvars.iv1111 = phi i64 [ %indvars.iv.next1112, %scalar.ph1443 ], [ %indvars.iv1111.ph, %scalar.ph1443.preheader ]
  %437 = getelementptr inbounds i64, ptr %129, i64 %indvars.iv1111
  %438 = load i64, ptr %437, align 8, !tbaa !9
  %439 = and i64 %438, %403
  %440 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1111
  %441 = load i64, ptr %440, align 8, !tbaa !9
  %442 = and i64 %441, %404
  %443 = or i64 %442, %439
  store i64 %443, ptr %440, align 8, !tbaa !9
  %indvars.iv.next1112 = add nuw nsw i64 %indvars.iv1111, 1
  %exitcond1115.not = icmp eq i64 %indvars.iv.next1112, %84
  br i1 %exitcond1115.not, label %._crit_edge936, label %scalar.ph1443, !llvm.loop !49

scalar.ph1462:                                    ; preds = %scalar.ph1462.preheader, %scalar.ph1462
  %indvars.iv1116 = phi i64 [ %indvars.iv.next1117, %scalar.ph1462 ], [ %indvars.iv1116.ph, %scalar.ph1462.preheader ]
  %444 = getelementptr inbounds i64, ptr %132, i64 %indvars.iv1116
  %445 = load i64, ptr %444, align 8, !tbaa !9
  %446 = and i64 %445, %424
  %447 = getelementptr inbounds i64, ptr %4, i64 %indvars.iv1116
  %448 = load i64, ptr %447, align 8, !tbaa !9
  %449 = and i64 %448, %425
  %450 = or i64 %449, %446
  store i64 %450, ptr %447, align 8, !tbaa !9
  %indvars.iv.next1117 = add nuw nsw i64 %indvars.iv1116, 1
  %exitcond1120.not = icmp eq i64 %indvars.iv.next1117, %84
  br i1 %exitcond1120.not, label %.lr.ph1002, label %scalar.ph1462, !llvm.loop !50

451:                                              ; preds = %76
  call void @Hacl_Bignum_Montgomery_bn_from_mont_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef nonnull %86, ptr noundef %4) #7
  br label %.lr.ph1002

.lr.ph1002:                                       ; preds = %scalar.ph1462, %middle.block1461, %451, %._crit_edge936, %._crit_edge936.thread
  %452 = alloca i64, i64 %84, align 16
  call void @llvm.memset.p0.i64(ptr nonnull align 16 %452, i8 0, i64 %85, i1 false)
  %453 = lshr i32 %2, 2
  %454 = and i32 %2, -4
  %455 = add i32 %454, -4
  %.not1031 = icmp eq i32 %6, 0
  %umax = call i32 @llvm.umax.i32(i32 %453, i32 1)
  %min.iters.check1748 = icmp ult i32 %6, 4
  %n.vec1751 = and i64 %84, 4294967292
  %cmp.n1764 = icmp eq i64 %n.vec1751, %84
  %min.iters.check1729 = icmp ult i32 %6, 4
  %n.vec1732 = and i64 %84, 4294967292
  %cmp.n1745 = icmp eq i64 %n.vec1732, %84
  %min.iters.check1710 = icmp ult i32 %6, 4
  %n.vec1713 = and i64 %84, 4294967292
  %cmp.n1726 = icmp eq i64 %n.vec1713, %84
  %min.iters.check1691 = icmp ult i32 %6, 4
  %n.vec1694 = and i64 %84, 4294967292
  %cmp.n1707 = icmp eq i64 %n.vec1694, %84
  %min.iters.check1672 = icmp ult i32 %6, 4
  %n.vec1675 = and i64 %84, 4294967292
  %cmp.n1688 = icmp eq i64 %n.vec1675, %84
  %min.iters.check1653 = icmp ult i32 %6, 4
  %n.vec1656 = and i64 %84, 4294967292
  %cmp.n1669 = icmp eq i64 %n.vec1656, %84
  %min.iters.check1634 = icmp ult i32 %6, 4
  %n.vec1637 = and i64 %84, 4294967292
  %cmp.n1650 = icmp eq i64 %n.vec1637, %84
  %min.iters.check1615 = icmp ult i32 %6, 4
  %n.vec1618 = and i64 %84, 4294967292
  %cmp.n1631 = icmp eq i64 %n.vec1618, %84
  %min.iters.check1596 = icmp ult i32 %6, 4
  %n.vec1599 = and i64 %84, 4294967292
  %cmp.n1612 = icmp eq i64 %n.vec1599, %84
  %min.iters.check1577 = icmp ult i32 %6, 4
  %n.vec1580 = and i64 %84, 4294967292
  %cmp.n1593 = icmp eq i64 %n.vec1580, %84
  %min.iters.check1558 = icmp ult i32 %6, 4
  %n.vec1561 = and i64 %84, 4294967292
  %cmp.n1574 = icmp eq i64 %n.vec1561, %84
  %min.iters.check1539 = icmp ult i32 %6, 4
  %n.vec1542 = and i64 %84, 4294967292
  %cmp.n1555 = icmp eq i64 %n.vec1542, %84
  %min.iters.check1520 = icmp ult i32 %6, 4
  %n.vec1523 = and i64 %84, 4294967292
  %cmp.n1536 = icmp eq i64 %n.vec1523, %84
  %min.iters.check1501 = icmp ult i32 %6, 4
  %n.vec1504 = and i64 %84, 4294967292
  %cmp.n1517 = icmp eq i64 %n.vec1504, %84
  %min.iters.check1482 = icmp ult i32 %6, 4
  %n.vec1485 = and i64 %84, 4294967292
  %cmp.n1498 = icmp eq i64 %n.vec1485, %84
  br label %456

456:                                              ; preds = %.lr.ph1002, %._crit_edge999
  %.08711000 = phi i32 [ 0, %.lr.ph1002 ], [ %767, %._crit_edge999 ]
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef %4, ptr noundef %4) #7
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef %4, ptr noundef %4) #7
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef %4, ptr noundef %4) #7
  call void @Hacl_Bignum_Montgomery_bn_mont_sqr_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef %4, ptr noundef %4) #7
  %457 = shl i32 %.08711000, 2
  %458 = sub i32 %455, %457
  %459 = call i64 @Hacl_Bignum_Lib_bn_get_bits_u64(i32 noundef %79, ptr noundef %3, i32 noundef %458, i32 noundef 4)
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 16 %452, ptr nonnull align 16 %89, i64 %85, i1 false)
  %460 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 1)
  br i1 %.not1031, label %._crit_edge943.thread, label %.lr.ph942

._crit_edge943.thread:                            ; preds = %456
  %461 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 2)
  br label %._crit_edge947.thread

.lr.ph942:                                        ; preds = %456
  %462 = xor i64 %460, -1
  br i1 %min.iters.check1748, label %scalar.ph1747.preheader, label %vector.ph1749

scalar.ph1747.preheader:                          ; preds = %middle.block1746, %.lr.ph942
  %indvars.iv1121.ph = phi i64 [ 0, %.lr.ph942 ], [ %n.vec1751, %middle.block1746 ]
  br label %scalar.ph1747

vector.ph1749:                                    ; preds = %.lr.ph942
  %broadcast.splatinsert1757 = insertelement <2 x i64> poison, i64 %460, i64 0
  %broadcast.splat1758 = shufflevector <2 x i64> %broadcast.splatinsert1757, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1761 = insertelement <2 x i64> poison, i64 %462, i64 0
  %broadcast.splat1762 = shufflevector <2 x i64> %broadcast.splatinsert1761, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1753

vector.body1753:                                  ; preds = %vector.body1753, %vector.ph1749
  %index1754 = phi i64 [ 0, %vector.ph1749 ], [ %index.next1763, %vector.body1753 ]
  %463 = getelementptr inbounds i64, ptr %92, i64 %index1754
  %464 = getelementptr inbounds i8, ptr %463, i64 16
  %wide.load1755 = load <2 x i64>, ptr %463, align 8, !tbaa !9
  %wide.load1756 = load <2 x i64>, ptr %464, align 8, !tbaa !9
  %465 = and <2 x i64> %wide.load1755, %broadcast.splat1758
  %466 = and <2 x i64> %wide.load1756, %broadcast.splat1758
  %467 = getelementptr inbounds i64, ptr %452, i64 %index1754
  %468 = getelementptr inbounds i8, ptr %467, i64 16
  %wide.load1759 = load <2 x i64>, ptr %467, align 16, !tbaa !9
  %wide.load1760 = load <2 x i64>, ptr %468, align 16, !tbaa !9
  %469 = and <2 x i64> %wide.load1759, %broadcast.splat1762
  %470 = and <2 x i64> %wide.load1760, %broadcast.splat1762
  %471 = or <2 x i64> %469, %465
  %472 = or <2 x i64> %470, %466
  store <2 x i64> %471, ptr %467, align 16, !tbaa !9
  store <2 x i64> %472, ptr %468, align 16, !tbaa !9
  %index.next1763 = add nuw i64 %index1754, 4
  %473 = icmp eq i64 %index.next1763, %n.vec1751
  br i1 %473, label %middle.block1746, label %vector.body1753, !llvm.loop !51

middle.block1746:                                 ; preds = %vector.body1753
  br i1 %cmp.n1764, label %._crit_edge943, label %scalar.ph1747.preheader

._crit_edge943:                                   ; preds = %scalar.ph1747, %middle.block1746
  %474 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 2)
  br i1 %.not1031, label %._crit_edge947.thread, label %.lr.ph946

.lr.ph946:                                        ; preds = %._crit_edge943
  %475 = xor i64 %474, -1
  br i1 %min.iters.check1729, label %scalar.ph1728.preheader, label %vector.ph1730

scalar.ph1728.preheader:                          ; preds = %middle.block1727, %.lr.ph946
  %indvars.iv1126.ph = phi i64 [ 0, %.lr.ph946 ], [ %n.vec1732, %middle.block1727 ]
  br label %scalar.ph1728

vector.ph1730:                                    ; preds = %.lr.ph946
  %broadcast.splatinsert1738 = insertelement <2 x i64> poison, i64 %474, i64 0
  %broadcast.splat1739 = shufflevector <2 x i64> %broadcast.splatinsert1738, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1742 = insertelement <2 x i64> poison, i64 %475, i64 0
  %broadcast.splat1743 = shufflevector <2 x i64> %broadcast.splatinsert1742, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1734

vector.body1734:                                  ; preds = %vector.body1734, %vector.ph1730
  %index1735 = phi i64 [ 0, %vector.ph1730 ], [ %index.next1744, %vector.body1734 ]
  %476 = getelementptr inbounds i64, ptr %93, i64 %index1735
  %477 = getelementptr inbounds i8, ptr %476, i64 16
  %wide.load1736 = load <2 x i64>, ptr %476, align 16, !tbaa !9
  %wide.load1737 = load <2 x i64>, ptr %477, align 16, !tbaa !9
  %478 = and <2 x i64> %wide.load1736, %broadcast.splat1739
  %479 = and <2 x i64> %wide.load1737, %broadcast.splat1739
  %480 = getelementptr inbounds i64, ptr %452, i64 %index1735
  %481 = getelementptr inbounds i8, ptr %480, i64 16
  %wide.load1740 = load <2 x i64>, ptr %480, align 16, !tbaa !9
  %wide.load1741 = load <2 x i64>, ptr %481, align 16, !tbaa !9
  %482 = and <2 x i64> %wide.load1740, %broadcast.splat1743
  %483 = and <2 x i64> %wide.load1741, %broadcast.splat1743
  %484 = or <2 x i64> %482, %478
  %485 = or <2 x i64> %483, %479
  store <2 x i64> %484, ptr %480, align 16, !tbaa !9
  store <2 x i64> %485, ptr %481, align 16, !tbaa !9
  %index.next1744 = add nuw i64 %index1735, 4
  %486 = icmp eq i64 %index.next1744, %n.vec1732
  br i1 %486, label %middle.block1727, label %vector.body1734, !llvm.loop !52

middle.block1727:                                 ; preds = %vector.body1734
  br i1 %cmp.n1745, label %._crit_edge947, label %scalar.ph1728.preheader

scalar.ph1747:                                    ; preds = %scalar.ph1747.preheader, %scalar.ph1747
  %indvars.iv1121 = phi i64 [ %indvars.iv.next1122, %scalar.ph1747 ], [ %indvars.iv1121.ph, %scalar.ph1747.preheader ]
  %487 = getelementptr inbounds i64, ptr %92, i64 %indvars.iv1121
  %488 = load i64, ptr %487, align 8, !tbaa !9
  %489 = and i64 %488, %460
  %490 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1121
  %491 = load i64, ptr %490, align 8, !tbaa !9
  %492 = and i64 %491, %462
  %493 = or i64 %492, %489
  store i64 %493, ptr %490, align 8, !tbaa !9
  %indvars.iv.next1122 = add nuw nsw i64 %indvars.iv1121, 1
  %exitcond1125.not = icmp eq i64 %indvars.iv.next1122, %84
  br i1 %exitcond1125.not, label %._crit_edge943, label %scalar.ph1747, !llvm.loop !53

._crit_edge947.thread:                            ; preds = %._crit_edge943.thread, %._crit_edge943
  %494 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 3)
  br label %._crit_edge951.thread

._crit_edge947:                                   ; preds = %scalar.ph1728, %middle.block1727
  %495 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 3)
  br i1 %.not1031, label %._crit_edge951.thread, label %.lr.ph950

.lr.ph950:                                        ; preds = %._crit_edge947
  %496 = xor i64 %495, -1
  br i1 %min.iters.check1710, label %scalar.ph1709.preheader, label %vector.ph1711

scalar.ph1709.preheader:                          ; preds = %middle.block1708, %.lr.ph950
  %indvars.iv1131.ph = phi i64 [ 0, %.lr.ph950 ], [ %n.vec1713, %middle.block1708 ]
  br label %scalar.ph1709

vector.ph1711:                                    ; preds = %.lr.ph950
  %broadcast.splatinsert1719 = insertelement <2 x i64> poison, i64 %495, i64 0
  %broadcast.splat1720 = shufflevector <2 x i64> %broadcast.splatinsert1719, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1723 = insertelement <2 x i64> poison, i64 %496, i64 0
  %broadcast.splat1724 = shufflevector <2 x i64> %broadcast.splatinsert1723, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1715

vector.body1715:                                  ; preds = %vector.body1715, %vector.ph1711
  %index1716 = phi i64 [ 0, %vector.ph1711 ], [ %index.next1725, %vector.body1715 ]
  %497 = getelementptr inbounds i64, ptr %96, i64 %index1716
  %498 = getelementptr inbounds i8, ptr %497, i64 16
  %wide.load1717 = load <2 x i64>, ptr %497, align 8, !tbaa !9
  %wide.load1718 = load <2 x i64>, ptr %498, align 8, !tbaa !9
  %499 = and <2 x i64> %wide.load1717, %broadcast.splat1720
  %500 = and <2 x i64> %wide.load1718, %broadcast.splat1720
  %501 = getelementptr inbounds i64, ptr %452, i64 %index1716
  %502 = getelementptr inbounds i8, ptr %501, i64 16
  %wide.load1721 = load <2 x i64>, ptr %501, align 16, !tbaa !9
  %wide.load1722 = load <2 x i64>, ptr %502, align 16, !tbaa !9
  %503 = and <2 x i64> %wide.load1721, %broadcast.splat1724
  %504 = and <2 x i64> %wide.load1722, %broadcast.splat1724
  %505 = or <2 x i64> %503, %499
  %506 = or <2 x i64> %504, %500
  store <2 x i64> %505, ptr %501, align 16, !tbaa !9
  store <2 x i64> %506, ptr %502, align 16, !tbaa !9
  %index.next1725 = add nuw i64 %index1716, 4
  %507 = icmp eq i64 %index.next1725, %n.vec1713
  br i1 %507, label %middle.block1708, label %vector.body1715, !llvm.loop !54

middle.block1708:                                 ; preds = %vector.body1715
  br i1 %cmp.n1726, label %._crit_edge951, label %scalar.ph1709.preheader

scalar.ph1728:                                    ; preds = %scalar.ph1728.preheader, %scalar.ph1728
  %indvars.iv1126 = phi i64 [ %indvars.iv.next1127, %scalar.ph1728 ], [ %indvars.iv1126.ph, %scalar.ph1728.preheader ]
  %508 = getelementptr inbounds i64, ptr %93, i64 %indvars.iv1126
  %509 = load i64, ptr %508, align 8, !tbaa !9
  %510 = and i64 %509, %474
  %511 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1126
  %512 = load i64, ptr %511, align 8, !tbaa !9
  %513 = and i64 %512, %475
  %514 = or i64 %513, %510
  store i64 %514, ptr %511, align 8, !tbaa !9
  %indvars.iv.next1127 = add nuw nsw i64 %indvars.iv1126, 1
  %exitcond1130.not = icmp eq i64 %indvars.iv.next1127, %84
  br i1 %exitcond1130.not, label %._crit_edge947, label %scalar.ph1728, !llvm.loop !55

._crit_edge951.thread:                            ; preds = %._crit_edge947.thread, %._crit_edge947
  %515 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 4)
  br label %._crit_edge955.thread

._crit_edge951:                                   ; preds = %scalar.ph1709, %middle.block1708
  %516 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 4)
  br i1 %.not1031, label %._crit_edge955.thread, label %.lr.ph954

.lr.ph954:                                        ; preds = %._crit_edge951
  %517 = xor i64 %516, -1
  br i1 %min.iters.check1691, label %scalar.ph1690.preheader, label %vector.ph1692

scalar.ph1690.preheader:                          ; preds = %middle.block1689, %.lr.ph954
  %indvars.iv1136.ph = phi i64 [ 0, %.lr.ph954 ], [ %n.vec1694, %middle.block1689 ]
  br label %scalar.ph1690

vector.ph1692:                                    ; preds = %.lr.ph954
  %broadcast.splatinsert1700 = insertelement <2 x i64> poison, i64 %516, i64 0
  %broadcast.splat1701 = shufflevector <2 x i64> %broadcast.splatinsert1700, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1704 = insertelement <2 x i64> poison, i64 %517, i64 0
  %broadcast.splat1705 = shufflevector <2 x i64> %broadcast.splatinsert1704, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1696

vector.body1696:                                  ; preds = %vector.body1696, %vector.ph1692
  %index1697 = phi i64 [ 0, %vector.ph1692 ], [ %index.next1706, %vector.body1696 ]
  %518 = getelementptr inbounds i64, ptr %99, i64 %index1697
  %519 = getelementptr inbounds i8, ptr %518, i64 16
  %wide.load1698 = load <2 x i64>, ptr %518, align 16, !tbaa !9
  %wide.load1699 = load <2 x i64>, ptr %519, align 16, !tbaa !9
  %520 = and <2 x i64> %wide.load1698, %broadcast.splat1701
  %521 = and <2 x i64> %wide.load1699, %broadcast.splat1701
  %522 = getelementptr inbounds i64, ptr %452, i64 %index1697
  %523 = getelementptr inbounds i8, ptr %522, i64 16
  %wide.load1702 = load <2 x i64>, ptr %522, align 16, !tbaa !9
  %wide.load1703 = load <2 x i64>, ptr %523, align 16, !tbaa !9
  %524 = and <2 x i64> %wide.load1702, %broadcast.splat1705
  %525 = and <2 x i64> %wide.load1703, %broadcast.splat1705
  %526 = or <2 x i64> %524, %520
  %527 = or <2 x i64> %525, %521
  store <2 x i64> %526, ptr %522, align 16, !tbaa !9
  store <2 x i64> %527, ptr %523, align 16, !tbaa !9
  %index.next1706 = add nuw i64 %index1697, 4
  %528 = icmp eq i64 %index.next1706, %n.vec1694
  br i1 %528, label %middle.block1689, label %vector.body1696, !llvm.loop !56

middle.block1689:                                 ; preds = %vector.body1696
  br i1 %cmp.n1707, label %._crit_edge955, label %scalar.ph1690.preheader

scalar.ph1709:                                    ; preds = %scalar.ph1709.preheader, %scalar.ph1709
  %indvars.iv1131 = phi i64 [ %indvars.iv.next1132, %scalar.ph1709 ], [ %indvars.iv1131.ph, %scalar.ph1709.preheader ]
  %529 = getelementptr inbounds i64, ptr %96, i64 %indvars.iv1131
  %530 = load i64, ptr %529, align 8, !tbaa !9
  %531 = and i64 %530, %495
  %532 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1131
  %533 = load i64, ptr %532, align 8, !tbaa !9
  %534 = and i64 %533, %496
  %535 = or i64 %534, %531
  store i64 %535, ptr %532, align 8, !tbaa !9
  %indvars.iv.next1132 = add nuw nsw i64 %indvars.iv1131, 1
  %exitcond1135.not = icmp eq i64 %indvars.iv.next1132, %84
  br i1 %exitcond1135.not, label %._crit_edge951, label %scalar.ph1709, !llvm.loop !57

._crit_edge955.thread:                            ; preds = %._crit_edge951.thread, %._crit_edge951
  %536 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 5)
  br label %._crit_edge959.thread

._crit_edge955:                                   ; preds = %scalar.ph1690, %middle.block1689
  %537 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 5)
  br i1 %.not1031, label %._crit_edge959.thread, label %.lr.ph958

.lr.ph958:                                        ; preds = %._crit_edge955
  %538 = xor i64 %537, -1
  br i1 %min.iters.check1672, label %scalar.ph1671.preheader, label %vector.ph1673

scalar.ph1671.preheader:                          ; preds = %middle.block1670, %.lr.ph958
  %indvars.iv1141.ph = phi i64 [ 0, %.lr.ph958 ], [ %n.vec1675, %middle.block1670 ]
  br label %scalar.ph1671

vector.ph1673:                                    ; preds = %.lr.ph958
  %broadcast.splatinsert1681 = insertelement <2 x i64> poison, i64 %537, i64 0
  %broadcast.splat1682 = shufflevector <2 x i64> %broadcast.splatinsert1681, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1685 = insertelement <2 x i64> poison, i64 %538, i64 0
  %broadcast.splat1686 = shufflevector <2 x i64> %broadcast.splatinsert1685, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1677

vector.body1677:                                  ; preds = %vector.body1677, %vector.ph1673
  %index1678 = phi i64 [ 0, %vector.ph1673 ], [ %index.next1687, %vector.body1677 ]
  %539 = getelementptr inbounds i64, ptr %102, i64 %index1678
  %540 = getelementptr inbounds i8, ptr %539, i64 16
  %wide.load1679 = load <2 x i64>, ptr %539, align 8, !tbaa !9
  %wide.load1680 = load <2 x i64>, ptr %540, align 8, !tbaa !9
  %541 = and <2 x i64> %wide.load1679, %broadcast.splat1682
  %542 = and <2 x i64> %wide.load1680, %broadcast.splat1682
  %543 = getelementptr inbounds i64, ptr %452, i64 %index1678
  %544 = getelementptr inbounds i8, ptr %543, i64 16
  %wide.load1683 = load <2 x i64>, ptr %543, align 16, !tbaa !9
  %wide.load1684 = load <2 x i64>, ptr %544, align 16, !tbaa !9
  %545 = and <2 x i64> %wide.load1683, %broadcast.splat1686
  %546 = and <2 x i64> %wide.load1684, %broadcast.splat1686
  %547 = or <2 x i64> %545, %541
  %548 = or <2 x i64> %546, %542
  store <2 x i64> %547, ptr %543, align 16, !tbaa !9
  store <2 x i64> %548, ptr %544, align 16, !tbaa !9
  %index.next1687 = add nuw i64 %index1678, 4
  %549 = icmp eq i64 %index.next1687, %n.vec1675
  br i1 %549, label %middle.block1670, label %vector.body1677, !llvm.loop !58

middle.block1670:                                 ; preds = %vector.body1677
  br i1 %cmp.n1688, label %._crit_edge959, label %scalar.ph1671.preheader

scalar.ph1690:                                    ; preds = %scalar.ph1690.preheader, %scalar.ph1690
  %indvars.iv1136 = phi i64 [ %indvars.iv.next1137, %scalar.ph1690 ], [ %indvars.iv1136.ph, %scalar.ph1690.preheader ]
  %550 = getelementptr inbounds i64, ptr %99, i64 %indvars.iv1136
  %551 = load i64, ptr %550, align 8, !tbaa !9
  %552 = and i64 %551, %516
  %553 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1136
  %554 = load i64, ptr %553, align 8, !tbaa !9
  %555 = and i64 %554, %517
  %556 = or i64 %555, %552
  store i64 %556, ptr %553, align 8, !tbaa !9
  %indvars.iv.next1137 = add nuw nsw i64 %indvars.iv1136, 1
  %exitcond1140.not = icmp eq i64 %indvars.iv.next1137, %84
  br i1 %exitcond1140.not, label %._crit_edge955, label %scalar.ph1690, !llvm.loop !59

._crit_edge959.thread:                            ; preds = %._crit_edge955.thread, %._crit_edge955
  %557 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 6)
  br label %._crit_edge963.thread

._crit_edge959:                                   ; preds = %scalar.ph1671, %middle.block1670
  %558 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 6)
  br i1 %.not1031, label %._crit_edge963.thread, label %.lr.ph962

.lr.ph962:                                        ; preds = %._crit_edge959
  %559 = xor i64 %558, -1
  br i1 %min.iters.check1653, label %scalar.ph1652.preheader, label %vector.ph1654

scalar.ph1652.preheader:                          ; preds = %middle.block1651, %.lr.ph962
  %indvars.iv1146.ph = phi i64 [ 0, %.lr.ph962 ], [ %n.vec1656, %middle.block1651 ]
  br label %scalar.ph1652

vector.ph1654:                                    ; preds = %.lr.ph962
  %broadcast.splatinsert1662 = insertelement <2 x i64> poison, i64 %558, i64 0
  %broadcast.splat1663 = shufflevector <2 x i64> %broadcast.splatinsert1662, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1666 = insertelement <2 x i64> poison, i64 %559, i64 0
  %broadcast.splat1667 = shufflevector <2 x i64> %broadcast.splatinsert1666, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1658

vector.body1658:                                  ; preds = %vector.body1658, %vector.ph1654
  %index1659 = phi i64 [ 0, %vector.ph1654 ], [ %index.next1668, %vector.body1658 ]
  %560 = getelementptr inbounds i64, ptr %105, i64 %index1659
  %561 = getelementptr inbounds i8, ptr %560, i64 16
  %wide.load1660 = load <2 x i64>, ptr %560, align 16, !tbaa !9
  %wide.load1661 = load <2 x i64>, ptr %561, align 16, !tbaa !9
  %562 = and <2 x i64> %wide.load1660, %broadcast.splat1663
  %563 = and <2 x i64> %wide.load1661, %broadcast.splat1663
  %564 = getelementptr inbounds i64, ptr %452, i64 %index1659
  %565 = getelementptr inbounds i8, ptr %564, i64 16
  %wide.load1664 = load <2 x i64>, ptr %564, align 16, !tbaa !9
  %wide.load1665 = load <2 x i64>, ptr %565, align 16, !tbaa !9
  %566 = and <2 x i64> %wide.load1664, %broadcast.splat1667
  %567 = and <2 x i64> %wide.load1665, %broadcast.splat1667
  %568 = or <2 x i64> %566, %562
  %569 = or <2 x i64> %567, %563
  store <2 x i64> %568, ptr %564, align 16, !tbaa !9
  store <2 x i64> %569, ptr %565, align 16, !tbaa !9
  %index.next1668 = add nuw i64 %index1659, 4
  %570 = icmp eq i64 %index.next1668, %n.vec1656
  br i1 %570, label %middle.block1651, label %vector.body1658, !llvm.loop !60

middle.block1651:                                 ; preds = %vector.body1658
  br i1 %cmp.n1669, label %._crit_edge963, label %scalar.ph1652.preheader

scalar.ph1671:                                    ; preds = %scalar.ph1671.preheader, %scalar.ph1671
  %indvars.iv1141 = phi i64 [ %indvars.iv.next1142, %scalar.ph1671 ], [ %indvars.iv1141.ph, %scalar.ph1671.preheader ]
  %571 = getelementptr inbounds i64, ptr %102, i64 %indvars.iv1141
  %572 = load i64, ptr %571, align 8, !tbaa !9
  %573 = and i64 %572, %537
  %574 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1141
  %575 = load i64, ptr %574, align 8, !tbaa !9
  %576 = and i64 %575, %538
  %577 = or i64 %576, %573
  store i64 %577, ptr %574, align 8, !tbaa !9
  %indvars.iv.next1142 = add nuw nsw i64 %indvars.iv1141, 1
  %exitcond1145.not = icmp eq i64 %indvars.iv.next1142, %84
  br i1 %exitcond1145.not, label %._crit_edge959, label %scalar.ph1671, !llvm.loop !61

._crit_edge963.thread:                            ; preds = %._crit_edge959.thread, %._crit_edge959
  %578 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 7)
  br label %._crit_edge967.thread

._crit_edge963:                                   ; preds = %scalar.ph1652, %middle.block1651
  %579 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 7)
  br i1 %.not1031, label %._crit_edge967.thread, label %.lr.ph966

.lr.ph966:                                        ; preds = %._crit_edge963
  %580 = xor i64 %579, -1
  br i1 %min.iters.check1634, label %scalar.ph1633.preheader, label %vector.ph1635

scalar.ph1633.preheader:                          ; preds = %middle.block1632, %.lr.ph966
  %indvars.iv1151.ph = phi i64 [ 0, %.lr.ph966 ], [ %n.vec1637, %middle.block1632 ]
  br label %scalar.ph1633

vector.ph1635:                                    ; preds = %.lr.ph966
  %broadcast.splatinsert1643 = insertelement <2 x i64> poison, i64 %579, i64 0
  %broadcast.splat1644 = shufflevector <2 x i64> %broadcast.splatinsert1643, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1647 = insertelement <2 x i64> poison, i64 %580, i64 0
  %broadcast.splat1648 = shufflevector <2 x i64> %broadcast.splatinsert1647, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1639

vector.body1639:                                  ; preds = %vector.body1639, %vector.ph1635
  %index1640 = phi i64 [ 0, %vector.ph1635 ], [ %index.next1649, %vector.body1639 ]
  %581 = getelementptr inbounds i64, ptr %108, i64 %index1640
  %582 = getelementptr inbounds i8, ptr %581, i64 16
  %wide.load1641 = load <2 x i64>, ptr %581, align 8, !tbaa !9
  %wide.load1642 = load <2 x i64>, ptr %582, align 8, !tbaa !9
  %583 = and <2 x i64> %wide.load1641, %broadcast.splat1644
  %584 = and <2 x i64> %wide.load1642, %broadcast.splat1644
  %585 = getelementptr inbounds i64, ptr %452, i64 %index1640
  %586 = getelementptr inbounds i8, ptr %585, i64 16
  %wide.load1645 = load <2 x i64>, ptr %585, align 16, !tbaa !9
  %wide.load1646 = load <2 x i64>, ptr %586, align 16, !tbaa !9
  %587 = and <2 x i64> %wide.load1645, %broadcast.splat1648
  %588 = and <2 x i64> %wide.load1646, %broadcast.splat1648
  %589 = or <2 x i64> %587, %583
  %590 = or <2 x i64> %588, %584
  store <2 x i64> %589, ptr %585, align 16, !tbaa !9
  store <2 x i64> %590, ptr %586, align 16, !tbaa !9
  %index.next1649 = add nuw i64 %index1640, 4
  %591 = icmp eq i64 %index.next1649, %n.vec1637
  br i1 %591, label %middle.block1632, label %vector.body1639, !llvm.loop !62

middle.block1632:                                 ; preds = %vector.body1639
  br i1 %cmp.n1650, label %._crit_edge967, label %scalar.ph1633.preheader

scalar.ph1652:                                    ; preds = %scalar.ph1652.preheader, %scalar.ph1652
  %indvars.iv1146 = phi i64 [ %indvars.iv.next1147, %scalar.ph1652 ], [ %indvars.iv1146.ph, %scalar.ph1652.preheader ]
  %592 = getelementptr inbounds i64, ptr %105, i64 %indvars.iv1146
  %593 = load i64, ptr %592, align 8, !tbaa !9
  %594 = and i64 %593, %558
  %595 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1146
  %596 = load i64, ptr %595, align 8, !tbaa !9
  %597 = and i64 %596, %559
  %598 = or i64 %597, %594
  store i64 %598, ptr %595, align 8, !tbaa !9
  %indvars.iv.next1147 = add nuw nsw i64 %indvars.iv1146, 1
  %exitcond1150.not = icmp eq i64 %indvars.iv.next1147, %84
  br i1 %exitcond1150.not, label %._crit_edge963, label %scalar.ph1652, !llvm.loop !63

._crit_edge967.thread:                            ; preds = %._crit_edge963.thread, %._crit_edge963
  %599 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 8)
  br label %._crit_edge971.thread

._crit_edge967:                                   ; preds = %scalar.ph1633, %middle.block1632
  %600 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 8)
  br i1 %.not1031, label %._crit_edge971.thread, label %.lr.ph970

.lr.ph970:                                        ; preds = %._crit_edge967
  %601 = xor i64 %600, -1
  br i1 %min.iters.check1615, label %scalar.ph1614.preheader, label %vector.ph1616

scalar.ph1614.preheader:                          ; preds = %middle.block1613, %.lr.ph970
  %indvars.iv1156.ph = phi i64 [ 0, %.lr.ph970 ], [ %n.vec1618, %middle.block1613 ]
  br label %scalar.ph1614

vector.ph1616:                                    ; preds = %.lr.ph970
  %broadcast.splatinsert1624 = insertelement <2 x i64> poison, i64 %600, i64 0
  %broadcast.splat1625 = shufflevector <2 x i64> %broadcast.splatinsert1624, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1628 = insertelement <2 x i64> poison, i64 %601, i64 0
  %broadcast.splat1629 = shufflevector <2 x i64> %broadcast.splatinsert1628, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1620

vector.body1620:                                  ; preds = %vector.body1620, %vector.ph1616
  %index1621 = phi i64 [ 0, %vector.ph1616 ], [ %index.next1630, %vector.body1620 ]
  %602 = getelementptr inbounds i64, ptr %111, i64 %index1621
  %603 = getelementptr inbounds i8, ptr %602, i64 16
  %wide.load1622 = load <2 x i64>, ptr %602, align 16, !tbaa !9
  %wide.load1623 = load <2 x i64>, ptr %603, align 16, !tbaa !9
  %604 = and <2 x i64> %wide.load1622, %broadcast.splat1625
  %605 = and <2 x i64> %wide.load1623, %broadcast.splat1625
  %606 = getelementptr inbounds i64, ptr %452, i64 %index1621
  %607 = getelementptr inbounds i8, ptr %606, i64 16
  %wide.load1626 = load <2 x i64>, ptr %606, align 16, !tbaa !9
  %wide.load1627 = load <2 x i64>, ptr %607, align 16, !tbaa !9
  %608 = and <2 x i64> %wide.load1626, %broadcast.splat1629
  %609 = and <2 x i64> %wide.load1627, %broadcast.splat1629
  %610 = or <2 x i64> %608, %604
  %611 = or <2 x i64> %609, %605
  store <2 x i64> %610, ptr %606, align 16, !tbaa !9
  store <2 x i64> %611, ptr %607, align 16, !tbaa !9
  %index.next1630 = add nuw i64 %index1621, 4
  %612 = icmp eq i64 %index.next1630, %n.vec1618
  br i1 %612, label %middle.block1613, label %vector.body1620, !llvm.loop !64

middle.block1613:                                 ; preds = %vector.body1620
  br i1 %cmp.n1631, label %._crit_edge971, label %scalar.ph1614.preheader

scalar.ph1633:                                    ; preds = %scalar.ph1633.preheader, %scalar.ph1633
  %indvars.iv1151 = phi i64 [ %indvars.iv.next1152, %scalar.ph1633 ], [ %indvars.iv1151.ph, %scalar.ph1633.preheader ]
  %613 = getelementptr inbounds i64, ptr %108, i64 %indvars.iv1151
  %614 = load i64, ptr %613, align 8, !tbaa !9
  %615 = and i64 %614, %579
  %616 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1151
  %617 = load i64, ptr %616, align 8, !tbaa !9
  %618 = and i64 %617, %580
  %619 = or i64 %618, %615
  store i64 %619, ptr %616, align 8, !tbaa !9
  %indvars.iv.next1152 = add nuw nsw i64 %indvars.iv1151, 1
  %exitcond1155.not = icmp eq i64 %indvars.iv.next1152, %84
  br i1 %exitcond1155.not, label %._crit_edge967, label %scalar.ph1633, !llvm.loop !65

._crit_edge971.thread:                            ; preds = %._crit_edge967.thread, %._crit_edge967
  %620 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 9)
  br label %._crit_edge975.thread

._crit_edge971:                                   ; preds = %scalar.ph1614, %middle.block1613
  %621 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 9)
  br i1 %.not1031, label %._crit_edge975.thread, label %.lr.ph974

.lr.ph974:                                        ; preds = %._crit_edge971
  %622 = xor i64 %621, -1
  br i1 %min.iters.check1596, label %scalar.ph1595.preheader, label %vector.ph1597

scalar.ph1595.preheader:                          ; preds = %middle.block1594, %.lr.ph974
  %indvars.iv1161.ph = phi i64 [ 0, %.lr.ph974 ], [ %n.vec1599, %middle.block1594 ]
  br label %scalar.ph1595

vector.ph1597:                                    ; preds = %.lr.ph974
  %broadcast.splatinsert1605 = insertelement <2 x i64> poison, i64 %621, i64 0
  %broadcast.splat1606 = shufflevector <2 x i64> %broadcast.splatinsert1605, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1609 = insertelement <2 x i64> poison, i64 %622, i64 0
  %broadcast.splat1610 = shufflevector <2 x i64> %broadcast.splatinsert1609, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1601

vector.body1601:                                  ; preds = %vector.body1601, %vector.ph1597
  %index1602 = phi i64 [ 0, %vector.ph1597 ], [ %index.next1611, %vector.body1601 ]
  %623 = getelementptr inbounds i64, ptr %114, i64 %index1602
  %624 = getelementptr inbounds i8, ptr %623, i64 16
  %wide.load1603 = load <2 x i64>, ptr %623, align 8, !tbaa !9
  %wide.load1604 = load <2 x i64>, ptr %624, align 8, !tbaa !9
  %625 = and <2 x i64> %wide.load1603, %broadcast.splat1606
  %626 = and <2 x i64> %wide.load1604, %broadcast.splat1606
  %627 = getelementptr inbounds i64, ptr %452, i64 %index1602
  %628 = getelementptr inbounds i8, ptr %627, i64 16
  %wide.load1607 = load <2 x i64>, ptr %627, align 16, !tbaa !9
  %wide.load1608 = load <2 x i64>, ptr %628, align 16, !tbaa !9
  %629 = and <2 x i64> %wide.load1607, %broadcast.splat1610
  %630 = and <2 x i64> %wide.load1608, %broadcast.splat1610
  %631 = or <2 x i64> %629, %625
  %632 = or <2 x i64> %630, %626
  store <2 x i64> %631, ptr %627, align 16, !tbaa !9
  store <2 x i64> %632, ptr %628, align 16, !tbaa !9
  %index.next1611 = add nuw i64 %index1602, 4
  %633 = icmp eq i64 %index.next1611, %n.vec1599
  br i1 %633, label %middle.block1594, label %vector.body1601, !llvm.loop !66

middle.block1594:                                 ; preds = %vector.body1601
  br i1 %cmp.n1612, label %._crit_edge975, label %scalar.ph1595.preheader

scalar.ph1614:                                    ; preds = %scalar.ph1614.preheader, %scalar.ph1614
  %indvars.iv1156 = phi i64 [ %indvars.iv.next1157, %scalar.ph1614 ], [ %indvars.iv1156.ph, %scalar.ph1614.preheader ]
  %634 = getelementptr inbounds i64, ptr %111, i64 %indvars.iv1156
  %635 = load i64, ptr %634, align 8, !tbaa !9
  %636 = and i64 %635, %600
  %637 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1156
  %638 = load i64, ptr %637, align 8, !tbaa !9
  %639 = and i64 %638, %601
  %640 = or i64 %639, %636
  store i64 %640, ptr %637, align 8, !tbaa !9
  %indvars.iv.next1157 = add nuw nsw i64 %indvars.iv1156, 1
  %exitcond1160.not = icmp eq i64 %indvars.iv.next1157, %84
  br i1 %exitcond1160.not, label %._crit_edge971, label %scalar.ph1614, !llvm.loop !67

._crit_edge975.thread:                            ; preds = %._crit_edge971.thread, %._crit_edge971
  %641 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 10)
  br label %._crit_edge979.thread

._crit_edge975:                                   ; preds = %scalar.ph1595, %middle.block1594
  %642 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 10)
  br i1 %.not1031, label %._crit_edge979.thread, label %.lr.ph978

.lr.ph978:                                        ; preds = %._crit_edge975
  %643 = xor i64 %642, -1
  br i1 %min.iters.check1577, label %scalar.ph1576.preheader, label %vector.ph1578

scalar.ph1576.preheader:                          ; preds = %middle.block1575, %.lr.ph978
  %indvars.iv1166.ph = phi i64 [ 0, %.lr.ph978 ], [ %n.vec1580, %middle.block1575 ]
  br label %scalar.ph1576

vector.ph1578:                                    ; preds = %.lr.ph978
  %broadcast.splatinsert1586 = insertelement <2 x i64> poison, i64 %642, i64 0
  %broadcast.splat1587 = shufflevector <2 x i64> %broadcast.splatinsert1586, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1590 = insertelement <2 x i64> poison, i64 %643, i64 0
  %broadcast.splat1591 = shufflevector <2 x i64> %broadcast.splatinsert1590, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1582

vector.body1582:                                  ; preds = %vector.body1582, %vector.ph1578
  %index1583 = phi i64 [ 0, %vector.ph1578 ], [ %index.next1592, %vector.body1582 ]
  %644 = getelementptr inbounds i64, ptr %117, i64 %index1583
  %645 = getelementptr inbounds i8, ptr %644, i64 16
  %wide.load1584 = load <2 x i64>, ptr %644, align 16, !tbaa !9
  %wide.load1585 = load <2 x i64>, ptr %645, align 16, !tbaa !9
  %646 = and <2 x i64> %wide.load1584, %broadcast.splat1587
  %647 = and <2 x i64> %wide.load1585, %broadcast.splat1587
  %648 = getelementptr inbounds i64, ptr %452, i64 %index1583
  %649 = getelementptr inbounds i8, ptr %648, i64 16
  %wide.load1588 = load <2 x i64>, ptr %648, align 16, !tbaa !9
  %wide.load1589 = load <2 x i64>, ptr %649, align 16, !tbaa !9
  %650 = and <2 x i64> %wide.load1588, %broadcast.splat1591
  %651 = and <2 x i64> %wide.load1589, %broadcast.splat1591
  %652 = or <2 x i64> %650, %646
  %653 = or <2 x i64> %651, %647
  store <2 x i64> %652, ptr %648, align 16, !tbaa !9
  store <2 x i64> %653, ptr %649, align 16, !tbaa !9
  %index.next1592 = add nuw i64 %index1583, 4
  %654 = icmp eq i64 %index.next1592, %n.vec1580
  br i1 %654, label %middle.block1575, label %vector.body1582, !llvm.loop !68

middle.block1575:                                 ; preds = %vector.body1582
  br i1 %cmp.n1593, label %._crit_edge979, label %scalar.ph1576.preheader

scalar.ph1595:                                    ; preds = %scalar.ph1595.preheader, %scalar.ph1595
  %indvars.iv1161 = phi i64 [ %indvars.iv.next1162, %scalar.ph1595 ], [ %indvars.iv1161.ph, %scalar.ph1595.preheader ]
  %655 = getelementptr inbounds i64, ptr %114, i64 %indvars.iv1161
  %656 = load i64, ptr %655, align 8, !tbaa !9
  %657 = and i64 %656, %621
  %658 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1161
  %659 = load i64, ptr %658, align 8, !tbaa !9
  %660 = and i64 %659, %622
  %661 = or i64 %660, %657
  store i64 %661, ptr %658, align 8, !tbaa !9
  %indvars.iv.next1162 = add nuw nsw i64 %indvars.iv1161, 1
  %exitcond1165.not = icmp eq i64 %indvars.iv.next1162, %84
  br i1 %exitcond1165.not, label %._crit_edge975, label %scalar.ph1595, !llvm.loop !69

._crit_edge979.thread:                            ; preds = %._crit_edge975.thread, %._crit_edge975
  %662 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 11)
  br label %._crit_edge983.thread

._crit_edge979:                                   ; preds = %scalar.ph1576, %middle.block1575
  %663 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 11)
  br i1 %.not1031, label %._crit_edge983.thread, label %.lr.ph982

.lr.ph982:                                        ; preds = %._crit_edge979
  %664 = xor i64 %663, -1
  br i1 %min.iters.check1558, label %scalar.ph1557.preheader, label %vector.ph1559

scalar.ph1557.preheader:                          ; preds = %middle.block1556, %.lr.ph982
  %indvars.iv1171.ph = phi i64 [ 0, %.lr.ph982 ], [ %n.vec1561, %middle.block1556 ]
  br label %scalar.ph1557

vector.ph1559:                                    ; preds = %.lr.ph982
  %broadcast.splatinsert1567 = insertelement <2 x i64> poison, i64 %663, i64 0
  %broadcast.splat1568 = shufflevector <2 x i64> %broadcast.splatinsert1567, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1571 = insertelement <2 x i64> poison, i64 %664, i64 0
  %broadcast.splat1572 = shufflevector <2 x i64> %broadcast.splatinsert1571, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1563

vector.body1563:                                  ; preds = %vector.body1563, %vector.ph1559
  %index1564 = phi i64 [ 0, %vector.ph1559 ], [ %index.next1573, %vector.body1563 ]
  %665 = getelementptr inbounds i64, ptr %120, i64 %index1564
  %666 = getelementptr inbounds i8, ptr %665, i64 16
  %wide.load1565 = load <2 x i64>, ptr %665, align 8, !tbaa !9
  %wide.load1566 = load <2 x i64>, ptr %666, align 8, !tbaa !9
  %667 = and <2 x i64> %wide.load1565, %broadcast.splat1568
  %668 = and <2 x i64> %wide.load1566, %broadcast.splat1568
  %669 = getelementptr inbounds i64, ptr %452, i64 %index1564
  %670 = getelementptr inbounds i8, ptr %669, i64 16
  %wide.load1569 = load <2 x i64>, ptr %669, align 16, !tbaa !9
  %wide.load1570 = load <2 x i64>, ptr %670, align 16, !tbaa !9
  %671 = and <2 x i64> %wide.load1569, %broadcast.splat1572
  %672 = and <2 x i64> %wide.load1570, %broadcast.splat1572
  %673 = or <2 x i64> %671, %667
  %674 = or <2 x i64> %672, %668
  store <2 x i64> %673, ptr %669, align 16, !tbaa !9
  store <2 x i64> %674, ptr %670, align 16, !tbaa !9
  %index.next1573 = add nuw i64 %index1564, 4
  %675 = icmp eq i64 %index.next1573, %n.vec1561
  br i1 %675, label %middle.block1556, label %vector.body1563, !llvm.loop !70

middle.block1556:                                 ; preds = %vector.body1563
  br i1 %cmp.n1574, label %._crit_edge983, label %scalar.ph1557.preheader

scalar.ph1576:                                    ; preds = %scalar.ph1576.preheader, %scalar.ph1576
  %indvars.iv1166 = phi i64 [ %indvars.iv.next1167, %scalar.ph1576 ], [ %indvars.iv1166.ph, %scalar.ph1576.preheader ]
  %676 = getelementptr inbounds i64, ptr %117, i64 %indvars.iv1166
  %677 = load i64, ptr %676, align 8, !tbaa !9
  %678 = and i64 %677, %642
  %679 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1166
  %680 = load i64, ptr %679, align 8, !tbaa !9
  %681 = and i64 %680, %643
  %682 = or i64 %681, %678
  store i64 %682, ptr %679, align 8, !tbaa !9
  %indvars.iv.next1167 = add nuw nsw i64 %indvars.iv1166, 1
  %exitcond1170.not = icmp eq i64 %indvars.iv.next1167, %84
  br i1 %exitcond1170.not, label %._crit_edge979, label %scalar.ph1576, !llvm.loop !71

._crit_edge983.thread:                            ; preds = %._crit_edge979.thread, %._crit_edge979
  %683 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 12)
  br label %._crit_edge987.thread

._crit_edge983:                                   ; preds = %scalar.ph1557, %middle.block1556
  %684 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 12)
  br i1 %.not1031, label %._crit_edge987.thread, label %.lr.ph986

.lr.ph986:                                        ; preds = %._crit_edge983
  %685 = xor i64 %684, -1
  br i1 %min.iters.check1539, label %scalar.ph1538.preheader, label %vector.ph1540

scalar.ph1538.preheader:                          ; preds = %middle.block1537, %.lr.ph986
  %indvars.iv1176.ph = phi i64 [ 0, %.lr.ph986 ], [ %n.vec1542, %middle.block1537 ]
  br label %scalar.ph1538

vector.ph1540:                                    ; preds = %.lr.ph986
  %broadcast.splatinsert1548 = insertelement <2 x i64> poison, i64 %684, i64 0
  %broadcast.splat1549 = shufflevector <2 x i64> %broadcast.splatinsert1548, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1552 = insertelement <2 x i64> poison, i64 %685, i64 0
  %broadcast.splat1553 = shufflevector <2 x i64> %broadcast.splatinsert1552, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1544

vector.body1544:                                  ; preds = %vector.body1544, %vector.ph1540
  %index1545 = phi i64 [ 0, %vector.ph1540 ], [ %index.next1554, %vector.body1544 ]
  %686 = getelementptr inbounds i64, ptr %123, i64 %index1545
  %687 = getelementptr inbounds i8, ptr %686, i64 16
  %wide.load1546 = load <2 x i64>, ptr %686, align 16, !tbaa !9
  %wide.load1547 = load <2 x i64>, ptr %687, align 16, !tbaa !9
  %688 = and <2 x i64> %wide.load1546, %broadcast.splat1549
  %689 = and <2 x i64> %wide.load1547, %broadcast.splat1549
  %690 = getelementptr inbounds i64, ptr %452, i64 %index1545
  %691 = getelementptr inbounds i8, ptr %690, i64 16
  %wide.load1550 = load <2 x i64>, ptr %690, align 16, !tbaa !9
  %wide.load1551 = load <2 x i64>, ptr %691, align 16, !tbaa !9
  %692 = and <2 x i64> %wide.load1550, %broadcast.splat1553
  %693 = and <2 x i64> %wide.load1551, %broadcast.splat1553
  %694 = or <2 x i64> %692, %688
  %695 = or <2 x i64> %693, %689
  store <2 x i64> %694, ptr %690, align 16, !tbaa !9
  store <2 x i64> %695, ptr %691, align 16, !tbaa !9
  %index.next1554 = add nuw i64 %index1545, 4
  %696 = icmp eq i64 %index.next1554, %n.vec1542
  br i1 %696, label %middle.block1537, label %vector.body1544, !llvm.loop !72

middle.block1537:                                 ; preds = %vector.body1544
  br i1 %cmp.n1555, label %._crit_edge987, label %scalar.ph1538.preheader

scalar.ph1557:                                    ; preds = %scalar.ph1557.preheader, %scalar.ph1557
  %indvars.iv1171 = phi i64 [ %indvars.iv.next1172, %scalar.ph1557 ], [ %indvars.iv1171.ph, %scalar.ph1557.preheader ]
  %697 = getelementptr inbounds i64, ptr %120, i64 %indvars.iv1171
  %698 = load i64, ptr %697, align 8, !tbaa !9
  %699 = and i64 %698, %663
  %700 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1171
  %701 = load i64, ptr %700, align 8, !tbaa !9
  %702 = and i64 %701, %664
  %703 = or i64 %702, %699
  store i64 %703, ptr %700, align 8, !tbaa !9
  %indvars.iv.next1172 = add nuw nsw i64 %indvars.iv1171, 1
  %exitcond1175.not = icmp eq i64 %indvars.iv.next1172, %84
  br i1 %exitcond1175.not, label %._crit_edge983, label %scalar.ph1557, !llvm.loop !73

._crit_edge987.thread:                            ; preds = %._crit_edge983.thread, %._crit_edge983
  %704 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 13)
  br label %._crit_edge991.thread

._crit_edge987:                                   ; preds = %scalar.ph1538, %middle.block1537
  %705 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 13)
  br i1 %.not1031, label %._crit_edge991.thread, label %.lr.ph990

.lr.ph990:                                        ; preds = %._crit_edge987
  %706 = xor i64 %705, -1
  br i1 %min.iters.check1520, label %scalar.ph1519.preheader, label %vector.ph1521

scalar.ph1519.preheader:                          ; preds = %middle.block1518, %.lr.ph990
  %indvars.iv1181.ph = phi i64 [ 0, %.lr.ph990 ], [ %n.vec1523, %middle.block1518 ]
  br label %scalar.ph1519

vector.ph1521:                                    ; preds = %.lr.ph990
  %broadcast.splatinsert1529 = insertelement <2 x i64> poison, i64 %705, i64 0
  %broadcast.splat1530 = shufflevector <2 x i64> %broadcast.splatinsert1529, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1533 = insertelement <2 x i64> poison, i64 %706, i64 0
  %broadcast.splat1534 = shufflevector <2 x i64> %broadcast.splatinsert1533, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1525

vector.body1525:                                  ; preds = %vector.body1525, %vector.ph1521
  %index1526 = phi i64 [ 0, %vector.ph1521 ], [ %index.next1535, %vector.body1525 ]
  %707 = getelementptr inbounds i64, ptr %126, i64 %index1526
  %708 = getelementptr inbounds i8, ptr %707, i64 16
  %wide.load1527 = load <2 x i64>, ptr %707, align 8, !tbaa !9
  %wide.load1528 = load <2 x i64>, ptr %708, align 8, !tbaa !9
  %709 = and <2 x i64> %wide.load1527, %broadcast.splat1530
  %710 = and <2 x i64> %wide.load1528, %broadcast.splat1530
  %711 = getelementptr inbounds i64, ptr %452, i64 %index1526
  %712 = getelementptr inbounds i8, ptr %711, i64 16
  %wide.load1531 = load <2 x i64>, ptr %711, align 16, !tbaa !9
  %wide.load1532 = load <2 x i64>, ptr %712, align 16, !tbaa !9
  %713 = and <2 x i64> %wide.load1531, %broadcast.splat1534
  %714 = and <2 x i64> %wide.load1532, %broadcast.splat1534
  %715 = or <2 x i64> %713, %709
  %716 = or <2 x i64> %714, %710
  store <2 x i64> %715, ptr %711, align 16, !tbaa !9
  store <2 x i64> %716, ptr %712, align 16, !tbaa !9
  %index.next1535 = add nuw i64 %index1526, 4
  %717 = icmp eq i64 %index.next1535, %n.vec1523
  br i1 %717, label %middle.block1518, label %vector.body1525, !llvm.loop !74

middle.block1518:                                 ; preds = %vector.body1525
  br i1 %cmp.n1536, label %._crit_edge991, label %scalar.ph1519.preheader

scalar.ph1538:                                    ; preds = %scalar.ph1538.preheader, %scalar.ph1538
  %indvars.iv1176 = phi i64 [ %indvars.iv.next1177, %scalar.ph1538 ], [ %indvars.iv1176.ph, %scalar.ph1538.preheader ]
  %718 = getelementptr inbounds i64, ptr %123, i64 %indvars.iv1176
  %719 = load i64, ptr %718, align 8, !tbaa !9
  %720 = and i64 %719, %684
  %721 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1176
  %722 = load i64, ptr %721, align 8, !tbaa !9
  %723 = and i64 %722, %685
  %724 = or i64 %723, %720
  store i64 %724, ptr %721, align 8, !tbaa !9
  %indvars.iv.next1177 = add nuw nsw i64 %indvars.iv1176, 1
  %exitcond1180.not = icmp eq i64 %indvars.iv.next1177, %84
  br i1 %exitcond1180.not, label %._crit_edge987, label %scalar.ph1538, !llvm.loop !75

._crit_edge991.thread:                            ; preds = %._crit_edge987.thread, %._crit_edge987
  %725 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 14)
  br label %._crit_edge995.thread

._crit_edge991:                                   ; preds = %scalar.ph1519, %middle.block1518
  %726 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 14)
  br i1 %.not1031, label %._crit_edge995.thread, label %.lr.ph994

.lr.ph994:                                        ; preds = %._crit_edge991
  %727 = xor i64 %726, -1
  br i1 %min.iters.check1501, label %scalar.ph1500.preheader, label %vector.ph1502

scalar.ph1500.preheader:                          ; preds = %middle.block1499, %.lr.ph994
  %indvars.iv1186.ph = phi i64 [ 0, %.lr.ph994 ], [ %n.vec1504, %middle.block1499 ]
  br label %scalar.ph1500

vector.ph1502:                                    ; preds = %.lr.ph994
  %broadcast.splatinsert1510 = insertelement <2 x i64> poison, i64 %726, i64 0
  %broadcast.splat1511 = shufflevector <2 x i64> %broadcast.splatinsert1510, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1514 = insertelement <2 x i64> poison, i64 %727, i64 0
  %broadcast.splat1515 = shufflevector <2 x i64> %broadcast.splatinsert1514, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1506

vector.body1506:                                  ; preds = %vector.body1506, %vector.ph1502
  %index1507 = phi i64 [ 0, %vector.ph1502 ], [ %index.next1516, %vector.body1506 ]
  %728 = getelementptr inbounds i64, ptr %129, i64 %index1507
  %729 = getelementptr inbounds i8, ptr %728, i64 16
  %wide.load1508 = load <2 x i64>, ptr %728, align 16, !tbaa !9
  %wide.load1509 = load <2 x i64>, ptr %729, align 16, !tbaa !9
  %730 = and <2 x i64> %wide.load1508, %broadcast.splat1511
  %731 = and <2 x i64> %wide.load1509, %broadcast.splat1511
  %732 = getelementptr inbounds i64, ptr %452, i64 %index1507
  %733 = getelementptr inbounds i8, ptr %732, i64 16
  %wide.load1512 = load <2 x i64>, ptr %732, align 16, !tbaa !9
  %wide.load1513 = load <2 x i64>, ptr %733, align 16, !tbaa !9
  %734 = and <2 x i64> %wide.load1512, %broadcast.splat1515
  %735 = and <2 x i64> %wide.load1513, %broadcast.splat1515
  %736 = or <2 x i64> %734, %730
  %737 = or <2 x i64> %735, %731
  store <2 x i64> %736, ptr %732, align 16, !tbaa !9
  store <2 x i64> %737, ptr %733, align 16, !tbaa !9
  %index.next1516 = add nuw i64 %index1507, 4
  %738 = icmp eq i64 %index.next1516, %n.vec1504
  br i1 %738, label %middle.block1499, label %vector.body1506, !llvm.loop !76

middle.block1499:                                 ; preds = %vector.body1506
  br i1 %cmp.n1517, label %._crit_edge995, label %scalar.ph1500.preheader

scalar.ph1519:                                    ; preds = %scalar.ph1519.preheader, %scalar.ph1519
  %indvars.iv1181 = phi i64 [ %indvars.iv.next1182, %scalar.ph1519 ], [ %indvars.iv1181.ph, %scalar.ph1519.preheader ]
  %739 = getelementptr inbounds i64, ptr %126, i64 %indvars.iv1181
  %740 = load i64, ptr %739, align 8, !tbaa !9
  %741 = and i64 %740, %705
  %742 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1181
  %743 = load i64, ptr %742, align 8, !tbaa !9
  %744 = and i64 %743, %706
  %745 = or i64 %744, %741
  store i64 %745, ptr %742, align 8, !tbaa !9
  %indvars.iv.next1182 = add nuw nsw i64 %indvars.iv1181, 1
  %exitcond1185.not = icmp eq i64 %indvars.iv.next1182, %84
  br i1 %exitcond1185.not, label %._crit_edge991, label %scalar.ph1519, !llvm.loop !77

._crit_edge995.thread:                            ; preds = %._crit_edge991.thread, %._crit_edge991
  %746 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 15)
  br label %._crit_edge999

._crit_edge995:                                   ; preds = %scalar.ph1500, %middle.block1499
  %747 = call i64 @FStar_UInt64_eq_mask(i64 noundef %459, i64 noundef 15)
  br i1 %.not1031, label %._crit_edge999, label %.lr.ph998

.lr.ph998:                                        ; preds = %._crit_edge995
  %748 = xor i64 %747, -1
  br i1 %min.iters.check1482, label %scalar.ph1481.preheader, label %vector.ph1483

scalar.ph1481.preheader:                          ; preds = %middle.block1480, %.lr.ph998
  %indvars.iv1191.ph = phi i64 [ 0, %.lr.ph998 ], [ %n.vec1485, %middle.block1480 ]
  br label %scalar.ph1481

vector.ph1483:                                    ; preds = %.lr.ph998
  %broadcast.splatinsert1491 = insertelement <2 x i64> poison, i64 %747, i64 0
  %broadcast.splat1492 = shufflevector <2 x i64> %broadcast.splatinsert1491, <2 x i64> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert1495 = insertelement <2 x i64> poison, i64 %748, i64 0
  %broadcast.splat1496 = shufflevector <2 x i64> %broadcast.splatinsert1495, <2 x i64> poison, <2 x i32> zeroinitializer
  br label %vector.body1487

vector.body1487:                                  ; preds = %vector.body1487, %vector.ph1483
  %index1488 = phi i64 [ 0, %vector.ph1483 ], [ %index.next1497, %vector.body1487 ]
  %749 = getelementptr inbounds i64, ptr %132, i64 %index1488
  %750 = getelementptr inbounds i8, ptr %749, i64 16
  %wide.load1489 = load <2 x i64>, ptr %749, align 8, !tbaa !9
  %wide.load1490 = load <2 x i64>, ptr %750, align 8, !tbaa !9
  %751 = and <2 x i64> %wide.load1489, %broadcast.splat1492
  %752 = and <2 x i64> %wide.load1490, %broadcast.splat1492
  %753 = getelementptr inbounds i64, ptr %452, i64 %index1488
  %754 = getelementptr inbounds i8, ptr %753, i64 16
  %wide.load1493 = load <2 x i64>, ptr %753, align 16, !tbaa !9
  %wide.load1494 = load <2 x i64>, ptr %754, align 16, !tbaa !9
  %755 = and <2 x i64> %wide.load1493, %broadcast.splat1496
  %756 = and <2 x i64> %wide.load1494, %broadcast.splat1496
  %757 = or <2 x i64> %755, %751
  %758 = or <2 x i64> %756, %752
  store <2 x i64> %757, ptr %753, align 16, !tbaa !9
  store <2 x i64> %758, ptr %754, align 16, !tbaa !9
  %index.next1497 = add nuw i64 %index1488, 4
  %759 = icmp eq i64 %index.next1497, %n.vec1485
  br i1 %759, label %middle.block1480, label %vector.body1487, !llvm.loop !78

middle.block1480:                                 ; preds = %vector.body1487
  br i1 %cmp.n1498, label %._crit_edge999, label %scalar.ph1481.preheader

scalar.ph1500:                                    ; preds = %scalar.ph1500.preheader, %scalar.ph1500
  %indvars.iv1186 = phi i64 [ %indvars.iv.next1187, %scalar.ph1500 ], [ %indvars.iv1186.ph, %scalar.ph1500.preheader ]
  %760 = getelementptr inbounds i64, ptr %129, i64 %indvars.iv1186
  %761 = load i64, ptr %760, align 8, !tbaa !9
  %762 = and i64 %761, %726
  %763 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1186
  %764 = load i64, ptr %763, align 8, !tbaa !9
  %765 = and i64 %764, %727
  %766 = or i64 %765, %762
  store i64 %766, ptr %763, align 8, !tbaa !9
  %indvars.iv.next1187 = add nuw nsw i64 %indvars.iv1186, 1
  %exitcond1190.not = icmp eq i64 %indvars.iv.next1187, %84
  br i1 %exitcond1190.not, label %._crit_edge995, label %scalar.ph1500, !llvm.loop !79

._crit_edge999:                                   ; preds = %scalar.ph1481, %middle.block1480, %._crit_edge995.thread, %._crit_edge995
  call void @Hacl_Bignum_Montgomery_bn_mont_mul_u64(i32 noundef %6, ptr noundef nonnull %82, i64 noundef %.sroa.9.0.copyload, ptr noundef %4, ptr noundef nonnull %452, ptr noundef %4) #7
  %767 = add nuw nsw i32 %.08711000, 1
  %exitcond1196.not = icmp eq i32 %767, %umax
  br i1 %exitcond1196.not, label %._crit_edge1014, label %456, !llvm.loop !80

scalar.ph1481:                                    ; preds = %scalar.ph1481.preheader, %scalar.ph1481
  %indvars.iv1191 = phi i64 [ %indvars.iv.next1192, %scalar.ph1481 ], [ %indvars.iv1191.ph, %scalar.ph1481.preheader ]
  %768 = getelementptr inbounds i64, ptr %132, i64 %indvars.iv1191
  %769 = load i64, ptr %768, align 8, !tbaa !9
  %770 = and i64 %769, %747
  %771 = getelementptr inbounds i64, ptr %452, i64 %indvars.iv1191
  %772 = load i64, ptr %771, align 8, !tbaa !9
  %773 = and i64 %772, %748
  %774 = or i64 %773, %770
  store i64 %774, ptr %771, align 8, !tbaa !9
  %indvars.iv.next1192 = add nuw nsw i64 %indvars.iv1191, 1
  %exitcond1195.not = icmp eq i64 %indvars.iv.next1192, %84
  br i1 %exitcond1195.not, label %._crit_edge999, label %scalar.ph1481, !llvm.loop !81

._crit_edge1014:                                  ; preds = %._crit_edge999, %scalar.ph1783, %middle.block1782, %.preheader
  ret void
}

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

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

; Function Attrs: noinline nounwind uwtable
declare hidden i64 @FStar_UInt64_eq_mask(i64 noundef, i64 noundef) local_unnamed_addr #5

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

attributes #0 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { 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 #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #4 = { inlinehint nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #5 = { noinline nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #6 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #7 = { 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 = !{!"long", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"int", !7, i64 0}
!13 = distinct !{!13, !14, !15, !16}
!14 = !{!"llvm.loop.mustprogress"}
!15 = !{!"llvm.loop.isvectorized", i32 1}
!16 = !{!"llvm.loop.unroll.runtime.disable"}
!17 = distinct !{!17, !14, !15, !16}
!18 = distinct !{!18, !14}
!19 = distinct !{!19, !14, !16, !15}
!20 = distinct !{!20, !14, !16, !15}
!21 = distinct !{!21, !14, !15, !16}
!22 = distinct !{!22, !14, !15, !16}
!23 = distinct !{!23, !14, !16, !15}
!24 = distinct !{!24, !14, !15, !16}
!25 = distinct !{!25, !14, !16, !15}
!26 = distinct !{!26, !14, !15, !16}
!27 = distinct !{!27, !14, !16, !15}
!28 = distinct !{!28, !14, !15, !16}
!29 = distinct !{!29, !14, !16, !15}
!30 = distinct !{!30, !14, !15, !16}
!31 = distinct !{!31, !14, !16, !15}
!32 = distinct !{!32, !14, !15, !16}
!33 = distinct !{!33, !14, !16, !15}
!34 = distinct !{!34, !14, !15, !16}
!35 = distinct !{!35, !14, !16, !15}
!36 = distinct !{!36, !14, !15, !16}
!37 = distinct !{!37, !14, !16, !15}
!38 = distinct !{!38, !14, !15, !16}
!39 = distinct !{!39, !14, !16, !15}
!40 = distinct !{!40, !14, !15, !16}
!41 = distinct !{!41, !14, !16, !15}
!42 = distinct !{!42, !14, !15, !16}
!43 = distinct !{!43, !14, !16, !15}
!44 = distinct !{!44, !14, !15, !16}
!45 = distinct !{!45, !14, !16, !15}
!46 = distinct !{!46, !14, !15, !16}
!47 = distinct !{!47, !14, !16, !15}
!48 = distinct !{!48, !14, !15, !16}
!49 = distinct !{!49, !14, !16, !15}
!50 = distinct !{!50, !14, !16, !15}
!51 = distinct !{!51, !14, !15, !16}
!52 = distinct !{!52, !14, !15, !16}
!53 = distinct !{!53, !14, !16, !15}
!54 = distinct !{!54, !14, !15, !16}
!55 = distinct !{!55, !14, !16, !15}
!56 = distinct !{!56, !14, !15, !16}
!57 = distinct !{!57, !14, !16, !15}
!58 = distinct !{!58, !14, !15, !16}
!59 = distinct !{!59, !14, !16, !15}
!60 = distinct !{!60, !14, !15, !16}
!61 = distinct !{!61, !14, !16, !15}
!62 = distinct !{!62, !14, !15, !16}
!63 = distinct !{!63, !14, !16, !15}
!64 = distinct !{!64, !14, !15, !16}
!65 = distinct !{!65, !14, !16, !15}
!66 = distinct !{!66, !14, !15, !16}
!67 = distinct !{!67, !14, !16, !15}
!68 = distinct !{!68, !14, !15, !16}
!69 = distinct !{!69, !14, !16, !15}
!70 = distinct !{!70, !14, !15, !16}
!71 = distinct !{!71, !14, !16, !15}
!72 = distinct !{!72, !14, !15, !16}
!73 = distinct !{!73, !14, !16, !15}
!74 = distinct !{!74, !14, !15, !16}
!75 = distinct !{!75, !14, !16, !15}
!76 = distinct !{!76, !14, !15, !16}
!77 = distinct !{!77, !14, !16, !15}
!78 = distinct !{!78, !14, !15, !16}
!79 = distinct !{!79, !14, !16, !15}
!80 = distinct !{!80, !14}
!81 = distinct !{!81, !14, !16, !15}


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