; 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_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, 24
  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 %433

56:                                               ; preds = %9
  %57 = load i64, ptr %15, align 8, !tbaa !9
  %58 = sub i64 %57, 24
  %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 24, i1 false)
  %62 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  %63 = getelementptr inbounds i8, ptr %62, i64 24
  %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 24, 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_192_192_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, 24
  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 %402

77:                                               ; preds = %72
  br label %78

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

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 24, 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 3
  %111 = load i32, ptr %110, align 4, !tbaa !11
  %112 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 6
  %113 = load i32, ptr %112, align 8, !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 9
  %118 = load i32, ptr %117, align 4, !tbaa !11
  %119 = xor i32 %116, %118
  %120 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 3
  %121 = load i32, ptr %120, align 4, !tbaa !11
  %122 = xor i32 %121, %119
  store i32 %122, ptr %120, align 4, !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 4
  %126 = load i32, ptr %125, align 16, !tbaa !11
  %127 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 7
  %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 10
  %133 = load i32, ptr %132, align 8, !tbaa !11
  %134 = xor i32 %131, %133
  %135 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 4
  %136 = load i32, ptr %135, align 16, !tbaa !11
  %137 = xor i32 %136, %134
  store i32 %137, ptr %135, align 16, !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 5
  %141 = load i32, ptr %140, align 4, !tbaa !11
  %142 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 8
  %143 = load i32, ptr %142, align 16, !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 11
  %148 = load i32, ptr %147, align 4, !tbaa !11
  %149 = xor i32 %146, %148
  %150 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 5
  %151 = load i32, ptr %150, align 4, !tbaa !11
  %152 = xor i32 %151, %149
  store i32 %152, ptr %150, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #4
  br label %153

153:                                              ; preds = %107
  br label %154

154:                                              ; preds = %153
  br label %155

155:                                              ; preds = %154
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #4
  %156 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  store ptr %156, ptr %28, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #4
  %157 = load ptr, ptr %11, align 8, !tbaa !5
  store ptr %157, ptr %29, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #4
  store i32 24, ptr %30, align 4, !tbaa !11
  br label %158

158:                                              ; preds = %161, %155
  %159 = load i32, ptr %30, align 4, !tbaa !11
  %160 = icmp ugt i32 %159, 0
  br i1 %160, label %161, label %174

161:                                              ; preds = %158
  %162 = load ptr, ptr %29, align 8, !tbaa !5
  %163 = getelementptr inbounds i8, ptr %162, i32 1
  store ptr %163, ptr %29, align 8, !tbaa !5
  %164 = load i8, ptr %162, align 1, !tbaa !13
  %165 = zext i8 %164 to i32
  %166 = load ptr, ptr %28, align 8, !tbaa !5
  %167 = getelementptr inbounds i8, ptr %166, i32 1
  store ptr %167, ptr %28, align 8, !tbaa !5
  %168 = load i8, ptr %166, align 1, !tbaa !13
  %169 = zext i8 %168 to i32
  %170 = xor i32 %169, %165
  %171 = trunc i32 %170 to i8
  store i8 %171, ptr %166, align 1, !tbaa !13
  %172 = load i32, ptr %30, align 4, !tbaa !11
  %173 = add i32 %172, -1
  store i32 %173, ptr %30, align 4, !tbaa !11
  br label %158, !llvm.loop !16

174:                                              ; preds = %158
  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 %175

175:                                              ; preds = %174
  br label %176

176:                                              ; preds = %175
  %177 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  call void @sparkle_384(ptr noundef %177, i32 noundef 7)
  %178 = load ptr, ptr %14, align 8, !tbaa !5
  %179 = getelementptr inbounds i8, ptr %178, i64 24
  store ptr %179, ptr %14, align 8, !tbaa !5
  %180 = load ptr, ptr %11, align 8, !tbaa !5
  %181 = getelementptr inbounds i8, ptr %180, i64 24
  store ptr %181, ptr %11, align 8, !tbaa !5
  %182 = load i64, ptr %15, align 8, !tbaa !9
  %183 = sub i64 %182, 24
  store i64 %183, ptr %15, align 8, !tbaa !9
  br label %78, !llvm.loop !17

184:                                              ; preds = %78
  %185 = load i64, ptr %15, align 8, !tbaa !9
  %186 = icmp eq i64 %185, 24
  br i1 %186, label %187, label %286

187:                                              ; preds = %184
  br label %188

188:                                              ; preds = %187
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #4
  %189 = load ptr, ptr %11, align 8, !tbaa !5
  store ptr %189, ptr %31, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #4
  %190 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  store ptr %190, ptr %32, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #4
  %191 = load ptr, ptr %14, align 8, !tbaa !5
  store ptr %191, ptr %33, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #4
  store i32 24, ptr %34, align 4, !tbaa !11
  br label %192

192:                                              ; preds = %195, %188
  %193 = load i32, ptr %34, align 4, !tbaa !11
  %194 = icmp ugt i32 %193, 0
  br i1 %194, label %195, label %210

195:                                              ; preds = %192
  %196 = load ptr, ptr %32, align 8, !tbaa !5
  %197 = getelementptr inbounds i8, ptr %196, i32 1
  store ptr %197, ptr %32, align 8, !tbaa !5
  %198 = load i8, ptr %196, align 1, !tbaa !13
  %199 = zext i8 %198 to i32
  %200 = load ptr, ptr %33, align 8, !tbaa !5
  %201 = getelementptr inbounds i8, ptr %200, i32 1
  store ptr %201, ptr %33, align 8, !tbaa !5
  %202 = load i8, ptr %200, align 1, !tbaa !13
  %203 = zext i8 %202 to i32
  %204 = xor i32 %199, %203
  %205 = trunc i32 %204 to i8
  %206 = load ptr, ptr %31, align 8, !tbaa !5
  %207 = getelementptr inbounds i8, ptr %206, i32 1
  store ptr %207, ptr %31, align 8, !tbaa !5
  store i8 %205, ptr %206, align 1, !tbaa !13
  %208 = load i32, ptr %34, align 4, !tbaa !11
  %209 = add i32 %208, -1
  store i32 %209, ptr %34, align 4, !tbaa !11
  br label %192, !llvm.loop !18

210:                                              ; preds = %192
  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 %211

211:                                              ; preds = %210
  br label %212

212:                                              ; preds = %211
  %213 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 11
  %214 = load i32, ptr %213, align 4, !tbaa !11
  %215 = xor i32 %214, 184549376
  store i32 %215, ptr %213, align 4, !tbaa !11
  br label %216

216:                                              ; preds = %212
  call void @llvm.lifetime.start.p0(i64 4, ptr %35) #4
  %217 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  %218 = load i32, ptr %217, align 16, !tbaa !11
  store i32 %218, ptr %35, align 4, !tbaa !11
  %219 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 3
  %220 = load i32, ptr %219, align 4, !tbaa !11
  %221 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 6
  %222 = load i32, ptr %221, align 8, !tbaa !11
  %223 = xor i32 %220, %222
  %224 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  store i32 %223, ptr %224, align 16, !tbaa !11
  %225 = load i32, ptr %35, align 4, !tbaa !11
  %226 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 9
  %227 = load i32, ptr %226, align 4, !tbaa !11
  %228 = xor i32 %225, %227
  %229 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 3
  %230 = load i32, ptr %229, align 4, !tbaa !11
  %231 = xor i32 %230, %228
  store i32 %231, ptr %229, align 4, !tbaa !11
  %232 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 1
  %233 = load i32, ptr %232, align 4, !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 7
  %237 = load i32, ptr %236, align 4, !tbaa !11
  %238 = xor i32 %235, %237
  %239 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 1
  store i32 %238, ptr %239, align 4, !tbaa !11
  %240 = load i32, ptr %35, align 4, !tbaa !11
  %241 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 10
  %242 = load i32, ptr %241, align 8, !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 2
  %248 = load i32, ptr %247, align 8, !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 8
  %252 = load i32, ptr %251, align 16, !tbaa !11
  %253 = xor i32 %250, %252
  %254 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 2
  store i32 %253, ptr %254, align 8, !tbaa !11
  %255 = load i32, ptr %35, align 4, !tbaa !11
  %256 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 11
  %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
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #4
  br label %262

262:                                              ; preds = %216
  br label %263

263:                                              ; preds = %262
  br label %264

264:                                              ; preds = %263
  call void @llvm.lifetime.start.p0(i64 8, ptr %36) #4
  %265 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  store ptr %265, ptr %36, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #4
  %266 = load ptr, ptr %11, align 8, !tbaa !5
  store ptr %266, ptr %37, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #4
  store i32 24, ptr %38, align 4, !tbaa !11
  br label %267

267:                                              ; preds = %270, %264
  %268 = load i32, ptr %38, align 4, !tbaa !11
  %269 = icmp ugt i32 %268, 0
  br i1 %269, label %270, label %283

270:                                              ; preds = %267
  %271 = load ptr, ptr %37, align 8, !tbaa !5
  %272 = getelementptr inbounds i8, ptr %271, i32 1
  store ptr %272, ptr %37, align 8, !tbaa !5
  %273 = load i8, ptr %271, align 1, !tbaa !13
  %274 = zext i8 %273 to i32
  %275 = load ptr, ptr %36, align 8, !tbaa !5
  %276 = getelementptr inbounds i8, ptr %275, i32 1
  store ptr %276, ptr %36, align 8, !tbaa !5
  %277 = load i8, ptr %275, align 1, !tbaa !13
  %278 = zext i8 %277 to i32
  %279 = xor i32 %278, %274
  %280 = trunc i32 %279 to i8
  store i8 %280, ptr %275, align 1, !tbaa !13
  %281 = load i32, ptr %38, align 4, !tbaa !11
  %282 = add i32 %281, -1
  store i32 %282, ptr %38, align 4, !tbaa !11
  br label %267, !llvm.loop !19

283:                                              ; preds = %267
  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 %284

284:                                              ; preds = %283
  br label %285

285:                                              ; preds = %284
  br label %397

286:                                              ; preds = %184
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #4
  %287 = load i64, ptr %15, align 8, !tbaa !9
  %288 = trunc i64 %287 to i32
  store i32 %288, ptr %39, align 4, !tbaa !11
  br label %289

289:                                              ; preds = %286
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #4
  %290 = load ptr, ptr %11, align 8, !tbaa !5
  store ptr %290, ptr %40, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %41) #4
  %291 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  store ptr %291, ptr %41, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %42) #4
  %292 = load ptr, ptr %14, align 8, !tbaa !5
  store ptr %292, ptr %42, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #4
  %293 = load i32, ptr %39, align 4, !tbaa !11
  store i32 %293, ptr %43, align 4, !tbaa !11
  br label %294

294:                                              ; preds = %297, %289
  %295 = load i32, ptr %43, align 4, !tbaa !11
  %296 = icmp ugt i32 %295, 0
  br i1 %296, label %297, label %312

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

312:                                              ; preds = %294
  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 %313

313:                                              ; preds = %312
  br label %314

314:                                              ; preds = %313
  %315 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 11
  %316 = load i32, ptr %315, align 4, !tbaa !11
  %317 = xor i32 %316, 167772160
  store i32 %317, ptr %315, align 4, !tbaa !11
  br label %318

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

364:                                              ; preds = %318
  br label %365

365:                                              ; preds = %364
  br label %366

366:                                              ; preds = %365
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #4
  %367 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  store ptr %367, ptr %45, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #4
  %368 = load ptr, ptr %11, align 8, !tbaa !5
  store ptr %368, ptr %46, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %47) #4
  %369 = load i32, ptr %39, align 4, !tbaa !11
  store i32 %369, ptr %47, align 4, !tbaa !11
  br label %370

370:                                              ; preds = %373, %366
  %371 = load i32, ptr %47, align 4, !tbaa !11
  %372 = icmp ugt i32 %371, 0
  br i1 %372, label %373, label %386

373:                                              ; preds = %370
  %374 = load ptr, ptr %46, align 8, !tbaa !5
  %375 = getelementptr inbounds i8, ptr %374, i32 1
  store ptr %375, ptr %46, align 8, !tbaa !5
  %376 = load i8, ptr %374, align 1, !tbaa !13
  %377 = zext i8 %376 to i32
  %378 = load ptr, ptr %45, align 8, !tbaa !5
  %379 = getelementptr inbounds i8, ptr %378, i32 1
  store ptr %379, ptr %45, align 8, !tbaa !5
  %380 = load i8, ptr %378, align 1, !tbaa !13
  %381 = zext i8 %380 to i32
  %382 = xor i32 %381, %377
  %383 = trunc i32 %382 to i8
  store i8 %383, ptr %378, align 1, !tbaa !13
  %384 = load i32, ptr %47, align 4, !tbaa !11
  %385 = add i32 %384, -1
  store i32 %385, ptr %47, align 4, !tbaa !11
  br label %370, !llvm.loop !21

386:                                              ; preds = %370
  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 %387

387:                                              ; preds = %386
  br label %388

388:                                              ; preds = %387
  %389 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  %390 = load i32, ptr %39, align 4, !tbaa !11
  %391 = zext i32 %390 to i64
  %392 = getelementptr inbounds i8, ptr %389, i64 %391
  %393 = load i8, ptr %392, align 1, !tbaa !13
  %394 = zext i8 %393 to i32
  %395 = xor i32 %394, 128
  %396 = trunc i32 %395 to i8
  store i8 %396, ptr %392, align 1, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #4
  br label %397

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

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

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

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

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

423:                                              ; preds = %407
  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 %424

424:                                              ; preds = %423
  br label %425

425:                                              ; preds = %424
  %426 = load ptr, ptr %21, align 8, !tbaa !5
  %427 = load ptr, ptr %12, align 8, !tbaa !5
  %428 = load i64, ptr %427, align 8, !tbaa !9
  %429 = getelementptr inbounds [12 x i32], ptr %20, i64 0, i64 0
  %430 = getelementptr inbounds i8, ptr %429, i64 24
  %431 = load ptr, ptr %14, align 8, !tbaa !5
  %432 = call i32 @aead_check_tag(ptr noundef %426, i64 noundef %428, ptr noundef %430, ptr noundef %431, i32 noundef 24)
  store i32 %432, ptr %10, align 4
  store i32 1, ptr %22, align 4
  br label %433

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

; 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

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

; 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 i32 @schwaemm_192_192_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, 24
  br i1 %12, label %559, label %13

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

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

17:                                               ; preds = %16, %13
  %.not106 = icmp eq i64 %14, 0
  br i1 %.not106, label %548, label %.preheader115

.preheader115:                                    ; preds = %17
  %18 = icmp ugt i64 %14, 24
  br i1 %18, label %.preheader114.lr.ph, label %._crit_edge

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

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

._crit_edge:                                      ; preds = %.preheader114, %.preheader115
  %.098.lcssa = phi i64 [ %14, %.preheader115 ], [ %224, %.preheader114 ]
  %.090.lcssa = phi ptr [ %3, %.preheader115 ], [ %222, %.preheader114 ]
  %.086.lcssa = phi ptr [ %0, %.preheader115 ], [ %223, %.preheader114 ]
  %.086.lcssa161 = ptrtoint ptr %.086.lcssa to i64
  %.090.lcssa162 = ptrtoint ptr %.090.lcssa to i64
  %226 = icmp eq i64 %.098.lcssa, 24
  br i1 %226, label %.preheader.preheader, label %iter.check

.preheader.preheader:                             ; preds = %._crit_edge
  %227 = getelementptr inbounds i8, ptr %10, i64 1
  %228 = load i8, ptr %10, align 16, !tbaa !9
  %229 = getelementptr inbounds i8, ptr %.090.lcssa, i64 1
  %230 = load i8, ptr %.090.lcssa, align 1, !tbaa !9
  %231 = xor i8 %230, %228
  %232 = getelementptr inbounds i8, ptr %.086.lcssa, i64 1
  store i8 %231, ptr %.086.lcssa, align 1, !tbaa !9
  %233 = getelementptr inbounds i8, ptr %10, i64 2
  %234 = load i8, ptr %227, align 1, !tbaa !9
  %235 = getelementptr inbounds i8, ptr %.090.lcssa, i64 2
  %236 = load i8, ptr %229, align 1, !tbaa !9
  %237 = xor i8 %236, %234
  %238 = getelementptr inbounds i8, ptr %.086.lcssa, i64 2
  store i8 %237, ptr %232, align 1, !tbaa !9
  %239 = getelementptr inbounds i8, ptr %10, i64 3
  %240 = load i8, ptr %233, align 2, !tbaa !9
  %241 = getelementptr inbounds i8, ptr %.090.lcssa, i64 3
  %242 = load i8, ptr %235, align 1, !tbaa !9
  %243 = xor i8 %242, %240
  %244 = getelementptr inbounds i8, ptr %.086.lcssa, i64 3
  store i8 %243, ptr %238, align 1, !tbaa !9
  %245 = getelementptr inbounds i8, ptr %10, i64 4
  %246 = load i8, ptr %239, align 1, !tbaa !9
  %247 = getelementptr inbounds i8, ptr %.090.lcssa, i64 4
  %248 = load i8, ptr %241, align 1, !tbaa !9
  %249 = xor i8 %248, %246
  %250 = getelementptr inbounds i8, ptr %.086.lcssa, i64 4
  store i8 %249, ptr %244, align 1, !tbaa !9
  %251 = getelementptr inbounds i8, ptr %10, i64 5
  %252 = load i8, ptr %245, align 4, !tbaa !9
  %253 = getelementptr inbounds i8, ptr %.090.lcssa, i64 5
  %254 = load i8, ptr %247, align 1, !tbaa !9
  %255 = xor i8 %254, %252
  %256 = getelementptr inbounds i8, ptr %.086.lcssa, i64 5
  store i8 %255, ptr %250, align 1, !tbaa !9
  %257 = getelementptr inbounds i8, ptr %10, i64 6
  %258 = load i8, ptr %251, align 1, !tbaa !9
  %259 = getelementptr inbounds i8, ptr %.090.lcssa, i64 6
  %260 = load i8, ptr %253, align 1, !tbaa !9
  %261 = xor i8 %260, %258
  %262 = getelementptr inbounds i8, ptr %.086.lcssa, i64 6
  store i8 %261, ptr %256, align 1, !tbaa !9
  %263 = getelementptr inbounds i8, ptr %10, i64 7
  %264 = load i8, ptr %257, align 2, !tbaa !9
  %265 = getelementptr inbounds i8, ptr %.090.lcssa, i64 7
  %266 = load i8, ptr %259, align 1, !tbaa !9
  %267 = xor i8 %266, %264
  %268 = getelementptr inbounds i8, ptr %.086.lcssa, i64 7
  store i8 %267, ptr %262, align 1, !tbaa !9
  %269 = getelementptr inbounds i8, ptr %10, i64 8
  %270 = load i8, ptr %263, align 1, !tbaa !9
  %271 = getelementptr inbounds i8, ptr %.090.lcssa, i64 8
  %272 = load i8, ptr %265, align 1, !tbaa !9
  %273 = xor i8 %272, %270
  %274 = getelementptr inbounds i8, ptr %.086.lcssa, i64 8
  store i8 %273, ptr %268, align 1, !tbaa !9
  %275 = getelementptr inbounds i8, ptr %10, i64 9
  %276 = load i8, ptr %269, align 8, !tbaa !9
  %277 = getelementptr inbounds i8, ptr %.090.lcssa, i64 9
  %278 = load i8, ptr %271, align 1, !tbaa !9
  %279 = xor i8 %278, %276
  %280 = getelementptr inbounds i8, ptr %.086.lcssa, i64 9
  store i8 %279, ptr %274, align 1, !tbaa !9
  %281 = getelementptr inbounds i8, ptr %10, i64 10
  %282 = load i8, ptr %275, align 1, !tbaa !9
  %283 = getelementptr inbounds i8, ptr %.090.lcssa, i64 10
  %284 = load i8, ptr %277, align 1, !tbaa !9
  %285 = xor i8 %284, %282
  %286 = getelementptr inbounds i8, ptr %.086.lcssa, i64 10
  store i8 %285, ptr %280, align 1, !tbaa !9
  %287 = getelementptr inbounds i8, ptr %10, i64 11
  %288 = load i8, ptr %281, align 2, !tbaa !9
  %289 = getelementptr inbounds i8, ptr %.090.lcssa, i64 11
  %290 = load i8, ptr %283, align 1, !tbaa !9
  %291 = xor i8 %290, %288
  %292 = getelementptr inbounds i8, ptr %.086.lcssa, i64 11
  store i8 %291, ptr %286, align 1, !tbaa !9
  %293 = getelementptr inbounds i8, ptr %10, i64 12
  %294 = load i8, ptr %287, align 1, !tbaa !9
  %295 = getelementptr inbounds i8, ptr %.090.lcssa, i64 12
  %296 = load i8, ptr %289, align 1, !tbaa !9
  %297 = xor i8 %296, %294
  %298 = getelementptr inbounds i8, ptr %.086.lcssa, i64 12
  store i8 %297, ptr %292, align 1, !tbaa !9
  %299 = getelementptr inbounds i8, ptr %10, i64 13
  %300 = load i8, ptr %293, align 4, !tbaa !9
  %301 = getelementptr inbounds i8, ptr %.090.lcssa, i64 13
  %302 = load i8, ptr %295, align 1, !tbaa !9
  %303 = xor i8 %302, %300
  %304 = getelementptr inbounds i8, ptr %.086.lcssa, i64 13
  store i8 %303, ptr %298, align 1, !tbaa !9
  %305 = getelementptr inbounds i8, ptr %10, i64 14
  %306 = load i8, ptr %299, align 1, !tbaa !9
  %307 = getelementptr inbounds i8, ptr %.090.lcssa, i64 14
  %308 = load i8, ptr %301, align 1, !tbaa !9
  %309 = xor i8 %308, %306
  %310 = getelementptr inbounds i8, ptr %.086.lcssa, i64 14
  store i8 %309, ptr %304, align 1, !tbaa !9
  %311 = getelementptr inbounds i8, ptr %10, i64 15
  %312 = load i8, ptr %305, align 2, !tbaa !9
  %313 = getelementptr inbounds i8, ptr %.090.lcssa, i64 15
  %314 = load i8, ptr %307, align 1, !tbaa !9
  %315 = xor i8 %314, %312
  %316 = getelementptr inbounds i8, ptr %.086.lcssa, i64 15
  store i8 %315, ptr %310, align 1, !tbaa !9
  %317 = getelementptr inbounds i8, ptr %10, i64 16
  %318 = load i8, ptr %311, align 1, !tbaa !9
  %319 = getelementptr inbounds i8, ptr %.090.lcssa, i64 16
  %320 = load i8, ptr %313, align 1, !tbaa !9
  %321 = xor i8 %320, %318
  %322 = getelementptr inbounds i8, ptr %.086.lcssa, i64 16
  store i8 %321, ptr %316, align 1, !tbaa !9
  %323 = getelementptr inbounds i8, ptr %10, i64 17
  %324 = load i8, ptr %317, align 16, !tbaa !9
  %325 = getelementptr inbounds i8, ptr %.090.lcssa, i64 17
  %326 = load i8, ptr %319, align 1, !tbaa !9
  %327 = xor i8 %326, %324
  %328 = getelementptr inbounds i8, ptr %.086.lcssa, i64 17
  store i8 %327, ptr %322, align 1, !tbaa !9
  %329 = getelementptr inbounds i8, ptr %10, i64 18
  %330 = load i8, ptr %323, align 1, !tbaa !9
  %331 = getelementptr inbounds i8, ptr %.090.lcssa, i64 18
  %332 = load i8, ptr %325, align 1, !tbaa !9
  %333 = xor i8 %332, %330
  %334 = getelementptr inbounds i8, ptr %.086.lcssa, i64 18
  store i8 %333, ptr %328, align 1, !tbaa !9
  %335 = getelementptr inbounds i8, ptr %10, i64 19
  %336 = load i8, ptr %329, align 2, !tbaa !9
  %337 = getelementptr inbounds i8, ptr %.090.lcssa, i64 19
  %338 = load i8, ptr %331, align 1, !tbaa !9
  %339 = xor i8 %338, %336
  %340 = getelementptr inbounds i8, ptr %.086.lcssa, i64 19
  store i8 %339, ptr %334, align 1, !tbaa !9
  %341 = getelementptr inbounds i8, ptr %10, i64 20
  %342 = load i8, ptr %335, align 1, !tbaa !9
  %343 = getelementptr inbounds i8, ptr %.090.lcssa, i64 20
  %344 = load i8, ptr %337, align 1, !tbaa !9
  %345 = xor i8 %344, %342
  %346 = getelementptr inbounds i8, ptr %.086.lcssa, i64 20
  store i8 %345, ptr %340, align 1, !tbaa !9
  %347 = getelementptr inbounds i8, ptr %10, i64 21
  %348 = load i8, ptr %341, align 4, !tbaa !9
  %349 = getelementptr inbounds i8, ptr %.090.lcssa, i64 21
  %350 = load i8, ptr %343, align 1, !tbaa !9
  %351 = xor i8 %350, %348
  %352 = getelementptr inbounds i8, ptr %.086.lcssa, i64 21
  store i8 %351, ptr %346, align 1, !tbaa !9
  %353 = getelementptr inbounds i8, ptr %10, i64 22
  %354 = load i8, ptr %347, align 1, !tbaa !9
  %355 = getelementptr inbounds i8, ptr %.090.lcssa, i64 22
  %356 = load i8, ptr %349, align 1, !tbaa !9
  %357 = xor i8 %356, %354
  %358 = getelementptr inbounds i8, ptr %.086.lcssa, i64 22
  store i8 %357, ptr %352, align 1, !tbaa !9
  %359 = getelementptr inbounds i8, ptr %10, i64 23
  %360 = load i8, ptr %353, align 2, !tbaa !9
  %361 = getelementptr inbounds i8, ptr %.090.lcssa, i64 23
  %362 = load i8, ptr %355, align 1, !tbaa !9
  %363 = xor i8 %362, %360
  %364 = getelementptr inbounds i8, ptr %.086.lcssa, i64 23
  store i8 %363, ptr %358, align 1, !tbaa !9
  %365 = load i8, ptr %359, align 1, !tbaa !9
  %366 = load i8, ptr %361, align 1, !tbaa !9
  %367 = xor i8 %366, %365
  store i8 %367, ptr %364, align 1, !tbaa !9
  %368 = getelementptr inbounds i8, ptr %10, i64 44
  %369 = load i32, ptr %368, align 4, !tbaa !10
  %370 = xor i32 %369, 184549376
  store i32 %370, ptr %368, align 4, !tbaa !10
  %371 = getelementptr inbounds i8, ptr %10, i64 12
  %372 = load i32, ptr %15, align 8, !tbaa !10
  %373 = getelementptr inbounds i8, ptr %10, i64 36
  %374 = getelementptr inbounds i8, ptr %10, i64 4
  %375 = getelementptr inbounds i8, ptr %10, i64 28
  %376 = load i32, ptr %375, align 4, !tbaa !10
  %377 = load <2 x i32>, ptr %371, align 4, !tbaa !10
  %378 = extractelement <2 x i32> %377, i64 0
  %379 = load <2 x i32>, ptr %10, align 16, !tbaa !10
  %380 = extractelement <2 x i32> %377, i64 1
  %381 = xor i32 %376, %380
  store i32 %381, ptr %374, align 4, !tbaa !10
  %382 = load <2 x i32>, ptr %373, align 4, !tbaa !10
  %383 = xor <2 x i32> %379, %382
  %384 = xor <2 x i32> %383, %377
  store <2 x i32> %384, ptr %371, align 4, !tbaa !10
  %385 = getelementptr inbounds i8, ptr %10, i64 8
  %386 = load i32, ptr %385, align 8, !tbaa !10
  %387 = getelementptr inbounds i8, ptr %10, i64 20
  %388 = load i32, ptr %387, align 4, !tbaa !10
  %389 = getelementptr inbounds i8, ptr %10, i64 32
  %390 = load i32, ptr %389, align 16, !tbaa !10
  %391 = xor i32 %390, %388
  store i32 %391, ptr %385, align 8, !tbaa !10
  %392 = xor i32 %386, %370
  %393 = xor i32 %392, %388
  store i32 %393, ptr %387, align 4, !tbaa !10
  %394 = xor i32 %372, %378
  store i32 %394, ptr %10, align 16, !tbaa !10
  %395 = lshr i32 %394, 8
  %396 = lshr i32 %394, 16
  %397 = lshr i32 %394, 24
  %398 = insertelement <4 x i32> poison, i32 %394, i64 0
  %399 = insertelement <4 x i32> %398, i32 %395, i64 1
  %400 = insertelement <4 x i32> %399, i32 %396, i64 2
  %401 = insertelement <4 x i32> %400, i32 %397, i64 3
  %402 = trunc <4 x i32> %401 to <4 x i8>
  %403 = trunc i32 %381 to i8
  %404 = lshr i32 %381, 8
  %405 = trunc i32 %404 to i8
  %406 = lshr i32 %381, 16
  %407 = trunc i32 %406 to i8
  %408 = load <16 x i8>, ptr %263, align 1
  %409 = load i8, ptr %311, align 1, !tbaa !9
  %410 = load <16 x i8>, ptr %.086.lcssa, align 1, !tbaa !9
  %411 = shufflevector <4 x i8> %402, <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>
  %412 = insertelement <16 x i8> %411, i8 %403, i64 4
  %413 = insertelement <16 x i8> %412, i8 %405, i64 5
  %414 = insertelement <16 x i8> %413, i8 %407, i64 6
  %415 = shufflevector <16 x i8> %414, <16 x i8> %408, <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>
  %416 = insertelement <16 x i8> %415, i8 %409, i64 15
  %417 = xor <16 x i8> %410, %416
  store <16 x i8> %417, ptr %10, align 16, !tbaa !9
  %418 = load <4 x i8>, ptr %322, align 1, !tbaa !9
  %419 = load <4 x i8>, ptr %317, align 16, !tbaa !9
  %420 = xor <4 x i8> %419, %418
  store <4 x i8> %420, ptr %317, align 16, !tbaa !9
  %421 = load i8, ptr %346, align 1, !tbaa !9
  %422 = trunc i32 %393 to i8
  %423 = xor i8 %421, %422
  store i8 %423, ptr %341, align 4, !tbaa !9
  %424 = load i8, ptr %352, align 1, !tbaa !9
  %425 = lshr i32 %393, 8
  %426 = trunc i32 %425 to i8
  %427 = xor i8 %424, %426
  store i8 %427, ptr %347, align 1, !tbaa !9
  %428 = load i8, ptr %358, align 1, !tbaa !9
  %429 = lshr i32 %393, 16
  %430 = trunc i32 %429 to i8
  %431 = xor i8 %428, %430
  store i8 %431, ptr %353, align 2, !tbaa !9
  %432 = load i8, ptr %364, align 1, !tbaa !9
  br label %.loopexit

iter.check:                                       ; preds = %._crit_edge
  %433 = trunc nuw i64 %.098.lcssa to i32
  %434 = add nuw nsw i64 %.098.lcssa, 4294967295
  %435 = and i64 %434, 4294967295
  %436 = add nuw nsw i64 %435, 1
  %min.iters.check = icmp ult i64 %435, 7
  br i1 %min.iters.check, label %.lr.ph.preheader, label %vector.memcheck

vector.memcheck:                                  ; preds = %iter.check
  %437 = sub i64 %.086.lcssa161, %11
  %diff.check = icmp ult i64 %437, 32
  %438 = sub i64 %.086.lcssa161, %.090.lcssa162
  %diff.check163 = icmp ult i64 %438, 32
  %conflict.rdx = or i1 %diff.check, %diff.check163
  br i1 %conflict.rdx, label %.lr.ph.preheader, label %vector.main.loop.iter.check

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

vector.ph:                                        ; preds = %vector.main.loop.iter.check
  %n.vec = and i64 %436, 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 %.090.lcssa, i64 %index
  %next.gep166 = getelementptr i8, ptr %10, i64 %index
  %next.gep168 = getelementptr i8, ptr %.086.lcssa, i64 %index
  %439 = getelementptr i8, ptr %next.gep166, i64 16
  %wide.load = load <16 x i8>, ptr %next.gep166, align 16, !tbaa !9
  %wide.load170 = load <16 x i8>, ptr %439, align 16, !tbaa !9
  %440 = getelementptr i8, ptr %next.gep, i64 16
  %wide.load171 = load <16 x i8>, ptr %next.gep, align 1, !tbaa !9
  %wide.load172 = load <16 x i8>, ptr %440, align 1, !tbaa !9
  %441 = xor <16 x i8> %wide.load171, %wide.load
  %442 = xor <16 x i8> %wide.load172, %wide.load170
  %443 = getelementptr i8, ptr %next.gep168, i64 16
  store <16 x i8> %441, ptr %next.gep168, align 1, !tbaa !9
  store <16 x i8> %442, ptr %443, align 1, !tbaa !9
  %index.next = add nuw i64 %index, 32
  %444 = icmp eq i64 %index.next, %n.vec
  br i1 %444, label %middle.block, label %vector.body, !llvm.loop !14

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

vec.epilog.iter.check:                            ; preds = %middle.block
  %ind.end184 = getelementptr i8, ptr %.086.lcssa, i64 %n.vec
  %ind.end181 = getelementptr i8, ptr %10, i64 %n.vec
  %ind.end178 = getelementptr i8, ptr %.090.lcssa, i64 %n.vec
  %.cast175 = trunc i64 %n.vec to i32
  %ind.end176 = sub i32 %433, %.cast175
  %n.vec.remaining = and i64 %436, 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.vec174 = and i64 %436, 8589934584
  %.cast = trunc i64 %n.vec174 to i32
  %ind.end = sub i32 %433, %.cast
  %ind.end177 = getelementptr i8, ptr %.090.lcssa, i64 %n.vec174
  %ind.end180 = getelementptr i8, ptr %10, i64 %n.vec174
  %ind.end183 = getelementptr i8, ptr %.086.lcssa, i64 %n.vec174
  br label %vec.epilog.vector.body

vec.epilog.vector.body:                           ; preds = %vec.epilog.vector.body, %vec.epilog.ph
  %index186 = phi i64 [ %vec.epilog.resume.val, %vec.epilog.ph ], [ %index.next192, %vec.epilog.vector.body ]
  %next.gep187 = getelementptr i8, ptr %.090.lcssa, i64 %index186
  %next.gep188 = getelementptr i8, ptr %10, i64 %index186
  %next.gep189 = getelementptr i8, ptr %.086.lcssa, i64 %index186
  %wide.load190 = load <8 x i8>, ptr %next.gep188, align 8, !tbaa !9
  %wide.load191 = load <8 x i8>, ptr %next.gep187, align 1, !tbaa !9
  %445 = xor <8 x i8> %wide.load191, %wide.load190
  store <8 x i8> %445, ptr %next.gep189, align 1, !tbaa !9
  %index.next192 = add nuw i64 %index186, 8
  %446 = icmp eq i64 %index.next192, %n.vec174
  br i1 %446, label %vec.epilog.middle.block, label %vec.epilog.vector.body, !llvm.loop !17

vec.epilog.middle.block:                          ; preds = %vec.epilog.vector.body
  %cmp.n193 = icmp eq i64 %436, %n.vec174
  br i1 %cmp.n193, label %iter.check199, label %.lr.ph.preheader

.lr.ph.preheader:                                 ; preds = %vec.epilog.middle.block, %vector.memcheck, %iter.check, %vec.epilog.iter.check
  %.082132.ph = phi i32 [ %433, %iter.check ], [ %433, %vector.memcheck ], [ %ind.end176, %vec.epilog.iter.check ], [ %ind.end, %vec.epilog.middle.block ]
  %.083131.ph = phi ptr [ %.090.lcssa, %iter.check ], [ %.090.lcssa, %vector.memcheck ], [ %ind.end178, %vec.epilog.iter.check ], [ %ind.end177, %vec.epilog.middle.block ]
  %.084130.ph = phi ptr [ %10, %iter.check ], [ %10, %vector.memcheck ], [ %ind.end181, %vec.epilog.iter.check ], [ %ind.end180, %vec.epilog.middle.block ]
  %.085129.ph = phi ptr [ %.086.lcssa, %iter.check ], [ %.086.lcssa, %vector.memcheck ], [ %ind.end184, %vec.epilog.iter.check ], [ %ind.end183, %vec.epilog.middle.block ]
  %447 = add nsw i32 %.082132.ph, -1
  %xtraiter = and i32 %.082132.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
  %.082132.prol = phi i32 [ %454, %.lr.ph.prol ], [ %.082132.ph, %.lr.ph.preheader ]
  %.083131.prol = phi ptr [ %450, %.lr.ph.prol ], [ %.083131.ph, %.lr.ph.preheader ]
  %.084130.prol = phi ptr [ %448, %.lr.ph.prol ], [ %.084130.ph, %.lr.ph.preheader ]
  %.085129.prol = phi ptr [ %453, %.lr.ph.prol ], [ %.085129.ph, %.lr.ph.preheader ]
  %prol.iter = phi i32 [ %prol.iter.next, %.lr.ph.prol ], [ 0, %.lr.ph.preheader ]
  %448 = getelementptr inbounds i8, ptr %.084130.prol, i64 1
  %449 = load i8, ptr %.084130.prol, align 1, !tbaa !9
  %450 = getelementptr inbounds i8, ptr %.083131.prol, i64 1
  %451 = load i8, ptr %.083131.prol, align 1, !tbaa !9
  %452 = xor i8 %451, %449
  %453 = getelementptr inbounds i8, ptr %.085129.prol, i64 1
  store i8 %452, ptr %.085129.prol, align 1, !tbaa !9
  %454 = add nsw i32 %.082132.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
  %.082132.unr = phi i32 [ %.082132.ph, %.lr.ph.preheader ], [ %454, %.lr.ph.prol ]
  %.083131.unr = phi ptr [ %.083131.ph, %.lr.ph.preheader ], [ %450, %.lr.ph.prol ]
  %.084130.unr = phi ptr [ %.084130.ph, %.lr.ph.preheader ], [ %448, %.lr.ph.prol ]
  %.085129.unr = phi ptr [ %.085129.ph, %.lr.ph.preheader ], [ %453, %.lr.ph.prol ]
  %455 = icmp ult i32 %447, 3
  br i1 %455, label %iter.check199, label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.prol.loopexit, %.lr.ph
  %.082132 = phi i32 [ %480, %.lr.ph ], [ %.082132.unr, %.lr.ph.prol.loopexit ]
  %.083131 = phi ptr [ %476, %.lr.ph ], [ %.083131.unr, %.lr.ph.prol.loopexit ]
  %.084130 = phi ptr [ %474, %.lr.ph ], [ %.084130.unr, %.lr.ph.prol.loopexit ]
  %.085129 = phi ptr [ %479, %.lr.ph ], [ %.085129.unr, %.lr.ph.prol.loopexit ]
  %456 = getelementptr inbounds i8, ptr %.084130, i64 1
  %457 = load i8, ptr %.084130, align 1, !tbaa !9
  %458 = getelementptr inbounds i8, ptr %.083131, i64 1
  %459 = load i8, ptr %.083131, align 1, !tbaa !9
  %460 = xor i8 %459, %457
  %461 = getelementptr inbounds i8, ptr %.085129, i64 1
  store i8 %460, ptr %.085129, align 1, !tbaa !9
  %462 = getelementptr inbounds i8, ptr %.084130, i64 2
  %463 = load i8, ptr %456, align 1, !tbaa !9
  %464 = getelementptr inbounds i8, ptr %.083131, i64 2
  %465 = load i8, ptr %458, align 1, !tbaa !9
  %466 = xor i8 %465, %463
  %467 = getelementptr inbounds i8, ptr %.085129, i64 2
  store i8 %466, ptr %461, align 1, !tbaa !9
  %468 = getelementptr inbounds i8, ptr %.084130, i64 3
  %469 = load i8, ptr %462, align 1, !tbaa !9
  %470 = getelementptr inbounds i8, ptr %.083131, i64 3
  %471 = load i8, ptr %464, align 1, !tbaa !9
  %472 = xor i8 %471, %469
  %473 = getelementptr inbounds i8, ptr %.085129, i64 3
  store i8 %472, ptr %467, align 1, !tbaa !9
  %474 = getelementptr inbounds i8, ptr %.084130, i64 4
  %475 = load i8, ptr %468, align 1, !tbaa !9
  %476 = getelementptr inbounds i8, ptr %.083131, i64 4
  %477 = load i8, ptr %470, align 1, !tbaa !9
  %478 = xor i8 %477, %475
  %479 = getelementptr inbounds i8, ptr %.085129, i64 4
  store i8 %478, ptr %473, align 1, !tbaa !9
  %480 = add nsw i32 %.082132, -4
  %.not107.3 = icmp eq i32 %480, 0
  br i1 %.not107.3, label %iter.check199, label %.lr.ph, !llvm.loop !20

iter.check199:                                    ; preds = %.lr.ph.prol.loopexit, %.lr.ph, %vec.epilog.middle.block, %middle.block
  %481 = getelementptr inbounds i8, ptr %10, i64 44
  %482 = load i32, ptr %481, align 4, !tbaa !10
  %483 = xor i32 %482, 167772160
  store i32 %483, ptr %481, align 4, !tbaa !10
  %484 = getelementptr inbounds i8, ptr %10, i64 12
  %485 = getelementptr inbounds i8, ptr %10, i64 36
  %486 = load <2 x i32>, ptr %484, align 4, !tbaa !10
  %487 = load <2 x i32>, ptr %15, align 8, !tbaa !10
  %488 = xor <2 x i32> %487, %486
  %489 = load <2 x i32>, ptr %10, align 16, !tbaa !10
  store <2 x i32> %488, ptr %10, align 16, !tbaa !10
  %490 = load <2 x i32>, ptr %485, align 4, !tbaa !10
  %491 = xor <2 x i32> %489, %490
  %492 = xor <2 x i32> %491, %486
  store <2 x i32> %492, ptr %484, align 4, !tbaa !10
  %493 = getelementptr inbounds i8, ptr %10, i64 8
  %494 = load i32, ptr %493, align 8, !tbaa !10
  %495 = getelementptr inbounds i8, ptr %10, i64 20
  %496 = load i32, ptr %495, align 4, !tbaa !10
  %497 = getelementptr inbounds i8, ptr %10, i64 32
  %498 = load i32, ptr %497, align 16, !tbaa !10
  %499 = xor i32 %498, %496
  store i32 %499, ptr %493, align 8, !tbaa !10
  %500 = xor i32 %494, %483
  %501 = xor i32 %500, %496
  store i32 %501, ptr %495, align 4, !tbaa !10
  %502 = add nuw nsw i64 %.098.lcssa, 4294967295
  %503 = and i64 %502, 4294967295
  %504 = add nuw nsw i64 %503, 1
  %min.iters.check197 = icmp ult i64 %503, 7
  br i1 %min.iters.check197, label %.lr.ph140.preheader, label %vector.memcheck194

vector.memcheck194:                               ; preds = %iter.check199
  %505 = add nuw nsw i64 %.098.lcssa, 4294967295
  %506 = and i64 %505, 4294967295
  %507 = add nuw nsw i64 %506, 1
  %scevgep = getelementptr i8, ptr %10, i64 %507
  %scevgep195 = getelementptr i8, ptr %.086.lcssa, i64 %507
  %bound0 = icmp ult ptr %10, %scevgep195
  %bound1 = icmp ult ptr %.086.lcssa, %scevgep
  %found.conflict = and i1 %bound0, %bound1
  br i1 %found.conflict, label %.lr.ph140.preheader, label %vector.main.loop.iter.check201

vector.main.loop.iter.check201:                   ; preds = %vector.memcheck194
  %min.iters.check200 = icmp ult i64 %503, 31
  br i1 %min.iters.check200, label %vec.epilog.ph219, label %vector.ph202

vector.ph202:                                     ; preds = %vector.main.loop.iter.check201
  %n.vec204 = and i64 %504, 8589934560
  br label %vector.body205

vector.body205:                                   ; preds = %vector.body205, %vector.ph202
  %index206 = phi i64 [ 0, %vector.ph202 ], [ %index.next215, %vector.body205 ]
  %next.gep207 = getelementptr i8, ptr %.086.lcssa, i64 %index206
  %next.gep209 = getelementptr i8, ptr %10, i64 %index206
  %508 = getelementptr i8, ptr %next.gep207, i64 16
  %wide.load211 = load <16 x i8>, ptr %next.gep207, align 1, !tbaa !9, !alias.scope !21
  %wide.load212 = load <16 x i8>, ptr %508, align 1, !tbaa !9, !alias.scope !21
  %509 = getelementptr i8, ptr %next.gep209, i64 16
  %wide.load213 = load <16 x i8>, ptr %next.gep209, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %wide.load214 = load <16 x i8>, ptr %509, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %510 = xor <16 x i8> %wide.load213, %wide.load211
  %511 = xor <16 x i8> %wide.load214, %wide.load212
  store <16 x i8> %510, ptr %next.gep209, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  store <16 x i8> %511, ptr %509, align 16, !tbaa !9, !alias.scope !24, !noalias !21
  %index.next215 = add nuw i64 %index206, 32
  %512 = icmp eq i64 %index.next215, %n.vec204
  br i1 %512, label %middle.block196, label %vector.body205, !llvm.loop !26

middle.block196:                                  ; preds = %vector.body205
  %cmp.n216 = icmp eq i64 %504, %n.vec204
  br i1 %cmp.n216, label %._crit_edge141, label %vec.epilog.iter.check220

vec.epilog.iter.check220:                         ; preds = %middle.block196
  %ind.end235 = getelementptr i8, ptr %10, i64 %n.vec204
  %ind.end232 = getelementptr i8, ptr %.086.lcssa, i64 %n.vec204
  %.cast228 = trunc i64 %n.vec204 to i32
  %ind.end229 = sub i32 %433, %.cast228
  %n.vec.remaining221 = and i64 %504, 24
  %min.epilog.iters.check222 = icmp eq i64 %n.vec.remaining221, 0
  br i1 %min.epilog.iters.check222, label %.lr.ph140.preheader, label %vec.epilog.ph219

vec.epilog.ph219:                                 ; preds = %vector.main.loop.iter.check201, %vec.epilog.iter.check220
  %vec.epilog.resume.val223 = phi i64 [ %n.vec204, %vec.epilog.iter.check220 ], [ 0, %vector.main.loop.iter.check201 ]
  %n.vec225 = and i64 %504, 8589934584
  %.cast226 = trunc i64 %n.vec225 to i32
  %ind.end227 = sub i32 %433, %.cast226
  %ind.end231 = getelementptr i8, ptr %.086.lcssa, i64 %n.vec225
  %ind.end234 = getelementptr i8, ptr %10, i64 %n.vec225
  br label %vec.epilog.vector.body237

vec.epilog.vector.body237:                        ; preds = %vec.epilog.vector.body237, %vec.epilog.ph219
  %index238 = phi i64 [ %vec.epilog.resume.val223, %vec.epilog.ph219 ], [ %index.next243, %vec.epilog.vector.body237 ]
  %next.gep239 = getelementptr i8, ptr %.086.lcssa, i64 %index238
  %next.gep240 = getelementptr i8, ptr %10, i64 %index238
  %wide.load241 = load <8 x i8>, ptr %next.gep239, align 1, !tbaa !9, !alias.scope !27
  %wide.load242 = load <8 x i8>, ptr %next.gep240, align 8, !tbaa !9, !alias.scope !30, !noalias !27
  %513 = xor <8 x i8> %wide.load242, %wide.load241
  store <8 x i8> %513, ptr %next.gep240, align 8, !tbaa !9, !alias.scope !30, !noalias !27
  %index.next243 = add nuw i64 %index238, 8
  %514 = icmp eq i64 %index.next243, %n.vec225
  br i1 %514, label %vec.epilog.middle.block217, label %vec.epilog.vector.body237, !llvm.loop !32

vec.epilog.middle.block217:                       ; preds = %vec.epilog.vector.body237
  %cmp.n244 = icmp eq i64 %504, %n.vec225
  br i1 %cmp.n244, label %._crit_edge141, label %.lr.ph140.preheader

.lr.ph140.preheader:                              ; preds = %vec.epilog.middle.block217, %vector.memcheck194, %iter.check199, %vec.epilog.iter.check220
  %.078138.ph = phi i32 [ %433, %iter.check199 ], [ %433, %vector.memcheck194 ], [ %ind.end229, %vec.epilog.iter.check220 ], [ %ind.end227, %vec.epilog.middle.block217 ]
  %.079137.ph = phi ptr [ %.086.lcssa, %iter.check199 ], [ %.086.lcssa, %vector.memcheck194 ], [ %ind.end232, %vec.epilog.iter.check220 ], [ %ind.end231, %vec.epilog.middle.block217 ]
  %.080136.ph = phi ptr [ %10, %iter.check199 ], [ %10, %vector.memcheck194 ], [ %ind.end235, %vec.epilog.iter.check220 ], [ %ind.end234, %vec.epilog.middle.block217 ]
  %515 = add nsw i32 %.078138.ph, -1
  %xtraiter247 = and i32 %.078138.ph, 3
  %lcmp.mod248.not = icmp eq i32 %xtraiter247, 0
  br i1 %lcmp.mod248.not, label %.lr.ph140.prol.loopexit, label %.lr.ph140.prol

.lr.ph140.prol:                                   ; preds = %.lr.ph140.preheader, %.lr.ph140.prol
  %.078138.prol = phi i32 [ %521, %.lr.ph140.prol ], [ %.078138.ph, %.lr.ph140.preheader ]
  %.079137.prol = phi ptr [ %516, %.lr.ph140.prol ], [ %.079137.ph, %.lr.ph140.preheader ]
  %.080136.prol = phi ptr [ %518, %.lr.ph140.prol ], [ %.080136.ph, %.lr.ph140.preheader ]
  %prol.iter249 = phi i32 [ %prol.iter249.next, %.lr.ph140.prol ], [ 0, %.lr.ph140.preheader ]
  %516 = getelementptr inbounds i8, ptr %.079137.prol, i64 1
  %517 = load i8, ptr %.079137.prol, align 1, !tbaa !9
  %518 = getelementptr inbounds i8, ptr %.080136.prol, i64 1
  %519 = load i8, ptr %.080136.prol, align 1, !tbaa !9
  %520 = xor i8 %519, %517
  store i8 %520, ptr %.080136.prol, align 1, !tbaa !9
  %521 = add nsw i32 %.078138.prol, -1
  %prol.iter249.next = add i32 %prol.iter249, 1
  %prol.iter249.cmp.not = icmp eq i32 %prol.iter249.next, %xtraiter247
  br i1 %prol.iter249.cmp.not, label %.lr.ph140.prol.loopexit, label %.lr.ph140.prol, !llvm.loop !33

.lr.ph140.prol.loopexit:                          ; preds = %.lr.ph140.prol, %.lr.ph140.preheader
  %.078138.unr = phi i32 [ %.078138.ph, %.lr.ph140.preheader ], [ %521, %.lr.ph140.prol ]
  %.079137.unr = phi ptr [ %.079137.ph, %.lr.ph140.preheader ], [ %516, %.lr.ph140.prol ]
  %.080136.unr = phi ptr [ %.080136.ph, %.lr.ph140.preheader ], [ %518, %.lr.ph140.prol ]
  %522 = icmp ult i32 %515, 3
  br i1 %522, label %._crit_edge141, label %.lr.ph140

.lr.ph140:                                        ; preds = %.lr.ph140.prol.loopexit, %.lr.ph140
  %.078138 = phi i32 [ %543, %.lr.ph140 ], [ %.078138.unr, %.lr.ph140.prol.loopexit ]
  %.079137 = phi ptr [ %538, %.lr.ph140 ], [ %.079137.unr, %.lr.ph140.prol.loopexit ]
  %.080136 = phi ptr [ %540, %.lr.ph140 ], [ %.080136.unr, %.lr.ph140.prol.loopexit ]
  %523 = getelementptr inbounds i8, ptr %.079137, i64 1
  %524 = load i8, ptr %.079137, align 1, !tbaa !9
  %525 = getelementptr inbounds i8, ptr %.080136, i64 1
  %526 = load i8, ptr %.080136, align 1, !tbaa !9
  %527 = xor i8 %526, %524
  store i8 %527, ptr %.080136, align 1, !tbaa !9
  %528 = getelementptr inbounds i8, ptr %.079137, i64 2
  %529 = load i8, ptr %523, align 1, !tbaa !9
  %530 = getelementptr inbounds i8, ptr %.080136, i64 2
  %531 = load i8, ptr %525, align 1, !tbaa !9
  %532 = xor i8 %531, %529
  store i8 %532, ptr %525, align 1, !tbaa !9
  %533 = getelementptr inbounds i8, ptr %.079137, i64 3
  %534 = load i8, ptr %528, align 1, !tbaa !9
  %535 = getelementptr inbounds i8, ptr %.080136, i64 3
  %536 = load i8, ptr %530, align 1, !tbaa !9
  %537 = xor i8 %536, %534
  store i8 %537, ptr %530, align 1, !tbaa !9
  %538 = getelementptr inbounds i8, ptr %.079137, i64 4
  %539 = load i8, ptr %533, align 1, !tbaa !9
  %540 = getelementptr inbounds i8, ptr %.080136, i64 4
  %541 = load i8, ptr %535, align 1, !tbaa !9
  %542 = xor i8 %541, %539
  store i8 %542, ptr %535, align 1, !tbaa !9
  %543 = add nsw i32 %.078138, -4
  %.not108.3 = icmp eq i32 %543, 0
  br i1 %.not108.3, label %._crit_edge141, label %.lr.ph140, !llvm.loop !34

._crit_edge141:                                   ; preds = %.lr.ph140.prol.loopexit, %.lr.ph140, %vec.epilog.middle.block217, %middle.block196
  %544 = getelementptr inbounds i8, ptr %10, i64 %.098.lcssa
  br label %.loopexit

.loopexit:                                        ; preds = %.preheader.preheader, %._crit_edge141
  %.sink = phi ptr [ %359, %.preheader.preheader ], [ %544, %._crit_edge141 ]
  %.sink158 = phi i8 [ %432, %.preheader.preheader ], [ -128, %._crit_edge141 ]
  %545 = load i8, ptr %.sink, align 1, !tbaa !9
  %546 = xor i8 %545, %.sink158
  store i8 %546, ptr %.sink, align 1, !tbaa !9
  call void @sparkle_384(ptr noundef nonnull %10, i32 noundef 11) #4
  %547 = getelementptr inbounds i8, ptr %.090.lcssa, i64 %.098.lcssa
  br label %548

548:                                              ; preds = %17, %.loopexit
  %.1 = phi ptr [ %547, %.loopexit ], [ %3, %17 ]
  %549 = getelementptr inbounds i8, ptr %8, i64 16
  %550 = getelementptr inbounds i8, ptr %10, i64 40
  %551 = load <16 x i8>, ptr %8, align 1, !tbaa !9
  %552 = load <16 x i8>, ptr %15, align 8, !tbaa !9
  %553 = xor <16 x i8> %552, %551
  store <16 x i8> %553, ptr %15, align 8, !tbaa !9
  %554 = load <8 x i8>, ptr %549, align 1, !tbaa !9
  %555 = load <8 x i8>, ptr %550, align 8, !tbaa !9
  %556 = xor <8 x i8> %555, %554
  store <8 x i8> %556, ptr %550, align 8, !tbaa !9
  %557 = load i64, ptr %1, align 8, !tbaa !5
  %558 = call i32 @aead_check_tag(ptr noundef %0, i64 noundef %557, ptr noundef nonnull %15, ptr noundef %.1, i32 noundef 24) #4
  br label %559

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

; 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

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

; 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