; LLVM IR from openssl/openssl :: crypto/aes (aes_x86core)

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

%struct.aes_key_st = type { [60 x i32], i32 }

@Te4 = external hidden constant [256 x i8], align 16
@rcon = external hidden constant [10 x i32], align 16

; Function Attrs: nounwind uwtable
define dso_local i32 @AES_set_encrypt_key(ptr noundef %0, i32 noundef %1, ptr noundef %2) #0 {
  %4 = alloca i32, align 4
  %5 = alloca ptr, align 8
  %6 = alloca i32, align 4
  %7 = alloca ptr, align 8
  %8 = alloca ptr, align 8
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca i32, align 4
  store ptr %0, ptr %5, align 8, !tbaa !5
  store i32 %1, ptr %6, align 4, !tbaa !9
  store ptr %2, ptr %7, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #2
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #2
  store i32 0, ptr %9, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #2
  %12 = load ptr, ptr %5, align 8, !tbaa !5
  %13 = icmp ne ptr %12, null
  br i1 %13, label %14, label %17

14:                                               ; preds = %3
  %15 = load ptr, ptr %7, align 8, !tbaa !5
  %16 = icmp ne ptr %15, null
  br i1 %16, label %18, label %17

17:                                               ; preds = %14, %3
  store i32 -1, ptr %4, align 4
  store i32 1, ptr %11, align 4
  br label %431

18:                                               ; preds = %14
  %19 = load i32, ptr %6, align 4, !tbaa !9
  %20 = icmp ne i32 %19, 128
  br i1 %20, label %21, label %28

21:                                               ; preds = %18
  %22 = load i32, ptr %6, align 4, !tbaa !9
  %23 = icmp ne i32 %22, 192
  br i1 %23, label %24, label %28

24:                                               ; preds = %21
  %25 = load i32, ptr %6, align 4, !tbaa !9
  %26 = icmp ne i32 %25, 256
  br i1 %26, label %27, label %28

27:                                               ; preds = %24
  store i32 -2, ptr %4, align 4
  store i32 1, ptr %11, align 4
  br label %431

28:                                               ; preds = %24, %21, %18
  %29 = load ptr, ptr %7, align 8, !tbaa !5
  %30 = getelementptr inbounds %struct.aes_key_st, ptr %29, i32 0, i32 0
  %31 = getelementptr inbounds [60 x i32], ptr %30, i64 0, i64 0
  store ptr %31, ptr %8, align 8, !tbaa !5
  %32 = load i32, ptr %6, align 4, !tbaa !9
  %33 = icmp eq i32 %32, 128
  br i1 %33, label %34, label %37

34:                                               ; preds = %28
  %35 = load ptr, ptr %7, align 8, !tbaa !5
  %36 = getelementptr inbounds %struct.aes_key_st, ptr %35, i32 0, i32 1
  store i32 10, ptr %36, align 4, !tbaa !11
  br label %47

37:                                               ; preds = %28
  %38 = load i32, ptr %6, align 4, !tbaa !9
  %39 = icmp eq i32 %38, 192
  br i1 %39, label %40, label %43

40:                                               ; preds = %37
  %41 = load ptr, ptr %7, align 8, !tbaa !5
  %42 = getelementptr inbounds %struct.aes_key_st, ptr %41, i32 0, i32 1
  store i32 12, ptr %42, align 4, !tbaa !11
  br label %46

43:                                               ; preds = %37
  %44 = load ptr, ptr %7, align 8, !tbaa !5
  %45 = getelementptr inbounds %struct.aes_key_st, ptr %44, i32 0, i32 1
  store i32 14, ptr %45, align 4, !tbaa !11
  br label %46

46:                                               ; preds = %43, %40
  br label %47

47:                                               ; preds = %46, %34
  %48 = load ptr, ptr %5, align 8, !tbaa !5
  %49 = load i32, ptr %48, align 4, !tbaa !9
  %50 = load ptr, ptr %8, align 8, !tbaa !5
  %51 = getelementptr inbounds i32, ptr %50, i64 0
  store i32 %49, ptr %51, align 4, !tbaa !9
  %52 = load ptr, ptr %5, align 8, !tbaa !5
  %53 = getelementptr inbounds i8, ptr %52, i64 4
  %54 = load i32, ptr %53, align 4, !tbaa !9
  %55 = load ptr, ptr %8, align 8, !tbaa !5
  %56 = getelementptr inbounds i32, ptr %55, i64 1
  store i32 %54, ptr %56, align 4, !tbaa !9
  %57 = load ptr, ptr %5, align 8, !tbaa !5
  %58 = getelementptr inbounds i8, ptr %57, i64 8
  %59 = load i32, ptr %58, align 4, !tbaa !9
  %60 = load ptr, ptr %8, align 8, !tbaa !5
  %61 = getelementptr inbounds i32, ptr %60, i64 2
  store i32 %59, ptr %61, align 4, !tbaa !9
  %62 = load ptr, ptr %5, align 8, !tbaa !5
  %63 = getelementptr inbounds i8, ptr %62, i64 12
  %64 = load i32, ptr %63, align 4, !tbaa !9
  %65 = load ptr, ptr %8, align 8, !tbaa !5
  %66 = getelementptr inbounds i32, ptr %65, i64 3
  store i32 %64, ptr %66, align 4, !tbaa !9
  %67 = load i32, ptr %6, align 4, !tbaa !9
  %68 = icmp eq i32 %67, 128
  br i1 %68, label %69, label %152

69:                                               ; preds = %47
  br label %70

70:                                               ; preds = %149, %69
  br label %71

71:                                               ; preds = %70
  %72 = load ptr, ptr %8, align 8, !tbaa !5
  %73 = getelementptr inbounds i32, ptr %72, i64 3
  %74 = load i32, ptr %73, align 4, !tbaa !9
  store i32 %74, ptr %10, align 4, !tbaa !9
  %75 = load ptr, ptr %8, align 8, !tbaa !5
  %76 = getelementptr inbounds i32, ptr %75, i64 0
  %77 = load i32, ptr %76, align 4, !tbaa !9
  %78 = load i32, ptr %10, align 4, !tbaa !9
  %79 = lshr i32 %78, 8
  %80 = and i32 %79, 255
  %81 = zext i32 %80 to i64
  %82 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %81
  %83 = load i8, ptr %82, align 1, !tbaa !13
  %84 = zext i8 %83 to i32
  %85 = xor i32 %77, %84
  %86 = load i32, ptr %10, align 4, !tbaa !9
  %87 = lshr i32 %86, 16
  %88 = and i32 %87, 255
  %89 = zext i32 %88 to i64
  %90 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %89
  %91 = load i8, ptr %90, align 1, !tbaa !13
  %92 = zext i8 %91 to i32
  %93 = shl i32 %92, 8
  %94 = xor i32 %85, %93
  %95 = load i32, ptr %10, align 4, !tbaa !9
  %96 = lshr i32 %95, 24
  %97 = zext i32 %96 to i64
  %98 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %97
  %99 = load i8, ptr %98, align 1, !tbaa !13
  %100 = zext i8 %99 to i32
  %101 = shl i32 %100, 16
  %102 = xor i32 %94, %101
  %103 = load i32, ptr %10, align 4, !tbaa !9
  %104 = and i32 %103, 255
  %105 = zext i32 %104 to i64
  %106 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %105
  %107 = load i8, ptr %106, align 1, !tbaa !13
  %108 = zext i8 %107 to i32
  %109 = shl i32 %108, 24
  %110 = xor i32 %102, %109
  %111 = load i32, ptr %9, align 4, !tbaa !9
  %112 = sext i32 %111 to i64
  %113 = getelementptr inbounds [10 x i32], ptr @rcon, i64 0, i64 %112
  %114 = load i32, ptr %113, align 4, !tbaa !9
  %115 = xor i32 %110, %114
  %116 = load ptr, ptr %8, align 8, !tbaa !5
  %117 = getelementptr inbounds i32, ptr %116, i64 4
  store i32 %115, ptr %117, align 4, !tbaa !9
  %118 = load ptr, ptr %8, align 8, !tbaa !5
  %119 = getelementptr inbounds i32, ptr %118, i64 1
  %120 = load i32, ptr %119, align 4, !tbaa !9
  %121 = load ptr, ptr %8, align 8, !tbaa !5
  %122 = getelementptr inbounds i32, ptr %121, i64 4
  %123 = load i32, ptr %122, align 4, !tbaa !9
  %124 = xor i32 %120, %123
  %125 = load ptr, ptr %8, align 8, !tbaa !5
  %126 = getelementptr inbounds i32, ptr %125, i64 5
  store i32 %124, ptr %126, align 4, !tbaa !9
  %127 = load ptr, ptr %8, align 8, !tbaa !5
  %128 = getelementptr inbounds i32, ptr %127, i64 2
  %129 = load i32, ptr %128, align 4, !tbaa !9
  %130 = load ptr, ptr %8, align 8, !tbaa !5
  %131 = getelementptr inbounds i32, ptr %130, i64 5
  %132 = load i32, ptr %131, align 4, !tbaa !9
  %133 = xor i32 %129, %132
  %134 = load ptr, ptr %8, align 8, !tbaa !5
  %135 = getelementptr inbounds i32, ptr %134, i64 6
  store i32 %133, ptr %135, align 4, !tbaa !9
  %136 = load ptr, ptr %8, align 8, !tbaa !5
  %137 = getelementptr inbounds i32, ptr %136, i64 3
  %138 = load i32, ptr %137, align 4, !tbaa !9
  %139 = load ptr, ptr %8, align 8, !tbaa !5
  %140 = getelementptr inbounds i32, ptr %139, i64 6
  %141 = load i32, ptr %140, align 4, !tbaa !9
  %142 = xor i32 %138, %141
  %143 = load ptr, ptr %8, align 8, !tbaa !5
  %144 = getelementptr inbounds i32, ptr %143, i64 7
  store i32 %142, ptr %144, align 4, !tbaa !9
  %145 = load i32, ptr %9, align 4, !tbaa !9
  %146 = add nsw i32 %145, 1
  store i32 %146, ptr %9, align 4, !tbaa !9
  %147 = icmp eq i32 %146, 10
  br i1 %147, label %148, label %149

148:                                              ; preds = %71
  store i32 0, ptr %4, align 4
  store i32 1, ptr %11, align 4
  br label %431

149:                                              ; preds = %71
  %150 = load ptr, ptr %8, align 8, !tbaa !5
  %151 = getelementptr inbounds i32, ptr %150, i64 4
  store ptr %151, ptr %8, align 8, !tbaa !5
  br label %70

152:                                              ; preds = %47
  %153 = load ptr, ptr %5, align 8, !tbaa !5
  %154 = getelementptr inbounds i8, ptr %153, i64 16
  %155 = load i32, ptr %154, align 4, !tbaa !9
  %156 = load ptr, ptr %8, align 8, !tbaa !5
  %157 = getelementptr inbounds i32, ptr %156, i64 4
  store i32 %155, ptr %157, align 4, !tbaa !9
  %158 = load ptr, ptr %5, align 8, !tbaa !5
  %159 = getelementptr inbounds i8, ptr %158, i64 20
  %160 = load i32, ptr %159, align 4, !tbaa !9
  %161 = load ptr, ptr %8, align 8, !tbaa !5
  %162 = getelementptr inbounds i32, ptr %161, i64 5
  store i32 %160, ptr %162, align 4, !tbaa !9
  %163 = load i32, ptr %6, align 4, !tbaa !9
  %164 = icmp eq i32 %163, 192
  br i1 %164, label %165, label %266

165:                                              ; preds = %152
  br label %166

166:                                              ; preds = %245, %165
  br label %167

167:                                              ; preds = %166
  %168 = load ptr, ptr %8, align 8, !tbaa !5
  %169 = getelementptr inbounds i32, ptr %168, i64 5
  %170 = load i32, ptr %169, align 4, !tbaa !9
  store i32 %170, ptr %10, align 4, !tbaa !9
  %171 = load ptr, ptr %8, align 8, !tbaa !5
  %172 = getelementptr inbounds i32, ptr %171, i64 0
  %173 = load i32, ptr %172, align 4, !tbaa !9
  %174 = load i32, ptr %10, align 4, !tbaa !9
  %175 = lshr i32 %174, 8
  %176 = and i32 %175, 255
  %177 = zext i32 %176 to i64
  %178 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %177
  %179 = load i8, ptr %178, align 1, !tbaa !13
  %180 = zext i8 %179 to i32
  %181 = xor i32 %173, %180
  %182 = load i32, ptr %10, align 4, !tbaa !9
  %183 = lshr i32 %182, 16
  %184 = and i32 %183, 255
  %185 = zext i32 %184 to i64
  %186 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %185
  %187 = load i8, ptr %186, align 1, !tbaa !13
  %188 = zext i8 %187 to i32
  %189 = shl i32 %188, 8
  %190 = xor i32 %181, %189
  %191 = load i32, ptr %10, align 4, !tbaa !9
  %192 = lshr i32 %191, 24
  %193 = zext i32 %192 to i64
  %194 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %193
  %195 = load i8, ptr %194, align 1, !tbaa !13
  %196 = zext i8 %195 to i32
  %197 = shl i32 %196, 16
  %198 = xor i32 %190, %197
  %199 = load i32, ptr %10, align 4, !tbaa !9
  %200 = and i32 %199, 255
  %201 = zext i32 %200 to i64
  %202 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %201
  %203 = load i8, ptr %202, align 1, !tbaa !13
  %204 = zext i8 %203 to i32
  %205 = shl i32 %204, 24
  %206 = xor i32 %198, %205
  %207 = load i32, ptr %9, align 4, !tbaa !9
  %208 = sext i32 %207 to i64
  %209 = getelementptr inbounds [10 x i32], ptr @rcon, i64 0, i64 %208
  %210 = load i32, ptr %209, align 4, !tbaa !9
  %211 = xor i32 %206, %210
  %212 = load ptr, ptr %8, align 8, !tbaa !5
  %213 = getelementptr inbounds i32, ptr %212, i64 6
  store i32 %211, ptr %213, align 4, !tbaa !9
  %214 = load ptr, ptr %8, align 8, !tbaa !5
  %215 = getelementptr inbounds i32, ptr %214, i64 1
  %216 = load i32, ptr %215, align 4, !tbaa !9
  %217 = load ptr, ptr %8, align 8, !tbaa !5
  %218 = getelementptr inbounds i32, ptr %217, i64 6
  %219 = load i32, ptr %218, align 4, !tbaa !9
  %220 = xor i32 %216, %219
  %221 = load ptr, ptr %8, align 8, !tbaa !5
  %222 = getelementptr inbounds i32, ptr %221, i64 7
  store i32 %220, ptr %222, align 4, !tbaa !9
  %223 = load ptr, ptr %8, align 8, !tbaa !5
  %224 = getelementptr inbounds i32, ptr %223, i64 2
  %225 = load i32, ptr %224, align 4, !tbaa !9
  %226 = load ptr, ptr %8, align 8, !tbaa !5
  %227 = getelementptr inbounds i32, ptr %226, i64 7
  %228 = load i32, ptr %227, align 4, !tbaa !9
  %229 = xor i32 %225, %228
  %230 = load ptr, ptr %8, align 8, !tbaa !5
  %231 = getelementptr inbounds i32, ptr %230, i64 8
  store i32 %229, ptr %231, align 4, !tbaa !9
  %232 = load ptr, ptr %8, align 8, !tbaa !5
  %233 = getelementptr inbounds i32, ptr %232, i64 3
  %234 = load i32, ptr %233, align 4, !tbaa !9
  %235 = load ptr, ptr %8, align 8, !tbaa !5
  %236 = getelementptr inbounds i32, ptr %235, i64 8
  %237 = load i32, ptr %236, align 4, !tbaa !9
  %238 = xor i32 %234, %237
  %239 = load ptr, ptr %8, align 8, !tbaa !5
  %240 = getelementptr inbounds i32, ptr %239, i64 9
  store i32 %238, ptr %240, align 4, !tbaa !9
  %241 = load i32, ptr %9, align 4, !tbaa !9
  %242 = add nsw i32 %241, 1
  store i32 %242, ptr %9, align 4, !tbaa !9
  %243 = icmp eq i32 %242, 8
  br i1 %243, label %244, label %245

244:                                              ; preds = %167
  store i32 0, ptr %4, align 4
  store i32 1, ptr %11, align 4
  br label %431

245:                                              ; preds = %167
  %246 = load ptr, ptr %8, align 8, !tbaa !5
  %247 = getelementptr inbounds i32, ptr %246, i64 4
  %248 = load i32, ptr %247, align 4, !tbaa !9
  %249 = load ptr, ptr %8, align 8, !tbaa !5
  %250 = getelementptr inbounds i32, ptr %249, i64 9
  %251 = load i32, ptr %250, align 4, !tbaa !9
  %252 = xor i32 %248, %251
  %253 = load ptr, ptr %8, align 8, !tbaa !5
  %254 = getelementptr inbounds i32, ptr %253, i64 10
  store i32 %252, ptr %254, align 4, !tbaa !9
  %255 = load ptr, ptr %8, align 8, !tbaa !5
  %256 = getelementptr inbounds i32, ptr %255, i64 5
  %257 = load i32, ptr %256, align 4, !tbaa !9
  %258 = load ptr, ptr %8, align 8, !tbaa !5
  %259 = getelementptr inbounds i32, ptr %258, i64 10
  %260 = load i32, ptr %259, align 4, !tbaa !9
  %261 = xor i32 %257, %260
  %262 = load ptr, ptr %8, align 8, !tbaa !5
  %263 = getelementptr inbounds i32, ptr %262, i64 11
  store i32 %261, ptr %263, align 4, !tbaa !9
  %264 = load ptr, ptr %8, align 8, !tbaa !5
  %265 = getelementptr inbounds i32, ptr %264, i64 6
  store ptr %265, ptr %8, align 8, !tbaa !5
  br label %166

266:                                              ; preds = %152
  %267 = load ptr, ptr %5, align 8, !tbaa !5
  %268 = getelementptr inbounds i8, ptr %267, i64 24
  %269 = load i32, ptr %268, align 4, !tbaa !9
  %270 = load ptr, ptr %8, align 8, !tbaa !5
  %271 = getelementptr inbounds i32, ptr %270, i64 6
  store i32 %269, ptr %271, align 4, !tbaa !9
  %272 = load ptr, ptr %5, align 8, !tbaa !5
  %273 = getelementptr inbounds i8, ptr %272, i64 28
  %274 = load i32, ptr %273, align 4, !tbaa !9
  %275 = load ptr, ptr %8, align 8, !tbaa !5
  %276 = getelementptr inbounds i32, ptr %275, i64 7
  store i32 %274, ptr %276, align 4, !tbaa !9
  %277 = load i32, ptr %6, align 4, !tbaa !9
  %278 = icmp eq i32 %277, 256
  br i1 %278, label %279, label %430

279:                                              ; preds = %266
  br label %280

280:                                              ; preds = %359, %279
  br label %281

281:                                              ; preds = %280
  %282 = load ptr, ptr %8, align 8, !tbaa !5
  %283 = getelementptr inbounds i32, ptr %282, i64 7
  %284 = load i32, ptr %283, align 4, !tbaa !9
  store i32 %284, ptr %10, align 4, !tbaa !9
  %285 = load ptr, ptr %8, align 8, !tbaa !5
  %286 = getelementptr inbounds i32, ptr %285, i64 0
  %287 = load i32, ptr %286, align 4, !tbaa !9
  %288 = load i32, ptr %10, align 4, !tbaa !9
  %289 = lshr i32 %288, 8
  %290 = and i32 %289, 255
  %291 = zext i32 %290 to i64
  %292 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %291
  %293 = load i8, ptr %292, align 1, !tbaa !13
  %294 = zext i8 %293 to i32
  %295 = xor i32 %287, %294
  %296 = load i32, ptr %10, align 4, !tbaa !9
  %297 = lshr i32 %296, 16
  %298 = and i32 %297, 255
  %299 = zext i32 %298 to i64
  %300 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %299
  %301 = load i8, ptr %300, align 1, !tbaa !13
  %302 = zext i8 %301 to i32
  %303 = shl i32 %302, 8
  %304 = xor i32 %295, %303
  %305 = load i32, ptr %10, align 4, !tbaa !9
  %306 = lshr i32 %305, 24
  %307 = zext i32 %306 to i64
  %308 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %307
  %309 = load i8, ptr %308, align 1, !tbaa !13
  %310 = zext i8 %309 to i32
  %311 = shl i32 %310, 16
  %312 = xor i32 %304, %311
  %313 = load i32, ptr %10, align 4, !tbaa !9
  %314 = and i32 %313, 255
  %315 = zext i32 %314 to i64
  %316 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %315
  %317 = load i8, ptr %316, align 1, !tbaa !13
  %318 = zext i8 %317 to i32
  %319 = shl i32 %318, 24
  %320 = xor i32 %312, %319
  %321 = load i32, ptr %9, align 4, !tbaa !9
  %322 = sext i32 %321 to i64
  %323 = getelementptr inbounds [10 x i32], ptr @rcon, i64 0, i64 %322
  %324 = load i32, ptr %323, align 4, !tbaa !9
  %325 = xor i32 %320, %324
  %326 = load ptr, ptr %8, align 8, !tbaa !5
  %327 = getelementptr inbounds i32, ptr %326, i64 8
  store i32 %325, ptr %327, align 4, !tbaa !9
  %328 = load ptr, ptr %8, align 8, !tbaa !5
  %329 = getelementptr inbounds i32, ptr %328, i64 1
  %330 = load i32, ptr %329, align 4, !tbaa !9
  %331 = load ptr, ptr %8, align 8, !tbaa !5
  %332 = getelementptr inbounds i32, ptr %331, i64 8
  %333 = load i32, ptr %332, align 4, !tbaa !9
  %334 = xor i32 %330, %333
  %335 = load ptr, ptr %8, align 8, !tbaa !5
  %336 = getelementptr inbounds i32, ptr %335, i64 9
  store i32 %334, ptr %336, align 4, !tbaa !9
  %337 = load ptr, ptr %8, align 8, !tbaa !5
  %338 = getelementptr inbounds i32, ptr %337, i64 2
  %339 = load i32, ptr %338, align 4, !tbaa !9
  %340 = load ptr, ptr %8, align 8, !tbaa !5
  %341 = getelementptr inbounds i32, ptr %340, i64 9
  %342 = load i32, ptr %341, align 4, !tbaa !9
  %343 = xor i32 %339, %342
  %344 = load ptr, ptr %8, align 8, !tbaa !5
  %345 = getelementptr inbounds i32, ptr %344, i64 10
  store i32 %343, ptr %345, align 4, !tbaa !9
  %346 = load ptr, ptr %8, align 8, !tbaa !5
  %347 = getelementptr inbounds i32, ptr %346, i64 3
  %348 = load i32, ptr %347, align 4, !tbaa !9
  %349 = load ptr, ptr %8, align 8, !tbaa !5
  %350 = getelementptr inbounds i32, ptr %349, i64 10
  %351 = load i32, ptr %350, align 4, !tbaa !9
  %352 = xor i32 %348, %351
  %353 = load ptr, ptr %8, align 8, !tbaa !5
  %354 = getelementptr inbounds i32, ptr %353, i64 11
  store i32 %352, ptr %354, align 4, !tbaa !9
  %355 = load i32, ptr %9, align 4, !tbaa !9
  %356 = add nsw i32 %355, 1
  store i32 %356, ptr %9, align 4, !tbaa !9
  %357 = icmp eq i32 %356, 7
  br i1 %357, label %358, label %359

358:                                              ; preds = %281
  store i32 0, ptr %4, align 4
  store i32 1, ptr %11, align 4
  br label %431

359:                                              ; preds = %281
  %360 = load ptr, ptr %8, align 8, !tbaa !5
  %361 = getelementptr inbounds i32, ptr %360, i64 11
  %362 = load i32, ptr %361, align 4, !tbaa !9
  store i32 %362, ptr %10, align 4, !tbaa !9
  %363 = load ptr, ptr %8, align 8, !tbaa !5
  %364 = getelementptr inbounds i32, ptr %363, i64 4
  %365 = load i32, ptr %364, align 4, !tbaa !9
  %366 = load i32, ptr %10, align 4, !tbaa !9
  %367 = and i32 %366, 255
  %368 = zext i32 %367 to i64
  %369 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %368
  %370 = load i8, ptr %369, align 1, !tbaa !13
  %371 = zext i8 %370 to i32
  %372 = xor i32 %365, %371
  %373 = load i32, ptr %10, align 4, !tbaa !9
  %374 = lshr i32 %373, 8
  %375 = and i32 %374, 255
  %376 = zext i32 %375 to i64
  %377 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %376
  %378 = load i8, ptr %377, align 1, !tbaa !13
  %379 = zext i8 %378 to i32
  %380 = shl i32 %379, 8
  %381 = xor i32 %372, %380
  %382 = load i32, ptr %10, align 4, !tbaa !9
  %383 = lshr i32 %382, 16
  %384 = and i32 %383, 255
  %385 = zext i32 %384 to i64
  %386 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %385
  %387 = load i8, ptr %386, align 1, !tbaa !13
  %388 = zext i8 %387 to i32
  %389 = shl i32 %388, 16
  %390 = xor i32 %381, %389
  %391 = load i32, ptr %10, align 4, !tbaa !9
  %392 = lshr i32 %391, 24
  %393 = zext i32 %392 to i64
  %394 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %393
  %395 = load i8, ptr %394, align 1, !tbaa !13
  %396 = zext i8 %395 to i32
  %397 = shl i32 %396, 24
  %398 = xor i32 %390, %397
  %399 = load ptr, ptr %8, align 8, !tbaa !5
  %400 = getelementptr inbounds i32, ptr %399, i64 12
  store i32 %398, ptr %400, align 4, !tbaa !9
  %401 = load ptr, ptr %8, align 8, !tbaa !5
  %402 = getelementptr inbounds i32, ptr %401, i64 5
  %403 = load i32, ptr %402, align 4, !tbaa !9
  %404 = load ptr, ptr %8, align 8, !tbaa !5
  %405 = getelementptr inbounds i32, ptr %404, i64 12
  %406 = load i32, ptr %405, align 4, !tbaa !9
  %407 = xor i32 %403, %406
  %408 = load ptr, ptr %8, align 8, !tbaa !5
  %409 = getelementptr inbounds i32, ptr %408, i64 13
  store i32 %407, ptr %409, align 4, !tbaa !9
  %410 = load ptr, ptr %8, align 8, !tbaa !5
  %411 = getelementptr inbounds i32, ptr %410, i64 6
  %412 = load i32, ptr %411, align 4, !tbaa !9
  %413 = load ptr, ptr %8, align 8, !tbaa !5
  %414 = getelementptr inbounds i32, ptr %413, i64 13
  %415 = load i32, ptr %414, align 4, !tbaa !9
  %416 = xor i32 %412, %415
  %417 = load ptr, ptr %8, align 8, !tbaa !5
  %418 = getelementptr inbounds i32, ptr %417, i64 14
  store i32 %416, ptr %418, align 4, !tbaa !9
  %419 = load ptr, ptr %8, align 8, !tbaa !5
  %420 = getelementptr inbounds i32, ptr %419, i64 7
  %421 = load i32, ptr %420, align 4, !tbaa !9
  %422 = load ptr, ptr %8, align 8, !tbaa !5
  %423 = getelementptr inbounds i32, ptr %422, i64 14
  %424 = load i32, ptr %423, align 4, !tbaa !9
  %425 = xor i32 %421, %424
  %426 = load ptr, ptr %8, align 8, !tbaa !5
  %427 = getelementptr inbounds i32, ptr %426, i64 15
  store i32 %425, ptr %427, align 4, !tbaa !9
  %428 = load ptr, ptr %8, align 8, !tbaa !5
  %429 = getelementptr inbounds i32, ptr %428, i64 8
  store ptr %429, ptr %8, align 8, !tbaa !5
  br label %280

430:                                              ; preds = %266
  store i32 0, ptr %4, align 4
  store i32 1, ptr %11, align 4
  br label %431

431:                                              ; preds = %430, %358, %244, %148, %27, %17
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #2
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #2
  call void @llvm.lifetime.end.p0(i64 8, ptr %8) #2
  %432 = load i32, ptr %4, align 4
  ret i32 %432
}

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

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { 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 = !{!"int", !7, i64 0}
!11 = !{!12, !10, i64 240}
!12 = !{!"aes_key_st", !7, i64 0, !10, i64 240}
!13 = !{!7, !7, i64 0}


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

@Te4 = external hidden local_unnamed_addr constant [256 x i8], align 16
@rcon = external hidden local_unnamed_addr constant [10 x i32], align 16

; Function Attrs: nofree norecurse nosync nounwind memory(readwrite, inaccessiblemem: none) uwtable
define dso_local range(i32 -2, 1) i32 @AES_set_encrypt_key(ptr noundef readonly %0, i32 noundef %1, ptr noundef %2) local_unnamed_addr #0 {
  %4 = icmp ne ptr %0, null
  %5 = icmp ne ptr %2, null
  %or.cond = and i1 %4, %5
  br i1 %or.cond, label %6, label %.loopexit

6:                                                ; preds = %3
  switch i32 %1, label %.loopexit [
    i32 256, label %7
    i32 192, label %7
    i32 128, label %7
  ]

7:                                                ; preds = %6, %6, %6
  %8 = icmp eq i32 %1, 128
  br i1 %8, label %9, label %11

9:                                                ; preds = %7
  %10 = getelementptr inbounds i8, ptr %2, i64 240
  store i32 10, ptr %10, align 4, !tbaa !5
  br label %16

11:                                               ; preds = %7
  %12 = icmp eq i32 %1, 192
  %13 = getelementptr inbounds i8, ptr %2, i64 240
  br i1 %12, label %14, label %15

14:                                               ; preds = %11
  store i32 12, ptr %13, align 4, !tbaa !5
  br label %16

15:                                               ; preds = %11
  store i32 14, ptr %13, align 4, !tbaa !5
  br label %16

16:                                               ; preds = %14, %15, %9
  %17 = load i32, ptr %0, align 4, !tbaa !10
  store i32 %17, ptr %2, align 4, !tbaa !10
  %18 = getelementptr inbounds i8, ptr %0, i64 4
  %19 = load i32, ptr %18, align 4, !tbaa !10
  %20 = getelementptr inbounds i8, ptr %2, i64 4
  store i32 %19, ptr %20, align 4, !tbaa !10
  %21 = getelementptr inbounds i8, ptr %0, i64 8
  %22 = load i32, ptr %21, align 4, !tbaa !10
  %23 = getelementptr inbounds i8, ptr %2, i64 8
  store i32 %22, ptr %23, align 4, !tbaa !10
  %24 = getelementptr inbounds i8, ptr %0, i64 12
  %25 = load i32, ptr %24, align 4, !tbaa !10
  %26 = getelementptr inbounds i8, ptr %2, i64 12
  store i32 %25, ptr %26, align 4, !tbaa !10
  br i1 %8, label %.preheader.preheader, label %422

.preheader.preheader:                             ; preds = %16
  %27 = lshr i32 %25, 8
  %28 = and i32 %27, 255
  %29 = zext nneg i32 %28 to i64
  %30 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %29
  %31 = load i8, ptr %30, align 1, !tbaa !11
  %32 = zext i8 %31 to i32
  %33 = lshr i32 %25, 16
  %34 = and i32 %33, 255
  %35 = zext nneg i32 %34 to i64
  %36 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %35
  %37 = load i8, ptr %36, align 1, !tbaa !11
  %38 = zext i8 %37 to i32
  %39 = shl nuw nsw i32 %38, 8
  %40 = or disjoint i32 %39, %32
  %41 = lshr i32 %25, 24
  %42 = zext nneg i32 %41 to i64
  %43 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %42
  %44 = load i8, ptr %43, align 1, !tbaa !11
  %45 = zext i8 %44 to i32
  %46 = shl nuw nsw i32 %45, 16
  %47 = or disjoint i32 %40, %46
  %48 = and i32 %25, 255
  %49 = zext nneg i32 %48 to i64
  %50 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %49
  %51 = load i8, ptr %50, align 1, !tbaa !11
  %52 = zext i8 %51 to i32
  %53 = shl nuw i32 %52, 24
  %54 = load i32, ptr @rcon, align 16, !tbaa !10
  %55 = xor i32 %47, %54
  %56 = xor i32 %55, %53
  %57 = xor i32 %56, %17
  %58 = getelementptr inbounds i8, ptr %2, i64 16
  store i32 %57, ptr %58, align 4, !tbaa !10
  %59 = xor i32 %57, %19
  %60 = getelementptr inbounds i8, ptr %2, i64 20
  store i32 %59, ptr %60, align 4, !tbaa !10
  %61 = xor i32 %22, %59
  %62 = getelementptr inbounds i8, ptr %2, i64 24
  store i32 %61, ptr %62, align 4, !tbaa !10
  %63 = xor i32 %61, %25
  %64 = getelementptr inbounds i8, ptr %2, i64 28
  store i32 %63, ptr %64, align 4, !tbaa !10
  %65 = lshr i32 %63, 8
  %66 = and i32 %65, 255
  %67 = zext nneg i32 %66 to i64
  %68 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %67
  %69 = load i8, ptr %68, align 1, !tbaa !11
  %70 = zext i8 %69 to i32
  %71 = lshr i32 %63, 16
  %72 = and i32 %71, 255
  %73 = zext nneg i32 %72 to i64
  %74 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %73
  %75 = load i8, ptr %74, align 1, !tbaa !11
  %76 = zext i8 %75 to i32
  %77 = shl nuw nsw i32 %76, 8
  %78 = or disjoint i32 %77, %70
  %79 = lshr i32 %63, 24
  %80 = zext nneg i32 %79 to i64
  %81 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %80
  %82 = load i8, ptr %81, align 1, !tbaa !11
  %83 = zext i8 %82 to i32
  %84 = shl nuw nsw i32 %83, 16
  %85 = or disjoint i32 %78, %84
  %86 = and i32 %63, 255
  %87 = zext nneg i32 %86 to i64
  %88 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %87
  %89 = load i8, ptr %88, align 1, !tbaa !11
  %90 = zext i8 %89 to i32
  %91 = shl nuw i32 %90, 24
  %92 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 4), align 4, !tbaa !10
  %93 = xor i32 %85, %92
  %94 = xor i32 %93, %91
  %95 = xor i32 %94, %57
  %96 = getelementptr inbounds i8, ptr %2, i64 32
  store i32 %95, ptr %96, align 4, !tbaa !10
  %97 = xor i32 %94, %19
  %98 = getelementptr inbounds i8, ptr %2, i64 36
  store i32 %97, ptr %98, align 4, !tbaa !10
  %99 = xor i32 %61, %97
  %100 = getelementptr inbounds i8, ptr %2, i64 40
  store i32 %99, ptr %100, align 4, !tbaa !10
  %101 = xor i32 %97, %25
  %102 = getelementptr inbounds i8, ptr %2, i64 44
  store i32 %101, ptr %102, align 4, !tbaa !10
  %103 = lshr i32 %101, 8
  %104 = and i32 %103, 255
  %105 = zext nneg i32 %104 to i64
  %106 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %105
  %107 = load i8, ptr %106, align 1, !tbaa !11
  %108 = zext i8 %107 to i32
  %109 = lshr i32 %101, 16
  %110 = and i32 %109, 255
  %111 = zext nneg i32 %110 to i64
  %112 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %111
  %113 = load i8, ptr %112, align 1, !tbaa !11
  %114 = zext i8 %113 to i32
  %115 = shl nuw nsw i32 %114, 8
  %116 = or disjoint i32 %115, %108
  %117 = lshr i32 %101, 24
  %118 = zext nneg i32 %117 to i64
  %119 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %118
  %120 = load i8, ptr %119, align 1, !tbaa !11
  %121 = zext i8 %120 to i32
  %122 = shl nuw nsw i32 %121, 16
  %123 = or disjoint i32 %116, %122
  %124 = and i32 %101, 255
  %125 = zext nneg i32 %124 to i64
  %126 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %125
  %127 = load i8, ptr %126, align 1, !tbaa !11
  %128 = zext i8 %127 to i32
  %129 = shl nuw i32 %128, 24
  %130 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 8), align 8, !tbaa !10
  %131 = xor i32 %123, %130
  %132 = xor i32 %131, %129
  %133 = xor i32 %132, %95
  %134 = getelementptr inbounds i8, ptr %2, i64 48
  store i32 %133, ptr %134, align 4, !tbaa !10
  %135 = xor i32 %133, %97
  %136 = getelementptr inbounds i8, ptr %2, i64 52
  store i32 %135, ptr %136, align 4, !tbaa !10
  %137 = xor i32 %61, %133
  %138 = getelementptr inbounds i8, ptr %2, i64 56
  store i32 %137, ptr %138, align 4, !tbaa !10
  %139 = xor i32 %137, %101
  %140 = getelementptr inbounds i8, ptr %2, i64 60
  store i32 %139, ptr %140, align 4, !tbaa !10
  %141 = lshr i32 %139, 8
  %142 = and i32 %141, 255
  %143 = zext nneg i32 %142 to i64
  %144 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %143
  %145 = load i8, ptr %144, align 1, !tbaa !11
  %146 = zext i8 %145 to i32
  %147 = lshr i32 %139, 16
  %148 = and i32 %147, 255
  %149 = zext nneg i32 %148 to i64
  %150 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %149
  %151 = load i8, ptr %150, align 1, !tbaa !11
  %152 = zext i8 %151 to i32
  %153 = shl nuw nsw i32 %152, 8
  %154 = or disjoint i32 %153, %146
  %155 = lshr i32 %139, 24
  %156 = zext nneg i32 %155 to i64
  %157 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %156
  %158 = load i8, ptr %157, align 1, !tbaa !11
  %159 = zext i8 %158 to i32
  %160 = shl nuw nsw i32 %159, 16
  %161 = or disjoint i32 %154, %160
  %162 = and i32 %139, 255
  %163 = zext nneg i32 %162 to i64
  %164 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %163
  %165 = load i8, ptr %164, align 1, !tbaa !11
  %166 = zext i8 %165 to i32
  %167 = shl nuw i32 %166, 24
  %168 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 12), align 4, !tbaa !10
  %169 = xor i32 %161, %168
  %170 = xor i32 %169, %167
  %171 = xor i32 %170, %133
  %172 = getelementptr inbounds i8, ptr %2, i64 64
  store i32 %171, ptr %172, align 4, !tbaa !10
  %173 = xor i32 %170, %97
  %174 = getelementptr inbounds i8, ptr %2, i64 68
  store i32 %173, ptr %174, align 4, !tbaa !10
  %175 = xor i32 %137, %173
  %176 = getelementptr inbounds i8, ptr %2, i64 72
  store i32 %175, ptr %176, align 4, !tbaa !10
  %177 = xor i32 %170, %25
  %178 = getelementptr inbounds i8, ptr %2, i64 76
  store i32 %177, ptr %178, align 4, !tbaa !10
  %179 = lshr i32 %177, 8
  %180 = and i32 %179, 255
  %181 = zext nneg i32 %180 to i64
  %182 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %181
  %183 = load i8, ptr %182, align 1, !tbaa !11
  %184 = zext i8 %183 to i32
  %185 = lshr i32 %177, 16
  %186 = and i32 %185, 255
  %187 = zext nneg i32 %186 to i64
  %188 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %187
  %189 = load i8, ptr %188, align 1, !tbaa !11
  %190 = zext i8 %189 to i32
  %191 = shl nuw nsw i32 %190, 8
  %192 = or disjoint i32 %191, %184
  %193 = lshr i32 %177, 24
  %194 = zext nneg i32 %193 to i64
  %195 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %194
  %196 = load i8, ptr %195, align 1, !tbaa !11
  %197 = zext i8 %196 to i32
  %198 = shl nuw nsw i32 %197, 16
  %199 = or disjoint i32 %192, %198
  %200 = and i32 %177, 255
  %201 = zext nneg i32 %200 to i64
  %202 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %201
  %203 = load i8, ptr %202, align 1, !tbaa !11
  %204 = zext i8 %203 to i32
  %205 = shl nuw i32 %204, 24
  %206 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 16), align 16, !tbaa !10
  %207 = xor i32 %199, %206
  %208 = xor i32 %207, %205
  %209 = xor i32 %208, %171
  %210 = getelementptr inbounds i8, ptr %2, i64 80
  store i32 %209, ptr %210, align 4, !tbaa !10
  %211 = xor i32 %209, %173
  %212 = getelementptr inbounds i8, ptr %2, i64 84
  store i32 %211, ptr %212, align 4, !tbaa !10
  %213 = xor i32 %137, %209
  %214 = getelementptr inbounds i8, ptr %2, i64 88
  store i32 %213, ptr %214, align 4, !tbaa !10
  %215 = xor i32 %213, %177
  %216 = getelementptr inbounds i8, ptr %2, i64 92
  store i32 %215, ptr %216, align 4, !tbaa !10
  %217 = lshr i32 %215, 8
  %218 = and i32 %217, 255
  %219 = zext nneg i32 %218 to i64
  %220 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %219
  %221 = load i8, ptr %220, align 1, !tbaa !11
  %222 = zext i8 %221 to i32
  %223 = lshr i32 %215, 16
  %224 = and i32 %223, 255
  %225 = zext nneg i32 %224 to i64
  %226 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %225
  %227 = load i8, ptr %226, align 1, !tbaa !11
  %228 = zext i8 %227 to i32
  %229 = shl nuw nsw i32 %228, 8
  %230 = or disjoint i32 %229, %222
  %231 = lshr i32 %215, 24
  %232 = zext nneg i32 %231 to i64
  %233 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %232
  %234 = load i8, ptr %233, align 1, !tbaa !11
  %235 = zext i8 %234 to i32
  %236 = shl nuw nsw i32 %235, 16
  %237 = or disjoint i32 %230, %236
  %238 = and i32 %215, 255
  %239 = zext nneg i32 %238 to i64
  %240 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %239
  %241 = load i8, ptr %240, align 1, !tbaa !11
  %242 = zext i8 %241 to i32
  %243 = shl nuw i32 %242, 24
  %244 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 20), align 4, !tbaa !10
  %245 = xor i32 %237, %244
  %246 = xor i32 %245, %243
  %247 = xor i32 %246, %209
  %248 = getelementptr inbounds i8, ptr %2, i64 96
  store i32 %247, ptr %248, align 4, !tbaa !10
  %249 = xor i32 %246, %173
  %250 = getelementptr inbounds i8, ptr %2, i64 100
  store i32 %249, ptr %250, align 4, !tbaa !10
  %251 = xor i32 %213, %249
  %252 = getelementptr inbounds i8, ptr %2, i64 104
  store i32 %251, ptr %252, align 4, !tbaa !10
  %253 = xor i32 %249, %177
  %254 = getelementptr inbounds i8, ptr %2, i64 108
  store i32 %253, ptr %254, align 4, !tbaa !10
  %255 = lshr i32 %253, 8
  %256 = and i32 %255, 255
  %257 = zext nneg i32 %256 to i64
  %258 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %257
  %259 = load i8, ptr %258, align 1, !tbaa !11
  %260 = zext i8 %259 to i32
  %261 = lshr i32 %253, 16
  %262 = and i32 %261, 255
  %263 = zext nneg i32 %262 to i64
  %264 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %263
  %265 = load i8, ptr %264, align 1, !tbaa !11
  %266 = zext i8 %265 to i32
  %267 = shl nuw nsw i32 %266, 8
  %268 = or disjoint i32 %267, %260
  %269 = lshr i32 %253, 24
  %270 = zext nneg i32 %269 to i64
  %271 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %270
  %272 = load i8, ptr %271, align 1, !tbaa !11
  %273 = zext i8 %272 to i32
  %274 = shl nuw nsw i32 %273, 16
  %275 = or disjoint i32 %268, %274
  %276 = and i32 %253, 255
  %277 = zext nneg i32 %276 to i64
  %278 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %277
  %279 = load i8, ptr %278, align 1, !tbaa !11
  %280 = zext i8 %279 to i32
  %281 = shl nuw i32 %280, 24
  %282 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 24), align 8, !tbaa !10
  %283 = xor i32 %275, %282
  %284 = xor i32 %283, %281
  %285 = xor i32 %284, %247
  %286 = getelementptr inbounds i8, ptr %2, i64 112
  store i32 %285, ptr %286, align 4, !tbaa !10
  %287 = getelementptr inbounds i8, ptr %2, i64 100
  %288 = load i32, ptr %287, align 4, !tbaa !10
  %289 = xor i32 %285, %288
  %290 = getelementptr inbounds i8, ptr %2, i64 116
  store i32 %289, ptr %290, align 4, !tbaa !10
  %291 = getelementptr inbounds i8, ptr %2, i64 104
  %292 = load i32, ptr %291, align 4, !tbaa !10
  %293 = xor i32 %292, %289
  %294 = getelementptr inbounds i8, ptr %2, i64 120
  store i32 %293, ptr %294, align 4, !tbaa !10
  %295 = xor i32 %293, %253
  %296 = getelementptr inbounds i8, ptr %2, i64 124
  store i32 %295, ptr %296, align 4, !tbaa !10
  %297 = lshr i32 %295, 8
  %298 = and i32 %297, 255
  %299 = zext nneg i32 %298 to i64
  %300 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %299
  %301 = load i8, ptr %300, align 1, !tbaa !11
  %302 = zext i8 %301 to i32
  %303 = lshr i32 %295, 16
  %304 = and i32 %303, 255
  %305 = zext nneg i32 %304 to i64
  %306 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %305
  %307 = load i8, ptr %306, align 1, !tbaa !11
  %308 = zext i8 %307 to i32
  %309 = shl nuw nsw i32 %308, 8
  %310 = or disjoint i32 %309, %302
  %311 = lshr i32 %295, 24
  %312 = zext nneg i32 %311 to i64
  %313 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %312
  %314 = load i8, ptr %313, align 1, !tbaa !11
  %315 = zext i8 %314 to i32
  %316 = shl nuw nsw i32 %315, 16
  %317 = or disjoint i32 %310, %316
  %318 = and i32 %295, 255
  %319 = zext nneg i32 %318 to i64
  %320 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %319
  %321 = load i8, ptr %320, align 1, !tbaa !11
  %322 = zext i8 %321 to i32
  %323 = shl nuw i32 %322, 24
  %324 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 28), align 4, !tbaa !10
  %325 = xor i32 %317, %324
  %326 = xor i32 %325, %323
  %327 = xor i32 %326, %285
  %328 = getelementptr inbounds i8, ptr %2, i64 128
  store i32 %327, ptr %328, align 4, !tbaa !10
  %329 = getelementptr inbounds i8, ptr %2, i64 116
  %330 = load i32, ptr %329, align 4, !tbaa !10
  %331 = xor i32 %327, %330
  %332 = getelementptr inbounds i8, ptr %2, i64 132
  store i32 %331, ptr %332, align 4, !tbaa !10
  %333 = getelementptr inbounds i8, ptr %2, i64 120
  %334 = load i32, ptr %333, align 4, !tbaa !10
  %335 = xor i32 %334, %331
  %336 = getelementptr inbounds i8, ptr %2, i64 136
  store i32 %335, ptr %336, align 4, !tbaa !10
  %337 = xor i32 %335, %295
  %338 = getelementptr inbounds i8, ptr %2, i64 140
  store i32 %337, ptr %338, align 4, !tbaa !10
  %339 = lshr i32 %337, 8
  %340 = and i32 %339, 255
  %341 = zext nneg i32 %340 to i64
  %342 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %341
  %343 = load i8, ptr %342, align 1, !tbaa !11
  %344 = zext i8 %343 to i32
  %345 = lshr i32 %337, 16
  %346 = and i32 %345, 255
  %347 = zext nneg i32 %346 to i64
  %348 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %347
  %349 = load i8, ptr %348, align 1, !tbaa !11
  %350 = zext i8 %349 to i32
  %351 = shl nuw nsw i32 %350, 8
  %352 = or disjoint i32 %351, %344
  %353 = lshr i32 %337, 24
  %354 = zext nneg i32 %353 to i64
  %355 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %354
  %356 = load i8, ptr %355, align 1, !tbaa !11
  %357 = zext i8 %356 to i32
  %358 = shl nuw nsw i32 %357, 16
  %359 = or disjoint i32 %352, %358
  %360 = and i32 %337, 255
  %361 = zext nneg i32 %360 to i64
  %362 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %361
  %363 = load i8, ptr %362, align 1, !tbaa !11
  %364 = zext i8 %363 to i32
  %365 = shl nuw i32 %364, 24
  %366 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 32), align 16, !tbaa !10
  %367 = xor i32 %359, %366
  %368 = xor i32 %367, %365
  %369 = xor i32 %368, %327
  %370 = getelementptr inbounds i8, ptr %2, i64 144
  store i32 %369, ptr %370, align 4, !tbaa !10
  %371 = getelementptr inbounds i8, ptr %2, i64 132
  %372 = load i32, ptr %371, align 4, !tbaa !10
  %373 = xor i32 %369, %372
  %374 = getelementptr inbounds i8, ptr %2, i64 148
  store i32 %373, ptr %374, align 4, !tbaa !10
  %375 = getelementptr inbounds i8, ptr %2, i64 136
  %376 = load i32, ptr %375, align 4, !tbaa !10
  %377 = xor i32 %376, %373
  %378 = getelementptr inbounds i8, ptr %2, i64 152
  store i32 %377, ptr %378, align 4, !tbaa !10
  %379 = xor i32 %377, %337
  %380 = getelementptr inbounds i8, ptr %2, i64 156
  store i32 %379, ptr %380, align 4, !tbaa !10
  %381 = lshr i32 %379, 8
  %382 = and i32 %381, 255
  %383 = zext nneg i32 %382 to i64
  %384 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %383
  %385 = load i8, ptr %384, align 1, !tbaa !11
  %386 = zext i8 %385 to i32
  %387 = lshr i32 %379, 16
  %388 = and i32 %387, 255
  %389 = zext nneg i32 %388 to i64
  %390 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %389
  %391 = load i8, ptr %390, align 1, !tbaa !11
  %392 = zext i8 %391 to i32
  %393 = shl nuw nsw i32 %392, 8
  %394 = or disjoint i32 %393, %386
  %395 = lshr i32 %379, 24
  %396 = zext nneg i32 %395 to i64
  %397 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %396
  %398 = load i8, ptr %397, align 1, !tbaa !11
  %399 = zext i8 %398 to i32
  %400 = shl nuw nsw i32 %399, 16
  %401 = or disjoint i32 %394, %400
  %402 = and i32 %379, 255
  %403 = zext nneg i32 %402 to i64
  %404 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %403
  %405 = load i8, ptr %404, align 1, !tbaa !11
  %406 = zext i8 %405 to i32
  %407 = shl nuw i32 %406, 24
  %408 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 36), align 4, !tbaa !10
  %409 = xor i32 %401, %408
  %410 = xor i32 %409, %407
  %411 = xor i32 %410, %369
  %412 = getelementptr inbounds i8, ptr %2, i64 160
  store i32 %411, ptr %412, align 4, !tbaa !10
  %413 = getelementptr inbounds i8, ptr %2, i64 148
  %414 = load i32, ptr %413, align 4, !tbaa !10
  %415 = xor i32 %411, %414
  %416 = getelementptr inbounds i8, ptr %2, i64 164
  store i32 %415, ptr %416, align 4, !tbaa !10
  %417 = getelementptr inbounds i8, ptr %2, i64 152
  %418 = load i32, ptr %417, align 4, !tbaa !10
  %419 = xor i32 %418, %415
  %420 = getelementptr inbounds i8, ptr %2, i64 168
  store i32 %419, ptr %420, align 4, !tbaa !10
  %421 = xor i32 %419, %379
  br label %.loopexit.sink.split

422:                                              ; preds = %16
  %423 = getelementptr inbounds i8, ptr %0, i64 16
  %424 = load i32, ptr %423, align 4, !tbaa !10
  %425 = getelementptr inbounds i8, ptr %2, i64 16
  store i32 %424, ptr %425, align 4, !tbaa !10
  %426 = getelementptr inbounds i8, ptr %0, i64 20
  %427 = load i32, ptr %426, align 4, !tbaa !10
  %428 = getelementptr inbounds i8, ptr %2, i64 20
  store i32 %427, ptr %428, align 4, !tbaa !10
  %429 = icmp eq i32 %1, 192
  br i1 %429, label %.loopexit.loopexit129, label %430

430:                                              ; preds = %422
  %431 = getelementptr inbounds i8, ptr %0, i64 24
  %432 = load i32, ptr %431, align 4, !tbaa !10
  %433 = getelementptr inbounds i8, ptr %2, i64 24
  store i32 %432, ptr %433, align 4, !tbaa !10
  %434 = getelementptr inbounds i8, ptr %0, i64 28
  %435 = load i32, ptr %434, align 4, !tbaa !10
  %436 = getelementptr inbounds i8, ptr %2, i64 28
  store i32 %435, ptr %436, align 4, !tbaa !10
  %437 = icmp eq i32 %1, 256
  br i1 %437, label %.preheader127, label %.loopexit

.preheader127:                                    ; preds = %430, %483
  %438 = phi i32 [ %480, %483 ], [ %25, %430 ]
  %439 = phi i32 [ %478, %483 ], [ %22, %430 ]
  %440 = phi i32 [ %476, %483 ], [ %19, %430 ]
  %441 = phi i32 [ %474, %483 ], [ %17, %430 ]
  %442 = phi i32 [ %524, %483 ], [ %435, %430 ]
  %indvars.iv = phi i64 [ %indvars.iv.next, %483 ], [ 0, %430 ]
  %.2116 = phi ptr [ %475, %483 ], [ %2, %430 ]
  %443 = lshr i32 %442, 8
  %444 = and i32 %443, 255
  %445 = zext nneg i32 %444 to i64
  %446 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %445
  %447 = load i8, ptr %446, align 1, !tbaa !11
  %448 = zext i8 %447 to i32
  %449 = xor i32 %441, %448
  %450 = lshr i32 %442, 16
  %451 = and i32 %450, 255
  %452 = zext nneg i32 %451 to i64
  %453 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %452
  %454 = load i8, ptr %453, align 1, !tbaa !11
  %455 = zext i8 %454 to i32
  %456 = shl nuw nsw i32 %455, 8
  %457 = xor i32 %449, %456
  %458 = lshr i32 %442, 24
  %459 = zext nneg i32 %458 to i64
  %460 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %459
  %461 = load i8, ptr %460, align 1, !tbaa !11
  %462 = zext i8 %461 to i32
  %463 = shl nuw nsw i32 %462, 16
  %464 = xor i32 %457, %463
  %465 = and i32 %442, 255
  %466 = zext nneg i32 %465 to i64
  %467 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %466
  %468 = load i8, ptr %467, align 1, !tbaa !11
  %469 = zext i8 %468 to i32
  %470 = shl nuw i32 %469, 24
  %471 = getelementptr inbounds [10 x i32], ptr @rcon, i64 0, i64 %indvars.iv
  %472 = load i32, ptr %471, align 4, !tbaa !10
  %473 = xor i32 %464, %472
  %474 = xor i32 %473, %470
  %475 = getelementptr inbounds i8, ptr %.2116, i64 32
  store i32 %474, ptr %475, align 4, !tbaa !10
  %476 = xor i32 %474, %440
  %477 = getelementptr inbounds i8, ptr %.2116, i64 36
  store i32 %476, ptr %477, align 4, !tbaa !10
  %478 = xor i32 %439, %476
  %479 = getelementptr inbounds i8, ptr %.2116, i64 40
  store i32 %478, ptr %479, align 4, !tbaa !10
  %480 = xor i32 %438, %478
  %481 = getelementptr inbounds i8, ptr %.2116, i64 44
  store i32 %480, ptr %481, align 4, !tbaa !10
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %482 = icmp eq i64 %indvars.iv.next, 7
  br i1 %482, label %.loopexit, label %483

483:                                              ; preds = %.preheader127
  %484 = getelementptr inbounds i8, ptr %.2116, i64 16
  %485 = load i32, ptr %484, align 4, !tbaa !10
  %486 = and i32 %480, 255
  %487 = zext nneg i32 %486 to i64
  %488 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %487
  %489 = load i8, ptr %488, align 1, !tbaa !11
  %490 = zext i8 %489 to i32
  %491 = xor i32 %485, %490
  %492 = lshr i32 %480, 8
  %493 = and i32 %492, 255
  %494 = zext nneg i32 %493 to i64
  %495 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %494
  %496 = load i8, ptr %495, align 1, !tbaa !11
  %497 = zext i8 %496 to i32
  %498 = shl nuw nsw i32 %497, 8
  %499 = xor i32 %491, %498
  %500 = lshr i32 %480, 16
  %501 = and i32 %500, 255
  %502 = zext nneg i32 %501 to i64
  %503 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %502
  %504 = load i8, ptr %503, align 1, !tbaa !11
  %505 = zext i8 %504 to i32
  %506 = shl nuw nsw i32 %505, 16
  %507 = xor i32 %499, %506
  %508 = lshr i32 %480, 24
  %509 = zext nneg i32 %508 to i64
  %510 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %509
  %511 = load i8, ptr %510, align 1, !tbaa !11
  %512 = zext i8 %511 to i32
  %513 = shl nuw i32 %512, 24
  %514 = xor i32 %507, %513
  %515 = getelementptr inbounds i8, ptr %.2116, i64 48
  store i32 %514, ptr %515, align 4, !tbaa !10
  %516 = getelementptr inbounds i8, ptr %.2116, i64 20
  %517 = load i32, ptr %516, align 4, !tbaa !10
  %518 = xor i32 %514, %517
  %519 = getelementptr inbounds i8, ptr %.2116, i64 52
  store i32 %518, ptr %519, align 4, !tbaa !10
  %520 = getelementptr inbounds i8, ptr %.2116, i64 24
  %521 = load i32, ptr %520, align 4, !tbaa !10
  %522 = xor i32 %521, %518
  %523 = getelementptr inbounds i8, ptr %.2116, i64 56
  store i32 %522, ptr %523, align 4, !tbaa !10
  %524 = xor i32 %522, %442
  %525 = getelementptr inbounds i8, ptr %.2116, i64 60
  store i32 %524, ptr %525, align 4, !tbaa !10
  br label %.preheader127

.loopexit.loopexit129:                            ; preds = %422
  %526 = lshr i32 %427, 8
  %527 = and i32 %526, 255
  %528 = zext nneg i32 %527 to i64
  %529 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %528
  %530 = load i8, ptr %529, align 1, !tbaa !11
  %531 = zext i8 %530 to i32
  %532 = lshr i32 %427, 16
  %533 = and i32 %532, 255
  %534 = zext nneg i32 %533 to i64
  %535 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %534
  %536 = load i8, ptr %535, align 1, !tbaa !11
  %537 = zext i8 %536 to i32
  %538 = shl nuw nsw i32 %537, 8
  %539 = or disjoint i32 %538, %531
  %540 = lshr i32 %427, 24
  %541 = zext nneg i32 %540 to i64
  %542 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %541
  %543 = load i8, ptr %542, align 1, !tbaa !11
  %544 = zext i8 %543 to i32
  %545 = shl nuw nsw i32 %544, 16
  %546 = or disjoint i32 %539, %545
  %547 = and i32 %427, 255
  %548 = zext nneg i32 %547 to i64
  %549 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %548
  %550 = load i8, ptr %549, align 1, !tbaa !11
  %551 = zext i8 %550 to i32
  %552 = shl nuw i32 %551, 24
  %553 = load i32, ptr @rcon, align 16, !tbaa !10
  %554 = xor i32 %546, %553
  %555 = xor i32 %554, %552
  %556 = xor i32 %555, %17
  %557 = getelementptr inbounds i8, ptr %2, i64 24
  store i32 %556, ptr %557, align 4, !tbaa !10
  %558 = xor i32 %556, %19
  %559 = getelementptr inbounds i8, ptr %2, i64 28
  store i32 %558, ptr %559, align 4, !tbaa !10
  %560 = xor i32 %22, %558
  %561 = getelementptr inbounds i8, ptr %2, i64 32
  store i32 %560, ptr %561, align 4, !tbaa !10
  %562 = xor i32 %25, %560
  %563 = getelementptr inbounds i8, ptr %2, i64 36
  store i32 %562, ptr %563, align 4, !tbaa !10
  %564 = xor i32 %424, %562
  %565 = getelementptr inbounds i8, ptr %2, i64 40
  store i32 %564, ptr %565, align 4, !tbaa !10
  %566 = xor i32 %564, %427
  %567 = getelementptr inbounds i8, ptr %2, i64 44
  store i32 %566, ptr %567, align 4, !tbaa !10
  %568 = lshr i32 %566, 8
  %569 = and i32 %568, 255
  %570 = zext nneg i32 %569 to i64
  %571 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %570
  %572 = load i8, ptr %571, align 1, !tbaa !11
  %573 = zext i8 %572 to i32
  %574 = lshr i32 %566, 16
  %575 = and i32 %574, 255
  %576 = zext nneg i32 %575 to i64
  %577 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %576
  %578 = load i8, ptr %577, align 1, !tbaa !11
  %579 = zext i8 %578 to i32
  %580 = shl nuw nsw i32 %579, 8
  %581 = or disjoint i32 %580, %573
  %582 = lshr i32 %566, 24
  %583 = zext nneg i32 %582 to i64
  %584 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %583
  %585 = load i8, ptr %584, align 1, !tbaa !11
  %586 = zext i8 %585 to i32
  %587 = shl nuw nsw i32 %586, 16
  %588 = or disjoint i32 %581, %587
  %589 = and i32 %566, 255
  %590 = zext nneg i32 %589 to i64
  %591 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %590
  %592 = load i8, ptr %591, align 1, !tbaa !11
  %593 = zext i8 %592 to i32
  %594 = shl nuw i32 %593, 24
  %595 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 4), align 4, !tbaa !10
  %596 = xor i32 %588, %595
  %597 = xor i32 %596, %594
  %598 = xor i32 %597, %556
  %599 = getelementptr inbounds i8, ptr %2, i64 48
  store i32 %598, ptr %599, align 4, !tbaa !10
  %600 = xor i32 %597, %19
  %601 = getelementptr inbounds i8, ptr %2, i64 52
  store i32 %600, ptr %601, align 4, !tbaa !10
  %602 = xor i32 %560, %600
  %603 = getelementptr inbounds i8, ptr %2, i64 56
  store i32 %602, ptr %603, align 4, !tbaa !10
  %604 = xor i32 %25, %600
  %605 = getelementptr inbounds i8, ptr %2, i64 60
  store i32 %604, ptr %605, align 4, !tbaa !10
  %606 = xor i32 %564, %604
  %607 = getelementptr inbounds i8, ptr %2, i64 64
  store i32 %606, ptr %607, align 4, !tbaa !10
  %608 = xor i32 %604, %427
  %609 = getelementptr inbounds i8, ptr %2, i64 68
  store i32 %608, ptr %609, align 4, !tbaa !10
  %610 = lshr i32 %608, 8
  %611 = and i32 %610, 255
  %612 = zext nneg i32 %611 to i64
  %613 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %612
  %614 = load i8, ptr %613, align 1, !tbaa !11
  %615 = zext i8 %614 to i32
  %616 = lshr i32 %608, 16
  %617 = and i32 %616, 255
  %618 = zext nneg i32 %617 to i64
  %619 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %618
  %620 = load i8, ptr %619, align 1, !tbaa !11
  %621 = zext i8 %620 to i32
  %622 = shl nuw nsw i32 %621, 8
  %623 = or disjoint i32 %622, %615
  %624 = lshr i32 %608, 24
  %625 = zext nneg i32 %624 to i64
  %626 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %625
  %627 = load i8, ptr %626, align 1, !tbaa !11
  %628 = zext i8 %627 to i32
  %629 = shl nuw nsw i32 %628, 16
  %630 = or disjoint i32 %623, %629
  %631 = and i32 %608, 255
  %632 = zext nneg i32 %631 to i64
  %633 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %632
  %634 = load i8, ptr %633, align 1, !tbaa !11
  %635 = zext i8 %634 to i32
  %636 = shl nuw i32 %635, 24
  %637 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 8), align 8, !tbaa !10
  %638 = xor i32 %630, %637
  %639 = xor i32 %638, %636
  %640 = xor i32 %639, %598
  %641 = getelementptr inbounds i8, ptr %2, i64 72
  store i32 %640, ptr %641, align 4, !tbaa !10
  %642 = xor i32 %640, %600
  %643 = getelementptr inbounds i8, ptr %2, i64 76
  store i32 %642, ptr %643, align 4, !tbaa !10
  %644 = xor i32 %560, %640
  %645 = getelementptr inbounds i8, ptr %2, i64 80
  store i32 %644, ptr %645, align 4, !tbaa !10
  %646 = xor i32 %604, %644
  %647 = getelementptr inbounds i8, ptr %2, i64 84
  store i32 %646, ptr %647, align 4, !tbaa !10
  %648 = xor i32 %564, %644
  %649 = getelementptr inbounds i8, ptr %2, i64 88
  store i32 %648, ptr %649, align 4, !tbaa !10
  %650 = xor i32 %648, %608
  %651 = getelementptr inbounds i8, ptr %2, i64 92
  store i32 %650, ptr %651, align 4, !tbaa !10
  %652 = lshr i32 %650, 8
  %653 = and i32 %652, 255
  %654 = zext nneg i32 %653 to i64
  %655 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %654
  %656 = load i8, ptr %655, align 1, !tbaa !11
  %657 = zext i8 %656 to i32
  %658 = lshr i32 %650, 16
  %659 = and i32 %658, 255
  %660 = zext nneg i32 %659 to i64
  %661 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %660
  %662 = load i8, ptr %661, align 1, !tbaa !11
  %663 = zext i8 %662 to i32
  %664 = shl nuw nsw i32 %663, 8
  %665 = or disjoint i32 %664, %657
  %666 = lshr i32 %650, 24
  %667 = zext nneg i32 %666 to i64
  %668 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %667
  %669 = load i8, ptr %668, align 1, !tbaa !11
  %670 = zext i8 %669 to i32
  %671 = shl nuw nsw i32 %670, 16
  %672 = or disjoint i32 %665, %671
  %673 = and i32 %650, 255
  %674 = zext nneg i32 %673 to i64
  %675 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %674
  %676 = load i8, ptr %675, align 1, !tbaa !11
  %677 = zext i8 %676 to i32
  %678 = shl nuw i32 %677, 24
  %679 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 12), align 4, !tbaa !10
  %680 = xor i32 %672, %679
  %681 = xor i32 %680, %678
  %682 = xor i32 %681, %640
  %683 = getelementptr inbounds i8, ptr %2, i64 96
  store i32 %682, ptr %683, align 4, !tbaa !10
  %684 = xor i32 %681, %600
  %685 = getelementptr inbounds i8, ptr %2, i64 100
  store i32 %684, ptr %685, align 4, !tbaa !10
  %686 = xor i32 %644, %684
  %687 = getelementptr inbounds i8, ptr %2, i64 104
  store i32 %686, ptr %687, align 4, !tbaa !10
  %688 = xor i32 %25, %681
  %689 = getelementptr inbounds i8, ptr %2, i64 108
  store i32 %688, ptr %689, align 4, !tbaa !10
  %690 = xor i32 %648, %688
  %691 = getelementptr inbounds i8, ptr %2, i64 112
  store i32 %690, ptr %691, align 4, !tbaa !10
  %692 = xor i32 %688, %608
  %693 = getelementptr inbounds i8, ptr %2, i64 116
  store i32 %692, ptr %693, align 4, !tbaa !10
  %694 = lshr i32 %692, 8
  %695 = and i32 %694, 255
  %696 = zext nneg i32 %695 to i64
  %697 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %696
  %698 = load i8, ptr %697, align 1, !tbaa !11
  %699 = zext i8 %698 to i32
  %700 = lshr i32 %692, 16
  %701 = and i32 %700, 255
  %702 = zext nneg i32 %701 to i64
  %703 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %702
  %704 = load i8, ptr %703, align 1, !tbaa !11
  %705 = zext i8 %704 to i32
  %706 = shl nuw nsw i32 %705, 8
  %707 = or disjoint i32 %706, %699
  %708 = lshr i32 %692, 24
  %709 = zext nneg i32 %708 to i64
  %710 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %709
  %711 = load i8, ptr %710, align 1, !tbaa !11
  %712 = zext i8 %711 to i32
  %713 = shl nuw nsw i32 %712, 16
  %714 = or disjoint i32 %707, %713
  %715 = and i32 %692, 255
  %716 = zext nneg i32 %715 to i64
  %717 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %716
  %718 = load i8, ptr %717, align 1, !tbaa !11
  %719 = zext i8 %718 to i32
  %720 = shl nuw i32 %719, 24
  %721 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 16), align 16, !tbaa !10
  %722 = xor i32 %714, %721
  %723 = xor i32 %722, %720
  %724 = xor i32 %723, %682
  %725 = getelementptr inbounds i8, ptr %2, i64 120
  store i32 %724, ptr %725, align 4, !tbaa !10
  %726 = xor i32 %724, %684
  %727 = getelementptr inbounds i8, ptr %2, i64 124
  store i32 %726, ptr %727, align 4, !tbaa !10
  %728 = xor i32 %644, %724
  %729 = getelementptr inbounds i8, ptr %2, i64 128
  store i32 %728, ptr %729, align 4, !tbaa !10
  %730 = xor i32 %688, %728
  %731 = getelementptr inbounds i8, ptr %2, i64 132
  store i32 %730, ptr %731, align 4, !tbaa !10
  %732 = xor i32 %564, %724
  %733 = getelementptr inbounds i8, ptr %2, i64 136
  store i32 %732, ptr %733, align 4, !tbaa !10
  %734 = xor i32 %732, %692
  %735 = getelementptr inbounds i8, ptr %2, i64 140
  store i32 %734, ptr %735, align 4, !tbaa !10
  %736 = lshr i32 %734, 8
  %737 = and i32 %736, 255
  %738 = zext nneg i32 %737 to i64
  %739 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %738
  %740 = load i8, ptr %739, align 1, !tbaa !11
  %741 = zext i8 %740 to i32
  %742 = lshr i32 %734, 16
  %743 = and i32 %742, 255
  %744 = zext nneg i32 %743 to i64
  %745 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %744
  %746 = load i8, ptr %745, align 1, !tbaa !11
  %747 = zext i8 %746 to i32
  %748 = shl nuw nsw i32 %747, 8
  %749 = or disjoint i32 %748, %741
  %750 = lshr i32 %734, 24
  %751 = zext nneg i32 %750 to i64
  %752 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %751
  %753 = load i8, ptr %752, align 1, !tbaa !11
  %754 = zext i8 %753 to i32
  %755 = shl nuw nsw i32 %754, 16
  %756 = or disjoint i32 %749, %755
  %757 = and i32 %734, 255
  %758 = zext nneg i32 %757 to i64
  %759 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %758
  %760 = load i8, ptr %759, align 1, !tbaa !11
  %761 = zext i8 %760 to i32
  %762 = shl nuw i32 %761, 24
  %763 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 20), align 4, !tbaa !10
  %764 = xor i32 %756, %763
  %765 = xor i32 %764, %762
  %766 = xor i32 %765, %724
  %767 = getelementptr inbounds i8, ptr %2, i64 144
  store i32 %766, ptr %767, align 4, !tbaa !10
  %768 = xor i32 %765, %684
  %769 = getelementptr inbounds i8, ptr %2, i64 148
  store i32 %768, ptr %769, align 4, !tbaa !10
  %770 = xor i32 %728, %768
  %771 = getelementptr inbounds i8, ptr %2, i64 152
  store i32 %770, ptr %771, align 4, !tbaa !10
  %772 = xor i32 %688, %768
  %773 = getelementptr inbounds i8, ptr %2, i64 156
  store i32 %772, ptr %773, align 4, !tbaa !10
  %774 = xor i32 %732, %772
  %775 = getelementptr inbounds i8, ptr %2, i64 160
  store i32 %774, ptr %775, align 4, !tbaa !10
  %776 = xor i32 %768, %608
  %777 = getelementptr inbounds i8, ptr %2, i64 164
  store i32 %776, ptr %777, align 4, !tbaa !10
  %778 = lshr i32 %776, 8
  %779 = and i32 %778, 255
  %780 = zext nneg i32 %779 to i64
  %781 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %780
  %782 = load i8, ptr %781, align 1, !tbaa !11
  %783 = zext i8 %782 to i32
  %784 = lshr i32 %776, 16
  %785 = and i32 %784, 255
  %786 = zext nneg i32 %785 to i64
  %787 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %786
  %788 = load i8, ptr %787, align 1, !tbaa !11
  %789 = zext i8 %788 to i32
  %790 = shl nuw nsw i32 %789, 8
  %791 = or disjoint i32 %790, %783
  %792 = lshr i32 %776, 24
  %793 = zext nneg i32 %792 to i64
  %794 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %793
  %795 = load i8, ptr %794, align 1, !tbaa !11
  %796 = zext i8 %795 to i32
  %797 = shl nuw nsw i32 %796, 16
  %798 = or disjoint i32 %791, %797
  %799 = and i32 %776, 255
  %800 = zext nneg i32 %799 to i64
  %801 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %800
  %802 = load i8, ptr %801, align 1, !tbaa !11
  %803 = zext i8 %802 to i32
  %804 = shl nuw i32 %803, 24
  %805 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 24), align 8, !tbaa !10
  %806 = xor i32 %798, %805
  %807 = xor i32 %806, %804
  %808 = xor i32 %807, %766
  %809 = getelementptr inbounds i8, ptr %2, i64 168
  store i32 %808, ptr %809, align 4, !tbaa !10
  %810 = getelementptr inbounds i8, ptr %2, i64 148
  %811 = load i32, ptr %810, align 4, !tbaa !10
  %812 = xor i32 %808, %811
  %813 = getelementptr inbounds i8, ptr %2, i64 172
  store i32 %812, ptr %813, align 4, !tbaa !10
  %814 = getelementptr inbounds i8, ptr %2, i64 152
  %815 = load i32, ptr %814, align 4, !tbaa !10
  %816 = xor i32 %815, %812
  %817 = getelementptr inbounds i8, ptr %2, i64 176
  store i32 %816, ptr %817, align 4, !tbaa !10
  %818 = getelementptr inbounds i8, ptr %2, i64 156
  %819 = load i32, ptr %818, align 4, !tbaa !10
  %820 = xor i32 %819, %816
  %821 = getelementptr inbounds i8, ptr %2, i64 180
  store i32 %820, ptr %821, align 4, !tbaa !10
  %822 = getelementptr inbounds i8, ptr %2, i64 160
  %823 = load i32, ptr %822, align 4, !tbaa !10
  %824 = xor i32 %823, %820
  %825 = getelementptr inbounds i8, ptr %2, i64 184
  store i32 %824, ptr %825, align 4, !tbaa !10
  %826 = xor i32 %824, %776
  %827 = getelementptr inbounds i8, ptr %2, i64 188
  store i32 %826, ptr %827, align 4, !tbaa !10
  %828 = lshr i32 %826, 8
  %829 = and i32 %828, 255
  %830 = zext nneg i32 %829 to i64
  %831 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %830
  %832 = load i8, ptr %831, align 1, !tbaa !11
  %833 = zext i8 %832 to i32
  %834 = lshr i32 %826, 16
  %835 = and i32 %834, 255
  %836 = zext nneg i32 %835 to i64
  %837 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %836
  %838 = load i8, ptr %837, align 1, !tbaa !11
  %839 = zext i8 %838 to i32
  %840 = shl nuw nsw i32 %839, 8
  %841 = or disjoint i32 %840, %833
  %842 = lshr i32 %826, 24
  %843 = zext nneg i32 %842 to i64
  %844 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %843
  %845 = load i8, ptr %844, align 1, !tbaa !11
  %846 = zext i8 %845 to i32
  %847 = shl nuw nsw i32 %846, 16
  %848 = or disjoint i32 %841, %847
  %849 = and i32 %826, 255
  %850 = zext nneg i32 %849 to i64
  %851 = getelementptr inbounds [256 x i8], ptr @Te4, i64 0, i64 %850
  %852 = load i8, ptr %851, align 1, !tbaa !11
  %853 = zext i8 %852 to i32
  %854 = shl nuw i32 %853, 24
  %855 = load i32, ptr getelementptr inbounds (i8, ptr @rcon, i64 28), align 4, !tbaa !10
  %856 = xor i32 %848, %855
  %857 = xor i32 %856, %854
  %858 = xor i32 %857, %808
  %859 = getelementptr inbounds i8, ptr %2, i64 192
  store i32 %858, ptr %859, align 4, !tbaa !10
  %860 = getelementptr inbounds i8, ptr %2, i64 172
  %861 = load i32, ptr %860, align 4, !tbaa !10
  %862 = xor i32 %858, %861
  %863 = getelementptr inbounds i8, ptr %2, i64 196
  store i32 %862, ptr %863, align 4, !tbaa !10
  %864 = getelementptr inbounds i8, ptr %2, i64 176
  %865 = load i32, ptr %864, align 4, !tbaa !10
  %866 = xor i32 %865, %862
  %867 = getelementptr inbounds i8, ptr %2, i64 200
  store i32 %866, ptr %867, align 4, !tbaa !10
  %868 = getelementptr inbounds i8, ptr %2, i64 180
  %869 = load i32, ptr %868, align 4, !tbaa !10
  %870 = xor i32 %869, %866
  br label %.loopexit.sink.split

.loopexit.sink.split:                             ; preds = %.preheader.preheader, %.loopexit.loopexit129
  %.sink145 = phi i64 [ 204, %.loopexit.loopexit129 ], [ 172, %.preheader.preheader ]
  %.sink = phi i32 [ %870, %.loopexit.loopexit129 ], [ %421, %.preheader.preheader ]
  %871 = getelementptr inbounds i8, ptr %2, i64 %.sink145
  store i32 %.sink, ptr %871, align 4, !tbaa !10
  br label %.loopexit

.loopexit:                                        ; preds = %.preheader127, %.loopexit.sink.split, %430, %6, %3
  %.0117 = phi i32 [ -1, %3 ], [ -2, %6 ], [ 0, %430 ], [ 0, %.loopexit.sink.split ], [ 0, %.preheader127 ]
  ret i32 %.0117
}

attributes #0 = { nofree norecurse nosync nounwind memory(readwrite, inaccessiblemem: none) 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" }

!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, !9, i64 240}
!6 = !{!"aes_key_st", !7, i64 0, !9, i64 240}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!"int", !7, i64 0}
!10 = !{!9, !9, i64 0}
!11 = !{!7, !7, i64 0}


; Effective O3 passes: BDCEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,JumpThreadingPass,LoopSimplifyPass,LoopUnrollPass,PostOrderFunctionAttrsPass,ReassociatePass,SCCPPass,SROAPass,SimplifyCFGPass