; 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_decrypt(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, i64 noundef %4, ptr noundef %5, i64 noundef %6, ptr noundef %7, ptr noundef %8) #0 {
  %10 = alloca i32, align 4
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca ptr, align 8
  %15 = alloca i64, align 8
  %16 = alloca ptr, align 8
  %17 = alloca i64, align 8
  %18 = alloca ptr, align 8
  %19 = alloca ptr, align 8
  %20 = alloca [12 x i32], align 16
  %21 = alloca ptr, align 8
  %22 = alloca i32, align 4
  %23 = alloca ptr, align 8
  %24 = alloca ptr, align 8
  %25 = alloca ptr, align 8
  %26 = alloca i32, align 4
  %27 = alloca i32, align 4
  %28 = alloca ptr, align 8
  %29 = alloca ptr, align 8
  %30 = alloca i32, align 4
  %31 = alloca ptr, align 8
  %32 = alloca ptr, align 8
  %33 = alloca ptr, align 8
  %34 = alloca i32, align 4
  %35 = alloca i32, align 4
  %36 = alloca ptr, align 8
  %37 = alloca ptr, align 8
  %38 = alloca i32, align 4
  %39 = alloca i32, align 4
  %40 = alloca ptr, align 8
  %41 = alloca ptr, align 8
  %42 = alloca ptr, align 8
  %43 = alloca i32, align 4
  %44 = alloca i32, align 4
  %45 = alloca ptr, align 8
  %46 = alloca ptr, align 8
  %47 = alloca i32, align 4
  %48 = alloca ptr, align 8
  %49 = alloca ptr, align 8
  %50 = alloca i32, align 4
  store ptr %0, ptr %11, align 8, !tbaa !5
  store ptr %1, ptr %12, align 8, !tbaa !5
  store ptr %2, ptr %13, align 8, !tbaa !5
  store ptr %3, ptr %14, align 8, !tbaa !5
  store i64 %4, ptr %15, align 8, !tbaa !9
  store ptr %5, ptr %16, align 8, !tbaa !5
  store i64 %6, ptr %17, align 8, !tbaa !9
  store ptr %7, ptr %18, align 8, !tbaa !5
  store ptr %8, ptr %19, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 48, ptr %20) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #4
  %51 = load ptr, ptr %11, align 8, !tbaa !5
  store ptr %51, ptr %21, align 8, !tbaa !5
  %52 = load ptr, ptr %13, align 8, !tbaa !5
  %53 = load i64, ptr %15, align 8, !tbaa !9
  %54 = icmp ult i64 %53, 16
  br i1 %54, label %55, label %56

55:                                               ; preds = %9
  store i32 -1, ptr %10, align 4
  store i32 1, ptr %22, align 4
  br label %478

56:                                               ; preds = %9
  %57 = load i64, ptr %15, align 8, !tbaa !9
  %58 = sub i64 %57, 16
  %59 = load ptr, ptr %12, align 8, !tbaa !5
  store i64 %58, ptr %59, align 8, !tbaa !9
  %60 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  %61 = load ptr, ptr %18, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %60, ptr align 1 %61, i64 32, i1 false)
  %62 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  %63 = getelementptr inbounds i8, ptr %62, i64 32
  %64 = load ptr, ptr %19, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %63, ptr align 1 %64, i64 16, i1 false)
  %65 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  call void @sparkle_384(ptr noundef %65, i32 noundef 11)
  %66 = load i64, ptr %17, align 8, !tbaa !9
  %67 = icmp ugt i64 %66, 0
  br i1 %67, label %68, label %72

68:                                               ; preds = %56
  %69 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  %70 = load ptr, ptr %16, align 8, !tbaa !5
  %71 = load i64, ptr %17, align 8, !tbaa !9
  call void @schwaemm_256_128_authenticate(ptr noundef %69, ptr noundef %70, i64 noundef %71)
  br label %72

72:                                               ; preds = %68, %56
  %73 = load i64, ptr %15, align 8, !tbaa !9
  %74 = sub i64 %73, 16
  store i64 %74, ptr %15, align 8, !tbaa !9
  %75 = load i64, ptr %15, align 8, !tbaa !9
  %76 = icmp ugt i64 %75, 0
  br i1 %76, label %77, label %447

77:                                               ; preds = %72
  br label %78

78:                                               ; preds = %191, %77
  %79 = load i64, ptr %15, align 8, !tbaa !9
  %80 = icmp ugt i64 %79, 32
  br i1 %80, label %81, label %199

81:                                               ; preds = %78
  br label %82

82:                                               ; preds = %81
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #4
  %83 = load ptr, ptr %11, align 8, !tbaa !5
  store ptr %83, ptr %23, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #4
  %84 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  store ptr %84, ptr %24, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #4
  %85 = load ptr, ptr %14, align 8, !tbaa !5
  store ptr %85, ptr %25, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #4
  store i32 32, ptr %26, align 4, !tbaa !11
  br label %86

86:                                               ; preds = %89, %82
  %87 = load i32, ptr %26, align 4, !tbaa !11
  %88 = icmp ugt i32 %87, 0
  br i1 %88, label %89, label %104

89:                                               ; preds = %86
  %90 = load ptr, ptr %24, align 8, !tbaa !5
  %91 = getelementptr inbounds i8, ptr %90, i32 1
  store ptr %91, ptr %24, align 8, !tbaa !5
  %92 = load i8, ptr %90, align 1, !tbaa !13
  %93 = zext i8 %92 to i32
  %94 = load ptr, ptr %25, align 8, !tbaa !5
  %95 = getelementptr inbounds i8, ptr %94, i32 1
  store ptr %95, ptr %25, align 8, !tbaa !5
  %96 = load i8, ptr %94, align 1, !tbaa !13
  %97 = zext i8 %96 to i32
  %98 = xor i32 %93, %97
  %99 = trunc i32 %98 to i8
  %100 = load ptr, ptr %23, align 8, !tbaa !5
  %101 = getelementptr inbounds i8, ptr %100, i32 1
  store ptr %101, ptr %23, align 8, !tbaa !5
  store i8 %99, ptr %100, align 1, !tbaa !13
  %102 = load i32, ptr %26, align 4, !tbaa !11
  %103 = add i32 %102, -1
  store i32 %103, ptr %26, align 4, !tbaa !11
  br label %86, !llvm.loop !14

104:                                              ; preds = %86
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #4
  br label %105

105:                                              ; preds = %104
  br label %106

106:                                              ; preds = %105
  br label %107

107:                                              ; preds = %106
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #4
  %108 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  %109 = load i32, ptr %108, align 16, !tbaa !11
  store i32 %109, ptr %27, align 4, !tbaa !11
  %110 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 4
  %111 = load i32, ptr %110, align 16, !tbaa !11
  %112 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 8
  %113 = load i32, ptr %112, align 16, !tbaa !11
  %114 = xor i32 %111, %113
  %115 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  store i32 %114, ptr %115, align 16, !tbaa !11
  %116 = load i32, ptr %27, align 4, !tbaa !11
  %117 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 8
  %118 = load i32, ptr %117, align 16, !tbaa !11
  %119 = xor i32 %116, %118
  %120 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 4
  %121 = load i32, ptr %120, align 16, !tbaa !11
  %122 = xor i32 %121, %119
  store i32 %122, ptr %120, align 16, !tbaa !11
  %123 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 1
  %124 = load i32, ptr %123, align 4, !tbaa !11
  store i32 %124, ptr %27, align 4, !tbaa !11
  %125 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 5
  %126 = load i32, ptr %125, align 4, !tbaa !11
  %127 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 9
  %128 = load i32, ptr %127, align 4, !tbaa !11
  %129 = xor i32 %126, %128
  %130 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 1
  store i32 %129, ptr %130, align 4, !tbaa !11
  %131 = load i32, ptr %27, align 4, !tbaa !11
  %132 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 9
  %133 = load i32, ptr %132, align 4, !tbaa !11
  %134 = xor i32 %131, %133
  %135 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 5
  %136 = load i32, ptr %135, align 4, !tbaa !11
  %137 = xor i32 %136, %134
  store i32 %137, ptr %135, align 4, !tbaa !11
  %138 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 2
  %139 = load i32, ptr %138, align 8, !tbaa !11
  store i32 %139, ptr %27, align 4, !tbaa !11
  %140 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 6
  %141 = load i32, ptr %140, align 8, !tbaa !11
  %142 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 10
  %143 = load i32, ptr %142, align 8, !tbaa !11
  %144 = xor i32 %141, %143
  %145 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 2
  store i32 %144, ptr %145, align 8, !tbaa !11
  %146 = load i32, ptr %27, align 4, !tbaa !11
  %147 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 10
  %148 = load i32, ptr %147, align 8, !tbaa !11
  %149 = xor i32 %146, %148
  %150 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 6
  %151 = load i32, ptr %150, align 8, !tbaa !11
  %152 = xor i32 %151, %149
  store i32 %152, ptr %150, align 8, !tbaa !11
  %153 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 3
  %154 = load i32, ptr %153, align 4, !tbaa !11
  store i32 %154, ptr %27, align 4, !tbaa !11
  %155 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 7
  %156 = load i32, ptr %155, align 4, !tbaa !11
  %157 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 11
  %158 = load i32, ptr %157, align 4, !tbaa !11
  %159 = xor i32 %156, %158
  %160 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 3
  store i32 %159, ptr %160, align 4, !tbaa !11
  %161 = load i32, ptr %27, align 4, !tbaa !11
  %162 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 11
  %163 = load i32, ptr %162, align 4, !tbaa !11
  %164 = xor i32 %161, %163
  %165 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 7
  %166 = load i32, ptr %165, align 4, !tbaa !11
  %167 = xor i32 %166, %164
  store i32 %167, ptr %165, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #4
  br label %168

168:                                              ; preds = %107
  br label %169

169:                                              ; preds = %168
  br label %170

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

173:                                              ; preds = %176, %170
  %174 = load i32, ptr %30, align 4, !tbaa !11
  %175 = icmp ugt i32 %174, 0
  br i1 %175, label %176, label %189

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

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

190:                                              ; preds = %189
  br label %191

191:                                              ; preds = %190
  %192 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  call void @sparkle_384(ptr noundef %192, i32 noundef 7)
  %193 = load ptr, ptr %14, align 8, !tbaa !5
  %194 = getelementptr inbounds i8, ptr %193, i64 32
  store ptr %194, ptr %14, align 8, !tbaa !5
  %195 = load ptr, ptr %11, align 8, !tbaa !5
  %196 = getelementptr inbounds i8, ptr %195, i64 32
  store ptr %196, ptr %11, align 8, !tbaa !5
  %197 = load i64, ptr %15, align 8, !tbaa !9
  %198 = sub i64 %197, 32
  store i64 %198, ptr %15, align 8, !tbaa !9
  br label %78, !llvm.loop !17

199:                                              ; preds = %78
  %200 = load i64, ptr %15, align 8, !tbaa !9
  %201 = icmp eq i64 %200, 32
  br i1 %201, label %202, label %316

202:                                              ; preds = %199
  br label %203

203:                                              ; preds = %202
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #4
  %204 = load ptr, ptr %11, align 8, !tbaa !5
  store ptr %204, ptr %31, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #4
  %205 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  store ptr %205, ptr %32, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #4
  %206 = load ptr, ptr %14, align 8, !tbaa !5
  store ptr %206, ptr %33, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #4
  store i32 32, ptr %34, align 4, !tbaa !11
  br label %207

207:                                              ; preds = %210, %203
  %208 = load i32, ptr %34, align 4, !tbaa !11
  %209 = icmp ugt i32 %208, 0
  br i1 %209, label %210, label %225

210:                                              ; preds = %207
  %211 = load ptr, ptr %32, align 8, !tbaa !5
  %212 = getelementptr inbounds i8, ptr %211, i32 1
  store ptr %212, ptr %32, align 8, !tbaa !5
  %213 = load i8, ptr %211, align 1, !tbaa !13
  %214 = zext i8 %213 to i32
  %215 = load ptr, ptr %33, align 8, !tbaa !5
  %216 = getelementptr inbounds i8, ptr %215, i32 1
  store ptr %216, ptr %33, align 8, !tbaa !5
  %217 = load i8, ptr %215, align 1, !tbaa !13
  %218 = zext i8 %217 to i32
  %219 = xor i32 %214, %218
  %220 = trunc i32 %219 to i8
  %221 = load ptr, ptr %31, align 8, !tbaa !5
  %222 = getelementptr inbounds i8, ptr %221, i32 1
  store ptr %222, ptr %31, align 8, !tbaa !5
  store i8 %220, ptr %221, align 1, !tbaa !13
  %223 = load i32, ptr %34, align 4, !tbaa !11
  %224 = add i32 %223, -1
  store i32 %224, ptr %34, align 4, !tbaa !11
  br label %207, !llvm.loop !18

225:                                              ; preds = %207
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #4
  br label %226

226:                                              ; preds = %225
  br label %227

227:                                              ; preds = %226
  %228 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 11
  %229 = load i32, ptr %228, align 4, !tbaa !11
  %230 = xor i32 %229, 117440512
  store i32 %230, ptr %228, align 4, !tbaa !11
  br label %231

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

292:                                              ; preds = %231
  br label %293

293:                                              ; preds = %292
  br label %294

294:                                              ; preds = %293
  call void @llvm.lifetime.start.p0(i64 8, ptr %36) #4
  %295 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  store ptr %295, ptr %36, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #4
  %296 = load ptr, ptr %11, align 8, !tbaa !5
  store ptr %296, ptr %37, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #4
  store i32 32, ptr %38, align 4, !tbaa !11
  br label %297

297:                                              ; preds = %300, %294
  %298 = load i32, ptr %38, align 4, !tbaa !11
  %299 = icmp ugt i32 %298, 0
  br i1 %299, label %300, label %313

300:                                              ; preds = %297
  %301 = load ptr, ptr %37, align 8, !tbaa !5
  %302 = getelementptr inbounds i8, ptr %301, i32 1
  store ptr %302, ptr %37, align 8, !tbaa !5
  %303 = load i8, ptr %301, align 1, !tbaa !13
  %304 = zext i8 %303 to i32
  %305 = load ptr, ptr %36, align 8, !tbaa !5
  %306 = getelementptr inbounds i8, ptr %305, i32 1
  store ptr %306, ptr %36, align 8, !tbaa !5
  %307 = load i8, ptr %305, align 1, !tbaa !13
  %308 = zext i8 %307 to i32
  %309 = xor i32 %308, %304
  %310 = trunc i32 %309 to i8
  store i8 %310, ptr %305, align 1, !tbaa !13
  %311 = load i32, ptr %38, align 4, !tbaa !11
  %312 = add i32 %311, -1
  store i32 %312, ptr %38, align 4, !tbaa !11
  br label %297, !llvm.loop !19

313:                                              ; preds = %297
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #4
  br label %314

314:                                              ; preds = %313
  br label %315

315:                                              ; preds = %314
  br label %442

316:                                              ; preds = %199
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #4
  %317 = load i64, ptr %15, align 8, !tbaa !9
  %318 = trunc i64 %317 to i32
  store i32 %318, ptr %39, align 4, !tbaa !11
  br label %319

319:                                              ; preds = %316
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #4
  %320 = load ptr, ptr %11, align 8, !tbaa !5
  store ptr %320, ptr %40, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %41) #4
  %321 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  store ptr %321, ptr %41, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %42) #4
  %322 = load ptr, ptr %14, align 8, !tbaa !5
  store ptr %322, ptr %42, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #4
  %323 = load i32, ptr %39, align 4, !tbaa !11
  store i32 %323, ptr %43, align 4, !tbaa !11
  br label %324

324:                                              ; preds = %327, %319
  %325 = load i32, ptr %43, align 4, !tbaa !11
  %326 = icmp ugt i32 %325, 0
  br i1 %326, label %327, label %342

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

342:                                              ; preds = %324
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #4
  br label %343

343:                                              ; preds = %342
  br label %344

344:                                              ; preds = %343
  %345 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 11
  %346 = load i32, ptr %345, align 4, !tbaa !11
  %347 = xor i32 %346, 100663296
  store i32 %347, ptr %345, align 4, !tbaa !11
  br label %348

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

409:                                              ; preds = %348
  br label %410

410:                                              ; preds = %409
  br label %411

411:                                              ; preds = %410
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #4
  %412 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  store ptr %412, ptr %45, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #4
  %413 = load ptr, ptr %11, align 8, !tbaa !5
  store ptr %413, ptr %46, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %47) #4
  %414 = load i32, ptr %39, align 4, !tbaa !11
  store i32 %414, ptr %47, align 4, !tbaa !11
  br label %415

415:                                              ; preds = %418, %411
  %416 = load i32, ptr %47, align 4, !tbaa !11
  %417 = icmp ugt i32 %416, 0
  br i1 %417, label %418, label %431

418:                                              ; preds = %415
  %419 = load ptr, ptr %46, align 8, !tbaa !5
  %420 = getelementptr inbounds i8, ptr %419, i32 1
  store ptr %420, ptr %46, align 8, !tbaa !5
  %421 = load i8, ptr %419, align 1, !tbaa !13
  %422 = zext i8 %421 to i32
  %423 = load ptr, ptr %45, align 8, !tbaa !5
  %424 = getelementptr inbounds i8, ptr %423, i32 1
  store ptr %424, ptr %45, align 8, !tbaa !5
  %425 = load i8, ptr %423, align 1, !tbaa !13
  %426 = zext i8 %425 to i32
  %427 = xor i32 %426, %422
  %428 = trunc i32 %427 to i8
  store i8 %428, ptr %423, align 1, !tbaa !13
  %429 = load i32, ptr %47, align 4, !tbaa !11
  %430 = add i32 %429, -1
  store i32 %430, ptr %47, align 4, !tbaa !11
  br label %415, !llvm.loop !21

431:                                              ; preds = %415
  call void @llvm.lifetime.end.p0(i64 4, ptr %47) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #4
  br label %432

432:                                              ; preds = %431
  br label %433

433:                                              ; preds = %432
  %434 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  %435 = load i32, ptr %39, align 4, !tbaa !11
  %436 = zext i32 %435 to i64
  %437 = getelementptr inbounds i8, ptr %434, i64 %436
  %438 = load i8, ptr %437, align 1, !tbaa !13
  %439 = zext i8 %438 to i32
  %440 = xor i32 %439, 128
  %441 = trunc i32 %440 to i8
  store i8 %441, ptr %437, align 1, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #4
  br label %442

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

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

448:                                              ; preds = %447
  call void @llvm.lifetime.start.p0(i64 8, ptr %48) #4
  %449 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  %450 = getelementptr inbounds i8, ptr %449, i64 32
  store ptr %450, ptr %48, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %49) #4
  %451 = load ptr, ptr %19, align 8, !tbaa !5
  store ptr %451, ptr %49, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %50) #4
  store i32 16, ptr %50, align 4, !tbaa !11
  br label %452

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

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

468:                                              ; preds = %452
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %49) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %48) #4
  br label %469

469:                                              ; preds = %468
  br label %470

470:                                              ; preds = %469
  %471 = load ptr, ptr %21, align 8, !tbaa !5
  %472 = load ptr, ptr %12, align 8, !tbaa !5
  %473 = load i64, ptr %472, align 8, !tbaa !9
  %474 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  %475 = getelementptr inbounds i8, ptr %474, i64 32
  %476 = load ptr, ptr %14, align 8, !tbaa !5
  %477 = call i32 @aead_check_tag(ptr noundef %471, i64 noundef %473, ptr noundef %475, ptr noundef %476, i32 noundef 16)
  store i32 %477, ptr %10, align 4
  store i32 1, ptr %22, align 4
  br label %478

478:                                              ; preds = %470, %55
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #4
  call void @llvm.lifetime.end.p0(i64 48, ptr %20) #4
  %479 = load i32, ptr %10, align 4
  ret i32 %479
}

; 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

declare i32 @aead_check_tag(ptr noundef, i64 noundef, ptr noundef, ptr noundef, i32 noundef) #3

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 i32 @schwaemm_256_128_aead_decrypt(ptr noundef %0, ptr nocapture noundef %1, ptr nocapture noundef readnone %2, ptr noundef %3, i64 noundef %4, ptr noundef %5, i64 noundef %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
  call void @llvm.lifetime.start.p0(i64 48, ptr nonnull %10) #4
  %12 = icmp ult i64 %4, 16
  br i1 %12, label %631, label %13

13:                                               ; preds = %9
  %14 = add i64 %4, -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 %6, 0
  br i1 %.not, label %17, label %16

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

17:                                               ; preds = %16, %13
  %.not109 = icmp eq i64 %14, 0
  br i1 %.not109, label %625, label %.preheader118

.preheader118:                                    ; preds = %17
  %18 = icmp ugt i64 %14, 32
  br i1 %18, label %.preheader117.lr.ph, label %._crit_edge

.preheader117.lr.ph:                              ; preds = %.preheader118
  %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 1
  %23 = getelementptr inbounds i8, ptr %10, i64 2
  %24 = getelementptr inbounds i8, ptr %10, i64 3
  %25 = getelementptr inbounds i8, ptr %10, i64 4
  %26 = getelementptr inbounds i8, ptr %10, i64 5
  %27 = getelementptr inbounds i8, ptr %10, i64 6
  %28 = getelementptr inbounds i8, ptr %10, i64 7
  %29 = getelementptr inbounds i8, ptr %10, i64 8
  %30 = getelementptr inbounds i8, ptr %10, i64 9
  %31 = getelementptr inbounds i8, ptr %10, i64 10
  %32 = getelementptr inbounds i8, ptr %10, i64 11
  %33 = getelementptr inbounds i8, ptr %10, i64 12
  %34 = getelementptr inbounds i8, ptr %10, i64 13
  %35 = getelementptr inbounds i8, ptr %10, i64 14
  %36 = getelementptr inbounds i8, ptr %10, i64 15
  %37 = getelementptr inbounds i8, ptr %10, i64 16
  %38 = getelementptr inbounds i8, ptr %10, i64 17
  %39 = getelementptr inbounds i8, ptr %10, i64 18
  %40 = getelementptr inbounds i8, ptr %10, i64 19
  %41 = getelementptr inbounds i8, ptr %10, i64 20
  %42 = getelementptr inbounds i8, ptr %10, i64 21
  %43 = getelementptr inbounds i8, ptr %10, i64 22
  %44 = getelementptr inbounds i8, ptr %10, i64 23
  %45 = getelementptr inbounds i8, ptr %10, i64 24
  %46 = getelementptr inbounds i8, ptr %10, i64 25
  %47 = getelementptr inbounds i8, ptr %10, i64 26
  %48 = getelementptr inbounds i8, ptr %10, i64 27
  %49 = getelementptr inbounds i8, ptr %10, i64 28
  %50 = getelementptr inbounds i8, ptr %10, i64 29
  %51 = getelementptr inbounds i8, ptr %10, i64 30
  %52 = getelementptr inbounds i8, ptr %10, i64 31
  br label %.preheader117

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

._crit_edge:                                      ; preds = %.preheader117, %.preheader118
  %.0101.lcssa = phi i64 [ %14, %.preheader118 ], [ %250, %.preheader117 ]
  %.093.lcssa = phi ptr [ %3, %.preheader118 ], [ %248, %.preheader117 ]
  %.089.lcssa = phi ptr [ %0, %.preheader118 ], [ %249, %.preheader117 ]
  %.089.lcssa164 = ptrtoint ptr %.089.lcssa to i64
  %.093.lcssa165 = ptrtoint ptr %.093.lcssa to i64
  %252 = icmp eq i64 %.0101.lcssa, 32
  br i1 %252, label %.preheader.preheader, label %iter.check

.preheader.preheader:                             ; preds = %._crit_edge
  %253 = getelementptr inbounds i8, ptr %10, i64 1
  %254 = load i8, ptr %10, align 16, !tbaa !9
  %255 = getelementptr inbounds i8, ptr %.093.lcssa, i64 1
  %256 = load i8, ptr %.093.lcssa, align 1, !tbaa !9
  %257 = xor i8 %256, %254
  %258 = getelementptr inbounds i8, ptr %.089.lcssa, i64 1
  store i8 %257, ptr %.089.lcssa, align 1, !tbaa !9
  %259 = getelementptr inbounds i8, ptr %10, i64 2
  %260 = load i8, ptr %253, align 1, !tbaa !9
  %261 = getelementptr inbounds i8, ptr %.093.lcssa, i64 2
  %262 = load i8, ptr %255, align 1, !tbaa !9
  %263 = xor i8 %262, %260
  %264 = getelementptr inbounds i8, ptr %.089.lcssa, i64 2
  store i8 %263, ptr %258, align 1, !tbaa !9
  %265 = getelementptr inbounds i8, ptr %10, i64 3
  %266 = load i8, ptr %259, align 2, !tbaa !9
  %267 = getelementptr inbounds i8, ptr %.093.lcssa, i64 3
  %268 = load i8, ptr %261, align 1, !tbaa !9
  %269 = xor i8 %268, %266
  %270 = getelementptr inbounds i8, ptr %.089.lcssa, i64 3
  store i8 %269, ptr %264, align 1, !tbaa !9
  %271 = getelementptr inbounds i8, ptr %10, i64 4
  %272 = load i8, ptr %265, align 1, !tbaa !9
  %273 = getelementptr inbounds i8, ptr %.093.lcssa, i64 4
  %274 = load i8, ptr %267, align 1, !tbaa !9
  %275 = xor i8 %274, %272
  %276 = getelementptr inbounds i8, ptr %.089.lcssa, i64 4
  store i8 %275, ptr %270, align 1, !tbaa !9
  %277 = getelementptr inbounds i8, ptr %10, i64 5
  %278 = load i8, ptr %271, align 4, !tbaa !9
  %279 = getelementptr inbounds i8, ptr %.093.lcssa, i64 5
  %280 = load i8, ptr %273, align 1, !tbaa !9
  %281 = xor i8 %280, %278
  %282 = getelementptr inbounds i8, ptr %.089.lcssa, i64 5
  store i8 %281, ptr %276, align 1, !tbaa !9
  %283 = getelementptr inbounds i8, ptr %10, i64 6
  %284 = load i8, ptr %277, align 1, !tbaa !9
  %285 = getelementptr inbounds i8, ptr %.093.lcssa, i64 6
  %286 = load i8, ptr %279, align 1, !tbaa !9
  %287 = xor i8 %286, %284
  %288 = getelementptr inbounds i8, ptr %.089.lcssa, i64 6
  store i8 %287, ptr %282, align 1, !tbaa !9
  %289 = getelementptr inbounds i8, ptr %10, i64 7
  %290 = load i8, ptr %283, align 2, !tbaa !9
  %291 = getelementptr inbounds i8, ptr %.093.lcssa, i64 7
  %292 = load i8, ptr %285, align 1, !tbaa !9
  %293 = xor i8 %292, %290
  %294 = getelementptr inbounds i8, ptr %.089.lcssa, i64 7
  store i8 %293, ptr %288, align 1, !tbaa !9
  %295 = getelementptr inbounds i8, ptr %10, i64 8
  %296 = load i8, ptr %289, align 1, !tbaa !9
  %297 = getelementptr inbounds i8, ptr %.093.lcssa, i64 8
  %298 = load i8, ptr %291, align 1, !tbaa !9
  %299 = xor i8 %298, %296
  %300 = getelementptr inbounds i8, ptr %.089.lcssa, i64 8
  store i8 %299, ptr %294, align 1, !tbaa !9
  %301 = getelementptr inbounds i8, ptr %10, i64 9
  %302 = load i8, ptr %295, align 8, !tbaa !9
  %303 = getelementptr inbounds i8, ptr %.093.lcssa, i64 9
  %304 = load i8, ptr %297, align 1, !tbaa !9
  %305 = xor i8 %304, %302
  %306 = getelementptr inbounds i8, ptr %.089.lcssa, i64 9
  store i8 %305, ptr %300, align 1, !tbaa !9
  %307 = getelementptr inbounds i8, ptr %10, i64 10
  %308 = load i8, ptr %301, align 1, !tbaa !9
  %309 = getelementptr inbounds i8, ptr %.093.lcssa, i64 10
  %310 = load i8, ptr %303, align 1, !tbaa !9
  %311 = xor i8 %310, %308
  %312 = getelementptr inbounds i8, ptr %.089.lcssa, i64 10
  store i8 %311, ptr %306, align 1, !tbaa !9
  %313 = getelementptr inbounds i8, ptr %10, i64 11
  %314 = load i8, ptr %307, align 2, !tbaa !9
  %315 = getelementptr inbounds i8, ptr %.093.lcssa, i64 11
  %316 = load i8, ptr %309, align 1, !tbaa !9
  %317 = xor i8 %316, %314
  %318 = getelementptr inbounds i8, ptr %.089.lcssa, i64 11
  store i8 %317, ptr %312, align 1, !tbaa !9
  %319 = getelementptr inbounds i8, ptr %10, i64 12
  %320 = load i8, ptr %313, align 1, !tbaa !9
  %321 = getelementptr inbounds i8, ptr %.093.lcssa, i64 12
  %322 = load i8, ptr %315, align 1, !tbaa !9
  %323 = xor i8 %322, %320
  %324 = getelementptr inbounds i8, ptr %.089.lcssa, i64 12
  store i8 %323, ptr %318, align 1, !tbaa !9
  %325 = getelementptr inbounds i8, ptr %10, i64 13
  %326 = load i8, ptr %319, align 4, !tbaa !9
  %327 = getelementptr inbounds i8, ptr %.093.lcssa, i64 13
  %328 = load i8, ptr %321, align 1, !tbaa !9
  %329 = xor i8 %328, %326
  %330 = getelementptr inbounds i8, ptr %.089.lcssa, i64 13
  store i8 %329, ptr %324, align 1, !tbaa !9
  %331 = getelementptr inbounds i8, ptr %10, i64 14
  %332 = load i8, ptr %325, align 1, !tbaa !9
  %333 = getelementptr inbounds i8, ptr %.093.lcssa, i64 14
  %334 = load i8, ptr %327, align 1, !tbaa !9
  %335 = xor i8 %334, %332
  %336 = getelementptr inbounds i8, ptr %.089.lcssa, i64 14
  store i8 %335, ptr %330, align 1, !tbaa !9
  %337 = getelementptr inbounds i8, ptr %10, i64 15
  %338 = load i8, ptr %331, align 2, !tbaa !9
  %339 = getelementptr inbounds i8, ptr %.093.lcssa, i64 15
  %340 = load i8, ptr %333, align 1, !tbaa !9
  %341 = xor i8 %340, %338
  %342 = getelementptr inbounds i8, ptr %.089.lcssa, i64 15
  store i8 %341, ptr %336, align 1, !tbaa !9
  %343 = getelementptr inbounds i8, ptr %10, i64 16
  %344 = load i8, ptr %337, align 1, !tbaa !9
  %345 = getelementptr inbounds i8, ptr %.093.lcssa, i64 16
  %346 = load i8, ptr %339, align 1, !tbaa !9
  %347 = xor i8 %346, %344
  %348 = getelementptr inbounds i8, ptr %.089.lcssa, i64 16
  store i8 %347, ptr %342, align 1, !tbaa !9
  %349 = getelementptr inbounds i8, ptr %10, i64 17
  %350 = load i8, ptr %343, align 16, !tbaa !9
  %351 = getelementptr inbounds i8, ptr %.093.lcssa, i64 17
  %352 = load i8, ptr %345, align 1, !tbaa !9
  %353 = xor i8 %352, %350
  %354 = getelementptr inbounds i8, ptr %.089.lcssa, i64 17
  store i8 %353, ptr %348, align 1, !tbaa !9
  %355 = getelementptr inbounds i8, ptr %10, i64 18
  %356 = load i8, ptr %349, align 1, !tbaa !9
  %357 = getelementptr inbounds i8, ptr %.093.lcssa, i64 18
  %358 = load i8, ptr %351, align 1, !tbaa !9
  %359 = xor i8 %358, %356
  %360 = getelementptr inbounds i8, ptr %.089.lcssa, i64 18
  store i8 %359, ptr %354, align 1, !tbaa !9
  %361 = getelementptr inbounds i8, ptr %10, i64 19
  %362 = load i8, ptr %355, align 2, !tbaa !9
  %363 = getelementptr inbounds i8, ptr %.093.lcssa, i64 19
  %364 = load i8, ptr %357, align 1, !tbaa !9
  %365 = xor i8 %364, %362
  %366 = getelementptr inbounds i8, ptr %.089.lcssa, i64 19
  store i8 %365, ptr %360, align 1, !tbaa !9
  %367 = getelementptr inbounds i8, ptr %10, i64 20
  %368 = load i8, ptr %361, align 1, !tbaa !9
  %369 = getelementptr inbounds i8, ptr %.093.lcssa, i64 20
  %370 = load i8, ptr %363, align 1, !tbaa !9
  %371 = xor i8 %370, %368
  %372 = getelementptr inbounds i8, ptr %.089.lcssa, i64 20
  store i8 %371, ptr %366, align 1, !tbaa !9
  %373 = getelementptr inbounds i8, ptr %10, i64 21
  %374 = load i8, ptr %367, align 4, !tbaa !9
  %375 = getelementptr inbounds i8, ptr %.093.lcssa, i64 21
  %376 = load i8, ptr %369, align 1, !tbaa !9
  %377 = xor i8 %376, %374
  %378 = getelementptr inbounds i8, ptr %.089.lcssa, i64 21
  store i8 %377, ptr %372, align 1, !tbaa !9
  %379 = getelementptr inbounds i8, ptr %10, i64 22
  %380 = load i8, ptr %373, align 1, !tbaa !9
  %381 = getelementptr inbounds i8, ptr %.093.lcssa, i64 22
  %382 = load i8, ptr %375, align 1, !tbaa !9
  %383 = xor i8 %382, %380
  %384 = getelementptr inbounds i8, ptr %.089.lcssa, i64 22
  store i8 %383, ptr %378, align 1, !tbaa !9
  %385 = getelementptr inbounds i8, ptr %10, i64 23
  %386 = load i8, ptr %379, align 2, !tbaa !9
  %387 = getelementptr inbounds i8, ptr %.093.lcssa, i64 23
  %388 = load i8, ptr %381, align 1, !tbaa !9
  %389 = xor i8 %388, %386
  %390 = getelementptr inbounds i8, ptr %.089.lcssa, i64 23
  store i8 %389, ptr %384, align 1, !tbaa !9
  %391 = getelementptr inbounds i8, ptr %10, i64 24
  %392 = load i8, ptr %385, align 1, !tbaa !9
  %393 = getelementptr inbounds i8, ptr %.093.lcssa, i64 24
  %394 = load i8, ptr %387, align 1, !tbaa !9
  %395 = xor i8 %394, %392
  %396 = getelementptr inbounds i8, ptr %.089.lcssa, i64 24
  store i8 %395, ptr %390, align 1, !tbaa !9
  %397 = getelementptr inbounds i8, ptr %10, i64 25
  %398 = load i8, ptr %391, align 8, !tbaa !9
  %399 = getelementptr inbounds i8, ptr %.093.lcssa, i64 25
  %400 = load i8, ptr %393, align 1, !tbaa !9
  %401 = xor i8 %400, %398
  %402 = getelementptr inbounds i8, ptr %.089.lcssa, i64 25
  store i8 %401, ptr %396, align 1, !tbaa !9
  %403 = getelementptr inbounds i8, ptr %10, i64 26
  %404 = load i8, ptr %397, align 1, !tbaa !9
  %405 = getelementptr inbounds i8, ptr %.093.lcssa, i64 26
  %406 = load i8, ptr %399, align 1, !tbaa !9
  %407 = xor i8 %406, %404
  %408 = getelementptr inbounds i8, ptr %.089.lcssa, i64 26
  store i8 %407, ptr %402, align 1, !tbaa !9
  %409 = getelementptr inbounds i8, ptr %10, i64 27
  %410 = load i8, ptr %403, align 2, !tbaa !9
  %411 = getelementptr inbounds i8, ptr %.093.lcssa, i64 27
  %412 = load i8, ptr %405, align 1, !tbaa !9
  %413 = xor i8 %412, %410
  %414 = getelementptr inbounds i8, ptr %.089.lcssa, i64 27
  store i8 %413, ptr %408, align 1, !tbaa !9
  %415 = getelementptr inbounds i8, ptr %10, i64 28
  %416 = load i8, ptr %409, align 1, !tbaa !9
  %417 = getelementptr inbounds i8, ptr %.093.lcssa, i64 28
  %418 = load i8, ptr %411, align 1, !tbaa !9
  %419 = xor i8 %418, %416
  %420 = getelementptr inbounds i8, ptr %.089.lcssa, i64 28
  store i8 %419, ptr %414, align 1, !tbaa !9
  %421 = getelementptr inbounds i8, ptr %10, i64 29
  %422 = load i8, ptr %415, align 4, !tbaa !9
  %423 = getelementptr inbounds i8, ptr %.093.lcssa, i64 29
  %424 = load i8, ptr %417, align 1, !tbaa !9
  %425 = xor i8 %424, %422
  %426 = getelementptr inbounds i8, ptr %.089.lcssa, i64 29
  store i8 %425, ptr %420, align 1, !tbaa !9
  %427 = getelementptr inbounds i8, ptr %10, i64 30
  %428 = load i8, ptr %421, align 1, !tbaa !9
  %429 = getelementptr inbounds i8, ptr %.093.lcssa, i64 30
  %430 = load i8, ptr %423, align 1, !tbaa !9
  %431 = xor i8 %430, %428
  %432 = getelementptr inbounds i8, ptr %.089.lcssa, i64 30
  store i8 %431, ptr %426, align 1, !tbaa !9
  %433 = getelementptr inbounds i8, ptr %10, i64 31
  %434 = load i8, ptr %427, align 2, !tbaa !9
  %435 = getelementptr inbounds i8, ptr %.093.lcssa, i64 31
  %436 = load i8, ptr %429, align 1, !tbaa !9
  %437 = xor i8 %436, %434
  %438 = getelementptr inbounds i8, ptr %.089.lcssa, i64 31
  store i8 %437, ptr %432, align 1, !tbaa !9
  %439 = load i8, ptr %433, align 1, !tbaa !9
  %440 = load i8, ptr %435, align 1, !tbaa !9
  %441 = xor i8 %440, %439
  store i8 %441, ptr %438, align 1, !tbaa !9
  %442 = getelementptr inbounds i8, ptr %10, i64 44
  %443 = load i32, ptr %442, align 4, !tbaa !10
  %444 = xor i32 %443, 117440512
  store i32 %444, ptr %442, align 4, !tbaa !10
  %445 = getelementptr inbounds i8, ptr %10, i64 16
  %446 = getelementptr inbounds i8, ptr %10, i64 8
  %447 = getelementptr inbounds i8, ptr %10, i64 24
  %448 = load i32, ptr %447, align 8, !tbaa !10
  %449 = getelementptr inbounds i8, ptr %10, i64 12
  %450 = getelementptr inbounds i8, ptr %10, i64 28
  %451 = load <4 x i32>, ptr %450, align 4, !tbaa !10
  %452 = shufflevector <4 x i32> %451, <4 x i32> poison, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
  %453 = load <4 x i32>, ptr %10, align 16, !tbaa !10
  %454 = load <2 x i32>, ptr %445, align 16, !tbaa !10
  %455 = shufflevector <4 x i32> %452, <4 x i32> poison, <2 x i32> <i32 0, i32 1>
  %456 = xor <2 x i32> %455, %454
  store <2 x i32> %456, ptr %10, align 16, !tbaa !10
  %457 = extractelement <4 x i32> %451, i64 3
  %458 = xor i32 %457, %448
  store i32 %458, ptr %446, align 8, !tbaa !10
  %459 = extractelement <4 x i32> %451, i64 0
  %460 = xor i32 %459, %444
  store i32 %460, ptr %449, align 4, !tbaa !10
  %461 = shufflevector <2 x i32> %454, <2 x i32> poison, <4 x i32> <i32 0, i32 1, i32 poison, i32 poison>
  %462 = insertelement <4 x i32> %461, i32 %448, i64 2
  %463 = insertelement <4 x i32> %462, i32 %444, i64 3
  %464 = xor <4 x i32> %463, %453
  %465 = xor <4 x i32> %464, %452
  store <4 x i32> %465, ptr %445, align 16, !tbaa !10
  %466 = extractelement <2 x i32> %456, i64 0
  %467 = lshr i32 %466, 8
  %468 = lshr i32 %466, 16
  %469 = lshr i32 %466, 24
  %470 = shufflevector <2 x i32> %456, <2 x i32> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
  %471 = insertelement <4 x i32> %470, i32 %467, i64 1
  %472 = insertelement <4 x i32> %471, i32 %468, i64 2
  %473 = insertelement <4 x i32> %472, i32 %469, i64 3
  %474 = trunc <4 x i32> %473 to <4 x i8>
  %475 = extractelement <2 x i32> %456, i64 1
  %476 = trunc i32 %475 to i8
  %477 = lshr i32 %475, 8
  %478 = trunc i32 %477 to i8
  %479 = lshr i32 %475, 16
  %480 = trunc i32 %479 to i8
  %481 = load <16 x i8>, ptr %289, align 1
  %482 = load i8, ptr %337, align 1, !tbaa !9
  %483 = load <16 x i8>, ptr %.089.lcssa, align 1, !tbaa !9
  %484 = shufflevector <4 x i8> %474, <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>
  %485 = insertelement <16 x i8> %484, i8 %476, i64 4
  %486 = insertelement <16 x i8> %485, i8 %478, i64 5
  %487 = insertelement <16 x i8> %486, i8 %480, i64 6
  %488 = shufflevector <16 x i8> %487, <16 x i8> %481, <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>
  %489 = insertelement <16 x i8> %488, i8 %482, i64 15
  %490 = xor <16 x i8> %483, %489
  store <16 x i8> %490, ptr %10, align 16, !tbaa !9
  %491 = load <8 x i8>, ptr %348, align 1, !tbaa !9
  %492 = load <8 x i8>, ptr %343, align 16, !tbaa !9
  %493 = xor <8 x i8> %492, %491
  store <8 x i8> %493, ptr %343, align 16, !tbaa !9
  %494 = load <4 x i8>, ptr %396, align 1, !tbaa !9
  %495 = load <4 x i8>, ptr %391, align 8, !tbaa !9
  %496 = xor <4 x i8> %495, %494
  store <4 x i8> %496, ptr %391, align 8, !tbaa !9
  %497 = load i8, ptr %420, align 1, !tbaa !9
  %498 = load i8, ptr %415, align 4, !tbaa !9
  %499 = xor i8 %498, %497
  store i8 %499, ptr %415, align 4, !tbaa !9
  %500 = load i8, ptr %426, align 1, !tbaa !9
  %501 = load i8, ptr %421, align 1, !tbaa !9
  %502 = xor i8 %501, %500
  store i8 %502, ptr %421, align 1, !tbaa !9
  %503 = load i8, ptr %432, align 1, !tbaa !9
  %504 = load i8, ptr %427, align 2, !tbaa !9
  %505 = xor i8 %504, %503
  store i8 %505, ptr %427, align 2, !tbaa !9
  %506 = load i8, ptr %438, align 1, !tbaa !9
  br label %.loopexit

iter.check:                                       ; preds = %._crit_edge
  %507 = trunc nuw i64 %.0101.lcssa to i32
  %508 = add nuw nsw i64 %.0101.lcssa, 4294967295
  %509 = and i64 %508, 4294967295
  %510 = add nuw nsw i64 %509, 1
  %min.iters.check = icmp ult i64 %509, 7
  br i1 %min.iters.check, label %.lr.ph.preheader, label %vector.memcheck

vector.memcheck:                                  ; preds = %iter.check
  %511 = sub i64 %.089.lcssa164, %11
  %diff.check = icmp ult i64 %511, 32
  %512 = sub i64 %.089.lcssa164, %.093.lcssa165
  %diff.check166 = icmp ult i64 %512, 32
  %conflict.rdx = or i1 %diff.check, %diff.check166
  br i1 %conflict.rdx, label %.lr.ph.preheader, label %vector.main.loop.iter.check

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

vector.ph:                                        ; preds = %vector.main.loop.iter.check
  %n.vec = and i64 %510, 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 %.093.lcssa, i64 %index
  %next.gep169 = getelementptr i8, ptr %10, i64 %index
  %next.gep171 = getelementptr i8, ptr %.089.lcssa, i64 %index
  %513 = getelementptr i8, ptr %next.gep169, i64 16
  %wide.load = load <16 x i8>, ptr %next.gep169, align 16, !tbaa !9
  %wide.load173 = load <16 x i8>, ptr %513, align 16, !tbaa !9
  %514 = getelementptr i8, ptr %next.gep, i64 16
  %wide.load174 = load <16 x i8>, ptr %next.gep, align 1, !tbaa !9
  %wide.load175 = load <16 x i8>, ptr %514, align 1, !tbaa !9
  %515 = xor <16 x i8> %wide.load174, %wide.load
  %516 = xor <16 x i8> %wide.load175, %wide.load173
  %517 = getelementptr i8, ptr %next.gep171, i64 16
  store <16 x i8> %515, ptr %next.gep171, align 1, !tbaa !9
  store <16 x i8> %516, ptr %517, align 1, !tbaa !9
  %index.next = add nuw i64 %index, 32
  %518 = icmp eq i64 %index.next, %n.vec
  br i1 %518, label %middle.block, label %vector.body, !llvm.loop !14

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

vec.epilog.iter.check:                            ; preds = %middle.block
  %ind.end187 = getelementptr i8, ptr %.089.lcssa, i64 %n.vec
  %ind.end184 = getelementptr i8, ptr %10, i64 %n.vec
  %ind.end181 = getelementptr i8, ptr %.093.lcssa, i64 %n.vec
  %.cast178 = trunc i64 %n.vec to i32
  %ind.end179 = sub i32 %507, %.cast178
  %n.vec.remaining = and i64 %510, 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.vec177 = and i64 %510, 8589934584
  %.cast = trunc i64 %n.vec177 to i32
  %ind.end = sub i32 %507, %.cast
  %ind.end180 = getelementptr i8, ptr %.093.lcssa, i64 %n.vec177
  %ind.end183 = getelementptr i8, ptr %10, i64 %n.vec177
  %ind.end186 = getelementptr i8, ptr %.089.lcssa, i64 %n.vec177
  br label %vec.epilog.vector.body

vec.epilog.vector.body:                           ; preds = %vec.epilog.vector.body, %vec.epilog.ph
  %index189 = phi i64 [ %vec.epilog.resume.val, %vec.epilog.ph ], [ %index.next195, %vec.epilog.vector.body ]
  %next.gep190 = getelementptr i8, ptr %.093.lcssa, i64 %index189
  %next.gep191 = getelementptr i8, ptr %10, i64 %index189
  %next.gep192 = getelementptr i8, ptr %.089.lcssa, i64 %index189
  %wide.load193 = load <8 x i8>, ptr %next.gep191, align 8, !tbaa !9
  %wide.load194 = load <8 x i8>, ptr %next.gep190, align 1, !tbaa !9
  %519 = xor <8 x i8> %wide.load194, %wide.load193
  store <8 x i8> %519, ptr %next.gep192, align 1, !tbaa !9
  %index.next195 = add nuw i64 %index189, 8
  %520 = icmp eq i64 %index.next195, %n.vec177
  br i1 %520, label %vec.epilog.middle.block, label %vec.epilog.vector.body, !llvm.loop !17

vec.epilog.middle.block:                          ; preds = %vec.epilog.vector.body
  %cmp.n196 = icmp eq i64 %510, %n.vec177
  br i1 %cmp.n196, label %iter.check202, label %.lr.ph.preheader

.lr.ph.preheader:                                 ; preds = %vec.epilog.middle.block, %vector.memcheck, %iter.check, %vec.epilog.iter.check
  %.085135.ph = phi i32 [ %507, %iter.check ], [ %507, %vector.memcheck ], [ %ind.end179, %vec.epilog.iter.check ], [ %ind.end, %vec.epilog.middle.block ]
  %.086134.ph = phi ptr [ %.093.lcssa, %iter.check ], [ %.093.lcssa, %vector.memcheck ], [ %ind.end181, %vec.epilog.iter.check ], [ %ind.end180, %vec.epilog.middle.block ]
  %.087133.ph = phi ptr [ %10, %iter.check ], [ %10, %vector.memcheck ], [ %ind.end184, %vec.epilog.iter.check ], [ %ind.end183, %vec.epilog.middle.block ]
  %.088132.ph = phi ptr [ %.089.lcssa, %iter.check ], [ %.089.lcssa, %vector.memcheck ], [ %ind.end187, %vec.epilog.iter.check ], [ %ind.end186, %vec.epilog.middle.block ]
  %521 = add nsw i32 %.085135.ph, -1
  %xtraiter = and i32 %.085135.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
  %.085135.prol = phi i32 [ %528, %.lr.ph.prol ], [ %.085135.ph, %.lr.ph.preheader ]
  %.086134.prol = phi ptr [ %524, %.lr.ph.prol ], [ %.086134.ph, %.lr.ph.preheader ]
  %.087133.prol = phi ptr [ %522, %.lr.ph.prol ], [ %.087133.ph, %.lr.ph.preheader ]
  %.088132.prol = phi ptr [ %527, %.lr.ph.prol ], [ %.088132.ph, %.lr.ph.preheader ]
  %prol.iter = phi i32 [ %prol.iter.next, %.lr.ph.prol ], [ 0, %.lr.ph.preheader ]
  %522 = getelementptr inbounds i8, ptr %.087133.prol, i64 1
  %523 = load i8, ptr %.087133.prol, align 1, !tbaa !9
  %524 = getelementptr inbounds i8, ptr %.086134.prol, i64 1
  %525 = load i8, ptr %.086134.prol, align 1, !tbaa !9
  %526 = xor i8 %525, %523
  %527 = getelementptr inbounds i8, ptr %.088132.prol, i64 1
  store i8 %526, ptr %.088132.prol, align 1, !tbaa !9
  %528 = add nsw i32 %.085135.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
  %.085135.unr = phi i32 [ %.085135.ph, %.lr.ph.preheader ], [ %528, %.lr.ph.prol ]
  %.086134.unr = phi ptr [ %.086134.ph, %.lr.ph.preheader ], [ %524, %.lr.ph.prol ]
  %.087133.unr = phi ptr [ %.087133.ph, %.lr.ph.preheader ], [ %522, %.lr.ph.prol ]
  %.088132.unr = phi ptr [ %.088132.ph, %.lr.ph.preheader ], [ %527, %.lr.ph.prol ]
  %529 = icmp ult i32 %521, 3
  br i1 %529, label %iter.check202, label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.prol.loopexit, %.lr.ph
  %.085135 = phi i32 [ %554, %.lr.ph ], [ %.085135.unr, %.lr.ph.prol.loopexit ]
  %.086134 = phi ptr [ %550, %.lr.ph ], [ %.086134.unr, %.lr.ph.prol.loopexit ]
  %.087133 = phi ptr [ %548, %.lr.ph ], [ %.087133.unr, %.lr.ph.prol.loopexit ]
  %.088132 = phi ptr [ %553, %.lr.ph ], [ %.088132.unr, %.lr.ph.prol.loopexit ]
  %530 = getelementptr inbounds i8, ptr %.087133, i64 1
  %531 = load i8, ptr %.087133, align 1, !tbaa !9
  %532 = getelementptr inbounds i8, ptr %.086134, i64 1
  %533 = load i8, ptr %.086134, align 1, !tbaa !9
  %534 = xor i8 %533, %531
  %535 = getelementptr inbounds i8, ptr %.088132, i64 1
  store i8 %534, ptr %.088132, align 1, !tbaa !9
  %536 = getelementptr inbounds i8, ptr %.087133, i64 2
  %537 = load i8, ptr %530, align 1, !tbaa !9
  %538 = getelementptr inbounds i8, ptr %.086134, i64 2
  %539 = load i8, ptr %532, align 1, !tbaa !9
  %540 = xor i8 %539, %537
  %541 = getelementptr inbounds i8, ptr %.088132, i64 2
  store i8 %540, ptr %535, align 1, !tbaa !9
  %542 = getelementptr inbounds i8, ptr %.087133, i64 3
  %543 = load i8, ptr %536, align 1, !tbaa !9
  %544 = getelementptr inbounds i8, ptr %.086134, i64 3
  %545 = load i8, ptr %538, align 1, !tbaa !9
  %546 = xor i8 %545, %543
  %547 = getelementptr inbounds i8, ptr %.088132, i64 3
  store i8 %546, ptr %541, align 1, !tbaa !9
  %548 = getelementptr inbounds i8, ptr %.087133, i64 4
  %549 = load i8, ptr %542, align 1, !tbaa !9
  %550 = getelementptr inbounds i8, ptr %.086134, i64 4
  %551 = load i8, ptr %544, align 1, !tbaa !9
  %552 = xor i8 %551, %549
  %553 = getelementptr inbounds i8, ptr %.088132, i64 4
  store i8 %552, ptr %547, align 1, !tbaa !9
  %554 = add nsw i32 %.085135, -4
  %.not110.3 = icmp eq i32 %554, 0
  br i1 %.not110.3, label %iter.check202, label %.lr.ph, !llvm.loop !20

iter.check202:                                    ; preds = %.lr.ph.prol.loopexit, %.lr.ph, %vec.epilog.middle.block, %middle.block
  %555 = getelementptr inbounds i8, ptr %10, i64 44
  %556 = load i32, ptr %555, align 4, !tbaa !10
  %557 = xor i32 %556, 100663296
  store i32 %557, ptr %555, align 4, !tbaa !10
  %558 = getelementptr inbounds i8, ptr %10, i64 16
  %559 = getelementptr inbounds i8, ptr %10, i64 8
  %560 = getelementptr inbounds i8, ptr %10, i64 24
  %561 = load i32, ptr %560, align 8, !tbaa !10
  %562 = getelementptr inbounds i8, ptr %10, i64 12
  %563 = getelementptr inbounds i8, ptr %10, i64 28
  %564 = load <4 x i32>, ptr %563, align 4, !tbaa !10
  %565 = shufflevector <4 x i32> %564, <4 x i32> poison, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
  %566 = load <4 x i32>, ptr %10, align 16, !tbaa !10
  %567 = load <2 x i32>, ptr %558, align 16, !tbaa !10
  %568 = shufflevector <4 x i32> %565, <4 x i32> poison, <2 x i32> <i32 0, i32 1>
  %569 = xor <2 x i32> %568, %567
  store <2 x i32> %569, ptr %10, align 16, !tbaa !10
  %570 = extractelement <4 x i32> %564, i64 3
  %571 = xor i32 %570, %561
  store i32 %571, ptr %559, align 8, !tbaa !10
  %572 = extractelement <4 x i32> %564, i64 0
  %573 = xor i32 %572, %557
  store i32 %573, ptr %562, align 4, !tbaa !10
  %574 = shufflevector <2 x i32> %567, <2 x i32> poison, <4 x i32> <i32 0, i32 1, i32 poison, i32 poison>
  %575 = insertelement <4 x i32> %574, i32 %561, i64 2
  %576 = insertelement <4 x i32> %575, i32 %557, i64 3
  %577 = xor <4 x i32> %576, %566
  %578 = xor <4 x i32> %577, %565
  store <4 x i32> %578, ptr %558, align 16, !tbaa !10
  %579 = add nuw nsw i64 %.0101.lcssa, 4294967295
  %580 = and i64 %579, 4294967295
  %581 = add nuw nsw i64 %580, 1
  %min.iters.check200 = icmp ult i64 %580, 7
  br i1 %min.iters.check200, label %.lr.ph143.preheader, label %vector.memcheck197

vector.memcheck197:                               ; preds = %iter.check202
  %582 = add nuw nsw i64 %.0101.lcssa, 4294967295
  %583 = and i64 %582, 4294967295
  %584 = add nuw nsw i64 %583, 1
  %scevgep = getelementptr i8, ptr %10, i64 %584
  %scevgep198 = getelementptr i8, ptr %.089.lcssa, i64 %584
  %bound0 = icmp ult ptr %10, %scevgep198
  %bound1 = icmp ult ptr %.089.lcssa, %scevgep
  %found.conflict = and i1 %bound0, %bound1
  br i1 %found.conflict, label %.lr.ph143.preheader, label %vector.main.loop.iter.check204

vector.main.loop.iter.check204:                   ; preds = %vector.memcheck197
  %min.iters.check203 = icmp ult i64 %580, 31
  br i1 %min.iters.check203, label %vec.epilog.ph222, label %vector.ph205

vector.ph205:                                     ; preds = %vector.main.loop.iter.check204
  %n.vec207 = and i64 %581, 8589934560
  br label %vector.body208

vector.body208:                                   ; preds = %vector.body208, %vector.ph205
  %index209 = phi i64 [ 0, %vector.ph205 ], [ %index.next218, %vector.body208 ]
  %next.gep210 = getelementptr i8, ptr %.089.lcssa, i64 %index209
  %next.gep212 = getelementptr i8, ptr %10, i64 %index209
  %585 = getelementptr i8, ptr %next.gep210, i64 16
  %wide.load214 = load <16 x i8>, ptr %next.gep210, align 1, !tbaa !9, !alias.scope !21
  %wide.load215 = load <16 x i8>, ptr %585, align 1, !tbaa !9, !alias.scope !21
  %586 = getelementptr i8, ptr %next.gep212, i64 16
  %wide.load216 = load <16 x i8>, ptr %next.gep212, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %wide.load217 = load <16 x i8>, ptr %586, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %587 = xor <16 x i8> %wide.load216, %wide.load214
  %588 = xor <16 x i8> %wide.load217, %wide.load215
  store <16 x i8> %587, ptr %next.gep212, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  store <16 x i8> %588, ptr %586, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %index.next218 = add nuw i64 %index209, 32
  %589 = icmp eq i64 %index.next218, %n.vec207
  br i1 %589, label %middle.block199, label %vector.body208, !llvm.loop !26

middle.block199:                                  ; preds = %vector.body208
  %cmp.n219 = icmp eq i64 %581, %n.vec207
  br i1 %cmp.n219, label %._crit_edge144, label %vec.epilog.iter.check223

vec.epilog.iter.check223:                         ; preds = %middle.block199
  %ind.end238 = getelementptr i8, ptr %10, i64 %n.vec207
  %ind.end235 = getelementptr i8, ptr %.089.lcssa, i64 %n.vec207
  %.cast231 = trunc i64 %n.vec207 to i32
  %ind.end232 = sub i32 %507, %.cast231
  %n.vec.remaining224 = and i64 %581, 24
  %min.epilog.iters.check225 = icmp eq i64 %n.vec.remaining224, 0
  br i1 %min.epilog.iters.check225, label %.lr.ph143.preheader, label %vec.epilog.ph222

vec.epilog.ph222:                                 ; preds = %vector.main.loop.iter.check204, %vec.epilog.iter.check223
  %vec.epilog.resume.val226 = phi i64 [ %n.vec207, %vec.epilog.iter.check223 ], [ 0, %vector.main.loop.iter.check204 ]
  %n.vec228 = and i64 %581, 8589934584
  %.cast229 = trunc i64 %n.vec228 to i32
  %ind.end230 = sub i32 %507, %.cast229
  %ind.end234 = getelementptr i8, ptr %.089.lcssa, i64 %n.vec228
  %ind.end237 = getelementptr i8, ptr %10, i64 %n.vec228
  br label %vec.epilog.vector.body240

vec.epilog.vector.body240:                        ; preds = %vec.epilog.vector.body240, %vec.epilog.ph222
  %index241 = phi i64 [ %vec.epilog.resume.val226, %vec.epilog.ph222 ], [ %index.next246, %vec.epilog.vector.body240 ]
  %next.gep242 = getelementptr i8, ptr %.089.lcssa, i64 %index241
  %next.gep243 = getelementptr i8, ptr %10, i64 %index241
  %wide.load244 = load <8 x i8>, ptr %next.gep242, align 1, !tbaa !9, !alias.scope !27
  %wide.load245 = load <8 x i8>, ptr %next.gep243, align 8, !tbaa !9, !alias.scope !30, !noalias !27
  %590 = xor <8 x i8> %wide.load245, %wide.load244
  store <8 x i8> %590, ptr %next.gep243, align 8, !tbaa !9, !alias.scope !30, !noalias !27
  %index.next246 = add nuw i64 %index241, 8
  %591 = icmp eq i64 %index.next246, %n.vec228
  br i1 %591, label %vec.epilog.middle.block220, label %vec.epilog.vector.body240, !llvm.loop !32

vec.epilog.middle.block220:                       ; preds = %vec.epilog.vector.body240
  %cmp.n247 = icmp eq i64 %581, %n.vec228
  br i1 %cmp.n247, label %._crit_edge144, label %.lr.ph143.preheader

.lr.ph143.preheader:                              ; preds = %vec.epilog.middle.block220, %vector.memcheck197, %iter.check202, %vec.epilog.iter.check223
  %.081141.ph = phi i32 [ %507, %iter.check202 ], [ %507, %vector.memcheck197 ], [ %ind.end232, %vec.epilog.iter.check223 ], [ %ind.end230, %vec.epilog.middle.block220 ]
  %.082140.ph = phi ptr [ %.089.lcssa, %iter.check202 ], [ %.089.lcssa, %vector.memcheck197 ], [ %ind.end235, %vec.epilog.iter.check223 ], [ %ind.end234, %vec.epilog.middle.block220 ]
  %.083139.ph = phi ptr [ %10, %iter.check202 ], [ %10, %vector.memcheck197 ], [ %ind.end238, %vec.epilog.iter.check223 ], [ %ind.end237, %vec.epilog.middle.block220 ]
  %592 = add nsw i32 %.081141.ph, -1
  %xtraiter250 = and i32 %.081141.ph, 3
  %lcmp.mod251.not = icmp eq i32 %xtraiter250, 0
  br i1 %lcmp.mod251.not, label %.lr.ph143.prol.loopexit, label %.lr.ph143.prol

.lr.ph143.prol:                                   ; preds = %.lr.ph143.preheader, %.lr.ph143.prol
  %.081141.prol = phi i32 [ %598, %.lr.ph143.prol ], [ %.081141.ph, %.lr.ph143.preheader ]
  %.082140.prol = phi ptr [ %593, %.lr.ph143.prol ], [ %.082140.ph, %.lr.ph143.preheader ]
  %.083139.prol = phi ptr [ %595, %.lr.ph143.prol ], [ %.083139.ph, %.lr.ph143.preheader ]
  %prol.iter252 = phi i32 [ %prol.iter252.next, %.lr.ph143.prol ], [ 0, %.lr.ph143.preheader ]
  %593 = getelementptr inbounds i8, ptr %.082140.prol, i64 1
  %594 = load i8, ptr %.082140.prol, align 1, !tbaa !9
  %595 = getelementptr inbounds i8, ptr %.083139.prol, i64 1
  %596 = load i8, ptr %.083139.prol, align 1, !tbaa !9
  %597 = xor i8 %596, %594
  store i8 %597, ptr %.083139.prol, align 1, !tbaa !9
  %598 = add nsw i32 %.081141.prol, -1
  %prol.iter252.next = add i32 %prol.iter252, 1
  %prol.iter252.cmp.not = icmp eq i32 %prol.iter252.next, %xtraiter250
  br i1 %prol.iter252.cmp.not, label %.lr.ph143.prol.loopexit, label %.lr.ph143.prol, !llvm.loop !33

.lr.ph143.prol.loopexit:                          ; preds = %.lr.ph143.prol, %.lr.ph143.preheader
  %.081141.unr = phi i32 [ %.081141.ph, %.lr.ph143.preheader ], [ %598, %.lr.ph143.prol ]
  %.082140.unr = phi ptr [ %.082140.ph, %.lr.ph143.preheader ], [ %593, %.lr.ph143.prol ]
  %.083139.unr = phi ptr [ %.083139.ph, %.lr.ph143.preheader ], [ %595, %.lr.ph143.prol ]
  %599 = icmp ult i32 %592, 3
  br i1 %599, label %._crit_edge144, label %.lr.ph143

.lr.ph143:                                        ; preds = %.lr.ph143.prol.loopexit, %.lr.ph143
  %.081141 = phi i32 [ %620, %.lr.ph143 ], [ %.081141.unr, %.lr.ph143.prol.loopexit ]
  %.082140 = phi ptr [ %615, %.lr.ph143 ], [ %.082140.unr, %.lr.ph143.prol.loopexit ]
  %.083139 = phi ptr [ %617, %.lr.ph143 ], [ %.083139.unr, %.lr.ph143.prol.loopexit ]
  %600 = getelementptr inbounds i8, ptr %.082140, i64 1
  %601 = load i8, ptr %.082140, align 1, !tbaa !9
  %602 = getelementptr inbounds i8, ptr %.083139, i64 1
  %603 = load i8, ptr %.083139, align 1, !tbaa !9
  %604 = xor i8 %603, %601
  store i8 %604, ptr %.083139, align 1, !tbaa !9
  %605 = getelementptr inbounds i8, ptr %.082140, i64 2
  %606 = load i8, ptr %600, align 1, !tbaa !9
  %607 = getelementptr inbounds i8, ptr %.083139, i64 2
  %608 = load i8, ptr %602, align 1, !tbaa !9
  %609 = xor i8 %608, %606
  store i8 %609, ptr %602, align 1, !tbaa !9
  %610 = getelementptr inbounds i8, ptr %.082140, i64 3
  %611 = load i8, ptr %605, align 1, !tbaa !9
  %612 = getelementptr inbounds i8, ptr %.083139, i64 3
  %613 = load i8, ptr %607, align 1, !tbaa !9
  %614 = xor i8 %613, %611
  store i8 %614, ptr %607, align 1, !tbaa !9
  %615 = getelementptr inbounds i8, ptr %.082140, i64 4
  %616 = load i8, ptr %610, align 1, !tbaa !9
  %617 = getelementptr inbounds i8, ptr %.083139, i64 4
  %618 = load i8, ptr %612, align 1, !tbaa !9
  %619 = xor i8 %618, %616
  store i8 %619, ptr %612, align 1, !tbaa !9
  %620 = add nsw i32 %.081141, -4
  %.not111.3 = icmp eq i32 %620, 0
  br i1 %.not111.3, label %._crit_edge144, label %.lr.ph143, !llvm.loop !34

._crit_edge144:                                   ; preds = %.lr.ph143.prol.loopexit, %.lr.ph143, %vec.epilog.middle.block220, %middle.block199
  %621 = getelementptr inbounds i8, ptr %10, i64 %.0101.lcssa
  br label %.loopexit

.loopexit:                                        ; preds = %.preheader.preheader, %._crit_edge144
  %.sink = phi ptr [ %433, %.preheader.preheader ], [ %621, %._crit_edge144 ]
  %.sink161 = phi i8 [ %506, %.preheader.preheader ], [ -128, %._crit_edge144 ]
  %622 = load i8, ptr %.sink, align 1, !tbaa !9
  %623 = xor i8 %622, %.sink161
  store i8 %623, ptr %.sink, align 1, !tbaa !9
  call void @sparkle_384(ptr noundef nonnull %10, i32 noundef 11) #4
  %624 = getelementptr inbounds i8, ptr %.093.lcssa, i64 %.0101.lcssa
  br label %625

625:                                              ; preds = %17, %.loopexit
  %.1 = phi ptr [ %624, %.loopexit ], [ %3, %17 ]
  %626 = load <16 x i8>, ptr %8, align 1, !tbaa !9
  %627 = load <16 x i8>, ptr %15, align 16, !tbaa !9
  %628 = xor <16 x i8> %627, %626
  store <16 x i8> %628, ptr %15, align 16, !tbaa !9
  %629 = load i64, ptr %1, align 8, !tbaa !5
  %630 = call i32 @aead_check_tag(ptr noundef %0, i64 noundef %629, ptr noundef nonnull %15, ptr noundef %.1, i32 noundef 16) #4
  br label %631

631:                                              ; preds = %9, %625
  %.084 = phi i32 [ %630, %625 ], [ -1, %9 ]
  call void @llvm.lifetime.end.p0(i64 48, ptr nonnull %10) #4
  ret i32 %.084
}

; 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

declare i32 @aead_check_tag(ptr noundef, i64 noundef, ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #3

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