; LLVM IR from openluopworld/aes_128 :: unroll (aes)

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

@SBOX = external hidden global [256 x i8], align 16

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #0

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #0

; Function Attrs: nounwind uwtable
define dso_local void @aes_encrypt_128(ptr noundef %0, ptr noundef %1, ptr noundef %2) #1 {
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca [16 x i8], align 16
  %8 = alloca i8, align 1
  store ptr %0, ptr %4, align 8, !tbaa !5
  store ptr %1, ptr %5, align 8, !tbaa !5
  store ptr %2, ptr %6, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 16, ptr %7) #3
  call void @llvm.lifetime.start.p0(i64 1, ptr %8) #3
  %9 = load ptr, ptr %5, align 8, !tbaa !5
  %10 = load i8, ptr %9, align 1, !tbaa !9
  %11 = zext i8 %10 to i32
  %12 = load ptr, ptr %4, align 8, !tbaa !5
  %13 = getelementptr inbounds i8, ptr %12, i32 1
  store ptr %13, ptr %4, align 8, !tbaa !5
  %14 = load i8, ptr %12, align 1, !tbaa !9
  %15 = zext i8 %14 to i32
  %16 = xor i32 %11, %15
  %17 = trunc i32 %16 to i8
  %18 = load ptr, ptr %6, align 8, !tbaa !5
  store i8 %17, ptr %18, align 1, !tbaa !9
  %19 = load ptr, ptr %5, align 8, !tbaa !5
  %20 = getelementptr inbounds i8, ptr %19, i64 1
  %21 = load i8, ptr %20, align 1, !tbaa !9
  %22 = zext i8 %21 to i32
  %23 = load ptr, ptr %4, align 8, !tbaa !5
  %24 = getelementptr inbounds i8, ptr %23, i32 1
  store ptr %24, ptr %4, align 8, !tbaa !5
  %25 = load i8, ptr %23, align 1, !tbaa !9
  %26 = zext i8 %25 to i32
  %27 = xor i32 %22, %26
  %28 = trunc i32 %27 to i8
  %29 = load ptr, ptr %6, align 8, !tbaa !5
  %30 = getelementptr inbounds i8, ptr %29, i64 1
  store i8 %28, ptr %30, align 1, !tbaa !9
  %31 = load ptr, ptr %5, align 8, !tbaa !5
  %32 = getelementptr inbounds i8, ptr %31, i64 2
  %33 = load i8, ptr %32, align 1, !tbaa !9
  %34 = zext i8 %33 to i32
  %35 = load ptr, ptr %4, align 8, !tbaa !5
  %36 = getelementptr inbounds i8, ptr %35, i32 1
  store ptr %36, ptr %4, align 8, !tbaa !5
  %37 = load i8, ptr %35, align 1, !tbaa !9
  %38 = zext i8 %37 to i32
  %39 = xor i32 %34, %38
  %40 = trunc i32 %39 to i8
  %41 = load ptr, ptr %6, align 8, !tbaa !5
  %42 = getelementptr inbounds i8, ptr %41, i64 2
  store i8 %40, ptr %42, align 1, !tbaa !9
  %43 = load ptr, ptr %5, align 8, !tbaa !5
  %44 = getelementptr inbounds i8, ptr %43, i64 3
  %45 = load i8, ptr %44, align 1, !tbaa !9
  %46 = zext i8 %45 to i32
  %47 = load ptr, ptr %4, align 8, !tbaa !5
  %48 = getelementptr inbounds i8, ptr %47, i32 1
  store ptr %48, ptr %4, align 8, !tbaa !5
  %49 = load i8, ptr %47, align 1, !tbaa !9
  %50 = zext i8 %49 to i32
  %51 = xor i32 %46, %50
  %52 = trunc i32 %51 to i8
  %53 = load ptr, ptr %6, align 8, !tbaa !5
  %54 = getelementptr inbounds i8, ptr %53, i64 3
  store i8 %52, ptr %54, align 1, !tbaa !9
  %55 = load ptr, ptr %5, align 8, !tbaa !5
  %56 = getelementptr inbounds i8, ptr %55, i64 4
  %57 = load i8, ptr %56, align 1, !tbaa !9
  %58 = zext i8 %57 to i32
  %59 = load ptr, ptr %4, align 8, !tbaa !5
  %60 = getelementptr inbounds i8, ptr %59, i32 1
  store ptr %60, ptr %4, align 8, !tbaa !5
  %61 = load i8, ptr %59, align 1, !tbaa !9
  %62 = zext i8 %61 to i32
  %63 = xor i32 %58, %62
  %64 = trunc i32 %63 to i8
  %65 = load ptr, ptr %6, align 8, !tbaa !5
  %66 = getelementptr inbounds i8, ptr %65, i64 4
  store i8 %64, ptr %66, align 1, !tbaa !9
  %67 = load ptr, ptr %5, align 8, !tbaa !5
  %68 = getelementptr inbounds i8, ptr %67, i64 5
  %69 = load i8, ptr %68, align 1, !tbaa !9
  %70 = zext i8 %69 to i32
  %71 = load ptr, ptr %4, align 8, !tbaa !5
  %72 = getelementptr inbounds i8, ptr %71, i32 1
  store ptr %72, ptr %4, align 8, !tbaa !5
  %73 = load i8, ptr %71, align 1, !tbaa !9
  %74 = zext i8 %73 to i32
  %75 = xor i32 %70, %74
  %76 = trunc i32 %75 to i8
  %77 = load ptr, ptr %6, align 8, !tbaa !5
  %78 = getelementptr inbounds i8, ptr %77, i64 5
  store i8 %76, ptr %78, align 1, !tbaa !9
  %79 = load ptr, ptr %5, align 8, !tbaa !5
  %80 = getelementptr inbounds i8, ptr %79, i64 6
  %81 = load i8, ptr %80, align 1, !tbaa !9
  %82 = zext i8 %81 to i32
  %83 = load ptr, ptr %4, align 8, !tbaa !5
  %84 = getelementptr inbounds i8, ptr %83, i32 1
  store ptr %84, ptr %4, align 8, !tbaa !5
  %85 = load i8, ptr %83, align 1, !tbaa !9
  %86 = zext i8 %85 to i32
  %87 = xor i32 %82, %86
  %88 = trunc i32 %87 to i8
  %89 = load ptr, ptr %6, align 8, !tbaa !5
  %90 = getelementptr inbounds i8, ptr %89, i64 6
  store i8 %88, ptr %90, align 1, !tbaa !9
  %91 = load ptr, ptr %5, align 8, !tbaa !5
  %92 = getelementptr inbounds i8, ptr %91, i64 7
  %93 = load i8, ptr %92, align 1, !tbaa !9
  %94 = zext i8 %93 to i32
  %95 = load ptr, ptr %4, align 8, !tbaa !5
  %96 = getelementptr inbounds i8, ptr %95, i32 1
  store ptr %96, ptr %4, align 8, !tbaa !5
  %97 = load i8, ptr %95, align 1, !tbaa !9
  %98 = zext i8 %97 to i32
  %99 = xor i32 %94, %98
  %100 = trunc i32 %99 to i8
  %101 = load ptr, ptr %6, align 8, !tbaa !5
  %102 = getelementptr inbounds i8, ptr %101, i64 7
  store i8 %100, ptr %102, align 1, !tbaa !9
  %103 = load ptr, ptr %5, align 8, !tbaa !5
  %104 = getelementptr inbounds i8, ptr %103, i64 8
  %105 = load i8, ptr %104, align 1, !tbaa !9
  %106 = zext i8 %105 to i32
  %107 = load ptr, ptr %4, align 8, !tbaa !5
  %108 = getelementptr inbounds i8, ptr %107, i32 1
  store ptr %108, ptr %4, align 8, !tbaa !5
  %109 = load i8, ptr %107, align 1, !tbaa !9
  %110 = zext i8 %109 to i32
  %111 = xor i32 %106, %110
  %112 = trunc i32 %111 to i8
  %113 = load ptr, ptr %6, align 8, !tbaa !5
  %114 = getelementptr inbounds i8, ptr %113, i64 8
  store i8 %112, ptr %114, align 1, !tbaa !9
  %115 = load ptr, ptr %5, align 8, !tbaa !5
  %116 = getelementptr inbounds i8, ptr %115, i64 9
  %117 = load i8, ptr %116, align 1, !tbaa !9
  %118 = zext i8 %117 to i32
  %119 = load ptr, ptr %4, align 8, !tbaa !5
  %120 = getelementptr inbounds i8, ptr %119, i32 1
  store ptr %120, ptr %4, align 8, !tbaa !5
  %121 = load i8, ptr %119, align 1, !tbaa !9
  %122 = zext i8 %121 to i32
  %123 = xor i32 %118, %122
  %124 = trunc i32 %123 to i8
  %125 = load ptr, ptr %6, align 8, !tbaa !5
  %126 = getelementptr inbounds i8, ptr %125, i64 9
  store i8 %124, ptr %126, align 1, !tbaa !9
  %127 = load ptr, ptr %5, align 8, !tbaa !5
  %128 = getelementptr inbounds i8, ptr %127, i64 10
  %129 = load i8, ptr %128, align 1, !tbaa !9
  %130 = zext i8 %129 to i32
  %131 = load ptr, ptr %4, align 8, !tbaa !5
  %132 = getelementptr inbounds i8, ptr %131, i32 1
  store ptr %132, ptr %4, align 8, !tbaa !5
  %133 = load i8, ptr %131, align 1, !tbaa !9
  %134 = zext i8 %133 to i32
  %135 = xor i32 %130, %134
  %136 = trunc i32 %135 to i8
  %137 = load ptr, ptr %6, align 8, !tbaa !5
  %138 = getelementptr inbounds i8, ptr %137, i64 10
  store i8 %136, ptr %138, align 1, !tbaa !9
  %139 = load ptr, ptr %5, align 8, !tbaa !5
  %140 = getelementptr inbounds i8, ptr %139, i64 11
  %141 = load i8, ptr %140, align 1, !tbaa !9
  %142 = zext i8 %141 to i32
  %143 = load ptr, ptr %4, align 8, !tbaa !5
  %144 = getelementptr inbounds i8, ptr %143, i32 1
  store ptr %144, ptr %4, align 8, !tbaa !5
  %145 = load i8, ptr %143, align 1, !tbaa !9
  %146 = zext i8 %145 to i32
  %147 = xor i32 %142, %146
  %148 = trunc i32 %147 to i8
  %149 = load ptr, ptr %6, align 8, !tbaa !5
  %150 = getelementptr inbounds i8, ptr %149, i64 11
  store i8 %148, ptr %150, align 1, !tbaa !9
  %151 = load ptr, ptr %5, align 8, !tbaa !5
  %152 = getelementptr inbounds i8, ptr %151, i64 12
  %153 = load i8, ptr %152, align 1, !tbaa !9
  %154 = zext i8 %153 to i32
  %155 = load ptr, ptr %4, align 8, !tbaa !5
  %156 = getelementptr inbounds i8, ptr %155, i32 1
  store ptr %156, ptr %4, align 8, !tbaa !5
  %157 = load i8, ptr %155, align 1, !tbaa !9
  %158 = zext i8 %157 to i32
  %159 = xor i32 %154, %158
  %160 = trunc i32 %159 to i8
  %161 = load ptr, ptr %6, align 8, !tbaa !5
  %162 = getelementptr inbounds i8, ptr %161, i64 12
  store i8 %160, ptr %162, align 1, !tbaa !9
  %163 = load ptr, ptr %5, align 8, !tbaa !5
  %164 = getelementptr inbounds i8, ptr %163, i64 13
  %165 = load i8, ptr %164, align 1, !tbaa !9
  %166 = zext i8 %165 to i32
  %167 = load ptr, ptr %4, align 8, !tbaa !5
  %168 = getelementptr inbounds i8, ptr %167, i32 1
  store ptr %168, ptr %4, align 8, !tbaa !5
  %169 = load i8, ptr %167, align 1, !tbaa !9
  %170 = zext i8 %169 to i32
  %171 = xor i32 %166, %170
  %172 = trunc i32 %171 to i8
  %173 = load ptr, ptr %6, align 8, !tbaa !5
  %174 = getelementptr inbounds i8, ptr %173, i64 13
  store i8 %172, ptr %174, align 1, !tbaa !9
  %175 = load ptr, ptr %5, align 8, !tbaa !5
  %176 = getelementptr inbounds i8, ptr %175, i64 14
  %177 = load i8, ptr %176, align 1, !tbaa !9
  %178 = zext i8 %177 to i32
  %179 = load ptr, ptr %4, align 8, !tbaa !5
  %180 = getelementptr inbounds i8, ptr %179, i32 1
  store ptr %180, ptr %4, align 8, !tbaa !5
  %181 = load i8, ptr %179, align 1, !tbaa !9
  %182 = zext i8 %181 to i32
  %183 = xor i32 %178, %182
  %184 = trunc i32 %183 to i8
  %185 = load ptr, ptr %6, align 8, !tbaa !5
  %186 = getelementptr inbounds i8, ptr %185, i64 14
  store i8 %184, ptr %186, align 1, !tbaa !9
  %187 = load ptr, ptr %5, align 8, !tbaa !5
  %188 = getelementptr inbounds i8, ptr %187, i64 15
  %189 = load i8, ptr %188, align 1, !tbaa !9
  %190 = zext i8 %189 to i32
  %191 = load ptr, ptr %4, align 8, !tbaa !5
  %192 = getelementptr inbounds i8, ptr %191, i32 1
  store ptr %192, ptr %4, align 8, !tbaa !5
  %193 = load i8, ptr %191, align 1, !tbaa !9
  %194 = zext i8 %193 to i32
  %195 = xor i32 %190, %194
  %196 = trunc i32 %195 to i8
  %197 = load ptr, ptr %6, align 8, !tbaa !5
  %198 = getelementptr inbounds i8, ptr %197, i64 15
  store i8 %196, ptr %198, align 1, !tbaa !9
  %199 = load ptr, ptr %6, align 8, !tbaa !5
  %200 = load i8, ptr %199, align 1, !tbaa !9
  %201 = zext i8 %200 to i64
  %202 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %201
  %203 = load i8, ptr %202, align 1, !tbaa !9
  %204 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  store i8 %203, ptr %204, align 16, !tbaa !9
  %205 = load ptr, ptr %6, align 8, !tbaa !5
  %206 = getelementptr inbounds i8, ptr %205, i64 1
  %207 = load i8, ptr %206, align 1, !tbaa !9
  %208 = zext i8 %207 to i64
  %209 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %208
  %210 = load i8, ptr %209, align 1, !tbaa !9
  %211 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %212 = getelementptr inbounds i8, ptr %211, i64 1
  store i8 %210, ptr %212, align 1, !tbaa !9
  %213 = load ptr, ptr %6, align 8, !tbaa !5
  %214 = getelementptr inbounds i8, ptr %213, i64 2
  %215 = load i8, ptr %214, align 1, !tbaa !9
  %216 = zext i8 %215 to i64
  %217 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %216
  %218 = load i8, ptr %217, align 1, !tbaa !9
  %219 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %220 = getelementptr inbounds i8, ptr %219, i64 2
  store i8 %218, ptr %220, align 1, !tbaa !9
  %221 = load ptr, ptr %6, align 8, !tbaa !5
  %222 = getelementptr inbounds i8, ptr %221, i64 3
  %223 = load i8, ptr %222, align 1, !tbaa !9
  %224 = zext i8 %223 to i64
  %225 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %224
  %226 = load i8, ptr %225, align 1, !tbaa !9
  %227 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %228 = getelementptr inbounds i8, ptr %227, i64 3
  store i8 %226, ptr %228, align 1, !tbaa !9
  %229 = load ptr, ptr %6, align 8, !tbaa !5
  %230 = getelementptr inbounds i8, ptr %229, i64 4
  %231 = load i8, ptr %230, align 1, !tbaa !9
  %232 = zext i8 %231 to i64
  %233 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %232
  %234 = load i8, ptr %233, align 1, !tbaa !9
  %235 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %236 = getelementptr inbounds i8, ptr %235, i64 4
  store i8 %234, ptr %236, align 1, !tbaa !9
  %237 = load ptr, ptr %6, align 8, !tbaa !5
  %238 = getelementptr inbounds i8, ptr %237, i64 5
  %239 = load i8, ptr %238, align 1, !tbaa !9
  %240 = zext i8 %239 to i64
  %241 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %240
  %242 = load i8, ptr %241, align 1, !tbaa !9
  %243 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %244 = getelementptr inbounds i8, ptr %243, i64 5
  store i8 %242, ptr %244, align 1, !tbaa !9
  %245 = load ptr, ptr %6, align 8, !tbaa !5
  %246 = getelementptr inbounds i8, ptr %245, i64 6
  %247 = load i8, ptr %246, align 1, !tbaa !9
  %248 = zext i8 %247 to i64
  %249 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %248
  %250 = load i8, ptr %249, align 1, !tbaa !9
  %251 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %252 = getelementptr inbounds i8, ptr %251, i64 6
  store i8 %250, ptr %252, align 1, !tbaa !9
  %253 = load ptr, ptr %6, align 8, !tbaa !5
  %254 = getelementptr inbounds i8, ptr %253, i64 7
  %255 = load i8, ptr %254, align 1, !tbaa !9
  %256 = zext i8 %255 to i64
  %257 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %256
  %258 = load i8, ptr %257, align 1, !tbaa !9
  %259 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %260 = getelementptr inbounds i8, ptr %259, i64 7
  store i8 %258, ptr %260, align 1, !tbaa !9
  %261 = load ptr, ptr %6, align 8, !tbaa !5
  %262 = getelementptr inbounds i8, ptr %261, i64 8
  %263 = load i8, ptr %262, align 1, !tbaa !9
  %264 = zext i8 %263 to i64
  %265 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %264
  %266 = load i8, ptr %265, align 1, !tbaa !9
  %267 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %268 = getelementptr inbounds i8, ptr %267, i64 8
  store i8 %266, ptr %268, align 1, !tbaa !9
  %269 = load ptr, ptr %6, align 8, !tbaa !5
  %270 = getelementptr inbounds i8, ptr %269, i64 9
  %271 = load i8, ptr %270, align 1, !tbaa !9
  %272 = zext i8 %271 to i64
  %273 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %272
  %274 = load i8, ptr %273, align 1, !tbaa !9
  %275 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %276 = getelementptr inbounds i8, ptr %275, i64 9
  store i8 %274, ptr %276, align 1, !tbaa !9
  %277 = load ptr, ptr %6, align 8, !tbaa !5
  %278 = getelementptr inbounds i8, ptr %277, i64 10
  %279 = load i8, ptr %278, align 1, !tbaa !9
  %280 = zext i8 %279 to i64
  %281 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %280
  %282 = load i8, ptr %281, align 1, !tbaa !9
  %283 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %284 = getelementptr inbounds i8, ptr %283, i64 10
  store i8 %282, ptr %284, align 1, !tbaa !9
  %285 = load ptr, ptr %6, align 8, !tbaa !5
  %286 = getelementptr inbounds i8, ptr %285, i64 11
  %287 = load i8, ptr %286, align 1, !tbaa !9
  %288 = zext i8 %287 to i64
  %289 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %288
  %290 = load i8, ptr %289, align 1, !tbaa !9
  %291 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %292 = getelementptr inbounds i8, ptr %291, i64 11
  store i8 %290, ptr %292, align 1, !tbaa !9
  %293 = load ptr, ptr %6, align 8, !tbaa !5
  %294 = getelementptr inbounds i8, ptr %293, i64 12
  %295 = load i8, ptr %294, align 1, !tbaa !9
  %296 = zext i8 %295 to i64
  %297 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %296
  %298 = load i8, ptr %297, align 1, !tbaa !9
  %299 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %300 = getelementptr inbounds i8, ptr %299, i64 12
  store i8 %298, ptr %300, align 1, !tbaa !9
  %301 = load ptr, ptr %6, align 8, !tbaa !5
  %302 = getelementptr inbounds i8, ptr %301, i64 13
  %303 = load i8, ptr %302, align 1, !tbaa !9
  %304 = zext i8 %303 to i64
  %305 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %304
  %306 = load i8, ptr %305, align 1, !tbaa !9
  %307 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %308 = getelementptr inbounds i8, ptr %307, i64 13
  store i8 %306, ptr %308, align 1, !tbaa !9
  %309 = load ptr, ptr %6, align 8, !tbaa !5
  %310 = getelementptr inbounds i8, ptr %309, i64 14
  %311 = load i8, ptr %310, align 1, !tbaa !9
  %312 = zext i8 %311 to i64
  %313 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %312
  %314 = load i8, ptr %313, align 1, !tbaa !9
  %315 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %316 = getelementptr inbounds i8, ptr %315, i64 14
  store i8 %314, ptr %316, align 1, !tbaa !9
  %317 = load ptr, ptr %6, align 8, !tbaa !5
  %318 = getelementptr inbounds i8, ptr %317, i64 15
  %319 = load i8, ptr %318, align 1, !tbaa !9
  %320 = zext i8 %319 to i64
  %321 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %320
  %322 = load i8, ptr %321, align 1, !tbaa !9
  %323 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %324 = getelementptr inbounds i8, ptr %323, i64 15
  store i8 %322, ptr %324, align 1, !tbaa !9
  %325 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %326 = getelementptr inbounds i8, ptr %325, i64 1
  %327 = load i8, ptr %326, align 1, !tbaa !9
  store i8 %327, ptr %8, align 1, !tbaa !9
  %328 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %329 = getelementptr inbounds i8, ptr %328, i64 5
  %330 = load i8, ptr %329, align 1, !tbaa !9
  %331 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %332 = getelementptr inbounds i8, ptr %331, i64 1
  store i8 %330, ptr %332, align 1, !tbaa !9
  %333 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %334 = getelementptr inbounds i8, ptr %333, i64 9
  %335 = load i8, ptr %334, align 1, !tbaa !9
  %336 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %337 = getelementptr inbounds i8, ptr %336, i64 5
  store i8 %335, ptr %337, align 1, !tbaa !9
  %338 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %339 = getelementptr inbounds i8, ptr %338, i64 13
  %340 = load i8, ptr %339, align 1, !tbaa !9
  %341 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %342 = getelementptr inbounds i8, ptr %341, i64 9
  store i8 %340, ptr %342, align 1, !tbaa !9
  %343 = load i8, ptr %8, align 1, !tbaa !9
  %344 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %345 = getelementptr inbounds i8, ptr %344, i64 13
  store i8 %343, ptr %345, align 1, !tbaa !9
  %346 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %347 = getelementptr inbounds i8, ptr %346, i64 2
  %348 = load i8, ptr %347, align 1, !tbaa !9
  store i8 %348, ptr %8, align 1, !tbaa !9
  %349 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %350 = getelementptr inbounds i8, ptr %349, i64 10
  %351 = load i8, ptr %350, align 1, !tbaa !9
  %352 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %353 = getelementptr inbounds i8, ptr %352, i64 2
  store i8 %351, ptr %353, align 1, !tbaa !9
  %354 = load i8, ptr %8, align 1, !tbaa !9
  %355 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %356 = getelementptr inbounds i8, ptr %355, i64 10
  store i8 %354, ptr %356, align 1, !tbaa !9
  %357 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %358 = getelementptr inbounds i8, ptr %357, i64 6
  %359 = load i8, ptr %358, align 1, !tbaa !9
  store i8 %359, ptr %8, align 1, !tbaa !9
  %360 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %361 = getelementptr inbounds i8, ptr %360, i64 14
  %362 = load i8, ptr %361, align 1, !tbaa !9
  %363 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %364 = getelementptr inbounds i8, ptr %363, i64 6
  store i8 %362, ptr %364, align 1, !tbaa !9
  %365 = load i8, ptr %8, align 1, !tbaa !9
  %366 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %367 = getelementptr inbounds i8, ptr %366, i64 14
  store i8 %365, ptr %367, align 1, !tbaa !9
  %368 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %369 = getelementptr inbounds i8, ptr %368, i64 15
  %370 = load i8, ptr %369, align 1, !tbaa !9
  store i8 %370, ptr %8, align 1, !tbaa !9
  %371 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %372 = getelementptr inbounds i8, ptr %371, i64 11
  %373 = load i8, ptr %372, align 1, !tbaa !9
  %374 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %375 = getelementptr inbounds i8, ptr %374, i64 15
  store i8 %373, ptr %375, align 1, !tbaa !9
  %376 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %377 = getelementptr inbounds i8, ptr %376, i64 7
  %378 = load i8, ptr %377, align 1, !tbaa !9
  %379 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %380 = getelementptr inbounds i8, ptr %379, i64 11
  store i8 %378, ptr %380, align 1, !tbaa !9
  %381 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %382 = getelementptr inbounds i8, ptr %381, i64 3
  %383 = load i8, ptr %382, align 1, !tbaa !9
  %384 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %385 = getelementptr inbounds i8, ptr %384, i64 7
  store i8 %383, ptr %385, align 1, !tbaa !9
  %386 = load i8, ptr %8, align 1, !tbaa !9
  %387 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %388 = getelementptr inbounds i8, ptr %387, i64 3
  store i8 %386, ptr %388, align 1, !tbaa !9
  %389 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %390 = load i8, ptr %389, align 16, !tbaa !9
  %391 = zext i8 %390 to i32
  %392 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %393 = load i8, ptr %392, align 1, !tbaa !9
  %394 = zext i8 %393 to i32
  %395 = xor i32 %391, %394
  %396 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %397 = load i8, ptr %396, align 2, !tbaa !9
  %398 = zext i8 %397 to i32
  %399 = xor i32 %395, %398
  %400 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %401 = load i8, ptr %400, align 1, !tbaa !9
  %402 = zext i8 %401 to i32
  %403 = xor i32 %399, %402
  %404 = trunc i32 %403 to i8
  store i8 %404, ptr %8, align 1, !tbaa !9
  %405 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %406 = load i8, ptr %405, align 16, !tbaa !9
  %407 = zext i8 %406 to i32
  %408 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %409 = load i8, ptr %408, align 1, !tbaa !9
  %410 = zext i8 %409 to i32
  %411 = xor i32 %407, %410
  %412 = trunc i32 %411 to i8
  %413 = call zeroext i8 @mul2(i8 noundef zeroext %412)
  %414 = zext i8 %413 to i32
  %415 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %416 = load i8, ptr %415, align 16, !tbaa !9
  %417 = zext i8 %416 to i32
  %418 = xor i32 %414, %417
  %419 = load i8, ptr %8, align 1, !tbaa !9
  %420 = zext i8 %419 to i32
  %421 = xor i32 %418, %420
  %422 = trunc i32 %421 to i8
  %423 = load ptr, ptr %6, align 8, !tbaa !5
  %424 = getelementptr inbounds i8, ptr %423, i64 0
  store i8 %422, ptr %424, align 1, !tbaa !9
  %425 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %426 = load i8, ptr %425, align 1, !tbaa !9
  %427 = zext i8 %426 to i32
  %428 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %429 = load i8, ptr %428, align 2, !tbaa !9
  %430 = zext i8 %429 to i32
  %431 = xor i32 %427, %430
  %432 = trunc i32 %431 to i8
  %433 = call zeroext i8 @mul2(i8 noundef zeroext %432)
  %434 = zext i8 %433 to i32
  %435 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %436 = load i8, ptr %435, align 1, !tbaa !9
  %437 = zext i8 %436 to i32
  %438 = xor i32 %434, %437
  %439 = load i8, ptr %8, align 1, !tbaa !9
  %440 = zext i8 %439 to i32
  %441 = xor i32 %438, %440
  %442 = trunc i32 %441 to i8
  %443 = load ptr, ptr %6, align 8, !tbaa !5
  %444 = getelementptr inbounds i8, ptr %443, i64 1
  store i8 %442, ptr %444, align 1, !tbaa !9
  %445 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %446 = load i8, ptr %445, align 2, !tbaa !9
  %447 = zext i8 %446 to i32
  %448 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %449 = load i8, ptr %448, align 1, !tbaa !9
  %450 = zext i8 %449 to i32
  %451 = xor i32 %447, %450
  %452 = trunc i32 %451 to i8
  %453 = call zeroext i8 @mul2(i8 noundef zeroext %452)
  %454 = zext i8 %453 to i32
  %455 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %456 = load i8, ptr %455, align 2, !tbaa !9
  %457 = zext i8 %456 to i32
  %458 = xor i32 %454, %457
  %459 = load i8, ptr %8, align 1, !tbaa !9
  %460 = zext i8 %459 to i32
  %461 = xor i32 %458, %460
  %462 = trunc i32 %461 to i8
  %463 = load ptr, ptr %6, align 8, !tbaa !5
  %464 = getelementptr inbounds i8, ptr %463, i64 2
  store i8 %462, ptr %464, align 1, !tbaa !9
  %465 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %466 = load i8, ptr %465, align 1, !tbaa !9
  %467 = zext i8 %466 to i32
  %468 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %469 = load i8, ptr %468, align 16, !tbaa !9
  %470 = zext i8 %469 to i32
  %471 = xor i32 %467, %470
  %472 = trunc i32 %471 to i8
  %473 = call zeroext i8 @mul2(i8 noundef zeroext %472)
  %474 = zext i8 %473 to i32
  %475 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %476 = load i8, ptr %475, align 1, !tbaa !9
  %477 = zext i8 %476 to i32
  %478 = xor i32 %474, %477
  %479 = load i8, ptr %8, align 1, !tbaa !9
  %480 = zext i8 %479 to i32
  %481 = xor i32 %478, %480
  %482 = trunc i32 %481 to i8
  %483 = load ptr, ptr %6, align 8, !tbaa !5
  %484 = getelementptr inbounds i8, ptr %483, i64 3
  store i8 %482, ptr %484, align 1, !tbaa !9
  %485 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %486 = load i8, ptr %485, align 4, !tbaa !9
  %487 = zext i8 %486 to i32
  %488 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %489 = load i8, ptr %488, align 1, !tbaa !9
  %490 = zext i8 %489 to i32
  %491 = xor i32 %487, %490
  %492 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %493 = load i8, ptr %492, align 2, !tbaa !9
  %494 = zext i8 %493 to i32
  %495 = xor i32 %491, %494
  %496 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %497 = load i8, ptr %496, align 1, !tbaa !9
  %498 = zext i8 %497 to i32
  %499 = xor i32 %495, %498
  %500 = trunc i32 %499 to i8
  store i8 %500, ptr %8, align 1, !tbaa !9
  %501 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %502 = load i8, ptr %501, align 4, !tbaa !9
  %503 = zext i8 %502 to i32
  %504 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %505 = load i8, ptr %504, align 1, !tbaa !9
  %506 = zext i8 %505 to i32
  %507 = xor i32 %503, %506
  %508 = trunc i32 %507 to i8
  %509 = call zeroext i8 @mul2(i8 noundef zeroext %508)
  %510 = zext i8 %509 to i32
  %511 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %512 = load i8, ptr %511, align 4, !tbaa !9
  %513 = zext i8 %512 to i32
  %514 = xor i32 %510, %513
  %515 = load i8, ptr %8, align 1, !tbaa !9
  %516 = zext i8 %515 to i32
  %517 = xor i32 %514, %516
  %518 = trunc i32 %517 to i8
  %519 = load ptr, ptr %6, align 8, !tbaa !5
  %520 = getelementptr inbounds i8, ptr %519, i64 4
  store i8 %518, ptr %520, align 1, !tbaa !9
  %521 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %522 = load i8, ptr %521, align 1, !tbaa !9
  %523 = zext i8 %522 to i32
  %524 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %525 = load i8, ptr %524, align 2, !tbaa !9
  %526 = zext i8 %525 to i32
  %527 = xor i32 %523, %526
  %528 = trunc i32 %527 to i8
  %529 = call zeroext i8 @mul2(i8 noundef zeroext %528)
  %530 = zext i8 %529 to i32
  %531 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %532 = load i8, ptr %531, align 1, !tbaa !9
  %533 = zext i8 %532 to i32
  %534 = xor i32 %530, %533
  %535 = load i8, ptr %8, align 1, !tbaa !9
  %536 = zext i8 %535 to i32
  %537 = xor i32 %534, %536
  %538 = trunc i32 %537 to i8
  %539 = load ptr, ptr %6, align 8, !tbaa !5
  %540 = getelementptr inbounds i8, ptr %539, i64 5
  store i8 %538, ptr %540, align 1, !tbaa !9
  %541 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %542 = load i8, ptr %541, align 2, !tbaa !9
  %543 = zext i8 %542 to i32
  %544 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %545 = load i8, ptr %544, align 1, !tbaa !9
  %546 = zext i8 %545 to i32
  %547 = xor i32 %543, %546
  %548 = trunc i32 %547 to i8
  %549 = call zeroext i8 @mul2(i8 noundef zeroext %548)
  %550 = zext i8 %549 to i32
  %551 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %552 = load i8, ptr %551, align 2, !tbaa !9
  %553 = zext i8 %552 to i32
  %554 = xor i32 %550, %553
  %555 = load i8, ptr %8, align 1, !tbaa !9
  %556 = zext i8 %555 to i32
  %557 = xor i32 %554, %556
  %558 = trunc i32 %557 to i8
  %559 = load ptr, ptr %6, align 8, !tbaa !5
  %560 = getelementptr inbounds i8, ptr %559, i64 6
  store i8 %558, ptr %560, align 1, !tbaa !9
  %561 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %562 = load i8, ptr %561, align 1, !tbaa !9
  %563 = zext i8 %562 to i32
  %564 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %565 = load i8, ptr %564, align 4, !tbaa !9
  %566 = zext i8 %565 to i32
  %567 = xor i32 %563, %566
  %568 = trunc i32 %567 to i8
  %569 = call zeroext i8 @mul2(i8 noundef zeroext %568)
  %570 = zext i8 %569 to i32
  %571 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %572 = load i8, ptr %571, align 1, !tbaa !9
  %573 = zext i8 %572 to i32
  %574 = xor i32 %570, %573
  %575 = load i8, ptr %8, align 1, !tbaa !9
  %576 = zext i8 %575 to i32
  %577 = xor i32 %574, %576
  %578 = trunc i32 %577 to i8
  %579 = load ptr, ptr %6, align 8, !tbaa !5
  %580 = getelementptr inbounds i8, ptr %579, i64 7
  store i8 %578, ptr %580, align 1, !tbaa !9
  %581 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %582 = load i8, ptr %581, align 8, !tbaa !9
  %583 = zext i8 %582 to i32
  %584 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %585 = load i8, ptr %584, align 1, !tbaa !9
  %586 = zext i8 %585 to i32
  %587 = xor i32 %583, %586
  %588 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %589 = load i8, ptr %588, align 2, !tbaa !9
  %590 = zext i8 %589 to i32
  %591 = xor i32 %587, %590
  %592 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %593 = load i8, ptr %592, align 1, !tbaa !9
  %594 = zext i8 %593 to i32
  %595 = xor i32 %591, %594
  %596 = trunc i32 %595 to i8
  store i8 %596, ptr %8, align 1, !tbaa !9
  %597 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %598 = load i8, ptr %597, align 8, !tbaa !9
  %599 = zext i8 %598 to i32
  %600 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %601 = load i8, ptr %600, align 1, !tbaa !9
  %602 = zext i8 %601 to i32
  %603 = xor i32 %599, %602
  %604 = trunc i32 %603 to i8
  %605 = call zeroext i8 @mul2(i8 noundef zeroext %604)
  %606 = zext i8 %605 to i32
  %607 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %608 = load i8, ptr %607, align 8, !tbaa !9
  %609 = zext i8 %608 to i32
  %610 = xor i32 %606, %609
  %611 = load i8, ptr %8, align 1, !tbaa !9
  %612 = zext i8 %611 to i32
  %613 = xor i32 %610, %612
  %614 = trunc i32 %613 to i8
  %615 = load ptr, ptr %6, align 8, !tbaa !5
  %616 = getelementptr inbounds i8, ptr %615, i64 8
  store i8 %614, ptr %616, align 1, !tbaa !9
  %617 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %618 = load i8, ptr %617, align 1, !tbaa !9
  %619 = zext i8 %618 to i32
  %620 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %621 = load i8, ptr %620, align 2, !tbaa !9
  %622 = zext i8 %621 to i32
  %623 = xor i32 %619, %622
  %624 = trunc i32 %623 to i8
  %625 = call zeroext i8 @mul2(i8 noundef zeroext %624)
  %626 = zext i8 %625 to i32
  %627 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %628 = load i8, ptr %627, align 1, !tbaa !9
  %629 = zext i8 %628 to i32
  %630 = xor i32 %626, %629
  %631 = load i8, ptr %8, align 1, !tbaa !9
  %632 = zext i8 %631 to i32
  %633 = xor i32 %630, %632
  %634 = trunc i32 %633 to i8
  %635 = load ptr, ptr %6, align 8, !tbaa !5
  %636 = getelementptr inbounds i8, ptr %635, i64 9
  store i8 %634, ptr %636, align 1, !tbaa !9
  %637 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %638 = load i8, ptr %637, align 2, !tbaa !9
  %639 = zext i8 %638 to i32
  %640 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %641 = load i8, ptr %640, align 1, !tbaa !9
  %642 = zext i8 %641 to i32
  %643 = xor i32 %639, %642
  %644 = trunc i32 %643 to i8
  %645 = call zeroext i8 @mul2(i8 noundef zeroext %644)
  %646 = zext i8 %645 to i32
  %647 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %648 = load i8, ptr %647, align 2, !tbaa !9
  %649 = zext i8 %648 to i32
  %650 = xor i32 %646, %649
  %651 = load i8, ptr %8, align 1, !tbaa !9
  %652 = zext i8 %651 to i32
  %653 = xor i32 %650, %652
  %654 = trunc i32 %653 to i8
  %655 = load ptr, ptr %6, align 8, !tbaa !5
  %656 = getelementptr inbounds i8, ptr %655, i64 10
  store i8 %654, ptr %656, align 1, !tbaa !9
  %657 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %658 = load i8, ptr %657, align 1, !tbaa !9
  %659 = zext i8 %658 to i32
  %660 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %661 = load i8, ptr %660, align 8, !tbaa !9
  %662 = zext i8 %661 to i32
  %663 = xor i32 %659, %662
  %664 = trunc i32 %663 to i8
  %665 = call zeroext i8 @mul2(i8 noundef zeroext %664)
  %666 = zext i8 %665 to i32
  %667 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %668 = load i8, ptr %667, align 1, !tbaa !9
  %669 = zext i8 %668 to i32
  %670 = xor i32 %666, %669
  %671 = load i8, ptr %8, align 1, !tbaa !9
  %672 = zext i8 %671 to i32
  %673 = xor i32 %670, %672
  %674 = trunc i32 %673 to i8
  %675 = load ptr, ptr %6, align 8, !tbaa !5
  %676 = getelementptr inbounds i8, ptr %675, i64 11
  store i8 %674, ptr %676, align 1, !tbaa !9
  %677 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %678 = load i8, ptr %677, align 4, !tbaa !9
  %679 = zext i8 %678 to i32
  %680 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %681 = load i8, ptr %680, align 1, !tbaa !9
  %682 = zext i8 %681 to i32
  %683 = xor i32 %679, %682
  %684 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %685 = load i8, ptr %684, align 2, !tbaa !9
  %686 = zext i8 %685 to i32
  %687 = xor i32 %683, %686
  %688 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %689 = load i8, ptr %688, align 1, !tbaa !9
  %690 = zext i8 %689 to i32
  %691 = xor i32 %687, %690
  %692 = trunc i32 %691 to i8
  store i8 %692, ptr %8, align 1, !tbaa !9
  %693 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %694 = load i8, ptr %693, align 4, !tbaa !9
  %695 = zext i8 %694 to i32
  %696 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %697 = load i8, ptr %696, align 1, !tbaa !9
  %698 = zext i8 %697 to i32
  %699 = xor i32 %695, %698
  %700 = trunc i32 %699 to i8
  %701 = call zeroext i8 @mul2(i8 noundef zeroext %700)
  %702 = zext i8 %701 to i32
  %703 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %704 = load i8, ptr %703, align 4, !tbaa !9
  %705 = zext i8 %704 to i32
  %706 = xor i32 %702, %705
  %707 = load i8, ptr %8, align 1, !tbaa !9
  %708 = zext i8 %707 to i32
  %709 = xor i32 %706, %708
  %710 = trunc i32 %709 to i8
  %711 = load ptr, ptr %6, align 8, !tbaa !5
  %712 = getelementptr inbounds i8, ptr %711, i64 12
  store i8 %710, ptr %712, align 1, !tbaa !9
  %713 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %714 = load i8, ptr %713, align 1, !tbaa !9
  %715 = zext i8 %714 to i32
  %716 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %717 = load i8, ptr %716, align 2, !tbaa !9
  %718 = zext i8 %717 to i32
  %719 = xor i32 %715, %718
  %720 = trunc i32 %719 to i8
  %721 = call zeroext i8 @mul2(i8 noundef zeroext %720)
  %722 = zext i8 %721 to i32
  %723 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %724 = load i8, ptr %723, align 1, !tbaa !9
  %725 = zext i8 %724 to i32
  %726 = xor i32 %722, %725
  %727 = load i8, ptr %8, align 1, !tbaa !9
  %728 = zext i8 %727 to i32
  %729 = xor i32 %726, %728
  %730 = trunc i32 %729 to i8
  %731 = load ptr, ptr %6, align 8, !tbaa !5
  %732 = getelementptr inbounds i8, ptr %731, i64 13
  store i8 %730, ptr %732, align 1, !tbaa !9
  %733 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %734 = load i8, ptr %733, align 2, !tbaa !9
  %735 = zext i8 %734 to i32
  %736 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %737 = load i8, ptr %736, align 1, !tbaa !9
  %738 = zext i8 %737 to i32
  %739 = xor i32 %735, %738
  %740 = trunc i32 %739 to i8
  %741 = call zeroext i8 @mul2(i8 noundef zeroext %740)
  %742 = zext i8 %741 to i32
  %743 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %744 = load i8, ptr %743, align 2, !tbaa !9
  %745 = zext i8 %744 to i32
  %746 = xor i32 %742, %745
  %747 = load i8, ptr %8, align 1, !tbaa !9
  %748 = zext i8 %747 to i32
  %749 = xor i32 %746, %748
  %750 = trunc i32 %749 to i8
  %751 = load ptr, ptr %6, align 8, !tbaa !5
  %752 = getelementptr inbounds i8, ptr %751, i64 14
  store i8 %750, ptr %752, align 1, !tbaa !9
  %753 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %754 = load i8, ptr %753, align 1, !tbaa !9
  %755 = zext i8 %754 to i32
  %756 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %757 = load i8, ptr %756, align 4, !tbaa !9
  %758 = zext i8 %757 to i32
  %759 = xor i32 %755, %758
  %760 = trunc i32 %759 to i8
  %761 = call zeroext i8 @mul2(i8 noundef zeroext %760)
  %762 = zext i8 %761 to i32
  %763 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %764 = load i8, ptr %763, align 1, !tbaa !9
  %765 = zext i8 %764 to i32
  %766 = xor i32 %762, %765
  %767 = load i8, ptr %8, align 1, !tbaa !9
  %768 = zext i8 %767 to i32
  %769 = xor i32 %766, %768
  %770 = trunc i32 %769 to i8
  %771 = load ptr, ptr %6, align 8, !tbaa !5
  %772 = getelementptr inbounds i8, ptr %771, i64 15
  store i8 %770, ptr %772, align 1, !tbaa !9
  %773 = load ptr, ptr %6, align 8, !tbaa !5
  %774 = load i8, ptr %773, align 1, !tbaa !9
  %775 = zext i8 %774 to i32
  %776 = load ptr, ptr %4, align 8, !tbaa !5
  %777 = getelementptr inbounds i8, ptr %776, i32 1
  store ptr %777, ptr %4, align 8, !tbaa !5
  %778 = load i8, ptr %776, align 1, !tbaa !9
  %779 = zext i8 %778 to i32
  %780 = xor i32 %775, %779
  %781 = trunc i32 %780 to i8
  %782 = load ptr, ptr %6, align 8, !tbaa !5
  store i8 %781, ptr %782, align 1, !tbaa !9
  %783 = load ptr, ptr %6, align 8, !tbaa !5
  %784 = getelementptr inbounds i8, ptr %783, i64 1
  %785 = load i8, ptr %784, align 1, !tbaa !9
  %786 = zext i8 %785 to i32
  %787 = load ptr, ptr %4, align 8, !tbaa !5
  %788 = getelementptr inbounds i8, ptr %787, i32 1
  store ptr %788, ptr %4, align 8, !tbaa !5
  %789 = load i8, ptr %787, align 1, !tbaa !9
  %790 = zext i8 %789 to i32
  %791 = xor i32 %786, %790
  %792 = trunc i32 %791 to i8
  %793 = load ptr, ptr %6, align 8, !tbaa !5
  %794 = getelementptr inbounds i8, ptr %793, i64 1
  store i8 %792, ptr %794, align 1, !tbaa !9
  %795 = load ptr, ptr %6, align 8, !tbaa !5
  %796 = getelementptr inbounds i8, ptr %795, i64 2
  %797 = load i8, ptr %796, align 1, !tbaa !9
  %798 = zext i8 %797 to i32
  %799 = load ptr, ptr %4, align 8, !tbaa !5
  %800 = getelementptr inbounds i8, ptr %799, i32 1
  store ptr %800, ptr %4, align 8, !tbaa !5
  %801 = load i8, ptr %799, align 1, !tbaa !9
  %802 = zext i8 %801 to i32
  %803 = xor i32 %798, %802
  %804 = trunc i32 %803 to i8
  %805 = load ptr, ptr %6, align 8, !tbaa !5
  %806 = getelementptr inbounds i8, ptr %805, i64 2
  store i8 %804, ptr %806, align 1, !tbaa !9
  %807 = load ptr, ptr %6, align 8, !tbaa !5
  %808 = getelementptr inbounds i8, ptr %807, i64 3
  %809 = load i8, ptr %808, align 1, !tbaa !9
  %810 = zext i8 %809 to i32
  %811 = load ptr, ptr %4, align 8, !tbaa !5
  %812 = getelementptr inbounds i8, ptr %811, i32 1
  store ptr %812, ptr %4, align 8, !tbaa !5
  %813 = load i8, ptr %811, align 1, !tbaa !9
  %814 = zext i8 %813 to i32
  %815 = xor i32 %810, %814
  %816 = trunc i32 %815 to i8
  %817 = load ptr, ptr %6, align 8, !tbaa !5
  %818 = getelementptr inbounds i8, ptr %817, i64 3
  store i8 %816, ptr %818, align 1, !tbaa !9
  %819 = load ptr, ptr %6, align 8, !tbaa !5
  %820 = getelementptr inbounds i8, ptr %819, i64 4
  %821 = load i8, ptr %820, align 1, !tbaa !9
  %822 = zext i8 %821 to i32
  %823 = load ptr, ptr %4, align 8, !tbaa !5
  %824 = getelementptr inbounds i8, ptr %823, i32 1
  store ptr %824, ptr %4, align 8, !tbaa !5
  %825 = load i8, ptr %823, align 1, !tbaa !9
  %826 = zext i8 %825 to i32
  %827 = xor i32 %822, %826
  %828 = trunc i32 %827 to i8
  %829 = load ptr, ptr %6, align 8, !tbaa !5
  %830 = getelementptr inbounds i8, ptr %829, i64 4
  store i8 %828, ptr %830, align 1, !tbaa !9
  %831 = load ptr, ptr %6, align 8, !tbaa !5
  %832 = getelementptr inbounds i8, ptr %831, i64 5
  %833 = load i8, ptr %832, align 1, !tbaa !9
  %834 = zext i8 %833 to i32
  %835 = load ptr, ptr %4, align 8, !tbaa !5
  %836 = getelementptr inbounds i8, ptr %835, i32 1
  store ptr %836, ptr %4, align 8, !tbaa !5
  %837 = load i8, ptr %835, align 1, !tbaa !9
  %838 = zext i8 %837 to i32
  %839 = xor i32 %834, %838
  %840 = trunc i32 %839 to i8
  %841 = load ptr, ptr %6, align 8, !tbaa !5
  %842 = getelementptr inbounds i8, ptr %841, i64 5
  store i8 %840, ptr %842, align 1, !tbaa !9
  %843 = load ptr, ptr %6, align 8, !tbaa !5
  %844 = getelementptr inbounds i8, ptr %843, i64 6
  %845 = load i8, ptr %844, align 1, !tbaa !9
  %846 = zext i8 %845 to i32
  %847 = load ptr, ptr %4, align 8, !tbaa !5
  %848 = getelementptr inbounds i8, ptr %847, i32 1
  store ptr %848, ptr %4, align 8, !tbaa !5
  %849 = load i8, ptr %847, align 1, !tbaa !9
  %850 = zext i8 %849 to i32
  %851 = xor i32 %846, %850
  %852 = trunc i32 %851 to i8
  %853 = load ptr, ptr %6, align 8, !tbaa !5
  %854 = getelementptr inbounds i8, ptr %853, i64 6
  store i8 %852, ptr %854, align 1, !tbaa !9
  %855 = load ptr, ptr %6, align 8, !tbaa !5
  %856 = getelementptr inbounds i8, ptr %855, i64 7
  %857 = load i8, ptr %856, align 1, !tbaa !9
  %858 = zext i8 %857 to i32
  %859 = load ptr, ptr %4, align 8, !tbaa !5
  %860 = getelementptr inbounds i8, ptr %859, i32 1
  store ptr %860, ptr %4, align 8, !tbaa !5
  %861 = load i8, ptr %859, align 1, !tbaa !9
  %862 = zext i8 %861 to i32
  %863 = xor i32 %858, %862
  %864 = trunc i32 %863 to i8
  %865 = load ptr, ptr %6, align 8, !tbaa !5
  %866 = getelementptr inbounds i8, ptr %865, i64 7
  store i8 %864, ptr %866, align 1, !tbaa !9
  %867 = load ptr, ptr %6, align 8, !tbaa !5
  %868 = getelementptr inbounds i8, ptr %867, i64 8
  %869 = load i8, ptr %868, align 1, !tbaa !9
  %870 = zext i8 %869 to i32
  %871 = load ptr, ptr %4, align 8, !tbaa !5
  %872 = getelementptr inbounds i8, ptr %871, i32 1
  store ptr %872, ptr %4, align 8, !tbaa !5
  %873 = load i8, ptr %871, align 1, !tbaa !9
  %874 = zext i8 %873 to i32
  %875 = xor i32 %870, %874
  %876 = trunc i32 %875 to i8
  %877 = load ptr, ptr %6, align 8, !tbaa !5
  %878 = getelementptr inbounds i8, ptr %877, i64 8
  store i8 %876, ptr %878, align 1, !tbaa !9
  %879 = load ptr, ptr %6, align 8, !tbaa !5
  %880 = getelementptr inbounds i8, ptr %879, i64 9
  %881 = load i8, ptr %880, align 1, !tbaa !9
  %882 = zext i8 %881 to i32
  %883 = load ptr, ptr %4, align 8, !tbaa !5
  %884 = getelementptr inbounds i8, ptr %883, i32 1
  store ptr %884, ptr %4, align 8, !tbaa !5
  %885 = load i8, ptr %883, align 1, !tbaa !9
  %886 = zext i8 %885 to i32
  %887 = xor i32 %882, %886
  %888 = trunc i32 %887 to i8
  %889 = load ptr, ptr %6, align 8, !tbaa !5
  %890 = getelementptr inbounds i8, ptr %889, i64 9
  store i8 %888, ptr %890, align 1, !tbaa !9
  %891 = load ptr, ptr %6, align 8, !tbaa !5
  %892 = getelementptr inbounds i8, ptr %891, i64 10
  %893 = load i8, ptr %892, align 1, !tbaa !9
  %894 = zext i8 %893 to i32
  %895 = load ptr, ptr %4, align 8, !tbaa !5
  %896 = getelementptr inbounds i8, ptr %895, i32 1
  store ptr %896, ptr %4, align 8, !tbaa !5
  %897 = load i8, ptr %895, align 1, !tbaa !9
  %898 = zext i8 %897 to i32
  %899 = xor i32 %894, %898
  %900 = trunc i32 %899 to i8
  %901 = load ptr, ptr %6, align 8, !tbaa !5
  %902 = getelementptr inbounds i8, ptr %901, i64 10
  store i8 %900, ptr %902, align 1, !tbaa !9
  %903 = load ptr, ptr %6, align 8, !tbaa !5
  %904 = getelementptr inbounds i8, ptr %903, i64 11
  %905 = load i8, ptr %904, align 1, !tbaa !9
  %906 = zext i8 %905 to i32
  %907 = load ptr, ptr %4, align 8, !tbaa !5
  %908 = getelementptr inbounds i8, ptr %907, i32 1
  store ptr %908, ptr %4, align 8, !tbaa !5
  %909 = load i8, ptr %907, align 1, !tbaa !9
  %910 = zext i8 %909 to i32
  %911 = xor i32 %906, %910
  %912 = trunc i32 %911 to i8
  %913 = load ptr, ptr %6, align 8, !tbaa !5
  %914 = getelementptr inbounds i8, ptr %913, i64 11
  store i8 %912, ptr %914, align 1, !tbaa !9
  %915 = load ptr, ptr %6, align 8, !tbaa !5
  %916 = getelementptr inbounds i8, ptr %915, i64 12
  %917 = load i8, ptr %916, align 1, !tbaa !9
  %918 = zext i8 %917 to i32
  %919 = load ptr, ptr %4, align 8, !tbaa !5
  %920 = getelementptr inbounds i8, ptr %919, i32 1
  store ptr %920, ptr %4, align 8, !tbaa !5
  %921 = load i8, ptr %919, align 1, !tbaa !9
  %922 = zext i8 %921 to i32
  %923 = xor i32 %918, %922
  %924 = trunc i32 %923 to i8
  %925 = load ptr, ptr %6, align 8, !tbaa !5
  %926 = getelementptr inbounds i8, ptr %925, i64 12
  store i8 %924, ptr %926, align 1, !tbaa !9
  %927 = load ptr, ptr %6, align 8, !tbaa !5
  %928 = getelementptr inbounds i8, ptr %927, i64 13
  %929 = load i8, ptr %928, align 1, !tbaa !9
  %930 = zext i8 %929 to i32
  %931 = load ptr, ptr %4, align 8, !tbaa !5
  %932 = getelementptr inbounds i8, ptr %931, i32 1
  store ptr %932, ptr %4, align 8, !tbaa !5
  %933 = load i8, ptr %931, align 1, !tbaa !9
  %934 = zext i8 %933 to i32
  %935 = xor i32 %930, %934
  %936 = trunc i32 %935 to i8
  %937 = load ptr, ptr %6, align 8, !tbaa !5
  %938 = getelementptr inbounds i8, ptr %937, i64 13
  store i8 %936, ptr %938, align 1, !tbaa !9
  %939 = load ptr, ptr %6, align 8, !tbaa !5
  %940 = getelementptr inbounds i8, ptr %939, i64 14
  %941 = load i8, ptr %940, align 1, !tbaa !9
  %942 = zext i8 %941 to i32
  %943 = load ptr, ptr %4, align 8, !tbaa !5
  %944 = getelementptr inbounds i8, ptr %943, i32 1
  store ptr %944, ptr %4, align 8, !tbaa !5
  %945 = load i8, ptr %943, align 1, !tbaa !9
  %946 = zext i8 %945 to i32
  %947 = xor i32 %942, %946
  %948 = trunc i32 %947 to i8
  %949 = load ptr, ptr %6, align 8, !tbaa !5
  %950 = getelementptr inbounds i8, ptr %949, i64 14
  store i8 %948, ptr %950, align 1, !tbaa !9
  %951 = load ptr, ptr %6, align 8, !tbaa !5
  %952 = getelementptr inbounds i8, ptr %951, i64 15
  %953 = load i8, ptr %952, align 1, !tbaa !9
  %954 = zext i8 %953 to i32
  %955 = load ptr, ptr %4, align 8, !tbaa !5
  %956 = getelementptr inbounds i8, ptr %955, i32 1
  store ptr %956, ptr %4, align 8, !tbaa !5
  %957 = load i8, ptr %955, align 1, !tbaa !9
  %958 = zext i8 %957 to i32
  %959 = xor i32 %954, %958
  %960 = trunc i32 %959 to i8
  %961 = load ptr, ptr %6, align 8, !tbaa !5
  %962 = getelementptr inbounds i8, ptr %961, i64 15
  store i8 %960, ptr %962, align 1, !tbaa !9
  %963 = load ptr, ptr %6, align 8, !tbaa !5
  %964 = load i8, ptr %963, align 1, !tbaa !9
  %965 = zext i8 %964 to i64
  %966 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %965
  %967 = load i8, ptr %966, align 1, !tbaa !9
  %968 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  store i8 %967, ptr %968, align 16, !tbaa !9
  %969 = load ptr, ptr %6, align 8, !tbaa !5
  %970 = getelementptr inbounds i8, ptr %969, i64 1
  %971 = load i8, ptr %970, align 1, !tbaa !9
  %972 = zext i8 %971 to i64
  %973 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %972
  %974 = load i8, ptr %973, align 1, !tbaa !9
  %975 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %976 = getelementptr inbounds i8, ptr %975, i64 1
  store i8 %974, ptr %976, align 1, !tbaa !9
  %977 = load ptr, ptr %6, align 8, !tbaa !5
  %978 = getelementptr inbounds i8, ptr %977, i64 2
  %979 = load i8, ptr %978, align 1, !tbaa !9
  %980 = zext i8 %979 to i64
  %981 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %980
  %982 = load i8, ptr %981, align 1, !tbaa !9
  %983 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %984 = getelementptr inbounds i8, ptr %983, i64 2
  store i8 %982, ptr %984, align 1, !tbaa !9
  %985 = load ptr, ptr %6, align 8, !tbaa !5
  %986 = getelementptr inbounds i8, ptr %985, i64 3
  %987 = load i8, ptr %986, align 1, !tbaa !9
  %988 = zext i8 %987 to i64
  %989 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %988
  %990 = load i8, ptr %989, align 1, !tbaa !9
  %991 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %992 = getelementptr inbounds i8, ptr %991, i64 3
  store i8 %990, ptr %992, align 1, !tbaa !9
  %993 = load ptr, ptr %6, align 8, !tbaa !5
  %994 = getelementptr inbounds i8, ptr %993, i64 4
  %995 = load i8, ptr %994, align 1, !tbaa !9
  %996 = zext i8 %995 to i64
  %997 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %996
  %998 = load i8, ptr %997, align 1, !tbaa !9
  %999 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1000 = getelementptr inbounds i8, ptr %999, i64 4
  store i8 %998, ptr %1000, align 1, !tbaa !9
  %1001 = load ptr, ptr %6, align 8, !tbaa !5
  %1002 = getelementptr inbounds i8, ptr %1001, i64 5
  %1003 = load i8, ptr %1002, align 1, !tbaa !9
  %1004 = zext i8 %1003 to i64
  %1005 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1004
  %1006 = load i8, ptr %1005, align 1, !tbaa !9
  %1007 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1008 = getelementptr inbounds i8, ptr %1007, i64 5
  store i8 %1006, ptr %1008, align 1, !tbaa !9
  %1009 = load ptr, ptr %6, align 8, !tbaa !5
  %1010 = getelementptr inbounds i8, ptr %1009, i64 6
  %1011 = load i8, ptr %1010, align 1, !tbaa !9
  %1012 = zext i8 %1011 to i64
  %1013 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1012
  %1014 = load i8, ptr %1013, align 1, !tbaa !9
  %1015 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1016 = getelementptr inbounds i8, ptr %1015, i64 6
  store i8 %1014, ptr %1016, align 1, !tbaa !9
  %1017 = load ptr, ptr %6, align 8, !tbaa !5
  %1018 = getelementptr inbounds i8, ptr %1017, i64 7
  %1019 = load i8, ptr %1018, align 1, !tbaa !9
  %1020 = zext i8 %1019 to i64
  %1021 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1020
  %1022 = load i8, ptr %1021, align 1, !tbaa !9
  %1023 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1024 = getelementptr inbounds i8, ptr %1023, i64 7
  store i8 %1022, ptr %1024, align 1, !tbaa !9
  %1025 = load ptr, ptr %6, align 8, !tbaa !5
  %1026 = getelementptr inbounds i8, ptr %1025, i64 8
  %1027 = load i8, ptr %1026, align 1, !tbaa !9
  %1028 = zext i8 %1027 to i64
  %1029 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1028
  %1030 = load i8, ptr %1029, align 1, !tbaa !9
  %1031 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1032 = getelementptr inbounds i8, ptr %1031, i64 8
  store i8 %1030, ptr %1032, align 1, !tbaa !9
  %1033 = load ptr, ptr %6, align 8, !tbaa !5
  %1034 = getelementptr inbounds i8, ptr %1033, i64 9
  %1035 = load i8, ptr %1034, align 1, !tbaa !9
  %1036 = zext i8 %1035 to i64
  %1037 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1036
  %1038 = load i8, ptr %1037, align 1, !tbaa !9
  %1039 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1040 = getelementptr inbounds i8, ptr %1039, i64 9
  store i8 %1038, ptr %1040, align 1, !tbaa !9
  %1041 = load ptr, ptr %6, align 8, !tbaa !5
  %1042 = getelementptr inbounds i8, ptr %1041, i64 10
  %1043 = load i8, ptr %1042, align 1, !tbaa !9
  %1044 = zext i8 %1043 to i64
  %1045 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1044
  %1046 = load i8, ptr %1045, align 1, !tbaa !9
  %1047 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1048 = getelementptr inbounds i8, ptr %1047, i64 10
  store i8 %1046, ptr %1048, align 1, !tbaa !9
  %1049 = load ptr, ptr %6, align 8, !tbaa !5
  %1050 = getelementptr inbounds i8, ptr %1049, i64 11
  %1051 = load i8, ptr %1050, align 1, !tbaa !9
  %1052 = zext i8 %1051 to i64
  %1053 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1052
  %1054 = load i8, ptr %1053, align 1, !tbaa !9
  %1055 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1056 = getelementptr inbounds i8, ptr %1055, i64 11
  store i8 %1054, ptr %1056, align 1, !tbaa !9
  %1057 = load ptr, ptr %6, align 8, !tbaa !5
  %1058 = getelementptr inbounds i8, ptr %1057, i64 12
  %1059 = load i8, ptr %1058, align 1, !tbaa !9
  %1060 = zext i8 %1059 to i64
  %1061 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1060
  %1062 = load i8, ptr %1061, align 1, !tbaa !9
  %1063 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1064 = getelementptr inbounds i8, ptr %1063, i64 12
  store i8 %1062, ptr %1064, align 1, !tbaa !9
  %1065 = load ptr, ptr %6, align 8, !tbaa !5
  %1066 = getelementptr inbounds i8, ptr %1065, i64 13
  %1067 = load i8, ptr %1066, align 1, !tbaa !9
  %1068 = zext i8 %1067 to i64
  %1069 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1068
  %1070 = load i8, ptr %1069, align 1, !tbaa !9
  %1071 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1072 = getelementptr inbounds i8, ptr %1071, i64 13
  store i8 %1070, ptr %1072, align 1, !tbaa !9
  %1073 = load ptr, ptr %6, align 8, !tbaa !5
  %1074 = getelementptr inbounds i8, ptr %1073, i64 14
  %1075 = load i8, ptr %1074, align 1, !tbaa !9
  %1076 = zext i8 %1075 to i64
  %1077 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1076
  %1078 = load i8, ptr %1077, align 1, !tbaa !9
  %1079 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1080 = getelementptr inbounds i8, ptr %1079, i64 14
  store i8 %1078, ptr %1080, align 1, !tbaa !9
  %1081 = load ptr, ptr %6, align 8, !tbaa !5
  %1082 = getelementptr inbounds i8, ptr %1081, i64 15
  %1083 = load i8, ptr %1082, align 1, !tbaa !9
  %1084 = zext i8 %1083 to i64
  %1085 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1084
  %1086 = load i8, ptr %1085, align 1, !tbaa !9
  %1087 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1088 = getelementptr inbounds i8, ptr %1087, i64 15
  store i8 %1086, ptr %1088, align 1, !tbaa !9
  %1089 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1090 = getelementptr inbounds i8, ptr %1089, i64 1
  %1091 = load i8, ptr %1090, align 1, !tbaa !9
  store i8 %1091, ptr %8, align 1, !tbaa !9
  %1092 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1093 = getelementptr inbounds i8, ptr %1092, i64 5
  %1094 = load i8, ptr %1093, align 1, !tbaa !9
  %1095 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1096 = getelementptr inbounds i8, ptr %1095, i64 1
  store i8 %1094, ptr %1096, align 1, !tbaa !9
  %1097 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1098 = getelementptr inbounds i8, ptr %1097, i64 9
  %1099 = load i8, ptr %1098, align 1, !tbaa !9
  %1100 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1101 = getelementptr inbounds i8, ptr %1100, i64 5
  store i8 %1099, ptr %1101, align 1, !tbaa !9
  %1102 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1103 = getelementptr inbounds i8, ptr %1102, i64 13
  %1104 = load i8, ptr %1103, align 1, !tbaa !9
  %1105 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1106 = getelementptr inbounds i8, ptr %1105, i64 9
  store i8 %1104, ptr %1106, align 1, !tbaa !9
  %1107 = load i8, ptr %8, align 1, !tbaa !9
  %1108 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1109 = getelementptr inbounds i8, ptr %1108, i64 13
  store i8 %1107, ptr %1109, align 1, !tbaa !9
  %1110 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1111 = getelementptr inbounds i8, ptr %1110, i64 2
  %1112 = load i8, ptr %1111, align 1, !tbaa !9
  store i8 %1112, ptr %8, align 1, !tbaa !9
  %1113 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1114 = getelementptr inbounds i8, ptr %1113, i64 10
  %1115 = load i8, ptr %1114, align 1, !tbaa !9
  %1116 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1117 = getelementptr inbounds i8, ptr %1116, i64 2
  store i8 %1115, ptr %1117, align 1, !tbaa !9
  %1118 = load i8, ptr %8, align 1, !tbaa !9
  %1119 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1120 = getelementptr inbounds i8, ptr %1119, i64 10
  store i8 %1118, ptr %1120, align 1, !tbaa !9
  %1121 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1122 = getelementptr inbounds i8, ptr %1121, i64 6
  %1123 = load i8, ptr %1122, align 1, !tbaa !9
  store i8 %1123, ptr %8, align 1, !tbaa !9
  %1124 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1125 = getelementptr inbounds i8, ptr %1124, i64 14
  %1126 = load i8, ptr %1125, align 1, !tbaa !9
  %1127 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1128 = getelementptr inbounds i8, ptr %1127, i64 6
  store i8 %1126, ptr %1128, align 1, !tbaa !9
  %1129 = load i8, ptr %8, align 1, !tbaa !9
  %1130 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1131 = getelementptr inbounds i8, ptr %1130, i64 14
  store i8 %1129, ptr %1131, align 1, !tbaa !9
  %1132 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1133 = getelementptr inbounds i8, ptr %1132, i64 15
  %1134 = load i8, ptr %1133, align 1, !tbaa !9
  store i8 %1134, ptr %8, align 1, !tbaa !9
  %1135 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1136 = getelementptr inbounds i8, ptr %1135, i64 11
  %1137 = load i8, ptr %1136, align 1, !tbaa !9
  %1138 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1139 = getelementptr inbounds i8, ptr %1138, i64 15
  store i8 %1137, ptr %1139, align 1, !tbaa !9
  %1140 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1141 = getelementptr inbounds i8, ptr %1140, i64 7
  %1142 = load i8, ptr %1141, align 1, !tbaa !9
  %1143 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1144 = getelementptr inbounds i8, ptr %1143, i64 11
  store i8 %1142, ptr %1144, align 1, !tbaa !9
  %1145 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1146 = getelementptr inbounds i8, ptr %1145, i64 3
  %1147 = load i8, ptr %1146, align 1, !tbaa !9
  %1148 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1149 = getelementptr inbounds i8, ptr %1148, i64 7
  store i8 %1147, ptr %1149, align 1, !tbaa !9
  %1150 = load i8, ptr %8, align 1, !tbaa !9
  %1151 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1152 = getelementptr inbounds i8, ptr %1151, i64 3
  store i8 %1150, ptr %1152, align 1, !tbaa !9
  %1153 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1154 = load i8, ptr %1153, align 16, !tbaa !9
  %1155 = zext i8 %1154 to i32
  %1156 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %1157 = load i8, ptr %1156, align 1, !tbaa !9
  %1158 = zext i8 %1157 to i32
  %1159 = xor i32 %1155, %1158
  %1160 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %1161 = load i8, ptr %1160, align 2, !tbaa !9
  %1162 = zext i8 %1161 to i32
  %1163 = xor i32 %1159, %1162
  %1164 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %1165 = load i8, ptr %1164, align 1, !tbaa !9
  %1166 = zext i8 %1165 to i32
  %1167 = xor i32 %1163, %1166
  %1168 = trunc i32 %1167 to i8
  store i8 %1168, ptr %8, align 1, !tbaa !9
  %1169 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1170 = load i8, ptr %1169, align 16, !tbaa !9
  %1171 = zext i8 %1170 to i32
  %1172 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %1173 = load i8, ptr %1172, align 1, !tbaa !9
  %1174 = zext i8 %1173 to i32
  %1175 = xor i32 %1171, %1174
  %1176 = trunc i32 %1175 to i8
  %1177 = call zeroext i8 @mul2(i8 noundef zeroext %1176)
  %1178 = zext i8 %1177 to i32
  %1179 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1180 = load i8, ptr %1179, align 16, !tbaa !9
  %1181 = zext i8 %1180 to i32
  %1182 = xor i32 %1178, %1181
  %1183 = load i8, ptr %8, align 1, !tbaa !9
  %1184 = zext i8 %1183 to i32
  %1185 = xor i32 %1182, %1184
  %1186 = trunc i32 %1185 to i8
  %1187 = load ptr, ptr %6, align 8, !tbaa !5
  %1188 = getelementptr inbounds i8, ptr %1187, i64 0
  store i8 %1186, ptr %1188, align 1, !tbaa !9
  %1189 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %1190 = load i8, ptr %1189, align 1, !tbaa !9
  %1191 = zext i8 %1190 to i32
  %1192 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %1193 = load i8, ptr %1192, align 2, !tbaa !9
  %1194 = zext i8 %1193 to i32
  %1195 = xor i32 %1191, %1194
  %1196 = trunc i32 %1195 to i8
  %1197 = call zeroext i8 @mul2(i8 noundef zeroext %1196)
  %1198 = zext i8 %1197 to i32
  %1199 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %1200 = load i8, ptr %1199, align 1, !tbaa !9
  %1201 = zext i8 %1200 to i32
  %1202 = xor i32 %1198, %1201
  %1203 = load i8, ptr %8, align 1, !tbaa !9
  %1204 = zext i8 %1203 to i32
  %1205 = xor i32 %1202, %1204
  %1206 = trunc i32 %1205 to i8
  %1207 = load ptr, ptr %6, align 8, !tbaa !5
  %1208 = getelementptr inbounds i8, ptr %1207, i64 1
  store i8 %1206, ptr %1208, align 1, !tbaa !9
  %1209 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %1210 = load i8, ptr %1209, align 2, !tbaa !9
  %1211 = zext i8 %1210 to i32
  %1212 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %1213 = load i8, ptr %1212, align 1, !tbaa !9
  %1214 = zext i8 %1213 to i32
  %1215 = xor i32 %1211, %1214
  %1216 = trunc i32 %1215 to i8
  %1217 = call zeroext i8 @mul2(i8 noundef zeroext %1216)
  %1218 = zext i8 %1217 to i32
  %1219 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %1220 = load i8, ptr %1219, align 2, !tbaa !9
  %1221 = zext i8 %1220 to i32
  %1222 = xor i32 %1218, %1221
  %1223 = load i8, ptr %8, align 1, !tbaa !9
  %1224 = zext i8 %1223 to i32
  %1225 = xor i32 %1222, %1224
  %1226 = trunc i32 %1225 to i8
  %1227 = load ptr, ptr %6, align 8, !tbaa !5
  %1228 = getelementptr inbounds i8, ptr %1227, i64 2
  store i8 %1226, ptr %1228, align 1, !tbaa !9
  %1229 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %1230 = load i8, ptr %1229, align 1, !tbaa !9
  %1231 = zext i8 %1230 to i32
  %1232 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1233 = load i8, ptr %1232, align 16, !tbaa !9
  %1234 = zext i8 %1233 to i32
  %1235 = xor i32 %1231, %1234
  %1236 = trunc i32 %1235 to i8
  %1237 = call zeroext i8 @mul2(i8 noundef zeroext %1236)
  %1238 = zext i8 %1237 to i32
  %1239 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %1240 = load i8, ptr %1239, align 1, !tbaa !9
  %1241 = zext i8 %1240 to i32
  %1242 = xor i32 %1238, %1241
  %1243 = load i8, ptr %8, align 1, !tbaa !9
  %1244 = zext i8 %1243 to i32
  %1245 = xor i32 %1242, %1244
  %1246 = trunc i32 %1245 to i8
  %1247 = load ptr, ptr %6, align 8, !tbaa !5
  %1248 = getelementptr inbounds i8, ptr %1247, i64 3
  store i8 %1246, ptr %1248, align 1, !tbaa !9
  %1249 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %1250 = load i8, ptr %1249, align 4, !tbaa !9
  %1251 = zext i8 %1250 to i32
  %1252 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %1253 = load i8, ptr %1252, align 1, !tbaa !9
  %1254 = zext i8 %1253 to i32
  %1255 = xor i32 %1251, %1254
  %1256 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %1257 = load i8, ptr %1256, align 2, !tbaa !9
  %1258 = zext i8 %1257 to i32
  %1259 = xor i32 %1255, %1258
  %1260 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %1261 = load i8, ptr %1260, align 1, !tbaa !9
  %1262 = zext i8 %1261 to i32
  %1263 = xor i32 %1259, %1262
  %1264 = trunc i32 %1263 to i8
  store i8 %1264, ptr %8, align 1, !tbaa !9
  %1265 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %1266 = load i8, ptr %1265, align 4, !tbaa !9
  %1267 = zext i8 %1266 to i32
  %1268 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %1269 = load i8, ptr %1268, align 1, !tbaa !9
  %1270 = zext i8 %1269 to i32
  %1271 = xor i32 %1267, %1270
  %1272 = trunc i32 %1271 to i8
  %1273 = call zeroext i8 @mul2(i8 noundef zeroext %1272)
  %1274 = zext i8 %1273 to i32
  %1275 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %1276 = load i8, ptr %1275, align 4, !tbaa !9
  %1277 = zext i8 %1276 to i32
  %1278 = xor i32 %1274, %1277
  %1279 = load i8, ptr %8, align 1, !tbaa !9
  %1280 = zext i8 %1279 to i32
  %1281 = xor i32 %1278, %1280
  %1282 = trunc i32 %1281 to i8
  %1283 = load ptr, ptr %6, align 8, !tbaa !5
  %1284 = getelementptr inbounds i8, ptr %1283, i64 4
  store i8 %1282, ptr %1284, align 1, !tbaa !9
  %1285 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %1286 = load i8, ptr %1285, align 1, !tbaa !9
  %1287 = zext i8 %1286 to i32
  %1288 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %1289 = load i8, ptr %1288, align 2, !tbaa !9
  %1290 = zext i8 %1289 to i32
  %1291 = xor i32 %1287, %1290
  %1292 = trunc i32 %1291 to i8
  %1293 = call zeroext i8 @mul2(i8 noundef zeroext %1292)
  %1294 = zext i8 %1293 to i32
  %1295 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %1296 = load i8, ptr %1295, align 1, !tbaa !9
  %1297 = zext i8 %1296 to i32
  %1298 = xor i32 %1294, %1297
  %1299 = load i8, ptr %8, align 1, !tbaa !9
  %1300 = zext i8 %1299 to i32
  %1301 = xor i32 %1298, %1300
  %1302 = trunc i32 %1301 to i8
  %1303 = load ptr, ptr %6, align 8, !tbaa !5
  %1304 = getelementptr inbounds i8, ptr %1303, i64 5
  store i8 %1302, ptr %1304, align 1, !tbaa !9
  %1305 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %1306 = load i8, ptr %1305, align 2, !tbaa !9
  %1307 = zext i8 %1306 to i32
  %1308 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %1309 = load i8, ptr %1308, align 1, !tbaa !9
  %1310 = zext i8 %1309 to i32
  %1311 = xor i32 %1307, %1310
  %1312 = trunc i32 %1311 to i8
  %1313 = call zeroext i8 @mul2(i8 noundef zeroext %1312)
  %1314 = zext i8 %1313 to i32
  %1315 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %1316 = load i8, ptr %1315, align 2, !tbaa !9
  %1317 = zext i8 %1316 to i32
  %1318 = xor i32 %1314, %1317
  %1319 = load i8, ptr %8, align 1, !tbaa !9
  %1320 = zext i8 %1319 to i32
  %1321 = xor i32 %1318, %1320
  %1322 = trunc i32 %1321 to i8
  %1323 = load ptr, ptr %6, align 8, !tbaa !5
  %1324 = getelementptr inbounds i8, ptr %1323, i64 6
  store i8 %1322, ptr %1324, align 1, !tbaa !9
  %1325 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %1326 = load i8, ptr %1325, align 1, !tbaa !9
  %1327 = zext i8 %1326 to i32
  %1328 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %1329 = load i8, ptr %1328, align 4, !tbaa !9
  %1330 = zext i8 %1329 to i32
  %1331 = xor i32 %1327, %1330
  %1332 = trunc i32 %1331 to i8
  %1333 = call zeroext i8 @mul2(i8 noundef zeroext %1332)
  %1334 = zext i8 %1333 to i32
  %1335 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %1336 = load i8, ptr %1335, align 1, !tbaa !9
  %1337 = zext i8 %1336 to i32
  %1338 = xor i32 %1334, %1337
  %1339 = load i8, ptr %8, align 1, !tbaa !9
  %1340 = zext i8 %1339 to i32
  %1341 = xor i32 %1338, %1340
  %1342 = trunc i32 %1341 to i8
  %1343 = load ptr, ptr %6, align 8, !tbaa !5
  %1344 = getelementptr inbounds i8, ptr %1343, i64 7
  store i8 %1342, ptr %1344, align 1, !tbaa !9
  %1345 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %1346 = load i8, ptr %1345, align 8, !tbaa !9
  %1347 = zext i8 %1346 to i32
  %1348 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %1349 = load i8, ptr %1348, align 1, !tbaa !9
  %1350 = zext i8 %1349 to i32
  %1351 = xor i32 %1347, %1350
  %1352 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %1353 = load i8, ptr %1352, align 2, !tbaa !9
  %1354 = zext i8 %1353 to i32
  %1355 = xor i32 %1351, %1354
  %1356 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %1357 = load i8, ptr %1356, align 1, !tbaa !9
  %1358 = zext i8 %1357 to i32
  %1359 = xor i32 %1355, %1358
  %1360 = trunc i32 %1359 to i8
  store i8 %1360, ptr %8, align 1, !tbaa !9
  %1361 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %1362 = load i8, ptr %1361, align 8, !tbaa !9
  %1363 = zext i8 %1362 to i32
  %1364 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %1365 = load i8, ptr %1364, align 1, !tbaa !9
  %1366 = zext i8 %1365 to i32
  %1367 = xor i32 %1363, %1366
  %1368 = trunc i32 %1367 to i8
  %1369 = call zeroext i8 @mul2(i8 noundef zeroext %1368)
  %1370 = zext i8 %1369 to i32
  %1371 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %1372 = load i8, ptr %1371, align 8, !tbaa !9
  %1373 = zext i8 %1372 to i32
  %1374 = xor i32 %1370, %1373
  %1375 = load i8, ptr %8, align 1, !tbaa !9
  %1376 = zext i8 %1375 to i32
  %1377 = xor i32 %1374, %1376
  %1378 = trunc i32 %1377 to i8
  %1379 = load ptr, ptr %6, align 8, !tbaa !5
  %1380 = getelementptr inbounds i8, ptr %1379, i64 8
  store i8 %1378, ptr %1380, align 1, !tbaa !9
  %1381 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %1382 = load i8, ptr %1381, align 1, !tbaa !9
  %1383 = zext i8 %1382 to i32
  %1384 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %1385 = load i8, ptr %1384, align 2, !tbaa !9
  %1386 = zext i8 %1385 to i32
  %1387 = xor i32 %1383, %1386
  %1388 = trunc i32 %1387 to i8
  %1389 = call zeroext i8 @mul2(i8 noundef zeroext %1388)
  %1390 = zext i8 %1389 to i32
  %1391 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %1392 = load i8, ptr %1391, align 1, !tbaa !9
  %1393 = zext i8 %1392 to i32
  %1394 = xor i32 %1390, %1393
  %1395 = load i8, ptr %8, align 1, !tbaa !9
  %1396 = zext i8 %1395 to i32
  %1397 = xor i32 %1394, %1396
  %1398 = trunc i32 %1397 to i8
  %1399 = load ptr, ptr %6, align 8, !tbaa !5
  %1400 = getelementptr inbounds i8, ptr %1399, i64 9
  store i8 %1398, ptr %1400, align 1, !tbaa !9
  %1401 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %1402 = load i8, ptr %1401, align 2, !tbaa !9
  %1403 = zext i8 %1402 to i32
  %1404 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %1405 = load i8, ptr %1404, align 1, !tbaa !9
  %1406 = zext i8 %1405 to i32
  %1407 = xor i32 %1403, %1406
  %1408 = trunc i32 %1407 to i8
  %1409 = call zeroext i8 @mul2(i8 noundef zeroext %1408)
  %1410 = zext i8 %1409 to i32
  %1411 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %1412 = load i8, ptr %1411, align 2, !tbaa !9
  %1413 = zext i8 %1412 to i32
  %1414 = xor i32 %1410, %1413
  %1415 = load i8, ptr %8, align 1, !tbaa !9
  %1416 = zext i8 %1415 to i32
  %1417 = xor i32 %1414, %1416
  %1418 = trunc i32 %1417 to i8
  %1419 = load ptr, ptr %6, align 8, !tbaa !5
  %1420 = getelementptr inbounds i8, ptr %1419, i64 10
  store i8 %1418, ptr %1420, align 1, !tbaa !9
  %1421 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %1422 = load i8, ptr %1421, align 1, !tbaa !9
  %1423 = zext i8 %1422 to i32
  %1424 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %1425 = load i8, ptr %1424, align 8, !tbaa !9
  %1426 = zext i8 %1425 to i32
  %1427 = xor i32 %1423, %1426
  %1428 = trunc i32 %1427 to i8
  %1429 = call zeroext i8 @mul2(i8 noundef zeroext %1428)
  %1430 = zext i8 %1429 to i32
  %1431 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %1432 = load i8, ptr %1431, align 1, !tbaa !9
  %1433 = zext i8 %1432 to i32
  %1434 = xor i32 %1430, %1433
  %1435 = load i8, ptr %8, align 1, !tbaa !9
  %1436 = zext i8 %1435 to i32
  %1437 = xor i32 %1434, %1436
  %1438 = trunc i32 %1437 to i8
  %1439 = load ptr, ptr %6, align 8, !tbaa !5
  %1440 = getelementptr inbounds i8, ptr %1439, i64 11
  store i8 %1438, ptr %1440, align 1, !tbaa !9
  %1441 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %1442 = load i8, ptr %1441, align 4, !tbaa !9
  %1443 = zext i8 %1442 to i32
  %1444 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %1445 = load i8, ptr %1444, align 1, !tbaa !9
  %1446 = zext i8 %1445 to i32
  %1447 = xor i32 %1443, %1446
  %1448 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %1449 = load i8, ptr %1448, align 2, !tbaa !9
  %1450 = zext i8 %1449 to i32
  %1451 = xor i32 %1447, %1450
  %1452 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %1453 = load i8, ptr %1452, align 1, !tbaa !9
  %1454 = zext i8 %1453 to i32
  %1455 = xor i32 %1451, %1454
  %1456 = trunc i32 %1455 to i8
  store i8 %1456, ptr %8, align 1, !tbaa !9
  %1457 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %1458 = load i8, ptr %1457, align 4, !tbaa !9
  %1459 = zext i8 %1458 to i32
  %1460 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %1461 = load i8, ptr %1460, align 1, !tbaa !9
  %1462 = zext i8 %1461 to i32
  %1463 = xor i32 %1459, %1462
  %1464 = trunc i32 %1463 to i8
  %1465 = call zeroext i8 @mul2(i8 noundef zeroext %1464)
  %1466 = zext i8 %1465 to i32
  %1467 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %1468 = load i8, ptr %1467, align 4, !tbaa !9
  %1469 = zext i8 %1468 to i32
  %1470 = xor i32 %1466, %1469
  %1471 = load i8, ptr %8, align 1, !tbaa !9
  %1472 = zext i8 %1471 to i32
  %1473 = xor i32 %1470, %1472
  %1474 = trunc i32 %1473 to i8
  %1475 = load ptr, ptr %6, align 8, !tbaa !5
  %1476 = getelementptr inbounds i8, ptr %1475, i64 12
  store i8 %1474, ptr %1476, align 1, !tbaa !9
  %1477 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %1478 = load i8, ptr %1477, align 1, !tbaa !9
  %1479 = zext i8 %1478 to i32
  %1480 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %1481 = load i8, ptr %1480, align 2, !tbaa !9
  %1482 = zext i8 %1481 to i32
  %1483 = xor i32 %1479, %1482
  %1484 = trunc i32 %1483 to i8
  %1485 = call zeroext i8 @mul2(i8 noundef zeroext %1484)
  %1486 = zext i8 %1485 to i32
  %1487 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %1488 = load i8, ptr %1487, align 1, !tbaa !9
  %1489 = zext i8 %1488 to i32
  %1490 = xor i32 %1486, %1489
  %1491 = load i8, ptr %8, align 1, !tbaa !9
  %1492 = zext i8 %1491 to i32
  %1493 = xor i32 %1490, %1492
  %1494 = trunc i32 %1493 to i8
  %1495 = load ptr, ptr %6, align 8, !tbaa !5
  %1496 = getelementptr inbounds i8, ptr %1495, i64 13
  store i8 %1494, ptr %1496, align 1, !tbaa !9
  %1497 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %1498 = load i8, ptr %1497, align 2, !tbaa !9
  %1499 = zext i8 %1498 to i32
  %1500 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %1501 = load i8, ptr %1500, align 1, !tbaa !9
  %1502 = zext i8 %1501 to i32
  %1503 = xor i32 %1499, %1502
  %1504 = trunc i32 %1503 to i8
  %1505 = call zeroext i8 @mul2(i8 noundef zeroext %1504)
  %1506 = zext i8 %1505 to i32
  %1507 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %1508 = load i8, ptr %1507, align 2, !tbaa !9
  %1509 = zext i8 %1508 to i32
  %1510 = xor i32 %1506, %1509
  %1511 = load i8, ptr %8, align 1, !tbaa !9
  %1512 = zext i8 %1511 to i32
  %1513 = xor i32 %1510, %1512
  %1514 = trunc i32 %1513 to i8
  %1515 = load ptr, ptr %6, align 8, !tbaa !5
  %1516 = getelementptr inbounds i8, ptr %1515, i64 14
  store i8 %1514, ptr %1516, align 1, !tbaa !9
  %1517 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %1518 = load i8, ptr %1517, align 1, !tbaa !9
  %1519 = zext i8 %1518 to i32
  %1520 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %1521 = load i8, ptr %1520, align 4, !tbaa !9
  %1522 = zext i8 %1521 to i32
  %1523 = xor i32 %1519, %1522
  %1524 = trunc i32 %1523 to i8
  %1525 = call zeroext i8 @mul2(i8 noundef zeroext %1524)
  %1526 = zext i8 %1525 to i32
  %1527 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %1528 = load i8, ptr %1527, align 1, !tbaa !9
  %1529 = zext i8 %1528 to i32
  %1530 = xor i32 %1526, %1529
  %1531 = load i8, ptr %8, align 1, !tbaa !9
  %1532 = zext i8 %1531 to i32
  %1533 = xor i32 %1530, %1532
  %1534 = trunc i32 %1533 to i8
  %1535 = load ptr, ptr %6, align 8, !tbaa !5
  %1536 = getelementptr inbounds i8, ptr %1535, i64 15
  store i8 %1534, ptr %1536, align 1, !tbaa !9
  %1537 = load ptr, ptr %6, align 8, !tbaa !5
  %1538 = load i8, ptr %1537, align 1, !tbaa !9
  %1539 = zext i8 %1538 to i32
  %1540 = load ptr, ptr %4, align 8, !tbaa !5
  %1541 = getelementptr inbounds i8, ptr %1540, i32 1
  store ptr %1541, ptr %4, align 8, !tbaa !5
  %1542 = load i8, ptr %1540, align 1, !tbaa !9
  %1543 = zext i8 %1542 to i32
  %1544 = xor i32 %1539, %1543
  %1545 = trunc i32 %1544 to i8
  %1546 = load ptr, ptr %6, align 8, !tbaa !5
  store i8 %1545, ptr %1546, align 1, !tbaa !9
  %1547 = load ptr, ptr %6, align 8, !tbaa !5
  %1548 = getelementptr inbounds i8, ptr %1547, i64 1
  %1549 = load i8, ptr %1548, align 1, !tbaa !9
  %1550 = zext i8 %1549 to i32
  %1551 = load ptr, ptr %4, align 8, !tbaa !5
  %1552 = getelementptr inbounds i8, ptr %1551, i32 1
  store ptr %1552, ptr %4, align 8, !tbaa !5
  %1553 = load i8, ptr %1551, align 1, !tbaa !9
  %1554 = zext i8 %1553 to i32
  %1555 = xor i32 %1550, %1554
  %1556 = trunc i32 %1555 to i8
  %1557 = load ptr, ptr %6, align 8, !tbaa !5
  %1558 = getelementptr inbounds i8, ptr %1557, i64 1
  store i8 %1556, ptr %1558, align 1, !tbaa !9
  %1559 = load ptr, ptr %6, align 8, !tbaa !5
  %1560 = getelementptr inbounds i8, ptr %1559, i64 2
  %1561 = load i8, ptr %1560, align 1, !tbaa !9
  %1562 = zext i8 %1561 to i32
  %1563 = load ptr, ptr %4, align 8, !tbaa !5
  %1564 = getelementptr inbounds i8, ptr %1563, i32 1
  store ptr %1564, ptr %4, align 8, !tbaa !5
  %1565 = load i8, ptr %1563, align 1, !tbaa !9
  %1566 = zext i8 %1565 to i32
  %1567 = xor i32 %1562, %1566
  %1568 = trunc i32 %1567 to i8
  %1569 = load ptr, ptr %6, align 8, !tbaa !5
  %1570 = getelementptr inbounds i8, ptr %1569, i64 2
  store i8 %1568, ptr %1570, align 1, !tbaa !9
  %1571 = load ptr, ptr %6, align 8, !tbaa !5
  %1572 = getelementptr inbounds i8, ptr %1571, i64 3
  %1573 = load i8, ptr %1572, align 1, !tbaa !9
  %1574 = zext i8 %1573 to i32
  %1575 = load ptr, ptr %4, align 8, !tbaa !5
  %1576 = getelementptr inbounds i8, ptr %1575, i32 1
  store ptr %1576, ptr %4, align 8, !tbaa !5
  %1577 = load i8, ptr %1575, align 1, !tbaa !9
  %1578 = zext i8 %1577 to i32
  %1579 = xor i32 %1574, %1578
  %1580 = trunc i32 %1579 to i8
  %1581 = load ptr, ptr %6, align 8, !tbaa !5
  %1582 = getelementptr inbounds i8, ptr %1581, i64 3
  store i8 %1580, ptr %1582, align 1, !tbaa !9
  %1583 = load ptr, ptr %6, align 8, !tbaa !5
  %1584 = getelementptr inbounds i8, ptr %1583, i64 4
  %1585 = load i8, ptr %1584, align 1, !tbaa !9
  %1586 = zext i8 %1585 to i32
  %1587 = load ptr, ptr %4, align 8, !tbaa !5
  %1588 = getelementptr inbounds i8, ptr %1587, i32 1
  store ptr %1588, ptr %4, align 8, !tbaa !5
  %1589 = load i8, ptr %1587, align 1, !tbaa !9
  %1590 = zext i8 %1589 to i32
  %1591 = xor i32 %1586, %1590
  %1592 = trunc i32 %1591 to i8
  %1593 = load ptr, ptr %6, align 8, !tbaa !5
  %1594 = getelementptr inbounds i8, ptr %1593, i64 4
  store i8 %1592, ptr %1594, align 1, !tbaa !9
  %1595 = load ptr, ptr %6, align 8, !tbaa !5
  %1596 = getelementptr inbounds i8, ptr %1595, i64 5
  %1597 = load i8, ptr %1596, align 1, !tbaa !9
  %1598 = zext i8 %1597 to i32
  %1599 = load ptr, ptr %4, align 8, !tbaa !5
  %1600 = getelementptr inbounds i8, ptr %1599, i32 1
  store ptr %1600, ptr %4, align 8, !tbaa !5
  %1601 = load i8, ptr %1599, align 1, !tbaa !9
  %1602 = zext i8 %1601 to i32
  %1603 = xor i32 %1598, %1602
  %1604 = trunc i32 %1603 to i8
  %1605 = load ptr, ptr %6, align 8, !tbaa !5
  %1606 = getelementptr inbounds i8, ptr %1605, i64 5
  store i8 %1604, ptr %1606, align 1, !tbaa !9
  %1607 = load ptr, ptr %6, align 8, !tbaa !5
  %1608 = getelementptr inbounds i8, ptr %1607, i64 6
  %1609 = load i8, ptr %1608, align 1, !tbaa !9
  %1610 = zext i8 %1609 to i32
  %1611 = load ptr, ptr %4, align 8, !tbaa !5
  %1612 = getelementptr inbounds i8, ptr %1611, i32 1
  store ptr %1612, ptr %4, align 8, !tbaa !5
  %1613 = load i8, ptr %1611, align 1, !tbaa !9
  %1614 = zext i8 %1613 to i32
  %1615 = xor i32 %1610, %1614
  %1616 = trunc i32 %1615 to i8
  %1617 = load ptr, ptr %6, align 8, !tbaa !5
  %1618 = getelementptr inbounds i8, ptr %1617, i64 6
  store i8 %1616, ptr %1618, align 1, !tbaa !9
  %1619 = load ptr, ptr %6, align 8, !tbaa !5
  %1620 = getelementptr inbounds i8, ptr %1619, i64 7
  %1621 = load i8, ptr %1620, align 1, !tbaa !9
  %1622 = zext i8 %1621 to i32
  %1623 = load ptr, ptr %4, align 8, !tbaa !5
  %1624 = getelementptr inbounds i8, ptr %1623, i32 1
  store ptr %1624, ptr %4, align 8, !tbaa !5
  %1625 = load i8, ptr %1623, align 1, !tbaa !9
  %1626 = zext i8 %1625 to i32
  %1627 = xor i32 %1622, %1626
  %1628 = trunc i32 %1627 to i8
  %1629 = load ptr, ptr %6, align 8, !tbaa !5
  %1630 = getelementptr inbounds i8, ptr %1629, i64 7
  store i8 %1628, ptr %1630, align 1, !tbaa !9
  %1631 = load ptr, ptr %6, align 8, !tbaa !5
  %1632 = getelementptr inbounds i8, ptr %1631, i64 8
  %1633 = load i8, ptr %1632, align 1, !tbaa !9
  %1634 = zext i8 %1633 to i32
  %1635 = load ptr, ptr %4, align 8, !tbaa !5
  %1636 = getelementptr inbounds i8, ptr %1635, i32 1
  store ptr %1636, ptr %4, align 8, !tbaa !5
  %1637 = load i8, ptr %1635, align 1, !tbaa !9
  %1638 = zext i8 %1637 to i32
  %1639 = xor i32 %1634, %1638
  %1640 = trunc i32 %1639 to i8
  %1641 = load ptr, ptr %6, align 8, !tbaa !5
  %1642 = getelementptr inbounds i8, ptr %1641, i64 8
  store i8 %1640, ptr %1642, align 1, !tbaa !9
  %1643 = load ptr, ptr %6, align 8, !tbaa !5
  %1644 = getelementptr inbounds i8, ptr %1643, i64 9
  %1645 = load i8, ptr %1644, align 1, !tbaa !9
  %1646 = zext i8 %1645 to i32
  %1647 = load ptr, ptr %4, align 8, !tbaa !5
  %1648 = getelementptr inbounds i8, ptr %1647, i32 1
  store ptr %1648, ptr %4, align 8, !tbaa !5
  %1649 = load i8, ptr %1647, align 1, !tbaa !9
  %1650 = zext i8 %1649 to i32
  %1651 = xor i32 %1646, %1650
  %1652 = trunc i32 %1651 to i8
  %1653 = load ptr, ptr %6, align 8, !tbaa !5
  %1654 = getelementptr inbounds i8, ptr %1653, i64 9
  store i8 %1652, ptr %1654, align 1, !tbaa !9
  %1655 = load ptr, ptr %6, align 8, !tbaa !5
  %1656 = getelementptr inbounds i8, ptr %1655, i64 10
  %1657 = load i8, ptr %1656, align 1, !tbaa !9
  %1658 = zext i8 %1657 to i32
  %1659 = load ptr, ptr %4, align 8, !tbaa !5
  %1660 = getelementptr inbounds i8, ptr %1659, i32 1
  store ptr %1660, ptr %4, align 8, !tbaa !5
  %1661 = load i8, ptr %1659, align 1, !tbaa !9
  %1662 = zext i8 %1661 to i32
  %1663 = xor i32 %1658, %1662
  %1664 = trunc i32 %1663 to i8
  %1665 = load ptr, ptr %6, align 8, !tbaa !5
  %1666 = getelementptr inbounds i8, ptr %1665, i64 10
  store i8 %1664, ptr %1666, align 1, !tbaa !9
  %1667 = load ptr, ptr %6, align 8, !tbaa !5
  %1668 = getelementptr inbounds i8, ptr %1667, i64 11
  %1669 = load i8, ptr %1668, align 1, !tbaa !9
  %1670 = zext i8 %1669 to i32
  %1671 = load ptr, ptr %4, align 8, !tbaa !5
  %1672 = getelementptr inbounds i8, ptr %1671, i32 1
  store ptr %1672, ptr %4, align 8, !tbaa !5
  %1673 = load i8, ptr %1671, align 1, !tbaa !9
  %1674 = zext i8 %1673 to i32
  %1675 = xor i32 %1670, %1674
  %1676 = trunc i32 %1675 to i8
  %1677 = load ptr, ptr %6, align 8, !tbaa !5
  %1678 = getelementptr inbounds i8, ptr %1677, i64 11
  store i8 %1676, ptr %1678, align 1, !tbaa !9
  %1679 = load ptr, ptr %6, align 8, !tbaa !5
  %1680 = getelementptr inbounds i8, ptr %1679, i64 12
  %1681 = load i8, ptr %1680, align 1, !tbaa !9
  %1682 = zext i8 %1681 to i32
  %1683 = load ptr, ptr %4, align 8, !tbaa !5
  %1684 = getelementptr inbounds i8, ptr %1683, i32 1
  store ptr %1684, ptr %4, align 8, !tbaa !5
  %1685 = load i8, ptr %1683, align 1, !tbaa !9
  %1686 = zext i8 %1685 to i32
  %1687 = xor i32 %1682, %1686
  %1688 = trunc i32 %1687 to i8
  %1689 = load ptr, ptr %6, align 8, !tbaa !5
  %1690 = getelementptr inbounds i8, ptr %1689, i64 12
  store i8 %1688, ptr %1690, align 1, !tbaa !9
  %1691 = load ptr, ptr %6, align 8, !tbaa !5
  %1692 = getelementptr inbounds i8, ptr %1691, i64 13
  %1693 = load i8, ptr %1692, align 1, !tbaa !9
  %1694 = zext i8 %1693 to i32
  %1695 = load ptr, ptr %4, align 8, !tbaa !5
  %1696 = getelementptr inbounds i8, ptr %1695, i32 1
  store ptr %1696, ptr %4, align 8, !tbaa !5
  %1697 = load i8, ptr %1695, align 1, !tbaa !9
  %1698 = zext i8 %1697 to i32
  %1699 = xor i32 %1694, %1698
  %1700 = trunc i32 %1699 to i8
  %1701 = load ptr, ptr %6, align 8, !tbaa !5
  %1702 = getelementptr inbounds i8, ptr %1701, i64 13
  store i8 %1700, ptr %1702, align 1, !tbaa !9
  %1703 = load ptr, ptr %6, align 8, !tbaa !5
  %1704 = getelementptr inbounds i8, ptr %1703, i64 14
  %1705 = load i8, ptr %1704, align 1, !tbaa !9
  %1706 = zext i8 %1705 to i32
  %1707 = load ptr, ptr %4, align 8, !tbaa !5
  %1708 = getelementptr inbounds i8, ptr %1707, i32 1
  store ptr %1708, ptr %4, align 8, !tbaa !5
  %1709 = load i8, ptr %1707, align 1, !tbaa !9
  %1710 = zext i8 %1709 to i32
  %1711 = xor i32 %1706, %1710
  %1712 = trunc i32 %1711 to i8
  %1713 = load ptr, ptr %6, align 8, !tbaa !5
  %1714 = getelementptr inbounds i8, ptr %1713, i64 14
  store i8 %1712, ptr %1714, align 1, !tbaa !9
  %1715 = load ptr, ptr %6, align 8, !tbaa !5
  %1716 = getelementptr inbounds i8, ptr %1715, i64 15
  %1717 = load i8, ptr %1716, align 1, !tbaa !9
  %1718 = zext i8 %1717 to i32
  %1719 = load ptr, ptr %4, align 8, !tbaa !5
  %1720 = getelementptr inbounds i8, ptr %1719, i32 1
  store ptr %1720, ptr %4, align 8, !tbaa !5
  %1721 = load i8, ptr %1719, align 1, !tbaa !9
  %1722 = zext i8 %1721 to i32
  %1723 = xor i32 %1718, %1722
  %1724 = trunc i32 %1723 to i8
  %1725 = load ptr, ptr %6, align 8, !tbaa !5
  %1726 = getelementptr inbounds i8, ptr %1725, i64 15
  store i8 %1724, ptr %1726, align 1, !tbaa !9
  %1727 = load ptr, ptr %6, align 8, !tbaa !5
  %1728 = load i8, ptr %1727, align 1, !tbaa !9
  %1729 = zext i8 %1728 to i64
  %1730 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1729
  %1731 = load i8, ptr %1730, align 1, !tbaa !9
  %1732 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  store i8 %1731, ptr %1732, align 16, !tbaa !9
  %1733 = load ptr, ptr %6, align 8, !tbaa !5
  %1734 = getelementptr inbounds i8, ptr %1733, i64 1
  %1735 = load i8, ptr %1734, align 1, !tbaa !9
  %1736 = zext i8 %1735 to i64
  %1737 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1736
  %1738 = load i8, ptr %1737, align 1, !tbaa !9
  %1739 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1740 = getelementptr inbounds i8, ptr %1739, i64 1
  store i8 %1738, ptr %1740, align 1, !tbaa !9
  %1741 = load ptr, ptr %6, align 8, !tbaa !5
  %1742 = getelementptr inbounds i8, ptr %1741, i64 2
  %1743 = load i8, ptr %1742, align 1, !tbaa !9
  %1744 = zext i8 %1743 to i64
  %1745 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1744
  %1746 = load i8, ptr %1745, align 1, !tbaa !9
  %1747 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1748 = getelementptr inbounds i8, ptr %1747, i64 2
  store i8 %1746, ptr %1748, align 1, !tbaa !9
  %1749 = load ptr, ptr %6, align 8, !tbaa !5
  %1750 = getelementptr inbounds i8, ptr %1749, i64 3
  %1751 = load i8, ptr %1750, align 1, !tbaa !9
  %1752 = zext i8 %1751 to i64
  %1753 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1752
  %1754 = load i8, ptr %1753, align 1, !tbaa !9
  %1755 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1756 = getelementptr inbounds i8, ptr %1755, i64 3
  store i8 %1754, ptr %1756, align 1, !tbaa !9
  %1757 = load ptr, ptr %6, align 8, !tbaa !5
  %1758 = getelementptr inbounds i8, ptr %1757, i64 4
  %1759 = load i8, ptr %1758, align 1, !tbaa !9
  %1760 = zext i8 %1759 to i64
  %1761 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1760
  %1762 = load i8, ptr %1761, align 1, !tbaa !9
  %1763 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1764 = getelementptr inbounds i8, ptr %1763, i64 4
  store i8 %1762, ptr %1764, align 1, !tbaa !9
  %1765 = load ptr, ptr %6, align 8, !tbaa !5
  %1766 = getelementptr inbounds i8, ptr %1765, i64 5
  %1767 = load i8, ptr %1766, align 1, !tbaa !9
  %1768 = zext i8 %1767 to i64
  %1769 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1768
  %1770 = load i8, ptr %1769, align 1, !tbaa !9
  %1771 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1772 = getelementptr inbounds i8, ptr %1771, i64 5
  store i8 %1770, ptr %1772, align 1, !tbaa !9
  %1773 = load ptr, ptr %6, align 8, !tbaa !5
  %1774 = getelementptr inbounds i8, ptr %1773, i64 6
  %1775 = load i8, ptr %1774, align 1, !tbaa !9
  %1776 = zext i8 %1775 to i64
  %1777 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1776
  %1778 = load i8, ptr %1777, align 1, !tbaa !9
  %1779 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1780 = getelementptr inbounds i8, ptr %1779, i64 6
  store i8 %1778, ptr %1780, align 1, !tbaa !9
  %1781 = load ptr, ptr %6, align 8, !tbaa !5
  %1782 = getelementptr inbounds i8, ptr %1781, i64 7
  %1783 = load i8, ptr %1782, align 1, !tbaa !9
  %1784 = zext i8 %1783 to i64
  %1785 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1784
  %1786 = load i8, ptr %1785, align 1, !tbaa !9
  %1787 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1788 = getelementptr inbounds i8, ptr %1787, i64 7
  store i8 %1786, ptr %1788, align 1, !tbaa !9
  %1789 = load ptr, ptr %6, align 8, !tbaa !5
  %1790 = getelementptr inbounds i8, ptr %1789, i64 8
  %1791 = load i8, ptr %1790, align 1, !tbaa !9
  %1792 = zext i8 %1791 to i64
  %1793 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1792
  %1794 = load i8, ptr %1793, align 1, !tbaa !9
  %1795 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1796 = getelementptr inbounds i8, ptr %1795, i64 8
  store i8 %1794, ptr %1796, align 1, !tbaa !9
  %1797 = load ptr, ptr %6, align 8, !tbaa !5
  %1798 = getelementptr inbounds i8, ptr %1797, i64 9
  %1799 = load i8, ptr %1798, align 1, !tbaa !9
  %1800 = zext i8 %1799 to i64
  %1801 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1800
  %1802 = load i8, ptr %1801, align 1, !tbaa !9
  %1803 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1804 = getelementptr inbounds i8, ptr %1803, i64 9
  store i8 %1802, ptr %1804, align 1, !tbaa !9
  %1805 = load ptr, ptr %6, align 8, !tbaa !5
  %1806 = getelementptr inbounds i8, ptr %1805, i64 10
  %1807 = load i8, ptr %1806, align 1, !tbaa !9
  %1808 = zext i8 %1807 to i64
  %1809 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1808
  %1810 = load i8, ptr %1809, align 1, !tbaa !9
  %1811 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1812 = getelementptr inbounds i8, ptr %1811, i64 10
  store i8 %1810, ptr %1812, align 1, !tbaa !9
  %1813 = load ptr, ptr %6, align 8, !tbaa !5
  %1814 = getelementptr inbounds i8, ptr %1813, i64 11
  %1815 = load i8, ptr %1814, align 1, !tbaa !9
  %1816 = zext i8 %1815 to i64
  %1817 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1816
  %1818 = load i8, ptr %1817, align 1, !tbaa !9
  %1819 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1820 = getelementptr inbounds i8, ptr %1819, i64 11
  store i8 %1818, ptr %1820, align 1, !tbaa !9
  %1821 = load ptr, ptr %6, align 8, !tbaa !5
  %1822 = getelementptr inbounds i8, ptr %1821, i64 12
  %1823 = load i8, ptr %1822, align 1, !tbaa !9
  %1824 = zext i8 %1823 to i64
  %1825 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1824
  %1826 = load i8, ptr %1825, align 1, !tbaa !9
  %1827 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1828 = getelementptr inbounds i8, ptr %1827, i64 12
  store i8 %1826, ptr %1828, align 1, !tbaa !9
  %1829 = load ptr, ptr %6, align 8, !tbaa !5
  %1830 = getelementptr inbounds i8, ptr %1829, i64 13
  %1831 = load i8, ptr %1830, align 1, !tbaa !9
  %1832 = zext i8 %1831 to i64
  %1833 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1832
  %1834 = load i8, ptr %1833, align 1, !tbaa !9
  %1835 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1836 = getelementptr inbounds i8, ptr %1835, i64 13
  store i8 %1834, ptr %1836, align 1, !tbaa !9
  %1837 = load ptr, ptr %6, align 8, !tbaa !5
  %1838 = getelementptr inbounds i8, ptr %1837, i64 14
  %1839 = load i8, ptr %1838, align 1, !tbaa !9
  %1840 = zext i8 %1839 to i64
  %1841 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1840
  %1842 = load i8, ptr %1841, align 1, !tbaa !9
  %1843 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1844 = getelementptr inbounds i8, ptr %1843, i64 14
  store i8 %1842, ptr %1844, align 1, !tbaa !9
  %1845 = load ptr, ptr %6, align 8, !tbaa !5
  %1846 = getelementptr inbounds i8, ptr %1845, i64 15
  %1847 = load i8, ptr %1846, align 1, !tbaa !9
  %1848 = zext i8 %1847 to i64
  %1849 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1848
  %1850 = load i8, ptr %1849, align 1, !tbaa !9
  %1851 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1852 = getelementptr inbounds i8, ptr %1851, i64 15
  store i8 %1850, ptr %1852, align 1, !tbaa !9
  %1853 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1854 = getelementptr inbounds i8, ptr %1853, i64 1
  %1855 = load i8, ptr %1854, align 1, !tbaa !9
  store i8 %1855, ptr %8, align 1, !tbaa !9
  %1856 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1857 = getelementptr inbounds i8, ptr %1856, i64 5
  %1858 = load i8, ptr %1857, align 1, !tbaa !9
  %1859 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1860 = getelementptr inbounds i8, ptr %1859, i64 1
  store i8 %1858, ptr %1860, align 1, !tbaa !9
  %1861 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1862 = getelementptr inbounds i8, ptr %1861, i64 9
  %1863 = load i8, ptr %1862, align 1, !tbaa !9
  %1864 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1865 = getelementptr inbounds i8, ptr %1864, i64 5
  store i8 %1863, ptr %1865, align 1, !tbaa !9
  %1866 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1867 = getelementptr inbounds i8, ptr %1866, i64 13
  %1868 = load i8, ptr %1867, align 1, !tbaa !9
  %1869 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1870 = getelementptr inbounds i8, ptr %1869, i64 9
  store i8 %1868, ptr %1870, align 1, !tbaa !9
  %1871 = load i8, ptr %8, align 1, !tbaa !9
  %1872 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1873 = getelementptr inbounds i8, ptr %1872, i64 13
  store i8 %1871, ptr %1873, align 1, !tbaa !9
  %1874 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1875 = getelementptr inbounds i8, ptr %1874, i64 2
  %1876 = load i8, ptr %1875, align 1, !tbaa !9
  store i8 %1876, ptr %8, align 1, !tbaa !9
  %1877 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1878 = getelementptr inbounds i8, ptr %1877, i64 10
  %1879 = load i8, ptr %1878, align 1, !tbaa !9
  %1880 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1881 = getelementptr inbounds i8, ptr %1880, i64 2
  store i8 %1879, ptr %1881, align 1, !tbaa !9
  %1882 = load i8, ptr %8, align 1, !tbaa !9
  %1883 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1884 = getelementptr inbounds i8, ptr %1883, i64 10
  store i8 %1882, ptr %1884, align 1, !tbaa !9
  %1885 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1886 = getelementptr inbounds i8, ptr %1885, i64 6
  %1887 = load i8, ptr %1886, align 1, !tbaa !9
  store i8 %1887, ptr %8, align 1, !tbaa !9
  %1888 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1889 = getelementptr inbounds i8, ptr %1888, i64 14
  %1890 = load i8, ptr %1889, align 1, !tbaa !9
  %1891 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1892 = getelementptr inbounds i8, ptr %1891, i64 6
  store i8 %1890, ptr %1892, align 1, !tbaa !9
  %1893 = load i8, ptr %8, align 1, !tbaa !9
  %1894 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1895 = getelementptr inbounds i8, ptr %1894, i64 14
  store i8 %1893, ptr %1895, align 1, !tbaa !9
  %1896 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1897 = getelementptr inbounds i8, ptr %1896, i64 15
  %1898 = load i8, ptr %1897, align 1, !tbaa !9
  store i8 %1898, ptr %8, align 1, !tbaa !9
  %1899 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1900 = getelementptr inbounds i8, ptr %1899, i64 11
  %1901 = load i8, ptr %1900, align 1, !tbaa !9
  %1902 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1903 = getelementptr inbounds i8, ptr %1902, i64 15
  store i8 %1901, ptr %1903, align 1, !tbaa !9
  %1904 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1905 = getelementptr inbounds i8, ptr %1904, i64 7
  %1906 = load i8, ptr %1905, align 1, !tbaa !9
  %1907 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1908 = getelementptr inbounds i8, ptr %1907, i64 11
  store i8 %1906, ptr %1908, align 1, !tbaa !9
  %1909 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1910 = getelementptr inbounds i8, ptr %1909, i64 3
  %1911 = load i8, ptr %1910, align 1, !tbaa !9
  %1912 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1913 = getelementptr inbounds i8, ptr %1912, i64 7
  store i8 %1911, ptr %1913, align 1, !tbaa !9
  %1914 = load i8, ptr %8, align 1, !tbaa !9
  %1915 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1916 = getelementptr inbounds i8, ptr %1915, i64 3
  store i8 %1914, ptr %1916, align 1, !tbaa !9
  %1917 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1918 = load i8, ptr %1917, align 16, !tbaa !9
  %1919 = zext i8 %1918 to i32
  %1920 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %1921 = load i8, ptr %1920, align 1, !tbaa !9
  %1922 = zext i8 %1921 to i32
  %1923 = xor i32 %1919, %1922
  %1924 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %1925 = load i8, ptr %1924, align 2, !tbaa !9
  %1926 = zext i8 %1925 to i32
  %1927 = xor i32 %1923, %1926
  %1928 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %1929 = load i8, ptr %1928, align 1, !tbaa !9
  %1930 = zext i8 %1929 to i32
  %1931 = xor i32 %1927, %1930
  %1932 = trunc i32 %1931 to i8
  store i8 %1932, ptr %8, align 1, !tbaa !9
  %1933 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1934 = load i8, ptr %1933, align 16, !tbaa !9
  %1935 = zext i8 %1934 to i32
  %1936 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %1937 = load i8, ptr %1936, align 1, !tbaa !9
  %1938 = zext i8 %1937 to i32
  %1939 = xor i32 %1935, %1938
  %1940 = trunc i32 %1939 to i8
  %1941 = call zeroext i8 @mul2(i8 noundef zeroext %1940)
  %1942 = zext i8 %1941 to i32
  %1943 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1944 = load i8, ptr %1943, align 16, !tbaa !9
  %1945 = zext i8 %1944 to i32
  %1946 = xor i32 %1942, %1945
  %1947 = load i8, ptr %8, align 1, !tbaa !9
  %1948 = zext i8 %1947 to i32
  %1949 = xor i32 %1946, %1948
  %1950 = trunc i32 %1949 to i8
  %1951 = load ptr, ptr %6, align 8, !tbaa !5
  %1952 = getelementptr inbounds i8, ptr %1951, i64 0
  store i8 %1950, ptr %1952, align 1, !tbaa !9
  %1953 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %1954 = load i8, ptr %1953, align 1, !tbaa !9
  %1955 = zext i8 %1954 to i32
  %1956 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %1957 = load i8, ptr %1956, align 2, !tbaa !9
  %1958 = zext i8 %1957 to i32
  %1959 = xor i32 %1955, %1958
  %1960 = trunc i32 %1959 to i8
  %1961 = call zeroext i8 @mul2(i8 noundef zeroext %1960)
  %1962 = zext i8 %1961 to i32
  %1963 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %1964 = load i8, ptr %1963, align 1, !tbaa !9
  %1965 = zext i8 %1964 to i32
  %1966 = xor i32 %1962, %1965
  %1967 = load i8, ptr %8, align 1, !tbaa !9
  %1968 = zext i8 %1967 to i32
  %1969 = xor i32 %1966, %1968
  %1970 = trunc i32 %1969 to i8
  %1971 = load ptr, ptr %6, align 8, !tbaa !5
  %1972 = getelementptr inbounds i8, ptr %1971, i64 1
  store i8 %1970, ptr %1972, align 1, !tbaa !9
  %1973 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %1974 = load i8, ptr %1973, align 2, !tbaa !9
  %1975 = zext i8 %1974 to i32
  %1976 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %1977 = load i8, ptr %1976, align 1, !tbaa !9
  %1978 = zext i8 %1977 to i32
  %1979 = xor i32 %1975, %1978
  %1980 = trunc i32 %1979 to i8
  %1981 = call zeroext i8 @mul2(i8 noundef zeroext %1980)
  %1982 = zext i8 %1981 to i32
  %1983 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %1984 = load i8, ptr %1983, align 2, !tbaa !9
  %1985 = zext i8 %1984 to i32
  %1986 = xor i32 %1982, %1985
  %1987 = load i8, ptr %8, align 1, !tbaa !9
  %1988 = zext i8 %1987 to i32
  %1989 = xor i32 %1986, %1988
  %1990 = trunc i32 %1989 to i8
  %1991 = load ptr, ptr %6, align 8, !tbaa !5
  %1992 = getelementptr inbounds i8, ptr %1991, i64 2
  store i8 %1990, ptr %1992, align 1, !tbaa !9
  %1993 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %1994 = load i8, ptr %1993, align 1, !tbaa !9
  %1995 = zext i8 %1994 to i32
  %1996 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %1997 = load i8, ptr %1996, align 16, !tbaa !9
  %1998 = zext i8 %1997 to i32
  %1999 = xor i32 %1995, %1998
  %2000 = trunc i32 %1999 to i8
  %2001 = call zeroext i8 @mul2(i8 noundef zeroext %2000)
  %2002 = zext i8 %2001 to i32
  %2003 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %2004 = load i8, ptr %2003, align 1, !tbaa !9
  %2005 = zext i8 %2004 to i32
  %2006 = xor i32 %2002, %2005
  %2007 = load i8, ptr %8, align 1, !tbaa !9
  %2008 = zext i8 %2007 to i32
  %2009 = xor i32 %2006, %2008
  %2010 = trunc i32 %2009 to i8
  %2011 = load ptr, ptr %6, align 8, !tbaa !5
  %2012 = getelementptr inbounds i8, ptr %2011, i64 3
  store i8 %2010, ptr %2012, align 1, !tbaa !9
  %2013 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %2014 = load i8, ptr %2013, align 4, !tbaa !9
  %2015 = zext i8 %2014 to i32
  %2016 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %2017 = load i8, ptr %2016, align 1, !tbaa !9
  %2018 = zext i8 %2017 to i32
  %2019 = xor i32 %2015, %2018
  %2020 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %2021 = load i8, ptr %2020, align 2, !tbaa !9
  %2022 = zext i8 %2021 to i32
  %2023 = xor i32 %2019, %2022
  %2024 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %2025 = load i8, ptr %2024, align 1, !tbaa !9
  %2026 = zext i8 %2025 to i32
  %2027 = xor i32 %2023, %2026
  %2028 = trunc i32 %2027 to i8
  store i8 %2028, ptr %8, align 1, !tbaa !9
  %2029 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %2030 = load i8, ptr %2029, align 4, !tbaa !9
  %2031 = zext i8 %2030 to i32
  %2032 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %2033 = load i8, ptr %2032, align 1, !tbaa !9
  %2034 = zext i8 %2033 to i32
  %2035 = xor i32 %2031, %2034
  %2036 = trunc i32 %2035 to i8
  %2037 = call zeroext i8 @mul2(i8 noundef zeroext %2036)
  %2038 = zext i8 %2037 to i32
  %2039 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %2040 = load i8, ptr %2039, align 4, !tbaa !9
  %2041 = zext i8 %2040 to i32
  %2042 = xor i32 %2038, %2041
  %2043 = load i8, ptr %8, align 1, !tbaa !9
  %2044 = zext i8 %2043 to i32
  %2045 = xor i32 %2042, %2044
  %2046 = trunc i32 %2045 to i8
  %2047 = load ptr, ptr %6, align 8, !tbaa !5
  %2048 = getelementptr inbounds i8, ptr %2047, i64 4
  store i8 %2046, ptr %2048, align 1, !tbaa !9
  %2049 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %2050 = load i8, ptr %2049, align 1, !tbaa !9
  %2051 = zext i8 %2050 to i32
  %2052 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %2053 = load i8, ptr %2052, align 2, !tbaa !9
  %2054 = zext i8 %2053 to i32
  %2055 = xor i32 %2051, %2054
  %2056 = trunc i32 %2055 to i8
  %2057 = call zeroext i8 @mul2(i8 noundef zeroext %2056)
  %2058 = zext i8 %2057 to i32
  %2059 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %2060 = load i8, ptr %2059, align 1, !tbaa !9
  %2061 = zext i8 %2060 to i32
  %2062 = xor i32 %2058, %2061
  %2063 = load i8, ptr %8, align 1, !tbaa !9
  %2064 = zext i8 %2063 to i32
  %2065 = xor i32 %2062, %2064
  %2066 = trunc i32 %2065 to i8
  %2067 = load ptr, ptr %6, align 8, !tbaa !5
  %2068 = getelementptr inbounds i8, ptr %2067, i64 5
  store i8 %2066, ptr %2068, align 1, !tbaa !9
  %2069 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %2070 = load i8, ptr %2069, align 2, !tbaa !9
  %2071 = zext i8 %2070 to i32
  %2072 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %2073 = load i8, ptr %2072, align 1, !tbaa !9
  %2074 = zext i8 %2073 to i32
  %2075 = xor i32 %2071, %2074
  %2076 = trunc i32 %2075 to i8
  %2077 = call zeroext i8 @mul2(i8 noundef zeroext %2076)
  %2078 = zext i8 %2077 to i32
  %2079 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %2080 = load i8, ptr %2079, align 2, !tbaa !9
  %2081 = zext i8 %2080 to i32
  %2082 = xor i32 %2078, %2081
  %2083 = load i8, ptr %8, align 1, !tbaa !9
  %2084 = zext i8 %2083 to i32
  %2085 = xor i32 %2082, %2084
  %2086 = trunc i32 %2085 to i8
  %2087 = load ptr, ptr %6, align 8, !tbaa !5
  %2088 = getelementptr inbounds i8, ptr %2087, i64 6
  store i8 %2086, ptr %2088, align 1, !tbaa !9
  %2089 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %2090 = load i8, ptr %2089, align 1, !tbaa !9
  %2091 = zext i8 %2090 to i32
  %2092 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %2093 = load i8, ptr %2092, align 4, !tbaa !9
  %2094 = zext i8 %2093 to i32
  %2095 = xor i32 %2091, %2094
  %2096 = trunc i32 %2095 to i8
  %2097 = call zeroext i8 @mul2(i8 noundef zeroext %2096)
  %2098 = zext i8 %2097 to i32
  %2099 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %2100 = load i8, ptr %2099, align 1, !tbaa !9
  %2101 = zext i8 %2100 to i32
  %2102 = xor i32 %2098, %2101
  %2103 = load i8, ptr %8, align 1, !tbaa !9
  %2104 = zext i8 %2103 to i32
  %2105 = xor i32 %2102, %2104
  %2106 = trunc i32 %2105 to i8
  %2107 = load ptr, ptr %6, align 8, !tbaa !5
  %2108 = getelementptr inbounds i8, ptr %2107, i64 7
  store i8 %2106, ptr %2108, align 1, !tbaa !9
  %2109 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %2110 = load i8, ptr %2109, align 8, !tbaa !9
  %2111 = zext i8 %2110 to i32
  %2112 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %2113 = load i8, ptr %2112, align 1, !tbaa !9
  %2114 = zext i8 %2113 to i32
  %2115 = xor i32 %2111, %2114
  %2116 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %2117 = load i8, ptr %2116, align 2, !tbaa !9
  %2118 = zext i8 %2117 to i32
  %2119 = xor i32 %2115, %2118
  %2120 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %2121 = load i8, ptr %2120, align 1, !tbaa !9
  %2122 = zext i8 %2121 to i32
  %2123 = xor i32 %2119, %2122
  %2124 = trunc i32 %2123 to i8
  store i8 %2124, ptr %8, align 1, !tbaa !9
  %2125 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %2126 = load i8, ptr %2125, align 8, !tbaa !9
  %2127 = zext i8 %2126 to i32
  %2128 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %2129 = load i8, ptr %2128, align 1, !tbaa !9
  %2130 = zext i8 %2129 to i32
  %2131 = xor i32 %2127, %2130
  %2132 = trunc i32 %2131 to i8
  %2133 = call zeroext i8 @mul2(i8 noundef zeroext %2132)
  %2134 = zext i8 %2133 to i32
  %2135 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %2136 = load i8, ptr %2135, align 8, !tbaa !9
  %2137 = zext i8 %2136 to i32
  %2138 = xor i32 %2134, %2137
  %2139 = load i8, ptr %8, align 1, !tbaa !9
  %2140 = zext i8 %2139 to i32
  %2141 = xor i32 %2138, %2140
  %2142 = trunc i32 %2141 to i8
  %2143 = load ptr, ptr %6, align 8, !tbaa !5
  %2144 = getelementptr inbounds i8, ptr %2143, i64 8
  store i8 %2142, ptr %2144, align 1, !tbaa !9
  %2145 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %2146 = load i8, ptr %2145, align 1, !tbaa !9
  %2147 = zext i8 %2146 to i32
  %2148 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %2149 = load i8, ptr %2148, align 2, !tbaa !9
  %2150 = zext i8 %2149 to i32
  %2151 = xor i32 %2147, %2150
  %2152 = trunc i32 %2151 to i8
  %2153 = call zeroext i8 @mul2(i8 noundef zeroext %2152)
  %2154 = zext i8 %2153 to i32
  %2155 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %2156 = load i8, ptr %2155, align 1, !tbaa !9
  %2157 = zext i8 %2156 to i32
  %2158 = xor i32 %2154, %2157
  %2159 = load i8, ptr %8, align 1, !tbaa !9
  %2160 = zext i8 %2159 to i32
  %2161 = xor i32 %2158, %2160
  %2162 = trunc i32 %2161 to i8
  %2163 = load ptr, ptr %6, align 8, !tbaa !5
  %2164 = getelementptr inbounds i8, ptr %2163, i64 9
  store i8 %2162, ptr %2164, align 1, !tbaa !9
  %2165 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %2166 = load i8, ptr %2165, align 2, !tbaa !9
  %2167 = zext i8 %2166 to i32
  %2168 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %2169 = load i8, ptr %2168, align 1, !tbaa !9
  %2170 = zext i8 %2169 to i32
  %2171 = xor i32 %2167, %2170
  %2172 = trunc i32 %2171 to i8
  %2173 = call zeroext i8 @mul2(i8 noundef zeroext %2172)
  %2174 = zext i8 %2173 to i32
  %2175 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %2176 = load i8, ptr %2175, align 2, !tbaa !9
  %2177 = zext i8 %2176 to i32
  %2178 = xor i32 %2174, %2177
  %2179 = load i8, ptr %8, align 1, !tbaa !9
  %2180 = zext i8 %2179 to i32
  %2181 = xor i32 %2178, %2180
  %2182 = trunc i32 %2181 to i8
  %2183 = load ptr, ptr %6, align 8, !tbaa !5
  %2184 = getelementptr inbounds i8, ptr %2183, i64 10
  store i8 %2182, ptr %2184, align 1, !tbaa !9
  %2185 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %2186 = load i8, ptr %2185, align 1, !tbaa !9
  %2187 = zext i8 %2186 to i32
  %2188 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %2189 = load i8, ptr %2188, align 8, !tbaa !9
  %2190 = zext i8 %2189 to i32
  %2191 = xor i32 %2187, %2190
  %2192 = trunc i32 %2191 to i8
  %2193 = call zeroext i8 @mul2(i8 noundef zeroext %2192)
  %2194 = zext i8 %2193 to i32
  %2195 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %2196 = load i8, ptr %2195, align 1, !tbaa !9
  %2197 = zext i8 %2196 to i32
  %2198 = xor i32 %2194, %2197
  %2199 = load i8, ptr %8, align 1, !tbaa !9
  %2200 = zext i8 %2199 to i32
  %2201 = xor i32 %2198, %2200
  %2202 = trunc i32 %2201 to i8
  %2203 = load ptr, ptr %6, align 8, !tbaa !5
  %2204 = getelementptr inbounds i8, ptr %2203, i64 11
  store i8 %2202, ptr %2204, align 1, !tbaa !9
  %2205 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %2206 = load i8, ptr %2205, align 4, !tbaa !9
  %2207 = zext i8 %2206 to i32
  %2208 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %2209 = load i8, ptr %2208, align 1, !tbaa !9
  %2210 = zext i8 %2209 to i32
  %2211 = xor i32 %2207, %2210
  %2212 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %2213 = load i8, ptr %2212, align 2, !tbaa !9
  %2214 = zext i8 %2213 to i32
  %2215 = xor i32 %2211, %2214
  %2216 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %2217 = load i8, ptr %2216, align 1, !tbaa !9
  %2218 = zext i8 %2217 to i32
  %2219 = xor i32 %2215, %2218
  %2220 = trunc i32 %2219 to i8
  store i8 %2220, ptr %8, align 1, !tbaa !9
  %2221 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %2222 = load i8, ptr %2221, align 4, !tbaa !9
  %2223 = zext i8 %2222 to i32
  %2224 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %2225 = load i8, ptr %2224, align 1, !tbaa !9
  %2226 = zext i8 %2225 to i32
  %2227 = xor i32 %2223, %2226
  %2228 = trunc i32 %2227 to i8
  %2229 = call zeroext i8 @mul2(i8 noundef zeroext %2228)
  %2230 = zext i8 %2229 to i32
  %2231 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %2232 = load i8, ptr %2231, align 4, !tbaa !9
  %2233 = zext i8 %2232 to i32
  %2234 = xor i32 %2230, %2233
  %2235 = load i8, ptr %8, align 1, !tbaa !9
  %2236 = zext i8 %2235 to i32
  %2237 = xor i32 %2234, %2236
  %2238 = trunc i32 %2237 to i8
  %2239 = load ptr, ptr %6, align 8, !tbaa !5
  %2240 = getelementptr inbounds i8, ptr %2239, i64 12
  store i8 %2238, ptr %2240, align 1, !tbaa !9
  %2241 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %2242 = load i8, ptr %2241, align 1, !tbaa !9
  %2243 = zext i8 %2242 to i32
  %2244 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %2245 = load i8, ptr %2244, align 2, !tbaa !9
  %2246 = zext i8 %2245 to i32
  %2247 = xor i32 %2243, %2246
  %2248 = trunc i32 %2247 to i8
  %2249 = call zeroext i8 @mul2(i8 noundef zeroext %2248)
  %2250 = zext i8 %2249 to i32
  %2251 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %2252 = load i8, ptr %2251, align 1, !tbaa !9
  %2253 = zext i8 %2252 to i32
  %2254 = xor i32 %2250, %2253
  %2255 = load i8, ptr %8, align 1, !tbaa !9
  %2256 = zext i8 %2255 to i32
  %2257 = xor i32 %2254, %2256
  %2258 = trunc i32 %2257 to i8
  %2259 = load ptr, ptr %6, align 8, !tbaa !5
  %2260 = getelementptr inbounds i8, ptr %2259, i64 13
  store i8 %2258, ptr %2260, align 1, !tbaa !9
  %2261 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %2262 = load i8, ptr %2261, align 2, !tbaa !9
  %2263 = zext i8 %2262 to i32
  %2264 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %2265 = load i8, ptr %2264, align 1, !tbaa !9
  %2266 = zext i8 %2265 to i32
  %2267 = xor i32 %2263, %2266
  %2268 = trunc i32 %2267 to i8
  %2269 = call zeroext i8 @mul2(i8 noundef zeroext %2268)
  %2270 = zext i8 %2269 to i32
  %2271 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %2272 = load i8, ptr %2271, align 2, !tbaa !9
  %2273 = zext i8 %2272 to i32
  %2274 = xor i32 %2270, %2273
  %2275 = load i8, ptr %8, align 1, !tbaa !9
  %2276 = zext i8 %2275 to i32
  %2277 = xor i32 %2274, %2276
  %2278 = trunc i32 %2277 to i8
  %2279 = load ptr, ptr %6, align 8, !tbaa !5
  %2280 = getelementptr inbounds i8, ptr %2279, i64 14
  store i8 %2278, ptr %2280, align 1, !tbaa !9
  %2281 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %2282 = load i8, ptr %2281, align 1, !tbaa !9
  %2283 = zext i8 %2282 to i32
  %2284 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %2285 = load i8, ptr %2284, align 4, !tbaa !9
  %2286 = zext i8 %2285 to i32
  %2287 = xor i32 %2283, %2286
  %2288 = trunc i32 %2287 to i8
  %2289 = call zeroext i8 @mul2(i8 noundef zeroext %2288)
  %2290 = zext i8 %2289 to i32
  %2291 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %2292 = load i8, ptr %2291, align 1, !tbaa !9
  %2293 = zext i8 %2292 to i32
  %2294 = xor i32 %2290, %2293
  %2295 = load i8, ptr %8, align 1, !tbaa !9
  %2296 = zext i8 %2295 to i32
  %2297 = xor i32 %2294, %2296
  %2298 = trunc i32 %2297 to i8
  %2299 = load ptr, ptr %6, align 8, !tbaa !5
  %2300 = getelementptr inbounds i8, ptr %2299, i64 15
  store i8 %2298, ptr %2300, align 1, !tbaa !9
  %2301 = load ptr, ptr %6, align 8, !tbaa !5
  %2302 = load i8, ptr %2301, align 1, !tbaa !9
  %2303 = zext i8 %2302 to i32
  %2304 = load ptr, ptr %4, align 8, !tbaa !5
  %2305 = getelementptr inbounds i8, ptr %2304, i32 1
  store ptr %2305, ptr %4, align 8, !tbaa !5
  %2306 = load i8, ptr %2304, align 1, !tbaa !9
  %2307 = zext i8 %2306 to i32
  %2308 = xor i32 %2303, %2307
  %2309 = trunc i32 %2308 to i8
  %2310 = load ptr, ptr %6, align 8, !tbaa !5
  store i8 %2309, ptr %2310, align 1, !tbaa !9
  %2311 = load ptr, ptr %6, align 8, !tbaa !5
  %2312 = getelementptr inbounds i8, ptr %2311, i64 1
  %2313 = load i8, ptr %2312, align 1, !tbaa !9
  %2314 = zext i8 %2313 to i32
  %2315 = load ptr, ptr %4, align 8, !tbaa !5
  %2316 = getelementptr inbounds i8, ptr %2315, i32 1
  store ptr %2316, ptr %4, align 8, !tbaa !5
  %2317 = load i8, ptr %2315, align 1, !tbaa !9
  %2318 = zext i8 %2317 to i32
  %2319 = xor i32 %2314, %2318
  %2320 = trunc i32 %2319 to i8
  %2321 = load ptr, ptr %6, align 8, !tbaa !5
  %2322 = getelementptr inbounds i8, ptr %2321, i64 1
  store i8 %2320, ptr %2322, align 1, !tbaa !9
  %2323 = load ptr, ptr %6, align 8, !tbaa !5
  %2324 = getelementptr inbounds i8, ptr %2323, i64 2
  %2325 = load i8, ptr %2324, align 1, !tbaa !9
  %2326 = zext i8 %2325 to i32
  %2327 = load ptr, ptr %4, align 8, !tbaa !5
  %2328 = getelementptr inbounds i8, ptr %2327, i32 1
  store ptr %2328, ptr %4, align 8, !tbaa !5
  %2329 = load i8, ptr %2327, align 1, !tbaa !9
  %2330 = zext i8 %2329 to i32
  %2331 = xor i32 %2326, %2330
  %2332 = trunc i32 %2331 to i8
  %2333 = load ptr, ptr %6, align 8, !tbaa !5
  %2334 = getelementptr inbounds i8, ptr %2333, i64 2
  store i8 %2332, ptr %2334, align 1, !tbaa !9
  %2335 = load ptr, ptr %6, align 8, !tbaa !5
  %2336 = getelementptr inbounds i8, ptr %2335, i64 3
  %2337 = load i8, ptr %2336, align 1, !tbaa !9
  %2338 = zext i8 %2337 to i32
  %2339 = load ptr, ptr %4, align 8, !tbaa !5
  %2340 = getelementptr inbounds i8, ptr %2339, i32 1
  store ptr %2340, ptr %4, align 8, !tbaa !5
  %2341 = load i8, ptr %2339, align 1, !tbaa !9
  %2342 = zext i8 %2341 to i32
  %2343 = xor i32 %2338, %2342
  %2344 = trunc i32 %2343 to i8
  %2345 = load ptr, ptr %6, align 8, !tbaa !5
  %2346 = getelementptr inbounds i8, ptr %2345, i64 3
  store i8 %2344, ptr %2346, align 1, !tbaa !9
  %2347 = load ptr, ptr %6, align 8, !tbaa !5
  %2348 = getelementptr inbounds i8, ptr %2347, i64 4
  %2349 = load i8, ptr %2348, align 1, !tbaa !9
  %2350 = zext i8 %2349 to i32
  %2351 = load ptr, ptr %4, align 8, !tbaa !5
  %2352 = getelementptr inbounds i8, ptr %2351, i32 1
  store ptr %2352, ptr %4, align 8, !tbaa !5
  %2353 = load i8, ptr %2351, align 1, !tbaa !9
  %2354 = zext i8 %2353 to i32
  %2355 = xor i32 %2350, %2354
  %2356 = trunc i32 %2355 to i8
  %2357 = load ptr, ptr %6, align 8, !tbaa !5
  %2358 = getelementptr inbounds i8, ptr %2357, i64 4
  store i8 %2356, ptr %2358, align 1, !tbaa !9
  %2359 = load ptr, ptr %6, align 8, !tbaa !5
  %2360 = getelementptr inbounds i8, ptr %2359, i64 5
  %2361 = load i8, ptr %2360, align 1, !tbaa !9
  %2362 = zext i8 %2361 to i32
  %2363 = load ptr, ptr %4, align 8, !tbaa !5
  %2364 = getelementptr inbounds i8, ptr %2363, i32 1
  store ptr %2364, ptr %4, align 8, !tbaa !5
  %2365 = load i8, ptr %2363, align 1, !tbaa !9
  %2366 = zext i8 %2365 to i32
  %2367 = xor i32 %2362, %2366
  %2368 = trunc i32 %2367 to i8
  %2369 = load ptr, ptr %6, align 8, !tbaa !5
  %2370 = getelementptr inbounds i8, ptr %2369, i64 5
  store i8 %2368, ptr %2370, align 1, !tbaa !9
  %2371 = load ptr, ptr %6, align 8, !tbaa !5
  %2372 = getelementptr inbounds i8, ptr %2371, i64 6
  %2373 = load i8, ptr %2372, align 1, !tbaa !9
  %2374 = zext i8 %2373 to i32
  %2375 = load ptr, ptr %4, align 8, !tbaa !5
  %2376 = getelementptr inbounds i8, ptr %2375, i32 1
  store ptr %2376, ptr %4, align 8, !tbaa !5
  %2377 = load i8, ptr %2375, align 1, !tbaa !9
  %2378 = zext i8 %2377 to i32
  %2379 = xor i32 %2374, %2378
  %2380 = trunc i32 %2379 to i8
  %2381 = load ptr, ptr %6, align 8, !tbaa !5
  %2382 = getelementptr inbounds i8, ptr %2381, i64 6
  store i8 %2380, ptr %2382, align 1, !tbaa !9
  %2383 = load ptr, ptr %6, align 8, !tbaa !5
  %2384 = getelementptr inbounds i8, ptr %2383, i64 7
  %2385 = load i8, ptr %2384, align 1, !tbaa !9
  %2386 = zext i8 %2385 to i32
  %2387 = load ptr, ptr %4, align 8, !tbaa !5
  %2388 = getelementptr inbounds i8, ptr %2387, i32 1
  store ptr %2388, ptr %4, align 8, !tbaa !5
  %2389 = load i8, ptr %2387, align 1, !tbaa !9
  %2390 = zext i8 %2389 to i32
  %2391 = xor i32 %2386, %2390
  %2392 = trunc i32 %2391 to i8
  %2393 = load ptr, ptr %6, align 8, !tbaa !5
  %2394 = getelementptr inbounds i8, ptr %2393, i64 7
  store i8 %2392, ptr %2394, align 1, !tbaa !9
  %2395 = load ptr, ptr %6, align 8, !tbaa !5
  %2396 = getelementptr inbounds i8, ptr %2395, i64 8
  %2397 = load i8, ptr %2396, align 1, !tbaa !9
  %2398 = zext i8 %2397 to i32
  %2399 = load ptr, ptr %4, align 8, !tbaa !5
  %2400 = getelementptr inbounds i8, ptr %2399, i32 1
  store ptr %2400, ptr %4, align 8, !tbaa !5
  %2401 = load i8, ptr %2399, align 1, !tbaa !9
  %2402 = zext i8 %2401 to i32
  %2403 = xor i32 %2398, %2402
  %2404 = trunc i32 %2403 to i8
  %2405 = load ptr, ptr %6, align 8, !tbaa !5
  %2406 = getelementptr inbounds i8, ptr %2405, i64 8
  store i8 %2404, ptr %2406, align 1, !tbaa !9
  %2407 = load ptr, ptr %6, align 8, !tbaa !5
  %2408 = getelementptr inbounds i8, ptr %2407, i64 9
  %2409 = load i8, ptr %2408, align 1, !tbaa !9
  %2410 = zext i8 %2409 to i32
  %2411 = load ptr, ptr %4, align 8, !tbaa !5
  %2412 = getelementptr inbounds i8, ptr %2411, i32 1
  store ptr %2412, ptr %4, align 8, !tbaa !5
  %2413 = load i8, ptr %2411, align 1, !tbaa !9
  %2414 = zext i8 %2413 to i32
  %2415 = xor i32 %2410, %2414
  %2416 = trunc i32 %2415 to i8
  %2417 = load ptr, ptr %6, align 8, !tbaa !5
  %2418 = getelementptr inbounds i8, ptr %2417, i64 9
  store i8 %2416, ptr %2418, align 1, !tbaa !9
  %2419 = load ptr, ptr %6, align 8, !tbaa !5
  %2420 = getelementptr inbounds i8, ptr %2419, i64 10
  %2421 = load i8, ptr %2420, align 1, !tbaa !9
  %2422 = zext i8 %2421 to i32
  %2423 = load ptr, ptr %4, align 8, !tbaa !5
  %2424 = getelementptr inbounds i8, ptr %2423, i32 1
  store ptr %2424, ptr %4, align 8, !tbaa !5
  %2425 = load i8, ptr %2423, align 1, !tbaa !9
  %2426 = zext i8 %2425 to i32
  %2427 = xor i32 %2422, %2426
  %2428 = trunc i32 %2427 to i8
  %2429 = load ptr, ptr %6, align 8, !tbaa !5
  %2430 = getelementptr inbounds i8, ptr %2429, i64 10
  store i8 %2428, ptr %2430, align 1, !tbaa !9
  %2431 = load ptr, ptr %6, align 8, !tbaa !5
  %2432 = getelementptr inbounds i8, ptr %2431, i64 11
  %2433 = load i8, ptr %2432, align 1, !tbaa !9
  %2434 = zext i8 %2433 to i32
  %2435 = load ptr, ptr %4, align 8, !tbaa !5
  %2436 = getelementptr inbounds i8, ptr %2435, i32 1
  store ptr %2436, ptr %4, align 8, !tbaa !5
  %2437 = load i8, ptr %2435, align 1, !tbaa !9
  %2438 = zext i8 %2437 to i32
  %2439 = xor i32 %2434, %2438
  %2440 = trunc i32 %2439 to i8
  %2441 = load ptr, ptr %6, align 8, !tbaa !5
  %2442 = getelementptr inbounds i8, ptr %2441, i64 11
  store i8 %2440, ptr %2442, align 1, !tbaa !9
  %2443 = load ptr, ptr %6, align 8, !tbaa !5
  %2444 = getelementptr inbounds i8, ptr %2443, i64 12
  %2445 = load i8, ptr %2444, align 1, !tbaa !9
  %2446 = zext i8 %2445 to i32
  %2447 = load ptr, ptr %4, align 8, !tbaa !5
  %2448 = getelementptr inbounds i8, ptr %2447, i32 1
  store ptr %2448, ptr %4, align 8, !tbaa !5
  %2449 = load i8, ptr %2447, align 1, !tbaa !9
  %2450 = zext i8 %2449 to i32
  %2451 = xor i32 %2446, %2450
  %2452 = trunc i32 %2451 to i8
  %2453 = load ptr, ptr %6, align 8, !tbaa !5
  %2454 = getelementptr inbounds i8, ptr %2453, i64 12
  store i8 %2452, ptr %2454, align 1, !tbaa !9
  %2455 = load ptr, ptr %6, align 8, !tbaa !5
  %2456 = getelementptr inbounds i8, ptr %2455, i64 13
  %2457 = load i8, ptr %2456, align 1, !tbaa !9
  %2458 = zext i8 %2457 to i32
  %2459 = load ptr, ptr %4, align 8, !tbaa !5
  %2460 = getelementptr inbounds i8, ptr %2459, i32 1
  store ptr %2460, ptr %4, align 8, !tbaa !5
  %2461 = load i8, ptr %2459, align 1, !tbaa !9
  %2462 = zext i8 %2461 to i32
  %2463 = xor i32 %2458, %2462
  %2464 = trunc i32 %2463 to i8
  %2465 = load ptr, ptr %6, align 8, !tbaa !5
  %2466 = getelementptr inbounds i8, ptr %2465, i64 13
  store i8 %2464, ptr %2466, align 1, !tbaa !9
  %2467 = load ptr, ptr %6, align 8, !tbaa !5
  %2468 = getelementptr inbounds i8, ptr %2467, i64 14
  %2469 = load i8, ptr %2468, align 1, !tbaa !9
  %2470 = zext i8 %2469 to i32
  %2471 = load ptr, ptr %4, align 8, !tbaa !5
  %2472 = getelementptr inbounds i8, ptr %2471, i32 1
  store ptr %2472, ptr %4, align 8, !tbaa !5
  %2473 = load i8, ptr %2471, align 1, !tbaa !9
  %2474 = zext i8 %2473 to i32
  %2475 = xor i32 %2470, %2474
  %2476 = trunc i32 %2475 to i8
  %2477 = load ptr, ptr %6, align 8, !tbaa !5
  %2478 = getelementptr inbounds i8, ptr %2477, i64 14
  store i8 %2476, ptr %2478, align 1, !tbaa !9
  %2479 = load ptr, ptr %6, align 8, !tbaa !5
  %2480 = getelementptr inbounds i8, ptr %2479, i64 15
  %2481 = load i8, ptr %2480, align 1, !tbaa !9
  %2482 = zext i8 %2481 to i32
  %2483 = load ptr, ptr %4, align 8, !tbaa !5
  %2484 = getelementptr inbounds i8, ptr %2483, i32 1
  store ptr %2484, ptr %4, align 8, !tbaa !5
  %2485 = load i8, ptr %2483, align 1, !tbaa !9
  %2486 = zext i8 %2485 to i32
  %2487 = xor i32 %2482, %2486
  %2488 = trunc i32 %2487 to i8
  %2489 = load ptr, ptr %6, align 8, !tbaa !5
  %2490 = getelementptr inbounds i8, ptr %2489, i64 15
  store i8 %2488, ptr %2490, align 1, !tbaa !9
  %2491 = load ptr, ptr %6, align 8, !tbaa !5
  %2492 = load i8, ptr %2491, align 1, !tbaa !9
  %2493 = zext i8 %2492 to i64
  %2494 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2493
  %2495 = load i8, ptr %2494, align 1, !tbaa !9
  %2496 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  store i8 %2495, ptr %2496, align 16, !tbaa !9
  %2497 = load ptr, ptr %6, align 8, !tbaa !5
  %2498 = getelementptr inbounds i8, ptr %2497, i64 1
  %2499 = load i8, ptr %2498, align 1, !tbaa !9
  %2500 = zext i8 %2499 to i64
  %2501 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2500
  %2502 = load i8, ptr %2501, align 1, !tbaa !9
  %2503 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2504 = getelementptr inbounds i8, ptr %2503, i64 1
  store i8 %2502, ptr %2504, align 1, !tbaa !9
  %2505 = load ptr, ptr %6, align 8, !tbaa !5
  %2506 = getelementptr inbounds i8, ptr %2505, i64 2
  %2507 = load i8, ptr %2506, align 1, !tbaa !9
  %2508 = zext i8 %2507 to i64
  %2509 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2508
  %2510 = load i8, ptr %2509, align 1, !tbaa !9
  %2511 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2512 = getelementptr inbounds i8, ptr %2511, i64 2
  store i8 %2510, ptr %2512, align 1, !tbaa !9
  %2513 = load ptr, ptr %6, align 8, !tbaa !5
  %2514 = getelementptr inbounds i8, ptr %2513, i64 3
  %2515 = load i8, ptr %2514, align 1, !tbaa !9
  %2516 = zext i8 %2515 to i64
  %2517 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2516
  %2518 = load i8, ptr %2517, align 1, !tbaa !9
  %2519 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2520 = getelementptr inbounds i8, ptr %2519, i64 3
  store i8 %2518, ptr %2520, align 1, !tbaa !9
  %2521 = load ptr, ptr %6, align 8, !tbaa !5
  %2522 = getelementptr inbounds i8, ptr %2521, i64 4
  %2523 = load i8, ptr %2522, align 1, !tbaa !9
  %2524 = zext i8 %2523 to i64
  %2525 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2524
  %2526 = load i8, ptr %2525, align 1, !tbaa !9
  %2527 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2528 = getelementptr inbounds i8, ptr %2527, i64 4
  store i8 %2526, ptr %2528, align 1, !tbaa !9
  %2529 = load ptr, ptr %6, align 8, !tbaa !5
  %2530 = getelementptr inbounds i8, ptr %2529, i64 5
  %2531 = load i8, ptr %2530, align 1, !tbaa !9
  %2532 = zext i8 %2531 to i64
  %2533 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2532
  %2534 = load i8, ptr %2533, align 1, !tbaa !9
  %2535 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2536 = getelementptr inbounds i8, ptr %2535, i64 5
  store i8 %2534, ptr %2536, align 1, !tbaa !9
  %2537 = load ptr, ptr %6, align 8, !tbaa !5
  %2538 = getelementptr inbounds i8, ptr %2537, i64 6
  %2539 = load i8, ptr %2538, align 1, !tbaa !9
  %2540 = zext i8 %2539 to i64
  %2541 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2540
  %2542 = load i8, ptr %2541, align 1, !tbaa !9
  %2543 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2544 = getelementptr inbounds i8, ptr %2543, i64 6
  store i8 %2542, ptr %2544, align 1, !tbaa !9
  %2545 = load ptr, ptr %6, align 8, !tbaa !5
  %2546 = getelementptr inbounds i8, ptr %2545, i64 7
  %2547 = load i8, ptr %2546, align 1, !tbaa !9
  %2548 = zext i8 %2547 to i64
  %2549 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2548
  %2550 = load i8, ptr %2549, align 1, !tbaa !9
  %2551 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2552 = getelementptr inbounds i8, ptr %2551, i64 7
  store i8 %2550, ptr %2552, align 1, !tbaa !9
  %2553 = load ptr, ptr %6, align 8, !tbaa !5
  %2554 = getelementptr inbounds i8, ptr %2553, i64 8
  %2555 = load i8, ptr %2554, align 1, !tbaa !9
  %2556 = zext i8 %2555 to i64
  %2557 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2556
  %2558 = load i8, ptr %2557, align 1, !tbaa !9
  %2559 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2560 = getelementptr inbounds i8, ptr %2559, i64 8
  store i8 %2558, ptr %2560, align 1, !tbaa !9
  %2561 = load ptr, ptr %6, align 8, !tbaa !5
  %2562 = getelementptr inbounds i8, ptr %2561, i64 9
  %2563 = load i8, ptr %2562, align 1, !tbaa !9
  %2564 = zext i8 %2563 to i64
  %2565 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2564
  %2566 = load i8, ptr %2565, align 1, !tbaa !9
  %2567 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2568 = getelementptr inbounds i8, ptr %2567, i64 9
  store i8 %2566, ptr %2568, align 1, !tbaa !9
  %2569 = load ptr, ptr %6, align 8, !tbaa !5
  %2570 = getelementptr inbounds i8, ptr %2569, i64 10
  %2571 = load i8, ptr %2570, align 1, !tbaa !9
  %2572 = zext i8 %2571 to i64
  %2573 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2572
  %2574 = load i8, ptr %2573, align 1, !tbaa !9
  %2575 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2576 = getelementptr inbounds i8, ptr %2575, i64 10
  store i8 %2574, ptr %2576, align 1, !tbaa !9
  %2577 = load ptr, ptr %6, align 8, !tbaa !5
  %2578 = getelementptr inbounds i8, ptr %2577, i64 11
  %2579 = load i8, ptr %2578, align 1, !tbaa !9
  %2580 = zext i8 %2579 to i64
  %2581 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2580
  %2582 = load i8, ptr %2581, align 1, !tbaa !9
  %2583 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2584 = getelementptr inbounds i8, ptr %2583, i64 11
  store i8 %2582, ptr %2584, align 1, !tbaa !9
  %2585 = load ptr, ptr %6, align 8, !tbaa !5
  %2586 = getelementptr inbounds i8, ptr %2585, i64 12
  %2587 = load i8, ptr %2586, align 1, !tbaa !9
  %2588 = zext i8 %2587 to i64
  %2589 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2588
  %2590 = load i8, ptr %2589, align 1, !tbaa !9
  %2591 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2592 = getelementptr inbounds i8, ptr %2591, i64 12
  store i8 %2590, ptr %2592, align 1, !tbaa !9
  %2593 = load ptr, ptr %6, align 8, !tbaa !5
  %2594 = getelementptr inbounds i8, ptr %2593, i64 13
  %2595 = load i8, ptr %2594, align 1, !tbaa !9
  %2596 = zext i8 %2595 to i64
  %2597 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2596
  %2598 = load i8, ptr %2597, align 1, !tbaa !9
  %2599 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2600 = getelementptr inbounds i8, ptr %2599, i64 13
  store i8 %2598, ptr %2600, align 1, !tbaa !9
  %2601 = load ptr, ptr %6, align 8, !tbaa !5
  %2602 = getelementptr inbounds i8, ptr %2601, i64 14
  %2603 = load i8, ptr %2602, align 1, !tbaa !9
  %2604 = zext i8 %2603 to i64
  %2605 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2604
  %2606 = load i8, ptr %2605, align 1, !tbaa !9
  %2607 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2608 = getelementptr inbounds i8, ptr %2607, i64 14
  store i8 %2606, ptr %2608, align 1, !tbaa !9
  %2609 = load ptr, ptr %6, align 8, !tbaa !5
  %2610 = getelementptr inbounds i8, ptr %2609, i64 15
  %2611 = load i8, ptr %2610, align 1, !tbaa !9
  %2612 = zext i8 %2611 to i64
  %2613 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %2612
  %2614 = load i8, ptr %2613, align 1, !tbaa !9
  %2615 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2616 = getelementptr inbounds i8, ptr %2615, i64 15
  store i8 %2614, ptr %2616, align 1, !tbaa !9
  %2617 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2618 = getelementptr inbounds i8, ptr %2617, i64 1
  %2619 = load i8, ptr %2618, align 1, !tbaa !9
  store i8 %2619, ptr %8, align 1, !tbaa !9
  %2620 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2621 = getelementptr inbounds i8, ptr %2620, i64 5
  %2622 = load i8, ptr %2621, align 1, !tbaa !9
  %2623 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2624 = getelementptr inbounds i8, ptr %2623, i64 1
  store i8 %2622, ptr %2624, align 1, !tbaa !9
  %2625 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2626 = getelementptr inbounds i8, ptr %2625, i64 9
  %2627 = load i8, ptr %2626, align 1, !tbaa !9
  %2628 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2629 = getelementptr inbounds i8, ptr %2628, i64 5
  store i8 %2627, ptr %2629, align 1, !tbaa !9
  %2630 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2631 = getelementptr inbounds i8, ptr %2630, i64 13
  %2632 = load i8, ptr %2631, align 1, !tbaa !9
  %2633 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2634 = getelementptr inbounds i8, ptr %2633, i64 9
  store i8 %2632, ptr %2634, align 1, !tbaa !9
  %2635 = load i8, ptr %8, align 1, !tbaa !9
  %2636 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2637 = getelementptr inbounds i8, ptr %2636, i64 13
  store i8 %2635, ptr %2637, align 1, !tbaa !9
  %2638 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2639 = getelementptr inbounds i8, ptr %2638, i64 2
  %2640 = load i8, ptr %2639, align 1, !tbaa !9
  store i8 %2640, ptr %8, align 1, !tbaa !9
  %2641 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2642 = getelementptr inbounds i8, ptr %2641, i64 10
  %2643 = load i8, ptr %2642, align 1, !tbaa !9
  %2644 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2645 = getelementptr inbounds i8, ptr %2644, i64 2
  store i8 %2643, ptr %2645, align 1, !tbaa !9
  %2646 = load i8, ptr %8, align 1, !tbaa !9
  %2647 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2648 = getelementptr inbounds i8, ptr %2647, i64 10
  store i8 %2646, ptr %2648, align 1, !tbaa !9
  %2649 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2650 = getelementptr inbounds i8, ptr %2649, i64 6
  %2651 = load i8, ptr %2650, align 1, !tbaa !9
  store i8 %2651, ptr %8, align 1, !tbaa !9
  %2652 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2653 = getelementptr inbounds i8, ptr %2652, i64 14
  %2654 = load i8, ptr %2653, align 1, !tbaa !9
  %2655 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2656 = getelementptr inbounds i8, ptr %2655, i64 6
  store i8 %2654, ptr %2656, align 1, !tbaa !9
  %2657 = load i8, ptr %8, align 1, !tbaa !9
  %2658 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2659 = getelementptr inbounds i8, ptr %2658, i64 14
  store i8 %2657, ptr %2659, align 1, !tbaa !9
  %2660 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2661 = getelementptr inbounds i8, ptr %2660, i64 15
  %2662 = load i8, ptr %2661, align 1, !tbaa !9
  store i8 %2662, ptr %8, align 1, !tbaa !9
  %2663 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2664 = getelementptr inbounds i8, ptr %2663, i64 11
  %2665 = load i8, ptr %2664, align 1, !tbaa !9
  %2666 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2667 = getelementptr inbounds i8, ptr %2666, i64 15
  store i8 %2665, ptr %2667, align 1, !tbaa !9
  %2668 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2669 = getelementptr inbounds i8, ptr %2668, i64 7
  %2670 = load i8, ptr %2669, align 1, !tbaa !9
  %2671 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2672 = getelementptr inbounds i8, ptr %2671, i64 11
  store i8 %2670, ptr %2672, align 1, !tbaa !9
  %2673 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2674 = getelementptr inbounds i8, ptr %2673, i64 3
  %2675 = load i8, ptr %2674, align 1, !tbaa !9
  %2676 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2677 = getelementptr inbounds i8, ptr %2676, i64 7
  store i8 %2675, ptr %2677, align 1, !tbaa !9
  %2678 = load i8, ptr %8, align 1, !tbaa !9
  %2679 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2680 = getelementptr inbounds i8, ptr %2679, i64 3
  store i8 %2678, ptr %2680, align 1, !tbaa !9
  %2681 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2682 = load i8, ptr %2681, align 16, !tbaa !9
  %2683 = zext i8 %2682 to i32
  %2684 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %2685 = load i8, ptr %2684, align 1, !tbaa !9
  %2686 = zext i8 %2685 to i32
  %2687 = xor i32 %2683, %2686
  %2688 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %2689 = load i8, ptr %2688, align 2, !tbaa !9
  %2690 = zext i8 %2689 to i32
  %2691 = xor i32 %2687, %2690
  %2692 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %2693 = load i8, ptr %2692, align 1, !tbaa !9
  %2694 = zext i8 %2693 to i32
  %2695 = xor i32 %2691, %2694
  %2696 = trunc i32 %2695 to i8
  store i8 %2696, ptr %8, align 1, !tbaa !9
  %2697 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2698 = load i8, ptr %2697, align 16, !tbaa !9
  %2699 = zext i8 %2698 to i32
  %2700 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %2701 = load i8, ptr %2700, align 1, !tbaa !9
  %2702 = zext i8 %2701 to i32
  %2703 = xor i32 %2699, %2702
  %2704 = trunc i32 %2703 to i8
  %2705 = call zeroext i8 @mul2(i8 noundef zeroext %2704)
  %2706 = zext i8 %2705 to i32
  %2707 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2708 = load i8, ptr %2707, align 16, !tbaa !9
  %2709 = zext i8 %2708 to i32
  %2710 = xor i32 %2706, %2709
  %2711 = load i8, ptr %8, align 1, !tbaa !9
  %2712 = zext i8 %2711 to i32
  %2713 = xor i32 %2710, %2712
  %2714 = trunc i32 %2713 to i8
  %2715 = load ptr, ptr %6, align 8, !tbaa !5
  %2716 = getelementptr inbounds i8, ptr %2715, i64 0
  store i8 %2714, ptr %2716, align 1, !tbaa !9
  %2717 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %2718 = load i8, ptr %2717, align 1, !tbaa !9
  %2719 = zext i8 %2718 to i32
  %2720 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %2721 = load i8, ptr %2720, align 2, !tbaa !9
  %2722 = zext i8 %2721 to i32
  %2723 = xor i32 %2719, %2722
  %2724 = trunc i32 %2723 to i8
  %2725 = call zeroext i8 @mul2(i8 noundef zeroext %2724)
  %2726 = zext i8 %2725 to i32
  %2727 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %2728 = load i8, ptr %2727, align 1, !tbaa !9
  %2729 = zext i8 %2728 to i32
  %2730 = xor i32 %2726, %2729
  %2731 = load i8, ptr %8, align 1, !tbaa !9
  %2732 = zext i8 %2731 to i32
  %2733 = xor i32 %2730, %2732
  %2734 = trunc i32 %2733 to i8
  %2735 = load ptr, ptr %6, align 8, !tbaa !5
  %2736 = getelementptr inbounds i8, ptr %2735, i64 1
  store i8 %2734, ptr %2736, align 1, !tbaa !9
  %2737 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %2738 = load i8, ptr %2737, align 2, !tbaa !9
  %2739 = zext i8 %2738 to i32
  %2740 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %2741 = load i8, ptr %2740, align 1, !tbaa !9
  %2742 = zext i8 %2741 to i32
  %2743 = xor i32 %2739, %2742
  %2744 = trunc i32 %2743 to i8
  %2745 = call zeroext i8 @mul2(i8 noundef zeroext %2744)
  %2746 = zext i8 %2745 to i32
  %2747 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %2748 = load i8, ptr %2747, align 2, !tbaa !9
  %2749 = zext i8 %2748 to i32
  %2750 = xor i32 %2746, %2749
  %2751 = load i8, ptr %8, align 1, !tbaa !9
  %2752 = zext i8 %2751 to i32
  %2753 = xor i32 %2750, %2752
  %2754 = trunc i32 %2753 to i8
  %2755 = load ptr, ptr %6, align 8, !tbaa !5
  %2756 = getelementptr inbounds i8, ptr %2755, i64 2
  store i8 %2754, ptr %2756, align 1, !tbaa !9
  %2757 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %2758 = load i8, ptr %2757, align 1, !tbaa !9
  %2759 = zext i8 %2758 to i32
  %2760 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %2761 = load i8, ptr %2760, align 16, !tbaa !9
  %2762 = zext i8 %2761 to i32
  %2763 = xor i32 %2759, %2762
  %2764 = trunc i32 %2763 to i8
  %2765 = call zeroext i8 @mul2(i8 noundef zeroext %2764)
  %2766 = zext i8 %2765 to i32
  %2767 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %2768 = load i8, ptr %2767, align 1, !tbaa !9
  %2769 = zext i8 %2768 to i32
  %2770 = xor i32 %2766, %2769
  %2771 = load i8, ptr %8, align 1, !tbaa !9
  %2772 = zext i8 %2771 to i32
  %2773 = xor i32 %2770, %2772
  %2774 = trunc i32 %2773 to i8
  %2775 = load ptr, ptr %6, align 8, !tbaa !5
  %2776 = getelementptr inbounds i8, ptr %2775, i64 3
  store i8 %2774, ptr %2776, align 1, !tbaa !9
  %2777 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %2778 = load i8, ptr %2777, align 4, !tbaa !9
  %2779 = zext i8 %2778 to i32
  %2780 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %2781 = load i8, ptr %2780, align 1, !tbaa !9
  %2782 = zext i8 %2781 to i32
  %2783 = xor i32 %2779, %2782
  %2784 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %2785 = load i8, ptr %2784, align 2, !tbaa !9
  %2786 = zext i8 %2785 to i32
  %2787 = xor i32 %2783, %2786
  %2788 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %2789 = load i8, ptr %2788, align 1, !tbaa !9
  %2790 = zext i8 %2789 to i32
  %2791 = xor i32 %2787, %2790
  %2792 = trunc i32 %2791 to i8
  store i8 %2792, ptr %8, align 1, !tbaa !9
  %2793 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %2794 = load i8, ptr %2793, align 4, !tbaa !9
  %2795 = zext i8 %2794 to i32
  %2796 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %2797 = load i8, ptr %2796, align 1, !tbaa !9
  %2798 = zext i8 %2797 to i32
  %2799 = xor i32 %2795, %2798
  %2800 = trunc i32 %2799 to i8
  %2801 = call zeroext i8 @mul2(i8 noundef zeroext %2800)
  %2802 = zext i8 %2801 to i32
  %2803 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %2804 = load i8, ptr %2803, align 4, !tbaa !9
  %2805 = zext i8 %2804 to i32
  %2806 = xor i32 %2802, %2805
  %2807 = load i8, ptr %8, align 1, !tbaa !9
  %2808 = zext i8 %2807 to i32
  %2809 = xor i32 %2806, %2808
  %2810 = trunc i32 %2809 to i8
  %2811 = load ptr, ptr %6, align 8, !tbaa !5
  %2812 = getelementptr inbounds i8, ptr %2811, i64 4
  store i8 %2810, ptr %2812, align 1, !tbaa !9
  %2813 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %2814 = load i8, ptr %2813, align 1, !tbaa !9
  %2815 = zext i8 %2814 to i32
  %2816 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %2817 = load i8, ptr %2816, align 2, !tbaa !9
  %2818 = zext i8 %2817 to i32
  %2819 = xor i32 %2815, %2818
  %2820 = trunc i32 %2819 to i8
  %2821 = call zeroext i8 @mul2(i8 noundef zeroext %2820)
  %2822 = zext i8 %2821 to i32
  %2823 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %2824 = load i8, ptr %2823, align 1, !tbaa !9
  %2825 = zext i8 %2824 to i32
  %2826 = xor i32 %2822, %2825
  %2827 = load i8, ptr %8, align 1, !tbaa !9
  %2828 = zext i8 %2827 to i32
  %2829 = xor i32 %2826, %2828
  %2830 = trunc i32 %2829 to i8
  %2831 = load ptr, ptr %6, align 8, !tbaa !5
  %2832 = getelementptr inbounds i8, ptr %2831, i64 5
  store i8 %2830, ptr %2832, align 1, !tbaa !9
  %2833 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %2834 = load i8, ptr %2833, align 2, !tbaa !9
  %2835 = zext i8 %2834 to i32
  %2836 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %2837 = load i8, ptr %2836, align 1, !tbaa !9
  %2838 = zext i8 %2837 to i32
  %2839 = xor i32 %2835, %2838
  %2840 = trunc i32 %2839 to i8
  %2841 = call zeroext i8 @mul2(i8 noundef zeroext %2840)
  %2842 = zext i8 %2841 to i32
  %2843 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %2844 = load i8, ptr %2843, align 2, !tbaa !9
  %2845 = zext i8 %2844 to i32
  %2846 = xor i32 %2842, %2845
  %2847 = load i8, ptr %8, align 1, !tbaa !9
  %2848 = zext i8 %2847 to i32
  %2849 = xor i32 %2846, %2848
  %2850 = trunc i32 %2849 to i8
  %2851 = load ptr, ptr %6, align 8, !tbaa !5
  %2852 = getelementptr inbounds i8, ptr %2851, i64 6
  store i8 %2850, ptr %2852, align 1, !tbaa !9
  %2853 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %2854 = load i8, ptr %2853, align 1, !tbaa !9
  %2855 = zext i8 %2854 to i32
  %2856 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %2857 = load i8, ptr %2856, align 4, !tbaa !9
  %2858 = zext i8 %2857 to i32
  %2859 = xor i32 %2855, %2858
  %2860 = trunc i32 %2859 to i8
  %2861 = call zeroext i8 @mul2(i8 noundef zeroext %2860)
  %2862 = zext i8 %2861 to i32
  %2863 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %2864 = load i8, ptr %2863, align 1, !tbaa !9
  %2865 = zext i8 %2864 to i32
  %2866 = xor i32 %2862, %2865
  %2867 = load i8, ptr %8, align 1, !tbaa !9
  %2868 = zext i8 %2867 to i32
  %2869 = xor i32 %2866, %2868
  %2870 = trunc i32 %2869 to i8
  %2871 = load ptr, ptr %6, align 8, !tbaa !5
  %2872 = getelementptr inbounds i8, ptr %2871, i64 7
  store i8 %2870, ptr %2872, align 1, !tbaa !9
  %2873 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %2874 = load i8, ptr %2873, align 8, !tbaa !9
  %2875 = zext i8 %2874 to i32
  %2876 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %2877 = load i8, ptr %2876, align 1, !tbaa !9
  %2878 = zext i8 %2877 to i32
  %2879 = xor i32 %2875, %2878
  %2880 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %2881 = load i8, ptr %2880, align 2, !tbaa !9
  %2882 = zext i8 %2881 to i32
  %2883 = xor i32 %2879, %2882
  %2884 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %2885 = load i8, ptr %2884, align 1, !tbaa !9
  %2886 = zext i8 %2885 to i32
  %2887 = xor i32 %2883, %2886
  %2888 = trunc i32 %2887 to i8
  store i8 %2888, ptr %8, align 1, !tbaa !9
  %2889 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %2890 = load i8, ptr %2889, align 8, !tbaa !9
  %2891 = zext i8 %2890 to i32
  %2892 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %2893 = load i8, ptr %2892, align 1, !tbaa !9
  %2894 = zext i8 %2893 to i32
  %2895 = xor i32 %2891, %2894
  %2896 = trunc i32 %2895 to i8
  %2897 = call zeroext i8 @mul2(i8 noundef zeroext %2896)
  %2898 = zext i8 %2897 to i32
  %2899 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %2900 = load i8, ptr %2899, align 8, !tbaa !9
  %2901 = zext i8 %2900 to i32
  %2902 = xor i32 %2898, %2901
  %2903 = load i8, ptr %8, align 1, !tbaa !9
  %2904 = zext i8 %2903 to i32
  %2905 = xor i32 %2902, %2904
  %2906 = trunc i32 %2905 to i8
  %2907 = load ptr, ptr %6, align 8, !tbaa !5
  %2908 = getelementptr inbounds i8, ptr %2907, i64 8
  store i8 %2906, ptr %2908, align 1, !tbaa !9
  %2909 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %2910 = load i8, ptr %2909, align 1, !tbaa !9
  %2911 = zext i8 %2910 to i32
  %2912 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %2913 = load i8, ptr %2912, align 2, !tbaa !9
  %2914 = zext i8 %2913 to i32
  %2915 = xor i32 %2911, %2914
  %2916 = trunc i32 %2915 to i8
  %2917 = call zeroext i8 @mul2(i8 noundef zeroext %2916)
  %2918 = zext i8 %2917 to i32
  %2919 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %2920 = load i8, ptr %2919, align 1, !tbaa !9
  %2921 = zext i8 %2920 to i32
  %2922 = xor i32 %2918, %2921
  %2923 = load i8, ptr %8, align 1, !tbaa !9
  %2924 = zext i8 %2923 to i32
  %2925 = xor i32 %2922, %2924
  %2926 = trunc i32 %2925 to i8
  %2927 = load ptr, ptr %6, align 8, !tbaa !5
  %2928 = getelementptr inbounds i8, ptr %2927, i64 9
  store i8 %2926, ptr %2928, align 1, !tbaa !9
  %2929 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %2930 = load i8, ptr %2929, align 2, !tbaa !9
  %2931 = zext i8 %2930 to i32
  %2932 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %2933 = load i8, ptr %2932, align 1, !tbaa !9
  %2934 = zext i8 %2933 to i32
  %2935 = xor i32 %2931, %2934
  %2936 = trunc i32 %2935 to i8
  %2937 = call zeroext i8 @mul2(i8 noundef zeroext %2936)
  %2938 = zext i8 %2937 to i32
  %2939 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %2940 = load i8, ptr %2939, align 2, !tbaa !9
  %2941 = zext i8 %2940 to i32
  %2942 = xor i32 %2938, %2941
  %2943 = load i8, ptr %8, align 1, !tbaa !9
  %2944 = zext i8 %2943 to i32
  %2945 = xor i32 %2942, %2944
  %2946 = trunc i32 %2945 to i8
  %2947 = load ptr, ptr %6, align 8, !tbaa !5
  %2948 = getelementptr inbounds i8, ptr %2947, i64 10
  store i8 %2946, ptr %2948, align 1, !tbaa !9
  %2949 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %2950 = load i8, ptr %2949, align 1, !tbaa !9
  %2951 = zext i8 %2950 to i32
  %2952 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %2953 = load i8, ptr %2952, align 8, !tbaa !9
  %2954 = zext i8 %2953 to i32
  %2955 = xor i32 %2951, %2954
  %2956 = trunc i32 %2955 to i8
  %2957 = call zeroext i8 @mul2(i8 noundef zeroext %2956)
  %2958 = zext i8 %2957 to i32
  %2959 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %2960 = load i8, ptr %2959, align 1, !tbaa !9
  %2961 = zext i8 %2960 to i32
  %2962 = xor i32 %2958, %2961
  %2963 = load i8, ptr %8, align 1, !tbaa !9
  %2964 = zext i8 %2963 to i32
  %2965 = xor i32 %2962, %2964
  %2966 = trunc i32 %2965 to i8
  %2967 = load ptr, ptr %6, align 8, !tbaa !5
  %2968 = getelementptr inbounds i8, ptr %2967, i64 11
  store i8 %2966, ptr %2968, align 1, !tbaa !9
  %2969 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %2970 = load i8, ptr %2969, align 4, !tbaa !9
  %2971 = zext i8 %2970 to i32
  %2972 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %2973 = load i8, ptr %2972, align 1, !tbaa !9
  %2974 = zext i8 %2973 to i32
  %2975 = xor i32 %2971, %2974
  %2976 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %2977 = load i8, ptr %2976, align 2, !tbaa !9
  %2978 = zext i8 %2977 to i32
  %2979 = xor i32 %2975, %2978
  %2980 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %2981 = load i8, ptr %2980, align 1, !tbaa !9
  %2982 = zext i8 %2981 to i32
  %2983 = xor i32 %2979, %2982
  %2984 = trunc i32 %2983 to i8
  store i8 %2984, ptr %8, align 1, !tbaa !9
  %2985 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %2986 = load i8, ptr %2985, align 4, !tbaa !9
  %2987 = zext i8 %2986 to i32
  %2988 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %2989 = load i8, ptr %2988, align 1, !tbaa !9
  %2990 = zext i8 %2989 to i32
  %2991 = xor i32 %2987, %2990
  %2992 = trunc i32 %2991 to i8
  %2993 = call zeroext i8 @mul2(i8 noundef zeroext %2992)
  %2994 = zext i8 %2993 to i32
  %2995 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %2996 = load i8, ptr %2995, align 4, !tbaa !9
  %2997 = zext i8 %2996 to i32
  %2998 = xor i32 %2994, %2997
  %2999 = load i8, ptr %8, align 1, !tbaa !9
  %3000 = zext i8 %2999 to i32
  %3001 = xor i32 %2998, %3000
  %3002 = trunc i32 %3001 to i8
  %3003 = load ptr, ptr %6, align 8, !tbaa !5
  %3004 = getelementptr inbounds i8, ptr %3003, i64 12
  store i8 %3002, ptr %3004, align 1, !tbaa !9
  %3005 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %3006 = load i8, ptr %3005, align 1, !tbaa !9
  %3007 = zext i8 %3006 to i32
  %3008 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %3009 = load i8, ptr %3008, align 2, !tbaa !9
  %3010 = zext i8 %3009 to i32
  %3011 = xor i32 %3007, %3010
  %3012 = trunc i32 %3011 to i8
  %3013 = call zeroext i8 @mul2(i8 noundef zeroext %3012)
  %3014 = zext i8 %3013 to i32
  %3015 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %3016 = load i8, ptr %3015, align 1, !tbaa !9
  %3017 = zext i8 %3016 to i32
  %3018 = xor i32 %3014, %3017
  %3019 = load i8, ptr %8, align 1, !tbaa !9
  %3020 = zext i8 %3019 to i32
  %3021 = xor i32 %3018, %3020
  %3022 = trunc i32 %3021 to i8
  %3023 = load ptr, ptr %6, align 8, !tbaa !5
  %3024 = getelementptr inbounds i8, ptr %3023, i64 13
  store i8 %3022, ptr %3024, align 1, !tbaa !9
  %3025 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %3026 = load i8, ptr %3025, align 2, !tbaa !9
  %3027 = zext i8 %3026 to i32
  %3028 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %3029 = load i8, ptr %3028, align 1, !tbaa !9
  %3030 = zext i8 %3029 to i32
  %3031 = xor i32 %3027, %3030
  %3032 = trunc i32 %3031 to i8
  %3033 = call zeroext i8 @mul2(i8 noundef zeroext %3032)
  %3034 = zext i8 %3033 to i32
  %3035 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %3036 = load i8, ptr %3035, align 2, !tbaa !9
  %3037 = zext i8 %3036 to i32
  %3038 = xor i32 %3034, %3037
  %3039 = load i8, ptr %8, align 1, !tbaa !9
  %3040 = zext i8 %3039 to i32
  %3041 = xor i32 %3038, %3040
  %3042 = trunc i32 %3041 to i8
  %3043 = load ptr, ptr %6, align 8, !tbaa !5
  %3044 = getelementptr inbounds i8, ptr %3043, i64 14
  store i8 %3042, ptr %3044, align 1, !tbaa !9
  %3045 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %3046 = load i8, ptr %3045, align 1, !tbaa !9
  %3047 = zext i8 %3046 to i32
  %3048 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %3049 = load i8, ptr %3048, align 4, !tbaa !9
  %3050 = zext i8 %3049 to i32
  %3051 = xor i32 %3047, %3050
  %3052 = trunc i32 %3051 to i8
  %3053 = call zeroext i8 @mul2(i8 noundef zeroext %3052)
  %3054 = zext i8 %3053 to i32
  %3055 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %3056 = load i8, ptr %3055, align 1, !tbaa !9
  %3057 = zext i8 %3056 to i32
  %3058 = xor i32 %3054, %3057
  %3059 = load i8, ptr %8, align 1, !tbaa !9
  %3060 = zext i8 %3059 to i32
  %3061 = xor i32 %3058, %3060
  %3062 = trunc i32 %3061 to i8
  %3063 = load ptr, ptr %6, align 8, !tbaa !5
  %3064 = getelementptr inbounds i8, ptr %3063, i64 15
  store i8 %3062, ptr %3064, align 1, !tbaa !9
  %3065 = load ptr, ptr %6, align 8, !tbaa !5
  %3066 = load i8, ptr %3065, align 1, !tbaa !9
  %3067 = zext i8 %3066 to i32
  %3068 = load ptr, ptr %4, align 8, !tbaa !5
  %3069 = getelementptr inbounds i8, ptr %3068, i32 1
  store ptr %3069, ptr %4, align 8, !tbaa !5
  %3070 = load i8, ptr %3068, align 1, !tbaa !9
  %3071 = zext i8 %3070 to i32
  %3072 = xor i32 %3067, %3071
  %3073 = trunc i32 %3072 to i8
  %3074 = load ptr, ptr %6, align 8, !tbaa !5
  store i8 %3073, ptr %3074, align 1, !tbaa !9
  %3075 = load ptr, ptr %6, align 8, !tbaa !5
  %3076 = getelementptr inbounds i8, ptr %3075, i64 1
  %3077 = load i8, ptr %3076, align 1, !tbaa !9
  %3078 = zext i8 %3077 to i32
  %3079 = load ptr, ptr %4, align 8, !tbaa !5
  %3080 = getelementptr inbounds i8, ptr %3079, i32 1
  store ptr %3080, ptr %4, align 8, !tbaa !5
  %3081 = load i8, ptr %3079, align 1, !tbaa !9
  %3082 = zext i8 %3081 to i32
  %3083 = xor i32 %3078, %3082
  %3084 = trunc i32 %3083 to i8
  %3085 = load ptr, ptr %6, align 8, !tbaa !5
  %3086 = getelementptr inbounds i8, ptr %3085, i64 1
  store i8 %3084, ptr %3086, align 1, !tbaa !9
  %3087 = load ptr, ptr %6, align 8, !tbaa !5
  %3088 = getelementptr inbounds i8, ptr %3087, i64 2
  %3089 = load i8, ptr %3088, align 1, !tbaa !9
  %3090 = zext i8 %3089 to i32
  %3091 = load ptr, ptr %4, align 8, !tbaa !5
  %3092 = getelementptr inbounds i8, ptr %3091, i32 1
  store ptr %3092, ptr %4, align 8, !tbaa !5
  %3093 = load i8, ptr %3091, align 1, !tbaa !9
  %3094 = zext i8 %3093 to i32
  %3095 = xor i32 %3090, %3094
  %3096 = trunc i32 %3095 to i8
  %3097 = load ptr, ptr %6, align 8, !tbaa !5
  %3098 = getelementptr inbounds i8, ptr %3097, i64 2
  store i8 %3096, ptr %3098, align 1, !tbaa !9
  %3099 = load ptr, ptr %6, align 8, !tbaa !5
  %3100 = getelementptr inbounds i8, ptr %3099, i64 3
  %3101 = load i8, ptr %3100, align 1, !tbaa !9
  %3102 = zext i8 %3101 to i32
  %3103 = load ptr, ptr %4, align 8, !tbaa !5
  %3104 = getelementptr inbounds i8, ptr %3103, i32 1
  store ptr %3104, ptr %4, align 8, !tbaa !5
  %3105 = load i8, ptr %3103, align 1, !tbaa !9
  %3106 = zext i8 %3105 to i32
  %3107 = xor i32 %3102, %3106
  %3108 = trunc i32 %3107 to i8
  %3109 = load ptr, ptr %6, align 8, !tbaa !5
  %3110 = getelementptr inbounds i8, ptr %3109, i64 3
  store i8 %3108, ptr %3110, align 1, !tbaa !9
  %3111 = load ptr, ptr %6, align 8, !tbaa !5
  %3112 = getelementptr inbounds i8, ptr %3111, i64 4
  %3113 = load i8, ptr %3112, align 1, !tbaa !9
  %3114 = zext i8 %3113 to i32
  %3115 = load ptr, ptr %4, align 8, !tbaa !5
  %3116 = getelementptr inbounds i8, ptr %3115, i32 1
  store ptr %3116, ptr %4, align 8, !tbaa !5
  %3117 = load i8, ptr %3115, align 1, !tbaa !9
  %3118 = zext i8 %3117 to i32
  %3119 = xor i32 %3114, %3118
  %3120 = trunc i32 %3119 to i8
  %3121 = load ptr, ptr %6, align 8, !tbaa !5
  %3122 = getelementptr inbounds i8, ptr %3121, i64 4
  store i8 %3120, ptr %3122, align 1, !tbaa !9
  %3123 = load ptr, ptr %6, align 8, !tbaa !5
  %3124 = getelementptr inbounds i8, ptr %3123, i64 5
  %3125 = load i8, ptr %3124, align 1, !tbaa !9
  %3126 = zext i8 %3125 to i32
  %3127 = load ptr, ptr %4, align 8, !tbaa !5
  %3128 = getelementptr inbounds i8, ptr %3127, i32 1
  store ptr %3128, ptr %4, align 8, !tbaa !5
  %3129 = load i8, ptr %3127, align 1, !tbaa !9
  %3130 = zext i8 %3129 to i32
  %3131 = xor i32 %3126, %3130
  %3132 = trunc i32 %3131 to i8
  %3133 = load ptr, ptr %6, align 8, !tbaa !5
  %3134 = getelementptr inbounds i8, ptr %3133, i64 5
  store i8 %3132, ptr %3134, align 1, !tbaa !9
  %3135 = load ptr, ptr %6, align 8, !tbaa !5
  %3136 = getelementptr inbounds i8, ptr %3135, i64 6
  %3137 = load i8, ptr %3136, align 1, !tbaa !9
  %3138 = zext i8 %3137 to i32
  %3139 = load ptr, ptr %4, align 8, !tbaa !5
  %3140 = getelementptr inbounds i8, ptr %3139, i32 1
  store ptr %3140, ptr %4, align 8, !tbaa !5
  %3141 = load i8, ptr %3139, align 1, !tbaa !9
  %3142 = zext i8 %3141 to i32
  %3143 = xor i32 %3138, %3142
  %3144 = trunc i32 %3143 to i8
  %3145 = load ptr, ptr %6, align 8, !tbaa !5
  %3146 = getelementptr inbounds i8, ptr %3145, i64 6
  store i8 %3144, ptr %3146, align 1, !tbaa !9
  %3147 = load ptr, ptr %6, align 8, !tbaa !5
  %3148 = getelementptr inbounds i8, ptr %3147, i64 7
  %3149 = load i8, ptr %3148, align 1, !tbaa !9
  %3150 = zext i8 %3149 to i32
  %3151 = load ptr, ptr %4, align 8, !tbaa !5
  %3152 = getelementptr inbounds i8, ptr %3151, i32 1
  store ptr %3152, ptr %4, align 8, !tbaa !5
  %3153 = load i8, ptr %3151, align 1, !tbaa !9
  %3154 = zext i8 %3153 to i32
  %3155 = xor i32 %3150, %3154
  %3156 = trunc i32 %3155 to i8
  %3157 = load ptr, ptr %6, align 8, !tbaa !5
  %3158 = getelementptr inbounds i8, ptr %3157, i64 7
  store i8 %3156, ptr %3158, align 1, !tbaa !9
  %3159 = load ptr, ptr %6, align 8, !tbaa !5
  %3160 = getelementptr inbounds i8, ptr %3159, i64 8
  %3161 = load i8, ptr %3160, align 1, !tbaa !9
  %3162 = zext i8 %3161 to i32
  %3163 = load ptr, ptr %4, align 8, !tbaa !5
  %3164 = getelementptr inbounds i8, ptr %3163, i32 1
  store ptr %3164, ptr %4, align 8, !tbaa !5
  %3165 = load i8, ptr %3163, align 1, !tbaa !9
  %3166 = zext i8 %3165 to i32
  %3167 = xor i32 %3162, %3166
  %3168 = trunc i32 %3167 to i8
  %3169 = load ptr, ptr %6, align 8, !tbaa !5
  %3170 = getelementptr inbounds i8, ptr %3169, i64 8
  store i8 %3168, ptr %3170, align 1, !tbaa !9
  %3171 = load ptr, ptr %6, align 8, !tbaa !5
  %3172 = getelementptr inbounds i8, ptr %3171, i64 9
  %3173 = load i8, ptr %3172, align 1, !tbaa !9
  %3174 = zext i8 %3173 to i32
  %3175 = load ptr, ptr %4, align 8, !tbaa !5
  %3176 = getelementptr inbounds i8, ptr %3175, i32 1
  store ptr %3176, ptr %4, align 8, !tbaa !5
  %3177 = load i8, ptr %3175, align 1, !tbaa !9
  %3178 = zext i8 %3177 to i32
  %3179 = xor i32 %3174, %3178
  %3180 = trunc i32 %3179 to i8
  %3181 = load ptr, ptr %6, align 8, !tbaa !5
  %3182 = getelementptr inbounds i8, ptr %3181, i64 9
  store i8 %3180, ptr %3182, align 1, !tbaa !9
  %3183 = load ptr, ptr %6, align 8, !tbaa !5
  %3184 = getelementptr inbounds i8, ptr %3183, i64 10
  %3185 = load i8, ptr %3184, align 1, !tbaa !9
  %3186 = zext i8 %3185 to i32
  %3187 = load ptr, ptr %4, align 8, !tbaa !5
  %3188 = getelementptr inbounds i8, ptr %3187, i32 1
  store ptr %3188, ptr %4, align 8, !tbaa !5
  %3189 = load i8, ptr %3187, align 1, !tbaa !9
  %3190 = zext i8 %3189 to i32
  %3191 = xor i32 %3186, %3190
  %3192 = trunc i32 %3191 to i8
  %3193 = load ptr, ptr %6, align 8, !tbaa !5
  %3194 = getelementptr inbounds i8, ptr %3193, i64 10
  store i8 %3192, ptr %3194, align 1, !tbaa !9
  %3195 = load ptr, ptr %6, align 8, !tbaa !5
  %3196 = getelementptr inbounds i8, ptr %3195, i64 11
  %3197 = load i8, ptr %3196, align 1, !tbaa !9
  %3198 = zext i8 %3197 to i32
  %3199 = load ptr, ptr %4, align 8, !tbaa !5
  %3200 = getelementptr inbounds i8, ptr %3199, i32 1
  store ptr %3200, ptr %4, align 8, !tbaa !5
  %3201 = load i8, ptr %3199, align 1, !tbaa !9
  %3202 = zext i8 %3201 to i32
  %3203 = xor i32 %3198, %3202
  %3204 = trunc i32 %3203 to i8
  %3205 = load ptr, ptr %6, align 8, !tbaa !5
  %3206 = getelementptr inbounds i8, ptr %3205, i64 11
  store i8 %3204, ptr %3206, align 1, !tbaa !9
  %3207 = load ptr, ptr %6, align 8, !tbaa !5
  %3208 = getelementptr inbounds i8, ptr %3207, i64 12
  %3209 = load i8, ptr %3208, align 1, !tbaa !9
  %3210 = zext i8 %3209 to i32
  %3211 = load ptr, ptr %4, align 8, !tbaa !5
  %3212 = getelementptr inbounds i8, ptr %3211, i32 1
  store ptr %3212, ptr %4, align 8, !tbaa !5
  %3213 = load i8, ptr %3211, align 1, !tbaa !9
  %3214 = zext i8 %3213 to i32
  %3215 = xor i32 %3210, %3214
  %3216 = trunc i32 %3215 to i8
  %3217 = load ptr, ptr %6, align 8, !tbaa !5
  %3218 = getelementptr inbounds i8, ptr %3217, i64 12
  store i8 %3216, ptr %3218, align 1, !tbaa !9
  %3219 = load ptr, ptr %6, align 8, !tbaa !5
  %3220 = getelementptr inbounds i8, ptr %3219, i64 13
  %3221 = load i8, ptr %3220, align 1, !tbaa !9
  %3222 = zext i8 %3221 to i32
  %3223 = load ptr, ptr %4, align 8, !tbaa !5
  %3224 = getelementptr inbounds i8, ptr %3223, i32 1
  store ptr %3224, ptr %4, align 8, !tbaa !5
  %3225 = load i8, ptr %3223, align 1, !tbaa !9
  %3226 = zext i8 %3225 to i32
  %3227 = xor i32 %3222, %3226
  %3228 = trunc i32 %3227 to i8
  %3229 = load ptr, ptr %6, align 8, !tbaa !5
  %3230 = getelementptr inbounds i8, ptr %3229, i64 13
  store i8 %3228, ptr %3230, align 1, !tbaa !9
  %3231 = load ptr, ptr %6, align 8, !tbaa !5
  %3232 = getelementptr inbounds i8, ptr %3231, i64 14
  %3233 = load i8, ptr %3232, align 1, !tbaa !9
  %3234 = zext i8 %3233 to i32
  %3235 = load ptr, ptr %4, align 8, !tbaa !5
  %3236 = getelementptr inbounds i8, ptr %3235, i32 1
  store ptr %3236, ptr %4, align 8, !tbaa !5
  %3237 = load i8, ptr %3235, align 1, !tbaa !9
  %3238 = zext i8 %3237 to i32
  %3239 = xor i32 %3234, %3238
  %3240 = trunc i32 %3239 to i8
  %3241 = load ptr, ptr %6, align 8, !tbaa !5
  %3242 = getelementptr inbounds i8, ptr %3241, i64 14
  store i8 %3240, ptr %3242, align 1, !tbaa !9
  %3243 = load ptr, ptr %6, align 8, !tbaa !5
  %3244 = getelementptr inbounds i8, ptr %3243, i64 15
  %3245 = load i8, ptr %3244, align 1, !tbaa !9
  %3246 = zext i8 %3245 to i32
  %3247 = load ptr, ptr %4, align 8, !tbaa !5
  %3248 = getelementptr inbounds i8, ptr %3247, i32 1
  store ptr %3248, ptr %4, align 8, !tbaa !5
  %3249 = load i8, ptr %3247, align 1, !tbaa !9
  %3250 = zext i8 %3249 to i32
  %3251 = xor i32 %3246, %3250
  %3252 = trunc i32 %3251 to i8
  %3253 = load ptr, ptr %6, align 8, !tbaa !5
  %3254 = getelementptr inbounds i8, ptr %3253, i64 15
  store i8 %3252, ptr %3254, align 1, !tbaa !9
  %3255 = load ptr, ptr %6, align 8, !tbaa !5
  %3256 = load i8, ptr %3255, align 1, !tbaa !9
  %3257 = zext i8 %3256 to i64
  %3258 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3257
  %3259 = load i8, ptr %3258, align 1, !tbaa !9
  %3260 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  store i8 %3259, ptr %3260, align 16, !tbaa !9
  %3261 = load ptr, ptr %6, align 8, !tbaa !5
  %3262 = getelementptr inbounds i8, ptr %3261, i64 1
  %3263 = load i8, ptr %3262, align 1, !tbaa !9
  %3264 = zext i8 %3263 to i64
  %3265 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3264
  %3266 = load i8, ptr %3265, align 1, !tbaa !9
  %3267 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3268 = getelementptr inbounds i8, ptr %3267, i64 1
  store i8 %3266, ptr %3268, align 1, !tbaa !9
  %3269 = load ptr, ptr %6, align 8, !tbaa !5
  %3270 = getelementptr inbounds i8, ptr %3269, i64 2
  %3271 = load i8, ptr %3270, align 1, !tbaa !9
  %3272 = zext i8 %3271 to i64
  %3273 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3272
  %3274 = load i8, ptr %3273, align 1, !tbaa !9
  %3275 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3276 = getelementptr inbounds i8, ptr %3275, i64 2
  store i8 %3274, ptr %3276, align 1, !tbaa !9
  %3277 = load ptr, ptr %6, align 8, !tbaa !5
  %3278 = getelementptr inbounds i8, ptr %3277, i64 3
  %3279 = load i8, ptr %3278, align 1, !tbaa !9
  %3280 = zext i8 %3279 to i64
  %3281 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3280
  %3282 = load i8, ptr %3281, align 1, !tbaa !9
  %3283 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3284 = getelementptr inbounds i8, ptr %3283, i64 3
  store i8 %3282, ptr %3284, align 1, !tbaa !9
  %3285 = load ptr, ptr %6, align 8, !tbaa !5
  %3286 = getelementptr inbounds i8, ptr %3285, i64 4
  %3287 = load i8, ptr %3286, align 1, !tbaa !9
  %3288 = zext i8 %3287 to i64
  %3289 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3288
  %3290 = load i8, ptr %3289, align 1, !tbaa !9
  %3291 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3292 = getelementptr inbounds i8, ptr %3291, i64 4
  store i8 %3290, ptr %3292, align 1, !tbaa !9
  %3293 = load ptr, ptr %6, align 8, !tbaa !5
  %3294 = getelementptr inbounds i8, ptr %3293, i64 5
  %3295 = load i8, ptr %3294, align 1, !tbaa !9
  %3296 = zext i8 %3295 to i64
  %3297 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3296
  %3298 = load i8, ptr %3297, align 1, !tbaa !9
  %3299 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3300 = getelementptr inbounds i8, ptr %3299, i64 5
  store i8 %3298, ptr %3300, align 1, !tbaa !9
  %3301 = load ptr, ptr %6, align 8, !tbaa !5
  %3302 = getelementptr inbounds i8, ptr %3301, i64 6
  %3303 = load i8, ptr %3302, align 1, !tbaa !9
  %3304 = zext i8 %3303 to i64
  %3305 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3304
  %3306 = load i8, ptr %3305, align 1, !tbaa !9
  %3307 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3308 = getelementptr inbounds i8, ptr %3307, i64 6
  store i8 %3306, ptr %3308, align 1, !tbaa !9
  %3309 = load ptr, ptr %6, align 8, !tbaa !5
  %3310 = getelementptr inbounds i8, ptr %3309, i64 7
  %3311 = load i8, ptr %3310, align 1, !tbaa !9
  %3312 = zext i8 %3311 to i64
  %3313 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3312
  %3314 = load i8, ptr %3313, align 1, !tbaa !9
  %3315 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3316 = getelementptr inbounds i8, ptr %3315, i64 7
  store i8 %3314, ptr %3316, align 1, !tbaa !9
  %3317 = load ptr, ptr %6, align 8, !tbaa !5
  %3318 = getelementptr inbounds i8, ptr %3317, i64 8
  %3319 = load i8, ptr %3318, align 1, !tbaa !9
  %3320 = zext i8 %3319 to i64
  %3321 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3320
  %3322 = load i8, ptr %3321, align 1, !tbaa !9
  %3323 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3324 = getelementptr inbounds i8, ptr %3323, i64 8
  store i8 %3322, ptr %3324, align 1, !tbaa !9
  %3325 = load ptr, ptr %6, align 8, !tbaa !5
  %3326 = getelementptr inbounds i8, ptr %3325, i64 9
  %3327 = load i8, ptr %3326, align 1, !tbaa !9
  %3328 = zext i8 %3327 to i64
  %3329 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3328
  %3330 = load i8, ptr %3329, align 1, !tbaa !9
  %3331 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3332 = getelementptr inbounds i8, ptr %3331, i64 9
  store i8 %3330, ptr %3332, align 1, !tbaa !9
  %3333 = load ptr, ptr %6, align 8, !tbaa !5
  %3334 = getelementptr inbounds i8, ptr %3333, i64 10
  %3335 = load i8, ptr %3334, align 1, !tbaa !9
  %3336 = zext i8 %3335 to i64
  %3337 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3336
  %3338 = load i8, ptr %3337, align 1, !tbaa !9
  %3339 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3340 = getelementptr inbounds i8, ptr %3339, i64 10
  store i8 %3338, ptr %3340, align 1, !tbaa !9
  %3341 = load ptr, ptr %6, align 8, !tbaa !5
  %3342 = getelementptr inbounds i8, ptr %3341, i64 11
  %3343 = load i8, ptr %3342, align 1, !tbaa !9
  %3344 = zext i8 %3343 to i64
  %3345 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3344
  %3346 = load i8, ptr %3345, align 1, !tbaa !9
  %3347 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3348 = getelementptr inbounds i8, ptr %3347, i64 11
  store i8 %3346, ptr %3348, align 1, !tbaa !9
  %3349 = load ptr, ptr %6, align 8, !tbaa !5
  %3350 = getelementptr inbounds i8, ptr %3349, i64 12
  %3351 = load i8, ptr %3350, align 1, !tbaa !9
  %3352 = zext i8 %3351 to i64
  %3353 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3352
  %3354 = load i8, ptr %3353, align 1, !tbaa !9
  %3355 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3356 = getelementptr inbounds i8, ptr %3355, i64 12
  store i8 %3354, ptr %3356, align 1, !tbaa !9
  %3357 = load ptr, ptr %6, align 8, !tbaa !5
  %3358 = getelementptr inbounds i8, ptr %3357, i64 13
  %3359 = load i8, ptr %3358, align 1, !tbaa !9
  %3360 = zext i8 %3359 to i64
  %3361 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3360
  %3362 = load i8, ptr %3361, align 1, !tbaa !9
  %3363 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3364 = getelementptr inbounds i8, ptr %3363, i64 13
  store i8 %3362, ptr %3364, align 1, !tbaa !9
  %3365 = load ptr, ptr %6, align 8, !tbaa !5
  %3366 = getelementptr inbounds i8, ptr %3365, i64 14
  %3367 = load i8, ptr %3366, align 1, !tbaa !9
  %3368 = zext i8 %3367 to i64
  %3369 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3368
  %3370 = load i8, ptr %3369, align 1, !tbaa !9
  %3371 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3372 = getelementptr inbounds i8, ptr %3371, i64 14
  store i8 %3370, ptr %3372, align 1, !tbaa !9
  %3373 = load ptr, ptr %6, align 8, !tbaa !5
  %3374 = getelementptr inbounds i8, ptr %3373, i64 15
  %3375 = load i8, ptr %3374, align 1, !tbaa !9
  %3376 = zext i8 %3375 to i64
  %3377 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %3376
  %3378 = load i8, ptr %3377, align 1, !tbaa !9
  %3379 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3380 = getelementptr inbounds i8, ptr %3379, i64 15
  store i8 %3378, ptr %3380, align 1, !tbaa !9
  %3381 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3382 = getelementptr inbounds i8, ptr %3381, i64 1
  %3383 = load i8, ptr %3382, align 1, !tbaa !9
  store i8 %3383, ptr %8, align 1, !tbaa !9
  %3384 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3385 = getelementptr inbounds i8, ptr %3384, i64 5
  %3386 = load i8, ptr %3385, align 1, !tbaa !9
  %3387 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3388 = getelementptr inbounds i8, ptr %3387, i64 1
  store i8 %3386, ptr %3388, align 1, !tbaa !9
  %3389 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3390 = getelementptr inbounds i8, ptr %3389, i64 9
  %3391 = load i8, ptr %3390, align 1, !tbaa !9
  %3392 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3393 = getelementptr inbounds i8, ptr %3392, i64 5
  store i8 %3391, ptr %3393, align 1, !tbaa !9
  %3394 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3395 = getelementptr inbounds i8, ptr %3394, i64 13
  %3396 = load i8, ptr %3395, align 1, !tbaa !9
  %3397 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3398 = getelementptr inbounds i8, ptr %3397, i64 9
  store i8 %3396, ptr %3398, align 1, !tbaa !9
  %3399 = load i8, ptr %8, align 1, !tbaa !9
  %3400 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3401 = getelementptr inbounds i8, ptr %3400, i64 13
  store i8 %3399, ptr %3401, align 1, !tbaa !9
  %3402 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3403 = getelementptr inbounds i8, ptr %3402, i64 2
  %3404 = load i8, ptr %3403, align 1, !tbaa !9
  store i8 %3404, ptr %8, align 1, !tbaa !9
  %3405 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3406 = getelementptr inbounds i8, ptr %3405, i64 10
  %3407 = load i8, ptr %3406, align 1, !tbaa !9
  %3408 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3409 = getelementptr inbounds i8, ptr %3408, i64 2
  store i8 %3407, ptr %3409, align 1, !tbaa !9
  %3410 = load i8, ptr %8, align 1, !tbaa !9
  %3411 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3412 = getelementptr inbounds i8, ptr %3411, i64 10
  store i8 %3410, ptr %3412, align 1, !tbaa !9
  %3413 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3414 = getelementptr inbounds i8, ptr %3413, i64 6
  %3415 = load i8, ptr %3414, align 1, !tbaa !9
  store i8 %3415, ptr %8, align 1, !tbaa !9
  %3416 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3417 = getelementptr inbounds i8, ptr %3416, i64 14
  %3418 = load i8, ptr %3417, align 1, !tbaa !9
  %3419 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3420 = getelementptr inbounds i8, ptr %3419, i64 6
  store i8 %3418, ptr %3420, align 1, !tbaa !9
  %3421 = load i8, ptr %8, align 1, !tbaa !9
  %3422 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3423 = getelementptr inbounds i8, ptr %3422, i64 14
  store i8 %3421, ptr %3423, align 1, !tbaa !9
  %3424 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3425 = getelementptr inbounds i8, ptr %3424, i64 15
  %3426 = load i8, ptr %3425, align 1, !tbaa !9
  store i8 %3426, ptr %8, align 1, !tbaa !9
  %3427 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3428 = getelementptr inbounds i8, ptr %3427, i64 11
  %3429 = load i8, ptr %3428, align 1, !tbaa !9
  %3430 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3431 = getelementptr inbounds i8, ptr %3430, i64 15
  store i8 %3429, ptr %3431, align 1, !tbaa !9
  %3432 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3433 = getelementptr inbounds i8, ptr %3432, i64 7
  %3434 = load i8, ptr %3433, align 1, !tbaa !9
  %3435 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3436 = getelementptr inbounds i8, ptr %3435, i64 11
  store i8 %3434, ptr %3436, align 1, !tbaa !9
  %3437 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3438 = getelementptr inbounds i8, ptr %3437, i64 3
  %3439 = load i8, ptr %3438, align 1, !tbaa !9
  %3440 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3441 = getelementptr inbounds i8, ptr %3440, i64 7
  store i8 %3439, ptr %3441, align 1, !tbaa !9
  %3442 = load i8, ptr %8, align 1, !tbaa !9
  %3443 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3444 = getelementptr inbounds i8, ptr %3443, i64 3
  store i8 %3442, ptr %3444, align 1, !tbaa !9
  %3445 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3446 = load i8, ptr %3445, align 16, !tbaa !9
  %3447 = zext i8 %3446 to i32
  %3448 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %3449 = load i8, ptr %3448, align 1, !tbaa !9
  %3450 = zext i8 %3449 to i32
  %3451 = xor i32 %3447, %3450
  %3452 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %3453 = load i8, ptr %3452, align 2, !tbaa !9
  %3454 = zext i8 %3453 to i32
  %3455 = xor i32 %3451, %3454
  %3456 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %3457 = load i8, ptr %3456, align 1, !tbaa !9
  %3458 = zext i8 %3457 to i32
  %3459 = xor i32 %3455, %3458
  %3460 = trunc i32 %3459 to i8
  store i8 %3460, ptr %8, align 1, !tbaa !9
  %3461 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3462 = load i8, ptr %3461, align 16, !tbaa !9
  %3463 = zext i8 %3462 to i32
  %3464 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %3465 = load i8, ptr %3464, align 1, !tbaa !9
  %3466 = zext i8 %3465 to i32
  %3467 = xor i32 %3463, %3466
  %3468 = trunc i32 %3467 to i8
  %3469 = call zeroext i8 @mul2(i8 noundef zeroext %3468)
  %3470 = zext i8 %3469 to i32
  %3471 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3472 = load i8, ptr %3471, align 16, !tbaa !9
  %3473 = zext i8 %3472 to i32
  %3474 = xor i32 %3470, %3473
  %3475 = load i8, ptr %8, align 1, !tbaa !9
  %3476 = zext i8 %3475 to i32
  %3477 = xor i32 %3474, %3476
  %3478 = trunc i32 %3477 to i8
  %3479 = load ptr, ptr %6, align 8, !tbaa !5
  %3480 = getelementptr inbounds i8, ptr %3479, i64 0
  store i8 %3478, ptr %3480, align 1, !tbaa !9
  %3481 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %3482 = load i8, ptr %3481, align 1, !tbaa !9
  %3483 = zext i8 %3482 to i32
  %3484 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %3485 = load i8, ptr %3484, align 2, !tbaa !9
  %3486 = zext i8 %3485 to i32
  %3487 = xor i32 %3483, %3486
  %3488 = trunc i32 %3487 to i8
  %3489 = call zeroext i8 @mul2(i8 noundef zeroext %3488)
  %3490 = zext i8 %3489 to i32
  %3491 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %3492 = load i8, ptr %3491, align 1, !tbaa !9
  %3493 = zext i8 %3492 to i32
  %3494 = xor i32 %3490, %3493
  %3495 = load i8, ptr %8, align 1, !tbaa !9
  %3496 = zext i8 %3495 to i32
  %3497 = xor i32 %3494, %3496
  %3498 = trunc i32 %3497 to i8
  %3499 = load ptr, ptr %6, align 8, !tbaa !5
  %3500 = getelementptr inbounds i8, ptr %3499, i64 1
  store i8 %3498, ptr %3500, align 1, !tbaa !9
  %3501 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %3502 = load i8, ptr %3501, align 2, !tbaa !9
  %3503 = zext i8 %3502 to i32
  %3504 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %3505 = load i8, ptr %3504, align 1, !tbaa !9
  %3506 = zext i8 %3505 to i32
  %3507 = xor i32 %3503, %3506
  %3508 = trunc i32 %3507 to i8
  %3509 = call zeroext i8 @mul2(i8 noundef zeroext %3508)
  %3510 = zext i8 %3509 to i32
  %3511 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %3512 = load i8, ptr %3511, align 2, !tbaa !9
  %3513 = zext i8 %3512 to i32
  %3514 = xor i32 %3510, %3513
  %3515 = load i8, ptr %8, align 1, !tbaa !9
  %3516 = zext i8 %3515 to i32
  %3517 = xor i32 %3514, %3516
  %3518 = trunc i32 %3517 to i8
  %3519 = load ptr, ptr %6, align 8, !tbaa !5
  %3520 = getelementptr inbounds i8, ptr %3519, i64 2
  store i8 %3518, ptr %3520, align 1, !tbaa !9
  %3521 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %3522 = load i8, ptr %3521, align 1, !tbaa !9
  %3523 = zext i8 %3522 to i32
  %3524 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %3525 = load i8, ptr %3524, align 16, !tbaa !9
  %3526 = zext i8 %3525 to i32
  %3527 = xor i32 %3523, %3526
  %3528 = trunc i32 %3527 to i8
  %3529 = call zeroext i8 @mul2(i8 noundef zeroext %3528)
  %3530 = zext i8 %3529 to i32
  %3531 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %3532 = load i8, ptr %3531, align 1, !tbaa !9
  %3533 = zext i8 %3532 to i32
  %3534 = xor i32 %3530, %3533
  %3535 = load i8, ptr %8, align 1, !tbaa !9
  %3536 = zext i8 %3535 to i32
  %3537 = xor i32 %3534, %3536
  %3538 = trunc i32 %3537 to i8
  %3539 = load ptr, ptr %6, align 8, !tbaa !5
  %3540 = getelementptr inbounds i8, ptr %3539, i64 3
  store i8 %3538, ptr %3540, align 1, !tbaa !9
  %3541 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %3542 = load i8, ptr %3541, align 4, !tbaa !9
  %3543 = zext i8 %3542 to i32
  %3544 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %3545 = load i8, ptr %3544, align 1, !tbaa !9
  %3546 = zext i8 %3545 to i32
  %3547 = xor i32 %3543, %3546
  %3548 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %3549 = load i8, ptr %3548, align 2, !tbaa !9
  %3550 = zext i8 %3549 to i32
  %3551 = xor i32 %3547, %3550
  %3552 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %3553 = load i8, ptr %3552, align 1, !tbaa !9
  %3554 = zext i8 %3553 to i32
  %3555 = xor i32 %3551, %3554
  %3556 = trunc i32 %3555 to i8
  store i8 %3556, ptr %8, align 1, !tbaa !9
  %3557 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %3558 = load i8, ptr %3557, align 4, !tbaa !9
  %3559 = zext i8 %3558 to i32
  %3560 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %3561 = load i8, ptr %3560, align 1, !tbaa !9
  %3562 = zext i8 %3561 to i32
  %3563 = xor i32 %3559, %3562
  %3564 = trunc i32 %3563 to i8
  %3565 = call zeroext i8 @mul2(i8 noundef zeroext %3564)
  %3566 = zext i8 %3565 to i32
  %3567 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %3568 = load i8, ptr %3567, align 4, !tbaa !9
  %3569 = zext i8 %3568 to i32
  %3570 = xor i32 %3566, %3569
  %3571 = load i8, ptr %8, align 1, !tbaa !9
  %3572 = zext i8 %3571 to i32
  %3573 = xor i32 %3570, %3572
  %3574 = trunc i32 %3573 to i8
  %3575 = load ptr, ptr %6, align 8, !tbaa !5
  %3576 = getelementptr inbounds i8, ptr %3575, i64 4
  store i8 %3574, ptr %3576, align 1, !tbaa !9
  %3577 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %3578 = load i8, ptr %3577, align 1, !tbaa !9
  %3579 = zext i8 %3578 to i32
  %3580 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %3581 = load i8, ptr %3580, align 2, !tbaa !9
  %3582 = zext i8 %3581 to i32
  %3583 = xor i32 %3579, %3582
  %3584 = trunc i32 %3583 to i8
  %3585 = call zeroext i8 @mul2(i8 noundef zeroext %3584)
  %3586 = zext i8 %3585 to i32
  %3587 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %3588 = load i8, ptr %3587, align 1, !tbaa !9
  %3589 = zext i8 %3588 to i32
  %3590 = xor i32 %3586, %3589
  %3591 = load i8, ptr %8, align 1, !tbaa !9
  %3592 = zext i8 %3591 to i32
  %3593 = xor i32 %3590, %3592
  %3594 = trunc i32 %3593 to i8
  %3595 = load ptr, ptr %6, align 8, !tbaa !5
  %3596 = getelementptr inbounds i8, ptr %3595, i64 5
  store i8 %3594, ptr %3596, align 1, !tbaa !9
  %3597 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %3598 = load i8, ptr %3597, align 2, !tbaa !9
  %3599 = zext i8 %3598 to i32
  %3600 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %3601 = load i8, ptr %3600, align 1, !tbaa !9
  %3602 = zext i8 %3601 to i32
  %3603 = xor i32 %3599, %3602
  %3604 = trunc i32 %3603 to i8
  %3605 = call zeroext i8 @mul2(i8 noundef zeroext %3604)
  %3606 = zext i8 %3605 to i32
  %3607 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %3608 = load i8, ptr %3607, align 2, !tbaa !9
  %3609 = zext i8 %3608 to i32
  %3610 = xor i32 %3606, %3609
  %3611 = load i8, ptr %8, align 1, !tbaa !9
  %3612 = zext i8 %3611 to i32
  %3613 = xor i32 %3610, %3612
  %3614 = trunc i32 %3613 to i8
  %3615 = load ptr, ptr %6, align 8, !tbaa !5
  %3616 = getelementptr inbounds i8, ptr %3615, i64 6
  store i8 %3614, ptr %3616, align 1, !tbaa !9
  %3617 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %3618 = load i8, ptr %3617, align 1, !tbaa !9
  %3619 = zext i8 %3618 to i32
  %3620 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %3621 = load i8, ptr %3620, align 4, !tbaa !9
  %3622 = zext i8 %3621 to i32
  %3623 = xor i32 %3619, %3622
  %3624 = trunc i32 %3623 to i8
  %3625 = call zeroext i8 @mul2(i8 noundef zeroext %3624)
  %3626 = zext i8 %3625 to i32
  %3627 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %3628 = load i8, ptr %3627, align 1, !tbaa !9
  %3629 = zext i8 %3628 to i32
  %3630 = xor i32 %3626, %3629
  %3631 = load i8, ptr %8, align 1, !tbaa !9
  %3632 = zext i8 %3631 to i32
  %3633 = xor i32 %3630, %3632
  %3634 = trunc i32 %3633 to i8
  %3635 = load ptr, ptr %6, align 8, !tbaa !5
  %3636 = getelementptr inbounds i8, ptr %3635, i64 7
  store i8 %3634, ptr %3636, align 1, !tbaa !9
  %3637 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %3638 = load i8, ptr %3637, align 8, !tbaa !9
  %3639 = zext i8 %3638 to i32
  %3640 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %3641 = load i8, ptr %3640, align 1, !tbaa !9
  %3642 = zext i8 %3641 to i32
  %3643 = xor i32 %3639, %3642
  %3644 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %3645 = load i8, ptr %3644, align 2, !tbaa !9
  %3646 = zext i8 %3645 to i32
  %3647 = xor i32 %3643, %3646
  %3648 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %3649 = load i8, ptr %3648, align 1, !tbaa !9
  %3650 = zext i8 %3649 to i32
  %3651 = xor i32 %3647, %3650
  %3652 = trunc i32 %3651 to i8
  store i8 %3652, ptr %8, align 1, !tbaa !9
  %3653 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %3654 = load i8, ptr %3653, align 8, !tbaa !9
  %3655 = zext i8 %3654 to i32
  %3656 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %3657 = load i8, ptr %3656, align 1, !tbaa !9
  %3658 = zext i8 %3657 to i32
  %3659 = xor i32 %3655, %3658
  %3660 = trunc i32 %3659 to i8
  %3661 = call zeroext i8 @mul2(i8 noundef zeroext %3660)
  %3662 = zext i8 %3661 to i32
  %3663 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %3664 = load i8, ptr %3663, align 8, !tbaa !9
  %3665 = zext i8 %3664 to i32
  %3666 = xor i32 %3662, %3665
  %3667 = load i8, ptr %8, align 1, !tbaa !9
  %3668 = zext i8 %3667 to i32
  %3669 = xor i32 %3666, %3668
  %3670 = trunc i32 %3669 to i8
  %3671 = load ptr, ptr %6, align 8, !tbaa !5
  %3672 = getelementptr inbounds i8, ptr %3671, i64 8
  store i8 %3670, ptr %3672, align 1, !tbaa !9
  %3673 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %3674 = load i8, ptr %3673, align 1, !tbaa !9
  %3675 = zext i8 %3674 to i32
  %3676 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %3677 = load i8, ptr %3676, align 2, !tbaa !9
  %3678 = zext i8 %3677 to i32
  %3679 = xor i32 %3675, %3678
  %3680 = trunc i32 %3679 to i8
  %3681 = call zeroext i8 @mul2(i8 noundef zeroext %3680)
  %3682 = zext i8 %3681 to i32
  %3683 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %3684 = load i8, ptr %3683, align 1, !tbaa !9
  %3685 = zext i8 %3684 to i32
  %3686 = xor i32 %3682, %3685
  %3687 = load i8, ptr %8, align 1, !tbaa !9
  %3688 = zext i8 %3687 to i32
  %3689 = xor i32 %3686, %3688
  %3690 = trunc i32 %3689 to i8
  %3691 = load ptr, ptr %6, align 8, !tbaa !5
  %3692 = getelementptr inbounds i8, ptr %3691, i64 9
  store i8 %3690, ptr %3692, align 1, !tbaa !9
  %3693 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %3694 = load i8, ptr %3693, align 2, !tbaa !9
  %3695 = zext i8 %3694 to i32
  %3696 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %3697 = load i8, ptr %3696, align 1, !tbaa !9
  %3698 = zext i8 %3697 to i32
  %3699 = xor i32 %3695, %3698
  %3700 = trunc i32 %3699 to i8
  %3701 = call zeroext i8 @mul2(i8 noundef zeroext %3700)
  %3702 = zext i8 %3701 to i32
  %3703 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %3704 = load i8, ptr %3703, align 2, !tbaa !9
  %3705 = zext i8 %3704 to i32
  %3706 = xor i32 %3702, %3705
  %3707 = load i8, ptr %8, align 1, !tbaa !9
  %3708 = zext i8 %3707 to i32
  %3709 = xor i32 %3706, %3708
  %3710 = trunc i32 %3709 to i8
  %3711 = load ptr, ptr %6, align 8, !tbaa !5
  %3712 = getelementptr inbounds i8, ptr %3711, i64 10
  store i8 %3710, ptr %3712, align 1, !tbaa !9
  %3713 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %3714 = load i8, ptr %3713, align 1, !tbaa !9
  %3715 = zext i8 %3714 to i32
  %3716 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %3717 = load i8, ptr %3716, align 8, !tbaa !9
  %3718 = zext i8 %3717 to i32
  %3719 = xor i32 %3715, %3718
  %3720 = trunc i32 %3719 to i8
  %3721 = call zeroext i8 @mul2(i8 noundef zeroext %3720)
  %3722 = zext i8 %3721 to i32
  %3723 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %3724 = load i8, ptr %3723, align 1, !tbaa !9
  %3725 = zext i8 %3724 to i32
  %3726 = xor i32 %3722, %3725
  %3727 = load i8, ptr %8, align 1, !tbaa !9
  %3728 = zext i8 %3727 to i32
  %3729 = xor i32 %3726, %3728
  %3730 = trunc i32 %3729 to i8
  %3731 = load ptr, ptr %6, align 8, !tbaa !5
  %3732 = getelementptr inbounds i8, ptr %3731, i64 11
  store i8 %3730, ptr %3732, align 1, !tbaa !9
  %3733 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %3734 = load i8, ptr %3733, align 4, !tbaa !9
  %3735 = zext i8 %3734 to i32
  %3736 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %3737 = load i8, ptr %3736, align 1, !tbaa !9
  %3738 = zext i8 %3737 to i32
  %3739 = xor i32 %3735, %3738
  %3740 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %3741 = load i8, ptr %3740, align 2, !tbaa !9
  %3742 = zext i8 %3741 to i32
  %3743 = xor i32 %3739, %3742
  %3744 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %3745 = load i8, ptr %3744, align 1, !tbaa !9
  %3746 = zext i8 %3745 to i32
  %3747 = xor i32 %3743, %3746
  %3748 = trunc i32 %3747 to i8
  store i8 %3748, ptr %8, align 1, !tbaa !9
  %3749 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %3750 = load i8, ptr %3749, align 4, !tbaa !9
  %3751 = zext i8 %3750 to i32
  %3752 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %3753 = load i8, ptr %3752, align 1, !tbaa !9
  %3754 = zext i8 %3753 to i32
  %3755 = xor i32 %3751, %3754
  %3756 = trunc i32 %3755 to i8
  %3757 = call zeroext i8 @mul2(i8 noundef zeroext %3756)
  %3758 = zext i8 %3757 to i32
  %3759 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %3760 = load i8, ptr %3759, align 4, !tbaa !9
  %3761 = zext i8 %3760 to i32
  %3762 = xor i32 %3758, %3761
  %3763 = load i8, ptr %8, align 1, !tbaa !9
  %3764 = zext i8 %3763 to i32
  %3765 = xor i32 %3762, %3764
  %3766 = trunc i32 %3765 to i8
  %3767 = load ptr, ptr %6, align 8, !tbaa !5
  %3768 = getelementptr inbounds i8, ptr %3767, i64 12
  store i8 %3766, ptr %3768, align 1, !tbaa !9
  %3769 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %3770 = load i8, ptr %3769, align 1, !tbaa !9
  %3771 = zext i8 %3770 to i32
  %3772 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %3773 = load i8, ptr %3772, align 2, !tbaa !9
  %3774 = zext i8 %3773 to i32
  %3775 = xor i32 %3771, %3774
  %3776 = trunc i32 %3775 to i8
  %3777 = call zeroext i8 @mul2(i8 noundef zeroext %3776)
  %3778 = zext i8 %3777 to i32
  %3779 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %3780 = load i8, ptr %3779, align 1, !tbaa !9
  %3781 = zext i8 %3780 to i32
  %3782 = xor i32 %3778, %3781
  %3783 = load i8, ptr %8, align 1, !tbaa !9
  %3784 = zext i8 %3783 to i32
  %3785 = xor i32 %3782, %3784
  %3786 = trunc i32 %3785 to i8
  %3787 = load ptr, ptr %6, align 8, !tbaa !5
  %3788 = getelementptr inbounds i8, ptr %3787, i64 13
  store i8 %3786, ptr %3788, align 1, !tbaa !9
  %3789 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %3790 = load i8, ptr %3789, align 2, !tbaa !9
  %3791 = zext i8 %3790 to i32
  %3792 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %3793 = load i8, ptr %3792, align 1, !tbaa !9
  %3794 = zext i8 %3793 to i32
  %3795 = xor i32 %3791, %3794
  %3796 = trunc i32 %3795 to i8
  %3797 = call zeroext i8 @mul2(i8 noundef zeroext %3796)
  %3798 = zext i8 %3797 to i32
  %3799 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %3800 = load i8, ptr %3799, align 2, !tbaa !9
  %3801 = zext i8 %3800 to i32
  %3802 = xor i32 %3798, %3801
  %3803 = load i8, ptr %8, align 1, !tbaa !9
  %3804 = zext i8 %3803 to i32
  %3805 = xor i32 %3802, %3804
  %3806 = trunc i32 %3805 to i8
  %3807 = load ptr, ptr %6, align 8, !tbaa !5
  %3808 = getelementptr inbounds i8, ptr %3807, i64 14
  store i8 %3806, ptr %3808, align 1, !tbaa !9
  %3809 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %3810 = load i8, ptr %3809, align 1, !tbaa !9
  %3811 = zext i8 %3810 to i32
  %3812 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %3813 = load i8, ptr %3812, align 4, !tbaa !9
  %3814 = zext i8 %3813 to i32
  %3815 = xor i32 %3811, %3814
  %3816 = trunc i32 %3815 to i8
  %3817 = call zeroext i8 @mul2(i8 noundef zeroext %3816)
  %3818 = zext i8 %3817 to i32
  %3819 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %3820 = load i8, ptr %3819, align 1, !tbaa !9
  %3821 = zext i8 %3820 to i32
  %3822 = xor i32 %3818, %3821
  %3823 = load i8, ptr %8, align 1, !tbaa !9
  %3824 = zext i8 %3823 to i32
  %3825 = xor i32 %3822, %3824
  %3826 = trunc i32 %3825 to i8
  %3827 = load ptr, ptr %6, align 8, !tbaa !5
  %3828 = getelementptr inbounds i8, ptr %3827, i64 15
  store i8 %3826, ptr %3828, align 1, !tbaa !9
  %3829 = load ptr, ptr %6, align 8, !tbaa !5
  %3830 = load i8, ptr %3829, align 1, !tbaa !9
  %3831 = zext i8 %3830 to i32
  %3832 = load ptr, ptr %4, align 8, !tbaa !5
  %3833 = getelementptr inbounds i8, ptr %3832, i32 1
  store ptr %3833, ptr %4, align 8, !tbaa !5
  %3834 = load i8, ptr %3832, align 1, !tbaa !9
  %3835 = zext i8 %3834 to i32
  %3836 = xor i32 %3831, %3835
  %3837 = trunc i32 %3836 to i8
  %3838 = load ptr, ptr %6, align 8, !tbaa !5
  store i8 %3837, ptr %3838, align 1, !tbaa !9
  %3839 = load ptr, ptr %6, align 8, !tbaa !5
  %3840 = getelementptr inbounds i8, ptr %3839, i64 1
  %3841 = load i8, ptr %3840, align 1, !tbaa !9
  %3842 = zext i8 %3841 to i32
  %3843 = load ptr, ptr %4, align 8, !tbaa !5
  %3844 = getelementptr inbounds i8, ptr %3843, i32 1
  store ptr %3844, ptr %4, align 8, !tbaa !5
  %3845 = load i8, ptr %3843, align 1, !tbaa !9
  %3846 = zext i8 %3845 to i32
  %3847 = xor i32 %3842, %3846
  %3848 = trunc i32 %3847 to i8
  %3849 = load ptr, ptr %6, align 8, !tbaa !5
  %3850 = getelementptr inbounds i8, ptr %3849, i64 1
  store i8 %3848, ptr %3850, align 1, !tbaa !9
  %3851 = load ptr, ptr %6, align 8, !tbaa !5
  %3852 = getelementptr inbounds i8, ptr %3851, i64 2
  %3853 = load i8, ptr %3852, align 1, !tbaa !9
  %3854 = zext i8 %3853 to i32
  %3855 = load ptr, ptr %4, align 8, !tbaa !5
  %3856 = getelementptr inbounds i8, ptr %3855, i32 1
  store ptr %3856, ptr %4, align 8, !tbaa !5
  %3857 = load i8, ptr %3855, align 1, !tbaa !9
  %3858 = zext i8 %3857 to i32
  %3859 = xor i32 %3854, %3858
  %3860 = trunc i32 %3859 to i8
  %3861 = load ptr, ptr %6, align 8, !tbaa !5
  %3862 = getelementptr inbounds i8, ptr %3861, i64 2
  store i8 %3860, ptr %3862, align 1, !tbaa !9
  %3863 = load ptr, ptr %6, align 8, !tbaa !5
  %3864 = getelementptr inbounds i8, ptr %3863, i64 3
  %3865 = load i8, ptr %3864, align 1, !tbaa !9
  %3866 = zext i8 %3865 to i32
  %3867 = load ptr, ptr %4, align 8, !tbaa !5
  %3868 = getelementptr inbounds i8, ptr %3867, i32 1
  store ptr %3868, ptr %4, align 8, !tbaa !5
  %3869 = load i8, ptr %3867, align 1, !tbaa !9
  %3870 = zext i8 %3869 to i32
  %3871 = xor i32 %3866, %3870
  %3872 = trunc i32 %3871 to i8
  %3873 = load ptr, ptr %6, align 8, !tbaa !5
  %3874 = getelementptr inbounds i8, ptr %3873, i64 3
  store i8 %3872, ptr %3874, align 1, !tbaa !9
  %3875 = load ptr, ptr %6, align 8, !tbaa !5
  %3876 = getelementptr inbounds i8, ptr %3875, i64 4
  %3877 = load i8, ptr %3876, align 1, !tbaa !9
  %3878 = zext i8 %3877 to i32
  %3879 = load ptr, ptr %4, align 8, !tbaa !5
  %3880 = getelementptr inbounds i8, ptr %3879, i32 1
  store ptr %3880, ptr %4, align 8, !tbaa !5
  %3881 = load i8, ptr %3879, align 1, !tbaa !9
  %3882 = zext i8 %3881 to i32
  %3883 = xor i32 %3878, %3882
  %3884 = trunc i32 %3883 to i8
  %3885 = load ptr, ptr %6, align 8, !tbaa !5
  %3886 = getelementptr inbounds i8, ptr %3885, i64 4
  store i8 %3884, ptr %3886, align 1, !tbaa !9
  %3887 = load ptr, ptr %6, align 8, !tbaa !5
  %3888 = getelementptr inbounds i8, ptr %3887, i64 5
  %3889 = load i8, ptr %3888, align 1, !tbaa !9
  %3890 = zext i8 %3889 to i32
  %3891 = load ptr, ptr %4, align 8, !tbaa !5
  %3892 = getelementptr inbounds i8, ptr %3891, i32 1
  store ptr %3892, ptr %4, align 8, !tbaa !5
  %3893 = load i8, ptr %3891, align 1, !tbaa !9
  %3894 = zext i8 %3893 to i32
  %3895 = xor i32 %3890, %3894
  %3896 = trunc i32 %3895 to i8
  %3897 = load ptr, ptr %6, align 8, !tbaa !5
  %3898 = getelementptr inbounds i8, ptr %3897, i64 5
  store i8 %3896, ptr %3898, align 1, !tbaa !9
  %3899 = load ptr, ptr %6, align 8, !tbaa !5
  %3900 = getelementptr inbounds i8, ptr %3899, i64 6
  %3901 = load i8, ptr %3900, align 1, !tbaa !9
  %3902 = zext i8 %3901 to i32
  %3903 = load ptr, ptr %4, align 8, !tbaa !5
  %3904 = getelementptr inbounds i8, ptr %3903, i32 1
  store ptr %3904, ptr %4, align 8, !tbaa !5
  %3905 = load i8, ptr %3903, align 1, !tbaa !9
  %3906 = zext i8 %3905 to i32
  %3907 = xor i32 %3902, %3906
  %3908 = trunc i32 %3907 to i8
  %3909 = load ptr, ptr %6, align 8, !tbaa !5
  %3910 = getelementptr inbounds i8, ptr %3909, i64 6
  store i8 %3908, ptr %3910, align 1, !tbaa !9
  %3911 = load ptr, ptr %6, align 8, !tbaa !5
  %3912 = getelementptr inbounds i8, ptr %3911, i64 7
  %3913 = load i8, ptr %3912, align 1, !tbaa !9
  %3914 = zext i8 %3913 to i32
  %3915 = load ptr, ptr %4, align 8, !tbaa !5
  %3916 = getelementptr inbounds i8, ptr %3915, i32 1
  store ptr %3916, ptr %4, align 8, !tbaa !5
  %3917 = load i8, ptr %3915, align 1, !tbaa !9
  %3918 = zext i8 %3917 to i32
  %3919 = xor i32 %3914, %3918
  %3920 = trunc i32 %3919 to i8
  %3921 = load ptr, ptr %6, align 8, !tbaa !5
  %3922 = getelementptr inbounds i8, ptr %3921, i64 7
  store i8 %3920, ptr %3922, align 1, !tbaa !9
  %3923 = load ptr, ptr %6, align 8, !tbaa !5
  %3924 = getelementptr inbounds i8, ptr %3923, i64 8
  %3925 = load i8, ptr %3924, align 1, !tbaa !9
  %3926 = zext i8 %3925 to i32
  %3927 = load ptr, ptr %4, align 8, !tbaa !5
  %3928 = getelementptr inbounds i8, ptr %3927, i32 1
  store ptr %3928, ptr %4, align 8, !tbaa !5
  %3929 = load i8, ptr %3927, align 1, !tbaa !9
  %3930 = zext i8 %3929 to i32
  %3931 = xor i32 %3926, %3930
  %3932 = trunc i32 %3931 to i8
  %3933 = load ptr, ptr %6, align 8, !tbaa !5
  %3934 = getelementptr inbounds i8, ptr %3933, i64 8
  store i8 %3932, ptr %3934, align 1, !tbaa !9
  %3935 = load ptr, ptr %6, align 8, !tbaa !5
  %3936 = getelementptr inbounds i8, ptr %3935, i64 9
  %3937 = load i8, ptr %3936, align 1, !tbaa !9
  %3938 = zext i8 %3937 to i32
  %3939 = load ptr, ptr %4, align 8, !tbaa !5
  %3940 = getelementptr inbounds i8, ptr %3939, i32 1
  store ptr %3940, ptr %4, align 8, !tbaa !5
  %3941 = load i8, ptr %3939, align 1, !tbaa !9
  %3942 = zext i8 %3941 to i32
  %3943 = xor i32 %3938, %3942
  %3944 = trunc i32 %3943 to i8
  %3945 = load ptr, ptr %6, align 8, !tbaa !5
  %3946 = getelementptr inbounds i8, ptr %3945, i64 9
  store i8 %3944, ptr %3946, align 1, !tbaa !9
  %3947 = load ptr, ptr %6, align 8, !tbaa !5
  %3948 = getelementptr inbounds i8, ptr %3947, i64 10
  %3949 = load i8, ptr %3948, align 1, !tbaa !9
  %3950 = zext i8 %3949 to i32
  %3951 = load ptr, ptr %4, align 8, !tbaa !5
  %3952 = getelementptr inbounds i8, ptr %3951, i32 1
  store ptr %3952, ptr %4, align 8, !tbaa !5
  %3953 = load i8, ptr %3951, align 1, !tbaa !9
  %3954 = zext i8 %3953 to i32
  %3955 = xor i32 %3950, %3954
  %3956 = trunc i32 %3955 to i8
  %3957 = load ptr, ptr %6, align 8, !tbaa !5
  %3958 = getelementptr inbounds i8, ptr %3957, i64 10
  store i8 %3956, ptr %3958, align 1, !tbaa !9
  %3959 = load ptr, ptr %6, align 8, !tbaa !5
  %3960 = getelementptr inbounds i8, ptr %3959, i64 11
  %3961 = load i8, ptr %3960, align 1, !tbaa !9
  %3962 = zext i8 %3961 to i32
  %3963 = load ptr, ptr %4, align 8, !tbaa !5
  %3964 = getelementptr inbounds i8, ptr %3963, i32 1
  store ptr %3964, ptr %4, align 8, !tbaa !5
  %3965 = load i8, ptr %3963, align 1, !tbaa !9
  %3966 = zext i8 %3965 to i32
  %3967 = xor i32 %3962, %3966
  %3968 = trunc i32 %3967 to i8
  %3969 = load ptr, ptr %6, align 8, !tbaa !5
  %3970 = getelementptr inbounds i8, ptr %3969, i64 11
  store i8 %3968, ptr %3970, align 1, !tbaa !9
  %3971 = load ptr, ptr %6, align 8, !tbaa !5
  %3972 = getelementptr inbounds i8, ptr %3971, i64 12
  %3973 = load i8, ptr %3972, align 1, !tbaa !9
  %3974 = zext i8 %3973 to i32
  %3975 = load ptr, ptr %4, align 8, !tbaa !5
  %3976 = getelementptr inbounds i8, ptr %3975, i32 1
  store ptr %3976, ptr %4, align 8, !tbaa !5
  %3977 = load i8, ptr %3975, align 1, !tbaa !9
  %3978 = zext i8 %3977 to i32
  %3979 = xor i32 %3974, %3978
  %3980 = trunc i32 %3979 to i8
  %3981 = load ptr, ptr %6, align 8, !tbaa !5
  %3982 = getelementptr inbounds i8, ptr %3981, i64 12
  store i8 %3980, ptr %3982, align 1, !tbaa !9
  %3983 = load ptr, ptr %6, align 8, !tbaa !5
  %3984 = getelementptr inbounds i8, ptr %3983, i64 13
  %3985 = load i8, ptr %3984, align 1, !tbaa !9
  %3986 = zext i8 %3985 to i32
  %3987 = load ptr, ptr %4, align 8, !tbaa !5
  %3988 = getelementptr inbounds i8, ptr %3987, i32 1
  store ptr %3988, ptr %4, align 8, !tbaa !5
  %3989 = load i8, ptr %3987, align 1, !tbaa !9
  %3990 = zext i8 %3989 to i32
  %3991 = xor i32 %3986, %3990
  %3992 = trunc i32 %3991 to i8
  %3993 = load ptr, ptr %6, align 8, !tbaa !5
  %3994 = getelementptr inbounds i8, ptr %3993, i64 13
  store i8 %3992, ptr %3994, align 1, !tbaa !9
  %3995 = load ptr, ptr %6, align 8, !tbaa !5
  %3996 = getelementptr inbounds i8, ptr %3995, i64 14
  %3997 = load i8, ptr %3996, align 1, !tbaa !9
  %3998 = zext i8 %3997 to i32
  %3999 = load ptr, ptr %4, align 8, !tbaa !5
  %4000 = getelementptr inbounds i8, ptr %3999, i32 1
  store ptr %4000, ptr %4, align 8, !tbaa !5
  %4001 = load i8, ptr %3999, align 1, !tbaa !9
  %4002 = zext i8 %4001 to i32
  %4003 = xor i32 %3998, %4002
  %4004 = trunc i32 %4003 to i8
  %4005 = load ptr, ptr %6, align 8, !tbaa !5
  %4006 = getelementptr inbounds i8, ptr %4005, i64 14
  store i8 %4004, ptr %4006, align 1, !tbaa !9
  %4007 = load ptr, ptr %6, align 8, !tbaa !5
  %4008 = getelementptr inbounds i8, ptr %4007, i64 15
  %4009 = load i8, ptr %4008, align 1, !tbaa !9
  %4010 = zext i8 %4009 to i32
  %4011 = load ptr, ptr %4, align 8, !tbaa !5
  %4012 = getelementptr inbounds i8, ptr %4011, i32 1
  store ptr %4012, ptr %4, align 8, !tbaa !5
  %4013 = load i8, ptr %4011, align 1, !tbaa !9
  %4014 = zext i8 %4013 to i32
  %4015 = xor i32 %4010, %4014
  %4016 = trunc i32 %4015 to i8
  %4017 = load ptr, ptr %6, align 8, !tbaa !5
  %4018 = getelementptr inbounds i8, ptr %4017, i64 15
  store i8 %4016, ptr %4018, align 1, !tbaa !9
  %4019 = load ptr, ptr %6, align 8, !tbaa !5
  %4020 = load i8, ptr %4019, align 1, !tbaa !9
  %4021 = zext i8 %4020 to i64
  %4022 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4021
  %4023 = load i8, ptr %4022, align 1, !tbaa !9
  %4024 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  store i8 %4023, ptr %4024, align 16, !tbaa !9
  %4025 = load ptr, ptr %6, align 8, !tbaa !5
  %4026 = getelementptr inbounds i8, ptr %4025, i64 1
  %4027 = load i8, ptr %4026, align 1, !tbaa !9
  %4028 = zext i8 %4027 to i64
  %4029 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4028
  %4030 = load i8, ptr %4029, align 1, !tbaa !9
  %4031 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4032 = getelementptr inbounds i8, ptr %4031, i64 1
  store i8 %4030, ptr %4032, align 1, !tbaa !9
  %4033 = load ptr, ptr %6, align 8, !tbaa !5
  %4034 = getelementptr inbounds i8, ptr %4033, i64 2
  %4035 = load i8, ptr %4034, align 1, !tbaa !9
  %4036 = zext i8 %4035 to i64
  %4037 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4036
  %4038 = load i8, ptr %4037, align 1, !tbaa !9
  %4039 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4040 = getelementptr inbounds i8, ptr %4039, i64 2
  store i8 %4038, ptr %4040, align 1, !tbaa !9
  %4041 = load ptr, ptr %6, align 8, !tbaa !5
  %4042 = getelementptr inbounds i8, ptr %4041, i64 3
  %4043 = load i8, ptr %4042, align 1, !tbaa !9
  %4044 = zext i8 %4043 to i64
  %4045 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4044
  %4046 = load i8, ptr %4045, align 1, !tbaa !9
  %4047 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4048 = getelementptr inbounds i8, ptr %4047, i64 3
  store i8 %4046, ptr %4048, align 1, !tbaa !9
  %4049 = load ptr, ptr %6, align 8, !tbaa !5
  %4050 = getelementptr inbounds i8, ptr %4049, i64 4
  %4051 = load i8, ptr %4050, align 1, !tbaa !9
  %4052 = zext i8 %4051 to i64
  %4053 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4052
  %4054 = load i8, ptr %4053, align 1, !tbaa !9
  %4055 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4056 = getelementptr inbounds i8, ptr %4055, i64 4
  store i8 %4054, ptr %4056, align 1, !tbaa !9
  %4057 = load ptr, ptr %6, align 8, !tbaa !5
  %4058 = getelementptr inbounds i8, ptr %4057, i64 5
  %4059 = load i8, ptr %4058, align 1, !tbaa !9
  %4060 = zext i8 %4059 to i64
  %4061 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4060
  %4062 = load i8, ptr %4061, align 1, !tbaa !9
  %4063 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4064 = getelementptr inbounds i8, ptr %4063, i64 5
  store i8 %4062, ptr %4064, align 1, !tbaa !9
  %4065 = load ptr, ptr %6, align 8, !tbaa !5
  %4066 = getelementptr inbounds i8, ptr %4065, i64 6
  %4067 = load i8, ptr %4066, align 1, !tbaa !9
  %4068 = zext i8 %4067 to i64
  %4069 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4068
  %4070 = load i8, ptr %4069, align 1, !tbaa !9
  %4071 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4072 = getelementptr inbounds i8, ptr %4071, i64 6
  store i8 %4070, ptr %4072, align 1, !tbaa !9
  %4073 = load ptr, ptr %6, align 8, !tbaa !5
  %4074 = getelementptr inbounds i8, ptr %4073, i64 7
  %4075 = load i8, ptr %4074, align 1, !tbaa !9
  %4076 = zext i8 %4075 to i64
  %4077 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4076
  %4078 = load i8, ptr %4077, align 1, !tbaa !9
  %4079 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4080 = getelementptr inbounds i8, ptr %4079, i64 7
  store i8 %4078, ptr %4080, align 1, !tbaa !9
  %4081 = load ptr, ptr %6, align 8, !tbaa !5
  %4082 = getelementptr inbounds i8, ptr %4081, i64 8
  %4083 = load i8, ptr %4082, align 1, !tbaa !9
  %4084 = zext i8 %4083 to i64
  %4085 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4084
  %4086 = load i8, ptr %4085, align 1, !tbaa !9
  %4087 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4088 = getelementptr inbounds i8, ptr %4087, i64 8
  store i8 %4086, ptr %4088, align 1, !tbaa !9
  %4089 = load ptr, ptr %6, align 8, !tbaa !5
  %4090 = getelementptr inbounds i8, ptr %4089, i64 9
  %4091 = load i8, ptr %4090, align 1, !tbaa !9
  %4092 = zext i8 %4091 to i64
  %4093 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4092
  %4094 = load i8, ptr %4093, align 1, !tbaa !9
  %4095 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4096 = getelementptr inbounds i8, ptr %4095, i64 9
  store i8 %4094, ptr %4096, align 1, !tbaa !9
  %4097 = load ptr, ptr %6, align 8, !tbaa !5
  %4098 = getelementptr inbounds i8, ptr %4097, i64 10
  %4099 = load i8, ptr %4098, align 1, !tbaa !9
  %4100 = zext i8 %4099 to i64
  %4101 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4100
  %4102 = load i8, ptr %4101, align 1, !tbaa !9
  %4103 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4104 = getelementptr inbounds i8, ptr %4103, i64 10
  store i8 %4102, ptr %4104, align 1, !tbaa !9
  %4105 = load ptr, ptr %6, align 8, !tbaa !5
  %4106 = getelementptr inbounds i8, ptr %4105, i64 11
  %4107 = load i8, ptr %4106, align 1, !tbaa !9
  %4108 = zext i8 %4107 to i64
  %4109 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4108
  %4110 = load i8, ptr %4109, align 1, !tbaa !9
  %4111 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4112 = getelementptr inbounds i8, ptr %4111, i64 11
  store i8 %4110, ptr %4112, align 1, !tbaa !9
  %4113 = load ptr, ptr %6, align 8, !tbaa !5
  %4114 = getelementptr inbounds i8, ptr %4113, i64 12
  %4115 = load i8, ptr %4114, align 1, !tbaa !9
  %4116 = zext i8 %4115 to i64
  %4117 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4116
  %4118 = load i8, ptr %4117, align 1, !tbaa !9
  %4119 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4120 = getelementptr inbounds i8, ptr %4119, i64 12
  store i8 %4118, ptr %4120, align 1, !tbaa !9
  %4121 = load ptr, ptr %6, align 8, !tbaa !5
  %4122 = getelementptr inbounds i8, ptr %4121, i64 13
  %4123 = load i8, ptr %4122, align 1, !tbaa !9
  %4124 = zext i8 %4123 to i64
  %4125 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4124
  %4126 = load i8, ptr %4125, align 1, !tbaa !9
  %4127 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4128 = getelementptr inbounds i8, ptr %4127, i64 13
  store i8 %4126, ptr %4128, align 1, !tbaa !9
  %4129 = load ptr, ptr %6, align 8, !tbaa !5
  %4130 = getelementptr inbounds i8, ptr %4129, i64 14
  %4131 = load i8, ptr %4130, align 1, !tbaa !9
  %4132 = zext i8 %4131 to i64
  %4133 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4132
  %4134 = load i8, ptr %4133, align 1, !tbaa !9
  %4135 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4136 = getelementptr inbounds i8, ptr %4135, i64 14
  store i8 %4134, ptr %4136, align 1, !tbaa !9
  %4137 = load ptr, ptr %6, align 8, !tbaa !5
  %4138 = getelementptr inbounds i8, ptr %4137, i64 15
  %4139 = load i8, ptr %4138, align 1, !tbaa !9
  %4140 = zext i8 %4139 to i64
  %4141 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4140
  %4142 = load i8, ptr %4141, align 1, !tbaa !9
  %4143 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4144 = getelementptr inbounds i8, ptr %4143, i64 15
  store i8 %4142, ptr %4144, align 1, !tbaa !9
  %4145 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4146 = getelementptr inbounds i8, ptr %4145, i64 1
  %4147 = load i8, ptr %4146, align 1, !tbaa !9
  store i8 %4147, ptr %8, align 1, !tbaa !9
  %4148 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4149 = getelementptr inbounds i8, ptr %4148, i64 5
  %4150 = load i8, ptr %4149, align 1, !tbaa !9
  %4151 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4152 = getelementptr inbounds i8, ptr %4151, i64 1
  store i8 %4150, ptr %4152, align 1, !tbaa !9
  %4153 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4154 = getelementptr inbounds i8, ptr %4153, i64 9
  %4155 = load i8, ptr %4154, align 1, !tbaa !9
  %4156 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4157 = getelementptr inbounds i8, ptr %4156, i64 5
  store i8 %4155, ptr %4157, align 1, !tbaa !9
  %4158 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4159 = getelementptr inbounds i8, ptr %4158, i64 13
  %4160 = load i8, ptr %4159, align 1, !tbaa !9
  %4161 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4162 = getelementptr inbounds i8, ptr %4161, i64 9
  store i8 %4160, ptr %4162, align 1, !tbaa !9
  %4163 = load i8, ptr %8, align 1, !tbaa !9
  %4164 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4165 = getelementptr inbounds i8, ptr %4164, i64 13
  store i8 %4163, ptr %4165, align 1, !tbaa !9
  %4166 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4167 = getelementptr inbounds i8, ptr %4166, i64 2
  %4168 = load i8, ptr %4167, align 1, !tbaa !9
  store i8 %4168, ptr %8, align 1, !tbaa !9
  %4169 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4170 = getelementptr inbounds i8, ptr %4169, i64 10
  %4171 = load i8, ptr %4170, align 1, !tbaa !9
  %4172 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4173 = getelementptr inbounds i8, ptr %4172, i64 2
  store i8 %4171, ptr %4173, align 1, !tbaa !9
  %4174 = load i8, ptr %8, align 1, !tbaa !9
  %4175 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4176 = getelementptr inbounds i8, ptr %4175, i64 10
  store i8 %4174, ptr %4176, align 1, !tbaa !9
  %4177 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4178 = getelementptr inbounds i8, ptr %4177, i64 6
  %4179 = load i8, ptr %4178, align 1, !tbaa !9
  store i8 %4179, ptr %8, align 1, !tbaa !9
  %4180 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4181 = getelementptr inbounds i8, ptr %4180, i64 14
  %4182 = load i8, ptr %4181, align 1, !tbaa !9
  %4183 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4184 = getelementptr inbounds i8, ptr %4183, i64 6
  store i8 %4182, ptr %4184, align 1, !tbaa !9
  %4185 = load i8, ptr %8, align 1, !tbaa !9
  %4186 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4187 = getelementptr inbounds i8, ptr %4186, i64 14
  store i8 %4185, ptr %4187, align 1, !tbaa !9
  %4188 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4189 = getelementptr inbounds i8, ptr %4188, i64 15
  %4190 = load i8, ptr %4189, align 1, !tbaa !9
  store i8 %4190, ptr %8, align 1, !tbaa !9
  %4191 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4192 = getelementptr inbounds i8, ptr %4191, i64 11
  %4193 = load i8, ptr %4192, align 1, !tbaa !9
  %4194 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4195 = getelementptr inbounds i8, ptr %4194, i64 15
  store i8 %4193, ptr %4195, align 1, !tbaa !9
  %4196 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4197 = getelementptr inbounds i8, ptr %4196, i64 7
  %4198 = load i8, ptr %4197, align 1, !tbaa !9
  %4199 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4200 = getelementptr inbounds i8, ptr %4199, i64 11
  store i8 %4198, ptr %4200, align 1, !tbaa !9
  %4201 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4202 = getelementptr inbounds i8, ptr %4201, i64 3
  %4203 = load i8, ptr %4202, align 1, !tbaa !9
  %4204 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4205 = getelementptr inbounds i8, ptr %4204, i64 7
  store i8 %4203, ptr %4205, align 1, !tbaa !9
  %4206 = load i8, ptr %8, align 1, !tbaa !9
  %4207 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4208 = getelementptr inbounds i8, ptr %4207, i64 3
  store i8 %4206, ptr %4208, align 1, !tbaa !9
  %4209 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4210 = load i8, ptr %4209, align 16, !tbaa !9
  %4211 = zext i8 %4210 to i32
  %4212 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %4213 = load i8, ptr %4212, align 1, !tbaa !9
  %4214 = zext i8 %4213 to i32
  %4215 = xor i32 %4211, %4214
  %4216 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %4217 = load i8, ptr %4216, align 2, !tbaa !9
  %4218 = zext i8 %4217 to i32
  %4219 = xor i32 %4215, %4218
  %4220 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %4221 = load i8, ptr %4220, align 1, !tbaa !9
  %4222 = zext i8 %4221 to i32
  %4223 = xor i32 %4219, %4222
  %4224 = trunc i32 %4223 to i8
  store i8 %4224, ptr %8, align 1, !tbaa !9
  %4225 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4226 = load i8, ptr %4225, align 16, !tbaa !9
  %4227 = zext i8 %4226 to i32
  %4228 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %4229 = load i8, ptr %4228, align 1, !tbaa !9
  %4230 = zext i8 %4229 to i32
  %4231 = xor i32 %4227, %4230
  %4232 = trunc i32 %4231 to i8
  %4233 = call zeroext i8 @mul2(i8 noundef zeroext %4232)
  %4234 = zext i8 %4233 to i32
  %4235 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4236 = load i8, ptr %4235, align 16, !tbaa !9
  %4237 = zext i8 %4236 to i32
  %4238 = xor i32 %4234, %4237
  %4239 = load i8, ptr %8, align 1, !tbaa !9
  %4240 = zext i8 %4239 to i32
  %4241 = xor i32 %4238, %4240
  %4242 = trunc i32 %4241 to i8
  %4243 = load ptr, ptr %6, align 8, !tbaa !5
  %4244 = getelementptr inbounds i8, ptr %4243, i64 0
  store i8 %4242, ptr %4244, align 1, !tbaa !9
  %4245 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %4246 = load i8, ptr %4245, align 1, !tbaa !9
  %4247 = zext i8 %4246 to i32
  %4248 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %4249 = load i8, ptr %4248, align 2, !tbaa !9
  %4250 = zext i8 %4249 to i32
  %4251 = xor i32 %4247, %4250
  %4252 = trunc i32 %4251 to i8
  %4253 = call zeroext i8 @mul2(i8 noundef zeroext %4252)
  %4254 = zext i8 %4253 to i32
  %4255 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %4256 = load i8, ptr %4255, align 1, !tbaa !9
  %4257 = zext i8 %4256 to i32
  %4258 = xor i32 %4254, %4257
  %4259 = load i8, ptr %8, align 1, !tbaa !9
  %4260 = zext i8 %4259 to i32
  %4261 = xor i32 %4258, %4260
  %4262 = trunc i32 %4261 to i8
  %4263 = load ptr, ptr %6, align 8, !tbaa !5
  %4264 = getelementptr inbounds i8, ptr %4263, i64 1
  store i8 %4262, ptr %4264, align 1, !tbaa !9
  %4265 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %4266 = load i8, ptr %4265, align 2, !tbaa !9
  %4267 = zext i8 %4266 to i32
  %4268 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %4269 = load i8, ptr %4268, align 1, !tbaa !9
  %4270 = zext i8 %4269 to i32
  %4271 = xor i32 %4267, %4270
  %4272 = trunc i32 %4271 to i8
  %4273 = call zeroext i8 @mul2(i8 noundef zeroext %4272)
  %4274 = zext i8 %4273 to i32
  %4275 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %4276 = load i8, ptr %4275, align 2, !tbaa !9
  %4277 = zext i8 %4276 to i32
  %4278 = xor i32 %4274, %4277
  %4279 = load i8, ptr %8, align 1, !tbaa !9
  %4280 = zext i8 %4279 to i32
  %4281 = xor i32 %4278, %4280
  %4282 = trunc i32 %4281 to i8
  %4283 = load ptr, ptr %6, align 8, !tbaa !5
  %4284 = getelementptr inbounds i8, ptr %4283, i64 2
  store i8 %4282, ptr %4284, align 1, !tbaa !9
  %4285 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %4286 = load i8, ptr %4285, align 1, !tbaa !9
  %4287 = zext i8 %4286 to i32
  %4288 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4289 = load i8, ptr %4288, align 16, !tbaa !9
  %4290 = zext i8 %4289 to i32
  %4291 = xor i32 %4287, %4290
  %4292 = trunc i32 %4291 to i8
  %4293 = call zeroext i8 @mul2(i8 noundef zeroext %4292)
  %4294 = zext i8 %4293 to i32
  %4295 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %4296 = load i8, ptr %4295, align 1, !tbaa !9
  %4297 = zext i8 %4296 to i32
  %4298 = xor i32 %4294, %4297
  %4299 = load i8, ptr %8, align 1, !tbaa !9
  %4300 = zext i8 %4299 to i32
  %4301 = xor i32 %4298, %4300
  %4302 = trunc i32 %4301 to i8
  %4303 = load ptr, ptr %6, align 8, !tbaa !5
  %4304 = getelementptr inbounds i8, ptr %4303, i64 3
  store i8 %4302, ptr %4304, align 1, !tbaa !9
  %4305 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %4306 = load i8, ptr %4305, align 4, !tbaa !9
  %4307 = zext i8 %4306 to i32
  %4308 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %4309 = load i8, ptr %4308, align 1, !tbaa !9
  %4310 = zext i8 %4309 to i32
  %4311 = xor i32 %4307, %4310
  %4312 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %4313 = load i8, ptr %4312, align 2, !tbaa !9
  %4314 = zext i8 %4313 to i32
  %4315 = xor i32 %4311, %4314
  %4316 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %4317 = load i8, ptr %4316, align 1, !tbaa !9
  %4318 = zext i8 %4317 to i32
  %4319 = xor i32 %4315, %4318
  %4320 = trunc i32 %4319 to i8
  store i8 %4320, ptr %8, align 1, !tbaa !9
  %4321 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %4322 = load i8, ptr %4321, align 4, !tbaa !9
  %4323 = zext i8 %4322 to i32
  %4324 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %4325 = load i8, ptr %4324, align 1, !tbaa !9
  %4326 = zext i8 %4325 to i32
  %4327 = xor i32 %4323, %4326
  %4328 = trunc i32 %4327 to i8
  %4329 = call zeroext i8 @mul2(i8 noundef zeroext %4328)
  %4330 = zext i8 %4329 to i32
  %4331 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %4332 = load i8, ptr %4331, align 4, !tbaa !9
  %4333 = zext i8 %4332 to i32
  %4334 = xor i32 %4330, %4333
  %4335 = load i8, ptr %8, align 1, !tbaa !9
  %4336 = zext i8 %4335 to i32
  %4337 = xor i32 %4334, %4336
  %4338 = trunc i32 %4337 to i8
  %4339 = load ptr, ptr %6, align 8, !tbaa !5
  %4340 = getelementptr inbounds i8, ptr %4339, i64 4
  store i8 %4338, ptr %4340, align 1, !tbaa !9
  %4341 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %4342 = load i8, ptr %4341, align 1, !tbaa !9
  %4343 = zext i8 %4342 to i32
  %4344 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %4345 = load i8, ptr %4344, align 2, !tbaa !9
  %4346 = zext i8 %4345 to i32
  %4347 = xor i32 %4343, %4346
  %4348 = trunc i32 %4347 to i8
  %4349 = call zeroext i8 @mul2(i8 noundef zeroext %4348)
  %4350 = zext i8 %4349 to i32
  %4351 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %4352 = load i8, ptr %4351, align 1, !tbaa !9
  %4353 = zext i8 %4352 to i32
  %4354 = xor i32 %4350, %4353
  %4355 = load i8, ptr %8, align 1, !tbaa !9
  %4356 = zext i8 %4355 to i32
  %4357 = xor i32 %4354, %4356
  %4358 = trunc i32 %4357 to i8
  %4359 = load ptr, ptr %6, align 8, !tbaa !5
  %4360 = getelementptr inbounds i8, ptr %4359, i64 5
  store i8 %4358, ptr %4360, align 1, !tbaa !9
  %4361 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %4362 = load i8, ptr %4361, align 2, !tbaa !9
  %4363 = zext i8 %4362 to i32
  %4364 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %4365 = load i8, ptr %4364, align 1, !tbaa !9
  %4366 = zext i8 %4365 to i32
  %4367 = xor i32 %4363, %4366
  %4368 = trunc i32 %4367 to i8
  %4369 = call zeroext i8 @mul2(i8 noundef zeroext %4368)
  %4370 = zext i8 %4369 to i32
  %4371 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %4372 = load i8, ptr %4371, align 2, !tbaa !9
  %4373 = zext i8 %4372 to i32
  %4374 = xor i32 %4370, %4373
  %4375 = load i8, ptr %8, align 1, !tbaa !9
  %4376 = zext i8 %4375 to i32
  %4377 = xor i32 %4374, %4376
  %4378 = trunc i32 %4377 to i8
  %4379 = load ptr, ptr %6, align 8, !tbaa !5
  %4380 = getelementptr inbounds i8, ptr %4379, i64 6
  store i8 %4378, ptr %4380, align 1, !tbaa !9
  %4381 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %4382 = load i8, ptr %4381, align 1, !tbaa !9
  %4383 = zext i8 %4382 to i32
  %4384 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %4385 = load i8, ptr %4384, align 4, !tbaa !9
  %4386 = zext i8 %4385 to i32
  %4387 = xor i32 %4383, %4386
  %4388 = trunc i32 %4387 to i8
  %4389 = call zeroext i8 @mul2(i8 noundef zeroext %4388)
  %4390 = zext i8 %4389 to i32
  %4391 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %4392 = load i8, ptr %4391, align 1, !tbaa !9
  %4393 = zext i8 %4392 to i32
  %4394 = xor i32 %4390, %4393
  %4395 = load i8, ptr %8, align 1, !tbaa !9
  %4396 = zext i8 %4395 to i32
  %4397 = xor i32 %4394, %4396
  %4398 = trunc i32 %4397 to i8
  %4399 = load ptr, ptr %6, align 8, !tbaa !5
  %4400 = getelementptr inbounds i8, ptr %4399, i64 7
  store i8 %4398, ptr %4400, align 1, !tbaa !9
  %4401 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %4402 = load i8, ptr %4401, align 8, !tbaa !9
  %4403 = zext i8 %4402 to i32
  %4404 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %4405 = load i8, ptr %4404, align 1, !tbaa !9
  %4406 = zext i8 %4405 to i32
  %4407 = xor i32 %4403, %4406
  %4408 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %4409 = load i8, ptr %4408, align 2, !tbaa !9
  %4410 = zext i8 %4409 to i32
  %4411 = xor i32 %4407, %4410
  %4412 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %4413 = load i8, ptr %4412, align 1, !tbaa !9
  %4414 = zext i8 %4413 to i32
  %4415 = xor i32 %4411, %4414
  %4416 = trunc i32 %4415 to i8
  store i8 %4416, ptr %8, align 1, !tbaa !9
  %4417 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %4418 = load i8, ptr %4417, align 8, !tbaa !9
  %4419 = zext i8 %4418 to i32
  %4420 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %4421 = load i8, ptr %4420, align 1, !tbaa !9
  %4422 = zext i8 %4421 to i32
  %4423 = xor i32 %4419, %4422
  %4424 = trunc i32 %4423 to i8
  %4425 = call zeroext i8 @mul2(i8 noundef zeroext %4424)
  %4426 = zext i8 %4425 to i32
  %4427 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %4428 = load i8, ptr %4427, align 8, !tbaa !9
  %4429 = zext i8 %4428 to i32
  %4430 = xor i32 %4426, %4429
  %4431 = load i8, ptr %8, align 1, !tbaa !9
  %4432 = zext i8 %4431 to i32
  %4433 = xor i32 %4430, %4432
  %4434 = trunc i32 %4433 to i8
  %4435 = load ptr, ptr %6, align 8, !tbaa !5
  %4436 = getelementptr inbounds i8, ptr %4435, i64 8
  store i8 %4434, ptr %4436, align 1, !tbaa !9
  %4437 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %4438 = load i8, ptr %4437, align 1, !tbaa !9
  %4439 = zext i8 %4438 to i32
  %4440 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %4441 = load i8, ptr %4440, align 2, !tbaa !9
  %4442 = zext i8 %4441 to i32
  %4443 = xor i32 %4439, %4442
  %4444 = trunc i32 %4443 to i8
  %4445 = call zeroext i8 @mul2(i8 noundef zeroext %4444)
  %4446 = zext i8 %4445 to i32
  %4447 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %4448 = load i8, ptr %4447, align 1, !tbaa !9
  %4449 = zext i8 %4448 to i32
  %4450 = xor i32 %4446, %4449
  %4451 = load i8, ptr %8, align 1, !tbaa !9
  %4452 = zext i8 %4451 to i32
  %4453 = xor i32 %4450, %4452
  %4454 = trunc i32 %4453 to i8
  %4455 = load ptr, ptr %6, align 8, !tbaa !5
  %4456 = getelementptr inbounds i8, ptr %4455, i64 9
  store i8 %4454, ptr %4456, align 1, !tbaa !9
  %4457 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %4458 = load i8, ptr %4457, align 2, !tbaa !9
  %4459 = zext i8 %4458 to i32
  %4460 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %4461 = load i8, ptr %4460, align 1, !tbaa !9
  %4462 = zext i8 %4461 to i32
  %4463 = xor i32 %4459, %4462
  %4464 = trunc i32 %4463 to i8
  %4465 = call zeroext i8 @mul2(i8 noundef zeroext %4464)
  %4466 = zext i8 %4465 to i32
  %4467 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %4468 = load i8, ptr %4467, align 2, !tbaa !9
  %4469 = zext i8 %4468 to i32
  %4470 = xor i32 %4466, %4469
  %4471 = load i8, ptr %8, align 1, !tbaa !9
  %4472 = zext i8 %4471 to i32
  %4473 = xor i32 %4470, %4472
  %4474 = trunc i32 %4473 to i8
  %4475 = load ptr, ptr %6, align 8, !tbaa !5
  %4476 = getelementptr inbounds i8, ptr %4475, i64 10
  store i8 %4474, ptr %4476, align 1, !tbaa !9
  %4477 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %4478 = load i8, ptr %4477, align 1, !tbaa !9
  %4479 = zext i8 %4478 to i32
  %4480 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %4481 = load i8, ptr %4480, align 8, !tbaa !9
  %4482 = zext i8 %4481 to i32
  %4483 = xor i32 %4479, %4482
  %4484 = trunc i32 %4483 to i8
  %4485 = call zeroext i8 @mul2(i8 noundef zeroext %4484)
  %4486 = zext i8 %4485 to i32
  %4487 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %4488 = load i8, ptr %4487, align 1, !tbaa !9
  %4489 = zext i8 %4488 to i32
  %4490 = xor i32 %4486, %4489
  %4491 = load i8, ptr %8, align 1, !tbaa !9
  %4492 = zext i8 %4491 to i32
  %4493 = xor i32 %4490, %4492
  %4494 = trunc i32 %4493 to i8
  %4495 = load ptr, ptr %6, align 8, !tbaa !5
  %4496 = getelementptr inbounds i8, ptr %4495, i64 11
  store i8 %4494, ptr %4496, align 1, !tbaa !9
  %4497 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %4498 = load i8, ptr %4497, align 4, !tbaa !9
  %4499 = zext i8 %4498 to i32
  %4500 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %4501 = load i8, ptr %4500, align 1, !tbaa !9
  %4502 = zext i8 %4501 to i32
  %4503 = xor i32 %4499, %4502
  %4504 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %4505 = load i8, ptr %4504, align 2, !tbaa !9
  %4506 = zext i8 %4505 to i32
  %4507 = xor i32 %4503, %4506
  %4508 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %4509 = load i8, ptr %4508, align 1, !tbaa !9
  %4510 = zext i8 %4509 to i32
  %4511 = xor i32 %4507, %4510
  %4512 = trunc i32 %4511 to i8
  store i8 %4512, ptr %8, align 1, !tbaa !9
  %4513 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %4514 = load i8, ptr %4513, align 4, !tbaa !9
  %4515 = zext i8 %4514 to i32
  %4516 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %4517 = load i8, ptr %4516, align 1, !tbaa !9
  %4518 = zext i8 %4517 to i32
  %4519 = xor i32 %4515, %4518
  %4520 = trunc i32 %4519 to i8
  %4521 = call zeroext i8 @mul2(i8 noundef zeroext %4520)
  %4522 = zext i8 %4521 to i32
  %4523 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %4524 = load i8, ptr %4523, align 4, !tbaa !9
  %4525 = zext i8 %4524 to i32
  %4526 = xor i32 %4522, %4525
  %4527 = load i8, ptr %8, align 1, !tbaa !9
  %4528 = zext i8 %4527 to i32
  %4529 = xor i32 %4526, %4528
  %4530 = trunc i32 %4529 to i8
  %4531 = load ptr, ptr %6, align 8, !tbaa !5
  %4532 = getelementptr inbounds i8, ptr %4531, i64 12
  store i8 %4530, ptr %4532, align 1, !tbaa !9
  %4533 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %4534 = load i8, ptr %4533, align 1, !tbaa !9
  %4535 = zext i8 %4534 to i32
  %4536 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %4537 = load i8, ptr %4536, align 2, !tbaa !9
  %4538 = zext i8 %4537 to i32
  %4539 = xor i32 %4535, %4538
  %4540 = trunc i32 %4539 to i8
  %4541 = call zeroext i8 @mul2(i8 noundef zeroext %4540)
  %4542 = zext i8 %4541 to i32
  %4543 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %4544 = load i8, ptr %4543, align 1, !tbaa !9
  %4545 = zext i8 %4544 to i32
  %4546 = xor i32 %4542, %4545
  %4547 = load i8, ptr %8, align 1, !tbaa !9
  %4548 = zext i8 %4547 to i32
  %4549 = xor i32 %4546, %4548
  %4550 = trunc i32 %4549 to i8
  %4551 = load ptr, ptr %6, align 8, !tbaa !5
  %4552 = getelementptr inbounds i8, ptr %4551, i64 13
  store i8 %4550, ptr %4552, align 1, !tbaa !9
  %4553 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %4554 = load i8, ptr %4553, align 2, !tbaa !9
  %4555 = zext i8 %4554 to i32
  %4556 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %4557 = load i8, ptr %4556, align 1, !tbaa !9
  %4558 = zext i8 %4557 to i32
  %4559 = xor i32 %4555, %4558
  %4560 = trunc i32 %4559 to i8
  %4561 = call zeroext i8 @mul2(i8 noundef zeroext %4560)
  %4562 = zext i8 %4561 to i32
  %4563 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %4564 = load i8, ptr %4563, align 2, !tbaa !9
  %4565 = zext i8 %4564 to i32
  %4566 = xor i32 %4562, %4565
  %4567 = load i8, ptr %8, align 1, !tbaa !9
  %4568 = zext i8 %4567 to i32
  %4569 = xor i32 %4566, %4568
  %4570 = trunc i32 %4569 to i8
  %4571 = load ptr, ptr %6, align 8, !tbaa !5
  %4572 = getelementptr inbounds i8, ptr %4571, i64 14
  store i8 %4570, ptr %4572, align 1, !tbaa !9
  %4573 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %4574 = load i8, ptr %4573, align 1, !tbaa !9
  %4575 = zext i8 %4574 to i32
  %4576 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %4577 = load i8, ptr %4576, align 4, !tbaa !9
  %4578 = zext i8 %4577 to i32
  %4579 = xor i32 %4575, %4578
  %4580 = trunc i32 %4579 to i8
  %4581 = call zeroext i8 @mul2(i8 noundef zeroext %4580)
  %4582 = zext i8 %4581 to i32
  %4583 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %4584 = load i8, ptr %4583, align 1, !tbaa !9
  %4585 = zext i8 %4584 to i32
  %4586 = xor i32 %4582, %4585
  %4587 = load i8, ptr %8, align 1, !tbaa !9
  %4588 = zext i8 %4587 to i32
  %4589 = xor i32 %4586, %4588
  %4590 = trunc i32 %4589 to i8
  %4591 = load ptr, ptr %6, align 8, !tbaa !5
  %4592 = getelementptr inbounds i8, ptr %4591, i64 15
  store i8 %4590, ptr %4592, align 1, !tbaa !9
  %4593 = load ptr, ptr %6, align 8, !tbaa !5
  %4594 = load i8, ptr %4593, align 1, !tbaa !9
  %4595 = zext i8 %4594 to i32
  %4596 = load ptr, ptr %4, align 8, !tbaa !5
  %4597 = getelementptr inbounds i8, ptr %4596, i32 1
  store ptr %4597, ptr %4, align 8, !tbaa !5
  %4598 = load i8, ptr %4596, align 1, !tbaa !9
  %4599 = zext i8 %4598 to i32
  %4600 = xor i32 %4595, %4599
  %4601 = trunc i32 %4600 to i8
  %4602 = load ptr, ptr %6, align 8, !tbaa !5
  store i8 %4601, ptr %4602, align 1, !tbaa !9
  %4603 = load ptr, ptr %6, align 8, !tbaa !5
  %4604 = getelementptr inbounds i8, ptr %4603, i64 1
  %4605 = load i8, ptr %4604, align 1, !tbaa !9
  %4606 = zext i8 %4605 to i32
  %4607 = load ptr, ptr %4, align 8, !tbaa !5
  %4608 = getelementptr inbounds i8, ptr %4607, i32 1
  store ptr %4608, ptr %4, align 8, !tbaa !5
  %4609 = load i8, ptr %4607, align 1, !tbaa !9
  %4610 = zext i8 %4609 to i32
  %4611 = xor i32 %4606, %4610
  %4612 = trunc i32 %4611 to i8
  %4613 = load ptr, ptr %6, align 8, !tbaa !5
  %4614 = getelementptr inbounds i8, ptr %4613, i64 1
  store i8 %4612, ptr %4614, align 1, !tbaa !9
  %4615 = load ptr, ptr %6, align 8, !tbaa !5
  %4616 = getelementptr inbounds i8, ptr %4615, i64 2
  %4617 = load i8, ptr %4616, align 1, !tbaa !9
  %4618 = zext i8 %4617 to i32
  %4619 = load ptr, ptr %4, align 8, !tbaa !5
  %4620 = getelementptr inbounds i8, ptr %4619, i32 1
  store ptr %4620, ptr %4, align 8, !tbaa !5
  %4621 = load i8, ptr %4619, align 1, !tbaa !9
  %4622 = zext i8 %4621 to i32
  %4623 = xor i32 %4618, %4622
  %4624 = trunc i32 %4623 to i8
  %4625 = load ptr, ptr %6, align 8, !tbaa !5
  %4626 = getelementptr inbounds i8, ptr %4625, i64 2
  store i8 %4624, ptr %4626, align 1, !tbaa !9
  %4627 = load ptr, ptr %6, align 8, !tbaa !5
  %4628 = getelementptr inbounds i8, ptr %4627, i64 3
  %4629 = load i8, ptr %4628, align 1, !tbaa !9
  %4630 = zext i8 %4629 to i32
  %4631 = load ptr, ptr %4, align 8, !tbaa !5
  %4632 = getelementptr inbounds i8, ptr %4631, i32 1
  store ptr %4632, ptr %4, align 8, !tbaa !5
  %4633 = load i8, ptr %4631, align 1, !tbaa !9
  %4634 = zext i8 %4633 to i32
  %4635 = xor i32 %4630, %4634
  %4636 = trunc i32 %4635 to i8
  %4637 = load ptr, ptr %6, align 8, !tbaa !5
  %4638 = getelementptr inbounds i8, ptr %4637, i64 3
  store i8 %4636, ptr %4638, align 1, !tbaa !9
  %4639 = load ptr, ptr %6, align 8, !tbaa !5
  %4640 = getelementptr inbounds i8, ptr %4639, i64 4
  %4641 = load i8, ptr %4640, align 1, !tbaa !9
  %4642 = zext i8 %4641 to i32
  %4643 = load ptr, ptr %4, align 8, !tbaa !5
  %4644 = getelementptr inbounds i8, ptr %4643, i32 1
  store ptr %4644, ptr %4, align 8, !tbaa !5
  %4645 = load i8, ptr %4643, align 1, !tbaa !9
  %4646 = zext i8 %4645 to i32
  %4647 = xor i32 %4642, %4646
  %4648 = trunc i32 %4647 to i8
  %4649 = load ptr, ptr %6, align 8, !tbaa !5
  %4650 = getelementptr inbounds i8, ptr %4649, i64 4
  store i8 %4648, ptr %4650, align 1, !tbaa !9
  %4651 = load ptr, ptr %6, align 8, !tbaa !5
  %4652 = getelementptr inbounds i8, ptr %4651, i64 5
  %4653 = load i8, ptr %4652, align 1, !tbaa !9
  %4654 = zext i8 %4653 to i32
  %4655 = load ptr, ptr %4, align 8, !tbaa !5
  %4656 = getelementptr inbounds i8, ptr %4655, i32 1
  store ptr %4656, ptr %4, align 8, !tbaa !5
  %4657 = load i8, ptr %4655, align 1, !tbaa !9
  %4658 = zext i8 %4657 to i32
  %4659 = xor i32 %4654, %4658
  %4660 = trunc i32 %4659 to i8
  %4661 = load ptr, ptr %6, align 8, !tbaa !5
  %4662 = getelementptr inbounds i8, ptr %4661, i64 5
  store i8 %4660, ptr %4662, align 1, !tbaa !9
  %4663 = load ptr, ptr %6, align 8, !tbaa !5
  %4664 = getelementptr inbounds i8, ptr %4663, i64 6
  %4665 = load i8, ptr %4664, align 1, !tbaa !9
  %4666 = zext i8 %4665 to i32
  %4667 = load ptr, ptr %4, align 8, !tbaa !5
  %4668 = getelementptr inbounds i8, ptr %4667, i32 1
  store ptr %4668, ptr %4, align 8, !tbaa !5
  %4669 = load i8, ptr %4667, align 1, !tbaa !9
  %4670 = zext i8 %4669 to i32
  %4671 = xor i32 %4666, %4670
  %4672 = trunc i32 %4671 to i8
  %4673 = load ptr, ptr %6, align 8, !tbaa !5
  %4674 = getelementptr inbounds i8, ptr %4673, i64 6
  store i8 %4672, ptr %4674, align 1, !tbaa !9
  %4675 = load ptr, ptr %6, align 8, !tbaa !5
  %4676 = getelementptr inbounds i8, ptr %4675, i64 7
  %4677 = load i8, ptr %4676, align 1, !tbaa !9
  %4678 = zext i8 %4677 to i32
  %4679 = load ptr, ptr %4, align 8, !tbaa !5
  %4680 = getelementptr inbounds i8, ptr %4679, i32 1
  store ptr %4680, ptr %4, align 8, !tbaa !5
  %4681 = load i8, ptr %4679, align 1, !tbaa !9
  %4682 = zext i8 %4681 to i32
  %4683 = xor i32 %4678, %4682
  %4684 = trunc i32 %4683 to i8
  %4685 = load ptr, ptr %6, align 8, !tbaa !5
  %4686 = getelementptr inbounds i8, ptr %4685, i64 7
  store i8 %4684, ptr %4686, align 1, !tbaa !9
  %4687 = load ptr, ptr %6, align 8, !tbaa !5
  %4688 = getelementptr inbounds i8, ptr %4687, i64 8
  %4689 = load i8, ptr %4688, align 1, !tbaa !9
  %4690 = zext i8 %4689 to i32
  %4691 = load ptr, ptr %4, align 8, !tbaa !5
  %4692 = getelementptr inbounds i8, ptr %4691, i32 1
  store ptr %4692, ptr %4, align 8, !tbaa !5
  %4693 = load i8, ptr %4691, align 1, !tbaa !9
  %4694 = zext i8 %4693 to i32
  %4695 = xor i32 %4690, %4694
  %4696 = trunc i32 %4695 to i8
  %4697 = load ptr, ptr %6, align 8, !tbaa !5
  %4698 = getelementptr inbounds i8, ptr %4697, i64 8
  store i8 %4696, ptr %4698, align 1, !tbaa !9
  %4699 = load ptr, ptr %6, align 8, !tbaa !5
  %4700 = getelementptr inbounds i8, ptr %4699, i64 9
  %4701 = load i8, ptr %4700, align 1, !tbaa !9
  %4702 = zext i8 %4701 to i32
  %4703 = load ptr, ptr %4, align 8, !tbaa !5
  %4704 = getelementptr inbounds i8, ptr %4703, i32 1
  store ptr %4704, ptr %4, align 8, !tbaa !5
  %4705 = load i8, ptr %4703, align 1, !tbaa !9
  %4706 = zext i8 %4705 to i32
  %4707 = xor i32 %4702, %4706
  %4708 = trunc i32 %4707 to i8
  %4709 = load ptr, ptr %6, align 8, !tbaa !5
  %4710 = getelementptr inbounds i8, ptr %4709, i64 9
  store i8 %4708, ptr %4710, align 1, !tbaa !9
  %4711 = load ptr, ptr %6, align 8, !tbaa !5
  %4712 = getelementptr inbounds i8, ptr %4711, i64 10
  %4713 = load i8, ptr %4712, align 1, !tbaa !9
  %4714 = zext i8 %4713 to i32
  %4715 = load ptr, ptr %4, align 8, !tbaa !5
  %4716 = getelementptr inbounds i8, ptr %4715, i32 1
  store ptr %4716, ptr %4, align 8, !tbaa !5
  %4717 = load i8, ptr %4715, align 1, !tbaa !9
  %4718 = zext i8 %4717 to i32
  %4719 = xor i32 %4714, %4718
  %4720 = trunc i32 %4719 to i8
  %4721 = load ptr, ptr %6, align 8, !tbaa !5
  %4722 = getelementptr inbounds i8, ptr %4721, i64 10
  store i8 %4720, ptr %4722, align 1, !tbaa !9
  %4723 = load ptr, ptr %6, align 8, !tbaa !5
  %4724 = getelementptr inbounds i8, ptr %4723, i64 11
  %4725 = load i8, ptr %4724, align 1, !tbaa !9
  %4726 = zext i8 %4725 to i32
  %4727 = load ptr, ptr %4, align 8, !tbaa !5
  %4728 = getelementptr inbounds i8, ptr %4727, i32 1
  store ptr %4728, ptr %4, align 8, !tbaa !5
  %4729 = load i8, ptr %4727, align 1, !tbaa !9
  %4730 = zext i8 %4729 to i32
  %4731 = xor i32 %4726, %4730
  %4732 = trunc i32 %4731 to i8
  %4733 = load ptr, ptr %6, align 8, !tbaa !5
  %4734 = getelementptr inbounds i8, ptr %4733, i64 11
  store i8 %4732, ptr %4734, align 1, !tbaa !9
  %4735 = load ptr, ptr %6, align 8, !tbaa !5
  %4736 = getelementptr inbounds i8, ptr %4735, i64 12
  %4737 = load i8, ptr %4736, align 1, !tbaa !9
  %4738 = zext i8 %4737 to i32
  %4739 = load ptr, ptr %4, align 8, !tbaa !5
  %4740 = getelementptr inbounds i8, ptr %4739, i32 1
  store ptr %4740, ptr %4, align 8, !tbaa !5
  %4741 = load i8, ptr %4739, align 1, !tbaa !9
  %4742 = zext i8 %4741 to i32
  %4743 = xor i32 %4738, %4742
  %4744 = trunc i32 %4743 to i8
  %4745 = load ptr, ptr %6, align 8, !tbaa !5
  %4746 = getelementptr inbounds i8, ptr %4745, i64 12
  store i8 %4744, ptr %4746, align 1, !tbaa !9
  %4747 = load ptr, ptr %6, align 8, !tbaa !5
  %4748 = getelementptr inbounds i8, ptr %4747, i64 13
  %4749 = load i8, ptr %4748, align 1, !tbaa !9
  %4750 = zext i8 %4749 to i32
  %4751 = load ptr, ptr %4, align 8, !tbaa !5
  %4752 = getelementptr inbounds i8, ptr %4751, i32 1
  store ptr %4752, ptr %4, align 8, !tbaa !5
  %4753 = load i8, ptr %4751, align 1, !tbaa !9
  %4754 = zext i8 %4753 to i32
  %4755 = xor i32 %4750, %4754
  %4756 = trunc i32 %4755 to i8
  %4757 = load ptr, ptr %6, align 8, !tbaa !5
  %4758 = getelementptr inbounds i8, ptr %4757, i64 13
  store i8 %4756, ptr %4758, align 1, !tbaa !9
  %4759 = load ptr, ptr %6, align 8, !tbaa !5
  %4760 = getelementptr inbounds i8, ptr %4759, i64 14
  %4761 = load i8, ptr %4760, align 1, !tbaa !9
  %4762 = zext i8 %4761 to i32
  %4763 = load ptr, ptr %4, align 8, !tbaa !5
  %4764 = getelementptr inbounds i8, ptr %4763, i32 1
  store ptr %4764, ptr %4, align 8, !tbaa !5
  %4765 = load i8, ptr %4763, align 1, !tbaa !9
  %4766 = zext i8 %4765 to i32
  %4767 = xor i32 %4762, %4766
  %4768 = trunc i32 %4767 to i8
  %4769 = load ptr, ptr %6, align 8, !tbaa !5
  %4770 = getelementptr inbounds i8, ptr %4769, i64 14
  store i8 %4768, ptr %4770, align 1, !tbaa !9
  %4771 = load ptr, ptr %6, align 8, !tbaa !5
  %4772 = getelementptr inbounds i8, ptr %4771, i64 15
  %4773 = load i8, ptr %4772, align 1, !tbaa !9
  %4774 = zext i8 %4773 to i32
  %4775 = load ptr, ptr %4, align 8, !tbaa !5
  %4776 = getelementptr inbounds i8, ptr %4775, i32 1
  store ptr %4776, ptr %4, align 8, !tbaa !5
  %4777 = load i8, ptr %4775, align 1, !tbaa !9
  %4778 = zext i8 %4777 to i32
  %4779 = xor i32 %4774, %4778
  %4780 = trunc i32 %4779 to i8
  %4781 = load ptr, ptr %6, align 8, !tbaa !5
  %4782 = getelementptr inbounds i8, ptr %4781, i64 15
  store i8 %4780, ptr %4782, align 1, !tbaa !9
  %4783 = load ptr, ptr %6, align 8, !tbaa !5
  %4784 = load i8, ptr %4783, align 1, !tbaa !9
  %4785 = zext i8 %4784 to i64
  %4786 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4785
  %4787 = load i8, ptr %4786, align 1, !tbaa !9
  %4788 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  store i8 %4787, ptr %4788, align 16, !tbaa !9
  %4789 = load ptr, ptr %6, align 8, !tbaa !5
  %4790 = getelementptr inbounds i8, ptr %4789, i64 1
  %4791 = load i8, ptr %4790, align 1, !tbaa !9
  %4792 = zext i8 %4791 to i64
  %4793 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4792
  %4794 = load i8, ptr %4793, align 1, !tbaa !9
  %4795 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4796 = getelementptr inbounds i8, ptr %4795, i64 1
  store i8 %4794, ptr %4796, align 1, !tbaa !9
  %4797 = load ptr, ptr %6, align 8, !tbaa !5
  %4798 = getelementptr inbounds i8, ptr %4797, i64 2
  %4799 = load i8, ptr %4798, align 1, !tbaa !9
  %4800 = zext i8 %4799 to i64
  %4801 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4800
  %4802 = load i8, ptr %4801, align 1, !tbaa !9
  %4803 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4804 = getelementptr inbounds i8, ptr %4803, i64 2
  store i8 %4802, ptr %4804, align 1, !tbaa !9
  %4805 = load ptr, ptr %6, align 8, !tbaa !5
  %4806 = getelementptr inbounds i8, ptr %4805, i64 3
  %4807 = load i8, ptr %4806, align 1, !tbaa !9
  %4808 = zext i8 %4807 to i64
  %4809 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4808
  %4810 = load i8, ptr %4809, align 1, !tbaa !9
  %4811 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4812 = getelementptr inbounds i8, ptr %4811, i64 3
  store i8 %4810, ptr %4812, align 1, !tbaa !9
  %4813 = load ptr, ptr %6, align 8, !tbaa !5
  %4814 = getelementptr inbounds i8, ptr %4813, i64 4
  %4815 = load i8, ptr %4814, align 1, !tbaa !9
  %4816 = zext i8 %4815 to i64
  %4817 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4816
  %4818 = load i8, ptr %4817, align 1, !tbaa !9
  %4819 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4820 = getelementptr inbounds i8, ptr %4819, i64 4
  store i8 %4818, ptr %4820, align 1, !tbaa !9
  %4821 = load ptr, ptr %6, align 8, !tbaa !5
  %4822 = getelementptr inbounds i8, ptr %4821, i64 5
  %4823 = load i8, ptr %4822, align 1, !tbaa !9
  %4824 = zext i8 %4823 to i64
  %4825 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4824
  %4826 = load i8, ptr %4825, align 1, !tbaa !9
  %4827 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4828 = getelementptr inbounds i8, ptr %4827, i64 5
  store i8 %4826, ptr %4828, align 1, !tbaa !9
  %4829 = load ptr, ptr %6, align 8, !tbaa !5
  %4830 = getelementptr inbounds i8, ptr %4829, i64 6
  %4831 = load i8, ptr %4830, align 1, !tbaa !9
  %4832 = zext i8 %4831 to i64
  %4833 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4832
  %4834 = load i8, ptr %4833, align 1, !tbaa !9
  %4835 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4836 = getelementptr inbounds i8, ptr %4835, i64 6
  store i8 %4834, ptr %4836, align 1, !tbaa !9
  %4837 = load ptr, ptr %6, align 8, !tbaa !5
  %4838 = getelementptr inbounds i8, ptr %4837, i64 7
  %4839 = load i8, ptr %4838, align 1, !tbaa !9
  %4840 = zext i8 %4839 to i64
  %4841 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4840
  %4842 = load i8, ptr %4841, align 1, !tbaa !9
  %4843 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4844 = getelementptr inbounds i8, ptr %4843, i64 7
  store i8 %4842, ptr %4844, align 1, !tbaa !9
  %4845 = load ptr, ptr %6, align 8, !tbaa !5
  %4846 = getelementptr inbounds i8, ptr %4845, i64 8
  %4847 = load i8, ptr %4846, align 1, !tbaa !9
  %4848 = zext i8 %4847 to i64
  %4849 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4848
  %4850 = load i8, ptr %4849, align 1, !tbaa !9
  %4851 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4852 = getelementptr inbounds i8, ptr %4851, i64 8
  store i8 %4850, ptr %4852, align 1, !tbaa !9
  %4853 = load ptr, ptr %6, align 8, !tbaa !5
  %4854 = getelementptr inbounds i8, ptr %4853, i64 9
  %4855 = load i8, ptr %4854, align 1, !tbaa !9
  %4856 = zext i8 %4855 to i64
  %4857 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4856
  %4858 = load i8, ptr %4857, align 1, !tbaa !9
  %4859 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4860 = getelementptr inbounds i8, ptr %4859, i64 9
  store i8 %4858, ptr %4860, align 1, !tbaa !9
  %4861 = load ptr, ptr %6, align 8, !tbaa !5
  %4862 = getelementptr inbounds i8, ptr %4861, i64 10
  %4863 = load i8, ptr %4862, align 1, !tbaa !9
  %4864 = zext i8 %4863 to i64
  %4865 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4864
  %4866 = load i8, ptr %4865, align 1, !tbaa !9
  %4867 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4868 = getelementptr inbounds i8, ptr %4867, i64 10
  store i8 %4866, ptr %4868, align 1, !tbaa !9
  %4869 = load ptr, ptr %6, align 8, !tbaa !5
  %4870 = getelementptr inbounds i8, ptr %4869, i64 11
  %4871 = load i8, ptr %4870, align 1, !tbaa !9
  %4872 = zext i8 %4871 to i64
  %4873 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4872
  %4874 = load i8, ptr %4873, align 1, !tbaa !9
  %4875 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4876 = getelementptr inbounds i8, ptr %4875, i64 11
  store i8 %4874, ptr %4876, align 1, !tbaa !9
  %4877 = load ptr, ptr %6, align 8, !tbaa !5
  %4878 = getelementptr inbounds i8, ptr %4877, i64 12
  %4879 = load i8, ptr %4878, align 1, !tbaa !9
  %4880 = zext i8 %4879 to i64
  %4881 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4880
  %4882 = load i8, ptr %4881, align 1, !tbaa !9
  %4883 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4884 = getelementptr inbounds i8, ptr %4883, i64 12
  store i8 %4882, ptr %4884, align 1, !tbaa !9
  %4885 = load ptr, ptr %6, align 8, !tbaa !5
  %4886 = getelementptr inbounds i8, ptr %4885, i64 13
  %4887 = load i8, ptr %4886, align 1, !tbaa !9
  %4888 = zext i8 %4887 to i64
  %4889 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4888
  %4890 = load i8, ptr %4889, align 1, !tbaa !9
  %4891 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4892 = getelementptr inbounds i8, ptr %4891, i64 13
  store i8 %4890, ptr %4892, align 1, !tbaa !9
  %4893 = load ptr, ptr %6, align 8, !tbaa !5
  %4894 = getelementptr inbounds i8, ptr %4893, i64 14
  %4895 = load i8, ptr %4894, align 1, !tbaa !9
  %4896 = zext i8 %4895 to i64
  %4897 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4896
  %4898 = load i8, ptr %4897, align 1, !tbaa !9
  %4899 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4900 = getelementptr inbounds i8, ptr %4899, i64 14
  store i8 %4898, ptr %4900, align 1, !tbaa !9
  %4901 = load ptr, ptr %6, align 8, !tbaa !5
  %4902 = getelementptr inbounds i8, ptr %4901, i64 15
  %4903 = load i8, ptr %4902, align 1, !tbaa !9
  %4904 = zext i8 %4903 to i64
  %4905 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %4904
  %4906 = load i8, ptr %4905, align 1, !tbaa !9
  %4907 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4908 = getelementptr inbounds i8, ptr %4907, i64 15
  store i8 %4906, ptr %4908, align 1, !tbaa !9
  %4909 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4910 = getelementptr inbounds i8, ptr %4909, i64 1
  %4911 = load i8, ptr %4910, align 1, !tbaa !9
  store i8 %4911, ptr %8, align 1, !tbaa !9
  %4912 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4913 = getelementptr inbounds i8, ptr %4912, i64 5
  %4914 = load i8, ptr %4913, align 1, !tbaa !9
  %4915 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4916 = getelementptr inbounds i8, ptr %4915, i64 1
  store i8 %4914, ptr %4916, align 1, !tbaa !9
  %4917 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4918 = getelementptr inbounds i8, ptr %4917, i64 9
  %4919 = load i8, ptr %4918, align 1, !tbaa !9
  %4920 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4921 = getelementptr inbounds i8, ptr %4920, i64 5
  store i8 %4919, ptr %4921, align 1, !tbaa !9
  %4922 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4923 = getelementptr inbounds i8, ptr %4922, i64 13
  %4924 = load i8, ptr %4923, align 1, !tbaa !9
  %4925 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4926 = getelementptr inbounds i8, ptr %4925, i64 9
  store i8 %4924, ptr %4926, align 1, !tbaa !9
  %4927 = load i8, ptr %8, align 1, !tbaa !9
  %4928 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4929 = getelementptr inbounds i8, ptr %4928, i64 13
  store i8 %4927, ptr %4929, align 1, !tbaa !9
  %4930 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4931 = getelementptr inbounds i8, ptr %4930, i64 2
  %4932 = load i8, ptr %4931, align 1, !tbaa !9
  store i8 %4932, ptr %8, align 1, !tbaa !9
  %4933 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4934 = getelementptr inbounds i8, ptr %4933, i64 10
  %4935 = load i8, ptr %4934, align 1, !tbaa !9
  %4936 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4937 = getelementptr inbounds i8, ptr %4936, i64 2
  store i8 %4935, ptr %4937, align 1, !tbaa !9
  %4938 = load i8, ptr %8, align 1, !tbaa !9
  %4939 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4940 = getelementptr inbounds i8, ptr %4939, i64 10
  store i8 %4938, ptr %4940, align 1, !tbaa !9
  %4941 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4942 = getelementptr inbounds i8, ptr %4941, i64 6
  %4943 = load i8, ptr %4942, align 1, !tbaa !9
  store i8 %4943, ptr %8, align 1, !tbaa !9
  %4944 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4945 = getelementptr inbounds i8, ptr %4944, i64 14
  %4946 = load i8, ptr %4945, align 1, !tbaa !9
  %4947 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4948 = getelementptr inbounds i8, ptr %4947, i64 6
  store i8 %4946, ptr %4948, align 1, !tbaa !9
  %4949 = load i8, ptr %8, align 1, !tbaa !9
  %4950 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4951 = getelementptr inbounds i8, ptr %4950, i64 14
  store i8 %4949, ptr %4951, align 1, !tbaa !9
  %4952 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4953 = getelementptr inbounds i8, ptr %4952, i64 15
  %4954 = load i8, ptr %4953, align 1, !tbaa !9
  store i8 %4954, ptr %8, align 1, !tbaa !9
  %4955 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4956 = getelementptr inbounds i8, ptr %4955, i64 11
  %4957 = load i8, ptr %4956, align 1, !tbaa !9
  %4958 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4959 = getelementptr inbounds i8, ptr %4958, i64 15
  store i8 %4957, ptr %4959, align 1, !tbaa !9
  %4960 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4961 = getelementptr inbounds i8, ptr %4960, i64 7
  %4962 = load i8, ptr %4961, align 1, !tbaa !9
  %4963 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4964 = getelementptr inbounds i8, ptr %4963, i64 11
  store i8 %4962, ptr %4964, align 1, !tbaa !9
  %4965 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4966 = getelementptr inbounds i8, ptr %4965, i64 3
  %4967 = load i8, ptr %4966, align 1, !tbaa !9
  %4968 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4969 = getelementptr inbounds i8, ptr %4968, i64 7
  store i8 %4967, ptr %4969, align 1, !tbaa !9
  %4970 = load i8, ptr %8, align 1, !tbaa !9
  %4971 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4972 = getelementptr inbounds i8, ptr %4971, i64 3
  store i8 %4970, ptr %4972, align 1, !tbaa !9
  %4973 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4974 = load i8, ptr %4973, align 16, !tbaa !9
  %4975 = zext i8 %4974 to i32
  %4976 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %4977 = load i8, ptr %4976, align 1, !tbaa !9
  %4978 = zext i8 %4977 to i32
  %4979 = xor i32 %4975, %4978
  %4980 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %4981 = load i8, ptr %4980, align 2, !tbaa !9
  %4982 = zext i8 %4981 to i32
  %4983 = xor i32 %4979, %4982
  %4984 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %4985 = load i8, ptr %4984, align 1, !tbaa !9
  %4986 = zext i8 %4985 to i32
  %4987 = xor i32 %4983, %4986
  %4988 = trunc i32 %4987 to i8
  store i8 %4988, ptr %8, align 1, !tbaa !9
  %4989 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %4990 = load i8, ptr %4989, align 16, !tbaa !9
  %4991 = zext i8 %4990 to i32
  %4992 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %4993 = load i8, ptr %4992, align 1, !tbaa !9
  %4994 = zext i8 %4993 to i32
  %4995 = xor i32 %4991, %4994
  %4996 = trunc i32 %4995 to i8
  %4997 = call zeroext i8 @mul2(i8 noundef zeroext %4996)
  %4998 = zext i8 %4997 to i32
  %4999 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5000 = load i8, ptr %4999, align 16, !tbaa !9
  %5001 = zext i8 %5000 to i32
  %5002 = xor i32 %4998, %5001
  %5003 = load i8, ptr %8, align 1, !tbaa !9
  %5004 = zext i8 %5003 to i32
  %5005 = xor i32 %5002, %5004
  %5006 = trunc i32 %5005 to i8
  %5007 = load ptr, ptr %6, align 8, !tbaa !5
  %5008 = getelementptr inbounds i8, ptr %5007, i64 0
  store i8 %5006, ptr %5008, align 1, !tbaa !9
  %5009 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %5010 = load i8, ptr %5009, align 1, !tbaa !9
  %5011 = zext i8 %5010 to i32
  %5012 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %5013 = load i8, ptr %5012, align 2, !tbaa !9
  %5014 = zext i8 %5013 to i32
  %5015 = xor i32 %5011, %5014
  %5016 = trunc i32 %5015 to i8
  %5017 = call zeroext i8 @mul2(i8 noundef zeroext %5016)
  %5018 = zext i8 %5017 to i32
  %5019 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %5020 = load i8, ptr %5019, align 1, !tbaa !9
  %5021 = zext i8 %5020 to i32
  %5022 = xor i32 %5018, %5021
  %5023 = load i8, ptr %8, align 1, !tbaa !9
  %5024 = zext i8 %5023 to i32
  %5025 = xor i32 %5022, %5024
  %5026 = trunc i32 %5025 to i8
  %5027 = load ptr, ptr %6, align 8, !tbaa !5
  %5028 = getelementptr inbounds i8, ptr %5027, i64 1
  store i8 %5026, ptr %5028, align 1, !tbaa !9
  %5029 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %5030 = load i8, ptr %5029, align 2, !tbaa !9
  %5031 = zext i8 %5030 to i32
  %5032 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %5033 = load i8, ptr %5032, align 1, !tbaa !9
  %5034 = zext i8 %5033 to i32
  %5035 = xor i32 %5031, %5034
  %5036 = trunc i32 %5035 to i8
  %5037 = call zeroext i8 @mul2(i8 noundef zeroext %5036)
  %5038 = zext i8 %5037 to i32
  %5039 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %5040 = load i8, ptr %5039, align 2, !tbaa !9
  %5041 = zext i8 %5040 to i32
  %5042 = xor i32 %5038, %5041
  %5043 = load i8, ptr %8, align 1, !tbaa !9
  %5044 = zext i8 %5043 to i32
  %5045 = xor i32 %5042, %5044
  %5046 = trunc i32 %5045 to i8
  %5047 = load ptr, ptr %6, align 8, !tbaa !5
  %5048 = getelementptr inbounds i8, ptr %5047, i64 2
  store i8 %5046, ptr %5048, align 1, !tbaa !9
  %5049 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %5050 = load i8, ptr %5049, align 1, !tbaa !9
  %5051 = zext i8 %5050 to i32
  %5052 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5053 = load i8, ptr %5052, align 16, !tbaa !9
  %5054 = zext i8 %5053 to i32
  %5055 = xor i32 %5051, %5054
  %5056 = trunc i32 %5055 to i8
  %5057 = call zeroext i8 @mul2(i8 noundef zeroext %5056)
  %5058 = zext i8 %5057 to i32
  %5059 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %5060 = load i8, ptr %5059, align 1, !tbaa !9
  %5061 = zext i8 %5060 to i32
  %5062 = xor i32 %5058, %5061
  %5063 = load i8, ptr %8, align 1, !tbaa !9
  %5064 = zext i8 %5063 to i32
  %5065 = xor i32 %5062, %5064
  %5066 = trunc i32 %5065 to i8
  %5067 = load ptr, ptr %6, align 8, !tbaa !5
  %5068 = getelementptr inbounds i8, ptr %5067, i64 3
  store i8 %5066, ptr %5068, align 1, !tbaa !9
  %5069 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %5070 = load i8, ptr %5069, align 4, !tbaa !9
  %5071 = zext i8 %5070 to i32
  %5072 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %5073 = load i8, ptr %5072, align 1, !tbaa !9
  %5074 = zext i8 %5073 to i32
  %5075 = xor i32 %5071, %5074
  %5076 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %5077 = load i8, ptr %5076, align 2, !tbaa !9
  %5078 = zext i8 %5077 to i32
  %5079 = xor i32 %5075, %5078
  %5080 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %5081 = load i8, ptr %5080, align 1, !tbaa !9
  %5082 = zext i8 %5081 to i32
  %5083 = xor i32 %5079, %5082
  %5084 = trunc i32 %5083 to i8
  store i8 %5084, ptr %8, align 1, !tbaa !9
  %5085 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %5086 = load i8, ptr %5085, align 4, !tbaa !9
  %5087 = zext i8 %5086 to i32
  %5088 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %5089 = load i8, ptr %5088, align 1, !tbaa !9
  %5090 = zext i8 %5089 to i32
  %5091 = xor i32 %5087, %5090
  %5092 = trunc i32 %5091 to i8
  %5093 = call zeroext i8 @mul2(i8 noundef zeroext %5092)
  %5094 = zext i8 %5093 to i32
  %5095 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %5096 = load i8, ptr %5095, align 4, !tbaa !9
  %5097 = zext i8 %5096 to i32
  %5098 = xor i32 %5094, %5097
  %5099 = load i8, ptr %8, align 1, !tbaa !9
  %5100 = zext i8 %5099 to i32
  %5101 = xor i32 %5098, %5100
  %5102 = trunc i32 %5101 to i8
  %5103 = load ptr, ptr %6, align 8, !tbaa !5
  %5104 = getelementptr inbounds i8, ptr %5103, i64 4
  store i8 %5102, ptr %5104, align 1, !tbaa !9
  %5105 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %5106 = load i8, ptr %5105, align 1, !tbaa !9
  %5107 = zext i8 %5106 to i32
  %5108 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %5109 = load i8, ptr %5108, align 2, !tbaa !9
  %5110 = zext i8 %5109 to i32
  %5111 = xor i32 %5107, %5110
  %5112 = trunc i32 %5111 to i8
  %5113 = call zeroext i8 @mul2(i8 noundef zeroext %5112)
  %5114 = zext i8 %5113 to i32
  %5115 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %5116 = load i8, ptr %5115, align 1, !tbaa !9
  %5117 = zext i8 %5116 to i32
  %5118 = xor i32 %5114, %5117
  %5119 = load i8, ptr %8, align 1, !tbaa !9
  %5120 = zext i8 %5119 to i32
  %5121 = xor i32 %5118, %5120
  %5122 = trunc i32 %5121 to i8
  %5123 = load ptr, ptr %6, align 8, !tbaa !5
  %5124 = getelementptr inbounds i8, ptr %5123, i64 5
  store i8 %5122, ptr %5124, align 1, !tbaa !9
  %5125 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %5126 = load i8, ptr %5125, align 2, !tbaa !9
  %5127 = zext i8 %5126 to i32
  %5128 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %5129 = load i8, ptr %5128, align 1, !tbaa !9
  %5130 = zext i8 %5129 to i32
  %5131 = xor i32 %5127, %5130
  %5132 = trunc i32 %5131 to i8
  %5133 = call zeroext i8 @mul2(i8 noundef zeroext %5132)
  %5134 = zext i8 %5133 to i32
  %5135 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %5136 = load i8, ptr %5135, align 2, !tbaa !9
  %5137 = zext i8 %5136 to i32
  %5138 = xor i32 %5134, %5137
  %5139 = load i8, ptr %8, align 1, !tbaa !9
  %5140 = zext i8 %5139 to i32
  %5141 = xor i32 %5138, %5140
  %5142 = trunc i32 %5141 to i8
  %5143 = load ptr, ptr %6, align 8, !tbaa !5
  %5144 = getelementptr inbounds i8, ptr %5143, i64 6
  store i8 %5142, ptr %5144, align 1, !tbaa !9
  %5145 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %5146 = load i8, ptr %5145, align 1, !tbaa !9
  %5147 = zext i8 %5146 to i32
  %5148 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %5149 = load i8, ptr %5148, align 4, !tbaa !9
  %5150 = zext i8 %5149 to i32
  %5151 = xor i32 %5147, %5150
  %5152 = trunc i32 %5151 to i8
  %5153 = call zeroext i8 @mul2(i8 noundef zeroext %5152)
  %5154 = zext i8 %5153 to i32
  %5155 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %5156 = load i8, ptr %5155, align 1, !tbaa !9
  %5157 = zext i8 %5156 to i32
  %5158 = xor i32 %5154, %5157
  %5159 = load i8, ptr %8, align 1, !tbaa !9
  %5160 = zext i8 %5159 to i32
  %5161 = xor i32 %5158, %5160
  %5162 = trunc i32 %5161 to i8
  %5163 = load ptr, ptr %6, align 8, !tbaa !5
  %5164 = getelementptr inbounds i8, ptr %5163, i64 7
  store i8 %5162, ptr %5164, align 1, !tbaa !9
  %5165 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %5166 = load i8, ptr %5165, align 8, !tbaa !9
  %5167 = zext i8 %5166 to i32
  %5168 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %5169 = load i8, ptr %5168, align 1, !tbaa !9
  %5170 = zext i8 %5169 to i32
  %5171 = xor i32 %5167, %5170
  %5172 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %5173 = load i8, ptr %5172, align 2, !tbaa !9
  %5174 = zext i8 %5173 to i32
  %5175 = xor i32 %5171, %5174
  %5176 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %5177 = load i8, ptr %5176, align 1, !tbaa !9
  %5178 = zext i8 %5177 to i32
  %5179 = xor i32 %5175, %5178
  %5180 = trunc i32 %5179 to i8
  store i8 %5180, ptr %8, align 1, !tbaa !9
  %5181 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %5182 = load i8, ptr %5181, align 8, !tbaa !9
  %5183 = zext i8 %5182 to i32
  %5184 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %5185 = load i8, ptr %5184, align 1, !tbaa !9
  %5186 = zext i8 %5185 to i32
  %5187 = xor i32 %5183, %5186
  %5188 = trunc i32 %5187 to i8
  %5189 = call zeroext i8 @mul2(i8 noundef zeroext %5188)
  %5190 = zext i8 %5189 to i32
  %5191 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %5192 = load i8, ptr %5191, align 8, !tbaa !9
  %5193 = zext i8 %5192 to i32
  %5194 = xor i32 %5190, %5193
  %5195 = load i8, ptr %8, align 1, !tbaa !9
  %5196 = zext i8 %5195 to i32
  %5197 = xor i32 %5194, %5196
  %5198 = trunc i32 %5197 to i8
  %5199 = load ptr, ptr %6, align 8, !tbaa !5
  %5200 = getelementptr inbounds i8, ptr %5199, i64 8
  store i8 %5198, ptr %5200, align 1, !tbaa !9
  %5201 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %5202 = load i8, ptr %5201, align 1, !tbaa !9
  %5203 = zext i8 %5202 to i32
  %5204 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %5205 = load i8, ptr %5204, align 2, !tbaa !9
  %5206 = zext i8 %5205 to i32
  %5207 = xor i32 %5203, %5206
  %5208 = trunc i32 %5207 to i8
  %5209 = call zeroext i8 @mul2(i8 noundef zeroext %5208)
  %5210 = zext i8 %5209 to i32
  %5211 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %5212 = load i8, ptr %5211, align 1, !tbaa !9
  %5213 = zext i8 %5212 to i32
  %5214 = xor i32 %5210, %5213
  %5215 = load i8, ptr %8, align 1, !tbaa !9
  %5216 = zext i8 %5215 to i32
  %5217 = xor i32 %5214, %5216
  %5218 = trunc i32 %5217 to i8
  %5219 = load ptr, ptr %6, align 8, !tbaa !5
  %5220 = getelementptr inbounds i8, ptr %5219, i64 9
  store i8 %5218, ptr %5220, align 1, !tbaa !9
  %5221 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %5222 = load i8, ptr %5221, align 2, !tbaa !9
  %5223 = zext i8 %5222 to i32
  %5224 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %5225 = load i8, ptr %5224, align 1, !tbaa !9
  %5226 = zext i8 %5225 to i32
  %5227 = xor i32 %5223, %5226
  %5228 = trunc i32 %5227 to i8
  %5229 = call zeroext i8 @mul2(i8 noundef zeroext %5228)
  %5230 = zext i8 %5229 to i32
  %5231 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %5232 = load i8, ptr %5231, align 2, !tbaa !9
  %5233 = zext i8 %5232 to i32
  %5234 = xor i32 %5230, %5233
  %5235 = load i8, ptr %8, align 1, !tbaa !9
  %5236 = zext i8 %5235 to i32
  %5237 = xor i32 %5234, %5236
  %5238 = trunc i32 %5237 to i8
  %5239 = load ptr, ptr %6, align 8, !tbaa !5
  %5240 = getelementptr inbounds i8, ptr %5239, i64 10
  store i8 %5238, ptr %5240, align 1, !tbaa !9
  %5241 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %5242 = load i8, ptr %5241, align 1, !tbaa !9
  %5243 = zext i8 %5242 to i32
  %5244 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %5245 = load i8, ptr %5244, align 8, !tbaa !9
  %5246 = zext i8 %5245 to i32
  %5247 = xor i32 %5243, %5246
  %5248 = trunc i32 %5247 to i8
  %5249 = call zeroext i8 @mul2(i8 noundef zeroext %5248)
  %5250 = zext i8 %5249 to i32
  %5251 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %5252 = load i8, ptr %5251, align 1, !tbaa !9
  %5253 = zext i8 %5252 to i32
  %5254 = xor i32 %5250, %5253
  %5255 = load i8, ptr %8, align 1, !tbaa !9
  %5256 = zext i8 %5255 to i32
  %5257 = xor i32 %5254, %5256
  %5258 = trunc i32 %5257 to i8
  %5259 = load ptr, ptr %6, align 8, !tbaa !5
  %5260 = getelementptr inbounds i8, ptr %5259, i64 11
  store i8 %5258, ptr %5260, align 1, !tbaa !9
  %5261 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %5262 = load i8, ptr %5261, align 4, !tbaa !9
  %5263 = zext i8 %5262 to i32
  %5264 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %5265 = load i8, ptr %5264, align 1, !tbaa !9
  %5266 = zext i8 %5265 to i32
  %5267 = xor i32 %5263, %5266
  %5268 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %5269 = load i8, ptr %5268, align 2, !tbaa !9
  %5270 = zext i8 %5269 to i32
  %5271 = xor i32 %5267, %5270
  %5272 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %5273 = load i8, ptr %5272, align 1, !tbaa !9
  %5274 = zext i8 %5273 to i32
  %5275 = xor i32 %5271, %5274
  %5276 = trunc i32 %5275 to i8
  store i8 %5276, ptr %8, align 1, !tbaa !9
  %5277 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %5278 = load i8, ptr %5277, align 4, !tbaa !9
  %5279 = zext i8 %5278 to i32
  %5280 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %5281 = load i8, ptr %5280, align 1, !tbaa !9
  %5282 = zext i8 %5281 to i32
  %5283 = xor i32 %5279, %5282
  %5284 = trunc i32 %5283 to i8
  %5285 = call zeroext i8 @mul2(i8 noundef zeroext %5284)
  %5286 = zext i8 %5285 to i32
  %5287 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %5288 = load i8, ptr %5287, align 4, !tbaa !9
  %5289 = zext i8 %5288 to i32
  %5290 = xor i32 %5286, %5289
  %5291 = load i8, ptr %8, align 1, !tbaa !9
  %5292 = zext i8 %5291 to i32
  %5293 = xor i32 %5290, %5292
  %5294 = trunc i32 %5293 to i8
  %5295 = load ptr, ptr %6, align 8, !tbaa !5
  %5296 = getelementptr inbounds i8, ptr %5295, i64 12
  store i8 %5294, ptr %5296, align 1, !tbaa !9
  %5297 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %5298 = load i8, ptr %5297, align 1, !tbaa !9
  %5299 = zext i8 %5298 to i32
  %5300 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %5301 = load i8, ptr %5300, align 2, !tbaa !9
  %5302 = zext i8 %5301 to i32
  %5303 = xor i32 %5299, %5302
  %5304 = trunc i32 %5303 to i8
  %5305 = call zeroext i8 @mul2(i8 noundef zeroext %5304)
  %5306 = zext i8 %5305 to i32
  %5307 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %5308 = load i8, ptr %5307, align 1, !tbaa !9
  %5309 = zext i8 %5308 to i32
  %5310 = xor i32 %5306, %5309
  %5311 = load i8, ptr %8, align 1, !tbaa !9
  %5312 = zext i8 %5311 to i32
  %5313 = xor i32 %5310, %5312
  %5314 = trunc i32 %5313 to i8
  %5315 = load ptr, ptr %6, align 8, !tbaa !5
  %5316 = getelementptr inbounds i8, ptr %5315, i64 13
  store i8 %5314, ptr %5316, align 1, !tbaa !9
  %5317 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %5318 = load i8, ptr %5317, align 2, !tbaa !9
  %5319 = zext i8 %5318 to i32
  %5320 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %5321 = load i8, ptr %5320, align 1, !tbaa !9
  %5322 = zext i8 %5321 to i32
  %5323 = xor i32 %5319, %5322
  %5324 = trunc i32 %5323 to i8
  %5325 = call zeroext i8 @mul2(i8 noundef zeroext %5324)
  %5326 = zext i8 %5325 to i32
  %5327 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %5328 = load i8, ptr %5327, align 2, !tbaa !9
  %5329 = zext i8 %5328 to i32
  %5330 = xor i32 %5326, %5329
  %5331 = load i8, ptr %8, align 1, !tbaa !9
  %5332 = zext i8 %5331 to i32
  %5333 = xor i32 %5330, %5332
  %5334 = trunc i32 %5333 to i8
  %5335 = load ptr, ptr %6, align 8, !tbaa !5
  %5336 = getelementptr inbounds i8, ptr %5335, i64 14
  store i8 %5334, ptr %5336, align 1, !tbaa !9
  %5337 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %5338 = load i8, ptr %5337, align 1, !tbaa !9
  %5339 = zext i8 %5338 to i32
  %5340 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %5341 = load i8, ptr %5340, align 4, !tbaa !9
  %5342 = zext i8 %5341 to i32
  %5343 = xor i32 %5339, %5342
  %5344 = trunc i32 %5343 to i8
  %5345 = call zeroext i8 @mul2(i8 noundef zeroext %5344)
  %5346 = zext i8 %5345 to i32
  %5347 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %5348 = load i8, ptr %5347, align 1, !tbaa !9
  %5349 = zext i8 %5348 to i32
  %5350 = xor i32 %5346, %5349
  %5351 = load i8, ptr %8, align 1, !tbaa !9
  %5352 = zext i8 %5351 to i32
  %5353 = xor i32 %5350, %5352
  %5354 = trunc i32 %5353 to i8
  %5355 = load ptr, ptr %6, align 8, !tbaa !5
  %5356 = getelementptr inbounds i8, ptr %5355, i64 15
  store i8 %5354, ptr %5356, align 1, !tbaa !9
  %5357 = load ptr, ptr %6, align 8, !tbaa !5
  %5358 = load i8, ptr %5357, align 1, !tbaa !9
  %5359 = zext i8 %5358 to i32
  %5360 = load ptr, ptr %4, align 8, !tbaa !5
  %5361 = getelementptr inbounds i8, ptr %5360, i32 1
  store ptr %5361, ptr %4, align 8, !tbaa !5
  %5362 = load i8, ptr %5360, align 1, !tbaa !9
  %5363 = zext i8 %5362 to i32
  %5364 = xor i32 %5359, %5363
  %5365 = trunc i32 %5364 to i8
  %5366 = load ptr, ptr %6, align 8, !tbaa !5
  store i8 %5365, ptr %5366, align 1, !tbaa !9
  %5367 = load ptr, ptr %6, align 8, !tbaa !5
  %5368 = getelementptr inbounds i8, ptr %5367, i64 1
  %5369 = load i8, ptr %5368, align 1, !tbaa !9
  %5370 = zext i8 %5369 to i32
  %5371 = load ptr, ptr %4, align 8, !tbaa !5
  %5372 = getelementptr inbounds i8, ptr %5371, i32 1
  store ptr %5372, ptr %4, align 8, !tbaa !5
  %5373 = load i8, ptr %5371, align 1, !tbaa !9
  %5374 = zext i8 %5373 to i32
  %5375 = xor i32 %5370, %5374
  %5376 = trunc i32 %5375 to i8
  %5377 = load ptr, ptr %6, align 8, !tbaa !5
  %5378 = getelementptr inbounds i8, ptr %5377, i64 1
  store i8 %5376, ptr %5378, align 1, !tbaa !9
  %5379 = load ptr, ptr %6, align 8, !tbaa !5
  %5380 = getelementptr inbounds i8, ptr %5379, i64 2
  %5381 = load i8, ptr %5380, align 1, !tbaa !9
  %5382 = zext i8 %5381 to i32
  %5383 = load ptr, ptr %4, align 8, !tbaa !5
  %5384 = getelementptr inbounds i8, ptr %5383, i32 1
  store ptr %5384, ptr %4, align 8, !tbaa !5
  %5385 = load i8, ptr %5383, align 1, !tbaa !9
  %5386 = zext i8 %5385 to i32
  %5387 = xor i32 %5382, %5386
  %5388 = trunc i32 %5387 to i8
  %5389 = load ptr, ptr %6, align 8, !tbaa !5
  %5390 = getelementptr inbounds i8, ptr %5389, i64 2
  store i8 %5388, ptr %5390, align 1, !tbaa !9
  %5391 = load ptr, ptr %6, align 8, !tbaa !5
  %5392 = getelementptr inbounds i8, ptr %5391, i64 3
  %5393 = load i8, ptr %5392, align 1, !tbaa !9
  %5394 = zext i8 %5393 to i32
  %5395 = load ptr, ptr %4, align 8, !tbaa !5
  %5396 = getelementptr inbounds i8, ptr %5395, i32 1
  store ptr %5396, ptr %4, align 8, !tbaa !5
  %5397 = load i8, ptr %5395, align 1, !tbaa !9
  %5398 = zext i8 %5397 to i32
  %5399 = xor i32 %5394, %5398
  %5400 = trunc i32 %5399 to i8
  %5401 = load ptr, ptr %6, align 8, !tbaa !5
  %5402 = getelementptr inbounds i8, ptr %5401, i64 3
  store i8 %5400, ptr %5402, align 1, !tbaa !9
  %5403 = load ptr, ptr %6, align 8, !tbaa !5
  %5404 = getelementptr inbounds i8, ptr %5403, i64 4
  %5405 = load i8, ptr %5404, align 1, !tbaa !9
  %5406 = zext i8 %5405 to i32
  %5407 = load ptr, ptr %4, align 8, !tbaa !5
  %5408 = getelementptr inbounds i8, ptr %5407, i32 1
  store ptr %5408, ptr %4, align 8, !tbaa !5
  %5409 = load i8, ptr %5407, align 1, !tbaa !9
  %5410 = zext i8 %5409 to i32
  %5411 = xor i32 %5406, %5410
  %5412 = trunc i32 %5411 to i8
  %5413 = load ptr, ptr %6, align 8, !tbaa !5
  %5414 = getelementptr inbounds i8, ptr %5413, i64 4
  store i8 %5412, ptr %5414, align 1, !tbaa !9
  %5415 = load ptr, ptr %6, align 8, !tbaa !5
  %5416 = getelementptr inbounds i8, ptr %5415, i64 5
  %5417 = load i8, ptr %5416, align 1, !tbaa !9
  %5418 = zext i8 %5417 to i32
  %5419 = load ptr, ptr %4, align 8, !tbaa !5
  %5420 = getelementptr inbounds i8, ptr %5419, i32 1
  store ptr %5420, ptr %4, align 8, !tbaa !5
  %5421 = load i8, ptr %5419, align 1, !tbaa !9
  %5422 = zext i8 %5421 to i32
  %5423 = xor i32 %5418, %5422
  %5424 = trunc i32 %5423 to i8
  %5425 = load ptr, ptr %6, align 8, !tbaa !5
  %5426 = getelementptr inbounds i8, ptr %5425, i64 5
  store i8 %5424, ptr %5426, align 1, !tbaa !9
  %5427 = load ptr, ptr %6, align 8, !tbaa !5
  %5428 = getelementptr inbounds i8, ptr %5427, i64 6
  %5429 = load i8, ptr %5428, align 1, !tbaa !9
  %5430 = zext i8 %5429 to i32
  %5431 = load ptr, ptr %4, align 8, !tbaa !5
  %5432 = getelementptr inbounds i8, ptr %5431, i32 1
  store ptr %5432, ptr %4, align 8, !tbaa !5
  %5433 = load i8, ptr %5431, align 1, !tbaa !9
  %5434 = zext i8 %5433 to i32
  %5435 = xor i32 %5430, %5434
  %5436 = trunc i32 %5435 to i8
  %5437 = load ptr, ptr %6, align 8, !tbaa !5
  %5438 = getelementptr inbounds i8, ptr %5437, i64 6
  store i8 %5436, ptr %5438, align 1, !tbaa !9
  %5439 = load ptr, ptr %6, align 8, !tbaa !5
  %5440 = getelementptr inbounds i8, ptr %5439, i64 7
  %5441 = load i8, ptr %5440, align 1, !tbaa !9
  %5442 = zext i8 %5441 to i32
  %5443 = load ptr, ptr %4, align 8, !tbaa !5
  %5444 = getelementptr inbounds i8, ptr %5443, i32 1
  store ptr %5444, ptr %4, align 8, !tbaa !5
  %5445 = load i8, ptr %5443, align 1, !tbaa !9
  %5446 = zext i8 %5445 to i32
  %5447 = xor i32 %5442, %5446
  %5448 = trunc i32 %5447 to i8
  %5449 = load ptr, ptr %6, align 8, !tbaa !5
  %5450 = getelementptr inbounds i8, ptr %5449, i64 7
  store i8 %5448, ptr %5450, align 1, !tbaa !9
  %5451 = load ptr, ptr %6, align 8, !tbaa !5
  %5452 = getelementptr inbounds i8, ptr %5451, i64 8
  %5453 = load i8, ptr %5452, align 1, !tbaa !9
  %5454 = zext i8 %5453 to i32
  %5455 = load ptr, ptr %4, align 8, !tbaa !5
  %5456 = getelementptr inbounds i8, ptr %5455, i32 1
  store ptr %5456, ptr %4, align 8, !tbaa !5
  %5457 = load i8, ptr %5455, align 1, !tbaa !9
  %5458 = zext i8 %5457 to i32
  %5459 = xor i32 %5454, %5458
  %5460 = trunc i32 %5459 to i8
  %5461 = load ptr, ptr %6, align 8, !tbaa !5
  %5462 = getelementptr inbounds i8, ptr %5461, i64 8
  store i8 %5460, ptr %5462, align 1, !tbaa !9
  %5463 = load ptr, ptr %6, align 8, !tbaa !5
  %5464 = getelementptr inbounds i8, ptr %5463, i64 9
  %5465 = load i8, ptr %5464, align 1, !tbaa !9
  %5466 = zext i8 %5465 to i32
  %5467 = load ptr, ptr %4, align 8, !tbaa !5
  %5468 = getelementptr inbounds i8, ptr %5467, i32 1
  store ptr %5468, ptr %4, align 8, !tbaa !5
  %5469 = load i8, ptr %5467, align 1, !tbaa !9
  %5470 = zext i8 %5469 to i32
  %5471 = xor i32 %5466, %5470
  %5472 = trunc i32 %5471 to i8
  %5473 = load ptr, ptr %6, align 8, !tbaa !5
  %5474 = getelementptr inbounds i8, ptr %5473, i64 9
  store i8 %5472, ptr %5474, align 1, !tbaa !9
  %5475 = load ptr, ptr %6, align 8, !tbaa !5
  %5476 = getelementptr inbounds i8, ptr %5475, i64 10
  %5477 = load i8, ptr %5476, align 1, !tbaa !9
  %5478 = zext i8 %5477 to i32
  %5479 = load ptr, ptr %4, align 8, !tbaa !5
  %5480 = getelementptr inbounds i8, ptr %5479, i32 1
  store ptr %5480, ptr %4, align 8, !tbaa !5
  %5481 = load i8, ptr %5479, align 1, !tbaa !9
  %5482 = zext i8 %5481 to i32
  %5483 = xor i32 %5478, %5482
  %5484 = trunc i32 %5483 to i8
  %5485 = load ptr, ptr %6, align 8, !tbaa !5
  %5486 = getelementptr inbounds i8, ptr %5485, i64 10
  store i8 %5484, ptr %5486, align 1, !tbaa !9
  %5487 = load ptr, ptr %6, align 8, !tbaa !5
  %5488 = getelementptr inbounds i8, ptr %5487, i64 11
  %5489 = load i8, ptr %5488, align 1, !tbaa !9
  %5490 = zext i8 %5489 to i32
  %5491 = load ptr, ptr %4, align 8, !tbaa !5
  %5492 = getelementptr inbounds i8, ptr %5491, i32 1
  store ptr %5492, ptr %4, align 8, !tbaa !5
  %5493 = load i8, ptr %5491, align 1, !tbaa !9
  %5494 = zext i8 %5493 to i32
  %5495 = xor i32 %5490, %5494
  %5496 = trunc i32 %5495 to i8
  %5497 = load ptr, ptr %6, align 8, !tbaa !5
  %5498 = getelementptr inbounds i8, ptr %5497, i64 11
  store i8 %5496, ptr %5498, align 1, !tbaa !9
  %5499 = load ptr, ptr %6, align 8, !tbaa !5
  %5500 = getelementptr inbounds i8, ptr %5499, i64 12
  %5501 = load i8, ptr %5500, align 1, !tbaa !9
  %5502 = zext i8 %5501 to i32
  %5503 = load ptr, ptr %4, align 8, !tbaa !5
  %5504 = getelementptr inbounds i8, ptr %5503, i32 1
  store ptr %5504, ptr %4, align 8, !tbaa !5
  %5505 = load i8, ptr %5503, align 1, !tbaa !9
  %5506 = zext i8 %5505 to i32
  %5507 = xor i32 %5502, %5506
  %5508 = trunc i32 %5507 to i8
  %5509 = load ptr, ptr %6, align 8, !tbaa !5
  %5510 = getelementptr inbounds i8, ptr %5509, i64 12
  store i8 %5508, ptr %5510, align 1, !tbaa !9
  %5511 = load ptr, ptr %6, align 8, !tbaa !5
  %5512 = getelementptr inbounds i8, ptr %5511, i64 13
  %5513 = load i8, ptr %5512, align 1, !tbaa !9
  %5514 = zext i8 %5513 to i32
  %5515 = load ptr, ptr %4, align 8, !tbaa !5
  %5516 = getelementptr inbounds i8, ptr %5515, i32 1
  store ptr %5516, ptr %4, align 8, !tbaa !5
  %5517 = load i8, ptr %5515, align 1, !tbaa !9
  %5518 = zext i8 %5517 to i32
  %5519 = xor i32 %5514, %5518
  %5520 = trunc i32 %5519 to i8
  %5521 = load ptr, ptr %6, align 8, !tbaa !5
  %5522 = getelementptr inbounds i8, ptr %5521, i64 13
  store i8 %5520, ptr %5522, align 1, !tbaa !9
  %5523 = load ptr, ptr %6, align 8, !tbaa !5
  %5524 = getelementptr inbounds i8, ptr %5523, i64 14
  %5525 = load i8, ptr %5524, align 1, !tbaa !9
  %5526 = zext i8 %5525 to i32
  %5527 = load ptr, ptr %4, align 8, !tbaa !5
  %5528 = getelementptr inbounds i8, ptr %5527, i32 1
  store ptr %5528, ptr %4, align 8, !tbaa !5
  %5529 = load i8, ptr %5527, align 1, !tbaa !9
  %5530 = zext i8 %5529 to i32
  %5531 = xor i32 %5526, %5530
  %5532 = trunc i32 %5531 to i8
  %5533 = load ptr, ptr %6, align 8, !tbaa !5
  %5534 = getelementptr inbounds i8, ptr %5533, i64 14
  store i8 %5532, ptr %5534, align 1, !tbaa !9
  %5535 = load ptr, ptr %6, align 8, !tbaa !5
  %5536 = getelementptr inbounds i8, ptr %5535, i64 15
  %5537 = load i8, ptr %5536, align 1, !tbaa !9
  %5538 = zext i8 %5537 to i32
  %5539 = load ptr, ptr %4, align 8, !tbaa !5
  %5540 = getelementptr inbounds i8, ptr %5539, i32 1
  store ptr %5540, ptr %4, align 8, !tbaa !5
  %5541 = load i8, ptr %5539, align 1, !tbaa !9
  %5542 = zext i8 %5541 to i32
  %5543 = xor i32 %5538, %5542
  %5544 = trunc i32 %5543 to i8
  %5545 = load ptr, ptr %6, align 8, !tbaa !5
  %5546 = getelementptr inbounds i8, ptr %5545, i64 15
  store i8 %5544, ptr %5546, align 1, !tbaa !9
  %5547 = load ptr, ptr %6, align 8, !tbaa !5
  %5548 = load i8, ptr %5547, align 1, !tbaa !9
  %5549 = zext i8 %5548 to i64
  %5550 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5549
  %5551 = load i8, ptr %5550, align 1, !tbaa !9
  %5552 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  store i8 %5551, ptr %5552, align 16, !tbaa !9
  %5553 = load ptr, ptr %6, align 8, !tbaa !5
  %5554 = getelementptr inbounds i8, ptr %5553, i64 1
  %5555 = load i8, ptr %5554, align 1, !tbaa !9
  %5556 = zext i8 %5555 to i64
  %5557 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5556
  %5558 = load i8, ptr %5557, align 1, !tbaa !9
  %5559 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5560 = getelementptr inbounds i8, ptr %5559, i64 1
  store i8 %5558, ptr %5560, align 1, !tbaa !9
  %5561 = load ptr, ptr %6, align 8, !tbaa !5
  %5562 = getelementptr inbounds i8, ptr %5561, i64 2
  %5563 = load i8, ptr %5562, align 1, !tbaa !9
  %5564 = zext i8 %5563 to i64
  %5565 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5564
  %5566 = load i8, ptr %5565, align 1, !tbaa !9
  %5567 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5568 = getelementptr inbounds i8, ptr %5567, i64 2
  store i8 %5566, ptr %5568, align 1, !tbaa !9
  %5569 = load ptr, ptr %6, align 8, !tbaa !5
  %5570 = getelementptr inbounds i8, ptr %5569, i64 3
  %5571 = load i8, ptr %5570, align 1, !tbaa !9
  %5572 = zext i8 %5571 to i64
  %5573 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5572
  %5574 = load i8, ptr %5573, align 1, !tbaa !9
  %5575 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5576 = getelementptr inbounds i8, ptr %5575, i64 3
  store i8 %5574, ptr %5576, align 1, !tbaa !9
  %5577 = load ptr, ptr %6, align 8, !tbaa !5
  %5578 = getelementptr inbounds i8, ptr %5577, i64 4
  %5579 = load i8, ptr %5578, align 1, !tbaa !9
  %5580 = zext i8 %5579 to i64
  %5581 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5580
  %5582 = load i8, ptr %5581, align 1, !tbaa !9
  %5583 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5584 = getelementptr inbounds i8, ptr %5583, i64 4
  store i8 %5582, ptr %5584, align 1, !tbaa !9
  %5585 = load ptr, ptr %6, align 8, !tbaa !5
  %5586 = getelementptr inbounds i8, ptr %5585, i64 5
  %5587 = load i8, ptr %5586, align 1, !tbaa !9
  %5588 = zext i8 %5587 to i64
  %5589 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5588
  %5590 = load i8, ptr %5589, align 1, !tbaa !9
  %5591 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5592 = getelementptr inbounds i8, ptr %5591, i64 5
  store i8 %5590, ptr %5592, align 1, !tbaa !9
  %5593 = load ptr, ptr %6, align 8, !tbaa !5
  %5594 = getelementptr inbounds i8, ptr %5593, i64 6
  %5595 = load i8, ptr %5594, align 1, !tbaa !9
  %5596 = zext i8 %5595 to i64
  %5597 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5596
  %5598 = load i8, ptr %5597, align 1, !tbaa !9
  %5599 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5600 = getelementptr inbounds i8, ptr %5599, i64 6
  store i8 %5598, ptr %5600, align 1, !tbaa !9
  %5601 = load ptr, ptr %6, align 8, !tbaa !5
  %5602 = getelementptr inbounds i8, ptr %5601, i64 7
  %5603 = load i8, ptr %5602, align 1, !tbaa !9
  %5604 = zext i8 %5603 to i64
  %5605 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5604
  %5606 = load i8, ptr %5605, align 1, !tbaa !9
  %5607 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5608 = getelementptr inbounds i8, ptr %5607, i64 7
  store i8 %5606, ptr %5608, align 1, !tbaa !9
  %5609 = load ptr, ptr %6, align 8, !tbaa !5
  %5610 = getelementptr inbounds i8, ptr %5609, i64 8
  %5611 = load i8, ptr %5610, align 1, !tbaa !9
  %5612 = zext i8 %5611 to i64
  %5613 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5612
  %5614 = load i8, ptr %5613, align 1, !tbaa !9
  %5615 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5616 = getelementptr inbounds i8, ptr %5615, i64 8
  store i8 %5614, ptr %5616, align 1, !tbaa !9
  %5617 = load ptr, ptr %6, align 8, !tbaa !5
  %5618 = getelementptr inbounds i8, ptr %5617, i64 9
  %5619 = load i8, ptr %5618, align 1, !tbaa !9
  %5620 = zext i8 %5619 to i64
  %5621 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5620
  %5622 = load i8, ptr %5621, align 1, !tbaa !9
  %5623 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5624 = getelementptr inbounds i8, ptr %5623, i64 9
  store i8 %5622, ptr %5624, align 1, !tbaa !9
  %5625 = load ptr, ptr %6, align 8, !tbaa !5
  %5626 = getelementptr inbounds i8, ptr %5625, i64 10
  %5627 = load i8, ptr %5626, align 1, !tbaa !9
  %5628 = zext i8 %5627 to i64
  %5629 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5628
  %5630 = load i8, ptr %5629, align 1, !tbaa !9
  %5631 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5632 = getelementptr inbounds i8, ptr %5631, i64 10
  store i8 %5630, ptr %5632, align 1, !tbaa !9
  %5633 = load ptr, ptr %6, align 8, !tbaa !5
  %5634 = getelementptr inbounds i8, ptr %5633, i64 11
  %5635 = load i8, ptr %5634, align 1, !tbaa !9
  %5636 = zext i8 %5635 to i64
  %5637 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5636
  %5638 = load i8, ptr %5637, align 1, !tbaa !9
  %5639 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5640 = getelementptr inbounds i8, ptr %5639, i64 11
  store i8 %5638, ptr %5640, align 1, !tbaa !9
  %5641 = load ptr, ptr %6, align 8, !tbaa !5
  %5642 = getelementptr inbounds i8, ptr %5641, i64 12
  %5643 = load i8, ptr %5642, align 1, !tbaa !9
  %5644 = zext i8 %5643 to i64
  %5645 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5644
  %5646 = load i8, ptr %5645, align 1, !tbaa !9
  %5647 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5648 = getelementptr inbounds i8, ptr %5647, i64 12
  store i8 %5646, ptr %5648, align 1, !tbaa !9
  %5649 = load ptr, ptr %6, align 8, !tbaa !5
  %5650 = getelementptr inbounds i8, ptr %5649, i64 13
  %5651 = load i8, ptr %5650, align 1, !tbaa !9
  %5652 = zext i8 %5651 to i64
  %5653 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5652
  %5654 = load i8, ptr %5653, align 1, !tbaa !9
  %5655 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5656 = getelementptr inbounds i8, ptr %5655, i64 13
  store i8 %5654, ptr %5656, align 1, !tbaa !9
  %5657 = load ptr, ptr %6, align 8, !tbaa !5
  %5658 = getelementptr inbounds i8, ptr %5657, i64 14
  %5659 = load i8, ptr %5658, align 1, !tbaa !9
  %5660 = zext i8 %5659 to i64
  %5661 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5660
  %5662 = load i8, ptr %5661, align 1, !tbaa !9
  %5663 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5664 = getelementptr inbounds i8, ptr %5663, i64 14
  store i8 %5662, ptr %5664, align 1, !tbaa !9
  %5665 = load ptr, ptr %6, align 8, !tbaa !5
  %5666 = getelementptr inbounds i8, ptr %5665, i64 15
  %5667 = load i8, ptr %5666, align 1, !tbaa !9
  %5668 = zext i8 %5667 to i64
  %5669 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %5668
  %5670 = load i8, ptr %5669, align 1, !tbaa !9
  %5671 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5672 = getelementptr inbounds i8, ptr %5671, i64 15
  store i8 %5670, ptr %5672, align 1, !tbaa !9
  %5673 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5674 = getelementptr inbounds i8, ptr %5673, i64 1
  %5675 = load i8, ptr %5674, align 1, !tbaa !9
  store i8 %5675, ptr %8, align 1, !tbaa !9
  %5676 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5677 = getelementptr inbounds i8, ptr %5676, i64 5
  %5678 = load i8, ptr %5677, align 1, !tbaa !9
  %5679 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5680 = getelementptr inbounds i8, ptr %5679, i64 1
  store i8 %5678, ptr %5680, align 1, !tbaa !9
  %5681 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5682 = getelementptr inbounds i8, ptr %5681, i64 9
  %5683 = load i8, ptr %5682, align 1, !tbaa !9
  %5684 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5685 = getelementptr inbounds i8, ptr %5684, i64 5
  store i8 %5683, ptr %5685, align 1, !tbaa !9
  %5686 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5687 = getelementptr inbounds i8, ptr %5686, i64 13
  %5688 = load i8, ptr %5687, align 1, !tbaa !9
  %5689 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5690 = getelementptr inbounds i8, ptr %5689, i64 9
  store i8 %5688, ptr %5690, align 1, !tbaa !9
  %5691 = load i8, ptr %8, align 1, !tbaa !9
  %5692 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5693 = getelementptr inbounds i8, ptr %5692, i64 13
  store i8 %5691, ptr %5693, align 1, !tbaa !9
  %5694 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5695 = getelementptr inbounds i8, ptr %5694, i64 2
  %5696 = load i8, ptr %5695, align 1, !tbaa !9
  store i8 %5696, ptr %8, align 1, !tbaa !9
  %5697 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5698 = getelementptr inbounds i8, ptr %5697, i64 10
  %5699 = load i8, ptr %5698, align 1, !tbaa !9
  %5700 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5701 = getelementptr inbounds i8, ptr %5700, i64 2
  store i8 %5699, ptr %5701, align 1, !tbaa !9
  %5702 = load i8, ptr %8, align 1, !tbaa !9
  %5703 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5704 = getelementptr inbounds i8, ptr %5703, i64 10
  store i8 %5702, ptr %5704, align 1, !tbaa !9
  %5705 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5706 = getelementptr inbounds i8, ptr %5705, i64 6
  %5707 = load i8, ptr %5706, align 1, !tbaa !9
  store i8 %5707, ptr %8, align 1, !tbaa !9
  %5708 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5709 = getelementptr inbounds i8, ptr %5708, i64 14
  %5710 = load i8, ptr %5709, align 1, !tbaa !9
  %5711 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5712 = getelementptr inbounds i8, ptr %5711, i64 6
  store i8 %5710, ptr %5712, align 1, !tbaa !9
  %5713 = load i8, ptr %8, align 1, !tbaa !9
  %5714 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5715 = getelementptr inbounds i8, ptr %5714, i64 14
  store i8 %5713, ptr %5715, align 1, !tbaa !9
  %5716 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5717 = getelementptr inbounds i8, ptr %5716, i64 15
  %5718 = load i8, ptr %5717, align 1, !tbaa !9
  store i8 %5718, ptr %8, align 1, !tbaa !9
  %5719 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5720 = getelementptr inbounds i8, ptr %5719, i64 11
  %5721 = load i8, ptr %5720, align 1, !tbaa !9
  %5722 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5723 = getelementptr inbounds i8, ptr %5722, i64 15
  store i8 %5721, ptr %5723, align 1, !tbaa !9
  %5724 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5725 = getelementptr inbounds i8, ptr %5724, i64 7
  %5726 = load i8, ptr %5725, align 1, !tbaa !9
  %5727 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5728 = getelementptr inbounds i8, ptr %5727, i64 11
  store i8 %5726, ptr %5728, align 1, !tbaa !9
  %5729 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5730 = getelementptr inbounds i8, ptr %5729, i64 3
  %5731 = load i8, ptr %5730, align 1, !tbaa !9
  %5732 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5733 = getelementptr inbounds i8, ptr %5732, i64 7
  store i8 %5731, ptr %5733, align 1, !tbaa !9
  %5734 = load i8, ptr %8, align 1, !tbaa !9
  %5735 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5736 = getelementptr inbounds i8, ptr %5735, i64 3
  store i8 %5734, ptr %5736, align 1, !tbaa !9
  %5737 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5738 = load i8, ptr %5737, align 16, !tbaa !9
  %5739 = zext i8 %5738 to i32
  %5740 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %5741 = load i8, ptr %5740, align 1, !tbaa !9
  %5742 = zext i8 %5741 to i32
  %5743 = xor i32 %5739, %5742
  %5744 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %5745 = load i8, ptr %5744, align 2, !tbaa !9
  %5746 = zext i8 %5745 to i32
  %5747 = xor i32 %5743, %5746
  %5748 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %5749 = load i8, ptr %5748, align 1, !tbaa !9
  %5750 = zext i8 %5749 to i32
  %5751 = xor i32 %5747, %5750
  %5752 = trunc i32 %5751 to i8
  store i8 %5752, ptr %8, align 1, !tbaa !9
  %5753 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5754 = load i8, ptr %5753, align 16, !tbaa !9
  %5755 = zext i8 %5754 to i32
  %5756 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %5757 = load i8, ptr %5756, align 1, !tbaa !9
  %5758 = zext i8 %5757 to i32
  %5759 = xor i32 %5755, %5758
  %5760 = trunc i32 %5759 to i8
  %5761 = call zeroext i8 @mul2(i8 noundef zeroext %5760)
  %5762 = zext i8 %5761 to i32
  %5763 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5764 = load i8, ptr %5763, align 16, !tbaa !9
  %5765 = zext i8 %5764 to i32
  %5766 = xor i32 %5762, %5765
  %5767 = load i8, ptr %8, align 1, !tbaa !9
  %5768 = zext i8 %5767 to i32
  %5769 = xor i32 %5766, %5768
  %5770 = trunc i32 %5769 to i8
  %5771 = load ptr, ptr %6, align 8, !tbaa !5
  %5772 = getelementptr inbounds i8, ptr %5771, i64 0
  store i8 %5770, ptr %5772, align 1, !tbaa !9
  %5773 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %5774 = load i8, ptr %5773, align 1, !tbaa !9
  %5775 = zext i8 %5774 to i32
  %5776 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %5777 = load i8, ptr %5776, align 2, !tbaa !9
  %5778 = zext i8 %5777 to i32
  %5779 = xor i32 %5775, %5778
  %5780 = trunc i32 %5779 to i8
  %5781 = call zeroext i8 @mul2(i8 noundef zeroext %5780)
  %5782 = zext i8 %5781 to i32
  %5783 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %5784 = load i8, ptr %5783, align 1, !tbaa !9
  %5785 = zext i8 %5784 to i32
  %5786 = xor i32 %5782, %5785
  %5787 = load i8, ptr %8, align 1, !tbaa !9
  %5788 = zext i8 %5787 to i32
  %5789 = xor i32 %5786, %5788
  %5790 = trunc i32 %5789 to i8
  %5791 = load ptr, ptr %6, align 8, !tbaa !5
  %5792 = getelementptr inbounds i8, ptr %5791, i64 1
  store i8 %5790, ptr %5792, align 1, !tbaa !9
  %5793 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %5794 = load i8, ptr %5793, align 2, !tbaa !9
  %5795 = zext i8 %5794 to i32
  %5796 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %5797 = load i8, ptr %5796, align 1, !tbaa !9
  %5798 = zext i8 %5797 to i32
  %5799 = xor i32 %5795, %5798
  %5800 = trunc i32 %5799 to i8
  %5801 = call zeroext i8 @mul2(i8 noundef zeroext %5800)
  %5802 = zext i8 %5801 to i32
  %5803 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %5804 = load i8, ptr %5803, align 2, !tbaa !9
  %5805 = zext i8 %5804 to i32
  %5806 = xor i32 %5802, %5805
  %5807 = load i8, ptr %8, align 1, !tbaa !9
  %5808 = zext i8 %5807 to i32
  %5809 = xor i32 %5806, %5808
  %5810 = trunc i32 %5809 to i8
  %5811 = load ptr, ptr %6, align 8, !tbaa !5
  %5812 = getelementptr inbounds i8, ptr %5811, i64 2
  store i8 %5810, ptr %5812, align 1, !tbaa !9
  %5813 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %5814 = load i8, ptr %5813, align 1, !tbaa !9
  %5815 = zext i8 %5814 to i32
  %5816 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %5817 = load i8, ptr %5816, align 16, !tbaa !9
  %5818 = zext i8 %5817 to i32
  %5819 = xor i32 %5815, %5818
  %5820 = trunc i32 %5819 to i8
  %5821 = call zeroext i8 @mul2(i8 noundef zeroext %5820)
  %5822 = zext i8 %5821 to i32
  %5823 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %5824 = load i8, ptr %5823, align 1, !tbaa !9
  %5825 = zext i8 %5824 to i32
  %5826 = xor i32 %5822, %5825
  %5827 = load i8, ptr %8, align 1, !tbaa !9
  %5828 = zext i8 %5827 to i32
  %5829 = xor i32 %5826, %5828
  %5830 = trunc i32 %5829 to i8
  %5831 = load ptr, ptr %6, align 8, !tbaa !5
  %5832 = getelementptr inbounds i8, ptr %5831, i64 3
  store i8 %5830, ptr %5832, align 1, !tbaa !9
  %5833 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %5834 = load i8, ptr %5833, align 4, !tbaa !9
  %5835 = zext i8 %5834 to i32
  %5836 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %5837 = load i8, ptr %5836, align 1, !tbaa !9
  %5838 = zext i8 %5837 to i32
  %5839 = xor i32 %5835, %5838
  %5840 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %5841 = load i8, ptr %5840, align 2, !tbaa !9
  %5842 = zext i8 %5841 to i32
  %5843 = xor i32 %5839, %5842
  %5844 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %5845 = load i8, ptr %5844, align 1, !tbaa !9
  %5846 = zext i8 %5845 to i32
  %5847 = xor i32 %5843, %5846
  %5848 = trunc i32 %5847 to i8
  store i8 %5848, ptr %8, align 1, !tbaa !9
  %5849 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %5850 = load i8, ptr %5849, align 4, !tbaa !9
  %5851 = zext i8 %5850 to i32
  %5852 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %5853 = load i8, ptr %5852, align 1, !tbaa !9
  %5854 = zext i8 %5853 to i32
  %5855 = xor i32 %5851, %5854
  %5856 = trunc i32 %5855 to i8
  %5857 = call zeroext i8 @mul2(i8 noundef zeroext %5856)
  %5858 = zext i8 %5857 to i32
  %5859 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %5860 = load i8, ptr %5859, align 4, !tbaa !9
  %5861 = zext i8 %5860 to i32
  %5862 = xor i32 %5858, %5861
  %5863 = load i8, ptr %8, align 1, !tbaa !9
  %5864 = zext i8 %5863 to i32
  %5865 = xor i32 %5862, %5864
  %5866 = trunc i32 %5865 to i8
  %5867 = load ptr, ptr %6, align 8, !tbaa !5
  %5868 = getelementptr inbounds i8, ptr %5867, i64 4
  store i8 %5866, ptr %5868, align 1, !tbaa !9
  %5869 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %5870 = load i8, ptr %5869, align 1, !tbaa !9
  %5871 = zext i8 %5870 to i32
  %5872 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %5873 = load i8, ptr %5872, align 2, !tbaa !9
  %5874 = zext i8 %5873 to i32
  %5875 = xor i32 %5871, %5874
  %5876 = trunc i32 %5875 to i8
  %5877 = call zeroext i8 @mul2(i8 noundef zeroext %5876)
  %5878 = zext i8 %5877 to i32
  %5879 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %5880 = load i8, ptr %5879, align 1, !tbaa !9
  %5881 = zext i8 %5880 to i32
  %5882 = xor i32 %5878, %5881
  %5883 = load i8, ptr %8, align 1, !tbaa !9
  %5884 = zext i8 %5883 to i32
  %5885 = xor i32 %5882, %5884
  %5886 = trunc i32 %5885 to i8
  %5887 = load ptr, ptr %6, align 8, !tbaa !5
  %5888 = getelementptr inbounds i8, ptr %5887, i64 5
  store i8 %5886, ptr %5888, align 1, !tbaa !9
  %5889 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %5890 = load i8, ptr %5889, align 2, !tbaa !9
  %5891 = zext i8 %5890 to i32
  %5892 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %5893 = load i8, ptr %5892, align 1, !tbaa !9
  %5894 = zext i8 %5893 to i32
  %5895 = xor i32 %5891, %5894
  %5896 = trunc i32 %5895 to i8
  %5897 = call zeroext i8 @mul2(i8 noundef zeroext %5896)
  %5898 = zext i8 %5897 to i32
  %5899 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %5900 = load i8, ptr %5899, align 2, !tbaa !9
  %5901 = zext i8 %5900 to i32
  %5902 = xor i32 %5898, %5901
  %5903 = load i8, ptr %8, align 1, !tbaa !9
  %5904 = zext i8 %5903 to i32
  %5905 = xor i32 %5902, %5904
  %5906 = trunc i32 %5905 to i8
  %5907 = load ptr, ptr %6, align 8, !tbaa !5
  %5908 = getelementptr inbounds i8, ptr %5907, i64 6
  store i8 %5906, ptr %5908, align 1, !tbaa !9
  %5909 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %5910 = load i8, ptr %5909, align 1, !tbaa !9
  %5911 = zext i8 %5910 to i32
  %5912 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %5913 = load i8, ptr %5912, align 4, !tbaa !9
  %5914 = zext i8 %5913 to i32
  %5915 = xor i32 %5911, %5914
  %5916 = trunc i32 %5915 to i8
  %5917 = call zeroext i8 @mul2(i8 noundef zeroext %5916)
  %5918 = zext i8 %5917 to i32
  %5919 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %5920 = load i8, ptr %5919, align 1, !tbaa !9
  %5921 = zext i8 %5920 to i32
  %5922 = xor i32 %5918, %5921
  %5923 = load i8, ptr %8, align 1, !tbaa !9
  %5924 = zext i8 %5923 to i32
  %5925 = xor i32 %5922, %5924
  %5926 = trunc i32 %5925 to i8
  %5927 = load ptr, ptr %6, align 8, !tbaa !5
  %5928 = getelementptr inbounds i8, ptr %5927, i64 7
  store i8 %5926, ptr %5928, align 1, !tbaa !9
  %5929 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %5930 = load i8, ptr %5929, align 8, !tbaa !9
  %5931 = zext i8 %5930 to i32
  %5932 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %5933 = load i8, ptr %5932, align 1, !tbaa !9
  %5934 = zext i8 %5933 to i32
  %5935 = xor i32 %5931, %5934
  %5936 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %5937 = load i8, ptr %5936, align 2, !tbaa !9
  %5938 = zext i8 %5937 to i32
  %5939 = xor i32 %5935, %5938
  %5940 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %5941 = load i8, ptr %5940, align 1, !tbaa !9
  %5942 = zext i8 %5941 to i32
  %5943 = xor i32 %5939, %5942
  %5944 = trunc i32 %5943 to i8
  store i8 %5944, ptr %8, align 1, !tbaa !9
  %5945 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %5946 = load i8, ptr %5945, align 8, !tbaa !9
  %5947 = zext i8 %5946 to i32
  %5948 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %5949 = load i8, ptr %5948, align 1, !tbaa !9
  %5950 = zext i8 %5949 to i32
  %5951 = xor i32 %5947, %5950
  %5952 = trunc i32 %5951 to i8
  %5953 = call zeroext i8 @mul2(i8 noundef zeroext %5952)
  %5954 = zext i8 %5953 to i32
  %5955 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %5956 = load i8, ptr %5955, align 8, !tbaa !9
  %5957 = zext i8 %5956 to i32
  %5958 = xor i32 %5954, %5957
  %5959 = load i8, ptr %8, align 1, !tbaa !9
  %5960 = zext i8 %5959 to i32
  %5961 = xor i32 %5958, %5960
  %5962 = trunc i32 %5961 to i8
  %5963 = load ptr, ptr %6, align 8, !tbaa !5
  %5964 = getelementptr inbounds i8, ptr %5963, i64 8
  store i8 %5962, ptr %5964, align 1, !tbaa !9
  %5965 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %5966 = load i8, ptr %5965, align 1, !tbaa !9
  %5967 = zext i8 %5966 to i32
  %5968 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %5969 = load i8, ptr %5968, align 2, !tbaa !9
  %5970 = zext i8 %5969 to i32
  %5971 = xor i32 %5967, %5970
  %5972 = trunc i32 %5971 to i8
  %5973 = call zeroext i8 @mul2(i8 noundef zeroext %5972)
  %5974 = zext i8 %5973 to i32
  %5975 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %5976 = load i8, ptr %5975, align 1, !tbaa !9
  %5977 = zext i8 %5976 to i32
  %5978 = xor i32 %5974, %5977
  %5979 = load i8, ptr %8, align 1, !tbaa !9
  %5980 = zext i8 %5979 to i32
  %5981 = xor i32 %5978, %5980
  %5982 = trunc i32 %5981 to i8
  %5983 = load ptr, ptr %6, align 8, !tbaa !5
  %5984 = getelementptr inbounds i8, ptr %5983, i64 9
  store i8 %5982, ptr %5984, align 1, !tbaa !9
  %5985 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %5986 = load i8, ptr %5985, align 2, !tbaa !9
  %5987 = zext i8 %5986 to i32
  %5988 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %5989 = load i8, ptr %5988, align 1, !tbaa !9
  %5990 = zext i8 %5989 to i32
  %5991 = xor i32 %5987, %5990
  %5992 = trunc i32 %5991 to i8
  %5993 = call zeroext i8 @mul2(i8 noundef zeroext %5992)
  %5994 = zext i8 %5993 to i32
  %5995 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %5996 = load i8, ptr %5995, align 2, !tbaa !9
  %5997 = zext i8 %5996 to i32
  %5998 = xor i32 %5994, %5997
  %5999 = load i8, ptr %8, align 1, !tbaa !9
  %6000 = zext i8 %5999 to i32
  %6001 = xor i32 %5998, %6000
  %6002 = trunc i32 %6001 to i8
  %6003 = load ptr, ptr %6, align 8, !tbaa !5
  %6004 = getelementptr inbounds i8, ptr %6003, i64 10
  store i8 %6002, ptr %6004, align 1, !tbaa !9
  %6005 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %6006 = load i8, ptr %6005, align 1, !tbaa !9
  %6007 = zext i8 %6006 to i32
  %6008 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %6009 = load i8, ptr %6008, align 8, !tbaa !9
  %6010 = zext i8 %6009 to i32
  %6011 = xor i32 %6007, %6010
  %6012 = trunc i32 %6011 to i8
  %6013 = call zeroext i8 @mul2(i8 noundef zeroext %6012)
  %6014 = zext i8 %6013 to i32
  %6015 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %6016 = load i8, ptr %6015, align 1, !tbaa !9
  %6017 = zext i8 %6016 to i32
  %6018 = xor i32 %6014, %6017
  %6019 = load i8, ptr %8, align 1, !tbaa !9
  %6020 = zext i8 %6019 to i32
  %6021 = xor i32 %6018, %6020
  %6022 = trunc i32 %6021 to i8
  %6023 = load ptr, ptr %6, align 8, !tbaa !5
  %6024 = getelementptr inbounds i8, ptr %6023, i64 11
  store i8 %6022, ptr %6024, align 1, !tbaa !9
  %6025 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %6026 = load i8, ptr %6025, align 4, !tbaa !9
  %6027 = zext i8 %6026 to i32
  %6028 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %6029 = load i8, ptr %6028, align 1, !tbaa !9
  %6030 = zext i8 %6029 to i32
  %6031 = xor i32 %6027, %6030
  %6032 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %6033 = load i8, ptr %6032, align 2, !tbaa !9
  %6034 = zext i8 %6033 to i32
  %6035 = xor i32 %6031, %6034
  %6036 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %6037 = load i8, ptr %6036, align 1, !tbaa !9
  %6038 = zext i8 %6037 to i32
  %6039 = xor i32 %6035, %6038
  %6040 = trunc i32 %6039 to i8
  store i8 %6040, ptr %8, align 1, !tbaa !9
  %6041 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %6042 = load i8, ptr %6041, align 4, !tbaa !9
  %6043 = zext i8 %6042 to i32
  %6044 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %6045 = load i8, ptr %6044, align 1, !tbaa !9
  %6046 = zext i8 %6045 to i32
  %6047 = xor i32 %6043, %6046
  %6048 = trunc i32 %6047 to i8
  %6049 = call zeroext i8 @mul2(i8 noundef zeroext %6048)
  %6050 = zext i8 %6049 to i32
  %6051 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %6052 = load i8, ptr %6051, align 4, !tbaa !9
  %6053 = zext i8 %6052 to i32
  %6054 = xor i32 %6050, %6053
  %6055 = load i8, ptr %8, align 1, !tbaa !9
  %6056 = zext i8 %6055 to i32
  %6057 = xor i32 %6054, %6056
  %6058 = trunc i32 %6057 to i8
  %6059 = load ptr, ptr %6, align 8, !tbaa !5
  %6060 = getelementptr inbounds i8, ptr %6059, i64 12
  store i8 %6058, ptr %6060, align 1, !tbaa !9
  %6061 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %6062 = load i8, ptr %6061, align 1, !tbaa !9
  %6063 = zext i8 %6062 to i32
  %6064 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %6065 = load i8, ptr %6064, align 2, !tbaa !9
  %6066 = zext i8 %6065 to i32
  %6067 = xor i32 %6063, %6066
  %6068 = trunc i32 %6067 to i8
  %6069 = call zeroext i8 @mul2(i8 noundef zeroext %6068)
  %6070 = zext i8 %6069 to i32
  %6071 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %6072 = load i8, ptr %6071, align 1, !tbaa !9
  %6073 = zext i8 %6072 to i32
  %6074 = xor i32 %6070, %6073
  %6075 = load i8, ptr %8, align 1, !tbaa !9
  %6076 = zext i8 %6075 to i32
  %6077 = xor i32 %6074, %6076
  %6078 = trunc i32 %6077 to i8
  %6079 = load ptr, ptr %6, align 8, !tbaa !5
  %6080 = getelementptr inbounds i8, ptr %6079, i64 13
  store i8 %6078, ptr %6080, align 1, !tbaa !9
  %6081 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %6082 = load i8, ptr %6081, align 2, !tbaa !9
  %6083 = zext i8 %6082 to i32
  %6084 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %6085 = load i8, ptr %6084, align 1, !tbaa !9
  %6086 = zext i8 %6085 to i32
  %6087 = xor i32 %6083, %6086
  %6088 = trunc i32 %6087 to i8
  %6089 = call zeroext i8 @mul2(i8 noundef zeroext %6088)
  %6090 = zext i8 %6089 to i32
  %6091 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %6092 = load i8, ptr %6091, align 2, !tbaa !9
  %6093 = zext i8 %6092 to i32
  %6094 = xor i32 %6090, %6093
  %6095 = load i8, ptr %8, align 1, !tbaa !9
  %6096 = zext i8 %6095 to i32
  %6097 = xor i32 %6094, %6096
  %6098 = trunc i32 %6097 to i8
  %6099 = load ptr, ptr %6, align 8, !tbaa !5
  %6100 = getelementptr inbounds i8, ptr %6099, i64 14
  store i8 %6098, ptr %6100, align 1, !tbaa !9
  %6101 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %6102 = load i8, ptr %6101, align 1, !tbaa !9
  %6103 = zext i8 %6102 to i32
  %6104 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %6105 = load i8, ptr %6104, align 4, !tbaa !9
  %6106 = zext i8 %6105 to i32
  %6107 = xor i32 %6103, %6106
  %6108 = trunc i32 %6107 to i8
  %6109 = call zeroext i8 @mul2(i8 noundef zeroext %6108)
  %6110 = zext i8 %6109 to i32
  %6111 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %6112 = load i8, ptr %6111, align 1, !tbaa !9
  %6113 = zext i8 %6112 to i32
  %6114 = xor i32 %6110, %6113
  %6115 = load i8, ptr %8, align 1, !tbaa !9
  %6116 = zext i8 %6115 to i32
  %6117 = xor i32 %6114, %6116
  %6118 = trunc i32 %6117 to i8
  %6119 = load ptr, ptr %6, align 8, !tbaa !5
  %6120 = getelementptr inbounds i8, ptr %6119, i64 15
  store i8 %6118, ptr %6120, align 1, !tbaa !9
  %6121 = load ptr, ptr %6, align 8, !tbaa !5
  %6122 = load i8, ptr %6121, align 1, !tbaa !9
  %6123 = zext i8 %6122 to i32
  %6124 = load ptr, ptr %4, align 8, !tbaa !5
  %6125 = getelementptr inbounds i8, ptr %6124, i32 1
  store ptr %6125, ptr %4, align 8, !tbaa !5
  %6126 = load i8, ptr %6124, align 1, !tbaa !9
  %6127 = zext i8 %6126 to i32
  %6128 = xor i32 %6123, %6127
  %6129 = trunc i32 %6128 to i8
  %6130 = load ptr, ptr %6, align 8, !tbaa !5
  store i8 %6129, ptr %6130, align 1, !tbaa !9
  %6131 = load ptr, ptr %6, align 8, !tbaa !5
  %6132 = getelementptr inbounds i8, ptr %6131, i64 1
  %6133 = load i8, ptr %6132, align 1, !tbaa !9
  %6134 = zext i8 %6133 to i32
  %6135 = load ptr, ptr %4, align 8, !tbaa !5
  %6136 = getelementptr inbounds i8, ptr %6135, i32 1
  store ptr %6136, ptr %4, align 8, !tbaa !5
  %6137 = load i8, ptr %6135, align 1, !tbaa !9
  %6138 = zext i8 %6137 to i32
  %6139 = xor i32 %6134, %6138
  %6140 = trunc i32 %6139 to i8
  %6141 = load ptr, ptr %6, align 8, !tbaa !5
  %6142 = getelementptr inbounds i8, ptr %6141, i64 1
  store i8 %6140, ptr %6142, align 1, !tbaa !9
  %6143 = load ptr, ptr %6, align 8, !tbaa !5
  %6144 = getelementptr inbounds i8, ptr %6143, i64 2
  %6145 = load i8, ptr %6144, align 1, !tbaa !9
  %6146 = zext i8 %6145 to i32
  %6147 = load ptr, ptr %4, align 8, !tbaa !5
  %6148 = getelementptr inbounds i8, ptr %6147, i32 1
  store ptr %6148, ptr %4, align 8, !tbaa !5
  %6149 = load i8, ptr %6147, align 1, !tbaa !9
  %6150 = zext i8 %6149 to i32
  %6151 = xor i32 %6146, %6150
  %6152 = trunc i32 %6151 to i8
  %6153 = load ptr, ptr %6, align 8, !tbaa !5
  %6154 = getelementptr inbounds i8, ptr %6153, i64 2
  store i8 %6152, ptr %6154, align 1, !tbaa !9
  %6155 = load ptr, ptr %6, align 8, !tbaa !5
  %6156 = getelementptr inbounds i8, ptr %6155, i64 3
  %6157 = load i8, ptr %6156, align 1, !tbaa !9
  %6158 = zext i8 %6157 to i32
  %6159 = load ptr, ptr %4, align 8, !tbaa !5
  %6160 = getelementptr inbounds i8, ptr %6159, i32 1
  store ptr %6160, ptr %4, align 8, !tbaa !5
  %6161 = load i8, ptr %6159, align 1, !tbaa !9
  %6162 = zext i8 %6161 to i32
  %6163 = xor i32 %6158, %6162
  %6164 = trunc i32 %6163 to i8
  %6165 = load ptr, ptr %6, align 8, !tbaa !5
  %6166 = getelementptr inbounds i8, ptr %6165, i64 3
  store i8 %6164, ptr %6166, align 1, !tbaa !9
  %6167 = load ptr, ptr %6, align 8, !tbaa !5
  %6168 = getelementptr inbounds i8, ptr %6167, i64 4
  %6169 = load i8, ptr %6168, align 1, !tbaa !9
  %6170 = zext i8 %6169 to i32
  %6171 = load ptr, ptr %4, align 8, !tbaa !5
  %6172 = getelementptr inbounds i8, ptr %6171, i32 1
  store ptr %6172, ptr %4, align 8, !tbaa !5
  %6173 = load i8, ptr %6171, align 1, !tbaa !9
  %6174 = zext i8 %6173 to i32
  %6175 = xor i32 %6170, %6174
  %6176 = trunc i32 %6175 to i8
  %6177 = load ptr, ptr %6, align 8, !tbaa !5
  %6178 = getelementptr inbounds i8, ptr %6177, i64 4
  store i8 %6176, ptr %6178, align 1, !tbaa !9
  %6179 = load ptr, ptr %6, align 8, !tbaa !5
  %6180 = getelementptr inbounds i8, ptr %6179, i64 5
  %6181 = load i8, ptr %6180, align 1, !tbaa !9
  %6182 = zext i8 %6181 to i32
  %6183 = load ptr, ptr %4, align 8, !tbaa !5
  %6184 = getelementptr inbounds i8, ptr %6183, i32 1
  store ptr %6184, ptr %4, align 8, !tbaa !5
  %6185 = load i8, ptr %6183, align 1, !tbaa !9
  %6186 = zext i8 %6185 to i32
  %6187 = xor i32 %6182, %6186
  %6188 = trunc i32 %6187 to i8
  %6189 = load ptr, ptr %6, align 8, !tbaa !5
  %6190 = getelementptr inbounds i8, ptr %6189, i64 5
  store i8 %6188, ptr %6190, align 1, !tbaa !9
  %6191 = load ptr, ptr %6, align 8, !tbaa !5
  %6192 = getelementptr inbounds i8, ptr %6191, i64 6
  %6193 = load i8, ptr %6192, align 1, !tbaa !9
  %6194 = zext i8 %6193 to i32
  %6195 = load ptr, ptr %4, align 8, !tbaa !5
  %6196 = getelementptr inbounds i8, ptr %6195, i32 1
  store ptr %6196, ptr %4, align 8, !tbaa !5
  %6197 = load i8, ptr %6195, align 1, !tbaa !9
  %6198 = zext i8 %6197 to i32
  %6199 = xor i32 %6194, %6198
  %6200 = trunc i32 %6199 to i8
  %6201 = load ptr, ptr %6, align 8, !tbaa !5
  %6202 = getelementptr inbounds i8, ptr %6201, i64 6
  store i8 %6200, ptr %6202, align 1, !tbaa !9
  %6203 = load ptr, ptr %6, align 8, !tbaa !5
  %6204 = getelementptr inbounds i8, ptr %6203, i64 7
  %6205 = load i8, ptr %6204, align 1, !tbaa !9
  %6206 = zext i8 %6205 to i32
  %6207 = load ptr, ptr %4, align 8, !tbaa !5
  %6208 = getelementptr inbounds i8, ptr %6207, i32 1
  store ptr %6208, ptr %4, align 8, !tbaa !5
  %6209 = load i8, ptr %6207, align 1, !tbaa !9
  %6210 = zext i8 %6209 to i32
  %6211 = xor i32 %6206, %6210
  %6212 = trunc i32 %6211 to i8
  %6213 = load ptr, ptr %6, align 8, !tbaa !5
  %6214 = getelementptr inbounds i8, ptr %6213, i64 7
  store i8 %6212, ptr %6214, align 1, !tbaa !9
  %6215 = load ptr, ptr %6, align 8, !tbaa !5
  %6216 = getelementptr inbounds i8, ptr %6215, i64 8
  %6217 = load i8, ptr %6216, align 1, !tbaa !9
  %6218 = zext i8 %6217 to i32
  %6219 = load ptr, ptr %4, align 8, !tbaa !5
  %6220 = getelementptr inbounds i8, ptr %6219, i32 1
  store ptr %6220, ptr %4, align 8, !tbaa !5
  %6221 = load i8, ptr %6219, align 1, !tbaa !9
  %6222 = zext i8 %6221 to i32
  %6223 = xor i32 %6218, %6222
  %6224 = trunc i32 %6223 to i8
  %6225 = load ptr, ptr %6, align 8, !tbaa !5
  %6226 = getelementptr inbounds i8, ptr %6225, i64 8
  store i8 %6224, ptr %6226, align 1, !tbaa !9
  %6227 = load ptr, ptr %6, align 8, !tbaa !5
  %6228 = getelementptr inbounds i8, ptr %6227, i64 9
  %6229 = load i8, ptr %6228, align 1, !tbaa !9
  %6230 = zext i8 %6229 to i32
  %6231 = load ptr, ptr %4, align 8, !tbaa !5
  %6232 = getelementptr inbounds i8, ptr %6231, i32 1
  store ptr %6232, ptr %4, align 8, !tbaa !5
  %6233 = load i8, ptr %6231, align 1, !tbaa !9
  %6234 = zext i8 %6233 to i32
  %6235 = xor i32 %6230, %6234
  %6236 = trunc i32 %6235 to i8
  %6237 = load ptr, ptr %6, align 8, !tbaa !5
  %6238 = getelementptr inbounds i8, ptr %6237, i64 9
  store i8 %6236, ptr %6238, align 1, !tbaa !9
  %6239 = load ptr, ptr %6, align 8, !tbaa !5
  %6240 = getelementptr inbounds i8, ptr %6239, i64 10
  %6241 = load i8, ptr %6240, align 1, !tbaa !9
  %6242 = zext i8 %6241 to i32
  %6243 = load ptr, ptr %4, align 8, !tbaa !5
  %6244 = getelementptr inbounds i8, ptr %6243, i32 1
  store ptr %6244, ptr %4, align 8, !tbaa !5
  %6245 = load i8, ptr %6243, align 1, !tbaa !9
  %6246 = zext i8 %6245 to i32
  %6247 = xor i32 %6242, %6246
  %6248 = trunc i32 %6247 to i8
  %6249 = load ptr, ptr %6, align 8, !tbaa !5
  %6250 = getelementptr inbounds i8, ptr %6249, i64 10
  store i8 %6248, ptr %6250, align 1, !tbaa !9
  %6251 = load ptr, ptr %6, align 8, !tbaa !5
  %6252 = getelementptr inbounds i8, ptr %6251, i64 11
  %6253 = load i8, ptr %6252, align 1, !tbaa !9
  %6254 = zext i8 %6253 to i32
  %6255 = load ptr, ptr %4, align 8, !tbaa !5
  %6256 = getelementptr inbounds i8, ptr %6255, i32 1
  store ptr %6256, ptr %4, align 8, !tbaa !5
  %6257 = load i8, ptr %6255, align 1, !tbaa !9
  %6258 = zext i8 %6257 to i32
  %6259 = xor i32 %6254, %6258
  %6260 = trunc i32 %6259 to i8
  %6261 = load ptr, ptr %6, align 8, !tbaa !5
  %6262 = getelementptr inbounds i8, ptr %6261, i64 11
  store i8 %6260, ptr %6262, align 1, !tbaa !9
  %6263 = load ptr, ptr %6, align 8, !tbaa !5
  %6264 = getelementptr inbounds i8, ptr %6263, i64 12
  %6265 = load i8, ptr %6264, align 1, !tbaa !9
  %6266 = zext i8 %6265 to i32
  %6267 = load ptr, ptr %4, align 8, !tbaa !5
  %6268 = getelementptr inbounds i8, ptr %6267, i32 1
  store ptr %6268, ptr %4, align 8, !tbaa !5
  %6269 = load i8, ptr %6267, align 1, !tbaa !9
  %6270 = zext i8 %6269 to i32
  %6271 = xor i32 %6266, %6270
  %6272 = trunc i32 %6271 to i8
  %6273 = load ptr, ptr %6, align 8, !tbaa !5
  %6274 = getelementptr inbounds i8, ptr %6273, i64 12
  store i8 %6272, ptr %6274, align 1, !tbaa !9
  %6275 = load ptr, ptr %6, align 8, !tbaa !5
  %6276 = getelementptr inbounds i8, ptr %6275, i64 13
  %6277 = load i8, ptr %6276, align 1, !tbaa !9
  %6278 = zext i8 %6277 to i32
  %6279 = load ptr, ptr %4, align 8, !tbaa !5
  %6280 = getelementptr inbounds i8, ptr %6279, i32 1
  store ptr %6280, ptr %4, align 8, !tbaa !5
  %6281 = load i8, ptr %6279, align 1, !tbaa !9
  %6282 = zext i8 %6281 to i32
  %6283 = xor i32 %6278, %6282
  %6284 = trunc i32 %6283 to i8
  %6285 = load ptr, ptr %6, align 8, !tbaa !5
  %6286 = getelementptr inbounds i8, ptr %6285, i64 13
  store i8 %6284, ptr %6286, align 1, !tbaa !9
  %6287 = load ptr, ptr %6, align 8, !tbaa !5
  %6288 = getelementptr inbounds i8, ptr %6287, i64 14
  %6289 = load i8, ptr %6288, align 1, !tbaa !9
  %6290 = zext i8 %6289 to i32
  %6291 = load ptr, ptr %4, align 8, !tbaa !5
  %6292 = getelementptr inbounds i8, ptr %6291, i32 1
  store ptr %6292, ptr %4, align 8, !tbaa !5
  %6293 = load i8, ptr %6291, align 1, !tbaa !9
  %6294 = zext i8 %6293 to i32
  %6295 = xor i32 %6290, %6294
  %6296 = trunc i32 %6295 to i8
  %6297 = load ptr, ptr %6, align 8, !tbaa !5
  %6298 = getelementptr inbounds i8, ptr %6297, i64 14
  store i8 %6296, ptr %6298, align 1, !tbaa !9
  %6299 = load ptr, ptr %6, align 8, !tbaa !5
  %6300 = getelementptr inbounds i8, ptr %6299, i64 15
  %6301 = load i8, ptr %6300, align 1, !tbaa !9
  %6302 = zext i8 %6301 to i32
  %6303 = load ptr, ptr %4, align 8, !tbaa !5
  %6304 = getelementptr inbounds i8, ptr %6303, i32 1
  store ptr %6304, ptr %4, align 8, !tbaa !5
  %6305 = load i8, ptr %6303, align 1, !tbaa !9
  %6306 = zext i8 %6305 to i32
  %6307 = xor i32 %6302, %6306
  %6308 = trunc i32 %6307 to i8
  %6309 = load ptr, ptr %6, align 8, !tbaa !5
  %6310 = getelementptr inbounds i8, ptr %6309, i64 15
  store i8 %6308, ptr %6310, align 1, !tbaa !9
  %6311 = load ptr, ptr %6, align 8, !tbaa !5
  %6312 = load i8, ptr %6311, align 1, !tbaa !9
  %6313 = zext i8 %6312 to i64
  %6314 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6313
  %6315 = load i8, ptr %6314, align 1, !tbaa !9
  %6316 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  store i8 %6315, ptr %6316, align 16, !tbaa !9
  %6317 = load ptr, ptr %6, align 8, !tbaa !5
  %6318 = getelementptr inbounds i8, ptr %6317, i64 1
  %6319 = load i8, ptr %6318, align 1, !tbaa !9
  %6320 = zext i8 %6319 to i64
  %6321 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6320
  %6322 = load i8, ptr %6321, align 1, !tbaa !9
  %6323 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6324 = getelementptr inbounds i8, ptr %6323, i64 1
  store i8 %6322, ptr %6324, align 1, !tbaa !9
  %6325 = load ptr, ptr %6, align 8, !tbaa !5
  %6326 = getelementptr inbounds i8, ptr %6325, i64 2
  %6327 = load i8, ptr %6326, align 1, !tbaa !9
  %6328 = zext i8 %6327 to i64
  %6329 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6328
  %6330 = load i8, ptr %6329, align 1, !tbaa !9
  %6331 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6332 = getelementptr inbounds i8, ptr %6331, i64 2
  store i8 %6330, ptr %6332, align 1, !tbaa !9
  %6333 = load ptr, ptr %6, align 8, !tbaa !5
  %6334 = getelementptr inbounds i8, ptr %6333, i64 3
  %6335 = load i8, ptr %6334, align 1, !tbaa !9
  %6336 = zext i8 %6335 to i64
  %6337 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6336
  %6338 = load i8, ptr %6337, align 1, !tbaa !9
  %6339 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6340 = getelementptr inbounds i8, ptr %6339, i64 3
  store i8 %6338, ptr %6340, align 1, !tbaa !9
  %6341 = load ptr, ptr %6, align 8, !tbaa !5
  %6342 = getelementptr inbounds i8, ptr %6341, i64 4
  %6343 = load i8, ptr %6342, align 1, !tbaa !9
  %6344 = zext i8 %6343 to i64
  %6345 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6344
  %6346 = load i8, ptr %6345, align 1, !tbaa !9
  %6347 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6348 = getelementptr inbounds i8, ptr %6347, i64 4
  store i8 %6346, ptr %6348, align 1, !tbaa !9
  %6349 = load ptr, ptr %6, align 8, !tbaa !5
  %6350 = getelementptr inbounds i8, ptr %6349, i64 5
  %6351 = load i8, ptr %6350, align 1, !tbaa !9
  %6352 = zext i8 %6351 to i64
  %6353 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6352
  %6354 = load i8, ptr %6353, align 1, !tbaa !9
  %6355 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6356 = getelementptr inbounds i8, ptr %6355, i64 5
  store i8 %6354, ptr %6356, align 1, !tbaa !9
  %6357 = load ptr, ptr %6, align 8, !tbaa !5
  %6358 = getelementptr inbounds i8, ptr %6357, i64 6
  %6359 = load i8, ptr %6358, align 1, !tbaa !9
  %6360 = zext i8 %6359 to i64
  %6361 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6360
  %6362 = load i8, ptr %6361, align 1, !tbaa !9
  %6363 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6364 = getelementptr inbounds i8, ptr %6363, i64 6
  store i8 %6362, ptr %6364, align 1, !tbaa !9
  %6365 = load ptr, ptr %6, align 8, !tbaa !5
  %6366 = getelementptr inbounds i8, ptr %6365, i64 7
  %6367 = load i8, ptr %6366, align 1, !tbaa !9
  %6368 = zext i8 %6367 to i64
  %6369 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6368
  %6370 = load i8, ptr %6369, align 1, !tbaa !9
  %6371 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6372 = getelementptr inbounds i8, ptr %6371, i64 7
  store i8 %6370, ptr %6372, align 1, !tbaa !9
  %6373 = load ptr, ptr %6, align 8, !tbaa !5
  %6374 = getelementptr inbounds i8, ptr %6373, i64 8
  %6375 = load i8, ptr %6374, align 1, !tbaa !9
  %6376 = zext i8 %6375 to i64
  %6377 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6376
  %6378 = load i8, ptr %6377, align 1, !tbaa !9
  %6379 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6380 = getelementptr inbounds i8, ptr %6379, i64 8
  store i8 %6378, ptr %6380, align 1, !tbaa !9
  %6381 = load ptr, ptr %6, align 8, !tbaa !5
  %6382 = getelementptr inbounds i8, ptr %6381, i64 9
  %6383 = load i8, ptr %6382, align 1, !tbaa !9
  %6384 = zext i8 %6383 to i64
  %6385 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6384
  %6386 = load i8, ptr %6385, align 1, !tbaa !9
  %6387 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6388 = getelementptr inbounds i8, ptr %6387, i64 9
  store i8 %6386, ptr %6388, align 1, !tbaa !9
  %6389 = load ptr, ptr %6, align 8, !tbaa !5
  %6390 = getelementptr inbounds i8, ptr %6389, i64 10
  %6391 = load i8, ptr %6390, align 1, !tbaa !9
  %6392 = zext i8 %6391 to i64
  %6393 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6392
  %6394 = load i8, ptr %6393, align 1, !tbaa !9
  %6395 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6396 = getelementptr inbounds i8, ptr %6395, i64 10
  store i8 %6394, ptr %6396, align 1, !tbaa !9
  %6397 = load ptr, ptr %6, align 8, !tbaa !5
  %6398 = getelementptr inbounds i8, ptr %6397, i64 11
  %6399 = load i8, ptr %6398, align 1, !tbaa !9
  %6400 = zext i8 %6399 to i64
  %6401 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6400
  %6402 = load i8, ptr %6401, align 1, !tbaa !9
  %6403 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6404 = getelementptr inbounds i8, ptr %6403, i64 11
  store i8 %6402, ptr %6404, align 1, !tbaa !9
  %6405 = load ptr, ptr %6, align 8, !tbaa !5
  %6406 = getelementptr inbounds i8, ptr %6405, i64 12
  %6407 = load i8, ptr %6406, align 1, !tbaa !9
  %6408 = zext i8 %6407 to i64
  %6409 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6408
  %6410 = load i8, ptr %6409, align 1, !tbaa !9
  %6411 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6412 = getelementptr inbounds i8, ptr %6411, i64 12
  store i8 %6410, ptr %6412, align 1, !tbaa !9
  %6413 = load ptr, ptr %6, align 8, !tbaa !5
  %6414 = getelementptr inbounds i8, ptr %6413, i64 13
  %6415 = load i8, ptr %6414, align 1, !tbaa !9
  %6416 = zext i8 %6415 to i64
  %6417 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6416
  %6418 = load i8, ptr %6417, align 1, !tbaa !9
  %6419 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6420 = getelementptr inbounds i8, ptr %6419, i64 13
  store i8 %6418, ptr %6420, align 1, !tbaa !9
  %6421 = load ptr, ptr %6, align 8, !tbaa !5
  %6422 = getelementptr inbounds i8, ptr %6421, i64 14
  %6423 = load i8, ptr %6422, align 1, !tbaa !9
  %6424 = zext i8 %6423 to i64
  %6425 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6424
  %6426 = load i8, ptr %6425, align 1, !tbaa !9
  %6427 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6428 = getelementptr inbounds i8, ptr %6427, i64 14
  store i8 %6426, ptr %6428, align 1, !tbaa !9
  %6429 = load ptr, ptr %6, align 8, !tbaa !5
  %6430 = getelementptr inbounds i8, ptr %6429, i64 15
  %6431 = load i8, ptr %6430, align 1, !tbaa !9
  %6432 = zext i8 %6431 to i64
  %6433 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %6432
  %6434 = load i8, ptr %6433, align 1, !tbaa !9
  %6435 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6436 = getelementptr inbounds i8, ptr %6435, i64 15
  store i8 %6434, ptr %6436, align 1, !tbaa !9
  %6437 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6438 = getelementptr inbounds i8, ptr %6437, i64 1
  %6439 = load i8, ptr %6438, align 1, !tbaa !9
  store i8 %6439, ptr %8, align 1, !tbaa !9
  %6440 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6441 = getelementptr inbounds i8, ptr %6440, i64 5
  %6442 = load i8, ptr %6441, align 1, !tbaa !9
  %6443 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6444 = getelementptr inbounds i8, ptr %6443, i64 1
  store i8 %6442, ptr %6444, align 1, !tbaa !9
  %6445 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6446 = getelementptr inbounds i8, ptr %6445, i64 9
  %6447 = load i8, ptr %6446, align 1, !tbaa !9
  %6448 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6449 = getelementptr inbounds i8, ptr %6448, i64 5
  store i8 %6447, ptr %6449, align 1, !tbaa !9
  %6450 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6451 = getelementptr inbounds i8, ptr %6450, i64 13
  %6452 = load i8, ptr %6451, align 1, !tbaa !9
  %6453 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6454 = getelementptr inbounds i8, ptr %6453, i64 9
  store i8 %6452, ptr %6454, align 1, !tbaa !9
  %6455 = load i8, ptr %8, align 1, !tbaa !9
  %6456 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6457 = getelementptr inbounds i8, ptr %6456, i64 13
  store i8 %6455, ptr %6457, align 1, !tbaa !9
  %6458 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6459 = getelementptr inbounds i8, ptr %6458, i64 2
  %6460 = load i8, ptr %6459, align 1, !tbaa !9
  store i8 %6460, ptr %8, align 1, !tbaa !9
  %6461 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6462 = getelementptr inbounds i8, ptr %6461, i64 10
  %6463 = load i8, ptr %6462, align 1, !tbaa !9
  %6464 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6465 = getelementptr inbounds i8, ptr %6464, i64 2
  store i8 %6463, ptr %6465, align 1, !tbaa !9
  %6466 = load i8, ptr %8, align 1, !tbaa !9
  %6467 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6468 = getelementptr inbounds i8, ptr %6467, i64 10
  store i8 %6466, ptr %6468, align 1, !tbaa !9
  %6469 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6470 = getelementptr inbounds i8, ptr %6469, i64 6
  %6471 = load i8, ptr %6470, align 1, !tbaa !9
  store i8 %6471, ptr %8, align 1, !tbaa !9
  %6472 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6473 = getelementptr inbounds i8, ptr %6472, i64 14
  %6474 = load i8, ptr %6473, align 1, !tbaa !9
  %6475 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6476 = getelementptr inbounds i8, ptr %6475, i64 6
  store i8 %6474, ptr %6476, align 1, !tbaa !9
  %6477 = load i8, ptr %8, align 1, !tbaa !9
  %6478 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6479 = getelementptr inbounds i8, ptr %6478, i64 14
  store i8 %6477, ptr %6479, align 1, !tbaa !9
  %6480 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6481 = getelementptr inbounds i8, ptr %6480, i64 15
  %6482 = load i8, ptr %6481, align 1, !tbaa !9
  store i8 %6482, ptr %8, align 1, !tbaa !9
  %6483 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6484 = getelementptr inbounds i8, ptr %6483, i64 11
  %6485 = load i8, ptr %6484, align 1, !tbaa !9
  %6486 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6487 = getelementptr inbounds i8, ptr %6486, i64 15
  store i8 %6485, ptr %6487, align 1, !tbaa !9
  %6488 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6489 = getelementptr inbounds i8, ptr %6488, i64 7
  %6490 = load i8, ptr %6489, align 1, !tbaa !9
  %6491 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6492 = getelementptr inbounds i8, ptr %6491, i64 11
  store i8 %6490, ptr %6492, align 1, !tbaa !9
  %6493 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6494 = getelementptr inbounds i8, ptr %6493, i64 3
  %6495 = load i8, ptr %6494, align 1, !tbaa !9
  %6496 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6497 = getelementptr inbounds i8, ptr %6496, i64 7
  store i8 %6495, ptr %6497, align 1, !tbaa !9
  %6498 = load i8, ptr %8, align 1, !tbaa !9
  %6499 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6500 = getelementptr inbounds i8, ptr %6499, i64 3
  store i8 %6498, ptr %6500, align 1, !tbaa !9
  %6501 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6502 = load i8, ptr %6501, align 16, !tbaa !9
  %6503 = zext i8 %6502 to i32
  %6504 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %6505 = load i8, ptr %6504, align 1, !tbaa !9
  %6506 = zext i8 %6505 to i32
  %6507 = xor i32 %6503, %6506
  %6508 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %6509 = load i8, ptr %6508, align 2, !tbaa !9
  %6510 = zext i8 %6509 to i32
  %6511 = xor i32 %6507, %6510
  %6512 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %6513 = load i8, ptr %6512, align 1, !tbaa !9
  %6514 = zext i8 %6513 to i32
  %6515 = xor i32 %6511, %6514
  %6516 = trunc i32 %6515 to i8
  store i8 %6516, ptr %8, align 1, !tbaa !9
  %6517 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6518 = load i8, ptr %6517, align 16, !tbaa !9
  %6519 = zext i8 %6518 to i32
  %6520 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %6521 = load i8, ptr %6520, align 1, !tbaa !9
  %6522 = zext i8 %6521 to i32
  %6523 = xor i32 %6519, %6522
  %6524 = trunc i32 %6523 to i8
  %6525 = call zeroext i8 @mul2(i8 noundef zeroext %6524)
  %6526 = zext i8 %6525 to i32
  %6527 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6528 = load i8, ptr %6527, align 16, !tbaa !9
  %6529 = zext i8 %6528 to i32
  %6530 = xor i32 %6526, %6529
  %6531 = load i8, ptr %8, align 1, !tbaa !9
  %6532 = zext i8 %6531 to i32
  %6533 = xor i32 %6530, %6532
  %6534 = trunc i32 %6533 to i8
  %6535 = load ptr, ptr %6, align 8, !tbaa !5
  %6536 = getelementptr inbounds i8, ptr %6535, i64 0
  store i8 %6534, ptr %6536, align 1, !tbaa !9
  %6537 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %6538 = load i8, ptr %6537, align 1, !tbaa !9
  %6539 = zext i8 %6538 to i32
  %6540 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %6541 = load i8, ptr %6540, align 2, !tbaa !9
  %6542 = zext i8 %6541 to i32
  %6543 = xor i32 %6539, %6542
  %6544 = trunc i32 %6543 to i8
  %6545 = call zeroext i8 @mul2(i8 noundef zeroext %6544)
  %6546 = zext i8 %6545 to i32
  %6547 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 1
  %6548 = load i8, ptr %6547, align 1, !tbaa !9
  %6549 = zext i8 %6548 to i32
  %6550 = xor i32 %6546, %6549
  %6551 = load i8, ptr %8, align 1, !tbaa !9
  %6552 = zext i8 %6551 to i32
  %6553 = xor i32 %6550, %6552
  %6554 = trunc i32 %6553 to i8
  %6555 = load ptr, ptr %6, align 8, !tbaa !5
  %6556 = getelementptr inbounds i8, ptr %6555, i64 1
  store i8 %6554, ptr %6556, align 1, !tbaa !9
  %6557 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %6558 = load i8, ptr %6557, align 2, !tbaa !9
  %6559 = zext i8 %6558 to i32
  %6560 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %6561 = load i8, ptr %6560, align 1, !tbaa !9
  %6562 = zext i8 %6561 to i32
  %6563 = xor i32 %6559, %6562
  %6564 = trunc i32 %6563 to i8
  %6565 = call zeroext i8 @mul2(i8 noundef zeroext %6564)
  %6566 = zext i8 %6565 to i32
  %6567 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 2
  %6568 = load i8, ptr %6567, align 2, !tbaa !9
  %6569 = zext i8 %6568 to i32
  %6570 = xor i32 %6566, %6569
  %6571 = load i8, ptr %8, align 1, !tbaa !9
  %6572 = zext i8 %6571 to i32
  %6573 = xor i32 %6570, %6572
  %6574 = trunc i32 %6573 to i8
  %6575 = load ptr, ptr %6, align 8, !tbaa !5
  %6576 = getelementptr inbounds i8, ptr %6575, i64 2
  store i8 %6574, ptr %6576, align 1, !tbaa !9
  %6577 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %6578 = load i8, ptr %6577, align 1, !tbaa !9
  %6579 = zext i8 %6578 to i32
  %6580 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 0
  %6581 = load i8, ptr %6580, align 16, !tbaa !9
  %6582 = zext i8 %6581 to i32
  %6583 = xor i32 %6579, %6582
  %6584 = trunc i32 %6583 to i8
  %6585 = call zeroext i8 @mul2(i8 noundef zeroext %6584)
  %6586 = zext i8 %6585 to i32
  %6587 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 3
  %6588 = load i8, ptr %6587, align 1, !tbaa !9
  %6589 = zext i8 %6588 to i32
  %6590 = xor i32 %6586, %6589
  %6591 = load i8, ptr %8, align 1, !tbaa !9
  %6592 = zext i8 %6591 to i32
  %6593 = xor i32 %6590, %6592
  %6594 = trunc i32 %6593 to i8
  %6595 = load ptr, ptr %6, align 8, !tbaa !5
  %6596 = getelementptr inbounds i8, ptr %6595, i64 3
  store i8 %6594, ptr %6596, align 1, !tbaa !9
  %6597 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %6598 = load i8, ptr %6597, align 4, !tbaa !9
  %6599 = zext i8 %6598 to i32
  %6600 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %6601 = load i8, ptr %6600, align 1, !tbaa !9
  %6602 = zext i8 %6601 to i32
  %6603 = xor i32 %6599, %6602
  %6604 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %6605 = load i8, ptr %6604, align 2, !tbaa !9
  %6606 = zext i8 %6605 to i32
  %6607 = xor i32 %6603, %6606
  %6608 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %6609 = load i8, ptr %6608, align 1, !tbaa !9
  %6610 = zext i8 %6609 to i32
  %6611 = xor i32 %6607, %6610
  %6612 = trunc i32 %6611 to i8
  store i8 %6612, ptr %8, align 1, !tbaa !9
  %6613 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %6614 = load i8, ptr %6613, align 4, !tbaa !9
  %6615 = zext i8 %6614 to i32
  %6616 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %6617 = load i8, ptr %6616, align 1, !tbaa !9
  %6618 = zext i8 %6617 to i32
  %6619 = xor i32 %6615, %6618
  %6620 = trunc i32 %6619 to i8
  %6621 = call zeroext i8 @mul2(i8 noundef zeroext %6620)
  %6622 = zext i8 %6621 to i32
  %6623 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %6624 = load i8, ptr %6623, align 4, !tbaa !9
  %6625 = zext i8 %6624 to i32
  %6626 = xor i32 %6622, %6625
  %6627 = load i8, ptr %8, align 1, !tbaa !9
  %6628 = zext i8 %6627 to i32
  %6629 = xor i32 %6626, %6628
  %6630 = trunc i32 %6629 to i8
  %6631 = load ptr, ptr %6, align 8, !tbaa !5
  %6632 = getelementptr inbounds i8, ptr %6631, i64 4
  store i8 %6630, ptr %6632, align 1, !tbaa !9
  %6633 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %6634 = load i8, ptr %6633, align 1, !tbaa !9
  %6635 = zext i8 %6634 to i32
  %6636 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %6637 = load i8, ptr %6636, align 2, !tbaa !9
  %6638 = zext i8 %6637 to i32
  %6639 = xor i32 %6635, %6638
  %6640 = trunc i32 %6639 to i8
  %6641 = call zeroext i8 @mul2(i8 noundef zeroext %6640)
  %6642 = zext i8 %6641 to i32
  %6643 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 5
  %6644 = load i8, ptr %6643, align 1, !tbaa !9
  %6645 = zext i8 %6644 to i32
  %6646 = xor i32 %6642, %6645
  %6647 = load i8, ptr %8, align 1, !tbaa !9
  %6648 = zext i8 %6647 to i32
  %6649 = xor i32 %6646, %6648
  %6650 = trunc i32 %6649 to i8
  %6651 = load ptr, ptr %6, align 8, !tbaa !5
  %6652 = getelementptr inbounds i8, ptr %6651, i64 5
  store i8 %6650, ptr %6652, align 1, !tbaa !9
  %6653 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %6654 = load i8, ptr %6653, align 2, !tbaa !9
  %6655 = zext i8 %6654 to i32
  %6656 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %6657 = load i8, ptr %6656, align 1, !tbaa !9
  %6658 = zext i8 %6657 to i32
  %6659 = xor i32 %6655, %6658
  %6660 = trunc i32 %6659 to i8
  %6661 = call zeroext i8 @mul2(i8 noundef zeroext %6660)
  %6662 = zext i8 %6661 to i32
  %6663 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 6
  %6664 = load i8, ptr %6663, align 2, !tbaa !9
  %6665 = zext i8 %6664 to i32
  %6666 = xor i32 %6662, %6665
  %6667 = load i8, ptr %8, align 1, !tbaa !9
  %6668 = zext i8 %6667 to i32
  %6669 = xor i32 %6666, %6668
  %6670 = trunc i32 %6669 to i8
  %6671 = load ptr, ptr %6, align 8, !tbaa !5
  %6672 = getelementptr inbounds i8, ptr %6671, i64 6
  store i8 %6670, ptr %6672, align 1, !tbaa !9
  %6673 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %6674 = load i8, ptr %6673, align 1, !tbaa !9
  %6675 = zext i8 %6674 to i32
  %6676 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 4
  %6677 = load i8, ptr %6676, align 4, !tbaa !9
  %6678 = zext i8 %6677 to i32
  %6679 = xor i32 %6675, %6678
  %6680 = trunc i32 %6679 to i8
  %6681 = call zeroext i8 @mul2(i8 noundef zeroext %6680)
  %6682 = zext i8 %6681 to i32
  %6683 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 7
  %6684 = load i8, ptr %6683, align 1, !tbaa !9
  %6685 = zext i8 %6684 to i32
  %6686 = xor i32 %6682, %6685
  %6687 = load i8, ptr %8, align 1, !tbaa !9
  %6688 = zext i8 %6687 to i32
  %6689 = xor i32 %6686, %6688
  %6690 = trunc i32 %6689 to i8
  %6691 = load ptr, ptr %6, align 8, !tbaa !5
  %6692 = getelementptr inbounds i8, ptr %6691, i64 7
  store i8 %6690, ptr %6692, align 1, !tbaa !9
  %6693 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %6694 = load i8, ptr %6693, align 8, !tbaa !9
  %6695 = zext i8 %6694 to i32
  %6696 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %6697 = load i8, ptr %6696, align 1, !tbaa !9
  %6698 = zext i8 %6697 to i32
  %6699 = xor i32 %6695, %6698
  %6700 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %6701 = load i8, ptr %6700, align 2, !tbaa !9
  %6702 = zext i8 %6701 to i32
  %6703 = xor i32 %6699, %6702
  %6704 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %6705 = load i8, ptr %6704, align 1, !tbaa !9
  %6706 = zext i8 %6705 to i32
  %6707 = xor i32 %6703, %6706
  %6708 = trunc i32 %6707 to i8
  store i8 %6708, ptr %8, align 1, !tbaa !9
  %6709 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %6710 = load i8, ptr %6709, align 8, !tbaa !9
  %6711 = zext i8 %6710 to i32
  %6712 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %6713 = load i8, ptr %6712, align 1, !tbaa !9
  %6714 = zext i8 %6713 to i32
  %6715 = xor i32 %6711, %6714
  %6716 = trunc i32 %6715 to i8
  %6717 = call zeroext i8 @mul2(i8 noundef zeroext %6716)
  %6718 = zext i8 %6717 to i32
  %6719 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %6720 = load i8, ptr %6719, align 8, !tbaa !9
  %6721 = zext i8 %6720 to i32
  %6722 = xor i32 %6718, %6721
  %6723 = load i8, ptr %8, align 1, !tbaa !9
  %6724 = zext i8 %6723 to i32
  %6725 = xor i32 %6722, %6724
  %6726 = trunc i32 %6725 to i8
  %6727 = load ptr, ptr %6, align 8, !tbaa !5
  %6728 = getelementptr inbounds i8, ptr %6727, i64 8
  store i8 %6726, ptr %6728, align 1, !tbaa !9
  %6729 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %6730 = load i8, ptr %6729, align 1, !tbaa !9
  %6731 = zext i8 %6730 to i32
  %6732 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %6733 = load i8, ptr %6732, align 2, !tbaa !9
  %6734 = zext i8 %6733 to i32
  %6735 = xor i32 %6731, %6734
  %6736 = trunc i32 %6735 to i8
  %6737 = call zeroext i8 @mul2(i8 noundef zeroext %6736)
  %6738 = zext i8 %6737 to i32
  %6739 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 9
  %6740 = load i8, ptr %6739, align 1, !tbaa !9
  %6741 = zext i8 %6740 to i32
  %6742 = xor i32 %6738, %6741
  %6743 = load i8, ptr %8, align 1, !tbaa !9
  %6744 = zext i8 %6743 to i32
  %6745 = xor i32 %6742, %6744
  %6746 = trunc i32 %6745 to i8
  %6747 = load ptr, ptr %6, align 8, !tbaa !5
  %6748 = getelementptr inbounds i8, ptr %6747, i64 9
  store i8 %6746, ptr %6748, align 1, !tbaa !9
  %6749 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %6750 = load i8, ptr %6749, align 2, !tbaa !9
  %6751 = zext i8 %6750 to i32
  %6752 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %6753 = load i8, ptr %6752, align 1, !tbaa !9
  %6754 = zext i8 %6753 to i32
  %6755 = xor i32 %6751, %6754
  %6756 = trunc i32 %6755 to i8
  %6757 = call zeroext i8 @mul2(i8 noundef zeroext %6756)
  %6758 = zext i8 %6757 to i32
  %6759 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 10
  %6760 = load i8, ptr %6759, align 2, !tbaa !9
  %6761 = zext i8 %6760 to i32
  %6762 = xor i32 %6758, %6761
  %6763 = load i8, ptr %8, align 1, !tbaa !9
  %6764 = zext i8 %6763 to i32
  %6765 = xor i32 %6762, %6764
  %6766 = trunc i32 %6765 to i8
  %6767 = load ptr, ptr %6, align 8, !tbaa !5
  %6768 = getelementptr inbounds i8, ptr %6767, i64 10
  store i8 %6766, ptr %6768, align 1, !tbaa !9
  %6769 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %6770 = load i8, ptr %6769, align 1, !tbaa !9
  %6771 = zext i8 %6770 to i32
  %6772 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 8
  %6773 = load i8, ptr %6772, align 8, !tbaa !9
  %6774 = zext i8 %6773 to i32
  %6775 = xor i32 %6771, %6774
  %6776 = trunc i32 %6775 to i8
  %6777 = call zeroext i8 @mul2(i8 noundef zeroext %6776)
  %6778 = zext i8 %6777 to i32
  %6779 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 11
  %6780 = load i8, ptr %6779, align 1, !tbaa !9
  %6781 = zext i8 %6780 to i32
  %6782 = xor i32 %6778, %6781
  %6783 = load i8, ptr %8, align 1, !tbaa !9
  %6784 = zext i8 %6783 to i32
  %6785 = xor i32 %6782, %6784
  %6786 = trunc i32 %6785 to i8
  %6787 = load ptr, ptr %6, align 8, !tbaa !5
  %6788 = getelementptr inbounds i8, ptr %6787, i64 11
  store i8 %6786, ptr %6788, align 1, !tbaa !9
  %6789 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %6790 = load i8, ptr %6789, align 4, !tbaa !9
  %6791 = zext i8 %6790 to i32
  %6792 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %6793 = load i8, ptr %6792, align 1, !tbaa !9
  %6794 = zext i8 %6793 to i32
  %6795 = xor i32 %6791, %6794
  %6796 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %6797 = load i8, ptr %6796, align 2, !tbaa !9
  %6798 = zext i8 %6797 to i32
  %6799 = xor i32 %6795, %6798
  %6800 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %6801 = load i8, ptr %6800, align 1, !tbaa !9
  %6802 = zext i8 %6801 to i32
  %6803 = xor i32 %6799, %6802
  %6804 = trunc i32 %6803 to i8
  store i8 %6804, ptr %8, align 1, !tbaa !9
  %6805 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %6806 = load i8, ptr %6805, align 4, !tbaa !9
  %6807 = zext i8 %6806 to i32
  %6808 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %6809 = load i8, ptr %6808, align 1, !tbaa !9
  %6810 = zext i8 %6809 to i32
  %6811 = xor i32 %6807, %6810
  %6812 = trunc i32 %6811 to i8
  %6813 = call zeroext i8 @mul2(i8 noundef zeroext %6812)
  %6814 = zext i8 %6813 to i32
  %6815 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %6816 = load i8, ptr %6815, align 4, !tbaa !9
  %6817 = zext i8 %6816 to i32
  %6818 = xor i32 %6814, %6817
  %6819 = load i8, ptr %8, align 1, !tbaa !9
  %6820 = zext i8 %6819 to i32
  %6821 = xor i32 %6818, %6820
  %6822 = trunc i32 %6821 to i8
  %6823 = load ptr, ptr %6, align 8, !tbaa !5
  %6824 = getelementptr inbounds i8, ptr %6823, i64 12
  store i8 %6822, ptr %6824, align 1, !tbaa !9
  %6825 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %6826 = load i8, ptr %6825, align 1, !tbaa !9
  %6827 = zext i8 %6826 to i32
  %6828 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %6829 = load i8, ptr %6828, align 2, !tbaa !9
  %6830 = zext i8 %6829 to i32
  %6831 = xor i32 %6827, %6830
  %6832 = trunc i32 %6831 to i8
  %6833 = call zeroext i8 @mul2(i8 noundef zeroext %6832)
  %6834 = zext i8 %6833 to i32
  %6835 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 13
  %6836 = load i8, ptr %6835, align 1, !tbaa !9
  %6837 = zext i8 %6836 to i32
  %6838 = xor i32 %6834, %6837
  %6839 = load i8, ptr %8, align 1, !tbaa !9
  %6840 = zext i8 %6839 to i32
  %6841 = xor i32 %6838, %6840
  %6842 = trunc i32 %6841 to i8
  %6843 = load ptr, ptr %6, align 8, !tbaa !5
  %6844 = getelementptr inbounds i8, ptr %6843, i64 13
  store i8 %6842, ptr %6844, align 1, !tbaa !9
  %6845 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %6846 = load i8, ptr %6845, align 2, !tbaa !9
  %6847 = zext i8 %6846 to i32
  %6848 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %6849 = load i8, ptr %6848, align 1, !tbaa !9
  %6850 = zext i8 %6849 to i32
  %6851 = xor i32 %6847, %6850
  %6852 = trunc i32 %6851 to i8
  %6853 = call zeroext i8 @mul2(i8 noundef zeroext %6852)
  %6854 = zext i8 %6853 to i32
  %6855 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 14
  %6856 = load i8, ptr %6855, align 2, !tbaa !9
  %6857 = zext i8 %6856 to i32
  %6858 = xor i32 %6854, %6857
  %6859 = load i8, ptr %8, align 1, !tbaa !9
  %6860 = zext i8 %6859 to i32
  %6861 = xor i32 %6858, %6860
  %6862 = trunc i32 %6861 to i8
  %6863 = load ptr, ptr %6, align 8, !tbaa !5
  %6864 = getelementptr inbounds i8, ptr %6863, i64 14
  store i8 %6862, ptr %6864, align 1, !tbaa !9
  %6865 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %6866 = load i8, ptr %6865, align 1, !tbaa !9
  %6867 = zext i8 %6866 to i32
  %6868 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 12
  %6869 = load i8, ptr %6868, align 4, !tbaa !9
  %6870 = zext i8 %6869 to i32
  %6871 = xor i32 %6867, %6870
  %6872 = trunc i32 %6871 to i8
  %6873 = call zeroext i8 @mul2(i8 noundef zeroext %6872)
  %6874 = zext i8 %6873 to i32
  %6875 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 15
  %6876 = load i8, ptr %6875, align 1, !tbaa !9
  %6877 = zext i8 %6876 to i32
  %6878 = xor i32 %6874, %6877
  %6879 = load i8, ptr %8, align 1, !tbaa !9
  %6880 = zext i8 %6879 to i32
  %6881 = xor i32 %6878, %6880
  %6882 = trunc i32 %6881 to i8
  %6883 = load ptr, ptr %6, align 8, !tbaa !5
  %6884 = getelementptr inbounds i8, ptr %6883, i64 15
  store i8 %6882, ptr %6884, align 1, !tbaa !9
  %6885 = load ptr, ptr %6, align 8, !tbaa !5
  %6886 = load i8, ptr %6885, align 1, !tbaa !9
  %6887 = zext i8 %6886 to i32
  %6888 = load ptr, ptr %4, align 8, !tbaa !5
  %6889 = getelementptr inbounds i8, ptr %6888, i32 1
  store ptr %6889, ptr %4, align 8, !tbaa !5
  %6890 = load i8, ptr %6888, align 1, !tbaa !9
  %6891 = zext i8 %6890 to i32
  %6892 = xor i32 %6887, %6891
  %6893 = trunc i32 %6892 to i8
  %6894 = load ptr, ptr %6, align 8, !tbaa !5
  store i8 %6893, ptr %6894, align 1, !tbaa !9
  %6895 = load ptr, ptr %6, align 8, !tbaa !5
  %6896 = getelementptr inbounds i8, ptr %6895, i64 1
  %6897 = load i8, ptr %6896, align 1, !tbaa !9
  %6898 = zext i8 %6897 to i32
  %6899 = load ptr, ptr %4, align 8, !tbaa !5
  %6900 = getelementptr inbounds i8, ptr %6899, i32 1
  store ptr %6900, ptr %4, align 8, !tbaa !5
  %6901 = load i8, ptr %6899, align 1, !tbaa !9
  %6902 = zext i8 %6901 to i32
  %6903 = xor i32 %6898, %6902
  %6904 = trunc i32 %6903 to i8
  %6905 = load ptr, ptr %6, align 8, !tbaa !5
  %6906 = getelementptr inbounds i8, ptr %6905, i64 1
  store i8 %6904, ptr %6906, align 1, !tbaa !9
  %6907 = load ptr, ptr %6, align 8, !tbaa !5
  %6908 = getelementptr inbounds i8, ptr %6907, i64 2
  %6909 = load i8, ptr %6908, align 1, !tbaa !9
  %6910 = zext i8 %6909 to i32
  %6911 = load ptr, ptr %4, align 8, !tbaa !5
  %6912 = getelementptr inbounds i8, ptr %6911, i32 1
  store ptr %6912, ptr %4, align 8, !tbaa !5
  %6913 = load i8, ptr %6911, align 1, !tbaa !9
  %6914 = zext i8 %6913 to i32
  %6915 = xor i32 %6910, %6914
  %6916 = trunc i32 %6915 to i8
  %6917 = load ptr, ptr %6, align 8, !tbaa !5
  %6918 = getelementptr inbounds i8, ptr %6917, i64 2
  store i8 %6916, ptr %6918, align 1, !tbaa !9
  %6919 = load ptr, ptr %6, align 8, !tbaa !5
  %6920 = getelementptr inbounds i8, ptr %6919, i64 3
  %6921 = load i8, ptr %6920, align 1, !tbaa !9
  %6922 = zext i8 %6921 to i32
  %6923 = load ptr, ptr %4, align 8, !tbaa !5
  %6924 = getelementptr inbounds i8, ptr %6923, i32 1
  store ptr %6924, ptr %4, align 8, !tbaa !5
  %6925 = load i8, ptr %6923, align 1, !tbaa !9
  %6926 = zext i8 %6925 to i32
  %6927 = xor i32 %6922, %6926
  %6928 = trunc i32 %6927 to i8
  %6929 = load ptr, ptr %6, align 8, !tbaa !5
  %6930 = getelementptr inbounds i8, ptr %6929, i64 3
  store i8 %6928, ptr %6930, align 1, !tbaa !9
  %6931 = load ptr, ptr %6, align 8, !tbaa !5
  %6932 = getelementptr inbounds i8, ptr %6931, i64 4
  %6933 = load i8, ptr %6932, align 1, !tbaa !9
  %6934 = zext i8 %6933 to i32
  %6935 = load ptr, ptr %4, align 8, !tbaa !5
  %6936 = getelementptr inbounds i8, ptr %6935, i32 1
  store ptr %6936, ptr %4, align 8, !tbaa !5
  %6937 = load i8, ptr %6935, align 1, !tbaa !9
  %6938 = zext i8 %6937 to i32
  %6939 = xor i32 %6934, %6938
  %6940 = trunc i32 %6939 to i8
  %6941 = load ptr, ptr %6, align 8, !tbaa !5
  %6942 = getelementptr inbounds i8, ptr %6941, i64 4
  store i8 %6940, ptr %6942, align 1, !tbaa !9
  %6943 = load ptr, ptr %6, align 8, !tbaa !5
  %6944 = getelementptr inbounds i8, ptr %6943, i64 5
  %6945 = load i8, ptr %6944, align 1, !tbaa !9
  %6946 = zext i8 %6945 to i32
  %6947 = load ptr, ptr %4, align 8, !tbaa !5
  %6948 = getelementptr inbounds i8, ptr %6947, i32 1
  store ptr %6948, ptr %4, align 8, !tbaa !5
  %6949 = load i8, ptr %6947, align 1, !tbaa !9
  %6950 = zext i8 %6949 to i32
  %6951 = xor i32 %6946, %6950
  %6952 = trunc i32 %6951 to i8
  %6953 = load ptr, ptr %6, align 8, !tbaa !5
  %6954 = getelementptr inbounds i8, ptr %6953, i64 5
  store i8 %6952, ptr %6954, align 1, !tbaa !9
  %6955 = load ptr, ptr %6, align 8, !tbaa !5
  %6956 = getelementptr inbounds i8, ptr %6955, i64 6
  %6957 = load i8, ptr %6956, align 1, !tbaa !9
  %6958 = zext i8 %6957 to i32
  %6959 = load ptr, ptr %4, align 8, !tbaa !5
  %6960 = getelementptr inbounds i8, ptr %6959, i32 1
  store ptr %6960, ptr %4, align 8, !tbaa !5
  %6961 = load i8, ptr %6959, align 1, !tbaa !9
  %6962 = zext i8 %6961 to i32
  %6963 = xor i32 %6958, %6962
  %6964 = trunc i32 %6963 to i8
  %6965 = load ptr, ptr %6, align 8, !tbaa !5
  %6966 = getelementptr inbounds i8, ptr %6965, i64 6
  store i8 %6964, ptr %6966, align 1, !tbaa !9
  %6967 = load ptr, ptr %6, align 8, !tbaa !5
  %6968 = getelementptr inbounds i8, ptr %6967, i64 7
  %6969 = load i8, ptr %6968, align 1, !tbaa !9
  %6970 = zext i8 %6969 to i32
  %6971 = load ptr, ptr %4, align 8, !tbaa !5
  %6972 = getelementptr inbounds i8, ptr %6971, i32 1
  store ptr %6972, ptr %4, align 8, !tbaa !5
  %6973 = load i8, ptr %6971, align 1, !tbaa !9
  %6974 = zext i8 %6973 to i32
  %6975 = xor i32 %6970, %6974
  %6976 = trunc i32 %6975 to i8
  %6977 = load ptr, ptr %6, align 8, !tbaa !5
  %6978 = getelementptr inbounds i8, ptr %6977, i64 7
  store i8 %6976, ptr %6978, align 1, !tbaa !9
  %6979 = load ptr, ptr %6, align 8, !tbaa !5
  %6980 = getelementptr inbounds i8, ptr %6979, i64 8
  %6981 = load i8, ptr %6980, align 1, !tbaa !9
  %6982 = zext i8 %6981 to i32
  %6983 = load ptr, ptr %4, align 8, !tbaa !5
  %6984 = getelementptr inbounds i8, ptr %6983, i32 1
  store ptr %6984, ptr %4, align 8, !tbaa !5
  %6985 = load i8, ptr %6983, align 1, !tbaa !9
  %6986 = zext i8 %6985 to i32
  %6987 = xor i32 %6982, %6986
  %6988 = trunc i32 %6987 to i8
  %6989 = load ptr, ptr %6, align 8, !tbaa !5
  %6990 = getelementptr inbounds i8, ptr %6989, i64 8
  store i8 %6988, ptr %6990, align 1, !tbaa !9
  %6991 = load ptr, ptr %6, align 8, !tbaa !5
  %6992 = getelementptr inbounds i8, ptr %6991, i64 9
  %6993 = load i8, ptr %6992, align 1, !tbaa !9
  %6994 = zext i8 %6993 to i32
  %6995 = load ptr, ptr %4, align 8, !tbaa !5
  %6996 = getelementptr inbounds i8, ptr %6995, i32 1
  store ptr %6996, ptr %4, align 8, !tbaa !5
  %6997 = load i8, ptr %6995, align 1, !tbaa !9
  %6998 = zext i8 %6997 to i32
  %6999 = xor i32 %6994, %6998
  %7000 = trunc i32 %6999 to i8
  %7001 = load ptr, ptr %6, align 8, !tbaa !5
  %7002 = getelementptr inbounds i8, ptr %7001, i64 9
  store i8 %7000, ptr %7002, align 1, !tbaa !9
  %7003 = load ptr, ptr %6, align 8, !tbaa !5
  %7004 = getelementptr inbounds i8, ptr %7003, i64 10
  %7005 = load i8, ptr %7004, align 1, !tbaa !9
  %7006 = zext i8 %7005 to i32
  %7007 = load ptr, ptr %4, align 8, !tbaa !5
  %7008 = getelementptr inbounds i8, ptr %7007, i32 1
  store ptr %7008, ptr %4, align 8, !tbaa !5
  %7009 = load i8, ptr %7007, align 1, !tbaa !9
  %7010 = zext i8 %7009 to i32
  %7011 = xor i32 %7006, %7010
  %7012 = trunc i32 %7011 to i8
  %7013 = load ptr, ptr %6, align 8, !tbaa !5
  %7014 = getelementptr inbounds i8, ptr %7013, i64 10
  store i8 %7012, ptr %7014, align 1, !tbaa !9
  %7015 = load ptr, ptr %6, align 8, !tbaa !5
  %7016 = getelementptr inbounds i8, ptr %7015, i64 11
  %7017 = load i8, ptr %7016, align 1, !tbaa !9
  %7018 = zext i8 %7017 to i32
  %7019 = load ptr, ptr %4, align 8, !tbaa !5
  %7020 = getelementptr inbounds i8, ptr %7019, i32 1
  store ptr %7020, ptr %4, align 8, !tbaa !5
  %7021 = load i8, ptr %7019, align 1, !tbaa !9
  %7022 = zext i8 %7021 to i32
  %7023 = xor i32 %7018, %7022
  %7024 = trunc i32 %7023 to i8
  %7025 = load ptr, ptr %6, align 8, !tbaa !5
  %7026 = getelementptr inbounds i8, ptr %7025, i64 11
  store i8 %7024, ptr %7026, align 1, !tbaa !9
  %7027 = load ptr, ptr %6, align 8, !tbaa !5
  %7028 = getelementptr inbounds i8, ptr %7027, i64 12
  %7029 = load i8, ptr %7028, align 1, !tbaa !9
  %7030 = zext i8 %7029 to i32
  %7031 = load ptr, ptr %4, align 8, !tbaa !5
  %7032 = getelementptr inbounds i8, ptr %7031, i32 1
  store ptr %7032, ptr %4, align 8, !tbaa !5
  %7033 = load i8, ptr %7031, align 1, !tbaa !9
  %7034 = zext i8 %7033 to i32
  %7035 = xor i32 %7030, %7034
  %7036 = trunc i32 %7035 to i8
  %7037 = load ptr, ptr %6, align 8, !tbaa !5
  %7038 = getelementptr inbounds i8, ptr %7037, i64 12
  store i8 %7036, ptr %7038, align 1, !tbaa !9
  %7039 = load ptr, ptr %6, align 8, !tbaa !5
  %7040 = getelementptr inbounds i8, ptr %7039, i64 13
  %7041 = load i8, ptr %7040, align 1, !tbaa !9
  %7042 = zext i8 %7041 to i32
  %7043 = load ptr, ptr %4, align 8, !tbaa !5
  %7044 = getelementptr inbounds i8, ptr %7043, i32 1
  store ptr %7044, ptr %4, align 8, !tbaa !5
  %7045 = load i8, ptr %7043, align 1, !tbaa !9
  %7046 = zext i8 %7045 to i32
  %7047 = xor i32 %7042, %7046
  %7048 = trunc i32 %7047 to i8
  %7049 = load ptr, ptr %6, align 8, !tbaa !5
  %7050 = getelementptr inbounds i8, ptr %7049, i64 13
  store i8 %7048, ptr %7050, align 1, !tbaa !9
  %7051 = load ptr, ptr %6, align 8, !tbaa !5
  %7052 = getelementptr inbounds i8, ptr %7051, i64 14
  %7053 = load i8, ptr %7052, align 1, !tbaa !9
  %7054 = zext i8 %7053 to i32
  %7055 = load ptr, ptr %4, align 8, !tbaa !5
  %7056 = getelementptr inbounds i8, ptr %7055, i32 1
  store ptr %7056, ptr %4, align 8, !tbaa !5
  %7057 = load i8, ptr %7055, align 1, !tbaa !9
  %7058 = zext i8 %7057 to i32
  %7059 = xor i32 %7054, %7058
  %7060 = trunc i32 %7059 to i8
  %7061 = load ptr, ptr %6, align 8, !tbaa !5
  %7062 = getelementptr inbounds i8, ptr %7061, i64 14
  store i8 %7060, ptr %7062, align 1, !tbaa !9
  %7063 = load ptr, ptr %6, align 8, !tbaa !5
  %7064 = getelementptr inbounds i8, ptr %7063, i64 15
  %7065 = load i8, ptr %7064, align 1, !tbaa !9
  %7066 = zext i8 %7065 to i32
  %7067 = load ptr, ptr %4, align 8, !tbaa !5
  %7068 = getelementptr inbounds i8, ptr %7067, i32 1
  store ptr %7068, ptr %4, align 8, !tbaa !5
  %7069 = load i8, ptr %7067, align 1, !tbaa !9
  %7070 = zext i8 %7069 to i32
  %7071 = xor i32 %7066, %7070
  %7072 = trunc i32 %7071 to i8
  %7073 = load ptr, ptr %6, align 8, !tbaa !5
  %7074 = getelementptr inbounds i8, ptr %7073, i64 15
  store i8 %7072, ptr %7074, align 1, !tbaa !9
  %7075 = load ptr, ptr %6, align 8, !tbaa !5
  %7076 = load i8, ptr %7075, align 1, !tbaa !9
  %7077 = zext i8 %7076 to i64
  %7078 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7077
  %7079 = load i8, ptr %7078, align 1, !tbaa !9
  %7080 = load ptr, ptr %6, align 8, !tbaa !5
  store i8 %7079, ptr %7080, align 1, !tbaa !9
  %7081 = load ptr, ptr %6, align 8, !tbaa !5
  %7082 = getelementptr inbounds i8, ptr %7081, i64 1
  %7083 = load i8, ptr %7082, align 1, !tbaa !9
  %7084 = zext i8 %7083 to i64
  %7085 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7084
  %7086 = load i8, ptr %7085, align 1, !tbaa !9
  %7087 = load ptr, ptr %6, align 8, !tbaa !5
  %7088 = getelementptr inbounds i8, ptr %7087, i64 1
  store i8 %7086, ptr %7088, align 1, !tbaa !9
  %7089 = load ptr, ptr %6, align 8, !tbaa !5
  %7090 = getelementptr inbounds i8, ptr %7089, i64 2
  %7091 = load i8, ptr %7090, align 1, !tbaa !9
  %7092 = zext i8 %7091 to i64
  %7093 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7092
  %7094 = load i8, ptr %7093, align 1, !tbaa !9
  %7095 = load ptr, ptr %6, align 8, !tbaa !5
  %7096 = getelementptr inbounds i8, ptr %7095, i64 2
  store i8 %7094, ptr %7096, align 1, !tbaa !9
  %7097 = load ptr, ptr %6, align 8, !tbaa !5
  %7098 = getelementptr inbounds i8, ptr %7097, i64 3
  %7099 = load i8, ptr %7098, align 1, !tbaa !9
  %7100 = zext i8 %7099 to i64
  %7101 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7100
  %7102 = load i8, ptr %7101, align 1, !tbaa !9
  %7103 = load ptr, ptr %6, align 8, !tbaa !5
  %7104 = getelementptr inbounds i8, ptr %7103, i64 3
  store i8 %7102, ptr %7104, align 1, !tbaa !9
  %7105 = load ptr, ptr %6, align 8, !tbaa !5
  %7106 = getelementptr inbounds i8, ptr %7105, i64 4
  %7107 = load i8, ptr %7106, align 1, !tbaa !9
  %7108 = zext i8 %7107 to i64
  %7109 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7108
  %7110 = load i8, ptr %7109, align 1, !tbaa !9
  %7111 = load ptr, ptr %6, align 8, !tbaa !5
  %7112 = getelementptr inbounds i8, ptr %7111, i64 4
  store i8 %7110, ptr %7112, align 1, !tbaa !9
  %7113 = load ptr, ptr %6, align 8, !tbaa !5
  %7114 = getelementptr inbounds i8, ptr %7113, i64 5
  %7115 = load i8, ptr %7114, align 1, !tbaa !9
  %7116 = zext i8 %7115 to i64
  %7117 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7116
  %7118 = load i8, ptr %7117, align 1, !tbaa !9
  %7119 = load ptr, ptr %6, align 8, !tbaa !5
  %7120 = getelementptr inbounds i8, ptr %7119, i64 5
  store i8 %7118, ptr %7120, align 1, !tbaa !9
  %7121 = load ptr, ptr %6, align 8, !tbaa !5
  %7122 = getelementptr inbounds i8, ptr %7121, i64 6
  %7123 = load i8, ptr %7122, align 1, !tbaa !9
  %7124 = zext i8 %7123 to i64
  %7125 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7124
  %7126 = load i8, ptr %7125, align 1, !tbaa !9
  %7127 = load ptr, ptr %6, align 8, !tbaa !5
  %7128 = getelementptr inbounds i8, ptr %7127, i64 6
  store i8 %7126, ptr %7128, align 1, !tbaa !9
  %7129 = load ptr, ptr %6, align 8, !tbaa !5
  %7130 = getelementptr inbounds i8, ptr %7129, i64 7
  %7131 = load i8, ptr %7130, align 1, !tbaa !9
  %7132 = zext i8 %7131 to i64
  %7133 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7132
  %7134 = load i8, ptr %7133, align 1, !tbaa !9
  %7135 = load ptr, ptr %6, align 8, !tbaa !5
  %7136 = getelementptr inbounds i8, ptr %7135, i64 7
  store i8 %7134, ptr %7136, align 1, !tbaa !9
  %7137 = load ptr, ptr %6, align 8, !tbaa !5
  %7138 = getelementptr inbounds i8, ptr %7137, i64 8
  %7139 = load i8, ptr %7138, align 1, !tbaa !9
  %7140 = zext i8 %7139 to i64
  %7141 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7140
  %7142 = load i8, ptr %7141, align 1, !tbaa !9
  %7143 = load ptr, ptr %6, align 8, !tbaa !5
  %7144 = getelementptr inbounds i8, ptr %7143, i64 8
  store i8 %7142, ptr %7144, align 1, !tbaa !9
  %7145 = load ptr, ptr %6, align 8, !tbaa !5
  %7146 = getelementptr inbounds i8, ptr %7145, i64 9
  %7147 = load i8, ptr %7146, align 1, !tbaa !9
  %7148 = zext i8 %7147 to i64
  %7149 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7148
  %7150 = load i8, ptr %7149, align 1, !tbaa !9
  %7151 = load ptr, ptr %6, align 8, !tbaa !5
  %7152 = getelementptr inbounds i8, ptr %7151, i64 9
  store i8 %7150, ptr %7152, align 1, !tbaa !9
  %7153 = load ptr, ptr %6, align 8, !tbaa !5
  %7154 = getelementptr inbounds i8, ptr %7153, i64 10
  %7155 = load i8, ptr %7154, align 1, !tbaa !9
  %7156 = zext i8 %7155 to i64
  %7157 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7156
  %7158 = load i8, ptr %7157, align 1, !tbaa !9
  %7159 = load ptr, ptr %6, align 8, !tbaa !5
  %7160 = getelementptr inbounds i8, ptr %7159, i64 10
  store i8 %7158, ptr %7160, align 1, !tbaa !9
  %7161 = load ptr, ptr %6, align 8, !tbaa !5
  %7162 = getelementptr inbounds i8, ptr %7161, i64 11
  %7163 = load i8, ptr %7162, align 1, !tbaa !9
  %7164 = zext i8 %7163 to i64
  %7165 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7164
  %7166 = load i8, ptr %7165, align 1, !tbaa !9
  %7167 = load ptr, ptr %6, align 8, !tbaa !5
  %7168 = getelementptr inbounds i8, ptr %7167, i64 11
  store i8 %7166, ptr %7168, align 1, !tbaa !9
  %7169 = load ptr, ptr %6, align 8, !tbaa !5
  %7170 = getelementptr inbounds i8, ptr %7169, i64 12
  %7171 = load i8, ptr %7170, align 1, !tbaa !9
  %7172 = zext i8 %7171 to i64
  %7173 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7172
  %7174 = load i8, ptr %7173, align 1, !tbaa !9
  %7175 = load ptr, ptr %6, align 8, !tbaa !5
  %7176 = getelementptr inbounds i8, ptr %7175, i64 12
  store i8 %7174, ptr %7176, align 1, !tbaa !9
  %7177 = load ptr, ptr %6, align 8, !tbaa !5
  %7178 = getelementptr inbounds i8, ptr %7177, i64 13
  %7179 = load i8, ptr %7178, align 1, !tbaa !9
  %7180 = zext i8 %7179 to i64
  %7181 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7180
  %7182 = load i8, ptr %7181, align 1, !tbaa !9
  %7183 = load ptr, ptr %6, align 8, !tbaa !5
  %7184 = getelementptr inbounds i8, ptr %7183, i64 13
  store i8 %7182, ptr %7184, align 1, !tbaa !9
  %7185 = load ptr, ptr %6, align 8, !tbaa !5
  %7186 = getelementptr inbounds i8, ptr %7185, i64 14
  %7187 = load i8, ptr %7186, align 1, !tbaa !9
  %7188 = zext i8 %7187 to i64
  %7189 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7188
  %7190 = load i8, ptr %7189, align 1, !tbaa !9
  %7191 = load ptr, ptr %6, align 8, !tbaa !5
  %7192 = getelementptr inbounds i8, ptr %7191, i64 14
  store i8 %7190, ptr %7192, align 1, !tbaa !9
  %7193 = load ptr, ptr %6, align 8, !tbaa !5
  %7194 = getelementptr inbounds i8, ptr %7193, i64 15
  %7195 = load i8, ptr %7194, align 1, !tbaa !9
  %7196 = zext i8 %7195 to i64
  %7197 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %7196
  %7198 = load i8, ptr %7197, align 1, !tbaa !9
  %7199 = load ptr, ptr %6, align 8, !tbaa !5
  %7200 = getelementptr inbounds i8, ptr %7199, i64 15
  store i8 %7198, ptr %7200, align 1, !tbaa !9
  %7201 = load ptr, ptr %6, align 8, !tbaa !5
  %7202 = getelementptr inbounds i8, ptr %7201, i64 1
  %7203 = load i8, ptr %7202, align 1, !tbaa !9
  store i8 %7203, ptr %8, align 1, !tbaa !9
  %7204 = load ptr, ptr %6, align 8, !tbaa !5
  %7205 = getelementptr inbounds i8, ptr %7204, i64 5
  %7206 = load i8, ptr %7205, align 1, !tbaa !9
  %7207 = load ptr, ptr %6, align 8, !tbaa !5
  %7208 = getelementptr inbounds i8, ptr %7207, i64 1
  store i8 %7206, ptr %7208, align 1, !tbaa !9
  %7209 = load ptr, ptr %6, align 8, !tbaa !5
  %7210 = getelementptr inbounds i8, ptr %7209, i64 9
  %7211 = load i8, ptr %7210, align 1, !tbaa !9
  %7212 = load ptr, ptr %6, align 8, !tbaa !5
  %7213 = getelementptr inbounds i8, ptr %7212, i64 5
  store i8 %7211, ptr %7213, align 1, !tbaa !9
  %7214 = load ptr, ptr %6, align 8, !tbaa !5
  %7215 = getelementptr inbounds i8, ptr %7214, i64 13
  %7216 = load i8, ptr %7215, align 1, !tbaa !9
  %7217 = load ptr, ptr %6, align 8, !tbaa !5
  %7218 = getelementptr inbounds i8, ptr %7217, i64 9
  store i8 %7216, ptr %7218, align 1, !tbaa !9
  %7219 = load i8, ptr %8, align 1, !tbaa !9
  %7220 = load ptr, ptr %6, align 8, !tbaa !5
  %7221 = getelementptr inbounds i8, ptr %7220, i64 13
  store i8 %7219, ptr %7221, align 1, !tbaa !9
  %7222 = load ptr, ptr %6, align 8, !tbaa !5
  %7223 = getelementptr inbounds i8, ptr %7222, i64 2
  %7224 = load i8, ptr %7223, align 1, !tbaa !9
  store i8 %7224, ptr %8, align 1, !tbaa !9
  %7225 = load ptr, ptr %6, align 8, !tbaa !5
  %7226 = getelementptr inbounds i8, ptr %7225, i64 10
  %7227 = load i8, ptr %7226, align 1, !tbaa !9
  %7228 = load ptr, ptr %6, align 8, !tbaa !5
  %7229 = getelementptr inbounds i8, ptr %7228, i64 2
  store i8 %7227, ptr %7229, align 1, !tbaa !9
  %7230 = load i8, ptr %8, align 1, !tbaa !9
  %7231 = load ptr, ptr %6, align 8, !tbaa !5
  %7232 = getelementptr inbounds i8, ptr %7231, i64 10
  store i8 %7230, ptr %7232, align 1, !tbaa !9
  %7233 = load ptr, ptr %6, align 8, !tbaa !5
  %7234 = getelementptr inbounds i8, ptr %7233, i64 6
  %7235 = load i8, ptr %7234, align 1, !tbaa !9
  store i8 %7235, ptr %8, align 1, !tbaa !9
  %7236 = load ptr, ptr %6, align 8, !tbaa !5
  %7237 = getelementptr inbounds i8, ptr %7236, i64 14
  %7238 = load i8, ptr %7237, align 1, !tbaa !9
  %7239 = load ptr, ptr %6, align 8, !tbaa !5
  %7240 = getelementptr inbounds i8, ptr %7239, i64 6
  store i8 %7238, ptr %7240, align 1, !tbaa !9
  %7241 = load i8, ptr %8, align 1, !tbaa !9
  %7242 = load ptr, ptr %6, align 8, !tbaa !5
  %7243 = getelementptr inbounds i8, ptr %7242, i64 14
  store i8 %7241, ptr %7243, align 1, !tbaa !9
  %7244 = load ptr, ptr %6, align 8, !tbaa !5
  %7245 = getelementptr inbounds i8, ptr %7244, i64 15
  %7246 = load i8, ptr %7245, align 1, !tbaa !9
  store i8 %7246, ptr %8, align 1, !tbaa !9
  %7247 = load ptr, ptr %6, align 8, !tbaa !5
  %7248 = getelementptr inbounds i8, ptr %7247, i64 11
  %7249 = load i8, ptr %7248, align 1, !tbaa !9
  %7250 = load ptr, ptr %6, align 8, !tbaa !5
  %7251 = getelementptr inbounds i8, ptr %7250, i64 15
  store i8 %7249, ptr %7251, align 1, !tbaa !9
  %7252 = load ptr, ptr %6, align 8, !tbaa !5
  %7253 = getelementptr inbounds i8, ptr %7252, i64 7
  %7254 = load i8, ptr %7253, align 1, !tbaa !9
  %7255 = load ptr, ptr %6, align 8, !tbaa !5
  %7256 = getelementptr inbounds i8, ptr %7255, i64 11
  store i8 %7254, ptr %7256, align 1, !tbaa !9
  %7257 = load ptr, ptr %6, align 8, !tbaa !5
  %7258 = getelementptr inbounds i8, ptr %7257, i64 3
  %7259 = load i8, ptr %7258, align 1, !tbaa !9
  %7260 = load ptr, ptr %6, align 8, !tbaa !5
  %7261 = getelementptr inbounds i8, ptr %7260, i64 7
  store i8 %7259, ptr %7261, align 1, !tbaa !9
  %7262 = load i8, ptr %8, align 1, !tbaa !9
  %7263 = load ptr, ptr %6, align 8, !tbaa !5
  %7264 = getelementptr inbounds i8, ptr %7263, i64 3
  store i8 %7262, ptr %7264, align 1, !tbaa !9
  %7265 = load ptr, ptr %6, align 8, !tbaa !5
  %7266 = load i8, ptr %7265, align 1, !tbaa !9
  %7267 = zext i8 %7266 to i32
  %7268 = load ptr, ptr %4, align 8, !tbaa !5
  %7269 = getelementptr inbounds i8, ptr %7268, i32 1
  store ptr %7269, ptr %4, align 8, !tbaa !5
  %7270 = load i8, ptr %7268, align 1, !tbaa !9
  %7271 = zext i8 %7270 to i32
  %7272 = xor i32 %7267, %7271
  %7273 = trunc i32 %7272 to i8
  %7274 = load ptr, ptr %6, align 8, !tbaa !5
  store i8 %7273, ptr %7274, align 1, !tbaa !9
  %7275 = load ptr, ptr %6, align 8, !tbaa !5
  %7276 = getelementptr inbounds i8, ptr %7275, i64 1
  %7277 = load i8, ptr %7276, align 1, !tbaa !9
  %7278 = zext i8 %7277 to i32
  %7279 = load ptr, ptr %4, align 8, !tbaa !5
  %7280 = getelementptr inbounds i8, ptr %7279, i32 1
  store ptr %7280, ptr %4, align 8, !tbaa !5
  %7281 = load i8, ptr %7279, align 1, !tbaa !9
  %7282 = zext i8 %7281 to i32
  %7283 = xor i32 %7278, %7282
  %7284 = trunc i32 %7283 to i8
  %7285 = load ptr, ptr %6, align 8, !tbaa !5
  %7286 = getelementptr inbounds i8, ptr %7285, i64 1
  store i8 %7284, ptr %7286, align 1, !tbaa !9
  %7287 = load ptr, ptr %6, align 8, !tbaa !5
  %7288 = getelementptr inbounds i8, ptr %7287, i64 2
  %7289 = load i8, ptr %7288, align 1, !tbaa !9
  %7290 = zext i8 %7289 to i32
  %7291 = load ptr, ptr %4, align 8, !tbaa !5
  %7292 = getelementptr inbounds i8, ptr %7291, i32 1
  store ptr %7292, ptr %4, align 8, !tbaa !5
  %7293 = load i8, ptr %7291, align 1, !tbaa !9
  %7294 = zext i8 %7293 to i32
  %7295 = xor i32 %7290, %7294
  %7296 = trunc i32 %7295 to i8
  %7297 = load ptr, ptr %6, align 8, !tbaa !5
  %7298 = getelementptr inbounds i8, ptr %7297, i64 2
  store i8 %7296, ptr %7298, align 1, !tbaa !9
  %7299 = load ptr, ptr %6, align 8, !tbaa !5
  %7300 = getelementptr inbounds i8, ptr %7299, i64 3
  %7301 = load i8, ptr %7300, align 1, !tbaa !9
  %7302 = zext i8 %7301 to i32
  %7303 = load ptr, ptr %4, align 8, !tbaa !5
  %7304 = getelementptr inbounds i8, ptr %7303, i32 1
  store ptr %7304, ptr %4, align 8, !tbaa !5
  %7305 = load i8, ptr %7303, align 1, !tbaa !9
  %7306 = zext i8 %7305 to i32
  %7307 = xor i32 %7302, %7306
  %7308 = trunc i32 %7307 to i8
  %7309 = load ptr, ptr %6, align 8, !tbaa !5
  %7310 = getelementptr inbounds i8, ptr %7309, i64 3
  store i8 %7308, ptr %7310, align 1, !tbaa !9
  %7311 = load ptr, ptr %6, align 8, !tbaa !5
  %7312 = getelementptr inbounds i8, ptr %7311, i64 4
  %7313 = load i8, ptr %7312, align 1, !tbaa !9
  %7314 = zext i8 %7313 to i32
  %7315 = load ptr, ptr %4, align 8, !tbaa !5
  %7316 = getelementptr inbounds i8, ptr %7315, i32 1
  store ptr %7316, ptr %4, align 8, !tbaa !5
  %7317 = load i8, ptr %7315, align 1, !tbaa !9
  %7318 = zext i8 %7317 to i32
  %7319 = xor i32 %7314, %7318
  %7320 = trunc i32 %7319 to i8
  %7321 = load ptr, ptr %6, align 8, !tbaa !5
  %7322 = getelementptr inbounds i8, ptr %7321, i64 4
  store i8 %7320, ptr %7322, align 1, !tbaa !9
  %7323 = load ptr, ptr %6, align 8, !tbaa !5
  %7324 = getelementptr inbounds i8, ptr %7323, i64 5
  %7325 = load i8, ptr %7324, align 1, !tbaa !9
  %7326 = zext i8 %7325 to i32
  %7327 = load ptr, ptr %4, align 8, !tbaa !5
  %7328 = getelementptr inbounds i8, ptr %7327, i32 1
  store ptr %7328, ptr %4, align 8, !tbaa !5
  %7329 = load i8, ptr %7327, align 1, !tbaa !9
  %7330 = zext i8 %7329 to i32
  %7331 = xor i32 %7326, %7330
  %7332 = trunc i32 %7331 to i8
  %7333 = load ptr, ptr %6, align 8, !tbaa !5
  %7334 = getelementptr inbounds i8, ptr %7333, i64 5
  store i8 %7332, ptr %7334, align 1, !tbaa !9
  %7335 = load ptr, ptr %6, align 8, !tbaa !5
  %7336 = getelementptr inbounds i8, ptr %7335, i64 6
  %7337 = load i8, ptr %7336, align 1, !tbaa !9
  %7338 = zext i8 %7337 to i32
  %7339 = load ptr, ptr %4, align 8, !tbaa !5
  %7340 = getelementptr inbounds i8, ptr %7339, i32 1
  store ptr %7340, ptr %4, align 8, !tbaa !5
  %7341 = load i8, ptr %7339, align 1, !tbaa !9
  %7342 = zext i8 %7341 to i32
  %7343 = xor i32 %7338, %7342
  %7344 = trunc i32 %7343 to i8
  %7345 = load ptr, ptr %6, align 8, !tbaa !5
  %7346 = getelementptr inbounds i8, ptr %7345, i64 6
  store i8 %7344, ptr %7346, align 1, !tbaa !9
  %7347 = load ptr, ptr %6, align 8, !tbaa !5
  %7348 = getelementptr inbounds i8, ptr %7347, i64 7
  %7349 = load i8, ptr %7348, align 1, !tbaa !9
  %7350 = zext i8 %7349 to i32
  %7351 = load ptr, ptr %4, align 8, !tbaa !5
  %7352 = getelementptr inbounds i8, ptr %7351, i32 1
  store ptr %7352, ptr %4, align 8, !tbaa !5
  %7353 = load i8, ptr %7351, align 1, !tbaa !9
  %7354 = zext i8 %7353 to i32
  %7355 = xor i32 %7350, %7354
  %7356 = trunc i32 %7355 to i8
  %7357 = load ptr, ptr %6, align 8, !tbaa !5
  %7358 = getelementptr inbounds i8, ptr %7357, i64 7
  store i8 %7356, ptr %7358, align 1, !tbaa !9
  %7359 = load ptr, ptr %6, align 8, !tbaa !5
  %7360 = getelementptr inbounds i8, ptr %7359, i64 8
  %7361 = load i8, ptr %7360, align 1, !tbaa !9
  %7362 = zext i8 %7361 to i32
  %7363 = load ptr, ptr %4, align 8, !tbaa !5
  %7364 = getelementptr inbounds i8, ptr %7363, i32 1
  store ptr %7364, ptr %4, align 8, !tbaa !5
  %7365 = load i8, ptr %7363, align 1, !tbaa !9
  %7366 = zext i8 %7365 to i32
  %7367 = xor i32 %7362, %7366
  %7368 = trunc i32 %7367 to i8
  %7369 = load ptr, ptr %6, align 8, !tbaa !5
  %7370 = getelementptr inbounds i8, ptr %7369, i64 8
  store i8 %7368, ptr %7370, align 1, !tbaa !9
  %7371 = load ptr, ptr %6, align 8, !tbaa !5
  %7372 = getelementptr inbounds i8, ptr %7371, i64 9
  %7373 = load i8, ptr %7372, align 1, !tbaa !9
  %7374 = zext i8 %7373 to i32
  %7375 = load ptr, ptr %4, align 8, !tbaa !5
  %7376 = getelementptr inbounds i8, ptr %7375, i32 1
  store ptr %7376, ptr %4, align 8, !tbaa !5
  %7377 = load i8, ptr %7375, align 1, !tbaa !9
  %7378 = zext i8 %7377 to i32
  %7379 = xor i32 %7374, %7378
  %7380 = trunc i32 %7379 to i8
  %7381 = load ptr, ptr %6, align 8, !tbaa !5
  %7382 = getelementptr inbounds i8, ptr %7381, i64 9
  store i8 %7380, ptr %7382, align 1, !tbaa !9
  %7383 = load ptr, ptr %6, align 8, !tbaa !5
  %7384 = getelementptr inbounds i8, ptr %7383, i64 10
  %7385 = load i8, ptr %7384, align 1, !tbaa !9
  %7386 = zext i8 %7385 to i32
  %7387 = load ptr, ptr %4, align 8, !tbaa !5
  %7388 = getelementptr inbounds i8, ptr %7387, i32 1
  store ptr %7388, ptr %4, align 8, !tbaa !5
  %7389 = load i8, ptr %7387, align 1, !tbaa !9
  %7390 = zext i8 %7389 to i32
  %7391 = xor i32 %7386, %7390
  %7392 = trunc i32 %7391 to i8
  %7393 = load ptr, ptr %6, align 8, !tbaa !5
  %7394 = getelementptr inbounds i8, ptr %7393, i64 10
  store i8 %7392, ptr %7394, align 1, !tbaa !9
  %7395 = load ptr, ptr %6, align 8, !tbaa !5
  %7396 = getelementptr inbounds i8, ptr %7395, i64 11
  %7397 = load i8, ptr %7396, align 1, !tbaa !9
  %7398 = zext i8 %7397 to i32
  %7399 = load ptr, ptr %4, align 8, !tbaa !5
  %7400 = getelementptr inbounds i8, ptr %7399, i32 1
  store ptr %7400, ptr %4, align 8, !tbaa !5
  %7401 = load i8, ptr %7399, align 1, !tbaa !9
  %7402 = zext i8 %7401 to i32
  %7403 = xor i32 %7398, %7402
  %7404 = trunc i32 %7403 to i8
  %7405 = load ptr, ptr %6, align 8, !tbaa !5
  %7406 = getelementptr inbounds i8, ptr %7405, i64 11
  store i8 %7404, ptr %7406, align 1, !tbaa !9
  %7407 = load ptr, ptr %6, align 8, !tbaa !5
  %7408 = getelementptr inbounds i8, ptr %7407, i64 12
  %7409 = load i8, ptr %7408, align 1, !tbaa !9
  %7410 = zext i8 %7409 to i32
  %7411 = load ptr, ptr %4, align 8, !tbaa !5
  %7412 = getelementptr inbounds i8, ptr %7411, i32 1
  store ptr %7412, ptr %4, align 8, !tbaa !5
  %7413 = load i8, ptr %7411, align 1, !tbaa !9
  %7414 = zext i8 %7413 to i32
  %7415 = xor i32 %7410, %7414
  %7416 = trunc i32 %7415 to i8
  %7417 = load ptr, ptr %6, align 8, !tbaa !5
  %7418 = getelementptr inbounds i8, ptr %7417, i64 12
  store i8 %7416, ptr %7418, align 1, !tbaa !9
  %7419 = load ptr, ptr %6, align 8, !tbaa !5
  %7420 = getelementptr inbounds i8, ptr %7419, i64 13
  %7421 = load i8, ptr %7420, align 1, !tbaa !9
  %7422 = zext i8 %7421 to i32
  %7423 = load ptr, ptr %4, align 8, !tbaa !5
  %7424 = getelementptr inbounds i8, ptr %7423, i32 1
  store ptr %7424, ptr %4, align 8, !tbaa !5
  %7425 = load i8, ptr %7423, align 1, !tbaa !9
  %7426 = zext i8 %7425 to i32
  %7427 = xor i32 %7422, %7426
  %7428 = trunc i32 %7427 to i8
  %7429 = load ptr, ptr %6, align 8, !tbaa !5
  %7430 = getelementptr inbounds i8, ptr %7429, i64 13
  store i8 %7428, ptr %7430, align 1, !tbaa !9
  %7431 = load ptr, ptr %6, align 8, !tbaa !5
  %7432 = getelementptr inbounds i8, ptr %7431, i64 14
  %7433 = load i8, ptr %7432, align 1, !tbaa !9
  %7434 = zext i8 %7433 to i32
  %7435 = load ptr, ptr %4, align 8, !tbaa !5
  %7436 = getelementptr inbounds i8, ptr %7435, i32 1
  store ptr %7436, ptr %4, align 8, !tbaa !5
  %7437 = load i8, ptr %7435, align 1, !tbaa !9
  %7438 = zext i8 %7437 to i32
  %7439 = xor i32 %7434, %7438
  %7440 = trunc i32 %7439 to i8
  %7441 = load ptr, ptr %6, align 8, !tbaa !5
  %7442 = getelementptr inbounds i8, ptr %7441, i64 14
  store i8 %7440, ptr %7442, align 1, !tbaa !9
  %7443 = load ptr, ptr %6, align 8, !tbaa !5
  %7444 = getelementptr inbounds i8, ptr %7443, i64 15
  %7445 = load i8, ptr %7444, align 1, !tbaa !9
  %7446 = zext i8 %7445 to i32
  %7447 = load ptr, ptr %4, align 8, !tbaa !5
  %7448 = getelementptr inbounds i8, ptr %7447, i32 1
  store ptr %7448, ptr %4, align 8, !tbaa !5
  %7449 = load i8, ptr %7447, align 1, !tbaa !9
  %7450 = zext i8 %7449 to i32
  %7451 = xor i32 %7446, %7450
  %7452 = trunc i32 %7451 to i8
  %7453 = load ptr, ptr %6, align 8, !tbaa !5
  %7454 = getelementptr inbounds i8, ptr %7453, i64 15
  store i8 %7452, ptr %7454, align 1, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 1, ptr %8) #3
  call void @llvm.lifetime.end.p0(i64 16, ptr %7) #3
  ret void
}

; Function Attrs: inlinehint nounwind uwtable
declare hidden zeroext i8 @mul2(i8 noundef zeroext) #2

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { 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 #2 = { inlinehint 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 #3 = { 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 = !{!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"

@SBOX = external hidden local_unnamed_addr global [256 x i8], align 16

; Function Attrs: nounwind uwtable
define dso_local void @aes_encrypt_128(ptr noundef readonly %0, ptr nocapture noundef readonly %1, ptr noundef %2) local_unnamed_addr #0 {
  %4 = load i8, ptr %1, align 1, !tbaa !5
  %5 = getelementptr inbounds i8, ptr %0, i64 1
  %6 = load i8, ptr %0, align 1, !tbaa !5
  %7 = xor i8 %6, %4
  store i8 %7, ptr %2, align 1, !tbaa !5
  %8 = getelementptr inbounds i8, ptr %1, i64 1
  %9 = load i8, ptr %8, align 1, !tbaa !5
  %10 = getelementptr inbounds i8, ptr %0, i64 2
  %11 = load i8, ptr %5, align 1, !tbaa !5
  %12 = xor i8 %11, %9
  %13 = getelementptr inbounds i8, ptr %2, i64 1
  store i8 %12, ptr %13, align 1, !tbaa !5
  %14 = getelementptr inbounds i8, ptr %1, i64 2
  %15 = load i8, ptr %14, align 1, !tbaa !5
  %16 = getelementptr inbounds i8, ptr %0, i64 3
  %17 = load i8, ptr %10, align 1, !tbaa !5
  %18 = xor i8 %17, %15
  %19 = getelementptr inbounds i8, ptr %2, i64 2
  store i8 %18, ptr %19, align 1, !tbaa !5
  %20 = getelementptr inbounds i8, ptr %1, i64 3
  %21 = load i8, ptr %20, align 1, !tbaa !5
  %22 = getelementptr inbounds i8, ptr %0, i64 4
  %23 = load i8, ptr %16, align 1, !tbaa !5
  %24 = xor i8 %23, %21
  %25 = getelementptr inbounds i8, ptr %2, i64 3
  store i8 %24, ptr %25, align 1, !tbaa !5
  %26 = getelementptr inbounds i8, ptr %1, i64 4
  %27 = load i8, ptr %26, align 1, !tbaa !5
  %28 = getelementptr inbounds i8, ptr %0, i64 5
  %29 = load i8, ptr %22, align 1, !tbaa !5
  %30 = xor i8 %29, %27
  %31 = getelementptr inbounds i8, ptr %2, i64 4
  store i8 %30, ptr %31, align 1, !tbaa !5
  %32 = getelementptr inbounds i8, ptr %1, i64 5
  %33 = load i8, ptr %32, align 1, !tbaa !5
  %34 = getelementptr inbounds i8, ptr %0, i64 6
  %35 = load i8, ptr %28, align 1, !tbaa !5
  %36 = xor i8 %35, %33
  %37 = getelementptr inbounds i8, ptr %2, i64 5
  store i8 %36, ptr %37, align 1, !tbaa !5
  %38 = getelementptr inbounds i8, ptr %1, i64 6
  %39 = load i8, ptr %38, align 1, !tbaa !5
  %40 = getelementptr inbounds i8, ptr %0, i64 7
  %41 = load i8, ptr %34, align 1, !tbaa !5
  %42 = xor i8 %41, %39
  %43 = getelementptr inbounds i8, ptr %2, i64 6
  store i8 %42, ptr %43, align 1, !tbaa !5
  %44 = getelementptr inbounds i8, ptr %1, i64 7
  %45 = load i8, ptr %44, align 1, !tbaa !5
  %46 = getelementptr inbounds i8, ptr %0, i64 8
  %47 = load i8, ptr %40, align 1, !tbaa !5
  %48 = xor i8 %47, %45
  %49 = getelementptr inbounds i8, ptr %2, i64 7
  store i8 %48, ptr %49, align 1, !tbaa !5
  %50 = getelementptr inbounds i8, ptr %1, i64 8
  %51 = load i8, ptr %50, align 1, !tbaa !5
  %52 = getelementptr inbounds i8, ptr %0, i64 9
  %53 = load i8, ptr %46, align 1, !tbaa !5
  %54 = xor i8 %53, %51
  %55 = getelementptr inbounds i8, ptr %2, i64 8
  store i8 %54, ptr %55, align 1, !tbaa !5
  %56 = getelementptr inbounds i8, ptr %1, i64 9
  %57 = load i8, ptr %56, align 1, !tbaa !5
  %58 = getelementptr inbounds i8, ptr %0, i64 10
  %59 = load i8, ptr %52, align 1, !tbaa !5
  %60 = xor i8 %59, %57
  %61 = getelementptr inbounds i8, ptr %2, i64 9
  store i8 %60, ptr %61, align 1, !tbaa !5
  %62 = getelementptr inbounds i8, ptr %1, i64 10
  %63 = load i8, ptr %62, align 1, !tbaa !5
  %64 = getelementptr inbounds i8, ptr %0, i64 11
  %65 = load i8, ptr %58, align 1, !tbaa !5
  %66 = xor i8 %65, %63
  %67 = getelementptr inbounds i8, ptr %2, i64 10
  store i8 %66, ptr %67, align 1, !tbaa !5
  %68 = getelementptr inbounds i8, ptr %1, i64 11
  %69 = load i8, ptr %68, align 1, !tbaa !5
  %70 = getelementptr inbounds i8, ptr %0, i64 12
  %71 = load i8, ptr %64, align 1, !tbaa !5
  %72 = xor i8 %71, %69
  %73 = getelementptr inbounds i8, ptr %2, i64 11
  store i8 %72, ptr %73, align 1, !tbaa !5
  %74 = getelementptr inbounds i8, ptr %1, i64 12
  %75 = load i8, ptr %74, align 1, !tbaa !5
  %76 = getelementptr inbounds i8, ptr %0, i64 13
  %77 = load i8, ptr %70, align 1, !tbaa !5
  %78 = xor i8 %77, %75
  %79 = getelementptr inbounds i8, ptr %2, i64 12
  store i8 %78, ptr %79, align 1, !tbaa !5
  %80 = getelementptr inbounds i8, ptr %1, i64 13
  %81 = load i8, ptr %80, align 1, !tbaa !5
  %82 = getelementptr inbounds i8, ptr %0, i64 14
  %83 = load i8, ptr %76, align 1, !tbaa !5
  %84 = xor i8 %83, %81
  %85 = getelementptr inbounds i8, ptr %2, i64 13
  store i8 %84, ptr %85, align 1, !tbaa !5
  %86 = getelementptr inbounds i8, ptr %1, i64 14
  %87 = load i8, ptr %86, align 1, !tbaa !5
  %88 = getelementptr inbounds i8, ptr %0, i64 15
  %89 = load i8, ptr %82, align 1, !tbaa !5
  %90 = xor i8 %89, %87
  %91 = getelementptr inbounds i8, ptr %2, i64 14
  store i8 %90, ptr %91, align 1, !tbaa !5
  %92 = getelementptr inbounds i8, ptr %1, i64 15
  %93 = load i8, ptr %92, align 1, !tbaa !5
  %94 = getelementptr inbounds i8, ptr %0, i64 16
  %95 = load i8, ptr %88, align 1, !tbaa !5
  %96 = xor i8 %95, %93
  %97 = getelementptr inbounds i8, ptr %2, i64 15
  store i8 %96, ptr %97, align 1, !tbaa !5
  %98 = zext i8 %7 to i64
  %99 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %98
  %100 = load i8, ptr %99, align 1, !tbaa !5
  %101 = zext i8 %12 to i64
  %102 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %101
  %103 = load i8, ptr %102, align 1, !tbaa !5
  %104 = zext i8 %18 to i64
  %105 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %104
  %106 = load i8, ptr %105, align 1, !tbaa !5
  %107 = zext i8 %24 to i64
  %108 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %107
  %109 = load i8, ptr %108, align 1, !tbaa !5
  %110 = zext i8 %30 to i64
  %111 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %110
  %112 = load i8, ptr %111, align 1, !tbaa !5
  %113 = zext i8 %36 to i64
  %114 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %113
  %115 = load i8, ptr %114, align 1, !tbaa !5
  %116 = zext i8 %42 to i64
  %117 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %116
  %118 = load i8, ptr %117, align 1, !tbaa !5
  %119 = zext i8 %48 to i64
  %120 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %119
  %121 = load i8, ptr %120, align 1, !tbaa !5
  %122 = zext i8 %54 to i64
  %123 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %122
  %124 = load i8, ptr %123, align 1, !tbaa !5
  %125 = zext i8 %60 to i64
  %126 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %125
  %127 = load i8, ptr %126, align 1, !tbaa !5
  %128 = zext i8 %66 to i64
  %129 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %128
  %130 = load i8, ptr %129, align 1, !tbaa !5
  %131 = zext i8 %72 to i64
  %132 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %131
  %133 = load i8, ptr %132, align 1, !tbaa !5
  %134 = zext i8 %78 to i64
  %135 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %134
  %136 = load i8, ptr %135, align 1, !tbaa !5
  %137 = zext i8 %84 to i64
  %138 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %137
  %139 = load i8, ptr %138, align 1, !tbaa !5
  %140 = zext i8 %90 to i64
  %141 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %140
  %142 = load i8, ptr %141, align 1, !tbaa !5
  %143 = zext i8 %96 to i64
  %144 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %143
  %145 = load i8, ptr %144, align 1, !tbaa !5
  %146 = xor i8 %115, %100
  %147 = xor i8 %130, %146
  %148 = xor i8 %145, %147
  %149 = tail call zeroext i8 @mul2(i8 noundef zeroext %146)
  %150 = xor i8 %149, %100
  %151 = xor i8 %150, %148
  store i8 %151, ptr %2, align 1, !tbaa !5
  %152 = xor i8 %130, %115
  %153 = tail call zeroext i8 @mul2(i8 noundef zeroext %152)
  %154 = xor i8 %115, %153
  %155 = xor i8 %154, %148
  store i8 %155, ptr %13, align 1, !tbaa !5
  %156 = xor i8 %145, %130
  %157 = tail call zeroext i8 @mul2(i8 noundef zeroext %156)
  %158 = xor i8 %146, %157
  %159 = xor i8 %158, %145
  store i8 %159, ptr %19, align 1, !tbaa !5
  %160 = xor i8 %145, %100
  %161 = tail call zeroext i8 @mul2(i8 noundef zeroext %160)
  %162 = xor i8 %161, %147
  store i8 %162, ptr %25, align 1, !tbaa !5
  %163 = xor i8 %127, %112
  %164 = xor i8 %142, %163
  %165 = xor i8 %164, %109
  %166 = tail call zeroext i8 @mul2(i8 noundef zeroext %163)
  %167 = xor i8 %112, %166
  %168 = xor i8 %167, %165
  store i8 %168, ptr %31, align 1, !tbaa !5
  %169 = xor i8 %142, %127
  %170 = tail call zeroext i8 @mul2(i8 noundef zeroext %169)
  %171 = xor i8 %127, %170
  %172 = xor i8 %171, %165
  store i8 %172, ptr %37, align 1, !tbaa !5
  %173 = xor i8 %142, %109
  %174 = tail call zeroext i8 @mul2(i8 noundef zeroext %173)
  %175 = xor i8 %109, %174
  %176 = xor i8 %175, %163
  store i8 %176, ptr %43, align 1, !tbaa !5
  %177 = xor i8 %112, %109
  %178 = tail call zeroext i8 @mul2(i8 noundef zeroext %177)
  %179 = xor i8 %178, %164
  store i8 %179, ptr %49, align 1, !tbaa !5
  %180 = xor i8 %139, %124
  %181 = xor i8 %180, %106
  %182 = xor i8 %181, %121
  %183 = tail call zeroext i8 @mul2(i8 noundef zeroext %180)
  %184 = xor i8 %124, %183
  %185 = xor i8 %184, %182
  store i8 %185, ptr %55, align 1, !tbaa !5
  %186 = xor i8 %139, %106
  %187 = tail call zeroext i8 @mul2(i8 noundef zeroext %186)
  %188 = xor i8 %139, %187
  %189 = xor i8 %188, %182
  store i8 %189, ptr %61, align 1, !tbaa !5
  %190 = xor i8 %121, %106
  %191 = tail call zeroext i8 @mul2(i8 noundef zeroext %190)
  %192 = xor i8 %121, %191
  %193 = xor i8 %192, %180
  store i8 %193, ptr %67, align 1, !tbaa !5
  %194 = xor i8 %124, %121
  %195 = tail call zeroext i8 @mul2(i8 noundef zeroext %194)
  %196 = xor i8 %195, %181
  store i8 %196, ptr %73, align 1, !tbaa !5
  %197 = xor i8 %136, %103
  %198 = xor i8 %197, %118
  %199 = xor i8 %198, %133
  %200 = tail call zeroext i8 @mul2(i8 noundef zeroext %197)
  %201 = xor i8 %136, %200
  %202 = xor i8 %201, %199
  store i8 %202, ptr %79, align 1, !tbaa !5
  %203 = xor i8 %118, %103
  %204 = tail call zeroext i8 @mul2(i8 noundef zeroext %203)
  %205 = xor i8 %103, %204
  %206 = xor i8 %205, %199
  store i8 %206, ptr %85, align 1, !tbaa !5
  %207 = xor i8 %133, %118
  %208 = tail call zeroext i8 @mul2(i8 noundef zeroext %207)
  %209 = xor i8 %133, %208
  %210 = xor i8 %209, %197
  store i8 %210, ptr %91, align 1, !tbaa !5
  %211 = xor i8 %136, %133
  %212 = tail call zeroext i8 @mul2(i8 noundef zeroext %211)
  %213 = xor i8 %212, %198
  store i8 %213, ptr %97, align 1, !tbaa !5
  %214 = load i8, ptr %2, align 1, !tbaa !5
  %215 = getelementptr inbounds i8, ptr %0, i64 17
  %216 = load i8, ptr %94, align 1, !tbaa !5
  %217 = xor i8 %216, %214
  store i8 %217, ptr %2, align 1, !tbaa !5
  %218 = load i8, ptr %13, align 1, !tbaa !5
  %219 = getelementptr inbounds i8, ptr %0, i64 18
  %220 = load i8, ptr %215, align 1, !tbaa !5
  %221 = xor i8 %220, %218
  store i8 %221, ptr %13, align 1, !tbaa !5
  %222 = load i8, ptr %19, align 1, !tbaa !5
  %223 = getelementptr inbounds i8, ptr %0, i64 19
  %224 = load i8, ptr %219, align 1, !tbaa !5
  %225 = xor i8 %224, %222
  store i8 %225, ptr %19, align 1, !tbaa !5
  %226 = load i8, ptr %25, align 1, !tbaa !5
  %227 = getelementptr inbounds i8, ptr %0, i64 20
  %228 = load i8, ptr %223, align 1, !tbaa !5
  %229 = xor i8 %228, %226
  store i8 %229, ptr %25, align 1, !tbaa !5
  %230 = load i8, ptr %31, align 1, !tbaa !5
  %231 = getelementptr inbounds i8, ptr %0, i64 21
  %232 = load i8, ptr %227, align 1, !tbaa !5
  %233 = xor i8 %232, %230
  store i8 %233, ptr %31, align 1, !tbaa !5
  %234 = load i8, ptr %37, align 1, !tbaa !5
  %235 = getelementptr inbounds i8, ptr %0, i64 22
  %236 = load i8, ptr %231, align 1, !tbaa !5
  %237 = xor i8 %236, %234
  store i8 %237, ptr %37, align 1, !tbaa !5
  %238 = load i8, ptr %43, align 1, !tbaa !5
  %239 = getelementptr inbounds i8, ptr %0, i64 23
  %240 = load i8, ptr %235, align 1, !tbaa !5
  %241 = xor i8 %240, %238
  store i8 %241, ptr %43, align 1, !tbaa !5
  %242 = load i8, ptr %49, align 1, !tbaa !5
  %243 = getelementptr inbounds i8, ptr %0, i64 24
  %244 = load i8, ptr %239, align 1, !tbaa !5
  %245 = xor i8 %244, %242
  store i8 %245, ptr %49, align 1, !tbaa !5
  %246 = load i8, ptr %55, align 1, !tbaa !5
  %247 = getelementptr inbounds i8, ptr %0, i64 25
  %248 = load i8, ptr %243, align 1, !tbaa !5
  %249 = xor i8 %248, %246
  store i8 %249, ptr %55, align 1, !tbaa !5
  %250 = load i8, ptr %61, align 1, !tbaa !5
  %251 = getelementptr inbounds i8, ptr %0, i64 26
  %252 = load i8, ptr %247, align 1, !tbaa !5
  %253 = xor i8 %252, %250
  store i8 %253, ptr %61, align 1, !tbaa !5
  %254 = load i8, ptr %67, align 1, !tbaa !5
  %255 = getelementptr inbounds i8, ptr %0, i64 27
  %256 = load i8, ptr %251, align 1, !tbaa !5
  %257 = xor i8 %256, %254
  store i8 %257, ptr %67, align 1, !tbaa !5
  %258 = load i8, ptr %73, align 1, !tbaa !5
  %259 = getelementptr inbounds i8, ptr %0, i64 28
  %260 = load i8, ptr %255, align 1, !tbaa !5
  %261 = xor i8 %260, %258
  store i8 %261, ptr %73, align 1, !tbaa !5
  %262 = load i8, ptr %79, align 1, !tbaa !5
  %263 = getelementptr inbounds i8, ptr %0, i64 29
  %264 = load i8, ptr %259, align 1, !tbaa !5
  %265 = xor i8 %264, %262
  store i8 %265, ptr %79, align 1, !tbaa !5
  %266 = load i8, ptr %85, align 1, !tbaa !5
  %267 = getelementptr inbounds i8, ptr %0, i64 30
  %268 = load i8, ptr %263, align 1, !tbaa !5
  %269 = xor i8 %268, %266
  store i8 %269, ptr %85, align 1, !tbaa !5
  %270 = load i8, ptr %91, align 1, !tbaa !5
  %271 = getelementptr inbounds i8, ptr %0, i64 31
  %272 = load i8, ptr %267, align 1, !tbaa !5
  %273 = xor i8 %272, %270
  store i8 %273, ptr %91, align 1, !tbaa !5
  %274 = getelementptr inbounds i8, ptr %0, i64 32
  %275 = load i8, ptr %271, align 1, !tbaa !5
  %276 = xor i8 %275, %213
  store i8 %276, ptr %97, align 1, !tbaa !5
  %277 = zext i8 %217 to i64
  %278 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %277
  %279 = load i8, ptr %278, align 1, !tbaa !5
  %280 = zext i8 %221 to i64
  %281 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %280
  %282 = load i8, ptr %281, align 1, !tbaa !5
  %283 = zext i8 %225 to i64
  %284 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %283
  %285 = load i8, ptr %284, align 1, !tbaa !5
  %286 = zext i8 %229 to i64
  %287 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %286
  %288 = load i8, ptr %287, align 1, !tbaa !5
  %289 = zext i8 %233 to i64
  %290 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %289
  %291 = load i8, ptr %290, align 1, !tbaa !5
  %292 = zext i8 %237 to i64
  %293 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %292
  %294 = load i8, ptr %293, align 1, !tbaa !5
  %295 = zext i8 %241 to i64
  %296 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %295
  %297 = load i8, ptr %296, align 1, !tbaa !5
  %298 = zext i8 %245 to i64
  %299 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %298
  %300 = load i8, ptr %299, align 1, !tbaa !5
  %301 = zext i8 %249 to i64
  %302 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %301
  %303 = load i8, ptr %302, align 1, !tbaa !5
  %304 = zext i8 %253 to i64
  %305 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %304
  %306 = load i8, ptr %305, align 1, !tbaa !5
  %307 = zext i8 %257 to i64
  %308 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %307
  %309 = load i8, ptr %308, align 1, !tbaa !5
  %310 = zext i8 %261 to i64
  %311 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %310
  %312 = load i8, ptr %311, align 1, !tbaa !5
  %313 = zext i8 %265 to i64
  %314 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %313
  %315 = load i8, ptr %314, align 1, !tbaa !5
  %316 = zext i8 %269 to i64
  %317 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %316
  %318 = load i8, ptr %317, align 1, !tbaa !5
  %319 = zext i8 %273 to i64
  %320 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %319
  %321 = load i8, ptr %320, align 1, !tbaa !5
  %322 = zext i8 %276 to i64
  %323 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %322
  %324 = load i8, ptr %323, align 1, !tbaa !5
  %325 = xor i8 %294, %279
  %326 = xor i8 %309, %325
  %327 = xor i8 %324, %326
  %328 = tail call zeroext i8 @mul2(i8 noundef zeroext %325)
  %329 = xor i8 %328, %279
  %330 = xor i8 %329, %327
  store i8 %330, ptr %2, align 1, !tbaa !5
  %331 = xor i8 %309, %294
  %332 = tail call zeroext i8 @mul2(i8 noundef zeroext %331)
  %333 = xor i8 %294, %332
  %334 = xor i8 %333, %327
  store i8 %334, ptr %13, align 1, !tbaa !5
  %335 = xor i8 %324, %309
  %336 = tail call zeroext i8 @mul2(i8 noundef zeroext %335)
  %337 = xor i8 %325, %336
  %338 = xor i8 %337, %324
  store i8 %338, ptr %19, align 1, !tbaa !5
  %339 = xor i8 %324, %279
  %340 = tail call zeroext i8 @mul2(i8 noundef zeroext %339)
  %341 = xor i8 %340, %326
  store i8 %341, ptr %25, align 1, !tbaa !5
  %342 = xor i8 %306, %291
  %343 = xor i8 %321, %342
  %344 = xor i8 %343, %288
  %345 = tail call zeroext i8 @mul2(i8 noundef zeroext %342)
  %346 = xor i8 %291, %345
  %347 = xor i8 %346, %344
  store i8 %347, ptr %31, align 1, !tbaa !5
  %348 = xor i8 %321, %306
  %349 = tail call zeroext i8 @mul2(i8 noundef zeroext %348)
  %350 = xor i8 %306, %349
  %351 = xor i8 %350, %344
  store i8 %351, ptr %37, align 1, !tbaa !5
  %352 = xor i8 %321, %288
  %353 = tail call zeroext i8 @mul2(i8 noundef zeroext %352)
  %354 = xor i8 %288, %353
  %355 = xor i8 %354, %342
  store i8 %355, ptr %43, align 1, !tbaa !5
  %356 = xor i8 %291, %288
  %357 = tail call zeroext i8 @mul2(i8 noundef zeroext %356)
  %358 = xor i8 %357, %343
  store i8 %358, ptr %49, align 1, !tbaa !5
  %359 = xor i8 %318, %303
  %360 = xor i8 %359, %285
  %361 = xor i8 %360, %300
  %362 = tail call zeroext i8 @mul2(i8 noundef zeroext %359)
  %363 = xor i8 %303, %362
  %364 = xor i8 %363, %361
  store i8 %364, ptr %55, align 1, !tbaa !5
  %365 = xor i8 %318, %285
  %366 = tail call zeroext i8 @mul2(i8 noundef zeroext %365)
  %367 = xor i8 %318, %366
  %368 = xor i8 %367, %361
  store i8 %368, ptr %61, align 1, !tbaa !5
  %369 = xor i8 %300, %285
  %370 = tail call zeroext i8 @mul2(i8 noundef zeroext %369)
  %371 = xor i8 %300, %370
  %372 = xor i8 %371, %359
  store i8 %372, ptr %67, align 1, !tbaa !5
  %373 = xor i8 %303, %300
  %374 = tail call zeroext i8 @mul2(i8 noundef zeroext %373)
  %375 = xor i8 %374, %360
  store i8 %375, ptr %73, align 1, !tbaa !5
  %376 = xor i8 %315, %282
  %377 = xor i8 %376, %297
  %378 = xor i8 %377, %312
  %379 = tail call zeroext i8 @mul2(i8 noundef zeroext %376)
  %380 = xor i8 %315, %379
  %381 = xor i8 %380, %378
  store i8 %381, ptr %79, align 1, !tbaa !5
  %382 = xor i8 %297, %282
  %383 = tail call zeroext i8 @mul2(i8 noundef zeroext %382)
  %384 = xor i8 %282, %383
  %385 = xor i8 %384, %378
  store i8 %385, ptr %85, align 1, !tbaa !5
  %386 = xor i8 %312, %297
  %387 = tail call zeroext i8 @mul2(i8 noundef zeroext %386)
  %388 = xor i8 %312, %387
  %389 = xor i8 %388, %376
  store i8 %389, ptr %91, align 1, !tbaa !5
  %390 = xor i8 %315, %312
  %391 = tail call zeroext i8 @mul2(i8 noundef zeroext %390)
  %392 = xor i8 %391, %377
  store i8 %392, ptr %97, align 1, !tbaa !5
  %393 = load i8, ptr %2, align 1, !tbaa !5
  %394 = getelementptr inbounds i8, ptr %0, i64 33
  %395 = load i8, ptr %274, align 1, !tbaa !5
  %396 = xor i8 %395, %393
  store i8 %396, ptr %2, align 1, !tbaa !5
  %397 = load i8, ptr %13, align 1, !tbaa !5
  %398 = getelementptr inbounds i8, ptr %0, i64 34
  %399 = load i8, ptr %394, align 1, !tbaa !5
  %400 = xor i8 %399, %397
  store i8 %400, ptr %13, align 1, !tbaa !5
  %401 = load i8, ptr %19, align 1, !tbaa !5
  %402 = getelementptr inbounds i8, ptr %0, i64 35
  %403 = load i8, ptr %398, align 1, !tbaa !5
  %404 = xor i8 %403, %401
  store i8 %404, ptr %19, align 1, !tbaa !5
  %405 = load i8, ptr %25, align 1, !tbaa !5
  %406 = getelementptr inbounds i8, ptr %0, i64 36
  %407 = load i8, ptr %402, align 1, !tbaa !5
  %408 = xor i8 %407, %405
  store i8 %408, ptr %25, align 1, !tbaa !5
  %409 = load i8, ptr %31, align 1, !tbaa !5
  %410 = getelementptr inbounds i8, ptr %0, i64 37
  %411 = load i8, ptr %406, align 1, !tbaa !5
  %412 = xor i8 %411, %409
  store i8 %412, ptr %31, align 1, !tbaa !5
  %413 = load i8, ptr %37, align 1, !tbaa !5
  %414 = getelementptr inbounds i8, ptr %0, i64 38
  %415 = load i8, ptr %410, align 1, !tbaa !5
  %416 = xor i8 %415, %413
  store i8 %416, ptr %37, align 1, !tbaa !5
  %417 = load i8, ptr %43, align 1, !tbaa !5
  %418 = getelementptr inbounds i8, ptr %0, i64 39
  %419 = load i8, ptr %414, align 1, !tbaa !5
  %420 = xor i8 %419, %417
  store i8 %420, ptr %43, align 1, !tbaa !5
  %421 = load i8, ptr %49, align 1, !tbaa !5
  %422 = getelementptr inbounds i8, ptr %0, i64 40
  %423 = load i8, ptr %418, align 1, !tbaa !5
  %424 = xor i8 %423, %421
  store i8 %424, ptr %49, align 1, !tbaa !5
  %425 = load i8, ptr %55, align 1, !tbaa !5
  %426 = getelementptr inbounds i8, ptr %0, i64 41
  %427 = load i8, ptr %422, align 1, !tbaa !5
  %428 = xor i8 %427, %425
  store i8 %428, ptr %55, align 1, !tbaa !5
  %429 = load i8, ptr %61, align 1, !tbaa !5
  %430 = getelementptr inbounds i8, ptr %0, i64 42
  %431 = load i8, ptr %426, align 1, !tbaa !5
  %432 = xor i8 %431, %429
  store i8 %432, ptr %61, align 1, !tbaa !5
  %433 = load i8, ptr %67, align 1, !tbaa !5
  %434 = getelementptr inbounds i8, ptr %0, i64 43
  %435 = load i8, ptr %430, align 1, !tbaa !5
  %436 = xor i8 %435, %433
  store i8 %436, ptr %67, align 1, !tbaa !5
  %437 = load i8, ptr %73, align 1, !tbaa !5
  %438 = getelementptr inbounds i8, ptr %0, i64 44
  %439 = load i8, ptr %434, align 1, !tbaa !5
  %440 = xor i8 %439, %437
  store i8 %440, ptr %73, align 1, !tbaa !5
  %441 = load i8, ptr %79, align 1, !tbaa !5
  %442 = getelementptr inbounds i8, ptr %0, i64 45
  %443 = load i8, ptr %438, align 1, !tbaa !5
  %444 = xor i8 %443, %441
  store i8 %444, ptr %79, align 1, !tbaa !5
  %445 = load i8, ptr %85, align 1, !tbaa !5
  %446 = getelementptr inbounds i8, ptr %0, i64 46
  %447 = load i8, ptr %442, align 1, !tbaa !5
  %448 = xor i8 %447, %445
  store i8 %448, ptr %85, align 1, !tbaa !5
  %449 = load i8, ptr %91, align 1, !tbaa !5
  %450 = getelementptr inbounds i8, ptr %0, i64 47
  %451 = load i8, ptr %446, align 1, !tbaa !5
  %452 = xor i8 %451, %449
  store i8 %452, ptr %91, align 1, !tbaa !5
  %453 = getelementptr inbounds i8, ptr %0, i64 48
  %454 = load i8, ptr %450, align 1, !tbaa !5
  %455 = xor i8 %454, %392
  store i8 %455, ptr %97, align 1, !tbaa !5
  %456 = zext i8 %396 to i64
  %457 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %456
  %458 = load i8, ptr %457, align 1, !tbaa !5
  %459 = zext i8 %400 to i64
  %460 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %459
  %461 = load i8, ptr %460, align 1, !tbaa !5
  %462 = zext i8 %404 to i64
  %463 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %462
  %464 = load i8, ptr %463, align 1, !tbaa !5
  %465 = zext i8 %408 to i64
  %466 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %465
  %467 = load i8, ptr %466, align 1, !tbaa !5
  %468 = zext i8 %412 to i64
  %469 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %468
  %470 = load i8, ptr %469, align 1, !tbaa !5
  %471 = zext i8 %416 to i64
  %472 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %471
  %473 = load i8, ptr %472, align 1, !tbaa !5
  %474 = zext i8 %420 to i64
  %475 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %474
  %476 = load i8, ptr %475, align 1, !tbaa !5
  %477 = zext i8 %424 to i64
  %478 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %477
  %479 = load i8, ptr %478, align 1, !tbaa !5
  %480 = zext i8 %428 to i64
  %481 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %480
  %482 = load i8, ptr %481, align 1, !tbaa !5
  %483 = zext i8 %432 to i64
  %484 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %483
  %485 = load i8, ptr %484, align 1, !tbaa !5
  %486 = zext i8 %436 to i64
  %487 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %486
  %488 = load i8, ptr %487, align 1, !tbaa !5
  %489 = zext i8 %440 to i64
  %490 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %489
  %491 = load i8, ptr %490, align 1, !tbaa !5
  %492 = zext i8 %444 to i64
  %493 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %492
  %494 = load i8, ptr %493, align 1, !tbaa !5
  %495 = zext i8 %448 to i64
  %496 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %495
  %497 = load i8, ptr %496, align 1, !tbaa !5
  %498 = zext i8 %452 to i64
  %499 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %498
  %500 = load i8, ptr %499, align 1, !tbaa !5
  %501 = zext i8 %455 to i64
  %502 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %501
  %503 = load i8, ptr %502, align 1, !tbaa !5
  %504 = xor i8 %473, %458
  %505 = xor i8 %488, %504
  %506 = xor i8 %503, %505
  %507 = tail call zeroext i8 @mul2(i8 noundef zeroext %504)
  %508 = xor i8 %507, %458
  %509 = xor i8 %508, %506
  store i8 %509, ptr %2, align 1, !tbaa !5
  %510 = xor i8 %488, %473
  %511 = tail call zeroext i8 @mul2(i8 noundef zeroext %510)
  %512 = xor i8 %473, %511
  %513 = xor i8 %512, %506
  store i8 %513, ptr %13, align 1, !tbaa !5
  %514 = xor i8 %503, %488
  %515 = tail call zeroext i8 @mul2(i8 noundef zeroext %514)
  %516 = xor i8 %504, %515
  %517 = xor i8 %516, %503
  store i8 %517, ptr %19, align 1, !tbaa !5
  %518 = xor i8 %503, %458
  %519 = tail call zeroext i8 @mul2(i8 noundef zeroext %518)
  %520 = xor i8 %519, %505
  store i8 %520, ptr %25, align 1, !tbaa !5
  %521 = xor i8 %485, %470
  %522 = xor i8 %500, %521
  %523 = xor i8 %522, %467
  %524 = tail call zeroext i8 @mul2(i8 noundef zeroext %521)
  %525 = xor i8 %470, %524
  %526 = xor i8 %525, %523
  store i8 %526, ptr %31, align 1, !tbaa !5
  %527 = xor i8 %500, %485
  %528 = tail call zeroext i8 @mul2(i8 noundef zeroext %527)
  %529 = xor i8 %485, %528
  %530 = xor i8 %529, %523
  store i8 %530, ptr %37, align 1, !tbaa !5
  %531 = xor i8 %500, %467
  %532 = tail call zeroext i8 @mul2(i8 noundef zeroext %531)
  %533 = xor i8 %467, %532
  %534 = xor i8 %533, %521
  store i8 %534, ptr %43, align 1, !tbaa !5
  %535 = xor i8 %470, %467
  %536 = tail call zeroext i8 @mul2(i8 noundef zeroext %535)
  %537 = xor i8 %536, %522
  store i8 %537, ptr %49, align 1, !tbaa !5
  %538 = xor i8 %497, %482
  %539 = xor i8 %538, %464
  %540 = xor i8 %539, %479
  %541 = tail call zeroext i8 @mul2(i8 noundef zeroext %538)
  %542 = xor i8 %482, %541
  %543 = xor i8 %542, %540
  store i8 %543, ptr %55, align 1, !tbaa !5
  %544 = xor i8 %497, %464
  %545 = tail call zeroext i8 @mul2(i8 noundef zeroext %544)
  %546 = xor i8 %497, %545
  %547 = xor i8 %546, %540
  store i8 %547, ptr %61, align 1, !tbaa !5
  %548 = xor i8 %479, %464
  %549 = tail call zeroext i8 @mul2(i8 noundef zeroext %548)
  %550 = xor i8 %479, %549
  %551 = xor i8 %550, %538
  store i8 %551, ptr %67, align 1, !tbaa !5
  %552 = xor i8 %482, %479
  %553 = tail call zeroext i8 @mul2(i8 noundef zeroext %552)
  %554 = xor i8 %553, %539
  store i8 %554, ptr %73, align 1, !tbaa !5
  %555 = xor i8 %494, %461
  %556 = xor i8 %555, %476
  %557 = xor i8 %556, %491
  %558 = tail call zeroext i8 @mul2(i8 noundef zeroext %555)
  %559 = xor i8 %494, %558
  %560 = xor i8 %559, %557
  store i8 %560, ptr %79, align 1, !tbaa !5
  %561 = xor i8 %476, %461
  %562 = tail call zeroext i8 @mul2(i8 noundef zeroext %561)
  %563 = xor i8 %461, %562
  %564 = xor i8 %563, %557
  store i8 %564, ptr %85, align 1, !tbaa !5
  %565 = xor i8 %491, %476
  %566 = tail call zeroext i8 @mul2(i8 noundef zeroext %565)
  %567 = xor i8 %491, %566
  %568 = xor i8 %567, %555
  store i8 %568, ptr %91, align 1, !tbaa !5
  %569 = xor i8 %494, %491
  %570 = tail call zeroext i8 @mul2(i8 noundef zeroext %569)
  %571 = xor i8 %570, %556
  store i8 %571, ptr %97, align 1, !tbaa !5
  %572 = load i8, ptr %2, align 1, !tbaa !5
  %573 = getelementptr inbounds i8, ptr %0, i64 49
  %574 = load i8, ptr %453, align 1, !tbaa !5
  %575 = xor i8 %574, %572
  store i8 %575, ptr %2, align 1, !tbaa !5
  %576 = load i8, ptr %13, align 1, !tbaa !5
  %577 = getelementptr inbounds i8, ptr %0, i64 50
  %578 = load i8, ptr %573, align 1, !tbaa !5
  %579 = xor i8 %578, %576
  store i8 %579, ptr %13, align 1, !tbaa !5
  %580 = load i8, ptr %19, align 1, !tbaa !5
  %581 = getelementptr inbounds i8, ptr %0, i64 51
  %582 = load i8, ptr %577, align 1, !tbaa !5
  %583 = xor i8 %582, %580
  store i8 %583, ptr %19, align 1, !tbaa !5
  %584 = load i8, ptr %25, align 1, !tbaa !5
  %585 = getelementptr inbounds i8, ptr %0, i64 52
  %586 = load i8, ptr %581, align 1, !tbaa !5
  %587 = xor i8 %586, %584
  store i8 %587, ptr %25, align 1, !tbaa !5
  %588 = load i8, ptr %31, align 1, !tbaa !5
  %589 = getelementptr inbounds i8, ptr %0, i64 53
  %590 = load i8, ptr %585, align 1, !tbaa !5
  %591 = xor i8 %590, %588
  store i8 %591, ptr %31, align 1, !tbaa !5
  %592 = load i8, ptr %37, align 1, !tbaa !5
  %593 = getelementptr inbounds i8, ptr %0, i64 54
  %594 = load i8, ptr %589, align 1, !tbaa !5
  %595 = xor i8 %594, %592
  store i8 %595, ptr %37, align 1, !tbaa !5
  %596 = load i8, ptr %43, align 1, !tbaa !5
  %597 = getelementptr inbounds i8, ptr %0, i64 55
  %598 = load i8, ptr %593, align 1, !tbaa !5
  %599 = xor i8 %598, %596
  store i8 %599, ptr %43, align 1, !tbaa !5
  %600 = load i8, ptr %49, align 1, !tbaa !5
  %601 = getelementptr inbounds i8, ptr %0, i64 56
  %602 = load i8, ptr %597, align 1, !tbaa !5
  %603 = xor i8 %602, %600
  store i8 %603, ptr %49, align 1, !tbaa !5
  %604 = load i8, ptr %55, align 1, !tbaa !5
  %605 = getelementptr inbounds i8, ptr %0, i64 57
  %606 = load i8, ptr %601, align 1, !tbaa !5
  %607 = xor i8 %606, %604
  store i8 %607, ptr %55, align 1, !tbaa !5
  %608 = load i8, ptr %61, align 1, !tbaa !5
  %609 = getelementptr inbounds i8, ptr %0, i64 58
  %610 = load i8, ptr %605, align 1, !tbaa !5
  %611 = xor i8 %610, %608
  store i8 %611, ptr %61, align 1, !tbaa !5
  %612 = load i8, ptr %67, align 1, !tbaa !5
  %613 = getelementptr inbounds i8, ptr %0, i64 59
  %614 = load i8, ptr %609, align 1, !tbaa !5
  %615 = xor i8 %614, %612
  store i8 %615, ptr %67, align 1, !tbaa !5
  %616 = load i8, ptr %73, align 1, !tbaa !5
  %617 = getelementptr inbounds i8, ptr %0, i64 60
  %618 = load i8, ptr %613, align 1, !tbaa !5
  %619 = xor i8 %618, %616
  store i8 %619, ptr %73, align 1, !tbaa !5
  %620 = load i8, ptr %79, align 1, !tbaa !5
  %621 = getelementptr inbounds i8, ptr %0, i64 61
  %622 = load i8, ptr %617, align 1, !tbaa !5
  %623 = xor i8 %622, %620
  store i8 %623, ptr %79, align 1, !tbaa !5
  %624 = load i8, ptr %85, align 1, !tbaa !5
  %625 = getelementptr inbounds i8, ptr %0, i64 62
  %626 = load i8, ptr %621, align 1, !tbaa !5
  %627 = xor i8 %626, %624
  store i8 %627, ptr %85, align 1, !tbaa !5
  %628 = load i8, ptr %91, align 1, !tbaa !5
  %629 = getelementptr inbounds i8, ptr %0, i64 63
  %630 = load i8, ptr %625, align 1, !tbaa !5
  %631 = xor i8 %630, %628
  store i8 %631, ptr %91, align 1, !tbaa !5
  %632 = getelementptr inbounds i8, ptr %0, i64 64
  %633 = load i8, ptr %629, align 1, !tbaa !5
  %634 = xor i8 %633, %571
  store i8 %634, ptr %97, align 1, !tbaa !5
  %635 = zext i8 %575 to i64
  %636 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %635
  %637 = load i8, ptr %636, align 1, !tbaa !5
  %638 = zext i8 %579 to i64
  %639 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %638
  %640 = load i8, ptr %639, align 1, !tbaa !5
  %641 = zext i8 %583 to i64
  %642 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %641
  %643 = load i8, ptr %642, align 1, !tbaa !5
  %644 = zext i8 %587 to i64
  %645 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %644
  %646 = load i8, ptr %645, align 1, !tbaa !5
  %647 = zext i8 %591 to i64
  %648 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %647
  %649 = load i8, ptr %648, align 1, !tbaa !5
  %650 = zext i8 %595 to i64
  %651 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %650
  %652 = load i8, ptr %651, align 1, !tbaa !5
  %653 = zext i8 %599 to i64
  %654 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %653
  %655 = load i8, ptr %654, align 1, !tbaa !5
  %656 = zext i8 %603 to i64
  %657 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %656
  %658 = load i8, ptr %657, align 1, !tbaa !5
  %659 = zext i8 %607 to i64
  %660 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %659
  %661 = load i8, ptr %660, align 1, !tbaa !5
  %662 = zext i8 %611 to i64
  %663 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %662
  %664 = load i8, ptr %663, align 1, !tbaa !5
  %665 = zext i8 %615 to i64
  %666 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %665
  %667 = load i8, ptr %666, align 1, !tbaa !5
  %668 = zext i8 %619 to i64
  %669 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %668
  %670 = load i8, ptr %669, align 1, !tbaa !5
  %671 = zext i8 %623 to i64
  %672 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %671
  %673 = load i8, ptr %672, align 1, !tbaa !5
  %674 = zext i8 %627 to i64
  %675 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %674
  %676 = load i8, ptr %675, align 1, !tbaa !5
  %677 = zext i8 %631 to i64
  %678 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %677
  %679 = load i8, ptr %678, align 1, !tbaa !5
  %680 = zext i8 %634 to i64
  %681 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %680
  %682 = load i8, ptr %681, align 1, !tbaa !5
  %683 = xor i8 %652, %637
  %684 = xor i8 %667, %683
  %685 = xor i8 %682, %684
  %686 = tail call zeroext i8 @mul2(i8 noundef zeroext %683)
  %687 = xor i8 %686, %637
  %688 = xor i8 %687, %685
  store i8 %688, ptr %2, align 1, !tbaa !5
  %689 = xor i8 %667, %652
  %690 = tail call zeroext i8 @mul2(i8 noundef zeroext %689)
  %691 = xor i8 %652, %690
  %692 = xor i8 %691, %685
  store i8 %692, ptr %13, align 1, !tbaa !5
  %693 = xor i8 %682, %667
  %694 = tail call zeroext i8 @mul2(i8 noundef zeroext %693)
  %695 = xor i8 %683, %694
  %696 = xor i8 %695, %682
  store i8 %696, ptr %19, align 1, !tbaa !5
  %697 = xor i8 %682, %637
  %698 = tail call zeroext i8 @mul2(i8 noundef zeroext %697)
  %699 = xor i8 %698, %684
  store i8 %699, ptr %25, align 1, !tbaa !5
  %700 = xor i8 %664, %649
  %701 = xor i8 %679, %700
  %702 = xor i8 %701, %646
  %703 = tail call zeroext i8 @mul2(i8 noundef zeroext %700)
  %704 = xor i8 %649, %703
  %705 = xor i8 %704, %702
  store i8 %705, ptr %31, align 1, !tbaa !5
  %706 = xor i8 %679, %664
  %707 = tail call zeroext i8 @mul2(i8 noundef zeroext %706)
  %708 = xor i8 %664, %707
  %709 = xor i8 %708, %702
  store i8 %709, ptr %37, align 1, !tbaa !5
  %710 = xor i8 %679, %646
  %711 = tail call zeroext i8 @mul2(i8 noundef zeroext %710)
  %712 = xor i8 %646, %711
  %713 = xor i8 %712, %700
  store i8 %713, ptr %43, align 1, !tbaa !5
  %714 = xor i8 %649, %646
  %715 = tail call zeroext i8 @mul2(i8 noundef zeroext %714)
  %716 = xor i8 %715, %701
  store i8 %716, ptr %49, align 1, !tbaa !5
  %717 = xor i8 %676, %661
  %718 = xor i8 %717, %643
  %719 = xor i8 %718, %658
  %720 = tail call zeroext i8 @mul2(i8 noundef zeroext %717)
  %721 = xor i8 %661, %720
  %722 = xor i8 %721, %719
  store i8 %722, ptr %55, align 1, !tbaa !5
  %723 = xor i8 %676, %643
  %724 = tail call zeroext i8 @mul2(i8 noundef zeroext %723)
  %725 = xor i8 %676, %724
  %726 = xor i8 %725, %719
  store i8 %726, ptr %61, align 1, !tbaa !5
  %727 = xor i8 %658, %643
  %728 = tail call zeroext i8 @mul2(i8 noundef zeroext %727)
  %729 = xor i8 %658, %728
  %730 = xor i8 %729, %717
  store i8 %730, ptr %67, align 1, !tbaa !5
  %731 = xor i8 %661, %658
  %732 = tail call zeroext i8 @mul2(i8 noundef zeroext %731)
  %733 = xor i8 %732, %718
  store i8 %733, ptr %73, align 1, !tbaa !5
  %734 = xor i8 %673, %640
  %735 = xor i8 %734, %655
  %736 = xor i8 %735, %670
  %737 = tail call zeroext i8 @mul2(i8 noundef zeroext %734)
  %738 = xor i8 %673, %737
  %739 = xor i8 %738, %736
  store i8 %739, ptr %79, align 1, !tbaa !5
  %740 = xor i8 %655, %640
  %741 = tail call zeroext i8 @mul2(i8 noundef zeroext %740)
  %742 = xor i8 %640, %741
  %743 = xor i8 %742, %736
  store i8 %743, ptr %85, align 1, !tbaa !5
  %744 = xor i8 %670, %655
  %745 = tail call zeroext i8 @mul2(i8 noundef zeroext %744)
  %746 = xor i8 %670, %745
  %747 = xor i8 %746, %734
  store i8 %747, ptr %91, align 1, !tbaa !5
  %748 = xor i8 %673, %670
  %749 = tail call zeroext i8 @mul2(i8 noundef zeroext %748)
  %750 = xor i8 %749, %735
  store i8 %750, ptr %97, align 1, !tbaa !5
  %751 = load i8, ptr %2, align 1, !tbaa !5
  %752 = getelementptr inbounds i8, ptr %0, i64 65
  %753 = load i8, ptr %632, align 1, !tbaa !5
  %754 = xor i8 %753, %751
  store i8 %754, ptr %2, align 1, !tbaa !5
  %755 = load i8, ptr %13, align 1, !tbaa !5
  %756 = getelementptr inbounds i8, ptr %0, i64 66
  %757 = load i8, ptr %752, align 1, !tbaa !5
  %758 = xor i8 %757, %755
  store i8 %758, ptr %13, align 1, !tbaa !5
  %759 = load i8, ptr %19, align 1, !tbaa !5
  %760 = getelementptr inbounds i8, ptr %0, i64 67
  %761 = load i8, ptr %756, align 1, !tbaa !5
  %762 = xor i8 %761, %759
  store i8 %762, ptr %19, align 1, !tbaa !5
  %763 = load i8, ptr %25, align 1, !tbaa !5
  %764 = getelementptr inbounds i8, ptr %0, i64 68
  %765 = load i8, ptr %760, align 1, !tbaa !5
  %766 = xor i8 %765, %763
  store i8 %766, ptr %25, align 1, !tbaa !5
  %767 = load i8, ptr %31, align 1, !tbaa !5
  %768 = getelementptr inbounds i8, ptr %0, i64 69
  %769 = load i8, ptr %764, align 1, !tbaa !5
  %770 = xor i8 %769, %767
  store i8 %770, ptr %31, align 1, !tbaa !5
  %771 = load i8, ptr %37, align 1, !tbaa !5
  %772 = getelementptr inbounds i8, ptr %0, i64 70
  %773 = load i8, ptr %768, align 1, !tbaa !5
  %774 = xor i8 %773, %771
  store i8 %774, ptr %37, align 1, !tbaa !5
  %775 = load i8, ptr %43, align 1, !tbaa !5
  %776 = getelementptr inbounds i8, ptr %0, i64 71
  %777 = load i8, ptr %772, align 1, !tbaa !5
  %778 = xor i8 %777, %775
  store i8 %778, ptr %43, align 1, !tbaa !5
  %779 = load i8, ptr %49, align 1, !tbaa !5
  %780 = getelementptr inbounds i8, ptr %0, i64 72
  %781 = load i8, ptr %776, align 1, !tbaa !5
  %782 = xor i8 %781, %779
  store i8 %782, ptr %49, align 1, !tbaa !5
  %783 = load i8, ptr %55, align 1, !tbaa !5
  %784 = getelementptr inbounds i8, ptr %0, i64 73
  %785 = load i8, ptr %780, align 1, !tbaa !5
  %786 = xor i8 %785, %783
  store i8 %786, ptr %55, align 1, !tbaa !5
  %787 = load i8, ptr %61, align 1, !tbaa !5
  %788 = getelementptr inbounds i8, ptr %0, i64 74
  %789 = load i8, ptr %784, align 1, !tbaa !5
  %790 = xor i8 %789, %787
  store i8 %790, ptr %61, align 1, !tbaa !5
  %791 = load i8, ptr %67, align 1, !tbaa !5
  %792 = getelementptr inbounds i8, ptr %0, i64 75
  %793 = load i8, ptr %788, align 1, !tbaa !5
  %794 = xor i8 %793, %791
  store i8 %794, ptr %67, align 1, !tbaa !5
  %795 = load i8, ptr %73, align 1, !tbaa !5
  %796 = getelementptr inbounds i8, ptr %0, i64 76
  %797 = load i8, ptr %792, align 1, !tbaa !5
  %798 = xor i8 %797, %795
  store i8 %798, ptr %73, align 1, !tbaa !5
  %799 = load i8, ptr %79, align 1, !tbaa !5
  %800 = getelementptr inbounds i8, ptr %0, i64 77
  %801 = load i8, ptr %796, align 1, !tbaa !5
  %802 = xor i8 %801, %799
  store i8 %802, ptr %79, align 1, !tbaa !5
  %803 = load i8, ptr %85, align 1, !tbaa !5
  %804 = getelementptr inbounds i8, ptr %0, i64 78
  %805 = load i8, ptr %800, align 1, !tbaa !5
  %806 = xor i8 %805, %803
  store i8 %806, ptr %85, align 1, !tbaa !5
  %807 = load i8, ptr %91, align 1, !tbaa !5
  %808 = getelementptr inbounds i8, ptr %0, i64 79
  %809 = load i8, ptr %804, align 1, !tbaa !5
  %810 = xor i8 %809, %807
  store i8 %810, ptr %91, align 1, !tbaa !5
  %811 = getelementptr inbounds i8, ptr %0, i64 80
  %812 = load i8, ptr %808, align 1, !tbaa !5
  %813 = xor i8 %812, %750
  store i8 %813, ptr %97, align 1, !tbaa !5
  %814 = zext i8 %754 to i64
  %815 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %814
  %816 = load i8, ptr %815, align 1, !tbaa !5
  %817 = zext i8 %758 to i64
  %818 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %817
  %819 = load i8, ptr %818, align 1, !tbaa !5
  %820 = zext i8 %762 to i64
  %821 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %820
  %822 = load i8, ptr %821, align 1, !tbaa !5
  %823 = zext i8 %766 to i64
  %824 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %823
  %825 = load i8, ptr %824, align 1, !tbaa !5
  %826 = zext i8 %770 to i64
  %827 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %826
  %828 = load i8, ptr %827, align 1, !tbaa !5
  %829 = zext i8 %774 to i64
  %830 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %829
  %831 = load i8, ptr %830, align 1, !tbaa !5
  %832 = zext i8 %778 to i64
  %833 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %832
  %834 = load i8, ptr %833, align 1, !tbaa !5
  %835 = zext i8 %782 to i64
  %836 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %835
  %837 = load i8, ptr %836, align 1, !tbaa !5
  %838 = zext i8 %786 to i64
  %839 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %838
  %840 = load i8, ptr %839, align 1, !tbaa !5
  %841 = zext i8 %790 to i64
  %842 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %841
  %843 = load i8, ptr %842, align 1, !tbaa !5
  %844 = zext i8 %794 to i64
  %845 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %844
  %846 = load i8, ptr %845, align 1, !tbaa !5
  %847 = zext i8 %798 to i64
  %848 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %847
  %849 = load i8, ptr %848, align 1, !tbaa !5
  %850 = zext i8 %802 to i64
  %851 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %850
  %852 = load i8, ptr %851, align 1, !tbaa !5
  %853 = zext i8 %806 to i64
  %854 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %853
  %855 = load i8, ptr %854, align 1, !tbaa !5
  %856 = zext i8 %810 to i64
  %857 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %856
  %858 = load i8, ptr %857, align 1, !tbaa !5
  %859 = zext i8 %813 to i64
  %860 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %859
  %861 = load i8, ptr %860, align 1, !tbaa !5
  %862 = xor i8 %831, %816
  %863 = xor i8 %846, %862
  %864 = xor i8 %861, %863
  %865 = tail call zeroext i8 @mul2(i8 noundef zeroext %862)
  %866 = xor i8 %865, %816
  %867 = xor i8 %866, %864
  store i8 %867, ptr %2, align 1, !tbaa !5
  %868 = xor i8 %846, %831
  %869 = tail call zeroext i8 @mul2(i8 noundef zeroext %868)
  %870 = xor i8 %831, %869
  %871 = xor i8 %870, %864
  store i8 %871, ptr %13, align 1, !tbaa !5
  %872 = xor i8 %861, %846
  %873 = tail call zeroext i8 @mul2(i8 noundef zeroext %872)
  %874 = xor i8 %862, %873
  %875 = xor i8 %874, %861
  store i8 %875, ptr %19, align 1, !tbaa !5
  %876 = xor i8 %861, %816
  %877 = tail call zeroext i8 @mul2(i8 noundef zeroext %876)
  %878 = xor i8 %877, %863
  store i8 %878, ptr %25, align 1, !tbaa !5
  %879 = xor i8 %843, %828
  %880 = xor i8 %858, %879
  %881 = xor i8 %880, %825
  %882 = tail call zeroext i8 @mul2(i8 noundef zeroext %879)
  %883 = xor i8 %828, %882
  %884 = xor i8 %883, %881
  store i8 %884, ptr %31, align 1, !tbaa !5
  %885 = xor i8 %858, %843
  %886 = tail call zeroext i8 @mul2(i8 noundef zeroext %885)
  %887 = xor i8 %843, %886
  %888 = xor i8 %887, %881
  store i8 %888, ptr %37, align 1, !tbaa !5
  %889 = xor i8 %858, %825
  %890 = tail call zeroext i8 @mul2(i8 noundef zeroext %889)
  %891 = xor i8 %825, %890
  %892 = xor i8 %891, %879
  store i8 %892, ptr %43, align 1, !tbaa !5
  %893 = xor i8 %828, %825
  %894 = tail call zeroext i8 @mul2(i8 noundef zeroext %893)
  %895 = xor i8 %894, %880
  store i8 %895, ptr %49, align 1, !tbaa !5
  %896 = xor i8 %855, %840
  %897 = xor i8 %896, %822
  %898 = xor i8 %897, %837
  %899 = tail call zeroext i8 @mul2(i8 noundef zeroext %896)
  %900 = xor i8 %840, %899
  %901 = xor i8 %900, %898
  store i8 %901, ptr %55, align 1, !tbaa !5
  %902 = xor i8 %855, %822
  %903 = tail call zeroext i8 @mul2(i8 noundef zeroext %902)
  %904 = xor i8 %855, %903
  %905 = xor i8 %904, %898
  store i8 %905, ptr %61, align 1, !tbaa !5
  %906 = xor i8 %837, %822
  %907 = tail call zeroext i8 @mul2(i8 noundef zeroext %906)
  %908 = xor i8 %837, %907
  %909 = xor i8 %908, %896
  store i8 %909, ptr %67, align 1, !tbaa !5
  %910 = xor i8 %840, %837
  %911 = tail call zeroext i8 @mul2(i8 noundef zeroext %910)
  %912 = xor i8 %911, %897
  store i8 %912, ptr %73, align 1, !tbaa !5
  %913 = xor i8 %852, %819
  %914 = xor i8 %913, %834
  %915 = xor i8 %914, %849
  %916 = tail call zeroext i8 @mul2(i8 noundef zeroext %913)
  %917 = xor i8 %852, %916
  %918 = xor i8 %917, %915
  store i8 %918, ptr %79, align 1, !tbaa !5
  %919 = xor i8 %834, %819
  %920 = tail call zeroext i8 @mul2(i8 noundef zeroext %919)
  %921 = xor i8 %819, %920
  %922 = xor i8 %921, %915
  store i8 %922, ptr %85, align 1, !tbaa !5
  %923 = xor i8 %849, %834
  %924 = tail call zeroext i8 @mul2(i8 noundef zeroext %923)
  %925 = xor i8 %849, %924
  %926 = xor i8 %925, %913
  store i8 %926, ptr %91, align 1, !tbaa !5
  %927 = xor i8 %852, %849
  %928 = tail call zeroext i8 @mul2(i8 noundef zeroext %927)
  %929 = xor i8 %928, %914
  store i8 %929, ptr %97, align 1, !tbaa !5
  %930 = load i8, ptr %2, align 1, !tbaa !5
  %931 = getelementptr inbounds i8, ptr %0, i64 81
  %932 = load i8, ptr %811, align 1, !tbaa !5
  %933 = xor i8 %932, %930
  store i8 %933, ptr %2, align 1, !tbaa !5
  %934 = load i8, ptr %13, align 1, !tbaa !5
  %935 = getelementptr inbounds i8, ptr %0, i64 82
  %936 = load i8, ptr %931, align 1, !tbaa !5
  %937 = xor i8 %936, %934
  store i8 %937, ptr %13, align 1, !tbaa !5
  %938 = load i8, ptr %19, align 1, !tbaa !5
  %939 = getelementptr inbounds i8, ptr %0, i64 83
  %940 = load i8, ptr %935, align 1, !tbaa !5
  %941 = xor i8 %940, %938
  store i8 %941, ptr %19, align 1, !tbaa !5
  %942 = load i8, ptr %25, align 1, !tbaa !5
  %943 = getelementptr inbounds i8, ptr %0, i64 84
  %944 = load i8, ptr %939, align 1, !tbaa !5
  %945 = xor i8 %944, %942
  store i8 %945, ptr %25, align 1, !tbaa !5
  %946 = load i8, ptr %31, align 1, !tbaa !5
  %947 = getelementptr inbounds i8, ptr %0, i64 85
  %948 = load i8, ptr %943, align 1, !tbaa !5
  %949 = xor i8 %948, %946
  store i8 %949, ptr %31, align 1, !tbaa !5
  %950 = load i8, ptr %37, align 1, !tbaa !5
  %951 = getelementptr inbounds i8, ptr %0, i64 86
  %952 = load i8, ptr %947, align 1, !tbaa !5
  %953 = xor i8 %952, %950
  store i8 %953, ptr %37, align 1, !tbaa !5
  %954 = load i8, ptr %43, align 1, !tbaa !5
  %955 = getelementptr inbounds i8, ptr %0, i64 87
  %956 = load i8, ptr %951, align 1, !tbaa !5
  %957 = xor i8 %956, %954
  store i8 %957, ptr %43, align 1, !tbaa !5
  %958 = load i8, ptr %49, align 1, !tbaa !5
  %959 = getelementptr inbounds i8, ptr %0, i64 88
  %960 = load i8, ptr %955, align 1, !tbaa !5
  %961 = xor i8 %960, %958
  store i8 %961, ptr %49, align 1, !tbaa !5
  %962 = load i8, ptr %55, align 1, !tbaa !5
  %963 = getelementptr inbounds i8, ptr %0, i64 89
  %964 = load i8, ptr %959, align 1, !tbaa !5
  %965 = xor i8 %964, %962
  store i8 %965, ptr %55, align 1, !tbaa !5
  %966 = load i8, ptr %61, align 1, !tbaa !5
  %967 = getelementptr inbounds i8, ptr %0, i64 90
  %968 = load i8, ptr %963, align 1, !tbaa !5
  %969 = xor i8 %968, %966
  store i8 %969, ptr %61, align 1, !tbaa !5
  %970 = load i8, ptr %67, align 1, !tbaa !5
  %971 = getelementptr inbounds i8, ptr %0, i64 91
  %972 = load i8, ptr %967, align 1, !tbaa !5
  %973 = xor i8 %972, %970
  store i8 %973, ptr %67, align 1, !tbaa !5
  %974 = load i8, ptr %73, align 1, !tbaa !5
  %975 = getelementptr inbounds i8, ptr %0, i64 92
  %976 = load i8, ptr %971, align 1, !tbaa !5
  %977 = xor i8 %976, %974
  store i8 %977, ptr %73, align 1, !tbaa !5
  %978 = load i8, ptr %79, align 1, !tbaa !5
  %979 = getelementptr inbounds i8, ptr %0, i64 93
  %980 = load i8, ptr %975, align 1, !tbaa !5
  %981 = xor i8 %980, %978
  store i8 %981, ptr %79, align 1, !tbaa !5
  %982 = load i8, ptr %85, align 1, !tbaa !5
  %983 = getelementptr inbounds i8, ptr %0, i64 94
  %984 = load i8, ptr %979, align 1, !tbaa !5
  %985 = xor i8 %984, %982
  store i8 %985, ptr %85, align 1, !tbaa !5
  %986 = load i8, ptr %91, align 1, !tbaa !5
  %987 = getelementptr inbounds i8, ptr %0, i64 95
  %988 = load i8, ptr %983, align 1, !tbaa !5
  %989 = xor i8 %988, %986
  store i8 %989, ptr %91, align 1, !tbaa !5
  %990 = getelementptr inbounds i8, ptr %0, i64 96
  %991 = load i8, ptr %987, align 1, !tbaa !5
  %992 = xor i8 %991, %929
  store i8 %992, ptr %97, align 1, !tbaa !5
  %993 = zext i8 %933 to i64
  %994 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %993
  %995 = load i8, ptr %994, align 1, !tbaa !5
  %996 = zext i8 %937 to i64
  %997 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %996
  %998 = load i8, ptr %997, align 1, !tbaa !5
  %999 = zext i8 %941 to i64
  %1000 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %999
  %1001 = load i8, ptr %1000, align 1, !tbaa !5
  %1002 = zext i8 %945 to i64
  %1003 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1002
  %1004 = load i8, ptr %1003, align 1, !tbaa !5
  %1005 = zext i8 %949 to i64
  %1006 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1005
  %1007 = load i8, ptr %1006, align 1, !tbaa !5
  %1008 = zext i8 %953 to i64
  %1009 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1008
  %1010 = load i8, ptr %1009, align 1, !tbaa !5
  %1011 = zext i8 %957 to i64
  %1012 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1011
  %1013 = load i8, ptr %1012, align 1, !tbaa !5
  %1014 = zext i8 %961 to i64
  %1015 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1014
  %1016 = load i8, ptr %1015, align 1, !tbaa !5
  %1017 = zext i8 %965 to i64
  %1018 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1017
  %1019 = load i8, ptr %1018, align 1, !tbaa !5
  %1020 = zext i8 %969 to i64
  %1021 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1020
  %1022 = load i8, ptr %1021, align 1, !tbaa !5
  %1023 = zext i8 %973 to i64
  %1024 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1023
  %1025 = load i8, ptr %1024, align 1, !tbaa !5
  %1026 = zext i8 %977 to i64
  %1027 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1026
  %1028 = load i8, ptr %1027, align 1, !tbaa !5
  %1029 = zext i8 %981 to i64
  %1030 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1029
  %1031 = load i8, ptr %1030, align 1, !tbaa !5
  %1032 = zext i8 %985 to i64
  %1033 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1032
  %1034 = load i8, ptr %1033, align 1, !tbaa !5
  %1035 = zext i8 %989 to i64
  %1036 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1035
  %1037 = load i8, ptr %1036, align 1, !tbaa !5
  %1038 = zext i8 %992 to i64
  %1039 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1038
  %1040 = load i8, ptr %1039, align 1, !tbaa !5
  %1041 = xor i8 %1010, %995
  %1042 = xor i8 %1025, %1041
  %1043 = xor i8 %1040, %1042
  %1044 = tail call zeroext i8 @mul2(i8 noundef zeroext %1041)
  %1045 = xor i8 %1044, %995
  %1046 = xor i8 %1045, %1043
  store i8 %1046, ptr %2, align 1, !tbaa !5
  %1047 = xor i8 %1025, %1010
  %1048 = tail call zeroext i8 @mul2(i8 noundef zeroext %1047)
  %1049 = xor i8 %1010, %1048
  %1050 = xor i8 %1049, %1043
  store i8 %1050, ptr %13, align 1, !tbaa !5
  %1051 = xor i8 %1040, %1025
  %1052 = tail call zeroext i8 @mul2(i8 noundef zeroext %1051)
  %1053 = xor i8 %1041, %1052
  %1054 = xor i8 %1053, %1040
  store i8 %1054, ptr %19, align 1, !tbaa !5
  %1055 = xor i8 %1040, %995
  %1056 = tail call zeroext i8 @mul2(i8 noundef zeroext %1055)
  %1057 = xor i8 %1056, %1042
  store i8 %1057, ptr %25, align 1, !tbaa !5
  %1058 = xor i8 %1022, %1007
  %1059 = xor i8 %1037, %1058
  %1060 = xor i8 %1059, %1004
  %1061 = tail call zeroext i8 @mul2(i8 noundef zeroext %1058)
  %1062 = xor i8 %1007, %1061
  %1063 = xor i8 %1062, %1060
  store i8 %1063, ptr %31, align 1, !tbaa !5
  %1064 = xor i8 %1037, %1022
  %1065 = tail call zeroext i8 @mul2(i8 noundef zeroext %1064)
  %1066 = xor i8 %1022, %1065
  %1067 = xor i8 %1066, %1060
  store i8 %1067, ptr %37, align 1, !tbaa !5
  %1068 = xor i8 %1037, %1004
  %1069 = tail call zeroext i8 @mul2(i8 noundef zeroext %1068)
  %1070 = xor i8 %1004, %1069
  %1071 = xor i8 %1070, %1058
  store i8 %1071, ptr %43, align 1, !tbaa !5
  %1072 = xor i8 %1007, %1004
  %1073 = tail call zeroext i8 @mul2(i8 noundef zeroext %1072)
  %1074 = xor i8 %1073, %1059
  store i8 %1074, ptr %49, align 1, !tbaa !5
  %1075 = xor i8 %1034, %1019
  %1076 = xor i8 %1075, %1001
  %1077 = xor i8 %1076, %1016
  %1078 = tail call zeroext i8 @mul2(i8 noundef zeroext %1075)
  %1079 = xor i8 %1019, %1078
  %1080 = xor i8 %1079, %1077
  store i8 %1080, ptr %55, align 1, !tbaa !5
  %1081 = xor i8 %1034, %1001
  %1082 = tail call zeroext i8 @mul2(i8 noundef zeroext %1081)
  %1083 = xor i8 %1034, %1082
  %1084 = xor i8 %1083, %1077
  store i8 %1084, ptr %61, align 1, !tbaa !5
  %1085 = xor i8 %1016, %1001
  %1086 = tail call zeroext i8 @mul2(i8 noundef zeroext %1085)
  %1087 = xor i8 %1016, %1086
  %1088 = xor i8 %1087, %1075
  store i8 %1088, ptr %67, align 1, !tbaa !5
  %1089 = xor i8 %1019, %1016
  %1090 = tail call zeroext i8 @mul2(i8 noundef zeroext %1089)
  %1091 = xor i8 %1090, %1076
  store i8 %1091, ptr %73, align 1, !tbaa !5
  %1092 = xor i8 %1031, %998
  %1093 = xor i8 %1092, %1013
  %1094 = xor i8 %1093, %1028
  %1095 = tail call zeroext i8 @mul2(i8 noundef zeroext %1092)
  %1096 = xor i8 %1031, %1095
  %1097 = xor i8 %1096, %1094
  store i8 %1097, ptr %79, align 1, !tbaa !5
  %1098 = xor i8 %1013, %998
  %1099 = tail call zeroext i8 @mul2(i8 noundef zeroext %1098)
  %1100 = xor i8 %998, %1099
  %1101 = xor i8 %1100, %1094
  store i8 %1101, ptr %85, align 1, !tbaa !5
  %1102 = xor i8 %1028, %1013
  %1103 = tail call zeroext i8 @mul2(i8 noundef zeroext %1102)
  %1104 = xor i8 %1028, %1103
  %1105 = xor i8 %1104, %1092
  store i8 %1105, ptr %91, align 1, !tbaa !5
  %1106 = xor i8 %1031, %1028
  %1107 = tail call zeroext i8 @mul2(i8 noundef zeroext %1106)
  %1108 = xor i8 %1107, %1093
  store i8 %1108, ptr %97, align 1, !tbaa !5
  %1109 = load i8, ptr %2, align 1, !tbaa !5
  %1110 = getelementptr inbounds i8, ptr %0, i64 97
  %1111 = load i8, ptr %990, align 1, !tbaa !5
  %1112 = xor i8 %1111, %1109
  store i8 %1112, ptr %2, align 1, !tbaa !5
  %1113 = load i8, ptr %13, align 1, !tbaa !5
  %1114 = getelementptr inbounds i8, ptr %0, i64 98
  %1115 = load i8, ptr %1110, align 1, !tbaa !5
  %1116 = xor i8 %1115, %1113
  store i8 %1116, ptr %13, align 1, !tbaa !5
  %1117 = load i8, ptr %19, align 1, !tbaa !5
  %1118 = getelementptr inbounds i8, ptr %0, i64 99
  %1119 = load i8, ptr %1114, align 1, !tbaa !5
  %1120 = xor i8 %1119, %1117
  store i8 %1120, ptr %19, align 1, !tbaa !5
  %1121 = load i8, ptr %25, align 1, !tbaa !5
  %1122 = getelementptr inbounds i8, ptr %0, i64 100
  %1123 = load i8, ptr %1118, align 1, !tbaa !5
  %1124 = xor i8 %1123, %1121
  store i8 %1124, ptr %25, align 1, !tbaa !5
  %1125 = load i8, ptr %31, align 1, !tbaa !5
  %1126 = getelementptr inbounds i8, ptr %0, i64 101
  %1127 = load i8, ptr %1122, align 1, !tbaa !5
  %1128 = xor i8 %1127, %1125
  store i8 %1128, ptr %31, align 1, !tbaa !5
  %1129 = load i8, ptr %37, align 1, !tbaa !5
  %1130 = getelementptr inbounds i8, ptr %0, i64 102
  %1131 = load i8, ptr %1126, align 1, !tbaa !5
  %1132 = xor i8 %1131, %1129
  store i8 %1132, ptr %37, align 1, !tbaa !5
  %1133 = load i8, ptr %43, align 1, !tbaa !5
  %1134 = getelementptr inbounds i8, ptr %0, i64 103
  %1135 = load i8, ptr %1130, align 1, !tbaa !5
  %1136 = xor i8 %1135, %1133
  store i8 %1136, ptr %43, align 1, !tbaa !5
  %1137 = load i8, ptr %49, align 1, !tbaa !5
  %1138 = getelementptr inbounds i8, ptr %0, i64 104
  %1139 = load i8, ptr %1134, align 1, !tbaa !5
  %1140 = xor i8 %1139, %1137
  store i8 %1140, ptr %49, align 1, !tbaa !5
  %1141 = load i8, ptr %55, align 1, !tbaa !5
  %1142 = getelementptr inbounds i8, ptr %0, i64 105
  %1143 = load i8, ptr %1138, align 1, !tbaa !5
  %1144 = xor i8 %1143, %1141
  store i8 %1144, ptr %55, align 1, !tbaa !5
  %1145 = load i8, ptr %61, align 1, !tbaa !5
  %1146 = getelementptr inbounds i8, ptr %0, i64 106
  %1147 = load i8, ptr %1142, align 1, !tbaa !5
  %1148 = xor i8 %1147, %1145
  store i8 %1148, ptr %61, align 1, !tbaa !5
  %1149 = load i8, ptr %67, align 1, !tbaa !5
  %1150 = getelementptr inbounds i8, ptr %0, i64 107
  %1151 = load i8, ptr %1146, align 1, !tbaa !5
  %1152 = xor i8 %1151, %1149
  store i8 %1152, ptr %67, align 1, !tbaa !5
  %1153 = load i8, ptr %73, align 1, !tbaa !5
  %1154 = getelementptr inbounds i8, ptr %0, i64 108
  %1155 = load i8, ptr %1150, align 1, !tbaa !5
  %1156 = xor i8 %1155, %1153
  store i8 %1156, ptr %73, align 1, !tbaa !5
  %1157 = load i8, ptr %79, align 1, !tbaa !5
  %1158 = getelementptr inbounds i8, ptr %0, i64 109
  %1159 = load i8, ptr %1154, align 1, !tbaa !5
  %1160 = xor i8 %1159, %1157
  store i8 %1160, ptr %79, align 1, !tbaa !5
  %1161 = load i8, ptr %85, align 1, !tbaa !5
  %1162 = getelementptr inbounds i8, ptr %0, i64 110
  %1163 = load i8, ptr %1158, align 1, !tbaa !5
  %1164 = xor i8 %1163, %1161
  store i8 %1164, ptr %85, align 1, !tbaa !5
  %1165 = load i8, ptr %91, align 1, !tbaa !5
  %1166 = getelementptr inbounds i8, ptr %0, i64 111
  %1167 = load i8, ptr %1162, align 1, !tbaa !5
  %1168 = xor i8 %1167, %1165
  store i8 %1168, ptr %91, align 1, !tbaa !5
  %1169 = getelementptr inbounds i8, ptr %0, i64 112
  %1170 = load i8, ptr %1166, align 1, !tbaa !5
  %1171 = xor i8 %1170, %1108
  store i8 %1171, ptr %97, align 1, !tbaa !5
  %1172 = zext i8 %1112 to i64
  %1173 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1172
  %1174 = load i8, ptr %1173, align 1, !tbaa !5
  %1175 = zext i8 %1116 to i64
  %1176 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1175
  %1177 = load i8, ptr %1176, align 1, !tbaa !5
  %1178 = zext i8 %1120 to i64
  %1179 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1178
  %1180 = load i8, ptr %1179, align 1, !tbaa !5
  %1181 = zext i8 %1124 to i64
  %1182 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1181
  %1183 = load i8, ptr %1182, align 1, !tbaa !5
  %1184 = zext i8 %1128 to i64
  %1185 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1184
  %1186 = load i8, ptr %1185, align 1, !tbaa !5
  %1187 = zext i8 %1132 to i64
  %1188 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1187
  %1189 = load i8, ptr %1188, align 1, !tbaa !5
  %1190 = zext i8 %1136 to i64
  %1191 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1190
  %1192 = load i8, ptr %1191, align 1, !tbaa !5
  %1193 = zext i8 %1140 to i64
  %1194 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1193
  %1195 = load i8, ptr %1194, align 1, !tbaa !5
  %1196 = zext i8 %1144 to i64
  %1197 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1196
  %1198 = load i8, ptr %1197, align 1, !tbaa !5
  %1199 = zext i8 %1148 to i64
  %1200 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1199
  %1201 = load i8, ptr %1200, align 1, !tbaa !5
  %1202 = zext i8 %1152 to i64
  %1203 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1202
  %1204 = load i8, ptr %1203, align 1, !tbaa !5
  %1205 = zext i8 %1156 to i64
  %1206 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1205
  %1207 = load i8, ptr %1206, align 1, !tbaa !5
  %1208 = zext i8 %1160 to i64
  %1209 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1208
  %1210 = load i8, ptr %1209, align 1, !tbaa !5
  %1211 = zext i8 %1164 to i64
  %1212 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1211
  %1213 = load i8, ptr %1212, align 1, !tbaa !5
  %1214 = zext i8 %1168 to i64
  %1215 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1214
  %1216 = load i8, ptr %1215, align 1, !tbaa !5
  %1217 = zext i8 %1171 to i64
  %1218 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1217
  %1219 = load i8, ptr %1218, align 1, !tbaa !5
  %1220 = xor i8 %1189, %1174
  %1221 = xor i8 %1204, %1220
  %1222 = xor i8 %1219, %1221
  %1223 = tail call zeroext i8 @mul2(i8 noundef zeroext %1220)
  %1224 = xor i8 %1223, %1174
  %1225 = xor i8 %1224, %1222
  store i8 %1225, ptr %2, align 1, !tbaa !5
  %1226 = xor i8 %1204, %1189
  %1227 = tail call zeroext i8 @mul2(i8 noundef zeroext %1226)
  %1228 = xor i8 %1189, %1227
  %1229 = xor i8 %1228, %1222
  store i8 %1229, ptr %13, align 1, !tbaa !5
  %1230 = xor i8 %1219, %1204
  %1231 = tail call zeroext i8 @mul2(i8 noundef zeroext %1230)
  %1232 = xor i8 %1220, %1231
  %1233 = xor i8 %1232, %1219
  store i8 %1233, ptr %19, align 1, !tbaa !5
  %1234 = xor i8 %1219, %1174
  %1235 = tail call zeroext i8 @mul2(i8 noundef zeroext %1234)
  %1236 = xor i8 %1235, %1221
  store i8 %1236, ptr %25, align 1, !tbaa !5
  %1237 = xor i8 %1201, %1186
  %1238 = xor i8 %1216, %1237
  %1239 = xor i8 %1238, %1183
  %1240 = tail call zeroext i8 @mul2(i8 noundef zeroext %1237)
  %1241 = xor i8 %1186, %1240
  %1242 = xor i8 %1241, %1239
  store i8 %1242, ptr %31, align 1, !tbaa !5
  %1243 = xor i8 %1216, %1201
  %1244 = tail call zeroext i8 @mul2(i8 noundef zeroext %1243)
  %1245 = xor i8 %1201, %1244
  %1246 = xor i8 %1245, %1239
  store i8 %1246, ptr %37, align 1, !tbaa !5
  %1247 = xor i8 %1216, %1183
  %1248 = tail call zeroext i8 @mul2(i8 noundef zeroext %1247)
  %1249 = xor i8 %1183, %1248
  %1250 = xor i8 %1249, %1237
  store i8 %1250, ptr %43, align 1, !tbaa !5
  %1251 = xor i8 %1186, %1183
  %1252 = tail call zeroext i8 @mul2(i8 noundef zeroext %1251)
  %1253 = xor i8 %1252, %1238
  store i8 %1253, ptr %49, align 1, !tbaa !5
  %1254 = xor i8 %1213, %1198
  %1255 = xor i8 %1254, %1180
  %1256 = xor i8 %1255, %1195
  %1257 = tail call zeroext i8 @mul2(i8 noundef zeroext %1254)
  %1258 = xor i8 %1198, %1257
  %1259 = xor i8 %1258, %1256
  store i8 %1259, ptr %55, align 1, !tbaa !5
  %1260 = xor i8 %1213, %1180
  %1261 = tail call zeroext i8 @mul2(i8 noundef zeroext %1260)
  %1262 = xor i8 %1213, %1261
  %1263 = xor i8 %1262, %1256
  store i8 %1263, ptr %61, align 1, !tbaa !5
  %1264 = xor i8 %1195, %1180
  %1265 = tail call zeroext i8 @mul2(i8 noundef zeroext %1264)
  %1266 = xor i8 %1195, %1265
  %1267 = xor i8 %1266, %1254
  store i8 %1267, ptr %67, align 1, !tbaa !5
  %1268 = xor i8 %1198, %1195
  %1269 = tail call zeroext i8 @mul2(i8 noundef zeroext %1268)
  %1270 = xor i8 %1269, %1255
  store i8 %1270, ptr %73, align 1, !tbaa !5
  %1271 = xor i8 %1210, %1177
  %1272 = xor i8 %1271, %1192
  %1273 = xor i8 %1272, %1207
  %1274 = tail call zeroext i8 @mul2(i8 noundef zeroext %1271)
  %1275 = xor i8 %1210, %1274
  %1276 = xor i8 %1275, %1273
  store i8 %1276, ptr %79, align 1, !tbaa !5
  %1277 = xor i8 %1192, %1177
  %1278 = tail call zeroext i8 @mul2(i8 noundef zeroext %1277)
  %1279 = xor i8 %1177, %1278
  %1280 = xor i8 %1279, %1273
  store i8 %1280, ptr %85, align 1, !tbaa !5
  %1281 = xor i8 %1207, %1192
  %1282 = tail call zeroext i8 @mul2(i8 noundef zeroext %1281)
  %1283 = xor i8 %1207, %1282
  %1284 = xor i8 %1283, %1271
  store i8 %1284, ptr %91, align 1, !tbaa !5
  %1285 = xor i8 %1210, %1207
  %1286 = tail call zeroext i8 @mul2(i8 noundef zeroext %1285)
  %1287 = xor i8 %1286, %1272
  store i8 %1287, ptr %97, align 1, !tbaa !5
  %1288 = load i8, ptr %2, align 1, !tbaa !5
  %1289 = getelementptr inbounds i8, ptr %0, i64 113
  %1290 = load i8, ptr %1169, align 1, !tbaa !5
  %1291 = xor i8 %1290, %1288
  store i8 %1291, ptr %2, align 1, !tbaa !5
  %1292 = load i8, ptr %13, align 1, !tbaa !5
  %1293 = getelementptr inbounds i8, ptr %0, i64 114
  %1294 = load i8, ptr %1289, align 1, !tbaa !5
  %1295 = xor i8 %1294, %1292
  store i8 %1295, ptr %13, align 1, !tbaa !5
  %1296 = load i8, ptr %19, align 1, !tbaa !5
  %1297 = getelementptr inbounds i8, ptr %0, i64 115
  %1298 = load i8, ptr %1293, align 1, !tbaa !5
  %1299 = xor i8 %1298, %1296
  store i8 %1299, ptr %19, align 1, !tbaa !5
  %1300 = load i8, ptr %25, align 1, !tbaa !5
  %1301 = getelementptr inbounds i8, ptr %0, i64 116
  %1302 = load i8, ptr %1297, align 1, !tbaa !5
  %1303 = xor i8 %1302, %1300
  store i8 %1303, ptr %25, align 1, !tbaa !5
  %1304 = load i8, ptr %31, align 1, !tbaa !5
  %1305 = getelementptr inbounds i8, ptr %0, i64 117
  %1306 = load i8, ptr %1301, align 1, !tbaa !5
  %1307 = xor i8 %1306, %1304
  store i8 %1307, ptr %31, align 1, !tbaa !5
  %1308 = load i8, ptr %37, align 1, !tbaa !5
  %1309 = getelementptr inbounds i8, ptr %0, i64 118
  %1310 = load i8, ptr %1305, align 1, !tbaa !5
  %1311 = xor i8 %1310, %1308
  store i8 %1311, ptr %37, align 1, !tbaa !5
  %1312 = load i8, ptr %43, align 1, !tbaa !5
  %1313 = getelementptr inbounds i8, ptr %0, i64 119
  %1314 = load i8, ptr %1309, align 1, !tbaa !5
  %1315 = xor i8 %1314, %1312
  store i8 %1315, ptr %43, align 1, !tbaa !5
  %1316 = load i8, ptr %49, align 1, !tbaa !5
  %1317 = getelementptr inbounds i8, ptr %0, i64 120
  %1318 = load i8, ptr %1313, align 1, !tbaa !5
  %1319 = xor i8 %1318, %1316
  store i8 %1319, ptr %49, align 1, !tbaa !5
  %1320 = load i8, ptr %55, align 1, !tbaa !5
  %1321 = getelementptr inbounds i8, ptr %0, i64 121
  %1322 = load i8, ptr %1317, align 1, !tbaa !5
  %1323 = xor i8 %1322, %1320
  store i8 %1323, ptr %55, align 1, !tbaa !5
  %1324 = load i8, ptr %61, align 1, !tbaa !5
  %1325 = getelementptr inbounds i8, ptr %0, i64 122
  %1326 = load i8, ptr %1321, align 1, !tbaa !5
  %1327 = xor i8 %1326, %1324
  store i8 %1327, ptr %61, align 1, !tbaa !5
  %1328 = load i8, ptr %67, align 1, !tbaa !5
  %1329 = getelementptr inbounds i8, ptr %0, i64 123
  %1330 = load i8, ptr %1325, align 1, !tbaa !5
  %1331 = xor i8 %1330, %1328
  store i8 %1331, ptr %67, align 1, !tbaa !5
  %1332 = load i8, ptr %73, align 1, !tbaa !5
  %1333 = getelementptr inbounds i8, ptr %0, i64 124
  %1334 = load i8, ptr %1329, align 1, !tbaa !5
  %1335 = xor i8 %1334, %1332
  store i8 %1335, ptr %73, align 1, !tbaa !5
  %1336 = load i8, ptr %79, align 1, !tbaa !5
  %1337 = getelementptr inbounds i8, ptr %0, i64 125
  %1338 = load i8, ptr %1333, align 1, !tbaa !5
  %1339 = xor i8 %1338, %1336
  store i8 %1339, ptr %79, align 1, !tbaa !5
  %1340 = load i8, ptr %85, align 1, !tbaa !5
  %1341 = getelementptr inbounds i8, ptr %0, i64 126
  %1342 = load i8, ptr %1337, align 1, !tbaa !5
  %1343 = xor i8 %1342, %1340
  store i8 %1343, ptr %85, align 1, !tbaa !5
  %1344 = load i8, ptr %91, align 1, !tbaa !5
  %1345 = getelementptr inbounds i8, ptr %0, i64 127
  %1346 = load i8, ptr %1341, align 1, !tbaa !5
  %1347 = xor i8 %1346, %1344
  store i8 %1347, ptr %91, align 1, !tbaa !5
  %1348 = getelementptr inbounds i8, ptr %0, i64 128
  %1349 = load i8, ptr %1345, align 1, !tbaa !5
  %1350 = xor i8 %1349, %1287
  store i8 %1350, ptr %97, align 1, !tbaa !5
  %1351 = zext i8 %1291 to i64
  %1352 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1351
  %1353 = load i8, ptr %1352, align 1, !tbaa !5
  %1354 = zext i8 %1295 to i64
  %1355 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1354
  %1356 = load i8, ptr %1355, align 1, !tbaa !5
  %1357 = zext i8 %1299 to i64
  %1358 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1357
  %1359 = load i8, ptr %1358, align 1, !tbaa !5
  %1360 = zext i8 %1303 to i64
  %1361 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1360
  %1362 = load i8, ptr %1361, align 1, !tbaa !5
  %1363 = zext i8 %1307 to i64
  %1364 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1363
  %1365 = load i8, ptr %1364, align 1, !tbaa !5
  %1366 = zext i8 %1311 to i64
  %1367 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1366
  %1368 = load i8, ptr %1367, align 1, !tbaa !5
  %1369 = zext i8 %1315 to i64
  %1370 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1369
  %1371 = load i8, ptr %1370, align 1, !tbaa !5
  %1372 = zext i8 %1319 to i64
  %1373 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1372
  %1374 = load i8, ptr %1373, align 1, !tbaa !5
  %1375 = zext i8 %1323 to i64
  %1376 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1375
  %1377 = load i8, ptr %1376, align 1, !tbaa !5
  %1378 = zext i8 %1327 to i64
  %1379 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1378
  %1380 = load i8, ptr %1379, align 1, !tbaa !5
  %1381 = zext i8 %1331 to i64
  %1382 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1381
  %1383 = load i8, ptr %1382, align 1, !tbaa !5
  %1384 = zext i8 %1335 to i64
  %1385 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1384
  %1386 = load i8, ptr %1385, align 1, !tbaa !5
  %1387 = zext i8 %1339 to i64
  %1388 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1387
  %1389 = load i8, ptr %1388, align 1, !tbaa !5
  %1390 = zext i8 %1343 to i64
  %1391 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1390
  %1392 = load i8, ptr %1391, align 1, !tbaa !5
  %1393 = zext i8 %1347 to i64
  %1394 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1393
  %1395 = load i8, ptr %1394, align 1, !tbaa !5
  %1396 = zext i8 %1350 to i64
  %1397 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1396
  %1398 = load i8, ptr %1397, align 1, !tbaa !5
  %1399 = xor i8 %1368, %1353
  %1400 = xor i8 %1383, %1399
  %1401 = xor i8 %1398, %1400
  %1402 = tail call zeroext i8 @mul2(i8 noundef zeroext %1399)
  %1403 = xor i8 %1402, %1353
  %1404 = xor i8 %1403, %1401
  store i8 %1404, ptr %2, align 1, !tbaa !5
  %1405 = xor i8 %1383, %1368
  %1406 = tail call zeroext i8 @mul2(i8 noundef zeroext %1405)
  %1407 = xor i8 %1368, %1406
  %1408 = xor i8 %1407, %1401
  store i8 %1408, ptr %13, align 1, !tbaa !5
  %1409 = xor i8 %1398, %1383
  %1410 = tail call zeroext i8 @mul2(i8 noundef zeroext %1409)
  %1411 = xor i8 %1399, %1410
  %1412 = xor i8 %1411, %1398
  store i8 %1412, ptr %19, align 1, !tbaa !5
  %1413 = xor i8 %1398, %1353
  %1414 = tail call zeroext i8 @mul2(i8 noundef zeroext %1413)
  %1415 = xor i8 %1414, %1400
  store i8 %1415, ptr %25, align 1, !tbaa !5
  %1416 = xor i8 %1380, %1365
  %1417 = xor i8 %1395, %1416
  %1418 = xor i8 %1417, %1362
  %1419 = tail call zeroext i8 @mul2(i8 noundef zeroext %1416)
  %1420 = xor i8 %1365, %1419
  %1421 = xor i8 %1420, %1418
  store i8 %1421, ptr %31, align 1, !tbaa !5
  %1422 = xor i8 %1395, %1380
  %1423 = tail call zeroext i8 @mul2(i8 noundef zeroext %1422)
  %1424 = xor i8 %1380, %1423
  %1425 = xor i8 %1424, %1418
  store i8 %1425, ptr %37, align 1, !tbaa !5
  %1426 = xor i8 %1395, %1362
  %1427 = tail call zeroext i8 @mul2(i8 noundef zeroext %1426)
  %1428 = xor i8 %1362, %1427
  %1429 = xor i8 %1428, %1416
  store i8 %1429, ptr %43, align 1, !tbaa !5
  %1430 = xor i8 %1365, %1362
  %1431 = tail call zeroext i8 @mul2(i8 noundef zeroext %1430)
  %1432 = xor i8 %1431, %1417
  store i8 %1432, ptr %49, align 1, !tbaa !5
  %1433 = xor i8 %1392, %1377
  %1434 = xor i8 %1433, %1359
  %1435 = xor i8 %1434, %1374
  %1436 = tail call zeroext i8 @mul2(i8 noundef zeroext %1433)
  %1437 = xor i8 %1377, %1436
  %1438 = xor i8 %1437, %1435
  store i8 %1438, ptr %55, align 1, !tbaa !5
  %1439 = xor i8 %1392, %1359
  %1440 = tail call zeroext i8 @mul2(i8 noundef zeroext %1439)
  %1441 = xor i8 %1392, %1440
  %1442 = xor i8 %1441, %1435
  store i8 %1442, ptr %61, align 1, !tbaa !5
  %1443 = xor i8 %1374, %1359
  %1444 = tail call zeroext i8 @mul2(i8 noundef zeroext %1443)
  %1445 = xor i8 %1374, %1444
  %1446 = xor i8 %1445, %1433
  store i8 %1446, ptr %67, align 1, !tbaa !5
  %1447 = xor i8 %1377, %1374
  %1448 = tail call zeroext i8 @mul2(i8 noundef zeroext %1447)
  %1449 = xor i8 %1448, %1434
  store i8 %1449, ptr %73, align 1, !tbaa !5
  %1450 = xor i8 %1389, %1356
  %1451 = xor i8 %1450, %1371
  %1452 = xor i8 %1451, %1386
  %1453 = tail call zeroext i8 @mul2(i8 noundef zeroext %1450)
  %1454 = xor i8 %1389, %1453
  %1455 = xor i8 %1454, %1452
  store i8 %1455, ptr %79, align 1, !tbaa !5
  %1456 = xor i8 %1371, %1356
  %1457 = tail call zeroext i8 @mul2(i8 noundef zeroext %1456)
  %1458 = xor i8 %1356, %1457
  %1459 = xor i8 %1458, %1452
  store i8 %1459, ptr %85, align 1, !tbaa !5
  %1460 = xor i8 %1386, %1371
  %1461 = tail call zeroext i8 @mul2(i8 noundef zeroext %1460)
  %1462 = xor i8 %1386, %1461
  %1463 = xor i8 %1462, %1450
  store i8 %1463, ptr %91, align 1, !tbaa !5
  %1464 = xor i8 %1389, %1386
  %1465 = tail call zeroext i8 @mul2(i8 noundef zeroext %1464)
  %1466 = xor i8 %1465, %1451
  store i8 %1466, ptr %97, align 1, !tbaa !5
  %1467 = load i8, ptr %2, align 1, !tbaa !5
  %1468 = getelementptr inbounds i8, ptr %0, i64 129
  %1469 = load i8, ptr %1348, align 1, !tbaa !5
  %1470 = xor i8 %1469, %1467
  store i8 %1470, ptr %2, align 1, !tbaa !5
  %1471 = load i8, ptr %13, align 1, !tbaa !5
  %1472 = getelementptr inbounds i8, ptr %0, i64 130
  %1473 = load i8, ptr %1468, align 1, !tbaa !5
  %1474 = xor i8 %1473, %1471
  store i8 %1474, ptr %13, align 1, !tbaa !5
  %1475 = load i8, ptr %19, align 1, !tbaa !5
  %1476 = getelementptr inbounds i8, ptr %0, i64 131
  %1477 = load i8, ptr %1472, align 1, !tbaa !5
  %1478 = xor i8 %1477, %1475
  store i8 %1478, ptr %19, align 1, !tbaa !5
  %1479 = load i8, ptr %25, align 1, !tbaa !5
  %1480 = getelementptr inbounds i8, ptr %0, i64 132
  %1481 = load i8, ptr %1476, align 1, !tbaa !5
  %1482 = xor i8 %1481, %1479
  store i8 %1482, ptr %25, align 1, !tbaa !5
  %1483 = load i8, ptr %31, align 1, !tbaa !5
  %1484 = getelementptr inbounds i8, ptr %0, i64 133
  %1485 = load i8, ptr %1480, align 1, !tbaa !5
  %1486 = xor i8 %1485, %1483
  store i8 %1486, ptr %31, align 1, !tbaa !5
  %1487 = load i8, ptr %37, align 1, !tbaa !5
  %1488 = getelementptr inbounds i8, ptr %0, i64 134
  %1489 = load i8, ptr %1484, align 1, !tbaa !5
  %1490 = xor i8 %1489, %1487
  store i8 %1490, ptr %37, align 1, !tbaa !5
  %1491 = load i8, ptr %43, align 1, !tbaa !5
  %1492 = getelementptr inbounds i8, ptr %0, i64 135
  %1493 = load i8, ptr %1488, align 1, !tbaa !5
  %1494 = xor i8 %1493, %1491
  store i8 %1494, ptr %43, align 1, !tbaa !5
  %1495 = load i8, ptr %49, align 1, !tbaa !5
  %1496 = getelementptr inbounds i8, ptr %0, i64 136
  %1497 = load i8, ptr %1492, align 1, !tbaa !5
  %1498 = xor i8 %1497, %1495
  store i8 %1498, ptr %49, align 1, !tbaa !5
  %1499 = load i8, ptr %55, align 1, !tbaa !5
  %1500 = getelementptr inbounds i8, ptr %0, i64 137
  %1501 = load i8, ptr %1496, align 1, !tbaa !5
  %1502 = xor i8 %1501, %1499
  store i8 %1502, ptr %55, align 1, !tbaa !5
  %1503 = load i8, ptr %61, align 1, !tbaa !5
  %1504 = getelementptr inbounds i8, ptr %0, i64 138
  %1505 = load i8, ptr %1500, align 1, !tbaa !5
  %1506 = xor i8 %1505, %1503
  store i8 %1506, ptr %61, align 1, !tbaa !5
  %1507 = load i8, ptr %67, align 1, !tbaa !5
  %1508 = getelementptr inbounds i8, ptr %0, i64 139
  %1509 = load i8, ptr %1504, align 1, !tbaa !5
  %1510 = xor i8 %1509, %1507
  store i8 %1510, ptr %67, align 1, !tbaa !5
  %1511 = load i8, ptr %73, align 1, !tbaa !5
  %1512 = getelementptr inbounds i8, ptr %0, i64 140
  %1513 = load i8, ptr %1508, align 1, !tbaa !5
  %1514 = xor i8 %1513, %1511
  store i8 %1514, ptr %73, align 1, !tbaa !5
  %1515 = load i8, ptr %79, align 1, !tbaa !5
  %1516 = getelementptr inbounds i8, ptr %0, i64 141
  %1517 = load i8, ptr %1512, align 1, !tbaa !5
  %1518 = xor i8 %1517, %1515
  store i8 %1518, ptr %79, align 1, !tbaa !5
  %1519 = load i8, ptr %85, align 1, !tbaa !5
  %1520 = getelementptr inbounds i8, ptr %0, i64 142
  %1521 = load i8, ptr %1516, align 1, !tbaa !5
  %1522 = xor i8 %1521, %1519
  store i8 %1522, ptr %85, align 1, !tbaa !5
  %1523 = load i8, ptr %91, align 1, !tbaa !5
  %1524 = getelementptr inbounds i8, ptr %0, i64 143
  %1525 = load i8, ptr %1520, align 1, !tbaa !5
  %1526 = xor i8 %1525, %1523
  store i8 %1526, ptr %91, align 1, !tbaa !5
  %1527 = getelementptr inbounds i8, ptr %0, i64 144
  %1528 = load i8, ptr %1524, align 1, !tbaa !5
  %1529 = xor i8 %1528, %1466
  store i8 %1529, ptr %97, align 1, !tbaa !5
  %1530 = zext i8 %1470 to i64
  %1531 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1530
  %1532 = load i8, ptr %1531, align 1, !tbaa !5
  %1533 = zext i8 %1474 to i64
  %1534 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1533
  %1535 = load i8, ptr %1534, align 1, !tbaa !5
  %1536 = zext i8 %1478 to i64
  %1537 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1536
  %1538 = load i8, ptr %1537, align 1, !tbaa !5
  %1539 = zext i8 %1482 to i64
  %1540 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1539
  %1541 = load i8, ptr %1540, align 1, !tbaa !5
  %1542 = zext i8 %1486 to i64
  %1543 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1542
  %1544 = load i8, ptr %1543, align 1, !tbaa !5
  %1545 = zext i8 %1490 to i64
  %1546 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1545
  %1547 = load i8, ptr %1546, align 1, !tbaa !5
  %1548 = zext i8 %1494 to i64
  %1549 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1548
  %1550 = load i8, ptr %1549, align 1, !tbaa !5
  %1551 = zext i8 %1498 to i64
  %1552 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1551
  %1553 = load i8, ptr %1552, align 1, !tbaa !5
  %1554 = zext i8 %1502 to i64
  %1555 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1554
  %1556 = load i8, ptr %1555, align 1, !tbaa !5
  %1557 = zext i8 %1506 to i64
  %1558 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1557
  %1559 = load i8, ptr %1558, align 1, !tbaa !5
  %1560 = zext i8 %1510 to i64
  %1561 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1560
  %1562 = load i8, ptr %1561, align 1, !tbaa !5
  %1563 = zext i8 %1514 to i64
  %1564 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1563
  %1565 = load i8, ptr %1564, align 1, !tbaa !5
  %1566 = zext i8 %1518 to i64
  %1567 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1566
  %1568 = load i8, ptr %1567, align 1, !tbaa !5
  %1569 = zext i8 %1522 to i64
  %1570 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1569
  %1571 = load i8, ptr %1570, align 1, !tbaa !5
  %1572 = zext i8 %1526 to i64
  %1573 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1572
  %1574 = load i8, ptr %1573, align 1, !tbaa !5
  %1575 = zext i8 %1529 to i64
  %1576 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1575
  %1577 = load i8, ptr %1576, align 1, !tbaa !5
  %1578 = xor i8 %1547, %1532
  %1579 = xor i8 %1562, %1578
  %1580 = xor i8 %1577, %1579
  %1581 = tail call zeroext i8 @mul2(i8 noundef zeroext %1578)
  %1582 = xor i8 %1581, %1532
  %1583 = xor i8 %1582, %1580
  store i8 %1583, ptr %2, align 1, !tbaa !5
  %1584 = xor i8 %1562, %1547
  %1585 = tail call zeroext i8 @mul2(i8 noundef zeroext %1584)
  %1586 = xor i8 %1547, %1585
  %1587 = xor i8 %1586, %1580
  store i8 %1587, ptr %13, align 1, !tbaa !5
  %1588 = xor i8 %1577, %1562
  %1589 = tail call zeroext i8 @mul2(i8 noundef zeroext %1588)
  %1590 = xor i8 %1578, %1589
  %1591 = xor i8 %1590, %1577
  store i8 %1591, ptr %19, align 1, !tbaa !5
  %1592 = xor i8 %1577, %1532
  %1593 = tail call zeroext i8 @mul2(i8 noundef zeroext %1592)
  %1594 = xor i8 %1593, %1579
  store i8 %1594, ptr %25, align 1, !tbaa !5
  %1595 = xor i8 %1559, %1544
  %1596 = xor i8 %1574, %1595
  %1597 = xor i8 %1596, %1541
  %1598 = tail call zeroext i8 @mul2(i8 noundef zeroext %1595)
  %1599 = xor i8 %1544, %1598
  %1600 = xor i8 %1599, %1597
  store i8 %1600, ptr %31, align 1, !tbaa !5
  %1601 = xor i8 %1574, %1559
  %1602 = tail call zeroext i8 @mul2(i8 noundef zeroext %1601)
  %1603 = xor i8 %1559, %1602
  %1604 = xor i8 %1603, %1597
  store i8 %1604, ptr %37, align 1, !tbaa !5
  %1605 = xor i8 %1574, %1541
  %1606 = tail call zeroext i8 @mul2(i8 noundef zeroext %1605)
  %1607 = xor i8 %1541, %1606
  %1608 = xor i8 %1607, %1595
  store i8 %1608, ptr %43, align 1, !tbaa !5
  %1609 = xor i8 %1544, %1541
  %1610 = tail call zeroext i8 @mul2(i8 noundef zeroext %1609)
  %1611 = xor i8 %1610, %1596
  store i8 %1611, ptr %49, align 1, !tbaa !5
  %1612 = xor i8 %1571, %1556
  %1613 = xor i8 %1612, %1538
  %1614 = xor i8 %1613, %1553
  %1615 = tail call zeroext i8 @mul2(i8 noundef zeroext %1612)
  %1616 = xor i8 %1556, %1615
  %1617 = xor i8 %1616, %1614
  store i8 %1617, ptr %55, align 1, !tbaa !5
  %1618 = xor i8 %1571, %1538
  %1619 = tail call zeroext i8 @mul2(i8 noundef zeroext %1618)
  %1620 = xor i8 %1571, %1619
  %1621 = xor i8 %1620, %1614
  store i8 %1621, ptr %61, align 1, !tbaa !5
  %1622 = xor i8 %1553, %1538
  %1623 = tail call zeroext i8 @mul2(i8 noundef zeroext %1622)
  %1624 = xor i8 %1553, %1623
  %1625 = xor i8 %1624, %1612
  store i8 %1625, ptr %67, align 1, !tbaa !5
  %1626 = xor i8 %1556, %1553
  %1627 = tail call zeroext i8 @mul2(i8 noundef zeroext %1626)
  %1628 = xor i8 %1627, %1613
  store i8 %1628, ptr %73, align 1, !tbaa !5
  %1629 = xor i8 %1568, %1535
  %1630 = xor i8 %1629, %1550
  %1631 = xor i8 %1630, %1565
  %1632 = tail call zeroext i8 @mul2(i8 noundef zeroext %1629)
  %1633 = xor i8 %1568, %1632
  %1634 = xor i8 %1633, %1631
  store i8 %1634, ptr %79, align 1, !tbaa !5
  %1635 = xor i8 %1550, %1535
  %1636 = tail call zeroext i8 @mul2(i8 noundef zeroext %1635)
  %1637 = xor i8 %1535, %1636
  %1638 = xor i8 %1637, %1631
  store i8 %1638, ptr %85, align 1, !tbaa !5
  %1639 = xor i8 %1565, %1550
  %1640 = tail call zeroext i8 @mul2(i8 noundef zeroext %1639)
  %1641 = xor i8 %1565, %1640
  %1642 = xor i8 %1641, %1629
  store i8 %1642, ptr %91, align 1, !tbaa !5
  %1643 = xor i8 %1568, %1565
  %1644 = tail call zeroext i8 @mul2(i8 noundef zeroext %1643)
  %1645 = xor i8 %1644, %1630
  store i8 %1645, ptr %97, align 1, !tbaa !5
  %1646 = load i8, ptr %2, align 1, !tbaa !5
  %1647 = getelementptr inbounds i8, ptr %0, i64 145
  %1648 = load i8, ptr %1527, align 1, !tbaa !5
  %1649 = xor i8 %1648, %1646
  store i8 %1649, ptr %2, align 1, !tbaa !5
  %1650 = load i8, ptr %13, align 1, !tbaa !5
  %1651 = getelementptr inbounds i8, ptr %0, i64 146
  %1652 = load i8, ptr %1647, align 1, !tbaa !5
  %1653 = xor i8 %1652, %1650
  store i8 %1653, ptr %13, align 1, !tbaa !5
  %1654 = load i8, ptr %19, align 1, !tbaa !5
  %1655 = getelementptr inbounds i8, ptr %0, i64 147
  %1656 = load i8, ptr %1651, align 1, !tbaa !5
  %1657 = xor i8 %1656, %1654
  store i8 %1657, ptr %19, align 1, !tbaa !5
  %1658 = load i8, ptr %25, align 1, !tbaa !5
  %1659 = getelementptr inbounds i8, ptr %0, i64 148
  %1660 = load i8, ptr %1655, align 1, !tbaa !5
  %1661 = xor i8 %1660, %1658
  store i8 %1661, ptr %25, align 1, !tbaa !5
  %1662 = load i8, ptr %31, align 1, !tbaa !5
  %1663 = getelementptr inbounds i8, ptr %0, i64 149
  %1664 = load i8, ptr %1659, align 1, !tbaa !5
  %1665 = xor i8 %1664, %1662
  store i8 %1665, ptr %31, align 1, !tbaa !5
  %1666 = load i8, ptr %37, align 1, !tbaa !5
  %1667 = getelementptr inbounds i8, ptr %0, i64 150
  %1668 = load i8, ptr %1663, align 1, !tbaa !5
  %1669 = xor i8 %1668, %1666
  store i8 %1669, ptr %37, align 1, !tbaa !5
  %1670 = load i8, ptr %43, align 1, !tbaa !5
  %1671 = getelementptr inbounds i8, ptr %0, i64 151
  %1672 = load i8, ptr %1667, align 1, !tbaa !5
  %1673 = xor i8 %1672, %1670
  store i8 %1673, ptr %43, align 1, !tbaa !5
  %1674 = load i8, ptr %49, align 1, !tbaa !5
  %1675 = getelementptr inbounds i8, ptr %0, i64 152
  %1676 = load i8, ptr %1671, align 1, !tbaa !5
  %1677 = xor i8 %1676, %1674
  store i8 %1677, ptr %49, align 1, !tbaa !5
  %1678 = load i8, ptr %55, align 1, !tbaa !5
  %1679 = getelementptr inbounds i8, ptr %0, i64 153
  %1680 = load i8, ptr %1675, align 1, !tbaa !5
  %1681 = xor i8 %1680, %1678
  store i8 %1681, ptr %55, align 1, !tbaa !5
  %1682 = load i8, ptr %61, align 1, !tbaa !5
  %1683 = getelementptr inbounds i8, ptr %0, i64 154
  %1684 = load i8, ptr %1679, align 1, !tbaa !5
  %1685 = xor i8 %1684, %1682
  store i8 %1685, ptr %61, align 1, !tbaa !5
  %1686 = load i8, ptr %67, align 1, !tbaa !5
  %1687 = getelementptr inbounds i8, ptr %0, i64 155
  %1688 = load i8, ptr %1683, align 1, !tbaa !5
  %1689 = xor i8 %1688, %1686
  store i8 %1689, ptr %67, align 1, !tbaa !5
  %1690 = load i8, ptr %73, align 1, !tbaa !5
  %1691 = getelementptr inbounds i8, ptr %0, i64 156
  %1692 = load i8, ptr %1687, align 1, !tbaa !5
  %1693 = xor i8 %1692, %1690
  store i8 %1693, ptr %73, align 1, !tbaa !5
  %1694 = load i8, ptr %79, align 1, !tbaa !5
  %1695 = getelementptr inbounds i8, ptr %0, i64 157
  %1696 = load i8, ptr %1691, align 1, !tbaa !5
  %1697 = xor i8 %1696, %1694
  store i8 %1697, ptr %79, align 1, !tbaa !5
  %1698 = load i8, ptr %85, align 1, !tbaa !5
  %1699 = getelementptr inbounds i8, ptr %0, i64 158
  %1700 = load i8, ptr %1695, align 1, !tbaa !5
  %1701 = xor i8 %1700, %1698
  store i8 %1701, ptr %85, align 1, !tbaa !5
  %1702 = load i8, ptr %91, align 1, !tbaa !5
  %1703 = getelementptr inbounds i8, ptr %0, i64 159
  %1704 = load i8, ptr %1699, align 1, !tbaa !5
  %1705 = xor i8 %1704, %1702
  store i8 %1705, ptr %91, align 1, !tbaa !5
  %1706 = getelementptr inbounds i8, ptr %0, i64 160
  %1707 = load i8, ptr %1703, align 1, !tbaa !5
  %1708 = xor i8 %1707, %1645
  store i8 %1708, ptr %97, align 1, !tbaa !5
  %1709 = zext i8 %1649 to i64
  %1710 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1709
  %1711 = load i8, ptr %1710, align 1, !tbaa !5
  store i8 %1711, ptr %2, align 1, !tbaa !5
  %1712 = zext i8 %1653 to i64
  %1713 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1712
  %1714 = load i8, ptr %1713, align 1, !tbaa !5
  store i8 %1714, ptr %13, align 1, !tbaa !5
  %1715 = zext i8 %1657 to i64
  %1716 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1715
  %1717 = load i8, ptr %1716, align 1, !tbaa !5
  store i8 %1717, ptr %19, align 1, !tbaa !5
  %1718 = zext i8 %1661 to i64
  %1719 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1718
  %1720 = load i8, ptr %1719, align 1, !tbaa !5
  store i8 %1720, ptr %25, align 1, !tbaa !5
  %1721 = zext i8 %1665 to i64
  %1722 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1721
  %1723 = load i8, ptr %1722, align 1, !tbaa !5
  store i8 %1723, ptr %31, align 1, !tbaa !5
  %1724 = zext i8 %1669 to i64
  %1725 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1724
  %1726 = load i8, ptr %1725, align 1, !tbaa !5
  store i8 %1726, ptr %37, align 1, !tbaa !5
  %1727 = zext i8 %1673 to i64
  %1728 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1727
  %1729 = load i8, ptr %1728, align 1, !tbaa !5
  store i8 %1729, ptr %43, align 1, !tbaa !5
  %1730 = zext i8 %1677 to i64
  %1731 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1730
  %1732 = load i8, ptr %1731, align 1, !tbaa !5
  store i8 %1732, ptr %49, align 1, !tbaa !5
  %1733 = zext i8 %1681 to i64
  %1734 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1733
  %1735 = load i8, ptr %1734, align 1, !tbaa !5
  store i8 %1735, ptr %55, align 1, !tbaa !5
  %1736 = zext i8 %1685 to i64
  %1737 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1736
  %1738 = load i8, ptr %1737, align 1, !tbaa !5
  store i8 %1738, ptr %61, align 1, !tbaa !5
  %1739 = zext i8 %1689 to i64
  %1740 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1739
  %1741 = load i8, ptr %1740, align 1, !tbaa !5
  store i8 %1741, ptr %67, align 1, !tbaa !5
  %1742 = zext i8 %1693 to i64
  %1743 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1742
  %1744 = load i8, ptr %1743, align 1, !tbaa !5
  store i8 %1744, ptr %73, align 1, !tbaa !5
  %1745 = zext i8 %1697 to i64
  %1746 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1745
  %1747 = load i8, ptr %1746, align 1, !tbaa !5
  store i8 %1747, ptr %79, align 1, !tbaa !5
  %1748 = zext i8 %1701 to i64
  %1749 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1748
  %1750 = load i8, ptr %1749, align 1, !tbaa !5
  store i8 %1750, ptr %85, align 1, !tbaa !5
  %1751 = zext i8 %1705 to i64
  %1752 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1751
  %1753 = load i8, ptr %1752, align 1, !tbaa !5
  store i8 %1753, ptr %91, align 1, !tbaa !5
  %1754 = zext i8 %1708 to i64
  %1755 = getelementptr inbounds [256 x i8], ptr @SBOX, i64 0, i64 %1754
  %1756 = load i8, ptr %1755, align 1, !tbaa !5
  store i8 %1726, ptr %13, align 1, !tbaa !5
  store i8 %1738, ptr %37, align 1, !tbaa !5
  store i8 %1750, ptr %61, align 1, !tbaa !5
  store i8 %1714, ptr %85, align 1, !tbaa !5
  store i8 %1741, ptr %19, align 1, !tbaa !5
  store i8 %1717, ptr %67, align 1, !tbaa !5
  store i8 %1753, ptr %43, align 1, !tbaa !5
  store i8 %1729, ptr %91, align 1, !tbaa !5
  store i8 %1744, ptr %97, align 1, !tbaa !5
  store i8 %1732, ptr %73, align 1, !tbaa !5
  store i8 %1720, ptr %49, align 1, !tbaa !5
  store i8 %1756, ptr %25, align 1, !tbaa !5
  %1757 = getelementptr inbounds i8, ptr %0, i64 161
  %1758 = load i8, ptr %1706, align 1, !tbaa !5
  %1759 = xor i8 %1758, %1711
  store i8 %1759, ptr %2, align 1, !tbaa !5
  %1760 = getelementptr inbounds i8, ptr %0, i64 162
  %1761 = load i8, ptr %1757, align 1, !tbaa !5
  %1762 = xor i8 %1761, %1726
  store i8 %1762, ptr %13, align 1, !tbaa !5
  %1763 = getelementptr inbounds i8, ptr %0, i64 163
  %1764 = load i8, ptr %1760, align 1, !tbaa !5
  %1765 = xor i8 %1764, %1741
  store i8 %1765, ptr %19, align 1, !tbaa !5
  %1766 = getelementptr inbounds i8, ptr %0, i64 164
  %1767 = load i8, ptr %1763, align 1, !tbaa !5
  %1768 = xor i8 %1767, %1756
  store i8 %1768, ptr %25, align 1, !tbaa !5
  %1769 = getelementptr inbounds i8, ptr %0, i64 165
  %1770 = load i8, ptr %1766, align 1, !tbaa !5
  %1771 = xor i8 %1770, %1723
  store i8 %1771, ptr %31, align 1, !tbaa !5
  %1772 = getelementptr inbounds i8, ptr %0, i64 166
  %1773 = load i8, ptr %1769, align 1, !tbaa !5
  %1774 = xor i8 %1773, %1738
  store i8 %1774, ptr %37, align 1, !tbaa !5
  %1775 = getelementptr inbounds i8, ptr %0, i64 167
  %1776 = load i8, ptr %1772, align 1, !tbaa !5
  %1777 = xor i8 %1776, %1753
  store i8 %1777, ptr %43, align 1, !tbaa !5
  %1778 = getelementptr inbounds i8, ptr %0, i64 168
  %1779 = load i8, ptr %1775, align 1, !tbaa !5
  %1780 = xor i8 %1779, %1720
  store i8 %1780, ptr %49, align 1, !tbaa !5
  %1781 = getelementptr inbounds i8, ptr %0, i64 169
  %1782 = load i8, ptr %1778, align 1, !tbaa !5
  %1783 = xor i8 %1782, %1735
  store i8 %1783, ptr %55, align 1, !tbaa !5
  %1784 = getelementptr inbounds i8, ptr %0, i64 170
  %1785 = load i8, ptr %1781, align 1, !tbaa !5
  %1786 = xor i8 %1785, %1750
  store i8 %1786, ptr %61, align 1, !tbaa !5
  %1787 = getelementptr inbounds i8, ptr %0, i64 171
  %1788 = load i8, ptr %1784, align 1, !tbaa !5
  %1789 = xor i8 %1788, %1717
  store i8 %1789, ptr %67, align 1, !tbaa !5
  %1790 = getelementptr inbounds i8, ptr %0, i64 172
  %1791 = load i8, ptr %1787, align 1, !tbaa !5
  %1792 = xor i8 %1791, %1732
  store i8 %1792, ptr %73, align 1, !tbaa !5
  %1793 = getelementptr inbounds i8, ptr %0, i64 173
  %1794 = load i8, ptr %1790, align 1, !tbaa !5
  %1795 = xor i8 %1794, %1747
  store i8 %1795, ptr %79, align 1, !tbaa !5
  %1796 = getelementptr inbounds i8, ptr %0, i64 174
  %1797 = load i8, ptr %1793, align 1, !tbaa !5
  %1798 = xor i8 %1797, %1714
  store i8 %1798, ptr %85, align 1, !tbaa !5
  %1799 = getelementptr inbounds i8, ptr %0, i64 175
  %1800 = load i8, ptr %1796, align 1, !tbaa !5
  %1801 = xor i8 %1800, %1729
  store i8 %1801, ptr %91, align 1, !tbaa !5
  %1802 = load i8, ptr %1799, align 1, !tbaa !5
  %1803 = xor i8 %1802, %1744
  store i8 %1803, ptr %97, align 1, !tbaa !5
  ret void
}

; Function Attrs: inlinehint nounwind uwtable
declare hidden zeroext i8 @mul2(i8 noundef zeroext) local_unnamed_addr #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 = { inlinehint 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" }

!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 = !{!"omnipotent char", !7, i64 0}
!7 = !{!"Simple C/C++ TBAA"}


; Effective O3 passes: DSEPass,EarlyCSEPass,GlobalOptPass,IPSCCPPass,InferFunctionAttrsPass,InstCombinePass,PostOrderFunctionAttrsPass,ReassociatePass,SROAPass,TailCallElimPass