; 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_256_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 [12 x i32], align 16
  %20 = alloca [32 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 48, ptr %19) #4
  call void @llvm.lifetime.start.p0(i64 32, 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 [12 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 32, i1 false)
  %56 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  %57 = getelementptr inbounds i8, ptr %56, i64 32
  %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 [12 x i32], ptr %19, i64 0, i64 0
  call void @sparkle_384(ptr noundef %59, i32 noundef 11)
  %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 [12 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_256_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 %447

69:                                               ; preds = %66
  br label %70

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

73:                                               ; preds = %70
  br label %74

74:                                               ; preds = %73
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #4
  %75 = getelementptr inbounds [32 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 [12 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 32, 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 [12 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 [12 x i32], ptr %19, i64 0, i64 4
  %103 = load i32, ptr %102, align 16, !tbaa !11
  %104 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 8
  %105 = load i32, ptr %104, align 16, !tbaa !11
  %106 = xor i32 %103, %105
  %107 = getelementptr inbounds [12 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 [12 x i32], ptr %19, i64 0, i64 8
  %110 = load i32, ptr %109, align 16, !tbaa !11
  %111 = xor i32 %108, %110
  %112 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 4
  %113 = load i32, ptr %112, align 16, !tbaa !11
  %114 = xor i32 %113, %111
  store i32 %114, ptr %112, align 16, !tbaa !11
  %115 = getelementptr inbounds [12 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 [12 x i32], ptr %19, i64 0, i64 5
  %118 = load i32, ptr %117, align 4, !tbaa !11
  %119 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 9
  %120 = load i32, ptr %119, align 4, !tbaa !11
  %121 = xor i32 %118, %120
  %122 = getelementptr inbounds [12 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 [12 x i32], ptr %19, i64 0, i64 9
  %125 = load i32, ptr %124, align 4, !tbaa !11
  %126 = xor i32 %123, %125
  %127 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 5
  %128 = load i32, ptr %127, align 4, !tbaa !11
  %129 = xor i32 %128, %126
  store i32 %129, ptr %127, align 4, !tbaa !11
  %130 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 2
  %131 = load i32, ptr %130, align 8, !tbaa !11
  store i32 %131, ptr %25, align 4, !tbaa !11
  %132 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 6
  %133 = load i32, ptr %132, align 8, !tbaa !11
  %134 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 10
  %135 = load i32, ptr %134, align 8, !tbaa !11
  %136 = xor i32 %133, %135
  %137 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 2
  store i32 %136, ptr %137, align 8, !tbaa !11
  %138 = load i32, ptr %25, align 4, !tbaa !11
  %139 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 10
  %140 = load i32, ptr %139, align 8, !tbaa !11
  %141 = xor i32 %138, %140
  %142 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 6
  %143 = load i32, ptr %142, align 8, !tbaa !11
  %144 = xor i32 %143, %141
  store i32 %144, ptr %142, align 8, !tbaa !11
  %145 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 3
  %146 = load i32, ptr %145, align 4, !tbaa !11
  store i32 %146, ptr %25, align 4, !tbaa !11
  %147 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 7
  %148 = load i32, ptr %147, align 4, !tbaa !11
  %149 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 11
  %150 = load i32, ptr %149, align 4, !tbaa !11
  %151 = xor i32 %148, %150
  %152 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 3
  store i32 %151, ptr %152, align 4, !tbaa !11
  %153 = load i32, ptr %25, align 4, !tbaa !11
  %154 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 11
  %155 = load i32, ptr %154, align 4, !tbaa !11
  %156 = xor i32 %153, %155
  %157 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 7
  %158 = load i32, ptr %157, align 4, !tbaa !11
  %159 = xor i32 %158, %156
  store i32 %159, ptr %157, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #4
  br label %160

160:                                              ; preds = %99
  br label %161

161:                                              ; preds = %160
  br label %162

162:                                              ; preds = %161
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #4
  %163 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  store ptr %163, ptr %26, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #4
  %164 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %164, ptr %27, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #4
  store i32 32, ptr %28, align 4, !tbaa !11
  br label %165

165:                                              ; preds = %168, %162
  %166 = load i32, ptr %28, align 4, !tbaa !11
  %167 = icmp ugt i32 %166, 0
  br i1 %167, label %168, label %181

168:                                              ; preds = %165
  %169 = load ptr, ptr %27, align 8, !tbaa !5
  %170 = getelementptr inbounds i8, ptr %169, i32 1
  store ptr %170, ptr %27, align 8, !tbaa !5
  %171 = load i8, ptr %169, align 1, !tbaa !13
  %172 = zext i8 %171 to i32
  %173 = load ptr, ptr %26, align 8, !tbaa !5
  %174 = getelementptr inbounds i8, ptr %173, i32 1
  store ptr %174, ptr %26, align 8, !tbaa !5
  %175 = load i8, ptr %173, align 1, !tbaa !13
  %176 = zext i8 %175 to i32
  %177 = xor i32 %176, %172
  %178 = trunc i32 %177 to i8
  store i8 %178, ptr %173, align 1, !tbaa !13
  %179 = load i32, ptr %28, align 4, !tbaa !11
  %180 = add i32 %179, -1
  store i32 %180, ptr %28, align 4, !tbaa !11
  br label %165, !llvm.loop !16

181:                                              ; preds = %165
  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 %182

182:                                              ; preds = %181
  br label %183

183:                                              ; preds = %182
  %184 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  call void @sparkle_384(ptr noundef %184, i32 noundef 7)
  %185 = load ptr, ptr %10, align 8, !tbaa !5
  %186 = getelementptr inbounds [32 x i8], ptr %20, i64 0, i64 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %185, ptr align 16 %186, i64 32, i1 false)
  %187 = load ptr, ptr %10, align 8, !tbaa !5
  %188 = getelementptr inbounds i8, ptr %187, i64 32
  store ptr %188, ptr %10, align 8, !tbaa !5
  %189 = load ptr, ptr %12, align 8, !tbaa !5
  %190 = getelementptr inbounds i8, ptr %189, i64 32
  store ptr %190, ptr %12, align 8, !tbaa !5
  %191 = load i64, ptr %13, align 8, !tbaa !9
  %192 = sub i64 %191, 32
  store i64 %192, ptr %13, align 8, !tbaa !9
  br label %70, !llvm.loop !17

193:                                              ; preds = %70
  %194 = load i64, ptr %13, align 8, !tbaa !9
  %195 = icmp eq i64 %194, 32
  br i1 %195, label %196, label %312

196:                                              ; preds = %193
  br label %197

197:                                              ; preds = %196
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #4
  %198 = getelementptr inbounds [32 x i8], ptr %20, i64 0, i64 0
  store ptr %198, ptr %29, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #4
  %199 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  store ptr %199, ptr %30, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #4
  %200 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %200, ptr %31, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #4
  store i32 32, ptr %32, align 4, !tbaa !11
  br label %201

201:                                              ; preds = %204, %197
  %202 = load i32, ptr %32, align 4, !tbaa !11
  %203 = icmp ugt i32 %202, 0
  br i1 %203, label %204, label %219

204:                                              ; preds = %201
  %205 = load ptr, ptr %30, align 8, !tbaa !5
  %206 = getelementptr inbounds i8, ptr %205, i32 1
  store ptr %206, ptr %30, align 8, !tbaa !5
  %207 = load i8, ptr %205, align 1, !tbaa !13
  %208 = zext i8 %207 to i32
  %209 = load ptr, ptr %31, align 8, !tbaa !5
  %210 = getelementptr inbounds i8, ptr %209, i32 1
  store ptr %210, ptr %31, align 8, !tbaa !5
  %211 = load i8, ptr %209, align 1, !tbaa !13
  %212 = zext i8 %211 to i32
  %213 = xor i32 %208, %212
  %214 = trunc i32 %213 to i8
  %215 = load ptr, ptr %29, align 8, !tbaa !5
  %216 = getelementptr inbounds i8, ptr %215, i32 1
  store ptr %216, ptr %29, align 8, !tbaa !5
  store i8 %214, ptr %215, align 1, !tbaa !13
  %217 = load i32, ptr %32, align 4, !tbaa !11
  %218 = add i32 %217, -1
  store i32 %218, ptr %32, align 4, !tbaa !11
  br label %201, !llvm.loop !18

219:                                              ; preds = %201
  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 %220

220:                                              ; preds = %219
  br label %221

221:                                              ; preds = %220
  %222 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 11
  %223 = load i32, ptr %222, align 4, !tbaa !11
  %224 = xor i32 %223, 117440512
  store i32 %224, ptr %222, align 4, !tbaa !11
  br label %225

225:                                              ; preds = %221
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #4
  %226 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  %227 = load i32, ptr %226, align 16, !tbaa !11
  store i32 %227, ptr %33, align 4, !tbaa !11
  %228 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 4
  %229 = load i32, ptr %228, align 16, !tbaa !11
  %230 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 8
  %231 = load i32, ptr %230, align 16, !tbaa !11
  %232 = xor i32 %229, %231
  %233 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  store i32 %232, ptr %233, align 16, !tbaa !11
  %234 = load i32, ptr %33, align 4, !tbaa !11
  %235 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 8
  %236 = load i32, ptr %235, align 16, !tbaa !11
  %237 = xor i32 %234, %236
  %238 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 4
  %239 = load i32, ptr %238, align 16, !tbaa !11
  %240 = xor i32 %239, %237
  store i32 %240, ptr %238, align 16, !tbaa !11
  %241 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 1
  %242 = load i32, ptr %241, align 4, !tbaa !11
  store i32 %242, ptr %33, align 4, !tbaa !11
  %243 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 5
  %244 = load i32, ptr %243, align 4, !tbaa !11
  %245 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 9
  %246 = load i32, ptr %245, align 4, !tbaa !11
  %247 = xor i32 %244, %246
  %248 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 1
  store i32 %247, ptr %248, align 4, !tbaa !11
  %249 = load i32, ptr %33, align 4, !tbaa !11
  %250 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 9
  %251 = load i32, ptr %250, align 4, !tbaa !11
  %252 = xor i32 %249, %251
  %253 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 5
  %254 = load i32, ptr %253, align 4, !tbaa !11
  %255 = xor i32 %254, %252
  store i32 %255, ptr %253, align 4, !tbaa !11
  %256 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 2
  %257 = load i32, ptr %256, align 8, !tbaa !11
  store i32 %257, ptr %33, align 4, !tbaa !11
  %258 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 6
  %259 = load i32, ptr %258, align 8, !tbaa !11
  %260 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 10
  %261 = load i32, ptr %260, align 8, !tbaa !11
  %262 = xor i32 %259, %261
  %263 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 2
  store i32 %262, ptr %263, align 8, !tbaa !11
  %264 = load i32, ptr %33, align 4, !tbaa !11
  %265 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 10
  %266 = load i32, ptr %265, align 8, !tbaa !11
  %267 = xor i32 %264, %266
  %268 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 6
  %269 = load i32, ptr %268, align 8, !tbaa !11
  %270 = xor i32 %269, %267
  store i32 %270, ptr %268, align 8, !tbaa !11
  %271 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 3
  %272 = load i32, ptr %271, align 4, !tbaa !11
  store i32 %272, ptr %33, align 4, !tbaa !11
  %273 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 7
  %274 = load i32, ptr %273, align 4, !tbaa !11
  %275 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 11
  %276 = load i32, ptr %275, align 4, !tbaa !11
  %277 = xor i32 %274, %276
  %278 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 3
  store i32 %277, ptr %278, align 4, !tbaa !11
  %279 = load i32, ptr %33, align 4, !tbaa !11
  %280 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 11
  %281 = load i32, ptr %280, align 4, !tbaa !11
  %282 = xor i32 %279, %281
  %283 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 7
  %284 = load i32, ptr %283, align 4, !tbaa !11
  %285 = xor i32 %284, %282
  store i32 %285, ptr %283, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #4
  br label %286

286:                                              ; preds = %225
  br label %287

287:                                              ; preds = %286
  br label %288

288:                                              ; preds = %287
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #4
  %289 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  store ptr %289, ptr %34, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #4
  %290 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %290, ptr %35, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #4
  store i32 32, ptr %36, align 4, !tbaa !11
  br label %291

291:                                              ; preds = %294, %288
  %292 = load i32, ptr %36, align 4, !tbaa !11
  %293 = icmp ugt i32 %292, 0
  br i1 %293, label %294, label %307

294:                                              ; preds = %291
  %295 = load ptr, ptr %35, align 8, !tbaa !5
  %296 = getelementptr inbounds i8, ptr %295, i32 1
  store ptr %296, ptr %35, align 8, !tbaa !5
  %297 = load i8, ptr %295, align 1, !tbaa !13
  %298 = zext i8 %297 to i32
  %299 = load ptr, ptr %34, align 8, !tbaa !5
  %300 = getelementptr inbounds i8, ptr %299, i32 1
  store ptr %300, ptr %34, align 8, !tbaa !5
  %301 = load i8, ptr %299, align 1, !tbaa !13
  %302 = zext i8 %301 to i32
  %303 = xor i32 %302, %298
  %304 = trunc i32 %303 to i8
  store i8 %304, ptr %299, align 1, !tbaa !13
  %305 = load i32, ptr %36, align 4, !tbaa !11
  %306 = add i32 %305, -1
  store i32 %306, ptr %36, align 4, !tbaa !11
  br label %291, !llvm.loop !19

307:                                              ; preds = %291
  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 %308

308:                                              ; preds = %307
  br label %309

309:                                              ; preds = %308
  %310 = load ptr, ptr %10, align 8, !tbaa !5
  %311 = getelementptr inbounds [32 x i8], ptr %20, i64 0, i64 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %310, ptr align 16 %311, i64 32, i1 false)
  br label %442

312:                                              ; preds = %193
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #4
  %313 = load i64, ptr %13, align 8, !tbaa !9
  %314 = trunc i64 %313 to i32
  store i32 %314, ptr %37, align 4, !tbaa !11
  br label %315

315:                                              ; preds = %312
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #4
  %316 = getelementptr inbounds [32 x i8], ptr %20, i64 0, i64 0
  store ptr %316, ptr %38, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #4
  %317 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  store ptr %317, ptr %39, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #4
  %318 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %318, ptr %40, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #4
  %319 = load i32, ptr %37, align 4, !tbaa !11
  store i32 %319, ptr %41, align 4, !tbaa !11
  br label %320

320:                                              ; preds = %323, %315
  %321 = load i32, ptr %41, align 4, !tbaa !11
  %322 = icmp ugt i32 %321, 0
  br i1 %322, label %323, label %338

323:                                              ; preds = %320
  %324 = load ptr, ptr %39, align 8, !tbaa !5
  %325 = getelementptr inbounds i8, ptr %324, i32 1
  store ptr %325, ptr %39, align 8, !tbaa !5
  %326 = load i8, ptr %324, align 1, !tbaa !13
  %327 = zext i8 %326 to i32
  %328 = load ptr, ptr %40, align 8, !tbaa !5
  %329 = getelementptr inbounds i8, ptr %328, i32 1
  store ptr %329, ptr %40, align 8, !tbaa !5
  %330 = load i8, ptr %328, align 1, !tbaa !13
  %331 = zext i8 %330 to i32
  %332 = xor i32 %327, %331
  %333 = trunc i32 %332 to i8
  %334 = load ptr, ptr %38, align 8, !tbaa !5
  %335 = getelementptr inbounds i8, ptr %334, i32 1
  store ptr %335, ptr %38, align 8, !tbaa !5
  store i8 %333, ptr %334, align 1, !tbaa !13
  %336 = load i32, ptr %41, align 4, !tbaa !11
  %337 = add i32 %336, -1
  store i32 %337, ptr %41, align 4, !tbaa !11
  br label %320, !llvm.loop !20

338:                                              ; preds = %320
  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 %339

339:                                              ; preds = %338
  br label %340

340:                                              ; preds = %339
  %341 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 11
  %342 = load i32, ptr %341, align 4, !tbaa !11
  %343 = xor i32 %342, 100663296
  store i32 %343, ptr %341, align 4, !tbaa !11
  br label %344

344:                                              ; preds = %340
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #4
  %345 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  %346 = load i32, ptr %345, align 16, !tbaa !11
  store i32 %346, ptr %42, align 4, !tbaa !11
  %347 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 4
  %348 = load i32, ptr %347, align 16, !tbaa !11
  %349 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 8
  %350 = load i32, ptr %349, align 16, !tbaa !11
  %351 = xor i32 %348, %350
  %352 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  store i32 %351, ptr %352, align 16, !tbaa !11
  %353 = load i32, ptr %42, align 4, !tbaa !11
  %354 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 8
  %355 = load i32, ptr %354, align 16, !tbaa !11
  %356 = xor i32 %353, %355
  %357 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 4
  %358 = load i32, ptr %357, align 16, !tbaa !11
  %359 = xor i32 %358, %356
  store i32 %359, ptr %357, align 16, !tbaa !11
  %360 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 1
  %361 = load i32, ptr %360, align 4, !tbaa !11
  store i32 %361, ptr %42, align 4, !tbaa !11
  %362 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 5
  %363 = load i32, ptr %362, align 4, !tbaa !11
  %364 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 9
  %365 = load i32, ptr %364, align 4, !tbaa !11
  %366 = xor i32 %363, %365
  %367 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 1
  store i32 %366, ptr %367, align 4, !tbaa !11
  %368 = load i32, ptr %42, align 4, !tbaa !11
  %369 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 9
  %370 = load i32, ptr %369, align 4, !tbaa !11
  %371 = xor i32 %368, %370
  %372 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 5
  %373 = load i32, ptr %372, align 4, !tbaa !11
  %374 = xor i32 %373, %371
  store i32 %374, ptr %372, align 4, !tbaa !11
  %375 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 2
  %376 = load i32, ptr %375, align 8, !tbaa !11
  store i32 %376, ptr %42, align 4, !tbaa !11
  %377 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 6
  %378 = load i32, ptr %377, align 8, !tbaa !11
  %379 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 10
  %380 = load i32, ptr %379, align 8, !tbaa !11
  %381 = xor i32 %378, %380
  %382 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 2
  store i32 %381, ptr %382, align 8, !tbaa !11
  %383 = load i32, ptr %42, align 4, !tbaa !11
  %384 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 10
  %385 = load i32, ptr %384, align 8, !tbaa !11
  %386 = xor i32 %383, %385
  %387 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 6
  %388 = load i32, ptr %387, align 8, !tbaa !11
  %389 = xor i32 %388, %386
  store i32 %389, ptr %387, align 8, !tbaa !11
  %390 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 3
  %391 = load i32, ptr %390, align 4, !tbaa !11
  store i32 %391, ptr %42, align 4, !tbaa !11
  %392 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 7
  %393 = load i32, ptr %392, align 4, !tbaa !11
  %394 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 11
  %395 = load i32, ptr %394, align 4, !tbaa !11
  %396 = xor i32 %393, %395
  %397 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 3
  store i32 %396, ptr %397, align 4, !tbaa !11
  %398 = load i32, ptr %42, align 4, !tbaa !11
  %399 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 11
  %400 = load i32, ptr %399, align 4, !tbaa !11
  %401 = xor i32 %398, %400
  %402 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 7
  %403 = load i32, ptr %402, align 4, !tbaa !11
  %404 = xor i32 %403, %401
  store i32 %404, ptr %402, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #4
  br label %405

405:                                              ; preds = %344
  br label %406

406:                                              ; preds = %405
  br label %407

407:                                              ; preds = %406
  call void @llvm.lifetime.start.p0(i64 8, ptr %43) #4
  %408 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  store ptr %408, ptr %43, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #4
  %409 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %409, ptr %44, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %45) #4
  %410 = load i32, ptr %37, align 4, !tbaa !11
  store i32 %410, ptr %45, align 4, !tbaa !11
  br label %411

411:                                              ; preds = %414, %407
  %412 = load i32, ptr %45, align 4, !tbaa !11
  %413 = icmp ugt i32 %412, 0
  br i1 %413, label %414, label %427

414:                                              ; preds = %411
  %415 = load ptr, ptr %44, align 8, !tbaa !5
  %416 = getelementptr inbounds i8, ptr %415, i32 1
  store ptr %416, ptr %44, align 8, !tbaa !5
  %417 = load i8, ptr %415, align 1, !tbaa !13
  %418 = zext i8 %417 to i32
  %419 = load ptr, ptr %43, align 8, !tbaa !5
  %420 = getelementptr inbounds i8, ptr %419, i32 1
  store ptr %420, ptr %43, align 8, !tbaa !5
  %421 = load i8, ptr %419, align 1, !tbaa !13
  %422 = zext i8 %421 to i32
  %423 = xor i32 %422, %418
  %424 = trunc i32 %423 to i8
  store i8 %424, ptr %419, align 1, !tbaa !13
  %425 = load i32, ptr %45, align 4, !tbaa !11
  %426 = add i32 %425, -1
  store i32 %426, ptr %45, align 4, !tbaa !11
  br label %411, !llvm.loop !21

427:                                              ; preds = %411
  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 %428

428:                                              ; preds = %427
  br label %429

429:                                              ; preds = %428
  %430 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  %431 = load i32, ptr %37, align 4, !tbaa !11
  %432 = zext i32 %431 to i64
  %433 = getelementptr inbounds i8, ptr %430, i64 %432
  %434 = load i8, ptr %433, align 1, !tbaa !13
  %435 = zext i8 %434 to i32
  %436 = xor i32 %435, 128
  %437 = trunc i32 %436 to i8
  store i8 %437, ptr %433, align 1, !tbaa !13
  %438 = load ptr, ptr %10, align 8, !tbaa !5
  %439 = getelementptr inbounds [32 x i8], ptr %20, i64 0, i64 0
  %440 = load i32, ptr %37, align 4, !tbaa !11
  %441 = zext i32 %440 to i64
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %438, ptr align 16 %439, i64 %441, i1 false)
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #4
  br label %442

442:                                              ; preds = %429, %309
  %443 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  call void @sparkle_384(ptr noundef %443, i32 noundef 11)
  %444 = load i64, ptr %13, align 8, !tbaa !9
  %445 = load ptr, ptr %10, align 8, !tbaa !5
  %446 = getelementptr inbounds i8, ptr %445, i64 %444
  store ptr %446, ptr %10, align 8, !tbaa !5
  br label %447

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

448:                                              ; preds = %447
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #4
  %449 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %449, ptr %46, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #4
  %450 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  %451 = getelementptr inbounds i8, ptr %450, i64 32
  store ptr %451, ptr %47, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %48) #4
  %452 = load ptr, ptr %18, align 8, !tbaa !5
  store ptr %452, 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 %453

453:                                              ; preds = %456, %448
  %454 = load i32, ptr %49, align 4, !tbaa !11
  %455 = icmp ugt i32 %454, 0
  br i1 %455, label %456, label %471

456:                                              ; preds = %453
  %457 = load ptr, ptr %47, align 8, !tbaa !5
  %458 = getelementptr inbounds i8, ptr %457, i32 1
  store ptr %458, ptr %47, align 8, !tbaa !5
  %459 = load i8, ptr %457, align 1, !tbaa !13
  %460 = zext i8 %459 to i32
  %461 = load ptr, ptr %48, align 8, !tbaa !5
  %462 = getelementptr inbounds i8, ptr %461, i32 1
  store ptr %462, ptr %48, align 8, !tbaa !5
  %463 = load i8, ptr %461, align 1, !tbaa !13
  %464 = zext i8 %463 to i32
  %465 = xor i32 %460, %464
  %466 = trunc i32 %465 to i8
  %467 = load ptr, ptr %46, align 8, !tbaa !5
  %468 = getelementptr inbounds i8, ptr %467, i32 1
  store ptr %468, ptr %46, align 8, !tbaa !5
  store i8 %466, ptr %467, align 1, !tbaa !13
  %469 = load i32, ptr %49, align 4, !tbaa !11
  %470 = add i32 %469, -1
  store i32 %470, ptr %49, align 4, !tbaa !11
  br label %453, !llvm.loop !22

471:                                              ; preds = %453
  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 %472

472:                                              ; preds = %471
  br label %473

473:                                              ; preds = %472
  call void @llvm.lifetime.end.p0(i64 32, ptr %20) #4
  call void @llvm.lifetime.end.p0(i64 48, 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

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

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

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #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 = { 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_256_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 [12 x i32], align 16
  %11 = ptrtoint ptr %10 to i64
  %12 = alloca [32 x i8], align 16
  %13 = ptrtoint ptr %12 to i64
  call void @llvm.lifetime.start.p0(i64 48, ptr nonnull %10) #4
  call void @llvm.lifetime.start.p0(i64 32, 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(32) %10, ptr noundef nonnull align 1 dereferenceable(32) %7, i64 32, i1 false)
  %15 = getelementptr inbounds i8, ptr %10, i64 32
  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_384(ptr noundef nonnull %10, i32 noundef 11) #4
  %.not = icmp eq i64 %5, 0
  br i1 %.not, label %17, label %16

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

17:                                               ; preds = %16, %9
  %.not104 = icmp eq i64 %3, 0
  br i1 %.not104, label %256, label %.preheader113

.preheader113:                                    ; preds = %17
  %18 = icmp ugt i64 %3, 32
  br i1 %18, label %.preheader112.lr.ph, label %._crit_edge

.preheader112.lr.ph:                              ; preds = %.preheader113
  %19 = getelementptr inbounds i8, ptr %10, i64 16
  %20 = getelementptr inbounds i8, ptr %10, i64 4
  %21 = getelementptr inbounds i8, ptr %10, i64 12
  %22 = getelementptr inbounds i8, ptr %10, i64 7
  %23 = getelementptr inbounds i8, ptr %10, i64 15
  %24 = getelementptr inbounds i8, ptr %10, i64 16
  %25 = getelementptr inbounds i8, ptr %12, i64 16
  br label %.preheader112

.preheader112:                                    ; preds = %.preheader112.lr.ph, %.preheader112
  %.081123 = phi ptr [ %0, %.preheader112.lr.ph ], [ %69, %.preheader112 ]
  %.086122 = phi ptr [ %2, %.preheader112.lr.ph ], [ %70, %.preheader112 ]
  %.090121 = phi i64 [ %3, %.preheader112.lr.ph ], [ %71, %.preheader112 ]
  %26 = getelementptr inbounds i8, ptr %.086122, i64 16
  %27 = load <16 x i8>, ptr %10, align 16, !tbaa !9
  %28 = load <16 x i8>, ptr %.086122, align 1, !tbaa !9
  %29 = xor <16 x i8> %28, %27
  store <16 x i8> %29, ptr %12, align 16, !tbaa !9
  %30 = load <16 x i8>, ptr %24, align 16, !tbaa !9
  %31 = load <16 x i8>, ptr %26, align 1, !tbaa !9
  %32 = xor <16 x i8> %31, %30
  store <16 x i8> %32, ptr %25, align 16, !tbaa !9
  %.cast240 = bitcast <16 x i8> %30 to <4 x i32>
  %33 = load <4 x i32>, ptr %15, align 16, !tbaa !10
  %34 = load <4 x i32>, ptr %10, align 16, !tbaa !10
  %35 = xor <4 x i32> %33, %.cast240
  %36 = shufflevector <4 x i32> %35, <4 x i32> poison, <2 x i32> <i32 1, i32 2>
  store <2 x i32> %36, ptr %20, align 4, !tbaa !10
  %37 = xor <4 x i32> %33, %.cast240
  %38 = extractelement <4 x i32> %37, i64 3
  store i32 %38, ptr %21, align 4, !tbaa !10
  %39 = xor <4 x i32> %34, %.cast240
  %40 = xor <4 x i32> %39, %33
  store <4 x i32> %40, ptr %19, align 16, !tbaa !10
  %41 = xor <4 x i32> %33, %.cast240
  %42 = extractelement <4 x i32> %41, i64 0
  %43 = lshr i32 %42, 8
  %44 = lshr i32 %42, 16
  %45 = lshr i32 %42, 24
  %46 = insertelement <4 x i32> %41, i32 %43, i64 1
  %47 = insertelement <4 x i32> %46, i32 %44, i64 2
  %48 = insertelement <4 x i32> %47, i32 %45, i64 3
  %49 = trunc <4 x i32> %48 to <4 x i8>
  %50 = extractelement <4 x i32> %35, i64 1
  %51 = trunc i32 %50 to i8
  %52 = lshr i32 %50, 8
  %53 = trunc i32 %52 to i8
  %54 = lshr i32 %50, 16
  %55 = trunc i32 %54 to i8
  %56 = load <16 x i8>, ptr %22, align 1
  %57 = load i8, ptr %23, align 1, !tbaa !9
  %58 = load <16 x i8>, ptr %.086122, align 1, !tbaa !9
  %59 = shufflevector <4 x i8> %49, <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>
  %60 = insertelement <16 x i8> %59, i8 %51, i64 4
  %61 = insertelement <16 x i8> %60, i8 %53, i64 5
  %62 = insertelement <16 x i8> %61, i8 %55, i64 6
  %63 = shufflevector <16 x i8> %62, <16 x i8> %56, <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 20, i32 21, i32 22, i32 23, i32 poison>
  %64 = insertelement <16 x i8> %63, i8 %57, i64 15
  %65 = xor <16 x i8> %58, %64
  store <16 x i8> %65, ptr %10, align 16, !tbaa !9
  %66 = load <16 x i8>, ptr %26, align 1, !tbaa !9
  %67 = load <16 x i8>, ptr %24, align 16, !tbaa !9
  %68 = xor <16 x i8> %67, %66
  store <16 x i8> %68, ptr %24, align 16, !tbaa !9
  call void @sparkle_384(ptr noundef nonnull %10, i32 noundef 7) #4
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(32) %.081123, ptr noundef nonnull align 16 dereferenceable(32) %12, i64 32, i1 false)
  %69 = getelementptr inbounds i8, ptr %.081123, i64 32
  %70 = getelementptr inbounds i8, ptr %.086122, i64 32
  %71 = add i64 %.090121, -32
  %72 = icmp ugt i64 %71, 32
  br i1 %72, label %.preheader112, label %._crit_edge, !llvm.loop !12

._crit_edge:                                      ; preds = %.preheader112, %.preheader113
  %.090.lcssa = phi i64 [ %3, %.preheader113 ], [ %71, %.preheader112 ]
  %.086.lcssa = phi ptr [ %2, %.preheader113 ], [ %70, %.preheader112 ]
  %.081.lcssa = phi ptr [ %0, %.preheader113 ], [ %69, %.preheader112 ]
  %.086.lcssa157 = ptrtoint ptr %.086.lcssa to i64
  %73 = icmp eq i64 %.090.lcssa, 32
  br i1 %73, label %.preheader.preheader, label %iter.check

.preheader.preheader:                             ; preds = %._crit_edge
  %74 = getelementptr inbounds i8, ptr %10, i64 7
  %75 = getelementptr inbounds i8, ptr %10, i64 15
  %76 = getelementptr inbounds i8, ptr %10, i64 16
  %77 = getelementptr inbounds i8, ptr %.086.lcssa, i64 16
  %78 = getelementptr inbounds i8, ptr %12, i64 16
  %79 = load <16 x i8>, ptr %10, align 16, !tbaa !9
  %80 = load <16 x i8>, ptr %.086.lcssa, align 1, !tbaa !9
  %81 = xor <16 x i8> %80, %79
  store <16 x i8> %81, ptr %12, align 16, !tbaa !9
  %82 = load <16 x i8>, ptr %76, align 16, !tbaa !9
  %83 = load <16 x i8>, ptr %77, align 1, !tbaa !9
  %84 = xor <16 x i8> %83, %82
  store <16 x i8> %84, ptr %78, align 16, !tbaa !9
  %85 = getelementptr inbounds i8, ptr %10, i64 44
  %86 = load i32, ptr %85, align 4, !tbaa !10
  %87 = xor i32 %86, 117440512
  store i32 %87, ptr %85, align 4, !tbaa !10
  %88 = getelementptr inbounds i8, ptr %10, i64 16
  %89 = getelementptr inbounds i8, ptr %10, i64 8
  %90 = getelementptr inbounds i8, ptr %10, i64 24
  %91 = load i32, ptr %90, align 8, !tbaa !10
  %92 = getelementptr inbounds i8, ptr %10, i64 12
  %93 = getelementptr inbounds i8, ptr %10, i64 28
  %94 = load <4 x i32>, ptr %93, align 4, !tbaa !10
  %95 = shufflevector <4 x i32> %94, <4 x i32> poison, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
  %96 = load <4 x i32>, ptr %10, align 16, !tbaa !10
  %97 = load <2 x i32>, ptr %88, align 16, !tbaa !10
  %98 = shufflevector <4 x i32> %95, <4 x i32> poison, <2 x i32> <i32 0, i32 1>
  %99 = xor <2 x i32> %98, %97
  store <2 x i32> %99, ptr %10, align 16, !tbaa !10
  %100 = extractelement <4 x i32> %94, i64 3
  %101 = xor i32 %100, %91
  store i32 %101, ptr %89, align 8, !tbaa !10
  %102 = extractelement <4 x i32> %94, i64 0
  %103 = xor i32 %102, %87
  store i32 %103, ptr %92, align 4, !tbaa !10
  %104 = shufflevector <2 x i32> %97, <2 x i32> poison, <4 x i32> <i32 0, i32 1, i32 poison, i32 poison>
  %105 = insertelement <4 x i32> %104, i32 %91, i64 2
  %106 = insertelement <4 x i32> %105, i32 %87, i64 3
  %107 = xor <4 x i32> %106, %96
  %108 = xor <4 x i32> %107, %95
  store <4 x i32> %108, ptr %88, align 16, !tbaa !10
  %109 = extractelement <2 x i32> %99, i64 0
  %110 = lshr i32 %109, 8
  %111 = lshr i32 %109, 16
  %112 = lshr i32 %109, 24
  %113 = shufflevector <2 x i32> %99, <2 x i32> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
  %114 = insertelement <4 x i32> %113, i32 %110, i64 1
  %115 = insertelement <4 x i32> %114, i32 %111, i64 2
  %116 = insertelement <4 x i32> %115, i32 %112, i64 3
  %117 = trunc <4 x i32> %116 to <4 x i8>
  %118 = extractelement <2 x i32> %99, i64 1
  %119 = trunc i32 %118 to i8
  %120 = lshr i32 %118, 8
  %121 = trunc i32 %120 to i8
  %122 = lshr i32 %118, 16
  %123 = trunc i32 %122 to i8
  %124 = load <16 x i8>, ptr %74, align 1
  %125 = load i8, ptr %75, align 1, !tbaa !9
  %126 = load <16 x i8>, ptr %.086.lcssa, align 1, !tbaa !9
  %127 = shufflevector <4 x i8> %117, <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>
  %128 = insertelement <16 x i8> %127, i8 %119, i64 4
  %129 = insertelement <16 x i8> %128, i8 %121, i64 5
  %130 = insertelement <16 x i8> %129, i8 %123, i64 6
  %131 = shufflevector <16 x i8> %130, <16 x i8> %124, <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 20, i32 21, i32 22, i32 23, i32 poison>
  %132 = insertelement <16 x i8> %131, i8 %125, i64 15
  %133 = xor <16 x i8> %126, %132
  store <16 x i8> %133, ptr %10, align 16, !tbaa !9
  %134 = load <16 x i8>, ptr %77, align 1, !tbaa !9
  %135 = load <16 x i8>, ptr %76, align 16, !tbaa !9
  %136 = xor <16 x i8> %135, %134
  store <16 x i8> %136, ptr %76, align 16, !tbaa !9
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(32) %.081.lcssa, ptr noundef nonnull align 16 dereferenceable(32) %12, i64 32, i1 false)
  br label %254

iter.check:                                       ; preds = %._crit_edge
  %137 = trunc nuw i64 %.090.lcssa to i32
  %138 = add nuw nsw i64 %.090.lcssa, 4294967295
  %139 = and i64 %138, 4294967295
  %140 = add nuw nsw i64 %139, 1
  %min.iters.check = icmp ult i64 %139, 7
  br i1 %min.iters.check, label %.lr.ph.preheader, label %vector.memcheck

vector.memcheck:                                  ; preds = %iter.check
  %141 = sub i64 %13, %11
  %diff.check = icmp ult i64 %141, 32
  %142 = sub i64 %13, %.086.lcssa157
  %diff.check158 = icmp ult i64 %142, 32
  %conflict.rdx = or i1 %diff.check, %diff.check158
  br i1 %conflict.rdx, label %.lr.ph.preheader, label %vector.main.loop.iter.check

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

vector.ph:                                        ; preds = %vector.main.loop.iter.check
  %n.vec = and i64 %140, 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 %.086.lcssa, i64 %index
  %next.gep161 = getelementptr i8, ptr %10, i64 %index
  %next.gep163 = getelementptr i8, ptr %12, i64 %index
  %143 = getelementptr i8, ptr %next.gep161, i64 16
  %wide.load = load <16 x i8>, ptr %next.gep161, align 16, !tbaa !9
  %wide.load165 = load <16 x i8>, ptr %143, align 16, !tbaa !9
  %144 = getelementptr i8, ptr %next.gep, i64 16
  %wide.load166 = load <16 x i8>, ptr %next.gep, align 1, !tbaa !9
  %wide.load167 = load <16 x i8>, ptr %144, align 1, !tbaa !9
  %145 = xor <16 x i8> %wide.load166, %wide.load
  %146 = xor <16 x i8> %wide.load167, %wide.load165
  %147 = getelementptr i8, ptr %next.gep163, i64 16
  store <16 x i8> %145, ptr %next.gep163, align 16, !tbaa !9
  store <16 x i8> %146, ptr %147, align 16, !tbaa !9
  %index.next = add nuw i64 %index, 32
  %148 = icmp eq i64 %index.next, %n.vec
  br i1 %148, label %middle.block, label %vector.body, !llvm.loop !14

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

vec.epilog.iter.check:                            ; preds = %middle.block
  %ind.end179 = getelementptr i8, ptr %12, i64 %n.vec
  %ind.end176 = getelementptr i8, ptr %10, i64 %n.vec
  %ind.end173 = getelementptr i8, ptr %.086.lcssa, i64 %n.vec
  %.cast170 = trunc i64 %n.vec to i32
  %ind.end171 = sub i32 %137, %.cast170
  %n.vec.remaining = and i64 %140, 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.vec169 = and i64 %140, 8589934584
  %.cast = trunc i64 %n.vec169 to i32
  %ind.end = sub i32 %137, %.cast
  %ind.end172 = getelementptr i8, ptr %.086.lcssa, i64 %n.vec169
  %ind.end175 = getelementptr i8, ptr %10, i64 %n.vec169
  %ind.end178 = getelementptr i8, ptr %12, i64 %n.vec169
  br label %vec.epilog.vector.body

vec.epilog.vector.body:                           ; preds = %vec.epilog.vector.body, %vec.epilog.ph
  %index181 = phi i64 [ %vec.epilog.resume.val, %vec.epilog.ph ], [ %index.next187, %vec.epilog.vector.body ]
  %next.gep182 = getelementptr i8, ptr %.086.lcssa, i64 %index181
  %next.gep183 = getelementptr i8, ptr %10, i64 %index181
  %next.gep184 = getelementptr i8, ptr %12, i64 %index181
  %wide.load185 = load <8 x i8>, ptr %next.gep183, align 8, !tbaa !9
  %wide.load186 = load <8 x i8>, ptr %next.gep182, align 1, !tbaa !9
  %149 = xor <8 x i8> %wide.load186, %wide.load185
  store <8 x i8> %149, ptr %next.gep184, align 8, !tbaa !9
  %index.next187 = add nuw i64 %index181, 8
  %150 = icmp eq i64 %index.next187, %n.vec169
  br i1 %150, label %vec.epilog.middle.block, label %vec.epilog.vector.body, !llvm.loop !17

vec.epilog.middle.block:                          ; preds = %vec.epilog.vector.body
  %cmp.n188 = icmp eq i64 %140, %n.vec169
  br i1 %cmp.n188, label %iter.check194, label %.lr.ph.preheader

.lr.ph.preheader:                                 ; preds = %vec.epilog.middle.block, %vector.memcheck, %iter.check, %vec.epilog.iter.check
  %.082130.ph = phi i32 [ %137, %iter.check ], [ %137, %vector.memcheck ], [ %ind.end171, %vec.epilog.iter.check ], [ %ind.end, %vec.epilog.middle.block ]
  %.083129.ph = phi ptr [ %.086.lcssa, %iter.check ], [ %.086.lcssa, %vector.memcheck ], [ %ind.end173, %vec.epilog.iter.check ], [ %ind.end172, %vec.epilog.middle.block ]
  %.084128.ph = phi ptr [ %10, %iter.check ], [ %10, %vector.memcheck ], [ %ind.end176, %vec.epilog.iter.check ], [ %ind.end175, %vec.epilog.middle.block ]
  %.085127.ph = phi ptr [ %12, %iter.check ], [ %12, %vector.memcheck ], [ %ind.end179, %vec.epilog.iter.check ], [ %ind.end178, %vec.epilog.middle.block ]
  %151 = add nsw i32 %.082130.ph, -1
  %xtraiter = and i32 %.082130.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
  %.082130.prol = phi i32 [ %158, %.lr.ph.prol ], [ %.082130.ph, %.lr.ph.preheader ]
  %.083129.prol = phi ptr [ %154, %.lr.ph.prol ], [ %.083129.ph, %.lr.ph.preheader ]
  %.084128.prol = phi ptr [ %152, %.lr.ph.prol ], [ %.084128.ph, %.lr.ph.preheader ]
  %.085127.prol = phi ptr [ %157, %.lr.ph.prol ], [ %.085127.ph, %.lr.ph.preheader ]
  %prol.iter = phi i32 [ %prol.iter.next, %.lr.ph.prol ], [ 0, %.lr.ph.preheader ]
  %152 = getelementptr inbounds i8, ptr %.084128.prol, i64 1
  %153 = load i8, ptr %.084128.prol, align 1, !tbaa !9
  %154 = getelementptr inbounds i8, ptr %.083129.prol, i64 1
  %155 = load i8, ptr %.083129.prol, align 1, !tbaa !9
  %156 = xor i8 %155, %153
  %157 = getelementptr inbounds i8, ptr %.085127.prol, i64 1
  store i8 %156, ptr %.085127.prol, align 1, !tbaa !9
  %158 = add nsw i32 %.082130.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
  %.082130.unr = phi i32 [ %.082130.ph, %.lr.ph.preheader ], [ %158, %.lr.ph.prol ]
  %.083129.unr = phi ptr [ %.083129.ph, %.lr.ph.preheader ], [ %154, %.lr.ph.prol ]
  %.084128.unr = phi ptr [ %.084128.ph, %.lr.ph.preheader ], [ %152, %.lr.ph.prol ]
  %.085127.unr = phi ptr [ %.085127.ph, %.lr.ph.preheader ], [ %157, %.lr.ph.prol ]
  %159 = icmp ult i32 %151, 3
  br i1 %159, label %iter.check194, label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.prol.loopexit, %.lr.ph
  %.082130 = phi i32 [ %184, %.lr.ph ], [ %.082130.unr, %.lr.ph.prol.loopexit ]
  %.083129 = phi ptr [ %180, %.lr.ph ], [ %.083129.unr, %.lr.ph.prol.loopexit ]
  %.084128 = phi ptr [ %178, %.lr.ph ], [ %.084128.unr, %.lr.ph.prol.loopexit ]
  %.085127 = phi ptr [ %183, %.lr.ph ], [ %.085127.unr, %.lr.ph.prol.loopexit ]
  %160 = getelementptr inbounds i8, ptr %.084128, i64 1
  %161 = load i8, ptr %.084128, align 1, !tbaa !9
  %162 = getelementptr inbounds i8, ptr %.083129, i64 1
  %163 = load i8, ptr %.083129, align 1, !tbaa !9
  %164 = xor i8 %163, %161
  %165 = getelementptr inbounds i8, ptr %.085127, i64 1
  store i8 %164, ptr %.085127, align 1, !tbaa !9
  %166 = getelementptr inbounds i8, ptr %.084128, i64 2
  %167 = load i8, ptr %160, align 1, !tbaa !9
  %168 = getelementptr inbounds i8, ptr %.083129, i64 2
  %169 = load i8, ptr %162, align 1, !tbaa !9
  %170 = xor i8 %169, %167
  %171 = getelementptr inbounds i8, ptr %.085127, i64 2
  store i8 %170, ptr %165, align 1, !tbaa !9
  %172 = getelementptr inbounds i8, ptr %.084128, i64 3
  %173 = load i8, ptr %166, align 1, !tbaa !9
  %174 = getelementptr inbounds i8, ptr %.083129, i64 3
  %175 = load i8, ptr %168, align 1, !tbaa !9
  %176 = xor i8 %175, %173
  %177 = getelementptr inbounds i8, ptr %.085127, i64 3
  store i8 %176, ptr %171, align 1, !tbaa !9
  %178 = getelementptr inbounds i8, ptr %.084128, i64 4
  %179 = load i8, ptr %172, align 1, !tbaa !9
  %180 = getelementptr inbounds i8, ptr %.083129, i64 4
  %181 = load i8, ptr %174, align 1, !tbaa !9
  %182 = xor i8 %181, %179
  %183 = getelementptr inbounds i8, ptr %.085127, i64 4
  store i8 %182, ptr %177, align 1, !tbaa !9
  %184 = add nsw i32 %.082130, -4
  %.not105.3 = icmp eq i32 %184, 0
  br i1 %.not105.3, label %iter.check194, label %.lr.ph, !llvm.loop !20

iter.check194:                                    ; preds = %.lr.ph.prol.loopexit, %.lr.ph, %vec.epilog.middle.block, %middle.block
  %185 = getelementptr inbounds i8, ptr %10, i64 44
  %186 = load i32, ptr %185, align 4, !tbaa !10
  %187 = xor i32 %186, 100663296
  store i32 %187, ptr %185, align 4, !tbaa !10
  %188 = getelementptr inbounds i8, ptr %10, i64 16
  %189 = getelementptr inbounds i8, ptr %10, i64 8
  %190 = getelementptr inbounds i8, ptr %10, i64 24
  %191 = load i32, ptr %190, align 8, !tbaa !10
  %192 = getelementptr inbounds i8, ptr %10, i64 12
  %193 = getelementptr inbounds i8, ptr %10, i64 28
  %194 = load <4 x i32>, ptr %193, align 4, !tbaa !10
  %195 = shufflevector <4 x i32> %194, <4 x i32> poison, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
  %196 = load <4 x i32>, ptr %10, align 16, !tbaa !10
  %197 = load <2 x i32>, ptr %188, align 16, !tbaa !10
  %198 = shufflevector <4 x i32> %195, <4 x i32> poison, <2 x i32> <i32 0, i32 1>
  %199 = xor <2 x i32> %198, %197
  store <2 x i32> %199, ptr %10, align 16, !tbaa !10
  %200 = extractelement <4 x i32> %194, i64 3
  %201 = xor i32 %200, %191
  store i32 %201, ptr %189, align 8, !tbaa !10
  %202 = extractelement <4 x i32> %194, i64 0
  %203 = xor i32 %202, %187
  store i32 %203, ptr %192, align 4, !tbaa !10
  %204 = shufflevector <2 x i32> %197, <2 x i32> poison, <4 x i32> <i32 0, i32 1, i32 poison, i32 poison>
  %205 = insertelement <4 x i32> %204, i32 %191, i64 2
  %206 = insertelement <4 x i32> %205, i32 %187, i64 3
  %207 = xor <4 x i32> %206, %196
  %208 = xor <4 x i32> %207, %195
  store <4 x i32> %208, ptr %188, align 16, !tbaa !10
  %209 = add nuw nsw i64 %.090.lcssa, 4294967295
  %210 = and i64 %209, 4294967295
  %211 = add nuw nsw i64 %210, 1
  %min.iters.check192 = icmp ult i64 %210, 7
  br i1 %min.iters.check192, label %.lr.ph138.preheader, label %vector.memcheck189

vector.memcheck189:                               ; preds = %iter.check194
  %212 = add nuw nsw i64 %.090.lcssa, 4294967295
  %213 = and i64 %212, 4294967295
  %214 = add nuw nsw i64 %213, 1
  %scevgep = getelementptr i8, ptr %10, i64 %214
  %scevgep190 = getelementptr i8, ptr %.086.lcssa, i64 %214
  %bound0 = icmp ult ptr %10, %scevgep190
  %bound1 = icmp ult ptr %.086.lcssa, %scevgep
  %found.conflict = and i1 %bound0, %bound1
  br i1 %found.conflict, label %.lr.ph138.preheader, label %vector.main.loop.iter.check196

vector.main.loop.iter.check196:                   ; preds = %vector.memcheck189
  %min.iters.check195 = icmp ult i64 %210, 31
  br i1 %min.iters.check195, label %vec.epilog.ph214, label %vector.ph197

vector.ph197:                                     ; preds = %vector.main.loop.iter.check196
  %n.vec199 = and i64 %211, 8589934560
  br label %vector.body200

vector.body200:                                   ; preds = %vector.body200, %vector.ph197
  %index201 = phi i64 [ 0, %vector.ph197 ], [ %index.next210, %vector.body200 ]
  %next.gep202 = getelementptr i8, ptr %.086.lcssa, i64 %index201
  %next.gep204 = getelementptr i8, ptr %10, i64 %index201
  %215 = getelementptr i8, ptr %next.gep202, i64 16
  %wide.load206 = load <16 x i8>, ptr %next.gep202, align 1, !tbaa !9, !alias.scope !21
  %wide.load207 = load <16 x i8>, ptr %215, align 1, !tbaa !9, !alias.scope !21
  %216 = getelementptr i8, ptr %next.gep204, i64 16
  %wide.load208 = load <16 x i8>, ptr %next.gep204, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %wide.load209 = load <16 x i8>, ptr %216, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %217 = xor <16 x i8> %wide.load208, %wide.load206
  %218 = xor <16 x i8> %wide.load209, %wide.load207
  store <16 x i8> %217, ptr %next.gep204, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  store <16 x i8> %218, ptr %216, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %index.next210 = add nuw i64 %index201, 32
  %219 = icmp eq i64 %index.next210, %n.vec199
  br i1 %219, label %middle.block191, label %vector.body200, !llvm.loop !26

middle.block191:                                  ; preds = %vector.body200
  %cmp.n211 = icmp eq i64 %211, %n.vec199
  br i1 %cmp.n211, label %._crit_edge139, label %vec.epilog.iter.check215

vec.epilog.iter.check215:                         ; preds = %middle.block191
  %ind.end230 = getelementptr i8, ptr %10, i64 %n.vec199
  %ind.end227 = getelementptr i8, ptr %.086.lcssa, i64 %n.vec199
  %.cast223 = trunc i64 %n.vec199 to i32
  %ind.end224 = sub i32 %137, %.cast223
  %n.vec.remaining216 = and i64 %211, 24
  %min.epilog.iters.check217 = icmp eq i64 %n.vec.remaining216, 0
  br i1 %min.epilog.iters.check217, label %.lr.ph138.preheader, label %vec.epilog.ph214

vec.epilog.ph214:                                 ; preds = %vector.main.loop.iter.check196, %vec.epilog.iter.check215
  %vec.epilog.resume.val218 = phi i64 [ %n.vec199, %vec.epilog.iter.check215 ], [ 0, %vector.main.loop.iter.check196 ]
  %n.vec220 = and i64 %211, 8589934584
  %.cast221 = trunc i64 %n.vec220 to i32
  %ind.end222 = sub i32 %137, %.cast221
  %ind.end226 = getelementptr i8, ptr %.086.lcssa, i64 %n.vec220
  %ind.end229 = getelementptr i8, ptr %10, i64 %n.vec220
  br label %vec.epilog.vector.body232

vec.epilog.vector.body232:                        ; preds = %vec.epilog.vector.body232, %vec.epilog.ph214
  %index233 = phi i64 [ %vec.epilog.resume.val218, %vec.epilog.ph214 ], [ %index.next238, %vec.epilog.vector.body232 ]
  %next.gep234 = getelementptr i8, ptr %.086.lcssa, i64 %index233
  %next.gep235 = getelementptr i8, ptr %10, i64 %index233
  %wide.load236 = load <8 x i8>, ptr %next.gep234, align 1, !tbaa !9, !alias.scope !27
  %wide.load237 = load <8 x i8>, ptr %next.gep235, align 8, !tbaa !9, !alias.scope !30, !noalias !27
  %220 = xor <8 x i8> %wide.load237, %wide.load236
  store <8 x i8> %220, ptr %next.gep235, align 8, !tbaa !9, !alias.scope !30, !noalias !27
  %index.next238 = add nuw i64 %index233, 8
  %221 = icmp eq i64 %index.next238, %n.vec220
  br i1 %221, label %vec.epilog.middle.block212, label %vec.epilog.vector.body232, !llvm.loop !32

vec.epilog.middle.block212:                       ; preds = %vec.epilog.vector.body232
  %cmp.n239 = icmp eq i64 %211, %n.vec220
  br i1 %cmp.n239, label %._crit_edge139, label %.lr.ph138.preheader

.lr.ph138.preheader:                              ; preds = %vec.epilog.middle.block212, %vector.memcheck189, %iter.check194, %vec.epilog.iter.check215
  %.078136.ph = phi i32 [ %137, %iter.check194 ], [ %137, %vector.memcheck189 ], [ %ind.end224, %vec.epilog.iter.check215 ], [ %ind.end222, %vec.epilog.middle.block212 ]
  %.079135.ph = phi ptr [ %.086.lcssa, %iter.check194 ], [ %.086.lcssa, %vector.memcheck189 ], [ %ind.end227, %vec.epilog.iter.check215 ], [ %ind.end226, %vec.epilog.middle.block212 ]
  %.080134.ph = phi ptr [ %10, %iter.check194 ], [ %10, %vector.memcheck189 ], [ %ind.end230, %vec.epilog.iter.check215 ], [ %ind.end229, %vec.epilog.middle.block212 ]
  %222 = add nsw i32 %.078136.ph, -1
  %xtraiter243 = and i32 %.078136.ph, 3
  %lcmp.mod244.not = icmp eq i32 %xtraiter243, 0
  br i1 %lcmp.mod244.not, label %.lr.ph138.prol.loopexit, label %.lr.ph138.prol

.lr.ph138.prol:                                   ; preds = %.lr.ph138.preheader, %.lr.ph138.prol
  %.078136.prol = phi i32 [ %228, %.lr.ph138.prol ], [ %.078136.ph, %.lr.ph138.preheader ]
  %.079135.prol = phi ptr [ %223, %.lr.ph138.prol ], [ %.079135.ph, %.lr.ph138.preheader ]
  %.080134.prol = phi ptr [ %225, %.lr.ph138.prol ], [ %.080134.ph, %.lr.ph138.preheader ]
  %prol.iter245 = phi i32 [ %prol.iter245.next, %.lr.ph138.prol ], [ 0, %.lr.ph138.preheader ]
  %223 = getelementptr inbounds i8, ptr %.079135.prol, i64 1
  %224 = load i8, ptr %.079135.prol, align 1, !tbaa !9
  %225 = getelementptr inbounds i8, ptr %.080134.prol, i64 1
  %226 = load i8, ptr %.080134.prol, align 1, !tbaa !9
  %227 = xor i8 %226, %224
  store i8 %227, ptr %.080134.prol, align 1, !tbaa !9
  %228 = add nsw i32 %.078136.prol, -1
  %prol.iter245.next = add i32 %prol.iter245, 1
  %prol.iter245.cmp.not = icmp eq i32 %prol.iter245.next, %xtraiter243
  br i1 %prol.iter245.cmp.not, label %.lr.ph138.prol.loopexit, label %.lr.ph138.prol, !llvm.loop !33

.lr.ph138.prol.loopexit:                          ; preds = %.lr.ph138.prol, %.lr.ph138.preheader
  %.078136.unr = phi i32 [ %.078136.ph, %.lr.ph138.preheader ], [ %228, %.lr.ph138.prol ]
  %.079135.unr = phi ptr [ %.079135.ph, %.lr.ph138.preheader ], [ %223, %.lr.ph138.prol ]
  %.080134.unr = phi ptr [ %.080134.ph, %.lr.ph138.preheader ], [ %225, %.lr.ph138.prol ]
  %229 = icmp ult i32 %222, 3
  br i1 %229, label %._crit_edge139, label %.lr.ph138

.lr.ph138:                                        ; preds = %.lr.ph138.prol.loopexit, %.lr.ph138
  %.078136 = phi i32 [ %250, %.lr.ph138 ], [ %.078136.unr, %.lr.ph138.prol.loopexit ]
  %.079135 = phi ptr [ %245, %.lr.ph138 ], [ %.079135.unr, %.lr.ph138.prol.loopexit ]
  %.080134 = phi ptr [ %247, %.lr.ph138 ], [ %.080134.unr, %.lr.ph138.prol.loopexit ]
  %230 = getelementptr inbounds i8, ptr %.079135, i64 1
  %231 = load i8, ptr %.079135, align 1, !tbaa !9
  %232 = getelementptr inbounds i8, ptr %.080134, i64 1
  %233 = load i8, ptr %.080134, align 1, !tbaa !9
  %234 = xor i8 %233, %231
  store i8 %234, ptr %.080134, align 1, !tbaa !9
  %235 = getelementptr inbounds i8, ptr %.079135, i64 2
  %236 = load i8, ptr %230, align 1, !tbaa !9
  %237 = getelementptr inbounds i8, ptr %.080134, i64 2
  %238 = load i8, ptr %232, align 1, !tbaa !9
  %239 = xor i8 %238, %236
  store i8 %239, ptr %232, align 1, !tbaa !9
  %240 = getelementptr inbounds i8, ptr %.079135, i64 3
  %241 = load i8, ptr %235, align 1, !tbaa !9
  %242 = getelementptr inbounds i8, ptr %.080134, i64 3
  %243 = load i8, ptr %237, align 1, !tbaa !9
  %244 = xor i8 %243, %241
  store i8 %244, ptr %237, align 1, !tbaa !9
  %245 = getelementptr inbounds i8, ptr %.079135, i64 4
  %246 = load i8, ptr %240, align 1, !tbaa !9
  %247 = getelementptr inbounds i8, ptr %.080134, i64 4
  %248 = load i8, ptr %242, align 1, !tbaa !9
  %249 = xor i8 %248, %246
  store i8 %249, ptr %242, align 1, !tbaa !9
  %250 = add nsw i32 %.078136, -4
  %.not106.3 = icmp eq i32 %250, 0
  br i1 %.not106.3, label %._crit_edge139, label %.lr.ph138, !llvm.loop !34

._crit_edge139:                                   ; preds = %.lr.ph138.prol.loopexit, %.lr.ph138, %vec.epilog.middle.block212, %middle.block191
  %251 = getelementptr inbounds i8, ptr %10, i64 %.090.lcssa
  %252 = load i8, ptr %251, align 1, !tbaa !9
  %253 = xor i8 %252, -128
  store i8 %253, ptr %251, align 1, !tbaa !9
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %.081.lcssa, ptr nonnull align 16 %12, i64 %.090.lcssa, i1 false)
  br label %254

254:                                              ; preds = %._crit_edge139, %.preheader.preheader
  call void @sparkle_384(ptr noundef nonnull %10, i32 noundef 11) #4
  %255 = getelementptr inbounds i8, ptr %.081.lcssa, i64 %.090.lcssa
  br label %256

256:                                              ; preds = %17, %254
  %.1 = phi ptr [ %255, %254 ], [ %0, %17 ]
  %257 = getelementptr inbounds i8, ptr %10, i64 33
  %258 = load i8, ptr %15, align 16, !tbaa !9
  %259 = getelementptr inbounds i8, ptr %8, i64 1
  %260 = load i8, ptr %8, align 1, !tbaa !9
  %261 = xor i8 %260, %258
  %262 = getelementptr inbounds i8, ptr %.1, i64 1
  store i8 %261, ptr %.1, align 1, !tbaa !9
  %263 = getelementptr inbounds i8, ptr %10, i64 34
  %264 = load i8, ptr %257, align 1, !tbaa !9
  %265 = getelementptr inbounds i8, ptr %8, i64 2
  %266 = load i8, ptr %259, align 1, !tbaa !9
  %267 = xor i8 %266, %264
  %268 = getelementptr inbounds i8, ptr %.1, i64 2
  store i8 %267, ptr %262, align 1, !tbaa !9
  %269 = getelementptr inbounds i8, ptr %10, i64 35
  %270 = load i8, ptr %263, align 2, !tbaa !9
  %271 = getelementptr inbounds i8, ptr %8, i64 3
  %272 = load i8, ptr %265, align 1, !tbaa !9
  %273 = xor i8 %272, %270
  %274 = getelementptr inbounds i8, ptr %.1, i64 3
  store i8 %273, ptr %268, align 1, !tbaa !9
  %275 = getelementptr inbounds i8, ptr %10, i64 36
  %276 = load i8, ptr %269, align 1, !tbaa !9
  %277 = getelementptr inbounds i8, ptr %8, i64 4
  %278 = load i8, ptr %271, align 1, !tbaa !9
  %279 = xor i8 %278, %276
  %280 = getelementptr inbounds i8, ptr %.1, i64 4
  store i8 %279, ptr %274, align 1, !tbaa !9
  %281 = getelementptr inbounds i8, ptr %10, i64 37
  %282 = load i8, ptr %275, align 4, !tbaa !9
  %283 = getelementptr inbounds i8, ptr %8, i64 5
  %284 = load i8, ptr %277, align 1, !tbaa !9
  %285 = xor i8 %284, %282
  %286 = getelementptr inbounds i8, ptr %.1, i64 5
  store i8 %285, ptr %280, align 1, !tbaa !9
  %287 = getelementptr inbounds i8, ptr %10, i64 38
  %288 = load i8, ptr %281, align 1, !tbaa !9
  %289 = getelementptr inbounds i8, ptr %8, i64 6
  %290 = load i8, ptr %283, align 1, !tbaa !9
  %291 = xor i8 %290, %288
  %292 = getelementptr inbounds i8, ptr %.1, i64 6
  store i8 %291, ptr %286, align 1, !tbaa !9
  %293 = getelementptr inbounds i8, ptr %10, i64 39
  %294 = load i8, ptr %287, align 2, !tbaa !9
  %295 = getelementptr inbounds i8, ptr %8, i64 7
  %296 = load i8, ptr %289, align 1, !tbaa !9
  %297 = xor i8 %296, %294
  %298 = getelementptr inbounds i8, ptr %.1, i64 7
  store i8 %297, ptr %292, align 1, !tbaa !9
  %299 = getelementptr inbounds i8, ptr %10, i64 40
  %300 = load i8, ptr %293, align 1, !tbaa !9
  %301 = getelementptr inbounds i8, ptr %8, i64 8
  %302 = load i8, ptr %295, align 1, !tbaa !9
  %303 = xor i8 %302, %300
  %304 = getelementptr inbounds i8, ptr %.1, i64 8
  store i8 %303, ptr %298, align 1, !tbaa !9
  %305 = getelementptr inbounds i8, ptr %10, i64 41
  %306 = load i8, ptr %299, align 8, !tbaa !9
  %307 = getelementptr inbounds i8, ptr %8, i64 9
  %308 = load i8, ptr %301, align 1, !tbaa !9
  %309 = xor i8 %308, %306
  %310 = getelementptr inbounds i8, ptr %.1, i64 9
  store i8 %309, ptr %304, align 1, !tbaa !9
  %311 = getelementptr inbounds i8, ptr %10, i64 42
  %312 = load i8, ptr %305, align 1, !tbaa !9
  %313 = getelementptr inbounds i8, ptr %8, i64 10
  %314 = load i8, ptr %307, align 1, !tbaa !9
  %315 = xor i8 %314, %312
  %316 = getelementptr inbounds i8, ptr %.1, i64 10
  store i8 %315, ptr %310, align 1, !tbaa !9
  %317 = getelementptr inbounds i8, ptr %10, i64 43
  %318 = load i8, ptr %311, align 2, !tbaa !9
  %319 = getelementptr inbounds i8, ptr %8, i64 11
  %320 = load i8, ptr %313, align 1, !tbaa !9
  %321 = xor i8 %320, %318
  %322 = getelementptr inbounds i8, ptr %.1, i64 11
  store i8 %321, ptr %316, align 1, !tbaa !9
  %323 = getelementptr inbounds i8, ptr %10, i64 44
  %324 = load i8, ptr %317, align 1, !tbaa !9
  %325 = getelementptr inbounds i8, ptr %8, i64 12
  %326 = load i8, ptr %319, align 1, !tbaa !9
  %327 = xor i8 %326, %324
  %328 = getelementptr inbounds i8, ptr %.1, i64 12
  store i8 %327, ptr %322, align 1, !tbaa !9
  %329 = getelementptr inbounds i8, ptr %10, i64 45
  %330 = load i8, ptr %323, align 4, !tbaa !9
  %331 = getelementptr inbounds i8, ptr %8, i64 13
  %332 = load i8, ptr %325, align 1, !tbaa !9
  %333 = xor i8 %332, %330
  %334 = getelementptr inbounds i8, ptr %.1, i64 13
  store i8 %333, ptr %328, align 1, !tbaa !9
  %335 = getelementptr inbounds i8, ptr %10, i64 46
  %336 = load i8, ptr %329, align 1, !tbaa !9
  %337 = getelementptr inbounds i8, ptr %8, i64 14
  %338 = load i8, ptr %331, align 1, !tbaa !9
  %339 = xor i8 %338, %336
  %340 = getelementptr inbounds i8, ptr %.1, i64 14
  store i8 %339, ptr %334, align 1, !tbaa !9
  %341 = getelementptr inbounds i8, ptr %10, i64 47
  %342 = load i8, ptr %335, align 2, !tbaa !9
  %343 = getelementptr inbounds i8, ptr %8, i64 15
  %344 = load i8, ptr %337, align 1, !tbaa !9
  %345 = xor i8 %344, %342
  %346 = getelementptr inbounds i8, ptr %.1, i64 15
  store i8 %345, ptr %340, align 1, !tbaa !9
  %347 = load i8, ptr %341, align 1, !tbaa !9
  %348 = load i8, ptr %343, align 1, !tbaa !9
  %349 = xor i8 %348, %347
  store i8 %349, ptr %346, align 1, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %12) #4
  call void @llvm.lifetime.end.p0(i64 48, 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

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

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

; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #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 = { 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