; LLVM IR from rweather/lightweight-crypto :: src/combined (ascon-hash)

; 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.anon = type { [40 x i8], i8, i8 }

; Function Attrs: nounwind uwtable
define dso_local void @ascon_hash_update(ptr noundef %0, ptr noundef %1, i64 noundef %2) #0 {
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  %6 = alloca i64, align 8
  %7 = alloca i32, align 4
  %8 = alloca ptr, align 8
  %9 = alloca ptr, align 8
  %10 = alloca i32, align 4
  %11 = alloca i32, align 4
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca i32, align 4
  %15 = alloca ptr, align 8
  %16 = alloca i32, align 4
  %17 = alloca i32, align 4
  %18 = alloca i32, align 4
  %19 = alloca i32, align 4
  %20 = alloca i32, align 4
  %21 = alloca i32, align 4
  %22 = alloca i32, align 4
  %23 = alloca i32, align 4
  %24 = alloca i32, align 4
  %25 = alloca i32, align 4
  %26 = alloca i32, align 4
  %27 = alloca i32, align 4
  %28 = alloca i32, align 4
  %29 = alloca i32, align 4
  %30 = alloca i32, align 4
  %31 = alloca i32, align 4
  %32 = alloca i32, align 4
  %33 = alloca i32, align 4
  %34 = alloca ptr, align 8
  %35 = alloca ptr, align 8
  %36 = alloca i32, align 4
  store ptr %0, ptr %4, align 8, !tbaa !5
  store ptr %1, ptr %5, align 8, !tbaa !5
  store i64 %2, ptr %6, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #3
  %37 = load ptr, ptr %4, align 8, !tbaa !5
  %38 = getelementptr inbounds %struct.anon, ptr %37, i32 0, i32 1
  %39 = load i8, ptr %38, align 8, !tbaa !11
  %40 = icmp ne i8 %39, 0
  br i1 %40, label %41, label %140

41:                                               ; preds = %3
  %42 = load ptr, ptr %4, align 8, !tbaa !5
  %43 = getelementptr inbounds %struct.anon, ptr %42, i32 0, i32 1
  %44 = load i8, ptr %43, align 8, !tbaa !11
  %45 = zext i8 %44 to i32
  %46 = sub nsw i32 8, %45
  store i32 %46, ptr %7, align 4, !tbaa !12
  %47 = load i32, ptr %7, align 4, !tbaa !12
  %48 = zext i32 %47 to i64
  %49 = load i64, ptr %6, align 8, !tbaa !9
  %50 = icmp ugt i64 %48, %49
  br i1 %50, label %51, label %92

51:                                               ; preds = %41
  %52 = load i64, ptr %6, align 8, !tbaa !9
  %53 = trunc i64 %52 to i32
  store i32 %53, ptr %7, align 4, !tbaa !12
  br label %54

54:                                               ; preds = %51
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #3
  %55 = load ptr, ptr %4, align 8, !tbaa !5
  %56 = getelementptr inbounds %struct.anon, ptr %55, i32 0, i32 0
  %57 = getelementptr inbounds [40 x i8], ptr %56, i64 0, i64 0
  %58 = load ptr, ptr %4, align 8, !tbaa !5
  %59 = getelementptr inbounds %struct.anon, ptr %58, i32 0, i32 1
  %60 = load i8, ptr %59, align 8, !tbaa !11
  %61 = zext i8 %60 to i32
  %62 = sext i32 %61 to i64
  %63 = getelementptr inbounds i8, ptr %57, i64 %62
  store ptr %63, ptr %8, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #3
  %64 = load ptr, ptr %5, align 8, !tbaa !5
  store ptr %64, ptr %9, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #3
  %65 = load i32, ptr %7, align 4, !tbaa !12
  store i32 %65, ptr %10, align 4, !tbaa !12
  br label %66

66:                                               ; preds = %69, %54
  %67 = load i32, ptr %10, align 4, !tbaa !12
  %68 = icmp ugt i32 %67, 0
  br i1 %68, label %69, label %82

69:                                               ; preds = %66
  %70 = load ptr, ptr %9, align 8, !tbaa !5
  %71 = getelementptr inbounds i8, ptr %70, i32 1
  store ptr %71, ptr %9, align 8, !tbaa !5
  %72 = load i8, ptr %70, align 1, !tbaa !11
  %73 = zext i8 %72 to i32
  %74 = load ptr, ptr %8, align 8, !tbaa !5
  %75 = getelementptr inbounds i8, ptr %74, i32 1
  store ptr %75, ptr %8, align 8, !tbaa !5
  %76 = load i8, ptr %74, align 1, !tbaa !11
  %77 = zext i8 %76 to i32
  %78 = xor i32 %77, %73
  %79 = trunc i32 %78 to i8
  store i8 %79, ptr %74, align 1, !tbaa !11
  %80 = load i32, ptr %10, align 4, !tbaa !12
  %81 = add i32 %80, -1
  store i32 %81, ptr %10, align 4, !tbaa !12
  br label %66, !llvm.loop !14

82:                                               ; preds = %66
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %8) #3
  br label %83

83:                                               ; preds = %82
  br label %84

84:                                               ; preds = %83
  %85 = load i32, ptr %7, align 4, !tbaa !12
  %86 = load ptr, ptr %4, align 8, !tbaa !5
  %87 = getelementptr inbounds %struct.anon, ptr %86, i32 0, i32 1
  %88 = load i8, ptr %87, align 8, !tbaa !11
  %89 = zext i8 %88 to i32
  %90 = add i32 %89, %85
  %91 = trunc i32 %90 to i8
  store i8 %91, ptr %87, align 8, !tbaa !11
  store i32 1, ptr %11, align 4
  br label %389

92:                                               ; preds = %41
  br label %93

93:                                               ; preds = %92
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #3
  %94 = load ptr, ptr %4, align 8, !tbaa !5
  %95 = getelementptr inbounds %struct.anon, ptr %94, i32 0, i32 0
  %96 = getelementptr inbounds [40 x i8], ptr %95, i64 0, i64 0
  %97 = load ptr, ptr %4, align 8, !tbaa !5
  %98 = getelementptr inbounds %struct.anon, ptr %97, i32 0, i32 1
  %99 = load i8, ptr %98, align 8, !tbaa !11
  %100 = zext i8 %99 to i32
  %101 = sext i32 %100 to i64
  %102 = getelementptr inbounds i8, ptr %96, i64 %101
  store ptr %102, ptr %12, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #3
  %103 = load ptr, ptr %5, align 8, !tbaa !5
  store ptr %103, ptr %13, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #3
  %104 = load i32, ptr %7, align 4, !tbaa !12
  store i32 %104, ptr %14, align 4, !tbaa !12
  br label %105

105:                                              ; preds = %108, %93
  %106 = load i32, ptr %14, align 4, !tbaa !12
  %107 = icmp ugt i32 %106, 0
  br i1 %107, label %108, label %121

108:                                              ; preds = %105
  %109 = load ptr, ptr %13, align 8, !tbaa !5
  %110 = getelementptr inbounds i8, ptr %109, i32 1
  store ptr %110, ptr %13, align 8, !tbaa !5
  %111 = load i8, ptr %109, align 1, !tbaa !11
  %112 = zext i8 %111 to i32
  %113 = load ptr, ptr %12, align 8, !tbaa !5
  %114 = getelementptr inbounds i8, ptr %113, i32 1
  store ptr %114, ptr %12, align 8, !tbaa !5
  %115 = load i8, ptr %113, align 1, !tbaa !11
  %116 = zext i8 %115 to i32
  %117 = xor i32 %116, %112
  %118 = trunc i32 %117 to i8
  store i8 %118, ptr %113, align 1, !tbaa !11
  %119 = load i32, ptr %14, align 4, !tbaa !12
  %120 = add i32 %119, -1
  store i32 %120, ptr %14, align 4, !tbaa !12
  br label %105, !llvm.loop !16

121:                                              ; preds = %105
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #3
  br label %122

122:                                              ; preds = %121
  br label %123

123:                                              ; preds = %122
  %124 = load ptr, ptr %4, align 8, !tbaa !5
  %125 = getelementptr inbounds %struct.anon, ptr %124, i32 0, i32 1
  store i8 0, ptr %125, align 8, !tbaa !11
  %126 = load i32, ptr %7, align 4, !tbaa !12
  %127 = load ptr, ptr %5, align 8, !tbaa !5
  %128 = zext i32 %126 to i64
  %129 = getelementptr inbounds i8, ptr %127, i64 %128
  store ptr %129, ptr %5, align 8, !tbaa !5
  %130 = load i32, ptr %7, align 4, !tbaa !12
  %131 = zext i32 %130 to i64
  %132 = load i64, ptr %6, align 8, !tbaa !9
  %133 = sub i64 %132, %131
  store i64 %133, ptr %6, align 8, !tbaa !9
  %134 = load ptr, ptr %4, align 8, !tbaa !5
  %135 = getelementptr inbounds %struct.anon, ptr %134, i32 0, i32 0
  %136 = getelementptr inbounds [40 x i8], ptr %135, i64 0, i64 0
  call void @ascon_to_sliced(ptr noundef %136)
  %137 = load ptr, ptr %4, align 8, !tbaa !5
  %138 = getelementptr inbounds %struct.anon, ptr %137, i32 0, i32 0
  %139 = getelementptr inbounds [40 x i8], ptr %138, i64 0, i64 0
  call void @ascon_permute_sliced(ptr noundef %139, i8 noundef zeroext 0)
  br label %144

140:                                              ; preds = %3
  %141 = load ptr, ptr %4, align 8, !tbaa !5
  %142 = getelementptr inbounds %struct.anon, ptr %141, i32 0, i32 0
  %143 = getelementptr inbounds [40 x i8], ptr %142, i64 0, i64 0
  call void @ascon_to_sliced(ptr noundef %143)
  br label %144

144:                                              ; preds = %140, %123
  br label %145

145:                                              ; preds = %346, %144
  %146 = load i64, ptr %6, align 8, !tbaa !9
  %147 = icmp uge i64 %146, 8
  br i1 %147, label %148, label %354

148:                                              ; preds = %145
  br label %149

149:                                              ; preds = %148
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #3
  %150 = load ptr, ptr %4, align 8, !tbaa !5
  %151 = getelementptr inbounds %struct.anon, ptr %150, i32 0, i32 0
  %152 = getelementptr inbounds [40 x i8], ptr %151, i64 0, i64 0
  store ptr %152, ptr %15, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #3
  %153 = load ptr, ptr %5, align 8, !tbaa !5
  %154 = getelementptr inbounds i8, ptr %153, i64 0
  %155 = load i8, ptr %154, align 1, !tbaa !11
  %156 = zext i8 %155 to i32
  %157 = shl i32 %156, 24
  %158 = load ptr, ptr %5, align 8, !tbaa !5
  %159 = getelementptr inbounds i8, ptr %158, i64 1
  %160 = load i8, ptr %159, align 1, !tbaa !11
  %161 = zext i8 %160 to i32
  %162 = shl i32 %161, 16
  %163 = or i32 %157, %162
  %164 = load ptr, ptr %5, align 8, !tbaa !5
  %165 = getelementptr inbounds i8, ptr %164, i64 2
  %166 = load i8, ptr %165, align 1, !tbaa !11
  %167 = zext i8 %166 to i32
  %168 = shl i32 %167, 8
  %169 = or i32 %163, %168
  %170 = load ptr, ptr %5, align 8, !tbaa !5
  %171 = getelementptr inbounds i8, ptr %170, i64 3
  %172 = load i8, ptr %171, align 1, !tbaa !11
  %173 = zext i8 %172 to i32
  %174 = or i32 %169, %173
  store i32 %174, ptr %16, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #3
  %175 = load ptr, ptr %5, align 8, !tbaa !5
  %176 = getelementptr inbounds i8, ptr %175, i64 4
  %177 = getelementptr inbounds i8, ptr %176, i64 0
  %178 = load i8, ptr %177, align 1, !tbaa !11
  %179 = zext i8 %178 to i32
  %180 = shl i32 %179, 24
  %181 = load ptr, ptr %5, align 8, !tbaa !5
  %182 = getelementptr inbounds i8, ptr %181, i64 4
  %183 = getelementptr inbounds i8, ptr %182, i64 1
  %184 = load i8, ptr %183, align 1, !tbaa !11
  %185 = zext i8 %184 to i32
  %186 = shl i32 %185, 16
  %187 = or i32 %180, %186
  %188 = load ptr, ptr %5, align 8, !tbaa !5
  %189 = getelementptr inbounds i8, ptr %188, i64 4
  %190 = getelementptr inbounds i8, ptr %189, i64 2
  %191 = load i8, ptr %190, align 1, !tbaa !11
  %192 = zext i8 %191 to i32
  %193 = shl i32 %192, 8
  %194 = or i32 %187, %193
  %195 = load ptr, ptr %5, align 8, !tbaa !5
  %196 = getelementptr inbounds i8, ptr %195, i64 4
  %197 = getelementptr inbounds i8, ptr %196, i64 3
  %198 = load i8, ptr %197, align 1, !tbaa !11
  %199 = zext i8 %198 to i32
  %200 = or i32 %194, %199
  store i32 %200, ptr %17, align 4, !tbaa !12
  br label %201

201:                                              ; preds = %149
  br label %202

202:                                              ; preds = %201
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #3
  %203 = load i32, ptr %16, align 4, !tbaa !12
  store i32 %203, ptr %18, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #3
  %204 = load i32, ptr %18, align 4, !tbaa !12
  %205 = lshr i32 %204, 1
  %206 = load i32, ptr %18, align 4, !tbaa !12
  %207 = xor i32 %205, %206
  %208 = and i32 %207, 572662306
  store i32 %208, ptr %19, align 4, !tbaa !12
  %209 = load i32, ptr %18, align 4, !tbaa !12
  %210 = load i32, ptr %19, align 4, !tbaa !12
  %211 = xor i32 %209, %210
  %212 = load i32, ptr %19, align 4, !tbaa !12
  %213 = shl i32 %212, 1
  %214 = xor i32 %211, %213
  store i32 %214, ptr %16, align 4, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #3
  br label %215

215:                                              ; preds = %202
  br label %216

216:                                              ; preds = %215
  br label %217

217:                                              ; preds = %216
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #3
  %218 = load i32, ptr %16, align 4, !tbaa !12
  store i32 %218, ptr %20, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #3
  %219 = load i32, ptr %20, align 4, !tbaa !12
  %220 = lshr i32 %219, 2
  %221 = load i32, ptr %20, align 4, !tbaa !12
  %222 = xor i32 %220, %221
  %223 = and i32 %222, 202116108
  store i32 %223, ptr %21, align 4, !tbaa !12
  %224 = load i32, ptr %20, align 4, !tbaa !12
  %225 = load i32, ptr %21, align 4, !tbaa !12
  %226 = xor i32 %224, %225
  %227 = load i32, ptr %21, align 4, !tbaa !12
  %228 = shl i32 %227, 2
  %229 = xor i32 %226, %228
  store i32 %229, ptr %16, align 4, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #3
  br label %230

230:                                              ; preds = %217
  br label %231

231:                                              ; preds = %230
  br label %232

232:                                              ; preds = %231
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #3
  %233 = load i32, ptr %16, align 4, !tbaa !12
  store i32 %233, ptr %22, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #3
  %234 = load i32, ptr %22, align 4, !tbaa !12
  %235 = lshr i32 %234, 4
  %236 = load i32, ptr %22, align 4, !tbaa !12
  %237 = xor i32 %235, %236
  %238 = and i32 %237, 15728880
  store i32 %238, ptr %23, align 4, !tbaa !12
  %239 = load i32, ptr %22, align 4, !tbaa !12
  %240 = load i32, ptr %23, align 4, !tbaa !12
  %241 = xor i32 %239, %240
  %242 = load i32, ptr %23, align 4, !tbaa !12
  %243 = shl i32 %242, 4
  %244 = xor i32 %241, %243
  store i32 %244, ptr %16, align 4, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #3
  br label %245

245:                                              ; preds = %232
  br label %246

246:                                              ; preds = %245
  br label %247

247:                                              ; preds = %246
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #3
  %248 = load i32, ptr %16, align 4, !tbaa !12
  store i32 %248, ptr %24, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #3
  %249 = load i32, ptr %24, align 4, !tbaa !12
  %250 = lshr i32 %249, 8
  %251 = load i32, ptr %24, align 4, !tbaa !12
  %252 = xor i32 %250, %251
  %253 = and i32 %252, 65280
  store i32 %253, ptr %25, align 4, !tbaa !12
  %254 = load i32, ptr %24, align 4, !tbaa !12
  %255 = load i32, ptr %25, align 4, !tbaa !12
  %256 = xor i32 %254, %255
  %257 = load i32, ptr %25, align 4, !tbaa !12
  %258 = shl i32 %257, 8
  %259 = xor i32 %256, %258
  store i32 %259, ptr %16, align 4, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #3
  br label %260

260:                                              ; preds = %247
  br label %261

261:                                              ; preds = %260
  br label %262

262:                                              ; preds = %261
  br label %263

263:                                              ; preds = %262
  br label %264

264:                                              ; preds = %263
  br label %265

265:                                              ; preds = %264
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #3
  %266 = load i32, ptr %17, align 4, !tbaa !12
  store i32 %266, ptr %26, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #3
  %267 = load i32, ptr %26, align 4, !tbaa !12
  %268 = lshr i32 %267, 1
  %269 = load i32, ptr %26, align 4, !tbaa !12
  %270 = xor i32 %268, %269
  %271 = and i32 %270, 572662306
  store i32 %271, ptr %27, align 4, !tbaa !12
  %272 = load i32, ptr %26, align 4, !tbaa !12
  %273 = load i32, ptr %27, align 4, !tbaa !12
  %274 = xor i32 %272, %273
  %275 = load i32, ptr %27, align 4, !tbaa !12
  %276 = shl i32 %275, 1
  %277 = xor i32 %274, %276
  store i32 %277, ptr %17, align 4, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #3
  br label %278

278:                                              ; preds = %265
  br label %279

279:                                              ; preds = %278
  br label %280

280:                                              ; preds = %279
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #3
  %281 = load i32, ptr %17, align 4, !tbaa !12
  store i32 %281, ptr %28, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #3
  %282 = load i32, ptr %28, align 4, !tbaa !12
  %283 = lshr i32 %282, 2
  %284 = load i32, ptr %28, align 4, !tbaa !12
  %285 = xor i32 %283, %284
  %286 = and i32 %285, 202116108
  store i32 %286, ptr %29, align 4, !tbaa !12
  %287 = load i32, ptr %28, align 4, !tbaa !12
  %288 = load i32, ptr %29, align 4, !tbaa !12
  %289 = xor i32 %287, %288
  %290 = load i32, ptr %29, align 4, !tbaa !12
  %291 = shl i32 %290, 2
  %292 = xor i32 %289, %291
  store i32 %292, ptr %17, align 4, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #3
  br label %293

293:                                              ; preds = %280
  br label %294

294:                                              ; preds = %293
  br label %295

295:                                              ; preds = %294
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #3
  %296 = load i32, ptr %17, align 4, !tbaa !12
  store i32 %296, ptr %30, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #3
  %297 = load i32, ptr %30, align 4, !tbaa !12
  %298 = lshr i32 %297, 4
  %299 = load i32, ptr %30, align 4, !tbaa !12
  %300 = xor i32 %298, %299
  %301 = and i32 %300, 15728880
  store i32 %301, ptr %31, align 4, !tbaa !12
  %302 = load i32, ptr %30, align 4, !tbaa !12
  %303 = load i32, ptr %31, align 4, !tbaa !12
  %304 = xor i32 %302, %303
  %305 = load i32, ptr %31, align 4, !tbaa !12
  %306 = shl i32 %305, 4
  %307 = xor i32 %304, %306
  store i32 %307, ptr %17, align 4, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #3
  br label %308

308:                                              ; preds = %295
  br label %309

309:                                              ; preds = %308
  br label %310

310:                                              ; preds = %309
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #3
  %311 = load i32, ptr %17, align 4, !tbaa !12
  store i32 %311, ptr %32, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #3
  %312 = load i32, ptr %32, align 4, !tbaa !12
  %313 = lshr i32 %312, 8
  %314 = load i32, ptr %32, align 4, !tbaa !12
  %315 = xor i32 %313, %314
  %316 = and i32 %315, 65280
  store i32 %316, ptr %33, align 4, !tbaa !12
  %317 = load i32, ptr %32, align 4, !tbaa !12
  %318 = load i32, ptr %33, align 4, !tbaa !12
  %319 = xor i32 %317, %318
  %320 = load i32, ptr %33, align 4, !tbaa !12
  %321 = shl i32 %320, 8
  %322 = xor i32 %319, %321
  store i32 %322, ptr %17, align 4, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #3
  br label %323

323:                                              ; preds = %310
  br label %324

324:                                              ; preds = %323
  br label %325

325:                                              ; preds = %324
  br label %326

326:                                              ; preds = %325
  %327 = load i32, ptr %16, align 4, !tbaa !12
  %328 = shl i32 %327, 16
  %329 = load i32, ptr %17, align 4, !tbaa !12
  %330 = and i32 %329, 65535
  %331 = or i32 %328, %330
  %332 = load ptr, ptr %15, align 8, !tbaa !5
  %333 = getelementptr inbounds [10 x i32], ptr %332, i64 0, i64 0
  %334 = load i32, ptr %333, align 8, !tbaa !11
  %335 = xor i32 %334, %331
  store i32 %335, ptr %333, align 8, !tbaa !11
  %336 = load i32, ptr %16, align 4, !tbaa !12
  %337 = and i32 %336, -65536
  %338 = load i32, ptr %17, align 4, !tbaa !12
  %339 = lshr i32 %338, 16
  %340 = or i32 %337, %339
  %341 = load ptr, ptr %15, align 8, !tbaa !5
  %342 = getelementptr inbounds [10 x i32], ptr %341, i64 0, i64 1
  %343 = load i32, ptr %342, align 4, !tbaa !11
  %344 = xor i32 %343, %340
  store i32 %344, ptr %342, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #3
  br label %345

345:                                              ; preds = %326
  br label %346

346:                                              ; preds = %345
  %347 = load ptr, ptr %5, align 8, !tbaa !5
  %348 = getelementptr inbounds i8, ptr %347, i64 8
  store ptr %348, ptr %5, align 8, !tbaa !5
  %349 = load i64, ptr %6, align 8, !tbaa !9
  %350 = sub i64 %349, 8
  store i64 %350, ptr %6, align 8, !tbaa !9
  %351 = load ptr, ptr %4, align 8, !tbaa !5
  %352 = getelementptr inbounds %struct.anon, ptr %351, i32 0, i32 0
  %353 = getelementptr inbounds [40 x i8], ptr %352, i64 0, i64 0
  call void @ascon_permute_sliced(ptr noundef %353, i8 noundef zeroext 0)
  br label %145, !llvm.loop !17

354:                                              ; preds = %145
  %355 = load ptr, ptr %4, align 8, !tbaa !5
  %356 = getelementptr inbounds %struct.anon, ptr %355, i32 0, i32 0
  %357 = getelementptr inbounds [40 x i8], ptr %356, i64 0, i64 0
  call void @ascon_from_sliced(ptr noundef %357)
  %358 = load i64, ptr %6, align 8, !tbaa !9
  %359 = trunc i64 %358 to i32
  store i32 %359, ptr %7, align 4, !tbaa !12
  br label %360

360:                                              ; preds = %354
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #3
  %361 = load ptr, ptr %4, align 8, !tbaa !5
  %362 = getelementptr inbounds %struct.anon, ptr %361, i32 0, i32 0
  %363 = getelementptr inbounds [40 x i8], ptr %362, i64 0, i64 0
  store ptr %363, ptr %34, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #3
  %364 = load ptr, ptr %5, align 8, !tbaa !5
  store ptr %364, ptr %35, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #3
  %365 = load i32, ptr %7, align 4, !tbaa !12
  store i32 %365, ptr %36, align 4, !tbaa !12
  br label %366

366:                                              ; preds = %369, %360
  %367 = load i32, ptr %36, align 4, !tbaa !12
  %368 = icmp ugt i32 %367, 0
  br i1 %368, label %369, label %382

369:                                              ; preds = %366
  %370 = load ptr, ptr %35, align 8, !tbaa !5
  %371 = getelementptr inbounds i8, ptr %370, i32 1
  store ptr %371, ptr %35, align 8, !tbaa !5
  %372 = load i8, ptr %370, align 1, !tbaa !11
  %373 = zext i8 %372 to i32
  %374 = load ptr, ptr %34, align 8, !tbaa !5
  %375 = getelementptr inbounds i8, ptr %374, i32 1
  store ptr %375, ptr %34, align 8, !tbaa !5
  %376 = load i8, ptr %374, align 1, !tbaa !11
  %377 = zext i8 %376 to i32
  %378 = xor i32 %377, %373
  %379 = trunc i32 %378 to i8
  store i8 %379, ptr %374, align 1, !tbaa !11
  %380 = load i32, ptr %36, align 4, !tbaa !12
  %381 = add i32 %380, -1
  store i32 %381, ptr %36, align 4, !tbaa !12
  br label %366, !llvm.loop !18

382:                                              ; preds = %366
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #3
  br label %383

383:                                              ; preds = %382
  br label %384

384:                                              ; preds = %383
  %385 = load i32, ptr %7, align 4, !tbaa !12
  %386 = trunc i32 %385 to i8
  %387 = load ptr, ptr %4, align 8, !tbaa !5
  %388 = getelementptr inbounds %struct.anon, ptr %387, i32 0, i32 1
  store i8 %386, ptr %388, align 8, !tbaa !11
  store i32 0, ptr %11, align 4
  br label %389

389:                                              ; preds = %384, %84
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #3
  %390 = load i32, ptr %11, align 4
  switch i32 %390, label %392 [
    i32 0, label %391
    i32 1, label %391
  ]

391:                                              ; preds = %389, %389
  ret void

392:                                              ; preds = %389
  unreachable
}

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

declare void @ascon_to_sliced(ptr noundef) #2

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

declare void @ascon_permute_sliced(ptr noundef, i8 noundef zeroext) #2

declare void @ascon_from_sliced(ptr noundef) #2

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

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

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


; 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: nounwind uwtable
define dso_local void @ascon_hash_update(ptr noundef %0, ptr nocapture noundef readonly %1, i64 noundef %2) local_unnamed_addr #0 {
  %4 = getelementptr inbounds i8, ptr %0, i64 40
  %5 = load i8, ptr %4, align 8, !tbaa !5
  %.not = icmp eq i8 %5, 0
  br i1 %.not, label %111, label %6

6:                                                ; preds = %3
  %7 = zext i8 %5 to i32
  %8 = sub nsw i32 8, %7
  %9 = zext i32 %8 to i64
  %10 = icmp ugt i64 %9, %2
  br i1 %10, label %11, label %62

11:                                               ; preds = %6
  %.not125130 = icmp eq i64 %2, 0
  br i1 %.not125130, label %._crit_edge136, label %iter.check187

iter.check187:                                    ; preds = %11
  %12 = zext i8 %5 to i64
  %13 = getelementptr i8, ptr %0, i64 %12
  %14 = trunc i64 %2 to i32
  %15 = add i64 %2, 4294967295
  %16 = and i64 %15, 4294967295
  %17 = add nuw nsw i64 %16, 1
  %min.iters.check185 = icmp ult i64 %16, 7
  br i1 %min.iters.check185, label %.lr.ph135.preheader, label %vector.memcheck178

vector.memcheck178:                               ; preds = %iter.check187
  %18 = add i64 %2, 4294967295
  %19 = and i64 %18, 4294967295
  %20 = getelementptr i8, ptr %0, i64 %19
  %21 = getelementptr i8, ptr %20, i64 %12
  %scevgep179 = getelementptr i8, ptr %21, i64 1
  %22 = getelementptr i8, ptr %1, i64 %19
  %scevgep180 = getelementptr i8, ptr %22, i64 1
  %bound0181 = icmp ult ptr %13, %scevgep180
  %bound1182 = icmp ugt ptr %scevgep179, %1
  %found.conflict183 = and i1 %bound0181, %bound1182
  br i1 %found.conflict183, label %.lr.ph135.preheader, label %vector.main.loop.iter.check189

vector.main.loop.iter.check189:                   ; preds = %vector.memcheck178
  %min.iters.check188 = icmp ult i64 %16, 31
  br i1 %min.iters.check188, label %vec.epilog.ph207, label %vector.ph190

vector.ph190:                                     ; preds = %vector.main.loop.iter.check189
  %n.vec192 = and i64 %17, 8589934560
  br label %vector.body193

vector.body193:                                   ; preds = %vector.body193, %vector.ph190
  %index194 = phi i64 [ 0, %vector.ph190 ], [ %index.next203, %vector.body193 ]
  %next.gep195 = getelementptr i8, ptr %13, i64 %index194
  %next.gep197 = getelementptr i8, ptr %1, i64 %index194
  %23 = getelementptr i8, ptr %next.gep197, i64 16
  %wide.load199 = load <16 x i8>, ptr %next.gep197, align 1, !tbaa !5, !alias.scope !8
  %wide.load200 = load <16 x i8>, ptr %23, align 1, !tbaa !5, !alias.scope !8
  %24 = getelementptr i8, ptr %next.gep195, i64 16
  %wide.load201 = load <16 x i8>, ptr %next.gep195, align 1, !tbaa !5, !alias.scope !11, !noalias !8
  %wide.load202 = load <16 x i8>, ptr %24, align 1, !tbaa !5, !alias.scope !11, !noalias !8
  %25 = xor <16 x i8> %wide.load201, %wide.load199
  %26 = xor <16 x i8> %wide.load202, %wide.load200
  store <16 x i8> %25, ptr %next.gep195, align 1, !tbaa !5, !alias.scope !11, !noalias !8
  store <16 x i8> %26, ptr %24, align 1, !tbaa !5, !alias.scope !11, !noalias !8
  %index.next203 = add nuw i64 %index194, 32
  %27 = icmp eq i64 %index.next203, %n.vec192
  br i1 %27, label %middle.block184, label %vector.body193, !llvm.loop !13

middle.block184:                                  ; preds = %vector.body193
  %cmp.n204 = icmp eq i64 %17, %n.vec192
  br i1 %cmp.n204, label %._crit_edge136.loopexit, label %vec.epilog.iter.check208

vec.epilog.iter.check208:                         ; preds = %middle.block184
  %.cast222 = trunc i64 %n.vec192 to i32
  %ind.end223 = sub i32 %14, %.cast222
  %ind.end218 = getelementptr i8, ptr %1, i64 %n.vec192
  %ind.end215 = getelementptr i8, ptr %13, i64 %n.vec192
  %n.vec.remaining209 = and i64 %17, 24
  %min.epilog.iters.check210 = icmp eq i64 %n.vec.remaining209, 0
  br i1 %min.epilog.iters.check210, label %.lr.ph135.preheader, label %vec.epilog.ph207

vec.epilog.ph207:                                 ; preds = %vector.main.loop.iter.check189, %vec.epilog.iter.check208
  %vec.epilog.resume.val211 = phi i64 [ %n.vec192, %vec.epilog.iter.check208 ], [ 0, %vector.main.loop.iter.check189 ]
  %n.vec213 = and i64 %17, 8589934584
  %ind.end214 = getelementptr i8, ptr %13, i64 %n.vec213
  %ind.end217 = getelementptr i8, ptr %1, i64 %n.vec213
  %.cast220 = trunc i64 %n.vec213 to i32
  %ind.end221 = sub i32 %14, %.cast220
  br label %vec.epilog.vector.body225

vec.epilog.vector.body225:                        ; preds = %vec.epilog.vector.body225, %vec.epilog.ph207
  %index226 = phi i64 [ %vec.epilog.resume.val211, %vec.epilog.ph207 ], [ %index.next231, %vec.epilog.vector.body225 ]
  %next.gep227 = getelementptr i8, ptr %13, i64 %index226
  %next.gep228 = getelementptr i8, ptr %1, i64 %index226
  %wide.load229 = load <8 x i8>, ptr %next.gep228, align 1, !tbaa !5, !alias.scope !17
  %wide.load230 = load <8 x i8>, ptr %next.gep227, align 1, !tbaa !5, !alias.scope !20, !noalias !17
  %28 = xor <8 x i8> %wide.load230, %wide.load229
  store <8 x i8> %28, ptr %next.gep227, align 1, !tbaa !5, !alias.scope !20, !noalias !17
  %index.next231 = add nuw i64 %index226, 8
  %29 = icmp eq i64 %index.next231, %n.vec213
  br i1 %29, label %vec.epilog.middle.block205, label %vec.epilog.vector.body225, !llvm.loop !22

vec.epilog.middle.block205:                       ; preds = %vec.epilog.vector.body225
  %cmp.n232 = icmp eq i64 %17, %n.vec213
  br i1 %cmp.n232, label %._crit_edge136.loopexit, label %.lr.ph135.preheader

.lr.ph135.preheader:                              ; preds = %vec.epilog.middle.block205, %vector.memcheck178, %iter.check187, %vec.epilog.iter.check208
  %.0113133.ph = phi ptr [ %13, %iter.check187 ], [ %13, %vector.memcheck178 ], [ %ind.end215, %vec.epilog.iter.check208 ], [ %ind.end214, %vec.epilog.middle.block205 ]
  %.0114132.ph = phi ptr [ %1, %iter.check187 ], [ %1, %vector.memcheck178 ], [ %ind.end218, %vec.epilog.iter.check208 ], [ %ind.end217, %vec.epilog.middle.block205 ]
  %.0115131.ph = phi i32 [ %14, %iter.check187 ], [ %14, %vector.memcheck178 ], [ %ind.end223, %vec.epilog.iter.check208 ], [ %ind.end221, %vec.epilog.middle.block205 ]
  %30 = add i32 %.0115131.ph, -1
  %xtraiter289 = and i32 %.0115131.ph, 3
  %lcmp.mod290.not = icmp eq i32 %xtraiter289, 0
  br i1 %lcmp.mod290.not, label %.lr.ph135.prol.loopexit, label %.lr.ph135.prol

.lr.ph135.prol:                                   ; preds = %.lr.ph135.preheader, %.lr.ph135.prol
  %.0113133.prol = phi ptr [ %33, %.lr.ph135.prol ], [ %.0113133.ph, %.lr.ph135.preheader ]
  %.0114132.prol = phi ptr [ %31, %.lr.ph135.prol ], [ %.0114132.ph, %.lr.ph135.preheader ]
  %.0115131.prol = phi i32 [ %36, %.lr.ph135.prol ], [ %.0115131.ph, %.lr.ph135.preheader ]
  %prol.iter291 = phi i32 [ %prol.iter291.next, %.lr.ph135.prol ], [ 0, %.lr.ph135.preheader ]
  %31 = getelementptr inbounds i8, ptr %.0114132.prol, i64 1
  %32 = load i8, ptr %.0114132.prol, align 1, !tbaa !5
  %33 = getelementptr inbounds i8, ptr %.0113133.prol, i64 1
  %34 = load i8, ptr %.0113133.prol, align 1, !tbaa !5
  %35 = xor i8 %34, %32
  store i8 %35, ptr %.0113133.prol, align 1, !tbaa !5
  %36 = add i32 %.0115131.prol, -1
  %prol.iter291.next = add i32 %prol.iter291, 1
  %prol.iter291.cmp.not = icmp eq i32 %prol.iter291.next, %xtraiter289
  br i1 %prol.iter291.cmp.not, label %.lr.ph135.prol.loopexit, label %.lr.ph135.prol, !llvm.loop !23

.lr.ph135.prol.loopexit:                          ; preds = %.lr.ph135.prol, %.lr.ph135.preheader
  %.0113133.unr = phi ptr [ %.0113133.ph, %.lr.ph135.preheader ], [ %33, %.lr.ph135.prol ]
  %.0114132.unr = phi ptr [ %.0114132.ph, %.lr.ph135.preheader ], [ %31, %.lr.ph135.prol ]
  %.0115131.unr = phi i32 [ %.0115131.ph, %.lr.ph135.preheader ], [ %36, %.lr.ph135.prol ]
  %37 = icmp ult i32 %30, 3
  br i1 %37, label %._crit_edge136.loopexit, label %.lr.ph135

.lr.ph135:                                        ; preds = %.lr.ph135.prol.loopexit, %.lr.ph135
  %.0113133 = phi ptr [ %55, %.lr.ph135 ], [ %.0113133.unr, %.lr.ph135.prol.loopexit ]
  %.0114132 = phi ptr [ %53, %.lr.ph135 ], [ %.0114132.unr, %.lr.ph135.prol.loopexit ]
  %.0115131 = phi i32 [ %58, %.lr.ph135 ], [ %.0115131.unr, %.lr.ph135.prol.loopexit ]
  %38 = getelementptr inbounds i8, ptr %.0114132, i64 1
  %39 = load i8, ptr %.0114132, align 1, !tbaa !5
  %40 = getelementptr inbounds i8, ptr %.0113133, i64 1
  %41 = load i8, ptr %.0113133, align 1, !tbaa !5
  %42 = xor i8 %41, %39
  store i8 %42, ptr %.0113133, align 1, !tbaa !5
  %43 = getelementptr inbounds i8, ptr %.0114132, i64 2
  %44 = load i8, ptr %38, align 1, !tbaa !5
  %45 = getelementptr inbounds i8, ptr %.0113133, i64 2
  %46 = load i8, ptr %40, align 1, !tbaa !5
  %47 = xor i8 %46, %44
  store i8 %47, ptr %40, align 1, !tbaa !5
  %48 = getelementptr inbounds i8, ptr %.0114132, i64 3
  %49 = load i8, ptr %43, align 1, !tbaa !5
  %50 = getelementptr inbounds i8, ptr %.0113133, i64 3
  %51 = load i8, ptr %45, align 1, !tbaa !5
  %52 = xor i8 %51, %49
  store i8 %52, ptr %45, align 1, !tbaa !5
  %53 = getelementptr inbounds i8, ptr %.0114132, i64 4
  %54 = load i8, ptr %48, align 1, !tbaa !5
  %55 = getelementptr inbounds i8, ptr %.0113133, i64 4
  %56 = load i8, ptr %50, align 1, !tbaa !5
  %57 = xor i8 %56, %54
  store i8 %57, ptr %50, align 1, !tbaa !5
  %58 = add i32 %.0115131, -4
  %.not125.3 = icmp eq i32 %58, 0
  br i1 %.not125.3, label %._crit_edge136.loopexit, label %.lr.ph135, !llvm.loop !25

._crit_edge136.loopexit:                          ; preds = %.lr.ph135.prol.loopexit, %.lr.ph135, %vec.epilog.middle.block205, %middle.block184
  %.pre = load i8, ptr %4, align 8, !tbaa !5
  br label %._crit_edge136

._crit_edge136:                                   ; preds = %._crit_edge136.loopexit, %11
  %59 = phi i8 [ %.pre, %._crit_edge136.loopexit ], [ %5, %11 ]
  %60 = trunc i64 %2 to i8
  %61 = add i8 %59, %60
  br label %248

62:                                               ; preds = %6
  %.not123126 = icmp eq i8 %5, 8
  br i1 %.not123126, label %._crit_edge, label %iter.check

iter.check:                                       ; preds = %62
  %63 = zext i8 %5 to i64
  %64 = getelementptr i8, ptr %0, i64 %63
  %65 = sub nsw i32 7, %7
  %66 = zext i32 %65 to i64
  %67 = add nuw nsw i64 %66, 1
  %min.iters.check = icmp ult i8 %5, 8
  br i1 %min.iters.check, label %.lr.ph.preheader, label %vector.memcheck

vector.memcheck:                                  ; preds = %iter.check
  %68 = sub nsw i32 7, %7
  %69 = zext i32 %68 to i64
  %70 = getelementptr i8, ptr %0, i64 %63
  %71 = getelementptr i8, ptr %70, i64 %69
  %scevgep = getelementptr i8, ptr %71, i64 1
  %72 = getelementptr i8, ptr %1, i64 %69
  %scevgep153 = getelementptr i8, ptr %72, i64 1
  %bound0 = icmp ult ptr %64, %scevgep153
  %bound1 = icmp ugt ptr %scevgep, %1
  %found.conflict = and i1 %bound0, %bound1
  br i1 %found.conflict, label %.lr.ph.preheader, label %vector.main.loop.iter.check

vector.main.loop.iter.check:                      ; preds = %vector.memcheck
  %min.iters.check154 = icmp ult i32 %65, 31
  br i1 %min.iters.check154, label %vec.epilog.ph, label %vector.ph

vector.ph:                                        ; preds = %vector.main.loop.iter.check
  %n.vec = and i64 %67, 8589934560
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %next.gep = getelementptr i8, ptr %64, i64 %index
  %next.gep156 = getelementptr i8, ptr %1, i64 %index
  %73 = getelementptr i8, ptr %next.gep156, i64 16
  %wide.load = load <16 x i8>, ptr %next.gep156, align 1, !tbaa !5, !alias.scope !26
  %wide.load158 = load <16 x i8>, ptr %73, align 1, !tbaa !5, !alias.scope !26
  %74 = getelementptr i8, ptr %next.gep, i64 16
  %wide.load159 = load <16 x i8>, ptr %next.gep, align 1, !tbaa !5, !alias.scope !29, !noalias !26
  %wide.load160 = load <16 x i8>, ptr %74, align 1, !tbaa !5, !alias.scope !29, !noalias !26
  %75 = xor <16 x i8> %wide.load159, %wide.load
  %76 = xor <16 x i8> %wide.load160, %wide.load158
  store <16 x i8> %75, ptr %next.gep, align 1, !tbaa !5, !alias.scope !29, !noalias !26
  store <16 x i8> %76, ptr %74, align 1, !tbaa !5, !alias.scope !29, !noalias !26
  %index.next = add nuw i64 %index, 32
  %77 = icmp eq i64 %index.next, %n.vec
  br i1 %77, label %middle.block, label %vector.body, !llvm.loop !31

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %67, %n.vec
  br i1 %cmp.n, label %._crit_edge, label %vec.epilog.iter.check

vec.epilog.iter.check:                            ; preds = %middle.block
  %.cast168 = trunc i64 %n.vec to i32
  %ind.end169 = sub i32 %8, %.cast168
  %ind.end165 = getelementptr i8, ptr %1, i64 %n.vec
  %ind.end163 = getelementptr i8, ptr %64, i64 %n.vec
  %n.vec.remaining = and i64 %67, 24
  %min.epilog.iters.check = icmp eq i64 %n.vec.remaining, 0
  br i1 %min.epilog.iters.check, label %.lr.ph.preheader, label %vec.epilog.ph

vec.epilog.ph:                                    ; preds = %vector.main.loop.iter.check, %vec.epilog.iter.check
  %vec.epilog.resume.val = phi i64 [ %n.vec, %vec.epilog.iter.check ], [ 0, %vector.main.loop.iter.check ]
  %n.vec162 = and i64 %67, 8589934584
  %ind.end = getelementptr i8, ptr %64, i64 %n.vec162
  %ind.end164 = getelementptr i8, ptr %1, i64 %n.vec162
  %.cast = trunc i64 %n.vec162 to i32
  %ind.end167 = sub i32 %8, %.cast
  br label %vec.epilog.vector.body

vec.epilog.vector.body:                           ; preds = %vec.epilog.vector.body, %vec.epilog.ph
  %index171 = phi i64 [ %vec.epilog.resume.val, %vec.epilog.ph ], [ %index.next176, %vec.epilog.vector.body ]
  %next.gep172 = getelementptr i8, ptr %64, i64 %index171
  %next.gep173 = getelementptr i8, ptr %1, i64 %index171
  %wide.load174 = load <8 x i8>, ptr %next.gep173, align 1, !tbaa !5, !alias.scope !32
  %wide.load175 = load <8 x i8>, ptr %next.gep172, align 1, !tbaa !5, !alias.scope !35, !noalias !32
  %78 = xor <8 x i8> %wide.load175, %wide.load174
  store <8 x i8> %78, ptr %next.gep172, align 1, !tbaa !5, !alias.scope !35, !noalias !32
  %index.next176 = add nuw i64 %index171, 8
  %79 = icmp eq i64 %index.next176, %n.vec162
  br i1 %79, label %vec.epilog.middle.block, label %vec.epilog.vector.body, !llvm.loop !37

vec.epilog.middle.block:                          ; preds = %vec.epilog.vector.body
  %cmp.n177 = icmp eq i64 %67, %n.vec162
  br i1 %cmp.n177, label %._crit_edge, label %.lr.ph.preheader

.lr.ph.preheader:                                 ; preds = %vec.epilog.middle.block, %vector.memcheck, %iter.check, %vec.epilog.iter.check
  %.0116129.ph = phi ptr [ %64, %iter.check ], [ %64, %vector.memcheck ], [ %ind.end163, %vec.epilog.iter.check ], [ %ind.end, %vec.epilog.middle.block ]
  %.0117128.ph = phi ptr [ %1, %iter.check ], [ %1, %vector.memcheck ], [ %ind.end165, %vec.epilog.iter.check ], [ %ind.end164, %vec.epilog.middle.block ]
  %.0118127.ph = phi i32 [ %8, %iter.check ], [ %8, %vector.memcheck ], [ %ind.end169, %vec.epilog.iter.check ], [ %ind.end167, %vec.epilog.middle.block ]
  %80 = add i32 %.0118127.ph, -1
  %xtraiter = and i32 %.0118127.ph, 3
  %lcmp.mod.not = icmp eq i32 %xtraiter, 0
  br i1 %lcmp.mod.not, label %.lr.ph.prol.loopexit, label %.lr.ph.prol

.lr.ph.prol:                                      ; preds = %.lr.ph.preheader, %.lr.ph.prol
  %.0116129.prol = phi ptr [ %83, %.lr.ph.prol ], [ %.0116129.ph, %.lr.ph.preheader ]
  %.0117128.prol = phi ptr [ %81, %.lr.ph.prol ], [ %.0117128.ph, %.lr.ph.preheader ]
  %.0118127.prol = phi i32 [ %86, %.lr.ph.prol ], [ %.0118127.ph, %.lr.ph.preheader ]
  %prol.iter = phi i32 [ %prol.iter.next, %.lr.ph.prol ], [ 0, %.lr.ph.preheader ]
  %81 = getelementptr inbounds i8, ptr %.0117128.prol, i64 1
  %82 = load i8, ptr %.0117128.prol, align 1, !tbaa !5
  %83 = getelementptr inbounds i8, ptr %.0116129.prol, i64 1
  %84 = load i8, ptr %.0116129.prol, align 1, !tbaa !5
  %85 = xor i8 %84, %82
  store i8 %85, ptr %.0116129.prol, align 1, !tbaa !5
  %86 = add i32 %.0118127.prol, -1
  %prol.iter.next = add i32 %prol.iter, 1
  %prol.iter.cmp.not = icmp eq i32 %prol.iter.next, %xtraiter
  br i1 %prol.iter.cmp.not, label %.lr.ph.prol.loopexit, label %.lr.ph.prol, !llvm.loop !38

.lr.ph.prol.loopexit:                             ; preds = %.lr.ph.prol, %.lr.ph.preheader
  %.0116129.unr = phi ptr [ %.0116129.ph, %.lr.ph.preheader ], [ %83, %.lr.ph.prol ]
  %.0117128.unr = phi ptr [ %.0117128.ph, %.lr.ph.preheader ], [ %81, %.lr.ph.prol ]
  %.0118127.unr = phi i32 [ %.0118127.ph, %.lr.ph.preheader ], [ %86, %.lr.ph.prol ]
  %87 = icmp ult i32 %80, 3
  br i1 %87, label %._crit_edge, label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.prol.loopexit, %.lr.ph
  %.0116129 = phi ptr [ %105, %.lr.ph ], [ %.0116129.unr, %.lr.ph.prol.loopexit ]
  %.0117128 = phi ptr [ %103, %.lr.ph ], [ %.0117128.unr, %.lr.ph.prol.loopexit ]
  %.0118127 = phi i32 [ %108, %.lr.ph ], [ %.0118127.unr, %.lr.ph.prol.loopexit ]
  %88 = getelementptr inbounds i8, ptr %.0117128, i64 1
  %89 = load i8, ptr %.0117128, align 1, !tbaa !5
  %90 = getelementptr inbounds i8, ptr %.0116129, i64 1
  %91 = load i8, ptr %.0116129, align 1, !tbaa !5
  %92 = xor i8 %91, %89
  store i8 %92, ptr %.0116129, align 1, !tbaa !5
  %93 = getelementptr inbounds i8, ptr %.0117128, i64 2
  %94 = load i8, ptr %88, align 1, !tbaa !5
  %95 = getelementptr inbounds i8, ptr %.0116129, i64 2
  %96 = load i8, ptr %90, align 1, !tbaa !5
  %97 = xor i8 %96, %94
  store i8 %97, ptr %90, align 1, !tbaa !5
  %98 = getelementptr inbounds i8, ptr %.0117128, i64 3
  %99 = load i8, ptr %93, align 1, !tbaa !5
  %100 = getelementptr inbounds i8, ptr %.0116129, i64 3
  %101 = load i8, ptr %95, align 1, !tbaa !5
  %102 = xor i8 %101, %99
  store i8 %102, ptr %95, align 1, !tbaa !5
  %103 = getelementptr inbounds i8, ptr %.0117128, i64 4
  %104 = load i8, ptr %98, align 1, !tbaa !5
  %105 = getelementptr inbounds i8, ptr %.0116129, i64 4
  %106 = load i8, ptr %100, align 1, !tbaa !5
  %107 = xor i8 %106, %104
  store i8 %107, ptr %100, align 1, !tbaa !5
  %108 = add i32 %.0118127, -4
  %.not123.3 = icmp eq i32 %108, 0
  br i1 %.not123.3, label %._crit_edge, label %.lr.ph, !llvm.loop !39

._crit_edge:                                      ; preds = %.lr.ph.prol.loopexit, %.lr.ph, %middle.block, %vec.epilog.middle.block, %62
  store i8 0, ptr %4, align 8, !tbaa !5
  %109 = getelementptr inbounds i8, ptr %1, i64 %9
  %110 = sub i64 %2, %9
  tail call void @ascon_to_sliced(ptr noundef %0) #2
  tail call void @ascon_permute_sliced(ptr noundef %0, i8 noundef zeroext 0) #2
  br label %112

111:                                              ; preds = %3
  tail call void @ascon_to_sliced(ptr noundef nonnull %0) #2
  br label %112

112:                                              ; preds = %111, %._crit_edge
  %.0111 = phi i64 [ %110, %._crit_edge ], [ %2, %111 ]
  %.0110 = phi ptr [ %109, %._crit_edge ], [ %1, %111 ]
  %113 = icmp ugt i64 %.0111, 7
  br i1 %113, label %.lr.ph140, label %._crit_edge141

.lr.ph140:                                        ; preds = %112
  %114 = getelementptr inbounds i8, ptr %0, i64 4
  br label %115

115:                                              ; preds = %.lr.ph140, %115
  %.1138 = phi ptr [ %.0110, %.lr.ph140 ], [ %201, %115 ]
  %.1112137 = phi i64 [ %.0111, %.lr.ph140 ], [ %202, %115 ]
  %116 = load i8, ptr %.1138, align 1, !tbaa !5
  %117 = zext i8 %116 to i32
  %118 = shl nuw i32 %117, 24
  %119 = getelementptr inbounds i8, ptr %.1138, i64 1
  %120 = load i8, ptr %119, align 1, !tbaa !5
  %121 = zext i8 %120 to i32
  %122 = shl nuw nsw i32 %121, 16
  %123 = or disjoint i32 %122, %118
  %124 = getelementptr inbounds i8, ptr %.1138, i64 2
  %125 = load i8, ptr %124, align 1, !tbaa !5
  %126 = zext i8 %125 to i32
  %127 = shl nuw nsw i32 %126, 8
  %128 = or disjoint i32 %123, %127
  %129 = getelementptr inbounds i8, ptr %.1138, i64 3
  %130 = load i8, ptr %129, align 1, !tbaa !5
  %131 = zext i8 %130 to i32
  %132 = or disjoint i32 %128, %131
  %133 = getelementptr inbounds i8, ptr %.1138, i64 4
  %134 = load i8, ptr %133, align 1, !tbaa !5
  %135 = zext i8 %134 to i32
  %136 = shl nuw i32 %135, 24
  %137 = getelementptr inbounds i8, ptr %.1138, i64 5
  %138 = load i8, ptr %137, align 1, !tbaa !5
  %139 = zext i8 %138 to i32
  %140 = shl nuw nsw i32 %139, 16
  %141 = or disjoint i32 %140, %136
  %142 = getelementptr inbounds i8, ptr %.1138, i64 6
  %143 = load i8, ptr %142, align 1, !tbaa !5
  %144 = zext i8 %143 to i32
  %145 = shl nuw nsw i32 %144, 8
  %146 = or disjoint i32 %141, %145
  %147 = getelementptr inbounds i8, ptr %.1138, i64 7
  %148 = load i8, ptr %147, align 1, !tbaa !5
  %149 = zext i8 %148 to i32
  %150 = or disjoint i32 %146, %149
  %151 = lshr i32 %132, 1
  %152 = xor i32 %151, %132
  %153 = and i32 %152, 572662306
  %154 = mul nuw nsw i32 %153, 3
  %155 = xor i32 %154, %132
  %156 = lshr i32 %155, 2
  %157 = xor i32 %156, %155
  %158 = and i32 %157, 202116108
  %159 = mul nuw nsw i32 %158, 5
  %160 = xor i32 %159, %155
  %161 = lshr i32 %160, 4
  %162 = xor i32 %161, %160
  %163 = and i32 %162, 15728880
  %164 = mul nuw nsw i32 %163, 17
  %165 = xor i32 %164, %160
  %166 = lshr i32 %165, 8
  %167 = xor i32 %166, %165
  %168 = and i32 %167, 65280
  %169 = mul nuw nsw i32 %168, 257
  %170 = xor i32 %169, %165
  %171 = lshr i32 %150, 1
  %172 = xor i32 %171, %150
  %173 = and i32 %172, 572662306
  %174 = mul nuw nsw i32 %173, 3
  %175 = xor i32 %174, %150
  %176 = lshr i32 %175, 2
  %177 = xor i32 %176, %175
  %178 = and i32 %177, 202116108
  %179 = mul nuw nsw i32 %178, 5
  %180 = xor i32 %179, %175
  %181 = lshr i32 %180, 4
  %182 = xor i32 %181, %180
  %183 = and i32 %182, 15728880
  %184 = mul nuw nsw i32 %183, 17
  %185 = xor i32 %184, %180
  %186 = lshr i32 %185, 8
  %187 = xor i32 %186, %185
  %188 = and i32 %187, 65280
  %189 = mul nuw nsw i32 %188, 257
  %190 = xor i32 %189, %185
  %191 = shl i32 %170, 16
  %192 = and i32 %190, 65535
  %193 = or disjoint i32 %192, %191
  %194 = load i32, ptr %0, align 8, !tbaa !5
  %195 = xor i32 %193, %194
  store i32 %195, ptr %0, align 8, !tbaa !5
  %196 = and i32 %170, -65536
  %197 = lshr i32 %190, 16
  %198 = or disjoint i32 %197, %196
  %199 = load i32, ptr %114, align 4, !tbaa !5
  %200 = xor i32 %198, %199
  store i32 %200, ptr %114, align 4, !tbaa !5
  %201 = getelementptr inbounds i8, ptr %.1138, i64 8
  %202 = add i64 %.1112137, -8
  tail call void @ascon_permute_sliced(ptr noundef nonnull %0, i8 noundef zeroext 0) #2
  %203 = icmp ugt i64 %202, 7
  br i1 %203, label %115, label %._crit_edge141, !llvm.loop !40

._crit_edge141:                                   ; preds = %115, %112
  %.1112.lcssa = phi i64 [ %.0111, %112 ], [ %202, %115 ]
  %.1.lcssa = phi ptr [ %.0110, %112 ], [ %201, %115 ]
  tail call void @ascon_from_sliced(ptr noundef nonnull %0) #2
  %.not124143 = icmp eq i64 %.1112.lcssa, 0
  br i1 %.not124143, label %._crit_edge149, label %iter.check242

iter.check242:                                    ; preds = %._crit_edge141
  %204 = trunc nuw i64 %.1112.lcssa to i32
  %205 = add nuw nsw i64 %.1112.lcssa, 4294967295
  %206 = and i64 %205, 4294967295
  %207 = add nuw nsw i64 %206, 1
  %min.iters.check240 = icmp ult i64 %206, 7
  br i1 %min.iters.check240, label %.lr.ph148.preheader, label %vector.memcheck233

vector.memcheck233:                               ; preds = %iter.check242
  %208 = add nuw nsw i64 %.1112.lcssa, 4294967295
  %209 = and i64 %208, 4294967295
  %210 = add nuw nsw i64 %209, 1
  %scevgep234 = getelementptr i8, ptr %0, i64 %210
  %scevgep235 = getelementptr i8, ptr %.1.lcssa, i64 %210
  %bound0236 = icmp ugt ptr %scevgep235, %0
  %bound1237 = icmp ult ptr %.1.lcssa, %scevgep234
  %found.conflict238 = and i1 %bound0236, %bound1237
  br i1 %found.conflict238, label %.lr.ph148.preheader, label %vector.main.loop.iter.check244

vector.main.loop.iter.check244:                   ; preds = %vector.memcheck233
  %min.iters.check243 = icmp ult i64 %206, 31
  br i1 %min.iters.check243, label %vec.epilog.ph262, label %vector.ph245

vector.ph245:                                     ; preds = %vector.main.loop.iter.check244
  %n.vec247 = and i64 %207, 8589934560
  br label %vector.body248

vector.body248:                                   ; preds = %vector.body248, %vector.ph245
  %index249 = phi i64 [ 0, %vector.ph245 ], [ %index.next258, %vector.body248 ]
  %next.gep250 = getelementptr i8, ptr %.1.lcssa, i64 %index249
  %next.gep252 = getelementptr i8, ptr %0, i64 %index249
  %211 = getelementptr i8, ptr %next.gep250, i64 16
  %wide.load254 = load <16 x i8>, ptr %next.gep250, align 1, !tbaa !5, !alias.scope !41
  %wide.load255 = load <16 x i8>, ptr %211, align 1, !tbaa !5, !alias.scope !41
  %212 = getelementptr i8, ptr %next.gep252, i64 16
  %wide.load256 = load <16 x i8>, ptr %next.gep252, align 1, !tbaa !5, !alias.scope !44, !noalias !41
  %wide.load257 = load <16 x i8>, ptr %212, align 1, !tbaa !5, !alias.scope !44, !noalias !41
  %213 = xor <16 x i8> %wide.load256, %wide.load254
  %214 = xor <16 x i8> %wide.load257, %wide.load255
  store <16 x i8> %213, ptr %next.gep252, align 1, !tbaa !5, !alias.scope !44, !noalias !41
  store <16 x i8> %214, ptr %212, align 1, !tbaa !5, !alias.scope !44, !noalias !41
  %index.next258 = add nuw i64 %index249, 32
  %215 = icmp eq i64 %index.next258, %n.vec247
  br i1 %215, label %middle.block239, label %vector.body248, !llvm.loop !46

middle.block239:                                  ; preds = %vector.body248
  %cmp.n259 = icmp eq i64 %207, %n.vec247
  br i1 %cmp.n259, label %._crit_edge149, label %vec.epilog.iter.check263

vec.epilog.iter.check263:                         ; preds = %middle.block239
  %ind.end278 = getelementptr i8, ptr %0, i64 %n.vec247
  %ind.end275 = getelementptr i8, ptr %.1.lcssa, i64 %n.vec247
  %.cast271 = trunc i64 %n.vec247 to i32
  %ind.end272 = sub i32 %204, %.cast271
  %n.vec.remaining264 = and i64 %207, 24
  %min.epilog.iters.check265 = icmp eq i64 %n.vec.remaining264, 0
  br i1 %min.epilog.iters.check265, label %.lr.ph148.preheader, label %vec.epilog.ph262

vec.epilog.ph262:                                 ; preds = %vector.main.loop.iter.check244, %vec.epilog.iter.check263
  %vec.epilog.resume.val266 = phi i64 [ %n.vec247, %vec.epilog.iter.check263 ], [ 0, %vector.main.loop.iter.check244 ]
  %n.vec268 = and i64 %207, 8589934584
  %.cast269 = trunc i64 %n.vec268 to i32
  %ind.end270 = sub i32 %204, %.cast269
  %ind.end274 = getelementptr i8, ptr %.1.lcssa, i64 %n.vec268
  %ind.end277 = getelementptr i8, ptr %0, i64 %n.vec268
  br label %vec.epilog.vector.body280

vec.epilog.vector.body280:                        ; preds = %vec.epilog.vector.body280, %vec.epilog.ph262
  %index281 = phi i64 [ %vec.epilog.resume.val266, %vec.epilog.ph262 ], [ %index.next286, %vec.epilog.vector.body280 ]
  %next.gep282 = getelementptr i8, ptr %.1.lcssa, i64 %index281
  %next.gep283 = getelementptr i8, ptr %0, i64 %index281
  %wide.load284 = load <8 x i8>, ptr %next.gep282, align 1, !tbaa !5, !alias.scope !47
  %wide.load285 = load <8 x i8>, ptr %next.gep283, align 1, !tbaa !5, !alias.scope !50, !noalias !47
  %216 = xor <8 x i8> %wide.load285, %wide.load284
  store <8 x i8> %216, ptr %next.gep283, align 1, !tbaa !5, !alias.scope !50, !noalias !47
  %index.next286 = add nuw i64 %index281, 8
  %217 = icmp eq i64 %index.next286, %n.vec268
  br i1 %217, label %vec.epilog.middle.block260, label %vec.epilog.vector.body280, !llvm.loop !52

vec.epilog.middle.block260:                       ; preds = %vec.epilog.vector.body280
  %cmp.n287 = icmp eq i64 %207, %n.vec268
  br i1 %cmp.n287, label %._crit_edge149, label %.lr.ph148.preheader

.lr.ph148.preheader:                              ; preds = %vec.epilog.middle.block260, %vector.memcheck233, %iter.check242, %vec.epilog.iter.check263
  %.0146.ph = phi i32 [ %204, %iter.check242 ], [ %204, %vector.memcheck233 ], [ %ind.end272, %vec.epilog.iter.check263 ], [ %ind.end270, %vec.epilog.middle.block260 ]
  %.0108145.ph = phi ptr [ %.1.lcssa, %iter.check242 ], [ %.1.lcssa, %vector.memcheck233 ], [ %ind.end275, %vec.epilog.iter.check263 ], [ %ind.end274, %vec.epilog.middle.block260 ]
  %.0109144.ph = phi ptr [ %0, %iter.check242 ], [ %0, %vector.memcheck233 ], [ %ind.end278, %vec.epilog.iter.check263 ], [ %ind.end277, %vec.epilog.middle.block260 ]
  %218 = add nsw i32 %.0146.ph, -1
  %xtraiter292 = and i32 %.0146.ph, 3
  %lcmp.mod293.not = icmp eq i32 %xtraiter292, 0
  br i1 %lcmp.mod293.not, label %.lr.ph148.prol.loopexit, label %.lr.ph148.prol

.lr.ph148.prol:                                   ; preds = %.lr.ph148.preheader, %.lr.ph148.prol
  %.0146.prol = phi i32 [ %224, %.lr.ph148.prol ], [ %.0146.ph, %.lr.ph148.preheader ]
  %.0108145.prol = phi ptr [ %219, %.lr.ph148.prol ], [ %.0108145.ph, %.lr.ph148.preheader ]
  %.0109144.prol = phi ptr [ %221, %.lr.ph148.prol ], [ %.0109144.ph, %.lr.ph148.preheader ]
  %prol.iter294 = phi i32 [ %prol.iter294.next, %.lr.ph148.prol ], [ 0, %.lr.ph148.preheader ]
  %219 = getelementptr inbounds i8, ptr %.0108145.prol, i64 1
  %220 = load i8, ptr %.0108145.prol, align 1, !tbaa !5
  %221 = getelementptr inbounds i8, ptr %.0109144.prol, i64 1
  %222 = load i8, ptr %.0109144.prol, align 1, !tbaa !5
  %223 = xor i8 %222, %220
  store i8 %223, ptr %.0109144.prol, align 1, !tbaa !5
  %224 = add nsw i32 %.0146.prol, -1
  %prol.iter294.next = add i32 %prol.iter294, 1
  %prol.iter294.cmp.not = icmp eq i32 %prol.iter294.next, %xtraiter292
  br i1 %prol.iter294.cmp.not, label %.lr.ph148.prol.loopexit, label %.lr.ph148.prol, !llvm.loop !53

.lr.ph148.prol.loopexit:                          ; preds = %.lr.ph148.prol, %.lr.ph148.preheader
  %.0146.unr = phi i32 [ %.0146.ph, %.lr.ph148.preheader ], [ %224, %.lr.ph148.prol ]
  %.0108145.unr = phi ptr [ %.0108145.ph, %.lr.ph148.preheader ], [ %219, %.lr.ph148.prol ]
  %.0109144.unr = phi ptr [ %.0109144.ph, %.lr.ph148.preheader ], [ %221, %.lr.ph148.prol ]
  %225 = icmp ult i32 %218, 3
  br i1 %225, label %._crit_edge149, label %.lr.ph148

.lr.ph148:                                        ; preds = %.lr.ph148.prol.loopexit, %.lr.ph148
  %.0146 = phi i32 [ %246, %.lr.ph148 ], [ %.0146.unr, %.lr.ph148.prol.loopexit ]
  %.0108145 = phi ptr [ %241, %.lr.ph148 ], [ %.0108145.unr, %.lr.ph148.prol.loopexit ]
  %.0109144 = phi ptr [ %243, %.lr.ph148 ], [ %.0109144.unr, %.lr.ph148.prol.loopexit ]
  %226 = getelementptr inbounds i8, ptr %.0108145, i64 1
  %227 = load i8, ptr %.0108145, align 1, !tbaa !5
  %228 = getelementptr inbounds i8, ptr %.0109144, i64 1
  %229 = load i8, ptr %.0109144, align 1, !tbaa !5
  %230 = xor i8 %229, %227
  store i8 %230, ptr %.0109144, align 1, !tbaa !5
  %231 = getelementptr inbounds i8, ptr %.0108145, i64 2
  %232 = load i8, ptr %226, align 1, !tbaa !5
  %233 = getelementptr inbounds i8, ptr %.0109144, i64 2
  %234 = load i8, ptr %228, align 1, !tbaa !5
  %235 = xor i8 %234, %232
  store i8 %235, ptr %228, align 1, !tbaa !5
  %236 = getelementptr inbounds i8, ptr %.0108145, i64 3
  %237 = load i8, ptr %231, align 1, !tbaa !5
  %238 = getelementptr inbounds i8, ptr %.0109144, i64 3
  %239 = load i8, ptr %233, align 1, !tbaa !5
  %240 = xor i8 %239, %237
  store i8 %240, ptr %233, align 1, !tbaa !5
  %241 = getelementptr inbounds i8, ptr %.0108145, i64 4
  %242 = load i8, ptr %236, align 1, !tbaa !5
  %243 = getelementptr inbounds i8, ptr %.0109144, i64 4
  %244 = load i8, ptr %238, align 1, !tbaa !5
  %245 = xor i8 %244, %242
  store i8 %245, ptr %238, align 1, !tbaa !5
  %246 = add nsw i32 %.0146, -4
  %.not124.3 = icmp eq i32 %246, 0
  br i1 %.not124.3, label %._crit_edge149, label %.lr.ph148, !llvm.loop !54

._crit_edge149:                                   ; preds = %.lr.ph148.prol.loopexit, %.lr.ph148, %middle.block239, %vec.epilog.middle.block260, %._crit_edge141
  %247 = trunc nuw i64 %.1112.lcssa to i8
  br label %248

248:                                              ; preds = %._crit_edge149, %._crit_edge136
  %storemerge = phi i8 [ %247, %._crit_edge149 ], [ %61, %._crit_edge136 ]
  store i8 %storemerge, ptr %4, align 8, !tbaa !5
  ret void
}

declare void @ascon_to_sliced(ptr noundef) local_unnamed_addr #1

declare void @ascon_permute_sliced(ptr noundef, i8 noundef zeroext) local_unnamed_addr #1

declare void @ascon_from_sliced(ptr noundef) local_unnamed_addr #1

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { nounwind }

!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 = !{!"omnipotent char", !7, i64 0}
!7 = !{!"Simple C/C++ TBAA"}
!8 = !{!9}
!9 = distinct !{!9, !10}
!10 = distinct !{!10, !"LVerDomain"}
!11 = !{!12}
!12 = distinct !{!12, !10}
!13 = distinct !{!13, !14, !15, !16}
!14 = !{!"llvm.loop.mustprogress"}
!15 = !{!"llvm.loop.isvectorized", i32 1}
!16 = !{!"llvm.loop.unroll.runtime.disable"}
!17 = !{!18}
!18 = distinct !{!18, !19}
!19 = distinct !{!19, !"LVerDomain"}
!20 = !{!21}
!21 = distinct !{!21, !19}
!22 = distinct !{!22, !14, !15, !16}
!23 = distinct !{!23, !24}
!24 = !{!"llvm.loop.unroll.disable"}
!25 = distinct !{!25, !14, !15}
!26 = !{!27}
!27 = distinct !{!27, !28}
!28 = distinct !{!28, !"LVerDomain"}
!29 = !{!30}
!30 = distinct !{!30, !28}
!31 = distinct !{!31, !14, !15, !16}
!32 = !{!33}
!33 = distinct !{!33, !34}
!34 = distinct !{!34, !"LVerDomain"}
!35 = !{!36}
!36 = distinct !{!36, !34}
!37 = distinct !{!37, !14, !15, !16}
!38 = distinct !{!38, !24}
!39 = distinct !{!39, !14, !15}
!40 = distinct !{!40, !14}
!41 = !{!42}
!42 = distinct !{!42, !43}
!43 = distinct !{!43, !"LVerDomain"}
!44 = !{!45}
!45 = distinct !{!45, !43}
!46 = distinct !{!46, !14, !15, !16}
!47 = !{!48}
!48 = distinct !{!48, !49}
!49 = distinct !{!49, !"LVerDomain"}
!50 = !{!51}
!51 = distinct !{!51, !49}
!52 = distinct !{!52, !14, !15, !16}
!53 = distinct !{!53, !24}
!54 = distinct !{!54, !14, !15}


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