; 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_192_192_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 [24 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 24, 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, 24
  %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 24, i1 false)
  %56 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  %57 = getelementptr inbounds i8, ptr %56, i64 24
  %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 24, 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_192_192_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 %402

69:                                               ; preds = %66
  br label %70

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

73:                                               ; preds = %70
  br label %74

74:                                               ; preds = %73
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #4
  %75 = getelementptr inbounds [24 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 24, 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 3
  %103 = load i32, ptr %102, align 4, !tbaa !11
  %104 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 6
  %105 = load i32, ptr %104, align 8, !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 9
  %110 = load i32, ptr %109, align 4, !tbaa !11
  %111 = xor i32 %108, %110
  %112 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 3
  %113 = load i32, ptr %112, align 4, !tbaa !11
  %114 = xor i32 %113, %111
  store i32 %114, ptr %112, align 4, !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 4
  %118 = load i32, ptr %117, align 16, !tbaa !11
  %119 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 7
  %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 10
  %125 = load i32, ptr %124, align 8, !tbaa !11
  %126 = xor i32 %123, %125
  %127 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 4
  %128 = load i32, ptr %127, align 16, !tbaa !11
  %129 = xor i32 %128, %126
  store i32 %129, ptr %127, align 16, !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 5
  %133 = load i32, ptr %132, align 4, !tbaa !11
  %134 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 8
  %135 = load i32, ptr %134, align 16, !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 11
  %140 = load i32, ptr %139, align 4, !tbaa !11
  %141 = xor i32 %138, %140
  %142 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 5
  %143 = load i32, ptr %142, align 4, !tbaa !11
  %144 = xor i32 %143, %141
  store i32 %144, ptr %142, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #4
  br label %145

145:                                              ; preds = %99
  br label %146

146:                                              ; preds = %145
  br label %147

147:                                              ; preds = %146
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #4
  %148 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  store ptr %148, ptr %26, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #4
  %149 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %149, ptr %27, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #4
  store i32 24, ptr %28, align 4, !tbaa !11
  br label %150

150:                                              ; preds = %153, %147
  %151 = load i32, ptr %28, align 4, !tbaa !11
  %152 = icmp ugt i32 %151, 0
  br i1 %152, label %153, label %166

153:                                              ; preds = %150
  %154 = load ptr, ptr %27, align 8, !tbaa !5
  %155 = getelementptr inbounds i8, ptr %154, i32 1
  store ptr %155, ptr %27, align 8, !tbaa !5
  %156 = load i8, ptr %154, align 1, !tbaa !13
  %157 = zext i8 %156 to i32
  %158 = load ptr, ptr %26, align 8, !tbaa !5
  %159 = getelementptr inbounds i8, ptr %158, i32 1
  store ptr %159, ptr %26, align 8, !tbaa !5
  %160 = load i8, ptr %158, align 1, !tbaa !13
  %161 = zext i8 %160 to i32
  %162 = xor i32 %161, %157
  %163 = trunc i32 %162 to i8
  store i8 %163, ptr %158, align 1, !tbaa !13
  %164 = load i32, ptr %28, align 4, !tbaa !11
  %165 = add i32 %164, -1
  store i32 %165, ptr %28, align 4, !tbaa !11
  br label %150, !llvm.loop !16

166:                                              ; preds = %150
  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 %167

167:                                              ; preds = %166
  br label %168

168:                                              ; preds = %167
  %169 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  call void @sparkle_384(ptr noundef %169, i32 noundef 7)
  %170 = load ptr, ptr %10, align 8, !tbaa !5
  %171 = getelementptr inbounds [24 x i8], ptr %20, i64 0, i64 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %170, ptr align 16 %171, i64 24, i1 false)
  %172 = load ptr, ptr %10, align 8, !tbaa !5
  %173 = getelementptr inbounds i8, ptr %172, i64 24
  store ptr %173, ptr %10, align 8, !tbaa !5
  %174 = load ptr, ptr %12, align 8, !tbaa !5
  %175 = getelementptr inbounds i8, ptr %174, i64 24
  store ptr %175, ptr %12, align 8, !tbaa !5
  %176 = load i64, ptr %13, align 8, !tbaa !9
  %177 = sub i64 %176, 24
  store i64 %177, ptr %13, align 8, !tbaa !9
  br label %70, !llvm.loop !17

178:                                              ; preds = %70
  %179 = load i64, ptr %13, align 8, !tbaa !9
  %180 = icmp eq i64 %179, 24
  br i1 %180, label %181, label %282

181:                                              ; preds = %178
  br label %182

182:                                              ; preds = %181
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #4
  %183 = getelementptr inbounds [24 x i8], ptr %20, i64 0, i64 0
  store ptr %183, ptr %29, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #4
  %184 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  store ptr %184, ptr %30, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #4
  %185 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %185, ptr %31, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #4
  store i32 24, ptr %32, align 4, !tbaa !11
  br label %186

186:                                              ; preds = %189, %182
  %187 = load i32, ptr %32, align 4, !tbaa !11
  %188 = icmp ugt i32 %187, 0
  br i1 %188, label %189, label %204

189:                                              ; preds = %186
  %190 = load ptr, ptr %30, align 8, !tbaa !5
  %191 = getelementptr inbounds i8, ptr %190, i32 1
  store ptr %191, ptr %30, align 8, !tbaa !5
  %192 = load i8, ptr %190, align 1, !tbaa !13
  %193 = zext i8 %192 to i32
  %194 = load ptr, ptr %31, align 8, !tbaa !5
  %195 = getelementptr inbounds i8, ptr %194, i32 1
  store ptr %195, ptr %31, align 8, !tbaa !5
  %196 = load i8, ptr %194, align 1, !tbaa !13
  %197 = zext i8 %196 to i32
  %198 = xor i32 %193, %197
  %199 = trunc i32 %198 to i8
  %200 = load ptr, ptr %29, align 8, !tbaa !5
  %201 = getelementptr inbounds i8, ptr %200, i32 1
  store ptr %201, ptr %29, align 8, !tbaa !5
  store i8 %199, ptr %200, align 1, !tbaa !13
  %202 = load i32, ptr %32, align 4, !tbaa !11
  %203 = add i32 %202, -1
  store i32 %203, ptr %32, align 4, !tbaa !11
  br label %186, !llvm.loop !18

204:                                              ; preds = %186
  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 %205

205:                                              ; preds = %204
  br label %206

206:                                              ; preds = %205
  %207 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 11
  %208 = load i32, ptr %207, align 4, !tbaa !11
  %209 = xor i32 %208, 184549376
  store i32 %209, ptr %207, align 4, !tbaa !11
  br label %210

210:                                              ; preds = %206
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #4
  %211 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  %212 = load i32, ptr %211, align 16, !tbaa !11
  store i32 %212, ptr %33, align 4, !tbaa !11
  %213 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 3
  %214 = load i32, ptr %213, align 4, !tbaa !11
  %215 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 6
  %216 = load i32, ptr %215, align 8, !tbaa !11
  %217 = xor i32 %214, %216
  %218 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  store i32 %217, ptr %218, align 16, !tbaa !11
  %219 = load i32, ptr %33, align 4, !tbaa !11
  %220 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 9
  %221 = load i32, ptr %220, align 4, !tbaa !11
  %222 = xor i32 %219, %221
  %223 = getelementptr inbounds [12 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
  %226 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 1
  %227 = load i32, ptr %226, align 4, !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 7
  %231 = load i32, ptr %230, align 4, !tbaa !11
  %232 = xor i32 %229, %231
  %233 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 1
  store i32 %232, ptr %233, align 4, !tbaa !11
  %234 = load i32, ptr %33, align 4, !tbaa !11
  %235 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 10
  %236 = load i32, ptr %235, align 8, !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 2
  %242 = load i32, ptr %241, align 8, !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 8
  %246 = load i32, ptr %245, align 16, !tbaa !11
  %247 = xor i32 %244, %246
  %248 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 2
  store i32 %247, ptr %248, align 8, !tbaa !11
  %249 = load i32, ptr %33, align 4, !tbaa !11
  %250 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 11
  %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
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #4
  br label %256

256:                                              ; preds = %210
  br label %257

257:                                              ; preds = %256
  br label %258

258:                                              ; preds = %257
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #4
  %259 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  store ptr %259, ptr %34, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #4
  %260 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %260, ptr %35, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #4
  store i32 24, ptr %36, align 4, !tbaa !11
  br label %261

261:                                              ; preds = %264, %258
  %262 = load i32, ptr %36, align 4, !tbaa !11
  %263 = icmp ugt i32 %262, 0
  br i1 %263, label %264, label %277

264:                                              ; preds = %261
  %265 = load ptr, ptr %35, align 8, !tbaa !5
  %266 = getelementptr inbounds i8, ptr %265, i32 1
  store ptr %266, ptr %35, align 8, !tbaa !5
  %267 = load i8, ptr %265, align 1, !tbaa !13
  %268 = zext i8 %267 to i32
  %269 = load ptr, ptr %34, align 8, !tbaa !5
  %270 = getelementptr inbounds i8, ptr %269, i32 1
  store ptr %270, ptr %34, align 8, !tbaa !5
  %271 = load i8, ptr %269, align 1, !tbaa !13
  %272 = zext i8 %271 to i32
  %273 = xor i32 %272, %268
  %274 = trunc i32 %273 to i8
  store i8 %274, ptr %269, align 1, !tbaa !13
  %275 = load i32, ptr %36, align 4, !tbaa !11
  %276 = add i32 %275, -1
  store i32 %276, ptr %36, align 4, !tbaa !11
  br label %261, !llvm.loop !19

277:                                              ; preds = %261
  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 %278

278:                                              ; preds = %277
  br label %279

279:                                              ; preds = %278
  %280 = load ptr, ptr %10, align 8, !tbaa !5
  %281 = getelementptr inbounds [24 x i8], ptr %20, i64 0, i64 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %280, ptr align 16 %281, i64 24, i1 false)
  br label %397

282:                                              ; preds = %178
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #4
  %283 = load i64, ptr %13, align 8, !tbaa !9
  %284 = trunc i64 %283 to i32
  store i32 %284, ptr %37, align 4, !tbaa !11
  br label %285

285:                                              ; preds = %282
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #4
  %286 = getelementptr inbounds [24 x i8], ptr %20, i64 0, i64 0
  store ptr %286, ptr %38, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #4
  %287 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  store ptr %287, ptr %39, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #4
  %288 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %288, ptr %40, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #4
  %289 = load i32, ptr %37, align 4, !tbaa !11
  store i32 %289, ptr %41, align 4, !tbaa !11
  br label %290

290:                                              ; preds = %293, %285
  %291 = load i32, ptr %41, align 4, !tbaa !11
  %292 = icmp ugt i32 %291, 0
  br i1 %292, label %293, label %308

293:                                              ; preds = %290
  %294 = load ptr, ptr %39, align 8, !tbaa !5
  %295 = getelementptr inbounds i8, ptr %294, i32 1
  store ptr %295, ptr %39, align 8, !tbaa !5
  %296 = load i8, ptr %294, align 1, !tbaa !13
  %297 = zext i8 %296 to i32
  %298 = load ptr, ptr %40, align 8, !tbaa !5
  %299 = getelementptr inbounds i8, ptr %298, i32 1
  store ptr %299, ptr %40, align 8, !tbaa !5
  %300 = load i8, ptr %298, align 1, !tbaa !13
  %301 = zext i8 %300 to i32
  %302 = xor i32 %297, %301
  %303 = trunc i32 %302 to i8
  %304 = load ptr, ptr %38, align 8, !tbaa !5
  %305 = getelementptr inbounds i8, ptr %304, i32 1
  store ptr %305, ptr %38, align 8, !tbaa !5
  store i8 %303, ptr %304, align 1, !tbaa !13
  %306 = load i32, ptr %41, align 4, !tbaa !11
  %307 = add i32 %306, -1
  store i32 %307, ptr %41, align 4, !tbaa !11
  br label %290, !llvm.loop !20

308:                                              ; preds = %290
  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 %309

309:                                              ; preds = %308
  br label %310

310:                                              ; preds = %309
  %311 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 11
  %312 = load i32, ptr %311, align 4, !tbaa !11
  %313 = xor i32 %312, 167772160
  store i32 %313, ptr %311, align 4, !tbaa !11
  br label %314

314:                                              ; preds = %310
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #4
  %315 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  %316 = load i32, ptr %315, align 16, !tbaa !11
  store i32 %316, ptr %42, align 4, !tbaa !11
  %317 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 3
  %318 = load i32, ptr %317, align 4, !tbaa !11
  %319 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 6
  %320 = load i32, ptr %319, align 8, !tbaa !11
  %321 = xor i32 %318, %320
  %322 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  store i32 %321, ptr %322, align 16, !tbaa !11
  %323 = load i32, ptr %42, align 4, !tbaa !11
  %324 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 9
  %325 = load i32, ptr %324, align 4, !tbaa !11
  %326 = xor i32 %323, %325
  %327 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 3
  %328 = load i32, ptr %327, align 4, !tbaa !11
  %329 = xor i32 %328, %326
  store i32 %329, ptr %327, align 4, !tbaa !11
  %330 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 1
  %331 = load i32, ptr %330, align 4, !tbaa !11
  store i32 %331, ptr %42, align 4, !tbaa !11
  %332 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 4
  %333 = load i32, ptr %332, align 16, !tbaa !11
  %334 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 7
  %335 = load i32, ptr %334, align 4, !tbaa !11
  %336 = xor i32 %333, %335
  %337 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 1
  store i32 %336, ptr %337, align 4, !tbaa !11
  %338 = load i32, ptr %42, align 4, !tbaa !11
  %339 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 10
  %340 = load i32, ptr %339, align 8, !tbaa !11
  %341 = xor i32 %338, %340
  %342 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 4
  %343 = load i32, ptr %342, align 16, !tbaa !11
  %344 = xor i32 %343, %341
  store i32 %344, ptr %342, align 16, !tbaa !11
  %345 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 2
  %346 = load i32, ptr %345, align 8, !tbaa !11
  store i32 %346, ptr %42, align 4, !tbaa !11
  %347 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 5
  %348 = load i32, ptr %347, align 4, !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 2
  store i32 %351, ptr %352, align 8, !tbaa !11
  %353 = load i32, ptr %42, align 4, !tbaa !11
  %354 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 11
  %355 = load i32, ptr %354, align 4, !tbaa !11
  %356 = xor i32 %353, %355
  %357 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 5
  %358 = load i32, ptr %357, align 4, !tbaa !11
  %359 = xor i32 %358, %356
  store i32 %359, ptr %357, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #4
  br label %360

360:                                              ; preds = %314
  br label %361

361:                                              ; preds = %360
  br label %362

362:                                              ; preds = %361
  call void @llvm.lifetime.start.p0(i64 8, ptr %43) #4
  %363 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  store ptr %363, ptr %43, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #4
  %364 = load ptr, ptr %12, align 8, !tbaa !5
  store ptr %364, ptr %44, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %45) #4
  %365 = load i32, ptr %37, align 4, !tbaa !11
  store i32 %365, ptr %45, align 4, !tbaa !11
  br label %366

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

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

382:                                              ; preds = %366
  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 %383

383:                                              ; preds = %382
  br label %384

384:                                              ; preds = %383
  %385 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  %386 = load i32, ptr %37, align 4, !tbaa !11
  %387 = zext i32 %386 to i64
  %388 = getelementptr inbounds i8, ptr %385, i64 %387
  %389 = load i8, ptr %388, align 1, !tbaa !13
  %390 = zext i8 %389 to i32
  %391 = xor i32 %390, 128
  %392 = trunc i32 %391 to i8
  store i8 %392, ptr %388, align 1, !tbaa !13
  %393 = load ptr, ptr %10, align 8, !tbaa !5
  %394 = getelementptr inbounds [24 x i8], ptr %20, i64 0, i64 0
  %395 = load i32, ptr %37, align 4, !tbaa !11
  %396 = zext i32 %395 to i64
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %393, ptr align 16 %394, i64 %396, i1 false)
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #4
  br label %397

397:                                              ; preds = %384, %279
  %398 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  call void @sparkle_384(ptr noundef %398, i32 noundef 11)
  %399 = load i64, ptr %13, align 8, !tbaa !9
  %400 = load ptr, ptr %10, align 8, !tbaa !5
  %401 = getelementptr inbounds i8, ptr %400, i64 %399
  store ptr %401, ptr %10, align 8, !tbaa !5
  br label %402

402:                                              ; preds = %397, %66
  br label %403

403:                                              ; preds = %402
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #4
  %404 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %404, ptr %46, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #4
  %405 = getelementptr inbounds [12 x i32], ptr %19, i64 0, i64 0
  %406 = getelementptr inbounds i8, ptr %405, i64 24
  store ptr %406, ptr %47, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %48) #4
  %407 = load ptr, ptr %18, align 8, !tbaa !5
  store ptr %407, ptr %48, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %49) #4
  store i32 24, ptr %49, align 4, !tbaa !11
  br label %408

408:                                              ; preds = %411, %403
  %409 = load i32, ptr %49, align 4, !tbaa !11
  %410 = icmp ugt i32 %409, 0
  br i1 %410, label %411, label %426

411:                                              ; preds = %408
  %412 = load ptr, ptr %47, align 8, !tbaa !5
  %413 = getelementptr inbounds i8, ptr %412, i32 1
  store ptr %413, ptr %47, align 8, !tbaa !5
  %414 = load i8, ptr %412, align 1, !tbaa !13
  %415 = zext i8 %414 to i32
  %416 = load ptr, ptr %48, align 8, !tbaa !5
  %417 = getelementptr inbounds i8, ptr %416, i32 1
  store ptr %417, ptr %48, align 8, !tbaa !5
  %418 = load i8, ptr %416, align 1, !tbaa !13
  %419 = zext i8 %418 to i32
  %420 = xor i32 %415, %419
  %421 = trunc i32 %420 to i8
  %422 = load ptr, ptr %46, align 8, !tbaa !5
  %423 = getelementptr inbounds i8, ptr %422, i32 1
  store ptr %423, ptr %46, align 8, !tbaa !5
  store i8 %421, ptr %422, align 1, !tbaa !13
  %424 = load i32, ptr %49, align 4, !tbaa !11
  %425 = add i32 %424, -1
  store i32 %425, ptr %49, align 4, !tbaa !11
  br label %408, !llvm.loop !22

426:                                              ; preds = %408
  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 %427

427:                                              ; preds = %426
  br label %428

428:                                              ; preds = %427
  call void @llvm.lifetime.end.p0(i64 24, 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: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #1

; Function Attrs: nounwind uwtable
declare hidden void @schwaemm_192_192_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_192_192_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 [24 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 24, ptr nonnull %12) #4
  %14 = add i64 %3, 24
  store i64 %14, ptr %1, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(24) %10, ptr noundef nonnull align 1 dereferenceable(24) %7, i64 24, i1 false)
  %15 = getelementptr inbounds i8, ptr %10, i64 24
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(24) %15, ptr noundef nonnull align 1 dereferenceable(24) %8, i64 24, 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_192_192_authenticate(ptr noundef nonnull %10, ptr noundef %4, i64 noundef %5)
  br label %17

17:                                               ; preds = %16, %9
  %.not101 = icmp eq i64 %3, 0
  br i1 %.not101, label %289, label %.preheader110

.preheader110:                                    ; preds = %17
  %18 = icmp ugt i64 %3, 24
  br i1 %18, label %.preheader109.lr.ph, label %._crit_edge

.preheader109.lr.ph:                              ; preds = %.preheader110
  %19 = getelementptr inbounds i8, ptr %10, i64 12
  %20 = getelementptr inbounds i8, ptr %10, i64 36
  %21 = getelementptr inbounds i8, ptr %10, i64 4
  %22 = getelementptr inbounds i8, ptr %10, i64 28
  %23 = getelementptr inbounds i8, ptr %10, i64 8
  %24 = getelementptr inbounds i8, ptr %10, i64 20
  %25 = getelementptr inbounds i8, ptr %10, i64 32
  %26 = getelementptr inbounds i8, ptr %10, i64 44
  %27 = getelementptr inbounds i8, ptr %10, i64 7
  %28 = getelementptr inbounds i8, ptr %10, i64 15
  %29 = getelementptr inbounds i8, ptr %10, i64 16
  %30 = getelementptr inbounds i8, ptr %12, i64 16
  %31 = getelementptr inbounds i8, ptr %10, i64 23
  br label %.preheader109

.preheader109:                                    ; preds = %.preheader109.lr.ph, %.preheader109
  %.078120 = phi ptr [ %0, %.preheader109.lr.ph ], [ %93, %.preheader109 ]
  %.083119 = phi ptr [ %2, %.preheader109.lr.ph ], [ %94, %.preheader109 ]
  %.087118 = phi i64 [ %3, %.preheader109.lr.ph ], [ %95, %.preheader109 ]
  %32 = getelementptr inbounds i8, ptr %.083119, i64 16
  %33 = load <16 x i8>, ptr %10, align 16, !tbaa !9
  %34 = load <16 x i8>, ptr %.083119, align 1, !tbaa !9
  %35 = xor <16 x i8> %34, %33
  store <16 x i8> %35, ptr %12, align 16, !tbaa !9
  %36 = load <8 x i8>, ptr %29, align 16, !tbaa !9
  %37 = load <8 x i8>, ptr %32, align 1, !tbaa !9
  %38 = xor <8 x i8> %37, %36
  store <8 x i8> %38, ptr %30, align 16, !tbaa !9
  %39 = load i32, ptr %15, align 8, !tbaa !10
  %40 = load i32, ptr %22, align 4, !tbaa !10
  %41 = load <2 x i32>, ptr %19, align 4, !tbaa !10
  %42 = extractelement <2 x i32> %41, i64 0
  %43 = load <2 x i32>, ptr %10, align 16, !tbaa !10
  %44 = extractelement <2 x i32> %41, i64 1
  %45 = xor i32 %40, %44
  store i32 %45, ptr %21, align 4, !tbaa !10
  %46 = load <2 x i32>, ptr %20, align 4, !tbaa !10
  %47 = xor <2 x i32> %43, %46
  %48 = xor <2 x i32> %47, %41
  store <2 x i32> %48, ptr %19, align 4, !tbaa !10
  %49 = load i32, ptr %23, align 8, !tbaa !10
  %50 = load i32, ptr %24, align 4, !tbaa !10
  %51 = load i32, ptr %25, align 16, !tbaa !10
  %52 = xor i32 %51, %50
  store i32 %52, ptr %23, align 8, !tbaa !10
  %53 = load i32, ptr %26, align 4, !tbaa !10
  %54 = xor i32 %49, %53
  %55 = xor i32 %54, %50
  store i32 %55, ptr %24, align 4, !tbaa !10
  %56 = xor i32 %39, %42
  %57 = lshr i32 %56, 8
  %58 = lshr i32 %56, 16
  %59 = lshr i32 %56, 24
  %60 = insertelement <4 x i32> poison, i32 %56, i64 0
  %61 = insertelement <4 x i32> %60, i32 %57, i64 1
  %62 = insertelement <4 x i32> %61, i32 %58, i64 2
  %63 = insertelement <4 x i32> %62, i32 %59, i64 3
  %64 = trunc <4 x i32> %63 to <4 x i8>
  %65 = trunc i32 %45 to i8
  %66 = lshr i32 %45, 8
  %67 = trunc i32 %66 to i8
  %68 = lshr i32 %45, 16
  %69 = trunc i32 %68 to i8
  %70 = load <16 x i8>, ptr %27, align 1
  %71 = load i8, ptr %28, align 1, !tbaa !9
  %72 = load <16 x i8>, ptr %.083119, align 1, !tbaa !9
  %73 = shufflevector <4 x i8> %64, <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>
  %74 = insertelement <16 x i8> %73, i8 %65, i64 4
  %75 = insertelement <16 x i8> %74, i8 %67, i64 5
  %76 = insertelement <16 x i8> %75, i8 %69, i64 6
  %77 = shufflevector <16 x i8> %76, <16 x i8> %70, <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>
  %78 = insertelement <16 x i8> %77, i8 %71, i64 15
  %79 = xor <16 x i8> %72, %78
  store <16 x i8> %79, ptr %10, align 16, !tbaa !9
  %80 = load <8 x i8>, ptr %29, align 16
  %81 = trunc i32 %55 to i8
  %82 = lshr i32 %55, 8
  %83 = trunc i32 %82 to i8
  %84 = lshr i32 %55, 16
  %85 = trunc i32 %84 to i8
  %86 = load i8, ptr %31, align 1, !tbaa !9
  %87 = load <8 x i8>, ptr %32, align 1, !tbaa !9
  %88 = insertelement <8 x i8> %80, i8 %81, i64 4
  %89 = insertelement <8 x i8> %88, i8 %83, i64 5
  %90 = insertelement <8 x i8> %89, i8 %85, i64 6
  %91 = insertelement <8 x i8> %90, i8 %86, i64 7
  %92 = xor <8 x i8> %91, %87
  store <8 x i8> %92, ptr %29, 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(24) %.078120, ptr noundef nonnull align 16 dereferenceable(24) %12, i64 24, i1 false)
  %93 = getelementptr inbounds i8, ptr %.078120, i64 24
  %94 = getelementptr inbounds i8, ptr %.083119, i64 24
  %95 = add i64 %.087118, -24
  %96 = icmp ugt i64 %95, 24
  br i1 %96, label %.preheader109, label %._crit_edge, !llvm.loop !12

._crit_edge:                                      ; preds = %.preheader109, %.preheader110
  %.087.lcssa = phi i64 [ %3, %.preheader110 ], [ %95, %.preheader109 ]
  %.083.lcssa = phi ptr [ %2, %.preheader110 ], [ %94, %.preheader109 ]
  %.078.lcssa = phi ptr [ %0, %.preheader110 ], [ %93, %.preheader109 ]
  %.083.lcssa154 = ptrtoint ptr %.083.lcssa to i64
  %97 = icmp eq i64 %.087.lcssa, 24
  br i1 %97, label %.preheader.preheader, label %iter.check

.preheader.preheader:                             ; preds = %._crit_edge
  %98 = getelementptr inbounds i8, ptr %10, i64 7
  %99 = getelementptr inbounds i8, ptr %10, i64 15
  %100 = getelementptr inbounds i8, ptr %10, i64 16
  %101 = getelementptr inbounds i8, ptr %.083.lcssa, i64 16
  %102 = getelementptr inbounds i8, ptr %12, i64 16
  %103 = load <16 x i8>, ptr %10, align 16, !tbaa !9
  %104 = load <16 x i8>, ptr %.083.lcssa, align 1, !tbaa !9
  %105 = xor <16 x i8> %104, %103
  store <16 x i8> %105, ptr %12, align 16, !tbaa !9
  %106 = getelementptr inbounds i8, ptr %10, i64 23
  %107 = load <8 x i8>, ptr %100, align 16, !tbaa !9
  %108 = load <8 x i8>, ptr %101, align 1, !tbaa !9
  %109 = xor <8 x i8> %108, %107
  store <8 x i8> %109, ptr %102, align 16, !tbaa !9
  %110 = getelementptr inbounds i8, ptr %10, i64 44
  %111 = load i32, ptr %110, align 4, !tbaa !10
  %112 = xor i32 %111, 184549376
  store i32 %112, ptr %110, align 4, !tbaa !10
  %113 = getelementptr inbounds i8, ptr %10, i64 12
  %114 = load i32, ptr %15, align 8, !tbaa !10
  %115 = getelementptr inbounds i8, ptr %10, i64 36
  %116 = getelementptr inbounds i8, ptr %10, i64 4
  %117 = getelementptr inbounds i8, ptr %10, i64 28
  %118 = load i32, ptr %117, align 4, !tbaa !10
  %119 = load <2 x i32>, ptr %113, align 4, !tbaa !10
  %120 = extractelement <2 x i32> %119, i64 0
  %121 = load <2 x i32>, ptr %10, align 16, !tbaa !10
  %122 = extractelement <2 x i32> %119, i64 1
  %123 = xor i32 %118, %122
  store i32 %123, ptr %116, align 4, !tbaa !10
  %124 = load <2 x i32>, ptr %115, align 4, !tbaa !10
  %125 = xor <2 x i32> %121, %124
  %126 = xor <2 x i32> %125, %119
  store <2 x i32> %126, ptr %113, align 4, !tbaa !10
  %127 = getelementptr inbounds i8, ptr %10, i64 8
  %128 = load i32, ptr %127, align 8, !tbaa !10
  %129 = getelementptr inbounds i8, ptr %10, i64 20
  %130 = load i32, ptr %129, align 4, !tbaa !10
  %131 = getelementptr inbounds i8, ptr %10, i64 32
  %132 = load i32, ptr %131, align 16, !tbaa !10
  %133 = xor i32 %132, %130
  store i32 %133, ptr %127, align 8, !tbaa !10
  %134 = xor i32 %128, %112
  %135 = xor i32 %134, %130
  store i32 %135, ptr %129, align 4, !tbaa !10
  %136 = xor i32 %114, %120
  store i32 %136, ptr %10, align 16, !tbaa !10
  %137 = lshr i32 %136, 8
  %138 = lshr i32 %136, 16
  %139 = lshr i32 %136, 24
  %140 = insertelement <4 x i32> poison, i32 %136, i64 0
  %141 = insertelement <4 x i32> %140, i32 %137, i64 1
  %142 = insertelement <4 x i32> %141, i32 %138, i64 2
  %143 = insertelement <4 x i32> %142, i32 %139, i64 3
  %144 = trunc <4 x i32> %143 to <4 x i8>
  %145 = trunc i32 %123 to i8
  %146 = lshr i32 %123, 8
  %147 = trunc i32 %146 to i8
  %148 = lshr i32 %123, 16
  %149 = trunc i32 %148 to i8
  %150 = load <16 x i8>, ptr %98, align 1
  %151 = load i8, ptr %99, align 1, !tbaa !9
  %152 = load <16 x i8>, ptr %.083.lcssa, align 1, !tbaa !9
  %153 = shufflevector <4 x i8> %144, <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>
  %154 = insertelement <16 x i8> %153, i8 %145, i64 4
  %155 = insertelement <16 x i8> %154, i8 %147, i64 5
  %156 = insertelement <16 x i8> %155, i8 %149, i64 6
  %157 = shufflevector <16 x i8> %156, <16 x i8> %150, <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>
  %158 = insertelement <16 x i8> %157, i8 %151, i64 15
  %159 = xor <16 x i8> %152, %158
  store <16 x i8> %159, ptr %10, align 16, !tbaa !9
  %160 = load <8 x i8>, ptr %100, align 16
  %161 = trunc i32 %135 to i8
  %162 = lshr i32 %135, 8
  %163 = trunc i32 %162 to i8
  %164 = lshr i32 %135, 16
  %165 = trunc i32 %164 to i8
  %166 = load i8, ptr %106, align 1, !tbaa !9
  %167 = load <8 x i8>, ptr %101, align 1, !tbaa !9
  %168 = insertelement <8 x i8> %160, i8 %161, i64 4
  %169 = insertelement <8 x i8> %168, i8 %163, i64 5
  %170 = insertelement <8 x i8> %169, i8 %165, i64 6
  %171 = insertelement <8 x i8> %170, i8 %166, i64 7
  %172 = xor <8 x i8> %171, %167
  store <8 x i8> %172, ptr %100, align 16, !tbaa !9
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(24) %.078.lcssa, ptr noundef nonnull align 16 dereferenceable(24) %12, i64 24, i1 false)
  br label %287

iter.check:                                       ; preds = %._crit_edge
  %173 = trunc nuw i64 %.087.lcssa to i32
  %174 = add nuw nsw i64 %.087.lcssa, 4294967295
  %175 = and i64 %174, 4294967295
  %176 = add nuw nsw i64 %175, 1
  %min.iters.check = icmp ult i64 %175, 7
  br i1 %min.iters.check, label %.lr.ph.preheader, label %vector.memcheck

vector.memcheck:                                  ; preds = %iter.check
  %177 = sub i64 %13, %11
  %diff.check = icmp ult i64 %177, 32
  %178 = sub i64 %13, %.083.lcssa154
  %diff.check155 = icmp ult i64 %178, 32
  %conflict.rdx = or i1 %diff.check, %diff.check155
  br i1 %conflict.rdx, label %.lr.ph.preheader, label %vector.main.loop.iter.check

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

vector.ph:                                        ; preds = %vector.main.loop.iter.check
  %n.vec = and i64 %176, 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 %.083.lcssa, i64 %index
  %next.gep158 = getelementptr i8, ptr %10, i64 %index
  %next.gep160 = getelementptr i8, ptr %12, i64 %index
  %179 = getelementptr i8, ptr %next.gep158, i64 16
  %wide.load = load <16 x i8>, ptr %next.gep158, align 16, !tbaa !9
  %wide.load162 = load <16 x i8>, ptr %179, align 16, !tbaa !9
  %180 = getelementptr i8, ptr %next.gep, i64 16
  %wide.load163 = load <16 x i8>, ptr %next.gep, align 1, !tbaa !9
  %wide.load164 = load <16 x i8>, ptr %180, align 1, !tbaa !9
  %181 = xor <16 x i8> %wide.load163, %wide.load
  %182 = xor <16 x i8> %wide.load164, %wide.load162
  %183 = getelementptr i8, ptr %next.gep160, i64 16
  store <16 x i8> %181, ptr %next.gep160, align 16, !tbaa !9
  store <16 x i8> %182, ptr %183, align 16, !tbaa !9
  %index.next = add nuw i64 %index, 32
  %184 = icmp eq i64 %index.next, %n.vec
  br i1 %184, label %middle.block, label %vector.body, !llvm.loop !14

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

vec.epilog.iter.check:                            ; preds = %middle.block
  %ind.end176 = getelementptr i8, ptr %12, i64 %n.vec
  %ind.end173 = getelementptr i8, ptr %10, i64 %n.vec
  %ind.end170 = getelementptr i8, ptr %.083.lcssa, i64 %n.vec
  %.cast167 = trunc i64 %n.vec to i32
  %ind.end168 = sub i32 %173, %.cast167
  %n.vec.remaining = and i64 %176, 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.vec166 = and i64 %176, 8589934584
  %.cast = trunc i64 %n.vec166 to i32
  %ind.end = sub i32 %173, %.cast
  %ind.end169 = getelementptr i8, ptr %.083.lcssa, i64 %n.vec166
  %ind.end172 = getelementptr i8, ptr %10, i64 %n.vec166
  %ind.end175 = getelementptr i8, ptr %12, i64 %n.vec166
  br label %vec.epilog.vector.body

vec.epilog.vector.body:                           ; preds = %vec.epilog.vector.body, %vec.epilog.ph
  %index178 = phi i64 [ %vec.epilog.resume.val, %vec.epilog.ph ], [ %index.next184, %vec.epilog.vector.body ]
  %next.gep179 = getelementptr i8, ptr %.083.lcssa, i64 %index178
  %next.gep180 = getelementptr i8, ptr %10, i64 %index178
  %next.gep181 = getelementptr i8, ptr %12, i64 %index178
  %wide.load182 = load <8 x i8>, ptr %next.gep180, align 8, !tbaa !9
  %wide.load183 = load <8 x i8>, ptr %next.gep179, align 1, !tbaa !9
  %185 = xor <8 x i8> %wide.load183, %wide.load182
  store <8 x i8> %185, ptr %next.gep181, align 8, !tbaa !9
  %index.next184 = add nuw i64 %index178, 8
  %186 = icmp eq i64 %index.next184, %n.vec166
  br i1 %186, label %vec.epilog.middle.block, label %vec.epilog.vector.body, !llvm.loop !17

vec.epilog.middle.block:                          ; preds = %vec.epilog.vector.body
  %cmp.n185 = icmp eq i64 %176, %n.vec166
  br i1 %cmp.n185, label %iter.check191, label %.lr.ph.preheader

.lr.ph.preheader:                                 ; preds = %vec.epilog.middle.block, %vector.memcheck, %iter.check, %vec.epilog.iter.check
  %.079127.ph = phi i32 [ %173, %iter.check ], [ %173, %vector.memcheck ], [ %ind.end168, %vec.epilog.iter.check ], [ %ind.end, %vec.epilog.middle.block ]
  %.080126.ph = phi ptr [ %.083.lcssa, %iter.check ], [ %.083.lcssa, %vector.memcheck ], [ %ind.end170, %vec.epilog.iter.check ], [ %ind.end169, %vec.epilog.middle.block ]
  %.081125.ph = phi ptr [ %10, %iter.check ], [ %10, %vector.memcheck ], [ %ind.end173, %vec.epilog.iter.check ], [ %ind.end172, %vec.epilog.middle.block ]
  %.082124.ph = phi ptr [ %12, %iter.check ], [ %12, %vector.memcheck ], [ %ind.end176, %vec.epilog.iter.check ], [ %ind.end175, %vec.epilog.middle.block ]
  %187 = add nsw i32 %.079127.ph, -1
  %xtraiter = and i32 %.079127.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
  %.079127.prol = phi i32 [ %194, %.lr.ph.prol ], [ %.079127.ph, %.lr.ph.preheader ]
  %.080126.prol = phi ptr [ %190, %.lr.ph.prol ], [ %.080126.ph, %.lr.ph.preheader ]
  %.081125.prol = phi ptr [ %188, %.lr.ph.prol ], [ %.081125.ph, %.lr.ph.preheader ]
  %.082124.prol = phi ptr [ %193, %.lr.ph.prol ], [ %.082124.ph, %.lr.ph.preheader ]
  %prol.iter = phi i32 [ %prol.iter.next, %.lr.ph.prol ], [ 0, %.lr.ph.preheader ]
  %188 = getelementptr inbounds i8, ptr %.081125.prol, i64 1
  %189 = load i8, ptr %.081125.prol, align 1, !tbaa !9
  %190 = getelementptr inbounds i8, ptr %.080126.prol, i64 1
  %191 = load i8, ptr %.080126.prol, align 1, !tbaa !9
  %192 = xor i8 %191, %189
  %193 = getelementptr inbounds i8, ptr %.082124.prol, i64 1
  store i8 %192, ptr %.082124.prol, align 1, !tbaa !9
  %194 = add nsw i32 %.079127.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
  %.079127.unr = phi i32 [ %.079127.ph, %.lr.ph.preheader ], [ %194, %.lr.ph.prol ]
  %.080126.unr = phi ptr [ %.080126.ph, %.lr.ph.preheader ], [ %190, %.lr.ph.prol ]
  %.081125.unr = phi ptr [ %.081125.ph, %.lr.ph.preheader ], [ %188, %.lr.ph.prol ]
  %.082124.unr = phi ptr [ %.082124.ph, %.lr.ph.preheader ], [ %193, %.lr.ph.prol ]
  %195 = icmp ult i32 %187, 3
  br i1 %195, label %iter.check191, label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.prol.loopexit, %.lr.ph
  %.079127 = phi i32 [ %220, %.lr.ph ], [ %.079127.unr, %.lr.ph.prol.loopexit ]
  %.080126 = phi ptr [ %216, %.lr.ph ], [ %.080126.unr, %.lr.ph.prol.loopexit ]
  %.081125 = phi ptr [ %214, %.lr.ph ], [ %.081125.unr, %.lr.ph.prol.loopexit ]
  %.082124 = phi ptr [ %219, %.lr.ph ], [ %.082124.unr, %.lr.ph.prol.loopexit ]
  %196 = getelementptr inbounds i8, ptr %.081125, i64 1
  %197 = load i8, ptr %.081125, align 1, !tbaa !9
  %198 = getelementptr inbounds i8, ptr %.080126, i64 1
  %199 = load i8, ptr %.080126, align 1, !tbaa !9
  %200 = xor i8 %199, %197
  %201 = getelementptr inbounds i8, ptr %.082124, i64 1
  store i8 %200, ptr %.082124, align 1, !tbaa !9
  %202 = getelementptr inbounds i8, ptr %.081125, i64 2
  %203 = load i8, ptr %196, align 1, !tbaa !9
  %204 = getelementptr inbounds i8, ptr %.080126, i64 2
  %205 = load i8, ptr %198, align 1, !tbaa !9
  %206 = xor i8 %205, %203
  %207 = getelementptr inbounds i8, ptr %.082124, i64 2
  store i8 %206, ptr %201, align 1, !tbaa !9
  %208 = getelementptr inbounds i8, ptr %.081125, i64 3
  %209 = load i8, ptr %202, align 1, !tbaa !9
  %210 = getelementptr inbounds i8, ptr %.080126, i64 3
  %211 = load i8, ptr %204, align 1, !tbaa !9
  %212 = xor i8 %211, %209
  %213 = getelementptr inbounds i8, ptr %.082124, i64 3
  store i8 %212, ptr %207, align 1, !tbaa !9
  %214 = getelementptr inbounds i8, ptr %.081125, i64 4
  %215 = load i8, ptr %208, align 1, !tbaa !9
  %216 = getelementptr inbounds i8, ptr %.080126, i64 4
  %217 = load i8, ptr %210, align 1, !tbaa !9
  %218 = xor i8 %217, %215
  %219 = getelementptr inbounds i8, ptr %.082124, i64 4
  store i8 %218, ptr %213, align 1, !tbaa !9
  %220 = add nsw i32 %.079127, -4
  %.not102.3 = icmp eq i32 %220, 0
  br i1 %.not102.3, label %iter.check191, label %.lr.ph, !llvm.loop !20

iter.check191:                                    ; preds = %.lr.ph.prol.loopexit, %.lr.ph, %vec.epilog.middle.block, %middle.block
  %221 = getelementptr inbounds i8, ptr %10, i64 44
  %222 = load i32, ptr %221, align 4, !tbaa !10
  %223 = xor i32 %222, 167772160
  store i32 %223, ptr %221, align 4, !tbaa !10
  %224 = getelementptr inbounds i8, ptr %10, i64 12
  %225 = getelementptr inbounds i8, ptr %10, i64 36
  %226 = load <2 x i32>, ptr %224, align 4, !tbaa !10
  %227 = load <2 x i32>, ptr %15, align 8, !tbaa !10
  %228 = xor <2 x i32> %227, %226
  %229 = load <2 x i32>, ptr %10, align 16, !tbaa !10
  store <2 x i32> %228, ptr %10, align 16, !tbaa !10
  %230 = load <2 x i32>, ptr %225, align 4, !tbaa !10
  %231 = xor <2 x i32> %229, %230
  %232 = xor <2 x i32> %231, %226
  store <2 x i32> %232, ptr %224, align 4, !tbaa !10
  %233 = getelementptr inbounds i8, ptr %10, i64 8
  %234 = load i32, ptr %233, align 8, !tbaa !10
  %235 = getelementptr inbounds i8, ptr %10, i64 20
  %236 = load i32, ptr %235, align 4, !tbaa !10
  %237 = getelementptr inbounds i8, ptr %10, i64 32
  %238 = load i32, ptr %237, align 16, !tbaa !10
  %239 = xor i32 %238, %236
  store i32 %239, ptr %233, align 8, !tbaa !10
  %240 = xor i32 %234, %223
  %241 = xor i32 %240, %236
  store i32 %241, ptr %235, align 4, !tbaa !10
  %242 = add nuw nsw i64 %.087.lcssa, 4294967295
  %243 = and i64 %242, 4294967295
  %244 = add nuw nsw i64 %243, 1
  %min.iters.check189 = icmp ult i64 %243, 7
  br i1 %min.iters.check189, label %.lr.ph135.preheader, label %vector.memcheck186

vector.memcheck186:                               ; preds = %iter.check191
  %245 = add nuw nsw i64 %.087.lcssa, 4294967295
  %246 = and i64 %245, 4294967295
  %247 = add nuw nsw i64 %246, 1
  %scevgep = getelementptr i8, ptr %10, i64 %247
  %scevgep187 = getelementptr i8, ptr %.083.lcssa, i64 %247
  %bound0 = icmp ult ptr %10, %scevgep187
  %bound1 = icmp ult ptr %.083.lcssa, %scevgep
  %found.conflict = and i1 %bound0, %bound1
  br i1 %found.conflict, label %.lr.ph135.preheader, label %vector.main.loop.iter.check193

vector.main.loop.iter.check193:                   ; preds = %vector.memcheck186
  %min.iters.check192 = icmp ult i64 %243, 31
  br i1 %min.iters.check192, label %vec.epilog.ph211, label %vector.ph194

vector.ph194:                                     ; preds = %vector.main.loop.iter.check193
  %n.vec196 = and i64 %244, 8589934560
  br label %vector.body197

vector.body197:                                   ; preds = %vector.body197, %vector.ph194
  %index198 = phi i64 [ 0, %vector.ph194 ], [ %index.next207, %vector.body197 ]
  %next.gep199 = getelementptr i8, ptr %.083.lcssa, i64 %index198
  %next.gep201 = getelementptr i8, ptr %10, i64 %index198
  %248 = getelementptr i8, ptr %next.gep199, i64 16
  %wide.load203 = load <16 x i8>, ptr %next.gep199, align 1, !tbaa !9, !alias.scope !21
  %wide.load204 = load <16 x i8>, ptr %248, align 1, !tbaa !9, !alias.scope !21
  %249 = getelementptr i8, ptr %next.gep201, i64 16
  %wide.load205 = load <16 x i8>, ptr %next.gep201, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %wide.load206 = load <16 x i8>, ptr %249, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %250 = xor <16 x i8> %wide.load205, %wide.load203
  %251 = xor <16 x i8> %wide.load206, %wide.load204
  store <16 x i8> %250, ptr %next.gep201, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  store <16 x i8> %251, ptr %249, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %index.next207 = add nuw i64 %index198, 32
  %252 = icmp eq i64 %index.next207, %n.vec196
  br i1 %252, label %middle.block188, label %vector.body197, !llvm.loop !26

middle.block188:                                  ; preds = %vector.body197
  %cmp.n208 = icmp eq i64 %244, %n.vec196
  br i1 %cmp.n208, label %._crit_edge136, label %vec.epilog.iter.check212

vec.epilog.iter.check212:                         ; preds = %middle.block188
  %ind.end227 = getelementptr i8, ptr %10, i64 %n.vec196
  %ind.end224 = getelementptr i8, ptr %.083.lcssa, i64 %n.vec196
  %.cast220 = trunc i64 %n.vec196 to i32
  %ind.end221 = sub i32 %173, %.cast220
  %n.vec.remaining213 = and i64 %244, 24
  %min.epilog.iters.check214 = icmp eq i64 %n.vec.remaining213, 0
  br i1 %min.epilog.iters.check214, label %.lr.ph135.preheader, label %vec.epilog.ph211

vec.epilog.ph211:                                 ; preds = %vector.main.loop.iter.check193, %vec.epilog.iter.check212
  %vec.epilog.resume.val215 = phi i64 [ %n.vec196, %vec.epilog.iter.check212 ], [ 0, %vector.main.loop.iter.check193 ]
  %n.vec217 = and i64 %244, 8589934584
  %.cast218 = trunc i64 %n.vec217 to i32
  %ind.end219 = sub i32 %173, %.cast218
  %ind.end223 = getelementptr i8, ptr %.083.lcssa, i64 %n.vec217
  %ind.end226 = getelementptr i8, ptr %10, i64 %n.vec217
  br label %vec.epilog.vector.body229

vec.epilog.vector.body229:                        ; preds = %vec.epilog.vector.body229, %vec.epilog.ph211
  %index230 = phi i64 [ %vec.epilog.resume.val215, %vec.epilog.ph211 ], [ %index.next235, %vec.epilog.vector.body229 ]
  %next.gep231 = getelementptr i8, ptr %.083.lcssa, i64 %index230
  %next.gep232 = getelementptr i8, ptr %10, i64 %index230
  %wide.load233 = load <8 x i8>, ptr %next.gep231, align 1, !tbaa !9, !alias.scope !27
  %wide.load234 = load <8 x i8>, ptr %next.gep232, align 8, !tbaa !9, !alias.scope !30, !noalias !27
  %253 = xor <8 x i8> %wide.load234, %wide.load233
  store <8 x i8> %253, ptr %next.gep232, align 8, !tbaa !9, !alias.scope !30, !noalias !27
  %index.next235 = add nuw i64 %index230, 8
  %254 = icmp eq i64 %index.next235, %n.vec217
  br i1 %254, label %vec.epilog.middle.block209, label %vec.epilog.vector.body229, !llvm.loop !32

vec.epilog.middle.block209:                       ; preds = %vec.epilog.vector.body229
  %cmp.n236 = icmp eq i64 %244, %n.vec217
  br i1 %cmp.n236, label %._crit_edge136, label %.lr.ph135.preheader

.lr.ph135.preheader:                              ; preds = %vec.epilog.middle.block209, %vector.memcheck186, %iter.check191, %vec.epilog.iter.check212
  %.075133.ph = phi i32 [ %173, %iter.check191 ], [ %173, %vector.memcheck186 ], [ %ind.end221, %vec.epilog.iter.check212 ], [ %ind.end219, %vec.epilog.middle.block209 ]
  %.076132.ph = phi ptr [ %.083.lcssa, %iter.check191 ], [ %.083.lcssa, %vector.memcheck186 ], [ %ind.end224, %vec.epilog.iter.check212 ], [ %ind.end223, %vec.epilog.middle.block209 ]
  %.077131.ph = phi ptr [ %10, %iter.check191 ], [ %10, %vector.memcheck186 ], [ %ind.end227, %vec.epilog.iter.check212 ], [ %ind.end226, %vec.epilog.middle.block209 ]
  %255 = add nsw i32 %.075133.ph, -1
  %xtraiter239 = and i32 %.075133.ph, 3
  %lcmp.mod240.not = icmp eq i32 %xtraiter239, 0
  br i1 %lcmp.mod240.not, label %.lr.ph135.prol.loopexit, label %.lr.ph135.prol

.lr.ph135.prol:                                   ; preds = %.lr.ph135.preheader, %.lr.ph135.prol
  %.075133.prol = phi i32 [ %261, %.lr.ph135.prol ], [ %.075133.ph, %.lr.ph135.preheader ]
  %.076132.prol = phi ptr [ %256, %.lr.ph135.prol ], [ %.076132.ph, %.lr.ph135.preheader ]
  %.077131.prol = phi ptr [ %258, %.lr.ph135.prol ], [ %.077131.ph, %.lr.ph135.preheader ]
  %prol.iter241 = phi i32 [ %prol.iter241.next, %.lr.ph135.prol ], [ 0, %.lr.ph135.preheader ]
  %256 = getelementptr inbounds i8, ptr %.076132.prol, i64 1
  %257 = load i8, ptr %.076132.prol, align 1, !tbaa !9
  %258 = getelementptr inbounds i8, ptr %.077131.prol, i64 1
  %259 = load i8, ptr %.077131.prol, align 1, !tbaa !9
  %260 = xor i8 %259, %257
  store i8 %260, ptr %.077131.prol, align 1, !tbaa !9
  %261 = add nsw i32 %.075133.prol, -1
  %prol.iter241.next = add i32 %prol.iter241, 1
  %prol.iter241.cmp.not = icmp eq i32 %prol.iter241.next, %xtraiter239
  br i1 %prol.iter241.cmp.not, label %.lr.ph135.prol.loopexit, label %.lr.ph135.prol, !llvm.loop !33

.lr.ph135.prol.loopexit:                          ; preds = %.lr.ph135.prol, %.lr.ph135.preheader
  %.075133.unr = phi i32 [ %.075133.ph, %.lr.ph135.preheader ], [ %261, %.lr.ph135.prol ]
  %.076132.unr = phi ptr [ %.076132.ph, %.lr.ph135.preheader ], [ %256, %.lr.ph135.prol ]
  %.077131.unr = phi ptr [ %.077131.ph, %.lr.ph135.preheader ], [ %258, %.lr.ph135.prol ]
  %262 = icmp ult i32 %255, 3
  br i1 %262, label %._crit_edge136, label %.lr.ph135

.lr.ph135:                                        ; preds = %.lr.ph135.prol.loopexit, %.lr.ph135
  %.075133 = phi i32 [ %283, %.lr.ph135 ], [ %.075133.unr, %.lr.ph135.prol.loopexit ]
  %.076132 = phi ptr [ %278, %.lr.ph135 ], [ %.076132.unr, %.lr.ph135.prol.loopexit ]
  %.077131 = phi ptr [ %280, %.lr.ph135 ], [ %.077131.unr, %.lr.ph135.prol.loopexit ]
  %263 = getelementptr inbounds i8, ptr %.076132, i64 1
  %264 = load i8, ptr %.076132, align 1, !tbaa !9
  %265 = getelementptr inbounds i8, ptr %.077131, i64 1
  %266 = load i8, ptr %.077131, align 1, !tbaa !9
  %267 = xor i8 %266, %264
  store i8 %267, ptr %.077131, align 1, !tbaa !9
  %268 = getelementptr inbounds i8, ptr %.076132, i64 2
  %269 = load i8, ptr %263, align 1, !tbaa !9
  %270 = getelementptr inbounds i8, ptr %.077131, i64 2
  %271 = load i8, ptr %265, align 1, !tbaa !9
  %272 = xor i8 %271, %269
  store i8 %272, ptr %265, align 1, !tbaa !9
  %273 = getelementptr inbounds i8, ptr %.076132, i64 3
  %274 = load i8, ptr %268, align 1, !tbaa !9
  %275 = getelementptr inbounds i8, ptr %.077131, i64 3
  %276 = load i8, ptr %270, align 1, !tbaa !9
  %277 = xor i8 %276, %274
  store i8 %277, ptr %270, align 1, !tbaa !9
  %278 = getelementptr inbounds i8, ptr %.076132, i64 4
  %279 = load i8, ptr %273, align 1, !tbaa !9
  %280 = getelementptr inbounds i8, ptr %.077131, i64 4
  %281 = load i8, ptr %275, align 1, !tbaa !9
  %282 = xor i8 %281, %279
  store i8 %282, ptr %275, align 1, !tbaa !9
  %283 = add nsw i32 %.075133, -4
  %.not103.3 = icmp eq i32 %283, 0
  br i1 %.not103.3, label %._crit_edge136, label %.lr.ph135, !llvm.loop !34

._crit_edge136:                                   ; preds = %.lr.ph135.prol.loopexit, %.lr.ph135, %vec.epilog.middle.block209, %middle.block188
  %284 = getelementptr inbounds i8, ptr %10, i64 %.087.lcssa
  %285 = load i8, ptr %284, align 1, !tbaa !9
  %286 = xor i8 %285, -128
  store i8 %286, ptr %284, align 1, !tbaa !9
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %.078.lcssa, ptr nonnull align 16 %12, i64 %.087.lcssa, i1 false)
  br label %287

287:                                              ; preds = %._crit_edge136, %.preheader.preheader
  call void @sparkle_384(ptr noundef nonnull %10, i32 noundef 11) #4
  %288 = getelementptr inbounds i8, ptr %.078.lcssa, i64 %.087.lcssa
  br label %289

289:                                              ; preds = %17, %287
  %.1 = phi ptr [ %288, %287 ], [ %0, %17 ]
  %290 = getelementptr inbounds i8, ptr %10, i64 25
  %291 = load i8, ptr %15, align 8, !tbaa !9
  %292 = getelementptr inbounds i8, ptr %8, i64 1
  %293 = load i8, ptr %8, align 1, !tbaa !9
  %294 = xor i8 %293, %291
  %295 = getelementptr inbounds i8, ptr %.1, i64 1
  store i8 %294, ptr %.1, align 1, !tbaa !9
  %296 = getelementptr inbounds i8, ptr %10, i64 26
  %297 = load i8, ptr %290, align 1, !tbaa !9
  %298 = getelementptr inbounds i8, ptr %8, i64 2
  %299 = load i8, ptr %292, align 1, !tbaa !9
  %300 = xor i8 %299, %297
  %301 = getelementptr inbounds i8, ptr %.1, i64 2
  store i8 %300, ptr %295, align 1, !tbaa !9
  %302 = getelementptr inbounds i8, ptr %10, i64 27
  %303 = load i8, ptr %296, align 2, !tbaa !9
  %304 = getelementptr inbounds i8, ptr %8, i64 3
  %305 = load i8, ptr %298, align 1, !tbaa !9
  %306 = xor i8 %305, %303
  %307 = getelementptr inbounds i8, ptr %.1, i64 3
  store i8 %306, ptr %301, align 1, !tbaa !9
  %308 = getelementptr inbounds i8, ptr %10, i64 28
  %309 = load i8, ptr %302, align 1, !tbaa !9
  %310 = getelementptr inbounds i8, ptr %8, i64 4
  %311 = load i8, ptr %304, align 1, !tbaa !9
  %312 = xor i8 %311, %309
  %313 = getelementptr inbounds i8, ptr %.1, i64 4
  store i8 %312, ptr %307, align 1, !tbaa !9
  %314 = getelementptr inbounds i8, ptr %10, i64 29
  %315 = load i8, ptr %308, align 4, !tbaa !9
  %316 = getelementptr inbounds i8, ptr %8, i64 5
  %317 = load i8, ptr %310, align 1, !tbaa !9
  %318 = xor i8 %317, %315
  %319 = getelementptr inbounds i8, ptr %.1, i64 5
  store i8 %318, ptr %313, align 1, !tbaa !9
  %320 = getelementptr inbounds i8, ptr %10, i64 30
  %321 = load i8, ptr %314, align 1, !tbaa !9
  %322 = getelementptr inbounds i8, ptr %8, i64 6
  %323 = load i8, ptr %316, align 1, !tbaa !9
  %324 = xor i8 %323, %321
  %325 = getelementptr inbounds i8, ptr %.1, i64 6
  store i8 %324, ptr %319, align 1, !tbaa !9
  %326 = getelementptr inbounds i8, ptr %10, i64 31
  %327 = load i8, ptr %320, align 2, !tbaa !9
  %328 = getelementptr inbounds i8, ptr %8, i64 7
  %329 = load i8, ptr %322, align 1, !tbaa !9
  %330 = xor i8 %329, %327
  %331 = getelementptr inbounds i8, ptr %.1, i64 7
  store i8 %330, ptr %325, align 1, !tbaa !9
  %332 = getelementptr inbounds i8, ptr %10, i64 32
  %333 = load i8, ptr %326, align 1, !tbaa !9
  %334 = getelementptr inbounds i8, ptr %8, i64 8
  %335 = load i8, ptr %328, align 1, !tbaa !9
  %336 = xor i8 %335, %333
  %337 = getelementptr inbounds i8, ptr %.1, i64 8
  store i8 %336, ptr %331, align 1, !tbaa !9
  %338 = getelementptr inbounds i8, ptr %10, i64 33
  %339 = load i8, ptr %332, align 16, !tbaa !9
  %340 = getelementptr inbounds i8, ptr %8, i64 9
  %341 = load i8, ptr %334, align 1, !tbaa !9
  %342 = xor i8 %341, %339
  %343 = getelementptr inbounds i8, ptr %.1, i64 9
  store i8 %342, ptr %337, align 1, !tbaa !9
  %344 = getelementptr inbounds i8, ptr %10, i64 34
  %345 = load i8, ptr %338, align 1, !tbaa !9
  %346 = getelementptr inbounds i8, ptr %8, i64 10
  %347 = load i8, ptr %340, align 1, !tbaa !9
  %348 = xor i8 %347, %345
  %349 = getelementptr inbounds i8, ptr %.1, i64 10
  store i8 %348, ptr %343, align 1, !tbaa !9
  %350 = getelementptr inbounds i8, ptr %10, i64 35
  %351 = load i8, ptr %344, align 2, !tbaa !9
  %352 = getelementptr inbounds i8, ptr %8, i64 11
  %353 = load i8, ptr %346, align 1, !tbaa !9
  %354 = xor i8 %353, %351
  %355 = getelementptr inbounds i8, ptr %.1, i64 11
  store i8 %354, ptr %349, align 1, !tbaa !9
  %356 = getelementptr inbounds i8, ptr %10, i64 36
  %357 = load i8, ptr %350, align 1, !tbaa !9
  %358 = getelementptr inbounds i8, ptr %8, i64 12
  %359 = load i8, ptr %352, align 1, !tbaa !9
  %360 = xor i8 %359, %357
  %361 = getelementptr inbounds i8, ptr %.1, i64 12
  store i8 %360, ptr %355, align 1, !tbaa !9
  %362 = getelementptr inbounds i8, ptr %10, i64 37
  %363 = load i8, ptr %356, align 4, !tbaa !9
  %364 = getelementptr inbounds i8, ptr %8, i64 13
  %365 = load i8, ptr %358, align 1, !tbaa !9
  %366 = xor i8 %365, %363
  %367 = getelementptr inbounds i8, ptr %.1, i64 13
  store i8 %366, ptr %361, align 1, !tbaa !9
  %368 = getelementptr inbounds i8, ptr %10, i64 38
  %369 = load i8, ptr %362, align 1, !tbaa !9
  %370 = getelementptr inbounds i8, ptr %8, i64 14
  %371 = load i8, ptr %364, align 1, !tbaa !9
  %372 = xor i8 %371, %369
  %373 = getelementptr inbounds i8, ptr %.1, i64 14
  store i8 %372, ptr %367, align 1, !tbaa !9
  %374 = getelementptr inbounds i8, ptr %10, i64 39
  %375 = load i8, ptr %368, align 2, !tbaa !9
  %376 = getelementptr inbounds i8, ptr %8, i64 15
  %377 = load i8, ptr %370, align 1, !tbaa !9
  %378 = xor i8 %377, %375
  %379 = getelementptr inbounds i8, ptr %.1, i64 15
  store i8 %378, ptr %373, align 1, !tbaa !9
  %380 = getelementptr inbounds i8, ptr %10, i64 40
  %381 = load i8, ptr %374, align 1, !tbaa !9
  %382 = getelementptr inbounds i8, ptr %8, i64 16
  %383 = load i8, ptr %376, align 1, !tbaa !9
  %384 = xor i8 %383, %381
  %385 = getelementptr inbounds i8, ptr %.1, i64 16
  store i8 %384, ptr %379, align 1, !tbaa !9
  %386 = getelementptr inbounds i8, ptr %10, i64 41
  %387 = load i8, ptr %380, align 8, !tbaa !9
  %388 = getelementptr inbounds i8, ptr %8, i64 17
  %389 = load i8, ptr %382, align 1, !tbaa !9
  %390 = xor i8 %389, %387
  %391 = getelementptr inbounds i8, ptr %.1, i64 17
  store i8 %390, ptr %385, align 1, !tbaa !9
  %392 = getelementptr inbounds i8, ptr %10, i64 42
  %393 = load i8, ptr %386, align 1, !tbaa !9
  %394 = getelementptr inbounds i8, ptr %8, i64 18
  %395 = load i8, ptr %388, align 1, !tbaa !9
  %396 = xor i8 %395, %393
  %397 = getelementptr inbounds i8, ptr %.1, i64 18
  store i8 %396, ptr %391, align 1, !tbaa !9
  %398 = getelementptr inbounds i8, ptr %10, i64 43
  %399 = load i8, ptr %392, align 2, !tbaa !9
  %400 = getelementptr inbounds i8, ptr %8, i64 19
  %401 = load i8, ptr %394, align 1, !tbaa !9
  %402 = xor i8 %401, %399
  %403 = getelementptr inbounds i8, ptr %.1, i64 19
  store i8 %402, ptr %397, align 1, !tbaa !9
  %404 = getelementptr inbounds i8, ptr %10, i64 44
  %405 = load i8, ptr %398, align 1, !tbaa !9
  %406 = getelementptr inbounds i8, ptr %8, i64 20
  %407 = load i8, ptr %400, align 1, !tbaa !9
  %408 = xor i8 %407, %405
  %409 = getelementptr inbounds i8, ptr %.1, i64 20
  store i8 %408, ptr %403, align 1, !tbaa !9
  %410 = getelementptr inbounds i8, ptr %10, i64 45
  %411 = load i8, ptr %404, align 4, !tbaa !9
  %412 = getelementptr inbounds i8, ptr %8, i64 21
  %413 = load i8, ptr %406, align 1, !tbaa !9
  %414 = xor i8 %413, %411
  %415 = getelementptr inbounds i8, ptr %.1, i64 21
  store i8 %414, ptr %409, align 1, !tbaa !9
  %416 = getelementptr inbounds i8, ptr %10, i64 46
  %417 = load i8, ptr %410, align 1, !tbaa !9
  %418 = getelementptr inbounds i8, ptr %8, i64 22
  %419 = load i8, ptr %412, align 1, !tbaa !9
  %420 = xor i8 %419, %417
  %421 = getelementptr inbounds i8, ptr %.1, i64 22
  store i8 %420, ptr %415, align 1, !tbaa !9
  %422 = getelementptr inbounds i8, ptr %10, i64 47
  %423 = load i8, ptr %416, align 2, !tbaa !9
  %424 = getelementptr inbounds i8, ptr %8, i64 23
  %425 = load i8, ptr %418, align 1, !tbaa !9
  %426 = xor i8 %425, %423
  %427 = getelementptr inbounds i8, ptr %.1, i64 23
  store i8 %426, ptr %421, align 1, !tbaa !9
  %428 = load i8, ptr %422, align 1, !tbaa !9
  %429 = load i8, ptr %424, align 1, !tbaa !9
  %430 = xor i8 %429, %428
  store i8 %430, ptr %427, align 1, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 24, 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: mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #1

; Function Attrs: nounwind uwtable
declare hidden void @schwaemm_192_192_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