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

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

; Function Attrs: nounwind uwtable
define dso_local i32 @schwaemm_128_128_aead_encrypt(ptr noundef %0, ptr noundef %1, ptr noundef %2, i64 noundef %3, ptr noundef %4, i64 noundef %5, ptr noundef %6, ptr noundef %7, ptr noundef %8) #0 {
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca i64, align 8
  %14 = alloca ptr, align 8
  %15 = alloca i64, align 8
  %16 = alloca ptr, align 8
  %17 = alloca ptr, align 8
  %18 = alloca ptr, align 8
  %19 = alloca [8 x i32], align 16
  %20 = alloca [16 x i8], align 16
  %21 = alloca ptr, align 8
  %22 = alloca ptr, align 8
  %23 = alloca ptr, align 8
  %24 = alloca i32, align 4
  %25 = alloca i32, align 4
  %26 = alloca ptr, align 8
  %27 = alloca ptr, align 8
  %28 = alloca i32, align 4
  %29 = alloca ptr, align 8
  %30 = alloca ptr, align 8
  %31 = alloca ptr, align 8
  %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
  %37 = alloca i32, align 4
  %38 = alloca ptr, align 8
  %39 = alloca ptr, align 8
  %40 = alloca ptr, align 8
  %41 = alloca i32, align 4
  %42 = alloca i32, align 4
  %43 = alloca ptr, align 8
  %44 = alloca ptr, align 8
  %45 = alloca i32, align 4
  %46 = alloca ptr, align 8
  %47 = alloca ptr, align 8
  %48 = alloca ptr, align 8
  %49 = alloca i32, align 4
  store ptr %0, ptr %10, align 8, !tbaa !5
  store ptr %1, ptr %11, align 8, !tbaa !5
  store ptr %2, ptr %12, align 8, !tbaa !5
  store i64 %3, ptr %13, align 8, !tbaa !9
  store ptr %4, ptr %14, align 8, !tbaa !5
  store i64 %5, ptr %15, align 8, !tbaa !9
  store ptr %6, ptr %16, align 8, !tbaa !5
  store ptr %7, ptr %17, align 8, !tbaa !5
  store ptr %8, ptr %18, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 32, ptr %19) #4
  call void @llvm.lifetime.start.p0(i64 16, ptr %20) #4
  %50 = load ptr, ptr %16, align 8, !tbaa !5
  %51 = load i64, ptr %13, align 8, !tbaa !9
  %52 = add i64 %51, 16
  %53 = load ptr, ptr %11, align 8, !tbaa !5
  store i64 %52, ptr %53, align 8, !tbaa !9
  %54 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  %55 = load ptr, ptr %17, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %54, ptr align 1 %55, i64 16, i1 false)
  %56 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  %57 = getelementptr inbounds i8, ptr %56, i64 16
  %58 = load ptr, ptr %18, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %57, ptr align 1 %58, i64 16, i1 false)
  %59 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  call void @sparkle_256(ptr noundef %59, i32 noundef 10)
  %60 = load i64, ptr %15, align 8, !tbaa !9
  %61 = icmp ugt i64 %60, 0
  br i1 %61, label %62, label %66

62:                                               ; preds = %9
  %63 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  %64 = load ptr, ptr %14, align 8, !tbaa !5
  %65 = load i64, ptr %15, align 8, !tbaa !9
  call void @schwaemm_128_128_authenticate(ptr noundef %63, ptr noundef %64, i64 noundef %65)
  br label %66

66:                                               ; preds = %62, %9
  %67 = load i64, ptr %13, align 8, !tbaa !9
  %68 = icmp ugt i64 %67, 0
  br i1 %68, label %69, label %357

69:                                               ; preds = %66
  br label %70

70:                                               ; preds = %153, %69
  %71 = load i64, ptr %13, align 8, !tbaa !9
  %72 = icmp ugt i64 %71, 16
  br i1 %72, label %73, label %163

73:                                               ; preds = %70
  br label %74

74:                                               ; preds = %73
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #4
  %75 = getelementptr inbounds [16 x i8], ptr %20, i64 0, i64 0
  store ptr %75, ptr %21, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #4
  %76 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  store ptr %76, ptr %22, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #4
  %77 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %77, ptr %23, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #4
  store i32 16, ptr %24, align 4, !tbaa !11
  br label %78

78:                                               ; preds = %81, %74
  %79 = load i32, ptr %24, align 4, !tbaa !11
  %80 = icmp ugt i32 %79, 0
  br i1 %80, label %81, label %96

81:                                               ; preds = %78
  %82 = load ptr, ptr %22, align 8, !tbaa !5
  %83 = getelementptr inbounds i8, ptr %82, i32 1
  store ptr %83, ptr %22, align 8, !tbaa !5
  %84 = load i8, ptr %82, align 1, !tbaa !13
  %85 = zext i8 %84 to i32
  %86 = load ptr, ptr %23, align 8, !tbaa !5
  %87 = getelementptr inbounds i8, ptr %86, i32 1
  store ptr %87, ptr %23, align 8, !tbaa !5
  %88 = load i8, ptr %86, align 1, !tbaa !13
  %89 = zext i8 %88 to i32
  %90 = xor i32 %85, %89
  %91 = trunc i32 %90 to i8
  %92 = load ptr, ptr %21, align 8, !tbaa !5
  %93 = getelementptr inbounds i8, ptr %92, i32 1
  store ptr %93, ptr %21, align 8, !tbaa !5
  store i8 %91, ptr %92, align 1, !tbaa !13
  %94 = load i32, ptr %24, align 4, !tbaa !11
  %95 = add i32 %94, -1
  store i32 %95, ptr %24, align 4, !tbaa !11
  br label %78, !llvm.loop !14

96:                                               ; preds = %78
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #4
  br label %97

97:                                               ; preds = %96
  br label %98

98:                                               ; preds = %97
  br label %99

99:                                               ; preds = %98
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #4
  %100 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  %101 = load i32, ptr %100, align 16, !tbaa !11
  store i32 %101, ptr %25, align 4, !tbaa !11
  %102 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 2
  %103 = load i32, ptr %102, align 8, !tbaa !11
  %104 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 4
  %105 = load i32, ptr %104, align 16, !tbaa !11
  %106 = xor i32 %103, %105
  %107 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  store i32 %106, ptr %107, align 16, !tbaa !11
  %108 = load i32, ptr %25, align 4, !tbaa !11
  %109 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 6
  %110 = load i32, ptr %109, align 8, !tbaa !11
  %111 = xor i32 %108, %110
  %112 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 2
  %113 = load i32, ptr %112, align 8, !tbaa !11
  %114 = xor i32 %113, %111
  store i32 %114, ptr %112, align 8, !tbaa !11
  %115 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 1
  %116 = load i32, ptr %115, align 4, !tbaa !11
  store i32 %116, ptr %25, align 4, !tbaa !11
  %117 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 3
  %118 = load i32, ptr %117, align 4, !tbaa !11
  %119 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 5
  %120 = load i32, ptr %119, align 4, !tbaa !11
  %121 = xor i32 %118, %120
  %122 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 1
  store i32 %121, ptr %122, align 4, !tbaa !11
  %123 = load i32, ptr %25, align 4, !tbaa !11
  %124 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 7
  %125 = load i32, ptr %124, align 4, !tbaa !11
  %126 = xor i32 %123, %125
  %127 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 3
  %128 = load i32, ptr %127, align 4, !tbaa !11
  %129 = xor i32 %128, %126
  store i32 %129, ptr %127, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #4
  br label %130

130:                                              ; preds = %99
  br label %131

131:                                              ; preds = %130
  br label %132

132:                                              ; preds = %131
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #4
  %133 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  store ptr %133, ptr %26, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #4
  %134 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %134, ptr %27, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #4
  store i32 16, ptr %28, align 4, !tbaa !11
  br label %135

135:                                              ; preds = %138, %132
  %136 = load i32, ptr %28, align 4, !tbaa !11
  %137 = icmp ugt i32 %136, 0
  br i1 %137, label %138, label %151

138:                                              ; preds = %135
  %139 = load ptr, ptr %27, align 8, !tbaa !5
  %140 = getelementptr inbounds i8, ptr %139, i32 1
  store ptr %140, ptr %27, align 8, !tbaa !5
  %141 = load i8, ptr %139, align 1, !tbaa !13
  %142 = zext i8 %141 to i32
  %143 = load ptr, ptr %26, align 8, !tbaa !5
  %144 = getelementptr inbounds i8, ptr %143, i32 1
  store ptr %144, ptr %26, align 8, !tbaa !5
  %145 = load i8, ptr %143, align 1, !tbaa !13
  %146 = zext i8 %145 to i32
  %147 = xor i32 %146, %142
  %148 = trunc i32 %147 to i8
  store i8 %148, ptr %143, align 1, !tbaa !13
  %149 = load i32, ptr %28, align 4, !tbaa !11
  %150 = add i32 %149, -1
  store i32 %150, ptr %28, align 4, !tbaa !11
  br label %135, !llvm.loop !16

151:                                              ; preds = %135
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #4
  br label %152

152:                                              ; preds = %151
  br label %153

153:                                              ; preds = %152
  %154 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  call void @sparkle_256(ptr noundef %154, i32 noundef 7)
  %155 = load ptr, ptr %10, align 8, !tbaa !5
  %156 = getelementptr inbounds [16 x i8], ptr %20, i64 0, i64 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %155, ptr align 16 %156, i64 16, i1 false)
  %157 = load ptr, ptr %10, align 8, !tbaa !5
  %158 = getelementptr inbounds i8, ptr %157, i64 16
  store ptr %158, ptr %10, align 8, !tbaa !5
  %159 = load ptr, ptr %12, align 8, !tbaa !5
  %160 = getelementptr inbounds i8, ptr %159, i64 16
  store ptr %160, ptr %12, align 8, !tbaa !5
  %161 = load i64, ptr %13, align 8, !tbaa !9
  %162 = sub i64 %161, 16
  store i64 %162, ptr %13, align 8, !tbaa !9
  br label %70, !llvm.loop !17

163:                                              ; preds = %70
  %164 = load i64, ptr %13, align 8, !tbaa !9
  %165 = icmp eq i64 %164, 16
  br i1 %165, label %166, label %252

166:                                              ; preds = %163
  br label %167

167:                                              ; preds = %166
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #4
  %168 = getelementptr inbounds [16 x i8], ptr %20, i64 0, i64 0
  store ptr %168, ptr %29, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #4
  %169 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  store ptr %169, ptr %30, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #4
  %170 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %170, ptr %31, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #4
  store i32 16, ptr %32, align 4, !tbaa !11
  br label %171

171:                                              ; preds = %174, %167
  %172 = load i32, ptr %32, align 4, !tbaa !11
  %173 = icmp ugt i32 %172, 0
  br i1 %173, label %174, label %189

174:                                              ; preds = %171
  %175 = load ptr, ptr %30, align 8, !tbaa !5
  %176 = getelementptr inbounds i8, ptr %175, i32 1
  store ptr %176, ptr %30, align 8, !tbaa !5
  %177 = load i8, ptr %175, align 1, !tbaa !13
  %178 = zext i8 %177 to i32
  %179 = load ptr, ptr %31, align 8, !tbaa !5
  %180 = getelementptr inbounds i8, ptr %179, i32 1
  store ptr %180, ptr %31, align 8, !tbaa !5
  %181 = load i8, ptr %179, align 1, !tbaa !13
  %182 = zext i8 %181 to i32
  %183 = xor i32 %178, %182
  %184 = trunc i32 %183 to i8
  %185 = load ptr, ptr %29, align 8, !tbaa !5
  %186 = getelementptr inbounds i8, ptr %185, i32 1
  store ptr %186, ptr %29, align 8, !tbaa !5
  store i8 %184, ptr %185, align 1, !tbaa !13
  %187 = load i32, ptr %32, align 4, !tbaa !11
  %188 = add i32 %187, -1
  store i32 %188, ptr %32, align 4, !tbaa !11
  br label %171, !llvm.loop !18

189:                                              ; preds = %171
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #4
  br label %190

190:                                              ; preds = %189
  br label %191

191:                                              ; preds = %190
  %192 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 7
  %193 = load i32, ptr %192, align 4, !tbaa !11
  %194 = xor i32 %193, 117440512
  store i32 %194, ptr %192, align 4, !tbaa !11
  br label %195

195:                                              ; preds = %191
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #4
  %196 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  %197 = load i32, ptr %196, align 16, !tbaa !11
  store i32 %197, ptr %33, align 4, !tbaa !11
  %198 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 2
  %199 = load i32, ptr %198, align 8, !tbaa !11
  %200 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 4
  %201 = load i32, ptr %200, align 16, !tbaa !11
  %202 = xor i32 %199, %201
  %203 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  store i32 %202, ptr %203, align 16, !tbaa !11
  %204 = load i32, ptr %33, align 4, !tbaa !11
  %205 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 6
  %206 = load i32, ptr %205, align 8, !tbaa !11
  %207 = xor i32 %204, %206
  %208 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 2
  %209 = load i32, ptr %208, align 8, !tbaa !11
  %210 = xor i32 %209, %207
  store i32 %210, ptr %208, align 8, !tbaa !11
  %211 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 1
  %212 = load i32, ptr %211, align 4, !tbaa !11
  store i32 %212, ptr %33, align 4, !tbaa !11
  %213 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 3
  %214 = load i32, ptr %213, align 4, !tbaa !11
  %215 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 5
  %216 = load i32, ptr %215, align 4, !tbaa !11
  %217 = xor i32 %214, %216
  %218 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 1
  store i32 %217, ptr %218, align 4, !tbaa !11
  %219 = load i32, ptr %33, align 4, !tbaa !11
  %220 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 7
  %221 = load i32, ptr %220, align 4, !tbaa !11
  %222 = xor i32 %219, %221
  %223 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 3
  %224 = load i32, ptr %223, align 4, !tbaa !11
  %225 = xor i32 %224, %222
  store i32 %225, ptr %223, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #4
  br label %226

226:                                              ; preds = %195
  br label %227

227:                                              ; preds = %226
  br label %228

228:                                              ; preds = %227
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #4
  %229 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  store ptr %229, ptr %34, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #4
  %230 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %230, ptr %35, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #4
  store i32 16, ptr %36, align 4, !tbaa !11
  br label %231

231:                                              ; preds = %234, %228
  %232 = load i32, ptr %36, align 4, !tbaa !11
  %233 = icmp ugt i32 %232, 0
  br i1 %233, label %234, label %247

234:                                              ; preds = %231
  %235 = load ptr, ptr %35, align 8, !tbaa !5
  %236 = getelementptr inbounds i8, ptr %235, i32 1
  store ptr %236, ptr %35, align 8, !tbaa !5
  %237 = load i8, ptr %235, align 1, !tbaa !13
  %238 = zext i8 %237 to i32
  %239 = load ptr, ptr %34, align 8, !tbaa !5
  %240 = getelementptr inbounds i8, ptr %239, i32 1
  store ptr %240, ptr %34, align 8, !tbaa !5
  %241 = load i8, ptr %239, align 1, !tbaa !13
  %242 = zext i8 %241 to i32
  %243 = xor i32 %242, %238
  %244 = trunc i32 %243 to i8
  store i8 %244, ptr %239, align 1, !tbaa !13
  %245 = load i32, ptr %36, align 4, !tbaa !11
  %246 = add i32 %245, -1
  store i32 %246, ptr %36, align 4, !tbaa !11
  br label %231, !llvm.loop !19

247:                                              ; preds = %231
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #4
  br label %248

248:                                              ; preds = %247
  br label %249

249:                                              ; preds = %248
  %250 = load ptr, ptr %10, align 8, !tbaa !5
  %251 = getelementptr inbounds [16 x i8], ptr %20, i64 0, i64 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %250, ptr align 16 %251, i64 16, i1 false)
  br label %352

252:                                              ; preds = %163
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #4
  %253 = load i64, ptr %13, align 8, !tbaa !9
  %254 = trunc i64 %253 to i32
  store i32 %254, ptr %37, align 4, !tbaa !11
  br label %255

255:                                              ; preds = %252
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #4
  %256 = getelementptr inbounds [16 x i8], ptr %20, i64 0, i64 0
  store ptr %256, ptr %38, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #4
  %257 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  store ptr %257, ptr %39, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #4
  %258 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %258, ptr %40, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #4
  %259 = load i32, ptr %37, align 4, !tbaa !11
  store i32 %259, ptr %41, align 4, !tbaa !11
  br label %260

260:                                              ; preds = %263, %255
  %261 = load i32, ptr %41, align 4, !tbaa !11
  %262 = icmp ugt i32 %261, 0
  br i1 %262, label %263, label %278

263:                                              ; preds = %260
  %264 = load ptr, ptr %39, align 8, !tbaa !5
  %265 = getelementptr inbounds i8, ptr %264, i32 1
  store ptr %265, ptr %39, align 8, !tbaa !5
  %266 = load i8, ptr %264, align 1, !tbaa !13
  %267 = zext i8 %266 to i32
  %268 = load ptr, ptr %40, align 8, !tbaa !5
  %269 = getelementptr inbounds i8, ptr %268, i32 1
  store ptr %269, ptr %40, align 8, !tbaa !5
  %270 = load i8, ptr %268, align 1, !tbaa !13
  %271 = zext i8 %270 to i32
  %272 = xor i32 %267, %271
  %273 = trunc i32 %272 to i8
  %274 = load ptr, ptr %38, align 8, !tbaa !5
  %275 = getelementptr inbounds i8, ptr %274, i32 1
  store ptr %275, ptr %38, align 8, !tbaa !5
  store i8 %273, ptr %274, align 1, !tbaa !13
  %276 = load i32, ptr %41, align 4, !tbaa !11
  %277 = add i32 %276, -1
  store i32 %277, ptr %41, align 4, !tbaa !11
  br label %260, !llvm.loop !20

278:                                              ; preds = %260
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #4
  br label %279

279:                                              ; preds = %278
  br label %280

280:                                              ; preds = %279
  %281 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 7
  %282 = load i32, ptr %281, align 4, !tbaa !11
  %283 = xor i32 %282, 100663296
  store i32 %283, ptr %281, align 4, !tbaa !11
  br label %284

284:                                              ; preds = %280
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #4
  %285 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  %286 = load i32, ptr %285, align 16, !tbaa !11
  store i32 %286, ptr %42, align 4, !tbaa !11
  %287 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 2
  %288 = load i32, ptr %287, align 8, !tbaa !11
  %289 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 4
  %290 = load i32, ptr %289, align 16, !tbaa !11
  %291 = xor i32 %288, %290
  %292 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  store i32 %291, ptr %292, align 16, !tbaa !11
  %293 = load i32, ptr %42, align 4, !tbaa !11
  %294 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 6
  %295 = load i32, ptr %294, align 8, !tbaa !11
  %296 = xor i32 %293, %295
  %297 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 2
  %298 = load i32, ptr %297, align 8, !tbaa !11
  %299 = xor i32 %298, %296
  store i32 %299, ptr %297, align 8, !tbaa !11
  %300 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 1
  %301 = load i32, ptr %300, align 4, !tbaa !11
  store i32 %301, ptr %42, align 4, !tbaa !11
  %302 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 3
  %303 = load i32, ptr %302, align 4, !tbaa !11
  %304 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 5
  %305 = load i32, ptr %304, align 4, !tbaa !11
  %306 = xor i32 %303, %305
  %307 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 1
  store i32 %306, ptr %307, align 4, !tbaa !11
  %308 = load i32, ptr %42, align 4, !tbaa !11
  %309 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 7
  %310 = load i32, ptr %309, align 4, !tbaa !11
  %311 = xor i32 %308, %310
  %312 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 3
  %313 = load i32, ptr %312, align 4, !tbaa !11
  %314 = xor i32 %313, %311
  store i32 %314, ptr %312, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #4
  br label %315

315:                                              ; preds = %284
  br label %316

316:                                              ; preds = %315
  br label %317

317:                                              ; preds = %316
  call void @llvm.lifetime.start.p0(i64 8, ptr %43) #4
  %318 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  store ptr %318, ptr %43, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #4
  %319 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %319, ptr %44, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %45) #4
  %320 = load i32, ptr %37, align 4, !tbaa !11
  store i32 %320, ptr %45, align 4, !tbaa !11
  br label %321

321:                                              ; preds = %324, %317
  %322 = load i32, ptr %45, align 4, !tbaa !11
  %323 = icmp ugt i32 %322, 0
  br i1 %323, label %324, label %337

324:                                              ; preds = %321
  %325 = load ptr, ptr %44, align 8, !tbaa !5
  %326 = getelementptr inbounds i8, ptr %325, i32 1
  store ptr %326, ptr %44, align 8, !tbaa !5
  %327 = load i8, ptr %325, align 1, !tbaa !13
  %328 = zext i8 %327 to i32
  %329 = load ptr, ptr %43, align 8, !tbaa !5
  %330 = getelementptr inbounds i8, ptr %329, i32 1
  store ptr %330, ptr %43, align 8, !tbaa !5
  %331 = load i8, ptr %329, align 1, !tbaa !13
  %332 = zext i8 %331 to i32
  %333 = xor i32 %332, %328
  %334 = trunc i32 %333 to i8
  store i8 %334, ptr %329, align 1, !tbaa !13
  %335 = load i32, ptr %45, align 4, !tbaa !11
  %336 = add i32 %335, -1
  store i32 %336, ptr %45, align 4, !tbaa !11
  br label %321, !llvm.loop !21

337:                                              ; preds = %321
  call void @llvm.lifetime.end.p0(i64 4, ptr %45) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %43) #4
  br label %338

338:                                              ; preds = %337
  br label %339

339:                                              ; preds = %338
  %340 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  %341 = load i32, ptr %37, align 4, !tbaa !11
  %342 = zext i32 %341 to i64
  %343 = getelementptr inbounds i8, ptr %340, i64 %342
  %344 = load i8, ptr %343, align 1, !tbaa !13
  %345 = zext i8 %344 to i32
  %346 = xor i32 %345, 128
  %347 = trunc i32 %346 to i8
  store i8 %347, ptr %343, align 1, !tbaa !13
  %348 = load ptr, ptr %10, align 8, !tbaa !5
  %349 = getelementptr inbounds [16 x i8], ptr %20, i64 0, i64 0
  %350 = load i32, ptr %37, align 4, !tbaa !11
  %351 = zext i32 %350 to i64
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %348, ptr align 16 %349, i64 %351, i1 false)
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #4
  br label %352

352:                                              ; preds = %339, %249
  %353 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  call void @sparkle_256(ptr noundef %353, i32 noundef 10)
  %354 = load i64, ptr %13, align 8, !tbaa !9
  %355 = load ptr, ptr %10, align 8, !tbaa !5
  %356 = getelementptr inbounds i8, ptr %355, i64 %354
  store ptr %356, ptr %10, align 8, !tbaa !5
  br label %357

357:                                              ; preds = %352, %66
  br label %358

358:                                              ; preds = %357
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #4
  %359 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %359, ptr %46, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #4
  %360 = getelementptr inbounds [8 x i32], ptr %19, i64 0, i64 0
  %361 = getelementptr inbounds i8, ptr %360, i64 16
  store ptr %361, ptr %47, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %48) #4
  %362 = load ptr, ptr %18, align 8, !tbaa !5
  store ptr %362, ptr %48, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %49) #4
  store i32 16, ptr %49, align 4, !tbaa !11
  br label %363

363:                                              ; preds = %366, %358
  %364 = load i32, ptr %49, align 4, !tbaa !11
  %365 = icmp ugt i32 %364, 0
  br i1 %365, label %366, label %381

366:                                              ; preds = %363
  %367 = load ptr, ptr %47, align 8, !tbaa !5
  %368 = getelementptr inbounds i8, ptr %367, i32 1
  store ptr %368, ptr %47, align 8, !tbaa !5
  %369 = load i8, ptr %367, align 1, !tbaa !13
  %370 = zext i8 %369 to i32
  %371 = load ptr, ptr %48, align 8, !tbaa !5
  %372 = getelementptr inbounds i8, ptr %371, i32 1
  store ptr %372, ptr %48, align 8, !tbaa !5
  %373 = load i8, ptr %371, align 1, !tbaa !13
  %374 = zext i8 %373 to i32
  %375 = xor i32 %370, %374
  %376 = trunc i32 %375 to i8
  %377 = load ptr, ptr %46, align 8, !tbaa !5
  %378 = getelementptr inbounds i8, ptr %377, i32 1
  store ptr %378, ptr %46, align 8, !tbaa !5
  store i8 %376, ptr %377, align 1, !tbaa !13
  %379 = load i32, ptr %49, align 4, !tbaa !11
  %380 = add i32 %379, -1
  store i32 %380, ptr %49, align 4, !tbaa !11
  br label %363, !llvm.loop !22

381:                                              ; preds = %363
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %48) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #4
  br label %382

382:                                              ; preds = %381
  br label %383

383:                                              ; preds = %382
  call void @llvm.lifetime.end.p0(i64 16, ptr %20) #4
  call void @llvm.lifetime.end.p0(i64 32, ptr %19) #4
  ret i32 0
}

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

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

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

declare void @sparkle_256(ptr noundef, i32 noundef) #3

; Function Attrs: nounwind uwtable
declare hidden void @schwaemm_128_128_authenticate(ptr noundef, ptr noundef, i64 noundef) #0

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #3 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { 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 = !{!12, !12, i64 0}
!12 = !{!"int", !7, i64 0}
!13 = !{!7, !7, i64 0}
!14 = distinct !{!14, !15}
!15 = !{!"llvm.loop.mustprogress"}
!16 = distinct !{!16, !15}
!17 = distinct !{!17, !15}
!18 = distinct !{!18, !15}
!19 = distinct !{!19, !15}
!20 = distinct !{!20, !15}
!21 = distinct !{!21, !15}
!22 = distinct !{!22, !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 noundef i32 @schwaemm_128_128_aead_encrypt(ptr nocapture noundef writeonly %0, ptr nocapture noundef writeonly %1, ptr nocapture noundef readonly %2, i64 noundef %3, ptr noundef %4, i64 noundef %5, ptr nocapture noundef readnone %6, ptr nocapture noundef readonly %7, ptr nocapture noundef readonly %8) local_unnamed_addr #0 {
  %10 = alloca [8 x i32], align 16
  %11 = ptrtoint ptr %10 to i64
  %12 = alloca [16 x i8], align 16
  %13 = ptrtoint ptr %12 to i64
  call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %10) #4
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %12) #4
  %14 = add i64 %3, 16
  store i64 %14, ptr %1, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(16) %10, ptr noundef nonnull align 1 dereferenceable(16) %7, i64 16, i1 false)
  %15 = getelementptr inbounds i8, ptr %10, i64 16
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(16) %15, ptr noundef nonnull align 1 dereferenceable(16) %8, i64 16, i1 false)
  call void @sparkle_256(ptr noundef nonnull %10, i32 noundef 10) #4
  %.not = icmp eq i64 %5, 0
  br i1 %.not, label %17, label %16

16:                                               ; preds = %9
  call void @schwaemm_128_128_authenticate(ptr noundef nonnull %10, ptr noundef %4, i64 noundef %5)
  br label %17

17:                                               ; preds = %16, %9
  %.not98 = icmp eq i64 %3, 0
  br i1 %.not98, label %254, label %.preheader107

.preheader107:                                    ; preds = %17
  %18 = icmp ugt i64 %3, 16
  br i1 %18, label %.preheader106.lr.ph, label %._crit_edge

.preheader106.lr.ph:                              ; preds = %.preheader107
  %19 = getelementptr inbounds i8, ptr %10, i64 8
  %20 = getelementptr inbounds i8, ptr %10, i64 24
  %21 = getelementptr inbounds i8, ptr %10, i64 4
  %22 = getelementptr inbounds i8, ptr %10, i64 12
  %23 = getelementptr inbounds i8, ptr %10, i64 20
  %24 = getelementptr inbounds i8, ptr %10, i64 28
  %25 = getelementptr inbounds i8, ptr %10, i64 7
  %26 = getelementptr inbounds i8, ptr %10, i64 11
  br label %.preheader106

.preheader106:                                    ; preds = %.preheader106.lr.ph, %.preheader106
  %.075117 = phi ptr [ %0, %.preheader106.lr.ph ], [ %78, %.preheader106 ]
  %.080116 = phi ptr [ %2, %.preheader106.lr.ph ], [ %79, %.preheader106 ]
  %.084115 = phi i64 [ %3, %.preheader106.lr.ph ], [ %80, %.preheader106 ]
  %27 = load <16 x i8>, ptr %10, align 16, !tbaa !9
  %28 = load <16 x i8>, ptr %.080116, align 1, !tbaa !9
  %29 = xor <16 x i8> %28, %27
  store <16 x i8> %29, ptr %12, align 16, !tbaa !9
  %30 = load i32, ptr %10, align 16, !tbaa !10
  %31 = load i32, ptr %19, align 8, !tbaa !10
  %32 = load i32, ptr %15, align 16, !tbaa !10
  %33 = load i32, ptr %20, align 8, !tbaa !10
  %34 = xor i32 %30, %33
  %35 = xor i32 %34, %31
  store i32 %35, ptr %19, align 8, !tbaa !10
  %36 = load i32, ptr %21, align 4, !tbaa !10
  %37 = load i32, ptr %22, align 4, !tbaa !10
  %38 = load i32, ptr %23, align 4, !tbaa !10
  %39 = xor i32 %38, %37
  store i32 %39, ptr %21, align 4, !tbaa !10
  %40 = load i32, ptr %24, align 4, !tbaa !10
  %41 = xor i32 %36, %40
  %42 = xor i32 %41, %37
  %43 = xor i32 %32, %31
  %44 = lshr i32 %43, 8
  %45 = lshr i32 %43, 16
  %46 = lshr i32 %43, 24
  %47 = insertelement <4 x i32> poison, i32 %43, i64 0
  %48 = insertelement <4 x i32> %47, i32 %44, i64 1
  %49 = insertelement <4 x i32> %48, i32 %45, i64 2
  %50 = insertelement <4 x i32> %49, i32 %46, i64 3
  %51 = trunc <4 x i32> %50 to <4 x i8>
  %52 = trunc i32 %39 to i8
  %53 = lshr i32 %39, 8
  %54 = trunc i32 %53 to i8
  %55 = lshr i32 %39, 16
  %56 = trunc i32 %55 to i8
  %57 = load <16 x i8>, ptr %25, align 1
  %58 = load i8, ptr %26, align 1, !tbaa !9
  %59 = trunc i32 %42 to i8
  %60 = lshr i32 %42, 8
  %61 = trunc i32 %60 to i8
  %62 = lshr i32 %42, 16
  %63 = trunc i32 %62 to i8
  %64 = lshr i32 %42, 24
  %65 = trunc nuw i32 %64 to i8
  %66 = load <16 x i8>, ptr %.080116, align 1, !tbaa !9
  %67 = shufflevector <4 x i8> %51, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
  %68 = insertelement <16 x i8> %67, i8 %52, i64 4
  %69 = insertelement <16 x i8> %68, i8 %54, i64 5
  %70 = insertelement <16 x i8> %69, i8 %56, i64 6
  %71 = shufflevector <16 x i8> %70, <16 x i8> %57, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 16, i32 17, i32 18, i32 19, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
  %72 = insertelement <16 x i8> %71, i8 %58, i64 11
  %73 = insertelement <16 x i8> %72, i8 %59, i64 12
  %74 = insertelement <16 x i8> %73, i8 %61, i64 13
  %75 = insertelement <16 x i8> %74, i8 %63, i64 14
  %76 = insertelement <16 x i8> %75, i8 %65, i64 15
  %77 = xor <16 x i8> %66, %76
  store <16 x i8> %77, ptr %10, align 16, !tbaa !9
  call void @sparkle_256(ptr noundef nonnull %10, i32 noundef 7) #4
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(16) %.075117, ptr noundef nonnull align 16 dereferenceable(16) %12, i64 16, i1 false)
  %78 = getelementptr inbounds i8, ptr %.075117, i64 16
  %79 = getelementptr inbounds i8, ptr %.080116, i64 16
  %80 = add i64 %.084115, -16
  %81 = icmp ugt i64 %80, 16
  br i1 %81, label %.preheader106, label %._crit_edge, !llvm.loop !12

._crit_edge:                                      ; preds = %.preheader106, %.preheader107
  %.084.lcssa = phi i64 [ %3, %.preheader107 ], [ %80, %.preheader106 ]
  %.080.lcssa = phi ptr [ %2, %.preheader107 ], [ %79, %.preheader106 ]
  %.075.lcssa = phi ptr [ %0, %.preheader107 ], [ %78, %.preheader106 ]
  %.080.lcssa151 = ptrtoint ptr %.080.lcssa to i64
  %82 = icmp eq i64 %.084.lcssa, 16
  br i1 %82, label %.preheader.preheader, label %iter.check

.preheader.preheader:                             ; preds = %._crit_edge
  %83 = getelementptr inbounds i8, ptr %10, i64 7
  %84 = getelementptr inbounds i8, ptr %10, i64 11
  %85 = load <16 x i8>, ptr %10, align 16, !tbaa !9
  %86 = load <16 x i8>, ptr %.080.lcssa, align 1, !tbaa !9
  %87 = xor <16 x i8> %86, %85
  store <16 x i8> %87, ptr %12, align 16, !tbaa !9
  %88 = getelementptr inbounds i8, ptr %10, i64 28
  %89 = load i32, ptr %88, align 4, !tbaa !10
  %90 = xor i32 %89, 117440512
  store i32 %90, ptr %88, align 4, !tbaa !10
  %91 = load i32, ptr %10, align 16, !tbaa !10
  %92 = getelementptr inbounds i8, ptr %10, i64 8
  %93 = load i32, ptr %92, align 8, !tbaa !10
  %94 = load i32, ptr %15, align 16, !tbaa !10
  %95 = getelementptr inbounds i8, ptr %10, i64 24
  %96 = load i32, ptr %95, align 8, !tbaa !10
  %97 = xor i32 %91, %96
  %98 = xor i32 %97, %93
  store i32 %98, ptr %92, align 8, !tbaa !10
  %99 = getelementptr inbounds i8, ptr %10, i64 4
  %100 = load i32, ptr %99, align 4, !tbaa !10
  %101 = getelementptr inbounds i8, ptr %10, i64 12
  %102 = load i32, ptr %101, align 4, !tbaa !10
  %103 = getelementptr inbounds i8, ptr %10, i64 20
  %104 = load i32, ptr %103, align 4, !tbaa !10
  %105 = xor i32 %104, %102
  store i32 %105, ptr %99, align 4, !tbaa !10
  %106 = xor i32 %100, %90
  %107 = xor i32 %106, %102
  store i32 %107, ptr %101, align 4, !tbaa !10
  %108 = xor i32 %94, %93
  store i32 %108, ptr %10, align 16, !tbaa !10
  %109 = lshr i32 %108, 8
  %110 = lshr i32 %108, 16
  %111 = lshr i32 %108, 24
  %112 = insertelement <4 x i32> poison, i32 %108, i64 0
  %113 = insertelement <4 x i32> %112, i32 %109, i64 1
  %114 = insertelement <4 x i32> %113, i32 %110, i64 2
  %115 = insertelement <4 x i32> %114, i32 %111, i64 3
  %116 = trunc <4 x i32> %115 to <4 x i8>
  %117 = trunc i32 %105 to i8
  %118 = lshr i32 %105, 8
  %119 = trunc i32 %118 to i8
  %120 = lshr i32 %105, 16
  %121 = trunc i32 %120 to i8
  %122 = load <16 x i8>, ptr %83, align 1
  %123 = load i8, ptr %84, align 1, !tbaa !9
  %124 = trunc i32 %107 to i8
  %125 = lshr i32 %107, 8
  %126 = trunc i32 %125 to i8
  %127 = lshr i32 %107, 16
  %128 = trunc i32 %127 to i8
  %129 = lshr i32 %107, 24
  %130 = trunc nuw i32 %129 to i8
  %131 = load <16 x i8>, ptr %.080.lcssa, align 1, !tbaa !9
  %132 = shufflevector <4 x i8> %116, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
  %133 = insertelement <16 x i8> %132, i8 %117, i64 4
  %134 = insertelement <16 x i8> %133, i8 %119, i64 5
  %135 = insertelement <16 x i8> %134, i8 %121, i64 6
  %136 = shufflevector <16 x i8> %135, <16 x i8> %122, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 16, i32 17, i32 18, i32 19, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
  %137 = insertelement <16 x i8> %136, i8 %123, i64 11
  %138 = insertelement <16 x i8> %137, i8 %124, i64 12
  %139 = insertelement <16 x i8> %138, i8 %126, i64 13
  %140 = insertelement <16 x i8> %139, i8 %128, i64 14
  %141 = insertelement <16 x i8> %140, i8 %130, i64 15
  %142 = xor <16 x i8> %131, %141
  store <16 x i8> %142, ptr %10, align 16, !tbaa !9
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(16) %.075.lcssa, ptr noundef nonnull align 16 dereferenceable(16) %12, i64 16, i1 false)
  br label %252

iter.check:                                       ; preds = %._crit_edge
  %143 = trunc nuw i64 %.084.lcssa to i32
  %144 = add nuw nsw i64 %.084.lcssa, 4294967295
  %145 = and i64 %144, 4294967295
  %146 = add nuw nsw i64 %145, 1
  %min.iters.check = icmp ult i64 %145, 7
  br i1 %min.iters.check, label %.lr.ph.preheader, label %vector.memcheck

vector.memcheck:                                  ; preds = %iter.check
  %147 = sub i64 %13, %11
  %diff.check = icmp ult i64 %147, 32
  %148 = sub i64 %13, %.080.lcssa151
  %diff.check152 = icmp ult i64 %148, 32
  %conflict.rdx = or i1 %diff.check, %diff.check152
  br i1 %conflict.rdx, label %.lr.ph.preheader, label %vector.main.loop.iter.check

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

vector.ph:                                        ; preds = %vector.main.loop.iter.check
  %n.vec = and i64 %146, 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 %.080.lcssa, i64 %index
  %next.gep155 = getelementptr i8, ptr %10, i64 %index
  %next.gep157 = getelementptr i8, ptr %12, i64 %index
  %149 = getelementptr i8, ptr %next.gep155, i64 16
  %wide.load = load <16 x i8>, ptr %next.gep155, align 16, !tbaa !9
  %wide.load159 = load <16 x i8>, ptr %149, align 16, !tbaa !9
  %150 = getelementptr i8, ptr %next.gep, i64 16
  %wide.load160 = load <16 x i8>, ptr %next.gep, align 1, !tbaa !9
  %wide.load161 = load <16 x i8>, ptr %150, align 1, !tbaa !9
  %151 = xor <16 x i8> %wide.load160, %wide.load
  %152 = xor <16 x i8> %wide.load161, %wide.load159
  %153 = getelementptr i8, ptr %next.gep157, i64 16
  store <16 x i8> %151, ptr %next.gep157, align 16, !tbaa !9
  store <16 x i8> %152, ptr %153, align 16, !tbaa !9
  %index.next = add nuw i64 %index, 32
  %154 = icmp eq i64 %index.next, %n.vec
  br i1 %154, label %middle.block, label %vector.body, !llvm.loop !14

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

vec.epilog.iter.check:                            ; preds = %middle.block
  %ind.end173 = getelementptr i8, ptr %12, i64 %n.vec
  %ind.end170 = getelementptr i8, ptr %10, i64 %n.vec
  %ind.end167 = getelementptr i8, ptr %.080.lcssa, i64 %n.vec
  %.cast164 = trunc i64 %n.vec to i32
  %ind.end165 = sub i32 %143, %.cast164
  %n.vec.remaining = and i64 %146, 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.vec163 = and i64 %146, 8589934584
  %.cast = trunc i64 %n.vec163 to i32
  %ind.end = sub i32 %143, %.cast
  %ind.end166 = getelementptr i8, ptr %.080.lcssa, i64 %n.vec163
  %ind.end169 = getelementptr i8, ptr %10, i64 %n.vec163
  %ind.end172 = getelementptr i8, ptr %12, i64 %n.vec163
  br label %vec.epilog.vector.body

vec.epilog.vector.body:                           ; preds = %vec.epilog.vector.body, %vec.epilog.ph
  %index175 = phi i64 [ %vec.epilog.resume.val, %vec.epilog.ph ], [ %index.next181, %vec.epilog.vector.body ]
  %next.gep176 = getelementptr i8, ptr %.080.lcssa, i64 %index175
  %next.gep177 = getelementptr i8, ptr %10, i64 %index175
  %next.gep178 = getelementptr i8, ptr %12, i64 %index175
  %wide.load179 = load <8 x i8>, ptr %next.gep177, align 8, !tbaa !9
  %wide.load180 = load <8 x i8>, ptr %next.gep176, align 1, !tbaa !9
  %155 = xor <8 x i8> %wide.load180, %wide.load179
  store <8 x i8> %155, ptr %next.gep178, align 8, !tbaa !9
  %index.next181 = add nuw i64 %index175, 8
  %156 = icmp eq i64 %index.next181, %n.vec163
  br i1 %156, label %vec.epilog.middle.block, label %vec.epilog.vector.body, !llvm.loop !17

vec.epilog.middle.block:                          ; preds = %vec.epilog.vector.body
  %cmp.n182 = icmp eq i64 %146, %n.vec163
  br i1 %cmp.n182, label %iter.check188, label %.lr.ph.preheader

.lr.ph.preheader:                                 ; preds = %vec.epilog.middle.block, %vector.memcheck, %iter.check, %vec.epilog.iter.check
  %.076124.ph = phi i32 [ %143, %iter.check ], [ %143, %vector.memcheck ], [ %ind.end165, %vec.epilog.iter.check ], [ %ind.end, %vec.epilog.middle.block ]
  %.077123.ph = phi ptr [ %.080.lcssa, %iter.check ], [ %.080.lcssa, %vector.memcheck ], [ %ind.end167, %vec.epilog.iter.check ], [ %ind.end166, %vec.epilog.middle.block ]
  %.078122.ph = phi ptr [ %10, %iter.check ], [ %10, %vector.memcheck ], [ %ind.end170, %vec.epilog.iter.check ], [ %ind.end169, %vec.epilog.middle.block ]
  %.079121.ph = phi ptr [ %12, %iter.check ], [ %12, %vector.memcheck ], [ %ind.end173, %vec.epilog.iter.check ], [ %ind.end172, %vec.epilog.middle.block ]
  %157 = add nsw i32 %.076124.ph, -1
  %xtraiter = and i32 %.076124.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
  %.076124.prol = phi i32 [ %164, %.lr.ph.prol ], [ %.076124.ph, %.lr.ph.preheader ]
  %.077123.prol = phi ptr [ %160, %.lr.ph.prol ], [ %.077123.ph, %.lr.ph.preheader ]
  %.078122.prol = phi ptr [ %158, %.lr.ph.prol ], [ %.078122.ph, %.lr.ph.preheader ]
  %.079121.prol = phi ptr [ %163, %.lr.ph.prol ], [ %.079121.ph, %.lr.ph.preheader ]
  %prol.iter = phi i32 [ %prol.iter.next, %.lr.ph.prol ], [ 0, %.lr.ph.preheader ]
  %158 = getelementptr inbounds i8, ptr %.078122.prol, i64 1
  %159 = load i8, ptr %.078122.prol, align 1, !tbaa !9
  %160 = getelementptr inbounds i8, ptr %.077123.prol, i64 1
  %161 = load i8, ptr %.077123.prol, align 1, !tbaa !9
  %162 = xor i8 %161, %159
  %163 = getelementptr inbounds i8, ptr %.079121.prol, i64 1
  store i8 %162, ptr %.079121.prol, align 1, !tbaa !9
  %164 = add nsw i32 %.076124.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 !18

.lr.ph.prol.loopexit:                             ; preds = %.lr.ph.prol, %.lr.ph.preheader
  %.076124.unr = phi i32 [ %.076124.ph, %.lr.ph.preheader ], [ %164, %.lr.ph.prol ]
  %.077123.unr = phi ptr [ %.077123.ph, %.lr.ph.preheader ], [ %160, %.lr.ph.prol ]
  %.078122.unr = phi ptr [ %.078122.ph, %.lr.ph.preheader ], [ %158, %.lr.ph.prol ]
  %.079121.unr = phi ptr [ %.079121.ph, %.lr.ph.preheader ], [ %163, %.lr.ph.prol ]
  %165 = icmp ult i32 %157, 3
  br i1 %165, label %iter.check188, label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.prol.loopexit, %.lr.ph
  %.076124 = phi i32 [ %190, %.lr.ph ], [ %.076124.unr, %.lr.ph.prol.loopexit ]
  %.077123 = phi ptr [ %186, %.lr.ph ], [ %.077123.unr, %.lr.ph.prol.loopexit ]
  %.078122 = phi ptr [ %184, %.lr.ph ], [ %.078122.unr, %.lr.ph.prol.loopexit ]
  %.079121 = phi ptr [ %189, %.lr.ph ], [ %.079121.unr, %.lr.ph.prol.loopexit ]
  %166 = getelementptr inbounds i8, ptr %.078122, i64 1
  %167 = load i8, ptr %.078122, align 1, !tbaa !9
  %168 = getelementptr inbounds i8, ptr %.077123, i64 1
  %169 = load i8, ptr %.077123, align 1, !tbaa !9
  %170 = xor i8 %169, %167
  %171 = getelementptr inbounds i8, ptr %.079121, i64 1
  store i8 %170, ptr %.079121, align 1, !tbaa !9
  %172 = getelementptr inbounds i8, ptr %.078122, i64 2
  %173 = load i8, ptr %166, align 1, !tbaa !9
  %174 = getelementptr inbounds i8, ptr %.077123, i64 2
  %175 = load i8, ptr %168, align 1, !tbaa !9
  %176 = xor i8 %175, %173
  %177 = getelementptr inbounds i8, ptr %.079121, i64 2
  store i8 %176, ptr %171, align 1, !tbaa !9
  %178 = getelementptr inbounds i8, ptr %.078122, i64 3
  %179 = load i8, ptr %172, align 1, !tbaa !9
  %180 = getelementptr inbounds i8, ptr %.077123, i64 3
  %181 = load i8, ptr %174, align 1, !tbaa !9
  %182 = xor i8 %181, %179
  %183 = getelementptr inbounds i8, ptr %.079121, i64 3
  store i8 %182, ptr %177, align 1, !tbaa !9
  %184 = getelementptr inbounds i8, ptr %.078122, i64 4
  %185 = load i8, ptr %178, align 1, !tbaa !9
  %186 = getelementptr inbounds i8, ptr %.077123, i64 4
  %187 = load i8, ptr %180, align 1, !tbaa !9
  %188 = xor i8 %187, %185
  %189 = getelementptr inbounds i8, ptr %.079121, i64 4
  store i8 %188, ptr %183, align 1, !tbaa !9
  %190 = add nsw i32 %.076124, -4
  %.not99.3 = icmp eq i32 %190, 0
  br i1 %.not99.3, label %iter.check188, label %.lr.ph, !llvm.loop !20

iter.check188:                                    ; preds = %.lr.ph.prol.loopexit, %.lr.ph, %vec.epilog.middle.block, %middle.block
  %191 = getelementptr inbounds i8, ptr %10, i64 28
  %192 = load i32, ptr %191, align 4, !tbaa !10
  %193 = xor i32 %192, 100663296
  store i32 %193, ptr %191, align 4, !tbaa !10
  %194 = getelementptr inbounds i8, ptr %10, i64 8
  %195 = getelementptr inbounds i8, ptr %10, i64 24
  %196 = load i32, ptr %195, align 8, !tbaa !10
  %197 = load <4 x i32>, ptr %15, align 16
  %198 = load <2 x i32>, ptr %10, align 16, !tbaa !10
  %199 = insertelement <2 x i32> poison, i32 %196, i64 0
  %200 = insertelement <2 x i32> %199, i32 %193, i64 1
  %201 = xor <2 x i32> %198, %200
  %202 = load <2 x i32>, ptr %194, align 8, !tbaa !10
  %203 = shufflevector <2 x i32> %202, <2 x i32> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
  %204 = shufflevector <2 x i32> %201, <2 x i32> poison, <4 x i32> <i32 0, i32 1, i32 poison, i32 poison>
  %205 = shufflevector <4 x i32> %197, <4 x i32> %204, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
  %206 = xor <4 x i32> %205, %203
  store <4 x i32> %206, ptr %10, align 16, !tbaa !10
  %207 = add nuw nsw i64 %.084.lcssa, 4294967295
  %208 = and i64 %207, 4294967295
  %209 = add nuw nsw i64 %208, 1
  %min.iters.check186 = icmp ult i64 %208, 7
  br i1 %min.iters.check186, label %.lr.ph132.preheader, label %vector.memcheck183

vector.memcheck183:                               ; preds = %iter.check188
  %210 = add nuw nsw i64 %.084.lcssa, 4294967295
  %211 = and i64 %210, 4294967295
  %212 = add nuw nsw i64 %211, 1
  %scevgep = getelementptr i8, ptr %10, i64 %212
  %scevgep184 = getelementptr i8, ptr %.080.lcssa, i64 %212
  %bound0 = icmp ult ptr %10, %scevgep184
  %bound1 = icmp ult ptr %.080.lcssa, %scevgep
  %found.conflict = and i1 %bound0, %bound1
  br i1 %found.conflict, label %.lr.ph132.preheader, label %vector.main.loop.iter.check190

vector.main.loop.iter.check190:                   ; preds = %vector.memcheck183
  %min.iters.check189 = icmp ult i64 %208, 31
  br i1 %min.iters.check189, label %vec.epilog.ph208, label %vector.ph191

vector.ph191:                                     ; preds = %vector.main.loop.iter.check190
  %n.vec193 = and i64 %209, 8589934560
  br label %vector.body194

vector.body194:                                   ; preds = %vector.body194, %vector.ph191
  %index195 = phi i64 [ 0, %vector.ph191 ], [ %index.next204, %vector.body194 ]
  %next.gep196 = getelementptr i8, ptr %.080.lcssa, i64 %index195
  %next.gep198 = getelementptr i8, ptr %10, i64 %index195
  %213 = getelementptr i8, ptr %next.gep196, i64 16
  %wide.load200 = load <16 x i8>, ptr %next.gep196, align 1, !tbaa !9, !alias.scope !21
  %wide.load201 = load <16 x i8>, ptr %213, align 1, !tbaa !9, !alias.scope !21
  %214 = getelementptr i8, ptr %next.gep198, i64 16
  %wide.load202 = load <16 x i8>, ptr %next.gep198, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %wide.load203 = load <16 x i8>, ptr %214, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %215 = xor <16 x i8> %wide.load202, %wide.load200
  %216 = xor <16 x i8> %wide.load203, %wide.load201
  store <16 x i8> %215, ptr %next.gep198, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  store <16 x i8> %216, ptr %214, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %index.next204 = add nuw i64 %index195, 32
  %217 = icmp eq i64 %index.next204, %n.vec193
  br i1 %217, label %middle.block185, label %vector.body194, !llvm.loop !26

middle.block185:                                  ; preds = %vector.body194
  %cmp.n205 = icmp eq i64 %209, %n.vec193
  br i1 %cmp.n205, label %._crit_edge133, label %vec.epilog.iter.check209

vec.epilog.iter.check209:                         ; preds = %middle.block185
  %ind.end224 = getelementptr i8, ptr %10, i64 %n.vec193
  %ind.end221 = getelementptr i8, ptr %.080.lcssa, i64 %n.vec193
  %.cast217 = trunc i64 %n.vec193 to i32
  %ind.end218 = sub i32 %143, %.cast217
  %n.vec.remaining210 = and i64 %209, 24
  %min.epilog.iters.check211 = icmp eq i64 %n.vec.remaining210, 0
  br i1 %min.epilog.iters.check211, label %.lr.ph132.preheader, label %vec.epilog.ph208

vec.epilog.ph208:                                 ; preds = %vector.main.loop.iter.check190, %vec.epilog.iter.check209
  %vec.epilog.resume.val212 = phi i64 [ %n.vec193, %vec.epilog.iter.check209 ], [ 0, %vector.main.loop.iter.check190 ]
  %n.vec214 = and i64 %209, 8589934584
  %.cast215 = trunc i64 %n.vec214 to i32
  %ind.end216 = sub i32 %143, %.cast215
  %ind.end220 = getelementptr i8, ptr %.080.lcssa, i64 %n.vec214
  %ind.end223 = getelementptr i8, ptr %10, i64 %n.vec214
  br label %vec.epilog.vector.body226

vec.epilog.vector.body226:                        ; preds = %vec.epilog.vector.body226, %vec.epilog.ph208
  %index227 = phi i64 [ %vec.epilog.resume.val212, %vec.epilog.ph208 ], [ %index.next232, %vec.epilog.vector.body226 ]
  %next.gep228 = getelementptr i8, ptr %.080.lcssa, i64 %index227
  %next.gep229 = getelementptr i8, ptr %10, i64 %index227
  %wide.load230 = load <8 x i8>, ptr %next.gep228, align 1, !tbaa !9, !alias.scope !27
  %wide.load231 = load <8 x i8>, ptr %next.gep229, align 8, !tbaa !9, !alias.scope !30, !noalias !27
  %218 = xor <8 x i8> %wide.load231, %wide.load230
  store <8 x i8> %218, ptr %next.gep229, align 8, !tbaa !9, !alias.scope !30, !noalias !27
  %index.next232 = add nuw i64 %index227, 8
  %219 = icmp eq i64 %index.next232, %n.vec214
  br i1 %219, label %vec.epilog.middle.block206, label %vec.epilog.vector.body226, !llvm.loop !32

vec.epilog.middle.block206:                       ; preds = %vec.epilog.vector.body226
  %cmp.n233 = icmp eq i64 %209, %n.vec214
  br i1 %cmp.n233, label %._crit_edge133, label %.lr.ph132.preheader

.lr.ph132.preheader:                              ; preds = %vec.epilog.middle.block206, %vector.memcheck183, %iter.check188, %vec.epilog.iter.check209
  %.072130.ph = phi i32 [ %143, %iter.check188 ], [ %143, %vector.memcheck183 ], [ %ind.end218, %vec.epilog.iter.check209 ], [ %ind.end216, %vec.epilog.middle.block206 ]
  %.073129.ph = phi ptr [ %.080.lcssa, %iter.check188 ], [ %.080.lcssa, %vector.memcheck183 ], [ %ind.end221, %vec.epilog.iter.check209 ], [ %ind.end220, %vec.epilog.middle.block206 ]
  %.074128.ph = phi ptr [ %10, %iter.check188 ], [ %10, %vector.memcheck183 ], [ %ind.end224, %vec.epilog.iter.check209 ], [ %ind.end223, %vec.epilog.middle.block206 ]
  %220 = add nsw i32 %.072130.ph, -1
  %xtraiter236 = and i32 %.072130.ph, 3
  %lcmp.mod237.not = icmp eq i32 %xtraiter236, 0
  br i1 %lcmp.mod237.not, label %.lr.ph132.prol.loopexit, label %.lr.ph132.prol

.lr.ph132.prol:                                   ; preds = %.lr.ph132.preheader, %.lr.ph132.prol
  %.072130.prol = phi i32 [ %226, %.lr.ph132.prol ], [ %.072130.ph, %.lr.ph132.preheader ]
  %.073129.prol = phi ptr [ %221, %.lr.ph132.prol ], [ %.073129.ph, %.lr.ph132.preheader ]
  %.074128.prol = phi ptr [ %223, %.lr.ph132.prol ], [ %.074128.ph, %.lr.ph132.preheader ]
  %prol.iter238 = phi i32 [ %prol.iter238.next, %.lr.ph132.prol ], [ 0, %.lr.ph132.preheader ]
  %221 = getelementptr inbounds i8, ptr %.073129.prol, i64 1
  %222 = load i8, ptr %.073129.prol, align 1, !tbaa !9
  %223 = getelementptr inbounds i8, ptr %.074128.prol, i64 1
  %224 = load i8, ptr %.074128.prol, align 1, !tbaa !9
  %225 = xor i8 %224, %222
  store i8 %225, ptr %.074128.prol, align 1, !tbaa !9
  %226 = add nsw i32 %.072130.prol, -1
  %prol.iter238.next = add i32 %prol.iter238, 1
  %prol.iter238.cmp.not = icmp eq i32 %prol.iter238.next, %xtraiter236
  br i1 %prol.iter238.cmp.not, label %.lr.ph132.prol.loopexit, label %.lr.ph132.prol, !llvm.loop !33

.lr.ph132.prol.loopexit:                          ; preds = %.lr.ph132.prol, %.lr.ph132.preheader
  %.072130.unr = phi i32 [ %.072130.ph, %.lr.ph132.preheader ], [ %226, %.lr.ph132.prol ]
  %.073129.unr = phi ptr [ %.073129.ph, %.lr.ph132.preheader ], [ %221, %.lr.ph132.prol ]
  %.074128.unr = phi ptr [ %.074128.ph, %.lr.ph132.preheader ], [ %223, %.lr.ph132.prol ]
  %227 = icmp ult i32 %220, 3
  br i1 %227, label %._crit_edge133, label %.lr.ph132

.lr.ph132:                                        ; preds = %.lr.ph132.prol.loopexit, %.lr.ph132
  %.072130 = phi i32 [ %248, %.lr.ph132 ], [ %.072130.unr, %.lr.ph132.prol.loopexit ]
  %.073129 = phi ptr [ %243, %.lr.ph132 ], [ %.073129.unr, %.lr.ph132.prol.loopexit ]
  %.074128 = phi ptr [ %245, %.lr.ph132 ], [ %.074128.unr, %.lr.ph132.prol.loopexit ]
  %228 = getelementptr inbounds i8, ptr %.073129, i64 1
  %229 = load i8, ptr %.073129, align 1, !tbaa !9
  %230 = getelementptr inbounds i8, ptr %.074128, i64 1
  %231 = load i8, ptr %.074128, align 1, !tbaa !9
  %232 = xor i8 %231, %229
  store i8 %232, ptr %.074128, align 1, !tbaa !9
  %233 = getelementptr inbounds i8, ptr %.073129, i64 2
  %234 = load i8, ptr %228, align 1, !tbaa !9
  %235 = getelementptr inbounds i8, ptr %.074128, i64 2
  %236 = load i8, ptr %230, align 1, !tbaa !9
  %237 = xor i8 %236, %234
  store i8 %237, ptr %230, align 1, !tbaa !9
  %238 = getelementptr inbounds i8, ptr %.073129, i64 3
  %239 = load i8, ptr %233, align 1, !tbaa !9
  %240 = getelementptr inbounds i8, ptr %.074128, i64 3
  %241 = load i8, ptr %235, align 1, !tbaa !9
  %242 = xor i8 %241, %239
  store i8 %242, ptr %235, align 1, !tbaa !9
  %243 = getelementptr inbounds i8, ptr %.073129, i64 4
  %244 = load i8, ptr %238, align 1, !tbaa !9
  %245 = getelementptr inbounds i8, ptr %.074128, i64 4
  %246 = load i8, ptr %240, align 1, !tbaa !9
  %247 = xor i8 %246, %244
  store i8 %247, ptr %240, align 1, !tbaa !9
  %248 = add nsw i32 %.072130, -4
  %.not100.3 = icmp eq i32 %248, 0
  br i1 %.not100.3, label %._crit_edge133, label %.lr.ph132, !llvm.loop !34

._crit_edge133:                                   ; preds = %.lr.ph132.prol.loopexit, %.lr.ph132, %vec.epilog.middle.block206, %middle.block185
  %249 = getelementptr inbounds i8, ptr %10, i64 %.084.lcssa
  %250 = load i8, ptr %249, align 1, !tbaa !9
  %251 = xor i8 %250, -128
  store i8 %251, ptr %249, align 1, !tbaa !9
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %.075.lcssa, ptr nonnull align 16 %12, i64 %.084.lcssa, i1 false)
  br label %252

252:                                              ; preds = %._crit_edge133, %.preheader.preheader
  call void @sparkle_256(ptr noundef nonnull %10, i32 noundef 10) #4
  %253 = getelementptr inbounds i8, ptr %.075.lcssa, i64 %.084.lcssa
  br label %254

254:                                              ; preds = %17, %252
  %.1 = phi ptr [ %253, %252 ], [ %0, %17 ]
  %255 = getelementptr inbounds i8, ptr %10, i64 17
  %256 = load i8, ptr %15, align 16, !tbaa !9
  %257 = getelementptr inbounds i8, ptr %8, i64 1
  %258 = load i8, ptr %8, align 1, !tbaa !9
  %259 = xor i8 %258, %256
  %260 = getelementptr inbounds i8, ptr %.1, i64 1
  store i8 %259, ptr %.1, align 1, !tbaa !9
  %261 = getelementptr inbounds i8, ptr %10, i64 18
  %262 = load i8, ptr %255, align 1, !tbaa !9
  %263 = getelementptr inbounds i8, ptr %8, i64 2
  %264 = load i8, ptr %257, align 1, !tbaa !9
  %265 = xor i8 %264, %262
  %266 = getelementptr inbounds i8, ptr %.1, i64 2
  store i8 %265, ptr %260, align 1, !tbaa !9
  %267 = getelementptr inbounds i8, ptr %10, i64 19
  %268 = load i8, ptr %261, align 2, !tbaa !9
  %269 = getelementptr inbounds i8, ptr %8, i64 3
  %270 = load i8, ptr %263, align 1, !tbaa !9
  %271 = xor i8 %270, %268
  %272 = getelementptr inbounds i8, ptr %.1, i64 3
  store i8 %271, ptr %266, align 1, !tbaa !9
  %273 = getelementptr inbounds i8, ptr %10, i64 20
  %274 = load i8, ptr %267, align 1, !tbaa !9
  %275 = getelementptr inbounds i8, ptr %8, i64 4
  %276 = load i8, ptr %269, align 1, !tbaa !9
  %277 = xor i8 %276, %274
  %278 = getelementptr inbounds i8, ptr %.1, i64 4
  store i8 %277, ptr %272, align 1, !tbaa !9
  %279 = getelementptr inbounds i8, ptr %10, i64 21
  %280 = load i8, ptr %273, align 4, !tbaa !9
  %281 = getelementptr inbounds i8, ptr %8, i64 5
  %282 = load i8, ptr %275, align 1, !tbaa !9
  %283 = xor i8 %282, %280
  %284 = getelementptr inbounds i8, ptr %.1, i64 5
  store i8 %283, ptr %278, align 1, !tbaa !9
  %285 = getelementptr inbounds i8, ptr %10, i64 22
  %286 = load i8, ptr %279, align 1, !tbaa !9
  %287 = getelementptr inbounds i8, ptr %8, i64 6
  %288 = load i8, ptr %281, align 1, !tbaa !9
  %289 = xor i8 %288, %286
  %290 = getelementptr inbounds i8, ptr %.1, i64 6
  store i8 %289, ptr %284, align 1, !tbaa !9
  %291 = getelementptr inbounds i8, ptr %10, i64 23
  %292 = load i8, ptr %285, align 2, !tbaa !9
  %293 = getelementptr inbounds i8, ptr %8, i64 7
  %294 = load i8, ptr %287, align 1, !tbaa !9
  %295 = xor i8 %294, %292
  %296 = getelementptr inbounds i8, ptr %.1, i64 7
  store i8 %295, ptr %290, align 1, !tbaa !9
  %297 = getelementptr inbounds i8, ptr %10, i64 24
  %298 = load i8, ptr %291, align 1, !tbaa !9
  %299 = getelementptr inbounds i8, ptr %8, i64 8
  %300 = load i8, ptr %293, align 1, !tbaa !9
  %301 = xor i8 %300, %298
  %302 = getelementptr inbounds i8, ptr %.1, i64 8
  store i8 %301, ptr %296, align 1, !tbaa !9
  %303 = getelementptr inbounds i8, ptr %10, i64 25
  %304 = load i8, ptr %297, align 8, !tbaa !9
  %305 = getelementptr inbounds i8, ptr %8, i64 9
  %306 = load i8, ptr %299, align 1, !tbaa !9
  %307 = xor i8 %306, %304
  %308 = getelementptr inbounds i8, ptr %.1, i64 9
  store i8 %307, ptr %302, align 1, !tbaa !9
  %309 = getelementptr inbounds i8, ptr %10, i64 26
  %310 = load i8, ptr %303, align 1, !tbaa !9
  %311 = getelementptr inbounds i8, ptr %8, i64 10
  %312 = load i8, ptr %305, align 1, !tbaa !9
  %313 = xor i8 %312, %310
  %314 = getelementptr inbounds i8, ptr %.1, i64 10
  store i8 %313, ptr %308, align 1, !tbaa !9
  %315 = getelementptr inbounds i8, ptr %10, i64 27
  %316 = load i8, ptr %309, align 2, !tbaa !9
  %317 = getelementptr inbounds i8, ptr %8, i64 11
  %318 = load i8, ptr %311, align 1, !tbaa !9
  %319 = xor i8 %318, %316
  %320 = getelementptr inbounds i8, ptr %.1, i64 11
  store i8 %319, ptr %314, align 1, !tbaa !9
  %321 = getelementptr inbounds i8, ptr %10, i64 28
  %322 = load i8, ptr %315, align 1, !tbaa !9
  %323 = getelementptr inbounds i8, ptr %8, i64 12
  %324 = load i8, ptr %317, align 1, !tbaa !9
  %325 = xor i8 %324, %322
  %326 = getelementptr inbounds i8, ptr %.1, i64 12
  store i8 %325, ptr %320, align 1, !tbaa !9
  %327 = getelementptr inbounds i8, ptr %10, i64 29
  %328 = load i8, ptr %321, align 4, !tbaa !9
  %329 = getelementptr inbounds i8, ptr %8, i64 13
  %330 = load i8, ptr %323, align 1, !tbaa !9
  %331 = xor i8 %330, %328
  %332 = getelementptr inbounds i8, ptr %.1, i64 13
  store i8 %331, ptr %326, align 1, !tbaa !9
  %333 = getelementptr inbounds i8, ptr %10, i64 30
  %334 = load i8, ptr %327, align 1, !tbaa !9
  %335 = getelementptr inbounds i8, ptr %8, i64 14
  %336 = load i8, ptr %329, align 1, !tbaa !9
  %337 = xor i8 %336, %334
  %338 = getelementptr inbounds i8, ptr %.1, i64 14
  store i8 %337, ptr %332, align 1, !tbaa !9
  %339 = getelementptr inbounds i8, ptr %10, i64 31
  %340 = load i8, ptr %333, align 2, !tbaa !9
  %341 = getelementptr inbounds i8, ptr %8, i64 15
  %342 = load i8, ptr %335, align 1, !tbaa !9
  %343 = xor i8 %342, %340
  %344 = getelementptr inbounds i8, ptr %.1, i64 15
  store i8 %343, ptr %338, align 1, !tbaa !9
  %345 = load i8, ptr %339, align 1, !tbaa !9
  %346 = load i8, ptr %341, align 1, !tbaa !9
  %347 = xor i8 %346, %345
  store i8 %347, ptr %344, align 1, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %12) #4
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %10) #4
  ret i32 0
}

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

; 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) #2

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

declare void @sparkle_256(ptr noundef, i32 noundef) local_unnamed_addr #3

; Function Attrs: nounwind uwtable
declare hidden void @schwaemm_128_128_authenticate(ptr noundef, ptr noundef, i64 noundef) local_unnamed_addr #0

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #3 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { 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 = !{!"long long", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!7, !7, i64 0}
!10 = !{!11, !11, i64 0}
!11 = !{!"int", !7, i64 0}
!12 = distinct !{!12, !13}
!13 = !{!"llvm.loop.mustprogress"}
!14 = distinct !{!14, !13, !15, !16}
!15 = !{!"llvm.loop.isvectorized", i32 1}
!16 = !{!"llvm.loop.unroll.runtime.disable"}
!17 = distinct !{!17, !13, !15, !16}
!18 = distinct !{!18, !19}
!19 = !{!"llvm.loop.unroll.disable"}
!20 = distinct !{!20, !13, !15}
!21 = !{!22}
!22 = distinct !{!22, !23}
!23 = distinct !{!23, !"LVerDomain"}
!24 = !{!25}
!25 = distinct !{!25, !23}
!26 = distinct !{!26, !13, !15, !16}
!27 = !{!28}
!28 = distinct !{!28, !29}
!29 = distinct !{!29, !"LVerDomain"}
!30 = !{!31}
!31 = distinct !{!31, !29}
!32 = distinct !{!32, !13, !15, !16}
!33 = distinct !{!33, !19}
!34 = distinct !{!34, !13, !15}


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