; LLVM IR from openssl/openssl :: crypto/seed (seed)

; Unoptimized IR (clang -disable-llvm-passes):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%struct.seed_key_st = type { [32 x i32] }

@SS = external hidden constant [4 x [256 x i32]], 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 @SEED_decrypt(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 i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca i32, align 4
  %12 = alloca i32, align 4
  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 4, ptr %7) #2
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #2
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #2
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #2
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #2
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #2
  %13 = load ptr, ptr %4, align 8, !tbaa !5
  %14 = getelementptr inbounds i8, ptr %13, i64 0
  %15 = load i8, ptr %14, align 1, !tbaa !9
  %16 = zext i8 %15 to i32
  %17 = shl i32 %16, 24
  %18 = load ptr, ptr %4, align 8, !tbaa !5
  %19 = getelementptr inbounds i8, ptr %18, i64 1
  %20 = load i8, ptr %19, align 1, !tbaa !9
  %21 = zext i8 %20 to i32
  %22 = shl i32 %21, 16
  %23 = or i32 %17, %22
  %24 = load ptr, ptr %4, align 8, !tbaa !5
  %25 = getelementptr inbounds i8, ptr %24, i64 2
  %26 = load i8, ptr %25, align 1, !tbaa !9
  %27 = zext i8 %26 to i32
  %28 = shl i32 %27, 8
  %29 = or i32 %23, %28
  %30 = load ptr, ptr %4, align 8, !tbaa !5
  %31 = getelementptr inbounds i8, ptr %30, i64 3
  %32 = load i8, ptr %31, align 1, !tbaa !9
  %33 = zext i8 %32 to i32
  %34 = or i32 %29, %33
  store i32 %34, ptr %7, align 4, !tbaa !10
  %35 = load ptr, ptr %4, align 8, !tbaa !5
  %36 = getelementptr inbounds i8, ptr %35, i64 4
  %37 = getelementptr inbounds i8, ptr %36, i64 0
  %38 = load i8, ptr %37, align 1, !tbaa !9
  %39 = zext i8 %38 to i32
  %40 = shl i32 %39, 24
  %41 = load ptr, ptr %4, align 8, !tbaa !5
  %42 = getelementptr inbounds i8, ptr %41, i64 4
  %43 = getelementptr inbounds i8, ptr %42, i64 1
  %44 = load i8, ptr %43, align 1, !tbaa !9
  %45 = zext i8 %44 to i32
  %46 = shl i32 %45, 16
  %47 = or i32 %40, %46
  %48 = load ptr, ptr %4, align 8, !tbaa !5
  %49 = getelementptr inbounds i8, ptr %48, i64 4
  %50 = getelementptr inbounds i8, ptr %49, i64 2
  %51 = load i8, ptr %50, align 1, !tbaa !9
  %52 = zext i8 %51 to i32
  %53 = shl i32 %52, 8
  %54 = or i32 %47, %53
  %55 = load ptr, ptr %4, align 8, !tbaa !5
  %56 = getelementptr inbounds i8, ptr %55, i64 4
  %57 = getelementptr inbounds i8, ptr %56, i64 3
  %58 = load i8, ptr %57, align 1, !tbaa !9
  %59 = zext i8 %58 to i32
  %60 = or i32 %54, %59
  store i32 %60, ptr %8, align 4, !tbaa !10
  %61 = load ptr, ptr %4, align 8, !tbaa !5
  %62 = getelementptr inbounds i8, ptr %61, i64 8
  %63 = getelementptr inbounds i8, ptr %62, i64 0
  %64 = load i8, ptr %63, align 1, !tbaa !9
  %65 = zext i8 %64 to i32
  %66 = shl i32 %65, 24
  %67 = load ptr, ptr %4, align 8, !tbaa !5
  %68 = getelementptr inbounds i8, ptr %67, i64 8
  %69 = getelementptr inbounds i8, ptr %68, i64 1
  %70 = load i8, ptr %69, align 1, !tbaa !9
  %71 = zext i8 %70 to i32
  %72 = shl i32 %71, 16
  %73 = or i32 %66, %72
  %74 = load ptr, ptr %4, align 8, !tbaa !5
  %75 = getelementptr inbounds i8, ptr %74, i64 8
  %76 = getelementptr inbounds i8, ptr %75, i64 2
  %77 = load i8, ptr %76, align 1, !tbaa !9
  %78 = zext i8 %77 to i32
  %79 = shl i32 %78, 8
  %80 = or i32 %73, %79
  %81 = load ptr, ptr %4, align 8, !tbaa !5
  %82 = getelementptr inbounds i8, ptr %81, i64 8
  %83 = getelementptr inbounds i8, ptr %82, i64 3
  %84 = load i8, ptr %83, align 1, !tbaa !9
  %85 = zext i8 %84 to i32
  %86 = or i32 %80, %85
  store i32 %86, ptr %9, align 4, !tbaa !10
  %87 = load ptr, ptr %4, align 8, !tbaa !5
  %88 = getelementptr inbounds i8, ptr %87, i64 12
  %89 = getelementptr inbounds i8, ptr %88, i64 0
  %90 = load i8, ptr %89, align 1, !tbaa !9
  %91 = zext i8 %90 to i32
  %92 = shl i32 %91, 24
  %93 = load ptr, ptr %4, align 8, !tbaa !5
  %94 = getelementptr inbounds i8, ptr %93, i64 12
  %95 = getelementptr inbounds i8, ptr %94, i64 1
  %96 = load i8, ptr %95, align 1, !tbaa !9
  %97 = zext i8 %96 to i32
  %98 = shl i32 %97, 16
  %99 = or i32 %92, %98
  %100 = load ptr, ptr %4, align 8, !tbaa !5
  %101 = getelementptr inbounds i8, ptr %100, i64 12
  %102 = getelementptr inbounds i8, ptr %101, i64 2
  %103 = load i8, ptr %102, align 1, !tbaa !9
  %104 = zext i8 %103 to i32
  %105 = shl i32 %104, 8
  %106 = or i32 %99, %105
  %107 = load ptr, ptr %4, align 8, !tbaa !5
  %108 = getelementptr inbounds i8, ptr %107, i64 12
  %109 = getelementptr inbounds i8, ptr %108, i64 3
  %110 = load i8, ptr %109, align 1, !tbaa !9
  %111 = zext i8 %110 to i32
  %112 = or i32 %106, %111
  store i32 %112, ptr %10, align 4, !tbaa !10
  %113 = load i32, ptr %9, align 4, !tbaa !10
  %114 = load ptr, ptr %6, align 8, !tbaa !5
  %115 = getelementptr inbounds %struct.seed_key_st, ptr %114, i32 0, i32 0
  %116 = getelementptr inbounds [32 x i32], ptr %115, i64 0, i64 30
  %117 = load i32, ptr %116, align 4, !tbaa !10
  %118 = xor i32 %113, %117
  store i32 %118, ptr %11, align 4, !tbaa !10
  %119 = load i32, ptr %10, align 4, !tbaa !10
  %120 = load ptr, ptr %6, align 8, !tbaa !5
  %121 = getelementptr inbounds %struct.seed_key_st, ptr %120, i32 0, i32 0
  %122 = getelementptr inbounds [32 x i32], ptr %121, i64 0, i64 31
  %123 = load i32, ptr %122, align 4, !tbaa !10
  %124 = xor i32 %119, %123
  store i32 %124, ptr %12, align 4, !tbaa !10
  %125 = load i32, ptr %11, align 4, !tbaa !10
  %126 = load i32, ptr %12, align 4, !tbaa !10
  %127 = xor i32 %126, %125
  store i32 %127, ptr %12, align 4, !tbaa !10
  %128 = load i32, ptr %12, align 4, !tbaa !10
  %129 = trunc i32 %128 to i8
  %130 = zext i8 %129 to i32
  %131 = and i32 %130, 255
  %132 = sext i32 %131 to i64
  %133 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %132
  %134 = load i32, ptr %133, align 4, !tbaa !10
  %135 = load i32, ptr %12, align 4, !tbaa !10
  %136 = lshr i32 %135, 8
  %137 = trunc i32 %136 to i8
  %138 = zext i8 %137 to i32
  %139 = and i32 %138, 255
  %140 = sext i32 %139 to i64
  %141 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %140
  %142 = load i32, ptr %141, align 4, !tbaa !10
  %143 = xor i32 %134, %142
  %144 = load i32, ptr %12, align 4, !tbaa !10
  %145 = lshr i32 %144, 16
  %146 = trunc i32 %145 to i8
  %147 = zext i8 %146 to i32
  %148 = and i32 %147, 255
  %149 = sext i32 %148 to i64
  %150 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %149
  %151 = load i32, ptr %150, align 4, !tbaa !10
  %152 = xor i32 %143, %151
  %153 = load i32, ptr %12, align 4, !tbaa !10
  %154 = lshr i32 %153, 24
  %155 = trunc i32 %154 to i8
  %156 = zext i8 %155 to i32
  %157 = and i32 %156, 255
  %158 = sext i32 %157 to i64
  %159 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %158
  %160 = load i32, ptr %159, align 4, !tbaa !10
  %161 = xor i32 %152, %160
  store i32 %161, ptr %12, align 4, !tbaa !10
  %162 = load i32, ptr %11, align 4, !tbaa !10
  %163 = load i32, ptr %12, align 4, !tbaa !10
  %164 = add i32 %162, %163
  %165 = and i32 %164, -1
  store i32 %165, ptr %11, align 4, !tbaa !10
  %166 = load i32, ptr %11, align 4, !tbaa !10
  %167 = trunc i32 %166 to i8
  %168 = zext i8 %167 to i32
  %169 = and i32 %168, 255
  %170 = sext i32 %169 to i64
  %171 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %170
  %172 = load i32, ptr %171, align 4, !tbaa !10
  %173 = load i32, ptr %11, align 4, !tbaa !10
  %174 = lshr i32 %173, 8
  %175 = trunc i32 %174 to i8
  %176 = zext i8 %175 to i32
  %177 = and i32 %176, 255
  %178 = sext i32 %177 to i64
  %179 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %178
  %180 = load i32, ptr %179, align 4, !tbaa !10
  %181 = xor i32 %172, %180
  %182 = load i32, ptr %11, align 4, !tbaa !10
  %183 = lshr i32 %182, 16
  %184 = trunc i32 %183 to i8
  %185 = zext i8 %184 to i32
  %186 = and i32 %185, 255
  %187 = sext i32 %186 to i64
  %188 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %187
  %189 = load i32, ptr %188, align 4, !tbaa !10
  %190 = xor i32 %181, %189
  %191 = load i32, ptr %11, align 4, !tbaa !10
  %192 = lshr i32 %191, 24
  %193 = trunc i32 %192 to i8
  %194 = zext i8 %193 to i32
  %195 = and i32 %194, 255
  %196 = sext i32 %195 to i64
  %197 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %196
  %198 = load i32, ptr %197, align 4, !tbaa !10
  %199 = xor i32 %190, %198
  store i32 %199, ptr %11, align 4, !tbaa !10
  %200 = load i32, ptr %12, align 4, !tbaa !10
  %201 = load i32, ptr %11, align 4, !tbaa !10
  %202 = add i32 %200, %201
  %203 = and i32 %202, -1
  store i32 %203, ptr %12, align 4, !tbaa !10
  %204 = load i32, ptr %12, align 4, !tbaa !10
  %205 = trunc i32 %204 to i8
  %206 = zext i8 %205 to i32
  %207 = and i32 %206, 255
  %208 = sext i32 %207 to i64
  %209 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %208
  %210 = load i32, ptr %209, align 4, !tbaa !10
  %211 = load i32, ptr %12, align 4, !tbaa !10
  %212 = lshr i32 %211, 8
  %213 = trunc i32 %212 to i8
  %214 = zext i8 %213 to i32
  %215 = and i32 %214, 255
  %216 = sext i32 %215 to i64
  %217 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %216
  %218 = load i32, ptr %217, align 4, !tbaa !10
  %219 = xor i32 %210, %218
  %220 = load i32, ptr %12, align 4, !tbaa !10
  %221 = lshr i32 %220, 16
  %222 = trunc i32 %221 to i8
  %223 = zext i8 %222 to i32
  %224 = and i32 %223, 255
  %225 = sext i32 %224 to i64
  %226 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %225
  %227 = load i32, ptr %226, align 4, !tbaa !10
  %228 = xor i32 %219, %227
  %229 = load i32, ptr %12, align 4, !tbaa !10
  %230 = lshr i32 %229, 24
  %231 = trunc i32 %230 to i8
  %232 = zext i8 %231 to i32
  %233 = and i32 %232, 255
  %234 = sext i32 %233 to i64
  %235 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %234
  %236 = load i32, ptr %235, align 4, !tbaa !10
  %237 = xor i32 %228, %236
  store i32 %237, ptr %12, align 4, !tbaa !10
  %238 = load i32, ptr %11, align 4, !tbaa !10
  %239 = load i32, ptr %12, align 4, !tbaa !10
  %240 = add i32 %238, %239
  %241 = and i32 %240, -1
  store i32 %241, ptr %11, align 4, !tbaa !10
  %242 = load i32, ptr %11, align 4, !tbaa !10
  %243 = load i32, ptr %7, align 4, !tbaa !10
  %244 = xor i32 %243, %242
  store i32 %244, ptr %7, align 4, !tbaa !10
  %245 = load i32, ptr %12, align 4, !tbaa !10
  %246 = load i32, ptr %8, align 4, !tbaa !10
  %247 = xor i32 %246, %245
  store i32 %247, ptr %8, align 4, !tbaa !10
  %248 = load i32, ptr %7, align 4, !tbaa !10
  %249 = load ptr, ptr %6, align 8, !tbaa !5
  %250 = getelementptr inbounds %struct.seed_key_st, ptr %249, i32 0, i32 0
  %251 = getelementptr inbounds [32 x i32], ptr %250, i64 0, i64 28
  %252 = load i32, ptr %251, align 4, !tbaa !10
  %253 = xor i32 %248, %252
  store i32 %253, ptr %11, align 4, !tbaa !10
  %254 = load i32, ptr %8, align 4, !tbaa !10
  %255 = load ptr, ptr %6, align 8, !tbaa !5
  %256 = getelementptr inbounds %struct.seed_key_st, ptr %255, i32 0, i32 0
  %257 = getelementptr inbounds [32 x i32], ptr %256, i64 0, i64 29
  %258 = load i32, ptr %257, align 4, !tbaa !10
  %259 = xor i32 %254, %258
  store i32 %259, ptr %12, align 4, !tbaa !10
  %260 = load i32, ptr %11, align 4, !tbaa !10
  %261 = load i32, ptr %12, align 4, !tbaa !10
  %262 = xor i32 %261, %260
  store i32 %262, ptr %12, align 4, !tbaa !10
  %263 = load i32, ptr %12, align 4, !tbaa !10
  %264 = trunc i32 %263 to i8
  %265 = zext i8 %264 to i32
  %266 = and i32 %265, 255
  %267 = sext i32 %266 to i64
  %268 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %267
  %269 = load i32, ptr %268, align 4, !tbaa !10
  %270 = load i32, ptr %12, align 4, !tbaa !10
  %271 = lshr i32 %270, 8
  %272 = trunc i32 %271 to i8
  %273 = zext i8 %272 to i32
  %274 = and i32 %273, 255
  %275 = sext i32 %274 to i64
  %276 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %275
  %277 = load i32, ptr %276, align 4, !tbaa !10
  %278 = xor i32 %269, %277
  %279 = load i32, ptr %12, align 4, !tbaa !10
  %280 = lshr i32 %279, 16
  %281 = trunc i32 %280 to i8
  %282 = zext i8 %281 to i32
  %283 = and i32 %282, 255
  %284 = sext i32 %283 to i64
  %285 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %284
  %286 = load i32, ptr %285, align 4, !tbaa !10
  %287 = xor i32 %278, %286
  %288 = load i32, ptr %12, align 4, !tbaa !10
  %289 = lshr i32 %288, 24
  %290 = trunc i32 %289 to i8
  %291 = zext i8 %290 to i32
  %292 = and i32 %291, 255
  %293 = sext i32 %292 to i64
  %294 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %293
  %295 = load i32, ptr %294, align 4, !tbaa !10
  %296 = xor i32 %287, %295
  store i32 %296, ptr %12, align 4, !tbaa !10
  %297 = load i32, ptr %11, align 4, !tbaa !10
  %298 = load i32, ptr %12, align 4, !tbaa !10
  %299 = add i32 %297, %298
  %300 = and i32 %299, -1
  store i32 %300, ptr %11, align 4, !tbaa !10
  %301 = load i32, ptr %11, align 4, !tbaa !10
  %302 = trunc i32 %301 to i8
  %303 = zext i8 %302 to i32
  %304 = and i32 %303, 255
  %305 = sext i32 %304 to i64
  %306 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %305
  %307 = load i32, ptr %306, align 4, !tbaa !10
  %308 = load i32, ptr %11, align 4, !tbaa !10
  %309 = lshr i32 %308, 8
  %310 = trunc i32 %309 to i8
  %311 = zext i8 %310 to i32
  %312 = and i32 %311, 255
  %313 = sext i32 %312 to i64
  %314 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %313
  %315 = load i32, ptr %314, align 4, !tbaa !10
  %316 = xor i32 %307, %315
  %317 = load i32, ptr %11, align 4, !tbaa !10
  %318 = lshr i32 %317, 16
  %319 = trunc i32 %318 to i8
  %320 = zext i8 %319 to i32
  %321 = and i32 %320, 255
  %322 = sext i32 %321 to i64
  %323 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %322
  %324 = load i32, ptr %323, align 4, !tbaa !10
  %325 = xor i32 %316, %324
  %326 = load i32, ptr %11, align 4, !tbaa !10
  %327 = lshr i32 %326, 24
  %328 = trunc i32 %327 to i8
  %329 = zext i8 %328 to i32
  %330 = and i32 %329, 255
  %331 = sext i32 %330 to i64
  %332 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %331
  %333 = load i32, ptr %332, align 4, !tbaa !10
  %334 = xor i32 %325, %333
  store i32 %334, ptr %11, align 4, !tbaa !10
  %335 = load i32, ptr %12, align 4, !tbaa !10
  %336 = load i32, ptr %11, align 4, !tbaa !10
  %337 = add i32 %335, %336
  %338 = and i32 %337, -1
  store i32 %338, ptr %12, align 4, !tbaa !10
  %339 = load i32, ptr %12, align 4, !tbaa !10
  %340 = trunc i32 %339 to i8
  %341 = zext i8 %340 to i32
  %342 = and i32 %341, 255
  %343 = sext i32 %342 to i64
  %344 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %343
  %345 = load i32, ptr %344, align 4, !tbaa !10
  %346 = load i32, ptr %12, align 4, !tbaa !10
  %347 = lshr i32 %346, 8
  %348 = trunc i32 %347 to i8
  %349 = zext i8 %348 to i32
  %350 = and i32 %349, 255
  %351 = sext i32 %350 to i64
  %352 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %351
  %353 = load i32, ptr %352, align 4, !tbaa !10
  %354 = xor i32 %345, %353
  %355 = load i32, ptr %12, align 4, !tbaa !10
  %356 = lshr i32 %355, 16
  %357 = trunc i32 %356 to i8
  %358 = zext i8 %357 to i32
  %359 = and i32 %358, 255
  %360 = sext i32 %359 to i64
  %361 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %360
  %362 = load i32, ptr %361, align 4, !tbaa !10
  %363 = xor i32 %354, %362
  %364 = load i32, ptr %12, align 4, !tbaa !10
  %365 = lshr i32 %364, 24
  %366 = trunc i32 %365 to i8
  %367 = zext i8 %366 to i32
  %368 = and i32 %367, 255
  %369 = sext i32 %368 to i64
  %370 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %369
  %371 = load i32, ptr %370, align 4, !tbaa !10
  %372 = xor i32 %363, %371
  store i32 %372, ptr %12, align 4, !tbaa !10
  %373 = load i32, ptr %11, align 4, !tbaa !10
  %374 = load i32, ptr %12, align 4, !tbaa !10
  %375 = add i32 %373, %374
  %376 = and i32 %375, -1
  store i32 %376, ptr %11, align 4, !tbaa !10
  %377 = load i32, ptr %11, align 4, !tbaa !10
  %378 = load i32, ptr %9, align 4, !tbaa !10
  %379 = xor i32 %378, %377
  store i32 %379, ptr %9, align 4, !tbaa !10
  %380 = load i32, ptr %12, align 4, !tbaa !10
  %381 = load i32, ptr %10, align 4, !tbaa !10
  %382 = xor i32 %381, %380
  store i32 %382, ptr %10, align 4, !tbaa !10
  %383 = load i32, ptr %9, align 4, !tbaa !10
  %384 = load ptr, ptr %6, align 8, !tbaa !5
  %385 = getelementptr inbounds %struct.seed_key_st, ptr %384, i32 0, i32 0
  %386 = getelementptr inbounds [32 x i32], ptr %385, i64 0, i64 26
  %387 = load i32, ptr %386, align 4, !tbaa !10
  %388 = xor i32 %383, %387
  store i32 %388, ptr %11, align 4, !tbaa !10
  %389 = load i32, ptr %10, align 4, !tbaa !10
  %390 = load ptr, ptr %6, align 8, !tbaa !5
  %391 = getelementptr inbounds %struct.seed_key_st, ptr %390, i32 0, i32 0
  %392 = getelementptr inbounds [32 x i32], ptr %391, i64 0, i64 27
  %393 = load i32, ptr %392, align 4, !tbaa !10
  %394 = xor i32 %389, %393
  store i32 %394, ptr %12, align 4, !tbaa !10
  %395 = load i32, ptr %11, align 4, !tbaa !10
  %396 = load i32, ptr %12, align 4, !tbaa !10
  %397 = xor i32 %396, %395
  store i32 %397, ptr %12, align 4, !tbaa !10
  %398 = load i32, ptr %12, align 4, !tbaa !10
  %399 = trunc i32 %398 to i8
  %400 = zext i8 %399 to i32
  %401 = and i32 %400, 255
  %402 = sext i32 %401 to i64
  %403 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %402
  %404 = load i32, ptr %403, align 4, !tbaa !10
  %405 = load i32, ptr %12, align 4, !tbaa !10
  %406 = lshr i32 %405, 8
  %407 = trunc i32 %406 to i8
  %408 = zext i8 %407 to i32
  %409 = and i32 %408, 255
  %410 = sext i32 %409 to i64
  %411 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %410
  %412 = load i32, ptr %411, align 4, !tbaa !10
  %413 = xor i32 %404, %412
  %414 = load i32, ptr %12, align 4, !tbaa !10
  %415 = lshr i32 %414, 16
  %416 = trunc i32 %415 to i8
  %417 = zext i8 %416 to i32
  %418 = and i32 %417, 255
  %419 = sext i32 %418 to i64
  %420 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %419
  %421 = load i32, ptr %420, align 4, !tbaa !10
  %422 = xor i32 %413, %421
  %423 = load i32, ptr %12, align 4, !tbaa !10
  %424 = lshr i32 %423, 24
  %425 = trunc i32 %424 to i8
  %426 = zext i8 %425 to i32
  %427 = and i32 %426, 255
  %428 = sext i32 %427 to i64
  %429 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %428
  %430 = load i32, ptr %429, align 4, !tbaa !10
  %431 = xor i32 %422, %430
  store i32 %431, ptr %12, align 4, !tbaa !10
  %432 = load i32, ptr %11, align 4, !tbaa !10
  %433 = load i32, ptr %12, align 4, !tbaa !10
  %434 = add i32 %432, %433
  %435 = and i32 %434, -1
  store i32 %435, ptr %11, align 4, !tbaa !10
  %436 = load i32, ptr %11, align 4, !tbaa !10
  %437 = trunc i32 %436 to i8
  %438 = zext i8 %437 to i32
  %439 = and i32 %438, 255
  %440 = sext i32 %439 to i64
  %441 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %440
  %442 = load i32, ptr %441, align 4, !tbaa !10
  %443 = load i32, ptr %11, align 4, !tbaa !10
  %444 = lshr i32 %443, 8
  %445 = trunc i32 %444 to i8
  %446 = zext i8 %445 to i32
  %447 = and i32 %446, 255
  %448 = sext i32 %447 to i64
  %449 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %448
  %450 = load i32, ptr %449, align 4, !tbaa !10
  %451 = xor i32 %442, %450
  %452 = load i32, ptr %11, align 4, !tbaa !10
  %453 = lshr i32 %452, 16
  %454 = trunc i32 %453 to i8
  %455 = zext i8 %454 to i32
  %456 = and i32 %455, 255
  %457 = sext i32 %456 to i64
  %458 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %457
  %459 = load i32, ptr %458, align 4, !tbaa !10
  %460 = xor i32 %451, %459
  %461 = load i32, ptr %11, align 4, !tbaa !10
  %462 = lshr i32 %461, 24
  %463 = trunc i32 %462 to i8
  %464 = zext i8 %463 to i32
  %465 = and i32 %464, 255
  %466 = sext i32 %465 to i64
  %467 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %466
  %468 = load i32, ptr %467, align 4, !tbaa !10
  %469 = xor i32 %460, %468
  store i32 %469, ptr %11, align 4, !tbaa !10
  %470 = load i32, ptr %12, align 4, !tbaa !10
  %471 = load i32, ptr %11, align 4, !tbaa !10
  %472 = add i32 %470, %471
  %473 = and i32 %472, -1
  store i32 %473, ptr %12, align 4, !tbaa !10
  %474 = load i32, ptr %12, align 4, !tbaa !10
  %475 = trunc i32 %474 to i8
  %476 = zext i8 %475 to i32
  %477 = and i32 %476, 255
  %478 = sext i32 %477 to i64
  %479 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %478
  %480 = load i32, ptr %479, align 4, !tbaa !10
  %481 = load i32, ptr %12, align 4, !tbaa !10
  %482 = lshr i32 %481, 8
  %483 = trunc i32 %482 to i8
  %484 = zext i8 %483 to i32
  %485 = and i32 %484, 255
  %486 = sext i32 %485 to i64
  %487 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %486
  %488 = load i32, ptr %487, align 4, !tbaa !10
  %489 = xor i32 %480, %488
  %490 = load i32, ptr %12, align 4, !tbaa !10
  %491 = lshr i32 %490, 16
  %492 = trunc i32 %491 to i8
  %493 = zext i8 %492 to i32
  %494 = and i32 %493, 255
  %495 = sext i32 %494 to i64
  %496 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %495
  %497 = load i32, ptr %496, align 4, !tbaa !10
  %498 = xor i32 %489, %497
  %499 = load i32, ptr %12, align 4, !tbaa !10
  %500 = lshr i32 %499, 24
  %501 = trunc i32 %500 to i8
  %502 = zext i8 %501 to i32
  %503 = and i32 %502, 255
  %504 = sext i32 %503 to i64
  %505 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %504
  %506 = load i32, ptr %505, align 4, !tbaa !10
  %507 = xor i32 %498, %506
  store i32 %507, ptr %12, align 4, !tbaa !10
  %508 = load i32, ptr %11, align 4, !tbaa !10
  %509 = load i32, ptr %12, align 4, !tbaa !10
  %510 = add i32 %508, %509
  %511 = and i32 %510, -1
  store i32 %511, ptr %11, align 4, !tbaa !10
  %512 = load i32, ptr %11, align 4, !tbaa !10
  %513 = load i32, ptr %7, align 4, !tbaa !10
  %514 = xor i32 %513, %512
  store i32 %514, ptr %7, align 4, !tbaa !10
  %515 = load i32, ptr %12, align 4, !tbaa !10
  %516 = load i32, ptr %8, align 4, !tbaa !10
  %517 = xor i32 %516, %515
  store i32 %517, ptr %8, align 4, !tbaa !10
  %518 = load i32, ptr %7, align 4, !tbaa !10
  %519 = load ptr, ptr %6, align 8, !tbaa !5
  %520 = getelementptr inbounds %struct.seed_key_st, ptr %519, i32 0, i32 0
  %521 = getelementptr inbounds [32 x i32], ptr %520, i64 0, i64 24
  %522 = load i32, ptr %521, align 4, !tbaa !10
  %523 = xor i32 %518, %522
  store i32 %523, ptr %11, align 4, !tbaa !10
  %524 = load i32, ptr %8, align 4, !tbaa !10
  %525 = load ptr, ptr %6, align 8, !tbaa !5
  %526 = getelementptr inbounds %struct.seed_key_st, ptr %525, i32 0, i32 0
  %527 = getelementptr inbounds [32 x i32], ptr %526, i64 0, i64 25
  %528 = load i32, ptr %527, align 4, !tbaa !10
  %529 = xor i32 %524, %528
  store i32 %529, ptr %12, align 4, !tbaa !10
  %530 = load i32, ptr %11, align 4, !tbaa !10
  %531 = load i32, ptr %12, align 4, !tbaa !10
  %532 = xor i32 %531, %530
  store i32 %532, ptr %12, align 4, !tbaa !10
  %533 = load i32, ptr %12, align 4, !tbaa !10
  %534 = trunc i32 %533 to i8
  %535 = zext i8 %534 to i32
  %536 = and i32 %535, 255
  %537 = sext i32 %536 to i64
  %538 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %537
  %539 = load i32, ptr %538, align 4, !tbaa !10
  %540 = load i32, ptr %12, align 4, !tbaa !10
  %541 = lshr i32 %540, 8
  %542 = trunc i32 %541 to i8
  %543 = zext i8 %542 to i32
  %544 = and i32 %543, 255
  %545 = sext i32 %544 to i64
  %546 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %545
  %547 = load i32, ptr %546, align 4, !tbaa !10
  %548 = xor i32 %539, %547
  %549 = load i32, ptr %12, align 4, !tbaa !10
  %550 = lshr i32 %549, 16
  %551 = trunc i32 %550 to i8
  %552 = zext i8 %551 to i32
  %553 = and i32 %552, 255
  %554 = sext i32 %553 to i64
  %555 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %554
  %556 = load i32, ptr %555, align 4, !tbaa !10
  %557 = xor i32 %548, %556
  %558 = load i32, ptr %12, align 4, !tbaa !10
  %559 = lshr i32 %558, 24
  %560 = trunc i32 %559 to i8
  %561 = zext i8 %560 to i32
  %562 = and i32 %561, 255
  %563 = sext i32 %562 to i64
  %564 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %563
  %565 = load i32, ptr %564, align 4, !tbaa !10
  %566 = xor i32 %557, %565
  store i32 %566, ptr %12, align 4, !tbaa !10
  %567 = load i32, ptr %11, align 4, !tbaa !10
  %568 = load i32, ptr %12, align 4, !tbaa !10
  %569 = add i32 %567, %568
  %570 = and i32 %569, -1
  store i32 %570, ptr %11, align 4, !tbaa !10
  %571 = load i32, ptr %11, align 4, !tbaa !10
  %572 = trunc i32 %571 to i8
  %573 = zext i8 %572 to i32
  %574 = and i32 %573, 255
  %575 = sext i32 %574 to i64
  %576 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %575
  %577 = load i32, ptr %576, align 4, !tbaa !10
  %578 = load i32, ptr %11, align 4, !tbaa !10
  %579 = lshr i32 %578, 8
  %580 = trunc i32 %579 to i8
  %581 = zext i8 %580 to i32
  %582 = and i32 %581, 255
  %583 = sext i32 %582 to i64
  %584 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %583
  %585 = load i32, ptr %584, align 4, !tbaa !10
  %586 = xor i32 %577, %585
  %587 = load i32, ptr %11, align 4, !tbaa !10
  %588 = lshr i32 %587, 16
  %589 = trunc i32 %588 to i8
  %590 = zext i8 %589 to i32
  %591 = and i32 %590, 255
  %592 = sext i32 %591 to i64
  %593 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %592
  %594 = load i32, ptr %593, align 4, !tbaa !10
  %595 = xor i32 %586, %594
  %596 = load i32, ptr %11, align 4, !tbaa !10
  %597 = lshr i32 %596, 24
  %598 = trunc i32 %597 to i8
  %599 = zext i8 %598 to i32
  %600 = and i32 %599, 255
  %601 = sext i32 %600 to i64
  %602 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %601
  %603 = load i32, ptr %602, align 4, !tbaa !10
  %604 = xor i32 %595, %603
  store i32 %604, ptr %11, align 4, !tbaa !10
  %605 = load i32, ptr %12, align 4, !tbaa !10
  %606 = load i32, ptr %11, align 4, !tbaa !10
  %607 = add i32 %605, %606
  %608 = and i32 %607, -1
  store i32 %608, ptr %12, align 4, !tbaa !10
  %609 = load i32, ptr %12, align 4, !tbaa !10
  %610 = trunc i32 %609 to i8
  %611 = zext i8 %610 to i32
  %612 = and i32 %611, 255
  %613 = sext i32 %612 to i64
  %614 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %613
  %615 = load i32, ptr %614, align 4, !tbaa !10
  %616 = load i32, ptr %12, align 4, !tbaa !10
  %617 = lshr i32 %616, 8
  %618 = trunc i32 %617 to i8
  %619 = zext i8 %618 to i32
  %620 = and i32 %619, 255
  %621 = sext i32 %620 to i64
  %622 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %621
  %623 = load i32, ptr %622, align 4, !tbaa !10
  %624 = xor i32 %615, %623
  %625 = load i32, ptr %12, align 4, !tbaa !10
  %626 = lshr i32 %625, 16
  %627 = trunc i32 %626 to i8
  %628 = zext i8 %627 to i32
  %629 = and i32 %628, 255
  %630 = sext i32 %629 to i64
  %631 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %630
  %632 = load i32, ptr %631, align 4, !tbaa !10
  %633 = xor i32 %624, %632
  %634 = load i32, ptr %12, align 4, !tbaa !10
  %635 = lshr i32 %634, 24
  %636 = trunc i32 %635 to i8
  %637 = zext i8 %636 to i32
  %638 = and i32 %637, 255
  %639 = sext i32 %638 to i64
  %640 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %639
  %641 = load i32, ptr %640, align 4, !tbaa !10
  %642 = xor i32 %633, %641
  store i32 %642, ptr %12, align 4, !tbaa !10
  %643 = load i32, ptr %11, align 4, !tbaa !10
  %644 = load i32, ptr %12, align 4, !tbaa !10
  %645 = add i32 %643, %644
  %646 = and i32 %645, -1
  store i32 %646, ptr %11, align 4, !tbaa !10
  %647 = load i32, ptr %11, align 4, !tbaa !10
  %648 = load i32, ptr %9, align 4, !tbaa !10
  %649 = xor i32 %648, %647
  store i32 %649, ptr %9, align 4, !tbaa !10
  %650 = load i32, ptr %12, align 4, !tbaa !10
  %651 = load i32, ptr %10, align 4, !tbaa !10
  %652 = xor i32 %651, %650
  store i32 %652, ptr %10, align 4, !tbaa !10
  %653 = load i32, ptr %9, align 4, !tbaa !10
  %654 = load ptr, ptr %6, align 8, !tbaa !5
  %655 = getelementptr inbounds %struct.seed_key_st, ptr %654, i32 0, i32 0
  %656 = getelementptr inbounds [32 x i32], ptr %655, i64 0, i64 22
  %657 = load i32, ptr %656, align 4, !tbaa !10
  %658 = xor i32 %653, %657
  store i32 %658, ptr %11, align 4, !tbaa !10
  %659 = load i32, ptr %10, align 4, !tbaa !10
  %660 = load ptr, ptr %6, align 8, !tbaa !5
  %661 = getelementptr inbounds %struct.seed_key_st, ptr %660, i32 0, i32 0
  %662 = getelementptr inbounds [32 x i32], ptr %661, i64 0, i64 23
  %663 = load i32, ptr %662, align 4, !tbaa !10
  %664 = xor i32 %659, %663
  store i32 %664, ptr %12, align 4, !tbaa !10
  %665 = load i32, ptr %11, align 4, !tbaa !10
  %666 = load i32, ptr %12, align 4, !tbaa !10
  %667 = xor i32 %666, %665
  store i32 %667, ptr %12, align 4, !tbaa !10
  %668 = load i32, ptr %12, align 4, !tbaa !10
  %669 = trunc i32 %668 to i8
  %670 = zext i8 %669 to i32
  %671 = and i32 %670, 255
  %672 = sext i32 %671 to i64
  %673 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %672
  %674 = load i32, ptr %673, align 4, !tbaa !10
  %675 = load i32, ptr %12, align 4, !tbaa !10
  %676 = lshr i32 %675, 8
  %677 = trunc i32 %676 to i8
  %678 = zext i8 %677 to i32
  %679 = and i32 %678, 255
  %680 = sext i32 %679 to i64
  %681 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %680
  %682 = load i32, ptr %681, align 4, !tbaa !10
  %683 = xor i32 %674, %682
  %684 = load i32, ptr %12, align 4, !tbaa !10
  %685 = lshr i32 %684, 16
  %686 = trunc i32 %685 to i8
  %687 = zext i8 %686 to i32
  %688 = and i32 %687, 255
  %689 = sext i32 %688 to i64
  %690 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %689
  %691 = load i32, ptr %690, align 4, !tbaa !10
  %692 = xor i32 %683, %691
  %693 = load i32, ptr %12, align 4, !tbaa !10
  %694 = lshr i32 %693, 24
  %695 = trunc i32 %694 to i8
  %696 = zext i8 %695 to i32
  %697 = and i32 %696, 255
  %698 = sext i32 %697 to i64
  %699 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %698
  %700 = load i32, ptr %699, align 4, !tbaa !10
  %701 = xor i32 %692, %700
  store i32 %701, ptr %12, align 4, !tbaa !10
  %702 = load i32, ptr %11, align 4, !tbaa !10
  %703 = load i32, ptr %12, align 4, !tbaa !10
  %704 = add i32 %702, %703
  %705 = and i32 %704, -1
  store i32 %705, ptr %11, align 4, !tbaa !10
  %706 = load i32, ptr %11, align 4, !tbaa !10
  %707 = trunc i32 %706 to i8
  %708 = zext i8 %707 to i32
  %709 = and i32 %708, 255
  %710 = sext i32 %709 to i64
  %711 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %710
  %712 = load i32, ptr %711, align 4, !tbaa !10
  %713 = load i32, ptr %11, align 4, !tbaa !10
  %714 = lshr i32 %713, 8
  %715 = trunc i32 %714 to i8
  %716 = zext i8 %715 to i32
  %717 = and i32 %716, 255
  %718 = sext i32 %717 to i64
  %719 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %718
  %720 = load i32, ptr %719, align 4, !tbaa !10
  %721 = xor i32 %712, %720
  %722 = load i32, ptr %11, align 4, !tbaa !10
  %723 = lshr i32 %722, 16
  %724 = trunc i32 %723 to i8
  %725 = zext i8 %724 to i32
  %726 = and i32 %725, 255
  %727 = sext i32 %726 to i64
  %728 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %727
  %729 = load i32, ptr %728, align 4, !tbaa !10
  %730 = xor i32 %721, %729
  %731 = load i32, ptr %11, align 4, !tbaa !10
  %732 = lshr i32 %731, 24
  %733 = trunc i32 %732 to i8
  %734 = zext i8 %733 to i32
  %735 = and i32 %734, 255
  %736 = sext i32 %735 to i64
  %737 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %736
  %738 = load i32, ptr %737, align 4, !tbaa !10
  %739 = xor i32 %730, %738
  store i32 %739, ptr %11, align 4, !tbaa !10
  %740 = load i32, ptr %12, align 4, !tbaa !10
  %741 = load i32, ptr %11, align 4, !tbaa !10
  %742 = add i32 %740, %741
  %743 = and i32 %742, -1
  store i32 %743, ptr %12, align 4, !tbaa !10
  %744 = load i32, ptr %12, align 4, !tbaa !10
  %745 = trunc i32 %744 to i8
  %746 = zext i8 %745 to i32
  %747 = and i32 %746, 255
  %748 = sext i32 %747 to i64
  %749 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %748
  %750 = load i32, ptr %749, align 4, !tbaa !10
  %751 = load i32, ptr %12, align 4, !tbaa !10
  %752 = lshr i32 %751, 8
  %753 = trunc i32 %752 to i8
  %754 = zext i8 %753 to i32
  %755 = and i32 %754, 255
  %756 = sext i32 %755 to i64
  %757 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %756
  %758 = load i32, ptr %757, align 4, !tbaa !10
  %759 = xor i32 %750, %758
  %760 = load i32, ptr %12, align 4, !tbaa !10
  %761 = lshr i32 %760, 16
  %762 = trunc i32 %761 to i8
  %763 = zext i8 %762 to i32
  %764 = and i32 %763, 255
  %765 = sext i32 %764 to i64
  %766 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %765
  %767 = load i32, ptr %766, align 4, !tbaa !10
  %768 = xor i32 %759, %767
  %769 = load i32, ptr %12, align 4, !tbaa !10
  %770 = lshr i32 %769, 24
  %771 = trunc i32 %770 to i8
  %772 = zext i8 %771 to i32
  %773 = and i32 %772, 255
  %774 = sext i32 %773 to i64
  %775 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %774
  %776 = load i32, ptr %775, align 4, !tbaa !10
  %777 = xor i32 %768, %776
  store i32 %777, ptr %12, align 4, !tbaa !10
  %778 = load i32, ptr %11, align 4, !tbaa !10
  %779 = load i32, ptr %12, align 4, !tbaa !10
  %780 = add i32 %778, %779
  %781 = and i32 %780, -1
  store i32 %781, ptr %11, align 4, !tbaa !10
  %782 = load i32, ptr %11, align 4, !tbaa !10
  %783 = load i32, ptr %7, align 4, !tbaa !10
  %784 = xor i32 %783, %782
  store i32 %784, ptr %7, align 4, !tbaa !10
  %785 = load i32, ptr %12, align 4, !tbaa !10
  %786 = load i32, ptr %8, align 4, !tbaa !10
  %787 = xor i32 %786, %785
  store i32 %787, ptr %8, align 4, !tbaa !10
  %788 = load i32, ptr %7, align 4, !tbaa !10
  %789 = load ptr, ptr %6, align 8, !tbaa !5
  %790 = getelementptr inbounds %struct.seed_key_st, ptr %789, i32 0, i32 0
  %791 = getelementptr inbounds [32 x i32], ptr %790, i64 0, i64 20
  %792 = load i32, ptr %791, align 4, !tbaa !10
  %793 = xor i32 %788, %792
  store i32 %793, ptr %11, align 4, !tbaa !10
  %794 = load i32, ptr %8, align 4, !tbaa !10
  %795 = load ptr, ptr %6, align 8, !tbaa !5
  %796 = getelementptr inbounds %struct.seed_key_st, ptr %795, i32 0, i32 0
  %797 = getelementptr inbounds [32 x i32], ptr %796, i64 0, i64 21
  %798 = load i32, ptr %797, align 4, !tbaa !10
  %799 = xor i32 %794, %798
  store i32 %799, ptr %12, align 4, !tbaa !10
  %800 = load i32, ptr %11, align 4, !tbaa !10
  %801 = load i32, ptr %12, align 4, !tbaa !10
  %802 = xor i32 %801, %800
  store i32 %802, ptr %12, align 4, !tbaa !10
  %803 = load i32, ptr %12, align 4, !tbaa !10
  %804 = trunc i32 %803 to i8
  %805 = zext i8 %804 to i32
  %806 = and i32 %805, 255
  %807 = sext i32 %806 to i64
  %808 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %807
  %809 = load i32, ptr %808, align 4, !tbaa !10
  %810 = load i32, ptr %12, align 4, !tbaa !10
  %811 = lshr i32 %810, 8
  %812 = trunc i32 %811 to i8
  %813 = zext i8 %812 to i32
  %814 = and i32 %813, 255
  %815 = sext i32 %814 to i64
  %816 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %815
  %817 = load i32, ptr %816, align 4, !tbaa !10
  %818 = xor i32 %809, %817
  %819 = load i32, ptr %12, align 4, !tbaa !10
  %820 = lshr i32 %819, 16
  %821 = trunc i32 %820 to i8
  %822 = zext i8 %821 to i32
  %823 = and i32 %822, 255
  %824 = sext i32 %823 to i64
  %825 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %824
  %826 = load i32, ptr %825, align 4, !tbaa !10
  %827 = xor i32 %818, %826
  %828 = load i32, ptr %12, align 4, !tbaa !10
  %829 = lshr i32 %828, 24
  %830 = trunc i32 %829 to i8
  %831 = zext i8 %830 to i32
  %832 = and i32 %831, 255
  %833 = sext i32 %832 to i64
  %834 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %833
  %835 = load i32, ptr %834, align 4, !tbaa !10
  %836 = xor i32 %827, %835
  store i32 %836, ptr %12, align 4, !tbaa !10
  %837 = load i32, ptr %11, align 4, !tbaa !10
  %838 = load i32, ptr %12, align 4, !tbaa !10
  %839 = add i32 %837, %838
  %840 = and i32 %839, -1
  store i32 %840, ptr %11, align 4, !tbaa !10
  %841 = load i32, ptr %11, align 4, !tbaa !10
  %842 = trunc i32 %841 to i8
  %843 = zext i8 %842 to i32
  %844 = and i32 %843, 255
  %845 = sext i32 %844 to i64
  %846 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %845
  %847 = load i32, ptr %846, align 4, !tbaa !10
  %848 = load i32, ptr %11, align 4, !tbaa !10
  %849 = lshr i32 %848, 8
  %850 = trunc i32 %849 to i8
  %851 = zext i8 %850 to i32
  %852 = and i32 %851, 255
  %853 = sext i32 %852 to i64
  %854 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %853
  %855 = load i32, ptr %854, align 4, !tbaa !10
  %856 = xor i32 %847, %855
  %857 = load i32, ptr %11, align 4, !tbaa !10
  %858 = lshr i32 %857, 16
  %859 = trunc i32 %858 to i8
  %860 = zext i8 %859 to i32
  %861 = and i32 %860, 255
  %862 = sext i32 %861 to i64
  %863 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %862
  %864 = load i32, ptr %863, align 4, !tbaa !10
  %865 = xor i32 %856, %864
  %866 = load i32, ptr %11, align 4, !tbaa !10
  %867 = lshr i32 %866, 24
  %868 = trunc i32 %867 to i8
  %869 = zext i8 %868 to i32
  %870 = and i32 %869, 255
  %871 = sext i32 %870 to i64
  %872 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %871
  %873 = load i32, ptr %872, align 4, !tbaa !10
  %874 = xor i32 %865, %873
  store i32 %874, ptr %11, align 4, !tbaa !10
  %875 = load i32, ptr %12, align 4, !tbaa !10
  %876 = load i32, ptr %11, align 4, !tbaa !10
  %877 = add i32 %875, %876
  %878 = and i32 %877, -1
  store i32 %878, ptr %12, align 4, !tbaa !10
  %879 = load i32, ptr %12, align 4, !tbaa !10
  %880 = trunc i32 %879 to i8
  %881 = zext i8 %880 to i32
  %882 = and i32 %881, 255
  %883 = sext i32 %882 to i64
  %884 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %883
  %885 = load i32, ptr %884, align 4, !tbaa !10
  %886 = load i32, ptr %12, align 4, !tbaa !10
  %887 = lshr i32 %886, 8
  %888 = trunc i32 %887 to i8
  %889 = zext i8 %888 to i32
  %890 = and i32 %889, 255
  %891 = sext i32 %890 to i64
  %892 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %891
  %893 = load i32, ptr %892, align 4, !tbaa !10
  %894 = xor i32 %885, %893
  %895 = load i32, ptr %12, align 4, !tbaa !10
  %896 = lshr i32 %895, 16
  %897 = trunc i32 %896 to i8
  %898 = zext i8 %897 to i32
  %899 = and i32 %898, 255
  %900 = sext i32 %899 to i64
  %901 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %900
  %902 = load i32, ptr %901, align 4, !tbaa !10
  %903 = xor i32 %894, %902
  %904 = load i32, ptr %12, align 4, !tbaa !10
  %905 = lshr i32 %904, 24
  %906 = trunc i32 %905 to i8
  %907 = zext i8 %906 to i32
  %908 = and i32 %907, 255
  %909 = sext i32 %908 to i64
  %910 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %909
  %911 = load i32, ptr %910, align 4, !tbaa !10
  %912 = xor i32 %903, %911
  store i32 %912, ptr %12, align 4, !tbaa !10
  %913 = load i32, ptr %11, align 4, !tbaa !10
  %914 = load i32, ptr %12, align 4, !tbaa !10
  %915 = add i32 %913, %914
  %916 = and i32 %915, -1
  store i32 %916, ptr %11, align 4, !tbaa !10
  %917 = load i32, ptr %11, align 4, !tbaa !10
  %918 = load i32, ptr %9, align 4, !tbaa !10
  %919 = xor i32 %918, %917
  store i32 %919, ptr %9, align 4, !tbaa !10
  %920 = load i32, ptr %12, align 4, !tbaa !10
  %921 = load i32, ptr %10, align 4, !tbaa !10
  %922 = xor i32 %921, %920
  store i32 %922, ptr %10, align 4, !tbaa !10
  %923 = load i32, ptr %9, align 4, !tbaa !10
  %924 = load ptr, ptr %6, align 8, !tbaa !5
  %925 = getelementptr inbounds %struct.seed_key_st, ptr %924, i32 0, i32 0
  %926 = getelementptr inbounds [32 x i32], ptr %925, i64 0, i64 18
  %927 = load i32, ptr %926, align 4, !tbaa !10
  %928 = xor i32 %923, %927
  store i32 %928, ptr %11, align 4, !tbaa !10
  %929 = load i32, ptr %10, align 4, !tbaa !10
  %930 = load ptr, ptr %6, align 8, !tbaa !5
  %931 = getelementptr inbounds %struct.seed_key_st, ptr %930, i32 0, i32 0
  %932 = getelementptr inbounds [32 x i32], ptr %931, i64 0, i64 19
  %933 = load i32, ptr %932, align 4, !tbaa !10
  %934 = xor i32 %929, %933
  store i32 %934, ptr %12, align 4, !tbaa !10
  %935 = load i32, ptr %11, align 4, !tbaa !10
  %936 = load i32, ptr %12, align 4, !tbaa !10
  %937 = xor i32 %936, %935
  store i32 %937, ptr %12, align 4, !tbaa !10
  %938 = load i32, ptr %12, align 4, !tbaa !10
  %939 = trunc i32 %938 to i8
  %940 = zext i8 %939 to i32
  %941 = and i32 %940, 255
  %942 = sext i32 %941 to i64
  %943 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %942
  %944 = load i32, ptr %943, align 4, !tbaa !10
  %945 = load i32, ptr %12, align 4, !tbaa !10
  %946 = lshr i32 %945, 8
  %947 = trunc i32 %946 to i8
  %948 = zext i8 %947 to i32
  %949 = and i32 %948, 255
  %950 = sext i32 %949 to i64
  %951 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %950
  %952 = load i32, ptr %951, align 4, !tbaa !10
  %953 = xor i32 %944, %952
  %954 = load i32, ptr %12, align 4, !tbaa !10
  %955 = lshr i32 %954, 16
  %956 = trunc i32 %955 to i8
  %957 = zext i8 %956 to i32
  %958 = and i32 %957, 255
  %959 = sext i32 %958 to i64
  %960 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %959
  %961 = load i32, ptr %960, align 4, !tbaa !10
  %962 = xor i32 %953, %961
  %963 = load i32, ptr %12, align 4, !tbaa !10
  %964 = lshr i32 %963, 24
  %965 = trunc i32 %964 to i8
  %966 = zext i8 %965 to i32
  %967 = and i32 %966, 255
  %968 = sext i32 %967 to i64
  %969 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %968
  %970 = load i32, ptr %969, align 4, !tbaa !10
  %971 = xor i32 %962, %970
  store i32 %971, ptr %12, align 4, !tbaa !10
  %972 = load i32, ptr %11, align 4, !tbaa !10
  %973 = load i32, ptr %12, align 4, !tbaa !10
  %974 = add i32 %972, %973
  %975 = and i32 %974, -1
  store i32 %975, ptr %11, align 4, !tbaa !10
  %976 = load i32, ptr %11, align 4, !tbaa !10
  %977 = trunc i32 %976 to i8
  %978 = zext i8 %977 to i32
  %979 = and i32 %978, 255
  %980 = sext i32 %979 to i64
  %981 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %980
  %982 = load i32, ptr %981, align 4, !tbaa !10
  %983 = load i32, ptr %11, align 4, !tbaa !10
  %984 = lshr i32 %983, 8
  %985 = trunc i32 %984 to i8
  %986 = zext i8 %985 to i32
  %987 = and i32 %986, 255
  %988 = sext i32 %987 to i64
  %989 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %988
  %990 = load i32, ptr %989, align 4, !tbaa !10
  %991 = xor i32 %982, %990
  %992 = load i32, ptr %11, align 4, !tbaa !10
  %993 = lshr i32 %992, 16
  %994 = trunc i32 %993 to i8
  %995 = zext i8 %994 to i32
  %996 = and i32 %995, 255
  %997 = sext i32 %996 to i64
  %998 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %997
  %999 = load i32, ptr %998, align 4, !tbaa !10
  %1000 = xor i32 %991, %999
  %1001 = load i32, ptr %11, align 4, !tbaa !10
  %1002 = lshr i32 %1001, 24
  %1003 = trunc i32 %1002 to i8
  %1004 = zext i8 %1003 to i32
  %1005 = and i32 %1004, 255
  %1006 = sext i32 %1005 to i64
  %1007 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1006
  %1008 = load i32, ptr %1007, align 4, !tbaa !10
  %1009 = xor i32 %1000, %1008
  store i32 %1009, ptr %11, align 4, !tbaa !10
  %1010 = load i32, ptr %12, align 4, !tbaa !10
  %1011 = load i32, ptr %11, align 4, !tbaa !10
  %1012 = add i32 %1010, %1011
  %1013 = and i32 %1012, -1
  store i32 %1013, ptr %12, align 4, !tbaa !10
  %1014 = load i32, ptr %12, align 4, !tbaa !10
  %1015 = trunc i32 %1014 to i8
  %1016 = zext i8 %1015 to i32
  %1017 = and i32 %1016, 255
  %1018 = sext i32 %1017 to i64
  %1019 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1018
  %1020 = load i32, ptr %1019, align 4, !tbaa !10
  %1021 = load i32, ptr %12, align 4, !tbaa !10
  %1022 = lshr i32 %1021, 8
  %1023 = trunc i32 %1022 to i8
  %1024 = zext i8 %1023 to i32
  %1025 = and i32 %1024, 255
  %1026 = sext i32 %1025 to i64
  %1027 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1026
  %1028 = load i32, ptr %1027, align 4, !tbaa !10
  %1029 = xor i32 %1020, %1028
  %1030 = load i32, ptr %12, align 4, !tbaa !10
  %1031 = lshr i32 %1030, 16
  %1032 = trunc i32 %1031 to i8
  %1033 = zext i8 %1032 to i32
  %1034 = and i32 %1033, 255
  %1035 = sext i32 %1034 to i64
  %1036 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1035
  %1037 = load i32, ptr %1036, align 4, !tbaa !10
  %1038 = xor i32 %1029, %1037
  %1039 = load i32, ptr %12, align 4, !tbaa !10
  %1040 = lshr i32 %1039, 24
  %1041 = trunc i32 %1040 to i8
  %1042 = zext i8 %1041 to i32
  %1043 = and i32 %1042, 255
  %1044 = sext i32 %1043 to i64
  %1045 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1044
  %1046 = load i32, ptr %1045, align 4, !tbaa !10
  %1047 = xor i32 %1038, %1046
  store i32 %1047, ptr %12, align 4, !tbaa !10
  %1048 = load i32, ptr %11, align 4, !tbaa !10
  %1049 = load i32, ptr %12, align 4, !tbaa !10
  %1050 = add i32 %1048, %1049
  %1051 = and i32 %1050, -1
  store i32 %1051, ptr %11, align 4, !tbaa !10
  %1052 = load i32, ptr %11, align 4, !tbaa !10
  %1053 = load i32, ptr %7, align 4, !tbaa !10
  %1054 = xor i32 %1053, %1052
  store i32 %1054, ptr %7, align 4, !tbaa !10
  %1055 = load i32, ptr %12, align 4, !tbaa !10
  %1056 = load i32, ptr %8, align 4, !tbaa !10
  %1057 = xor i32 %1056, %1055
  store i32 %1057, ptr %8, align 4, !tbaa !10
  %1058 = load i32, ptr %7, align 4, !tbaa !10
  %1059 = load ptr, ptr %6, align 8, !tbaa !5
  %1060 = getelementptr inbounds %struct.seed_key_st, ptr %1059, i32 0, i32 0
  %1061 = getelementptr inbounds [32 x i32], ptr %1060, i64 0, i64 16
  %1062 = load i32, ptr %1061, align 4, !tbaa !10
  %1063 = xor i32 %1058, %1062
  store i32 %1063, ptr %11, align 4, !tbaa !10
  %1064 = load i32, ptr %8, align 4, !tbaa !10
  %1065 = load ptr, ptr %6, align 8, !tbaa !5
  %1066 = getelementptr inbounds %struct.seed_key_st, ptr %1065, i32 0, i32 0
  %1067 = getelementptr inbounds [32 x i32], ptr %1066, i64 0, i64 17
  %1068 = load i32, ptr %1067, align 4, !tbaa !10
  %1069 = xor i32 %1064, %1068
  store i32 %1069, ptr %12, align 4, !tbaa !10
  %1070 = load i32, ptr %11, align 4, !tbaa !10
  %1071 = load i32, ptr %12, align 4, !tbaa !10
  %1072 = xor i32 %1071, %1070
  store i32 %1072, ptr %12, align 4, !tbaa !10
  %1073 = load i32, ptr %12, align 4, !tbaa !10
  %1074 = trunc i32 %1073 to i8
  %1075 = zext i8 %1074 to i32
  %1076 = and i32 %1075, 255
  %1077 = sext i32 %1076 to i64
  %1078 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1077
  %1079 = load i32, ptr %1078, align 4, !tbaa !10
  %1080 = load i32, ptr %12, align 4, !tbaa !10
  %1081 = lshr i32 %1080, 8
  %1082 = trunc i32 %1081 to i8
  %1083 = zext i8 %1082 to i32
  %1084 = and i32 %1083, 255
  %1085 = sext i32 %1084 to i64
  %1086 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1085
  %1087 = load i32, ptr %1086, align 4, !tbaa !10
  %1088 = xor i32 %1079, %1087
  %1089 = load i32, ptr %12, align 4, !tbaa !10
  %1090 = lshr i32 %1089, 16
  %1091 = trunc i32 %1090 to i8
  %1092 = zext i8 %1091 to i32
  %1093 = and i32 %1092, 255
  %1094 = sext i32 %1093 to i64
  %1095 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1094
  %1096 = load i32, ptr %1095, align 4, !tbaa !10
  %1097 = xor i32 %1088, %1096
  %1098 = load i32, ptr %12, align 4, !tbaa !10
  %1099 = lshr i32 %1098, 24
  %1100 = trunc i32 %1099 to i8
  %1101 = zext i8 %1100 to i32
  %1102 = and i32 %1101, 255
  %1103 = sext i32 %1102 to i64
  %1104 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1103
  %1105 = load i32, ptr %1104, align 4, !tbaa !10
  %1106 = xor i32 %1097, %1105
  store i32 %1106, ptr %12, align 4, !tbaa !10
  %1107 = load i32, ptr %11, align 4, !tbaa !10
  %1108 = load i32, ptr %12, align 4, !tbaa !10
  %1109 = add i32 %1107, %1108
  %1110 = and i32 %1109, -1
  store i32 %1110, ptr %11, align 4, !tbaa !10
  %1111 = load i32, ptr %11, align 4, !tbaa !10
  %1112 = trunc i32 %1111 to i8
  %1113 = zext i8 %1112 to i32
  %1114 = and i32 %1113, 255
  %1115 = sext i32 %1114 to i64
  %1116 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1115
  %1117 = load i32, ptr %1116, align 4, !tbaa !10
  %1118 = load i32, ptr %11, align 4, !tbaa !10
  %1119 = lshr i32 %1118, 8
  %1120 = trunc i32 %1119 to i8
  %1121 = zext i8 %1120 to i32
  %1122 = and i32 %1121, 255
  %1123 = sext i32 %1122 to i64
  %1124 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1123
  %1125 = load i32, ptr %1124, align 4, !tbaa !10
  %1126 = xor i32 %1117, %1125
  %1127 = load i32, ptr %11, align 4, !tbaa !10
  %1128 = lshr i32 %1127, 16
  %1129 = trunc i32 %1128 to i8
  %1130 = zext i8 %1129 to i32
  %1131 = and i32 %1130, 255
  %1132 = sext i32 %1131 to i64
  %1133 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1132
  %1134 = load i32, ptr %1133, align 4, !tbaa !10
  %1135 = xor i32 %1126, %1134
  %1136 = load i32, ptr %11, align 4, !tbaa !10
  %1137 = lshr i32 %1136, 24
  %1138 = trunc i32 %1137 to i8
  %1139 = zext i8 %1138 to i32
  %1140 = and i32 %1139, 255
  %1141 = sext i32 %1140 to i64
  %1142 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1141
  %1143 = load i32, ptr %1142, align 4, !tbaa !10
  %1144 = xor i32 %1135, %1143
  store i32 %1144, ptr %11, align 4, !tbaa !10
  %1145 = load i32, ptr %12, align 4, !tbaa !10
  %1146 = load i32, ptr %11, align 4, !tbaa !10
  %1147 = add i32 %1145, %1146
  %1148 = and i32 %1147, -1
  store i32 %1148, ptr %12, align 4, !tbaa !10
  %1149 = load i32, ptr %12, align 4, !tbaa !10
  %1150 = trunc i32 %1149 to i8
  %1151 = zext i8 %1150 to i32
  %1152 = and i32 %1151, 255
  %1153 = sext i32 %1152 to i64
  %1154 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1153
  %1155 = load i32, ptr %1154, align 4, !tbaa !10
  %1156 = load i32, ptr %12, align 4, !tbaa !10
  %1157 = lshr i32 %1156, 8
  %1158 = trunc i32 %1157 to i8
  %1159 = zext i8 %1158 to i32
  %1160 = and i32 %1159, 255
  %1161 = sext i32 %1160 to i64
  %1162 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1161
  %1163 = load i32, ptr %1162, align 4, !tbaa !10
  %1164 = xor i32 %1155, %1163
  %1165 = load i32, ptr %12, align 4, !tbaa !10
  %1166 = lshr i32 %1165, 16
  %1167 = trunc i32 %1166 to i8
  %1168 = zext i8 %1167 to i32
  %1169 = and i32 %1168, 255
  %1170 = sext i32 %1169 to i64
  %1171 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1170
  %1172 = load i32, ptr %1171, align 4, !tbaa !10
  %1173 = xor i32 %1164, %1172
  %1174 = load i32, ptr %12, align 4, !tbaa !10
  %1175 = lshr i32 %1174, 24
  %1176 = trunc i32 %1175 to i8
  %1177 = zext i8 %1176 to i32
  %1178 = and i32 %1177, 255
  %1179 = sext i32 %1178 to i64
  %1180 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1179
  %1181 = load i32, ptr %1180, align 4, !tbaa !10
  %1182 = xor i32 %1173, %1181
  store i32 %1182, ptr %12, align 4, !tbaa !10
  %1183 = load i32, ptr %11, align 4, !tbaa !10
  %1184 = load i32, ptr %12, align 4, !tbaa !10
  %1185 = add i32 %1183, %1184
  %1186 = and i32 %1185, -1
  store i32 %1186, ptr %11, align 4, !tbaa !10
  %1187 = load i32, ptr %11, align 4, !tbaa !10
  %1188 = load i32, ptr %9, align 4, !tbaa !10
  %1189 = xor i32 %1188, %1187
  store i32 %1189, ptr %9, align 4, !tbaa !10
  %1190 = load i32, ptr %12, align 4, !tbaa !10
  %1191 = load i32, ptr %10, align 4, !tbaa !10
  %1192 = xor i32 %1191, %1190
  store i32 %1192, ptr %10, align 4, !tbaa !10
  %1193 = load i32, ptr %9, align 4, !tbaa !10
  %1194 = load ptr, ptr %6, align 8, !tbaa !5
  %1195 = getelementptr inbounds %struct.seed_key_st, ptr %1194, i32 0, i32 0
  %1196 = getelementptr inbounds [32 x i32], ptr %1195, i64 0, i64 14
  %1197 = load i32, ptr %1196, align 4, !tbaa !10
  %1198 = xor i32 %1193, %1197
  store i32 %1198, ptr %11, align 4, !tbaa !10
  %1199 = load i32, ptr %10, align 4, !tbaa !10
  %1200 = load ptr, ptr %6, align 8, !tbaa !5
  %1201 = getelementptr inbounds %struct.seed_key_st, ptr %1200, i32 0, i32 0
  %1202 = getelementptr inbounds [32 x i32], ptr %1201, i64 0, i64 15
  %1203 = load i32, ptr %1202, align 4, !tbaa !10
  %1204 = xor i32 %1199, %1203
  store i32 %1204, ptr %12, align 4, !tbaa !10
  %1205 = load i32, ptr %11, align 4, !tbaa !10
  %1206 = load i32, ptr %12, align 4, !tbaa !10
  %1207 = xor i32 %1206, %1205
  store i32 %1207, ptr %12, align 4, !tbaa !10
  %1208 = load i32, ptr %12, align 4, !tbaa !10
  %1209 = trunc i32 %1208 to i8
  %1210 = zext i8 %1209 to i32
  %1211 = and i32 %1210, 255
  %1212 = sext i32 %1211 to i64
  %1213 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1212
  %1214 = load i32, ptr %1213, align 4, !tbaa !10
  %1215 = load i32, ptr %12, align 4, !tbaa !10
  %1216 = lshr i32 %1215, 8
  %1217 = trunc i32 %1216 to i8
  %1218 = zext i8 %1217 to i32
  %1219 = and i32 %1218, 255
  %1220 = sext i32 %1219 to i64
  %1221 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1220
  %1222 = load i32, ptr %1221, align 4, !tbaa !10
  %1223 = xor i32 %1214, %1222
  %1224 = load i32, ptr %12, align 4, !tbaa !10
  %1225 = lshr i32 %1224, 16
  %1226 = trunc i32 %1225 to i8
  %1227 = zext i8 %1226 to i32
  %1228 = and i32 %1227, 255
  %1229 = sext i32 %1228 to i64
  %1230 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1229
  %1231 = load i32, ptr %1230, align 4, !tbaa !10
  %1232 = xor i32 %1223, %1231
  %1233 = load i32, ptr %12, align 4, !tbaa !10
  %1234 = lshr i32 %1233, 24
  %1235 = trunc i32 %1234 to i8
  %1236 = zext i8 %1235 to i32
  %1237 = and i32 %1236, 255
  %1238 = sext i32 %1237 to i64
  %1239 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1238
  %1240 = load i32, ptr %1239, align 4, !tbaa !10
  %1241 = xor i32 %1232, %1240
  store i32 %1241, ptr %12, align 4, !tbaa !10
  %1242 = load i32, ptr %11, align 4, !tbaa !10
  %1243 = load i32, ptr %12, align 4, !tbaa !10
  %1244 = add i32 %1242, %1243
  %1245 = and i32 %1244, -1
  store i32 %1245, ptr %11, align 4, !tbaa !10
  %1246 = load i32, ptr %11, align 4, !tbaa !10
  %1247 = trunc i32 %1246 to i8
  %1248 = zext i8 %1247 to i32
  %1249 = and i32 %1248, 255
  %1250 = sext i32 %1249 to i64
  %1251 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1250
  %1252 = load i32, ptr %1251, align 4, !tbaa !10
  %1253 = load i32, ptr %11, align 4, !tbaa !10
  %1254 = lshr i32 %1253, 8
  %1255 = trunc i32 %1254 to i8
  %1256 = zext i8 %1255 to i32
  %1257 = and i32 %1256, 255
  %1258 = sext i32 %1257 to i64
  %1259 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1258
  %1260 = load i32, ptr %1259, align 4, !tbaa !10
  %1261 = xor i32 %1252, %1260
  %1262 = load i32, ptr %11, align 4, !tbaa !10
  %1263 = lshr i32 %1262, 16
  %1264 = trunc i32 %1263 to i8
  %1265 = zext i8 %1264 to i32
  %1266 = and i32 %1265, 255
  %1267 = sext i32 %1266 to i64
  %1268 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1267
  %1269 = load i32, ptr %1268, align 4, !tbaa !10
  %1270 = xor i32 %1261, %1269
  %1271 = load i32, ptr %11, align 4, !tbaa !10
  %1272 = lshr i32 %1271, 24
  %1273 = trunc i32 %1272 to i8
  %1274 = zext i8 %1273 to i32
  %1275 = and i32 %1274, 255
  %1276 = sext i32 %1275 to i64
  %1277 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1276
  %1278 = load i32, ptr %1277, align 4, !tbaa !10
  %1279 = xor i32 %1270, %1278
  store i32 %1279, ptr %11, align 4, !tbaa !10
  %1280 = load i32, ptr %12, align 4, !tbaa !10
  %1281 = load i32, ptr %11, align 4, !tbaa !10
  %1282 = add i32 %1280, %1281
  %1283 = and i32 %1282, -1
  store i32 %1283, ptr %12, align 4, !tbaa !10
  %1284 = load i32, ptr %12, align 4, !tbaa !10
  %1285 = trunc i32 %1284 to i8
  %1286 = zext i8 %1285 to i32
  %1287 = and i32 %1286, 255
  %1288 = sext i32 %1287 to i64
  %1289 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1288
  %1290 = load i32, ptr %1289, align 4, !tbaa !10
  %1291 = load i32, ptr %12, align 4, !tbaa !10
  %1292 = lshr i32 %1291, 8
  %1293 = trunc i32 %1292 to i8
  %1294 = zext i8 %1293 to i32
  %1295 = and i32 %1294, 255
  %1296 = sext i32 %1295 to i64
  %1297 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1296
  %1298 = load i32, ptr %1297, align 4, !tbaa !10
  %1299 = xor i32 %1290, %1298
  %1300 = load i32, ptr %12, align 4, !tbaa !10
  %1301 = lshr i32 %1300, 16
  %1302 = trunc i32 %1301 to i8
  %1303 = zext i8 %1302 to i32
  %1304 = and i32 %1303, 255
  %1305 = sext i32 %1304 to i64
  %1306 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1305
  %1307 = load i32, ptr %1306, align 4, !tbaa !10
  %1308 = xor i32 %1299, %1307
  %1309 = load i32, ptr %12, align 4, !tbaa !10
  %1310 = lshr i32 %1309, 24
  %1311 = trunc i32 %1310 to i8
  %1312 = zext i8 %1311 to i32
  %1313 = and i32 %1312, 255
  %1314 = sext i32 %1313 to i64
  %1315 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1314
  %1316 = load i32, ptr %1315, align 4, !tbaa !10
  %1317 = xor i32 %1308, %1316
  store i32 %1317, ptr %12, align 4, !tbaa !10
  %1318 = load i32, ptr %11, align 4, !tbaa !10
  %1319 = load i32, ptr %12, align 4, !tbaa !10
  %1320 = add i32 %1318, %1319
  %1321 = and i32 %1320, -1
  store i32 %1321, ptr %11, align 4, !tbaa !10
  %1322 = load i32, ptr %11, align 4, !tbaa !10
  %1323 = load i32, ptr %7, align 4, !tbaa !10
  %1324 = xor i32 %1323, %1322
  store i32 %1324, ptr %7, align 4, !tbaa !10
  %1325 = load i32, ptr %12, align 4, !tbaa !10
  %1326 = load i32, ptr %8, align 4, !tbaa !10
  %1327 = xor i32 %1326, %1325
  store i32 %1327, ptr %8, align 4, !tbaa !10
  %1328 = load i32, ptr %7, align 4, !tbaa !10
  %1329 = load ptr, ptr %6, align 8, !tbaa !5
  %1330 = getelementptr inbounds %struct.seed_key_st, ptr %1329, i32 0, i32 0
  %1331 = getelementptr inbounds [32 x i32], ptr %1330, i64 0, i64 12
  %1332 = load i32, ptr %1331, align 4, !tbaa !10
  %1333 = xor i32 %1328, %1332
  store i32 %1333, ptr %11, align 4, !tbaa !10
  %1334 = load i32, ptr %8, align 4, !tbaa !10
  %1335 = load ptr, ptr %6, align 8, !tbaa !5
  %1336 = getelementptr inbounds %struct.seed_key_st, ptr %1335, i32 0, i32 0
  %1337 = getelementptr inbounds [32 x i32], ptr %1336, i64 0, i64 13
  %1338 = load i32, ptr %1337, align 4, !tbaa !10
  %1339 = xor i32 %1334, %1338
  store i32 %1339, ptr %12, align 4, !tbaa !10
  %1340 = load i32, ptr %11, align 4, !tbaa !10
  %1341 = load i32, ptr %12, align 4, !tbaa !10
  %1342 = xor i32 %1341, %1340
  store i32 %1342, ptr %12, align 4, !tbaa !10
  %1343 = load i32, ptr %12, align 4, !tbaa !10
  %1344 = trunc i32 %1343 to i8
  %1345 = zext i8 %1344 to i32
  %1346 = and i32 %1345, 255
  %1347 = sext i32 %1346 to i64
  %1348 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1347
  %1349 = load i32, ptr %1348, align 4, !tbaa !10
  %1350 = load i32, ptr %12, align 4, !tbaa !10
  %1351 = lshr i32 %1350, 8
  %1352 = trunc i32 %1351 to i8
  %1353 = zext i8 %1352 to i32
  %1354 = and i32 %1353, 255
  %1355 = sext i32 %1354 to i64
  %1356 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1355
  %1357 = load i32, ptr %1356, align 4, !tbaa !10
  %1358 = xor i32 %1349, %1357
  %1359 = load i32, ptr %12, align 4, !tbaa !10
  %1360 = lshr i32 %1359, 16
  %1361 = trunc i32 %1360 to i8
  %1362 = zext i8 %1361 to i32
  %1363 = and i32 %1362, 255
  %1364 = sext i32 %1363 to i64
  %1365 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1364
  %1366 = load i32, ptr %1365, align 4, !tbaa !10
  %1367 = xor i32 %1358, %1366
  %1368 = load i32, ptr %12, align 4, !tbaa !10
  %1369 = lshr i32 %1368, 24
  %1370 = trunc i32 %1369 to i8
  %1371 = zext i8 %1370 to i32
  %1372 = and i32 %1371, 255
  %1373 = sext i32 %1372 to i64
  %1374 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1373
  %1375 = load i32, ptr %1374, align 4, !tbaa !10
  %1376 = xor i32 %1367, %1375
  store i32 %1376, ptr %12, align 4, !tbaa !10
  %1377 = load i32, ptr %11, align 4, !tbaa !10
  %1378 = load i32, ptr %12, align 4, !tbaa !10
  %1379 = add i32 %1377, %1378
  %1380 = and i32 %1379, -1
  store i32 %1380, ptr %11, align 4, !tbaa !10
  %1381 = load i32, ptr %11, align 4, !tbaa !10
  %1382 = trunc i32 %1381 to i8
  %1383 = zext i8 %1382 to i32
  %1384 = and i32 %1383, 255
  %1385 = sext i32 %1384 to i64
  %1386 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1385
  %1387 = load i32, ptr %1386, align 4, !tbaa !10
  %1388 = load i32, ptr %11, align 4, !tbaa !10
  %1389 = lshr i32 %1388, 8
  %1390 = trunc i32 %1389 to i8
  %1391 = zext i8 %1390 to i32
  %1392 = and i32 %1391, 255
  %1393 = sext i32 %1392 to i64
  %1394 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1393
  %1395 = load i32, ptr %1394, align 4, !tbaa !10
  %1396 = xor i32 %1387, %1395
  %1397 = load i32, ptr %11, align 4, !tbaa !10
  %1398 = lshr i32 %1397, 16
  %1399 = trunc i32 %1398 to i8
  %1400 = zext i8 %1399 to i32
  %1401 = and i32 %1400, 255
  %1402 = sext i32 %1401 to i64
  %1403 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1402
  %1404 = load i32, ptr %1403, align 4, !tbaa !10
  %1405 = xor i32 %1396, %1404
  %1406 = load i32, ptr %11, align 4, !tbaa !10
  %1407 = lshr i32 %1406, 24
  %1408 = trunc i32 %1407 to i8
  %1409 = zext i8 %1408 to i32
  %1410 = and i32 %1409, 255
  %1411 = sext i32 %1410 to i64
  %1412 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1411
  %1413 = load i32, ptr %1412, align 4, !tbaa !10
  %1414 = xor i32 %1405, %1413
  store i32 %1414, ptr %11, align 4, !tbaa !10
  %1415 = load i32, ptr %12, align 4, !tbaa !10
  %1416 = load i32, ptr %11, align 4, !tbaa !10
  %1417 = add i32 %1415, %1416
  %1418 = and i32 %1417, -1
  store i32 %1418, ptr %12, align 4, !tbaa !10
  %1419 = load i32, ptr %12, align 4, !tbaa !10
  %1420 = trunc i32 %1419 to i8
  %1421 = zext i8 %1420 to i32
  %1422 = and i32 %1421, 255
  %1423 = sext i32 %1422 to i64
  %1424 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1423
  %1425 = load i32, ptr %1424, align 4, !tbaa !10
  %1426 = load i32, ptr %12, align 4, !tbaa !10
  %1427 = lshr i32 %1426, 8
  %1428 = trunc i32 %1427 to i8
  %1429 = zext i8 %1428 to i32
  %1430 = and i32 %1429, 255
  %1431 = sext i32 %1430 to i64
  %1432 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1431
  %1433 = load i32, ptr %1432, align 4, !tbaa !10
  %1434 = xor i32 %1425, %1433
  %1435 = load i32, ptr %12, align 4, !tbaa !10
  %1436 = lshr i32 %1435, 16
  %1437 = trunc i32 %1436 to i8
  %1438 = zext i8 %1437 to i32
  %1439 = and i32 %1438, 255
  %1440 = sext i32 %1439 to i64
  %1441 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1440
  %1442 = load i32, ptr %1441, align 4, !tbaa !10
  %1443 = xor i32 %1434, %1442
  %1444 = load i32, ptr %12, align 4, !tbaa !10
  %1445 = lshr i32 %1444, 24
  %1446 = trunc i32 %1445 to i8
  %1447 = zext i8 %1446 to i32
  %1448 = and i32 %1447, 255
  %1449 = sext i32 %1448 to i64
  %1450 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1449
  %1451 = load i32, ptr %1450, align 4, !tbaa !10
  %1452 = xor i32 %1443, %1451
  store i32 %1452, ptr %12, align 4, !tbaa !10
  %1453 = load i32, ptr %11, align 4, !tbaa !10
  %1454 = load i32, ptr %12, align 4, !tbaa !10
  %1455 = add i32 %1453, %1454
  %1456 = and i32 %1455, -1
  store i32 %1456, ptr %11, align 4, !tbaa !10
  %1457 = load i32, ptr %11, align 4, !tbaa !10
  %1458 = load i32, ptr %9, align 4, !tbaa !10
  %1459 = xor i32 %1458, %1457
  store i32 %1459, ptr %9, align 4, !tbaa !10
  %1460 = load i32, ptr %12, align 4, !tbaa !10
  %1461 = load i32, ptr %10, align 4, !tbaa !10
  %1462 = xor i32 %1461, %1460
  store i32 %1462, ptr %10, align 4, !tbaa !10
  %1463 = load i32, ptr %9, align 4, !tbaa !10
  %1464 = load ptr, ptr %6, align 8, !tbaa !5
  %1465 = getelementptr inbounds %struct.seed_key_st, ptr %1464, i32 0, i32 0
  %1466 = getelementptr inbounds [32 x i32], ptr %1465, i64 0, i64 10
  %1467 = load i32, ptr %1466, align 4, !tbaa !10
  %1468 = xor i32 %1463, %1467
  store i32 %1468, ptr %11, align 4, !tbaa !10
  %1469 = load i32, ptr %10, align 4, !tbaa !10
  %1470 = load ptr, ptr %6, align 8, !tbaa !5
  %1471 = getelementptr inbounds %struct.seed_key_st, ptr %1470, i32 0, i32 0
  %1472 = getelementptr inbounds [32 x i32], ptr %1471, i64 0, i64 11
  %1473 = load i32, ptr %1472, align 4, !tbaa !10
  %1474 = xor i32 %1469, %1473
  store i32 %1474, ptr %12, align 4, !tbaa !10
  %1475 = load i32, ptr %11, align 4, !tbaa !10
  %1476 = load i32, ptr %12, align 4, !tbaa !10
  %1477 = xor i32 %1476, %1475
  store i32 %1477, ptr %12, align 4, !tbaa !10
  %1478 = load i32, ptr %12, align 4, !tbaa !10
  %1479 = trunc i32 %1478 to i8
  %1480 = zext i8 %1479 to i32
  %1481 = and i32 %1480, 255
  %1482 = sext i32 %1481 to i64
  %1483 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1482
  %1484 = load i32, ptr %1483, align 4, !tbaa !10
  %1485 = load i32, ptr %12, align 4, !tbaa !10
  %1486 = lshr i32 %1485, 8
  %1487 = trunc i32 %1486 to i8
  %1488 = zext i8 %1487 to i32
  %1489 = and i32 %1488, 255
  %1490 = sext i32 %1489 to i64
  %1491 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1490
  %1492 = load i32, ptr %1491, align 4, !tbaa !10
  %1493 = xor i32 %1484, %1492
  %1494 = load i32, ptr %12, align 4, !tbaa !10
  %1495 = lshr i32 %1494, 16
  %1496 = trunc i32 %1495 to i8
  %1497 = zext i8 %1496 to i32
  %1498 = and i32 %1497, 255
  %1499 = sext i32 %1498 to i64
  %1500 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1499
  %1501 = load i32, ptr %1500, align 4, !tbaa !10
  %1502 = xor i32 %1493, %1501
  %1503 = load i32, ptr %12, align 4, !tbaa !10
  %1504 = lshr i32 %1503, 24
  %1505 = trunc i32 %1504 to i8
  %1506 = zext i8 %1505 to i32
  %1507 = and i32 %1506, 255
  %1508 = sext i32 %1507 to i64
  %1509 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1508
  %1510 = load i32, ptr %1509, align 4, !tbaa !10
  %1511 = xor i32 %1502, %1510
  store i32 %1511, ptr %12, align 4, !tbaa !10
  %1512 = load i32, ptr %11, align 4, !tbaa !10
  %1513 = load i32, ptr %12, align 4, !tbaa !10
  %1514 = add i32 %1512, %1513
  %1515 = and i32 %1514, -1
  store i32 %1515, ptr %11, align 4, !tbaa !10
  %1516 = load i32, ptr %11, align 4, !tbaa !10
  %1517 = trunc i32 %1516 to i8
  %1518 = zext i8 %1517 to i32
  %1519 = and i32 %1518, 255
  %1520 = sext i32 %1519 to i64
  %1521 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1520
  %1522 = load i32, ptr %1521, align 4, !tbaa !10
  %1523 = load i32, ptr %11, align 4, !tbaa !10
  %1524 = lshr i32 %1523, 8
  %1525 = trunc i32 %1524 to i8
  %1526 = zext i8 %1525 to i32
  %1527 = and i32 %1526, 255
  %1528 = sext i32 %1527 to i64
  %1529 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1528
  %1530 = load i32, ptr %1529, align 4, !tbaa !10
  %1531 = xor i32 %1522, %1530
  %1532 = load i32, ptr %11, align 4, !tbaa !10
  %1533 = lshr i32 %1532, 16
  %1534 = trunc i32 %1533 to i8
  %1535 = zext i8 %1534 to i32
  %1536 = and i32 %1535, 255
  %1537 = sext i32 %1536 to i64
  %1538 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1537
  %1539 = load i32, ptr %1538, align 4, !tbaa !10
  %1540 = xor i32 %1531, %1539
  %1541 = load i32, ptr %11, align 4, !tbaa !10
  %1542 = lshr i32 %1541, 24
  %1543 = trunc i32 %1542 to i8
  %1544 = zext i8 %1543 to i32
  %1545 = and i32 %1544, 255
  %1546 = sext i32 %1545 to i64
  %1547 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1546
  %1548 = load i32, ptr %1547, align 4, !tbaa !10
  %1549 = xor i32 %1540, %1548
  store i32 %1549, ptr %11, align 4, !tbaa !10
  %1550 = load i32, ptr %12, align 4, !tbaa !10
  %1551 = load i32, ptr %11, align 4, !tbaa !10
  %1552 = add i32 %1550, %1551
  %1553 = and i32 %1552, -1
  store i32 %1553, ptr %12, align 4, !tbaa !10
  %1554 = load i32, ptr %12, align 4, !tbaa !10
  %1555 = trunc i32 %1554 to i8
  %1556 = zext i8 %1555 to i32
  %1557 = and i32 %1556, 255
  %1558 = sext i32 %1557 to i64
  %1559 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1558
  %1560 = load i32, ptr %1559, align 4, !tbaa !10
  %1561 = load i32, ptr %12, align 4, !tbaa !10
  %1562 = lshr i32 %1561, 8
  %1563 = trunc i32 %1562 to i8
  %1564 = zext i8 %1563 to i32
  %1565 = and i32 %1564, 255
  %1566 = sext i32 %1565 to i64
  %1567 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1566
  %1568 = load i32, ptr %1567, align 4, !tbaa !10
  %1569 = xor i32 %1560, %1568
  %1570 = load i32, ptr %12, align 4, !tbaa !10
  %1571 = lshr i32 %1570, 16
  %1572 = trunc i32 %1571 to i8
  %1573 = zext i8 %1572 to i32
  %1574 = and i32 %1573, 255
  %1575 = sext i32 %1574 to i64
  %1576 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1575
  %1577 = load i32, ptr %1576, align 4, !tbaa !10
  %1578 = xor i32 %1569, %1577
  %1579 = load i32, ptr %12, align 4, !tbaa !10
  %1580 = lshr i32 %1579, 24
  %1581 = trunc i32 %1580 to i8
  %1582 = zext i8 %1581 to i32
  %1583 = and i32 %1582, 255
  %1584 = sext i32 %1583 to i64
  %1585 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1584
  %1586 = load i32, ptr %1585, align 4, !tbaa !10
  %1587 = xor i32 %1578, %1586
  store i32 %1587, ptr %12, align 4, !tbaa !10
  %1588 = load i32, ptr %11, align 4, !tbaa !10
  %1589 = load i32, ptr %12, align 4, !tbaa !10
  %1590 = add i32 %1588, %1589
  %1591 = and i32 %1590, -1
  store i32 %1591, ptr %11, align 4, !tbaa !10
  %1592 = load i32, ptr %11, align 4, !tbaa !10
  %1593 = load i32, ptr %7, align 4, !tbaa !10
  %1594 = xor i32 %1593, %1592
  store i32 %1594, ptr %7, align 4, !tbaa !10
  %1595 = load i32, ptr %12, align 4, !tbaa !10
  %1596 = load i32, ptr %8, align 4, !tbaa !10
  %1597 = xor i32 %1596, %1595
  store i32 %1597, ptr %8, align 4, !tbaa !10
  %1598 = load i32, ptr %7, align 4, !tbaa !10
  %1599 = load ptr, ptr %6, align 8, !tbaa !5
  %1600 = getelementptr inbounds %struct.seed_key_st, ptr %1599, i32 0, i32 0
  %1601 = getelementptr inbounds [32 x i32], ptr %1600, i64 0, i64 8
  %1602 = load i32, ptr %1601, align 4, !tbaa !10
  %1603 = xor i32 %1598, %1602
  store i32 %1603, ptr %11, align 4, !tbaa !10
  %1604 = load i32, ptr %8, align 4, !tbaa !10
  %1605 = load ptr, ptr %6, align 8, !tbaa !5
  %1606 = getelementptr inbounds %struct.seed_key_st, ptr %1605, i32 0, i32 0
  %1607 = getelementptr inbounds [32 x i32], ptr %1606, i64 0, i64 9
  %1608 = load i32, ptr %1607, align 4, !tbaa !10
  %1609 = xor i32 %1604, %1608
  store i32 %1609, ptr %12, align 4, !tbaa !10
  %1610 = load i32, ptr %11, align 4, !tbaa !10
  %1611 = load i32, ptr %12, align 4, !tbaa !10
  %1612 = xor i32 %1611, %1610
  store i32 %1612, ptr %12, align 4, !tbaa !10
  %1613 = load i32, ptr %12, align 4, !tbaa !10
  %1614 = trunc i32 %1613 to i8
  %1615 = zext i8 %1614 to i32
  %1616 = and i32 %1615, 255
  %1617 = sext i32 %1616 to i64
  %1618 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1617
  %1619 = load i32, ptr %1618, align 4, !tbaa !10
  %1620 = load i32, ptr %12, align 4, !tbaa !10
  %1621 = lshr i32 %1620, 8
  %1622 = trunc i32 %1621 to i8
  %1623 = zext i8 %1622 to i32
  %1624 = and i32 %1623, 255
  %1625 = sext i32 %1624 to i64
  %1626 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1625
  %1627 = load i32, ptr %1626, align 4, !tbaa !10
  %1628 = xor i32 %1619, %1627
  %1629 = load i32, ptr %12, align 4, !tbaa !10
  %1630 = lshr i32 %1629, 16
  %1631 = trunc i32 %1630 to i8
  %1632 = zext i8 %1631 to i32
  %1633 = and i32 %1632, 255
  %1634 = sext i32 %1633 to i64
  %1635 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1634
  %1636 = load i32, ptr %1635, align 4, !tbaa !10
  %1637 = xor i32 %1628, %1636
  %1638 = load i32, ptr %12, align 4, !tbaa !10
  %1639 = lshr i32 %1638, 24
  %1640 = trunc i32 %1639 to i8
  %1641 = zext i8 %1640 to i32
  %1642 = and i32 %1641, 255
  %1643 = sext i32 %1642 to i64
  %1644 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1643
  %1645 = load i32, ptr %1644, align 4, !tbaa !10
  %1646 = xor i32 %1637, %1645
  store i32 %1646, ptr %12, align 4, !tbaa !10
  %1647 = load i32, ptr %11, align 4, !tbaa !10
  %1648 = load i32, ptr %12, align 4, !tbaa !10
  %1649 = add i32 %1647, %1648
  %1650 = and i32 %1649, -1
  store i32 %1650, ptr %11, align 4, !tbaa !10
  %1651 = load i32, ptr %11, align 4, !tbaa !10
  %1652 = trunc i32 %1651 to i8
  %1653 = zext i8 %1652 to i32
  %1654 = and i32 %1653, 255
  %1655 = sext i32 %1654 to i64
  %1656 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1655
  %1657 = load i32, ptr %1656, align 4, !tbaa !10
  %1658 = load i32, ptr %11, align 4, !tbaa !10
  %1659 = lshr i32 %1658, 8
  %1660 = trunc i32 %1659 to i8
  %1661 = zext i8 %1660 to i32
  %1662 = and i32 %1661, 255
  %1663 = sext i32 %1662 to i64
  %1664 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1663
  %1665 = load i32, ptr %1664, align 4, !tbaa !10
  %1666 = xor i32 %1657, %1665
  %1667 = load i32, ptr %11, align 4, !tbaa !10
  %1668 = lshr i32 %1667, 16
  %1669 = trunc i32 %1668 to i8
  %1670 = zext i8 %1669 to i32
  %1671 = and i32 %1670, 255
  %1672 = sext i32 %1671 to i64
  %1673 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1672
  %1674 = load i32, ptr %1673, align 4, !tbaa !10
  %1675 = xor i32 %1666, %1674
  %1676 = load i32, ptr %11, align 4, !tbaa !10
  %1677 = lshr i32 %1676, 24
  %1678 = trunc i32 %1677 to i8
  %1679 = zext i8 %1678 to i32
  %1680 = and i32 %1679, 255
  %1681 = sext i32 %1680 to i64
  %1682 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1681
  %1683 = load i32, ptr %1682, align 4, !tbaa !10
  %1684 = xor i32 %1675, %1683
  store i32 %1684, ptr %11, align 4, !tbaa !10
  %1685 = load i32, ptr %12, align 4, !tbaa !10
  %1686 = load i32, ptr %11, align 4, !tbaa !10
  %1687 = add i32 %1685, %1686
  %1688 = and i32 %1687, -1
  store i32 %1688, ptr %12, align 4, !tbaa !10
  %1689 = load i32, ptr %12, align 4, !tbaa !10
  %1690 = trunc i32 %1689 to i8
  %1691 = zext i8 %1690 to i32
  %1692 = and i32 %1691, 255
  %1693 = sext i32 %1692 to i64
  %1694 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1693
  %1695 = load i32, ptr %1694, align 4, !tbaa !10
  %1696 = load i32, ptr %12, align 4, !tbaa !10
  %1697 = lshr i32 %1696, 8
  %1698 = trunc i32 %1697 to i8
  %1699 = zext i8 %1698 to i32
  %1700 = and i32 %1699, 255
  %1701 = sext i32 %1700 to i64
  %1702 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1701
  %1703 = load i32, ptr %1702, align 4, !tbaa !10
  %1704 = xor i32 %1695, %1703
  %1705 = load i32, ptr %12, align 4, !tbaa !10
  %1706 = lshr i32 %1705, 16
  %1707 = trunc i32 %1706 to i8
  %1708 = zext i8 %1707 to i32
  %1709 = and i32 %1708, 255
  %1710 = sext i32 %1709 to i64
  %1711 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1710
  %1712 = load i32, ptr %1711, align 4, !tbaa !10
  %1713 = xor i32 %1704, %1712
  %1714 = load i32, ptr %12, align 4, !tbaa !10
  %1715 = lshr i32 %1714, 24
  %1716 = trunc i32 %1715 to i8
  %1717 = zext i8 %1716 to i32
  %1718 = and i32 %1717, 255
  %1719 = sext i32 %1718 to i64
  %1720 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1719
  %1721 = load i32, ptr %1720, align 4, !tbaa !10
  %1722 = xor i32 %1713, %1721
  store i32 %1722, ptr %12, align 4, !tbaa !10
  %1723 = load i32, ptr %11, align 4, !tbaa !10
  %1724 = load i32, ptr %12, align 4, !tbaa !10
  %1725 = add i32 %1723, %1724
  %1726 = and i32 %1725, -1
  store i32 %1726, ptr %11, align 4, !tbaa !10
  %1727 = load i32, ptr %11, align 4, !tbaa !10
  %1728 = load i32, ptr %9, align 4, !tbaa !10
  %1729 = xor i32 %1728, %1727
  store i32 %1729, ptr %9, align 4, !tbaa !10
  %1730 = load i32, ptr %12, align 4, !tbaa !10
  %1731 = load i32, ptr %10, align 4, !tbaa !10
  %1732 = xor i32 %1731, %1730
  store i32 %1732, ptr %10, align 4, !tbaa !10
  %1733 = load i32, ptr %9, align 4, !tbaa !10
  %1734 = load ptr, ptr %6, align 8, !tbaa !5
  %1735 = getelementptr inbounds %struct.seed_key_st, ptr %1734, i32 0, i32 0
  %1736 = getelementptr inbounds [32 x i32], ptr %1735, i64 0, i64 6
  %1737 = load i32, ptr %1736, align 4, !tbaa !10
  %1738 = xor i32 %1733, %1737
  store i32 %1738, ptr %11, align 4, !tbaa !10
  %1739 = load i32, ptr %10, align 4, !tbaa !10
  %1740 = load ptr, ptr %6, align 8, !tbaa !5
  %1741 = getelementptr inbounds %struct.seed_key_st, ptr %1740, i32 0, i32 0
  %1742 = getelementptr inbounds [32 x i32], ptr %1741, i64 0, i64 7
  %1743 = load i32, ptr %1742, align 4, !tbaa !10
  %1744 = xor i32 %1739, %1743
  store i32 %1744, ptr %12, align 4, !tbaa !10
  %1745 = load i32, ptr %11, align 4, !tbaa !10
  %1746 = load i32, ptr %12, align 4, !tbaa !10
  %1747 = xor i32 %1746, %1745
  store i32 %1747, ptr %12, align 4, !tbaa !10
  %1748 = load i32, ptr %12, align 4, !tbaa !10
  %1749 = trunc i32 %1748 to i8
  %1750 = zext i8 %1749 to i32
  %1751 = and i32 %1750, 255
  %1752 = sext i32 %1751 to i64
  %1753 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1752
  %1754 = load i32, ptr %1753, align 4, !tbaa !10
  %1755 = load i32, ptr %12, align 4, !tbaa !10
  %1756 = lshr i32 %1755, 8
  %1757 = trunc i32 %1756 to i8
  %1758 = zext i8 %1757 to i32
  %1759 = and i32 %1758, 255
  %1760 = sext i32 %1759 to i64
  %1761 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1760
  %1762 = load i32, ptr %1761, align 4, !tbaa !10
  %1763 = xor i32 %1754, %1762
  %1764 = load i32, ptr %12, align 4, !tbaa !10
  %1765 = lshr i32 %1764, 16
  %1766 = trunc i32 %1765 to i8
  %1767 = zext i8 %1766 to i32
  %1768 = and i32 %1767, 255
  %1769 = sext i32 %1768 to i64
  %1770 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1769
  %1771 = load i32, ptr %1770, align 4, !tbaa !10
  %1772 = xor i32 %1763, %1771
  %1773 = load i32, ptr %12, align 4, !tbaa !10
  %1774 = lshr i32 %1773, 24
  %1775 = trunc i32 %1774 to i8
  %1776 = zext i8 %1775 to i32
  %1777 = and i32 %1776, 255
  %1778 = sext i32 %1777 to i64
  %1779 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1778
  %1780 = load i32, ptr %1779, align 4, !tbaa !10
  %1781 = xor i32 %1772, %1780
  store i32 %1781, ptr %12, align 4, !tbaa !10
  %1782 = load i32, ptr %11, align 4, !tbaa !10
  %1783 = load i32, ptr %12, align 4, !tbaa !10
  %1784 = add i32 %1782, %1783
  %1785 = and i32 %1784, -1
  store i32 %1785, ptr %11, align 4, !tbaa !10
  %1786 = load i32, ptr %11, align 4, !tbaa !10
  %1787 = trunc i32 %1786 to i8
  %1788 = zext i8 %1787 to i32
  %1789 = and i32 %1788, 255
  %1790 = sext i32 %1789 to i64
  %1791 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1790
  %1792 = load i32, ptr %1791, align 4, !tbaa !10
  %1793 = load i32, ptr %11, align 4, !tbaa !10
  %1794 = lshr i32 %1793, 8
  %1795 = trunc i32 %1794 to i8
  %1796 = zext i8 %1795 to i32
  %1797 = and i32 %1796, 255
  %1798 = sext i32 %1797 to i64
  %1799 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1798
  %1800 = load i32, ptr %1799, align 4, !tbaa !10
  %1801 = xor i32 %1792, %1800
  %1802 = load i32, ptr %11, align 4, !tbaa !10
  %1803 = lshr i32 %1802, 16
  %1804 = trunc i32 %1803 to i8
  %1805 = zext i8 %1804 to i32
  %1806 = and i32 %1805, 255
  %1807 = sext i32 %1806 to i64
  %1808 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1807
  %1809 = load i32, ptr %1808, align 4, !tbaa !10
  %1810 = xor i32 %1801, %1809
  %1811 = load i32, ptr %11, align 4, !tbaa !10
  %1812 = lshr i32 %1811, 24
  %1813 = trunc i32 %1812 to i8
  %1814 = zext i8 %1813 to i32
  %1815 = and i32 %1814, 255
  %1816 = sext i32 %1815 to i64
  %1817 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1816
  %1818 = load i32, ptr %1817, align 4, !tbaa !10
  %1819 = xor i32 %1810, %1818
  store i32 %1819, ptr %11, align 4, !tbaa !10
  %1820 = load i32, ptr %12, align 4, !tbaa !10
  %1821 = load i32, ptr %11, align 4, !tbaa !10
  %1822 = add i32 %1820, %1821
  %1823 = and i32 %1822, -1
  store i32 %1823, ptr %12, align 4, !tbaa !10
  %1824 = load i32, ptr %12, align 4, !tbaa !10
  %1825 = trunc i32 %1824 to i8
  %1826 = zext i8 %1825 to i32
  %1827 = and i32 %1826, 255
  %1828 = sext i32 %1827 to i64
  %1829 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1828
  %1830 = load i32, ptr %1829, align 4, !tbaa !10
  %1831 = load i32, ptr %12, align 4, !tbaa !10
  %1832 = lshr i32 %1831, 8
  %1833 = trunc i32 %1832 to i8
  %1834 = zext i8 %1833 to i32
  %1835 = and i32 %1834, 255
  %1836 = sext i32 %1835 to i64
  %1837 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1836
  %1838 = load i32, ptr %1837, align 4, !tbaa !10
  %1839 = xor i32 %1830, %1838
  %1840 = load i32, ptr %12, align 4, !tbaa !10
  %1841 = lshr i32 %1840, 16
  %1842 = trunc i32 %1841 to i8
  %1843 = zext i8 %1842 to i32
  %1844 = and i32 %1843, 255
  %1845 = sext i32 %1844 to i64
  %1846 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1845
  %1847 = load i32, ptr %1846, align 4, !tbaa !10
  %1848 = xor i32 %1839, %1847
  %1849 = load i32, ptr %12, align 4, !tbaa !10
  %1850 = lshr i32 %1849, 24
  %1851 = trunc i32 %1850 to i8
  %1852 = zext i8 %1851 to i32
  %1853 = and i32 %1852, 255
  %1854 = sext i32 %1853 to i64
  %1855 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1854
  %1856 = load i32, ptr %1855, align 4, !tbaa !10
  %1857 = xor i32 %1848, %1856
  store i32 %1857, ptr %12, align 4, !tbaa !10
  %1858 = load i32, ptr %11, align 4, !tbaa !10
  %1859 = load i32, ptr %12, align 4, !tbaa !10
  %1860 = add i32 %1858, %1859
  %1861 = and i32 %1860, -1
  store i32 %1861, ptr %11, align 4, !tbaa !10
  %1862 = load i32, ptr %11, align 4, !tbaa !10
  %1863 = load i32, ptr %7, align 4, !tbaa !10
  %1864 = xor i32 %1863, %1862
  store i32 %1864, ptr %7, align 4, !tbaa !10
  %1865 = load i32, ptr %12, align 4, !tbaa !10
  %1866 = load i32, ptr %8, align 4, !tbaa !10
  %1867 = xor i32 %1866, %1865
  store i32 %1867, ptr %8, align 4, !tbaa !10
  %1868 = load i32, ptr %7, align 4, !tbaa !10
  %1869 = load ptr, ptr %6, align 8, !tbaa !5
  %1870 = getelementptr inbounds %struct.seed_key_st, ptr %1869, i32 0, i32 0
  %1871 = getelementptr inbounds [32 x i32], ptr %1870, i64 0, i64 4
  %1872 = load i32, ptr %1871, align 4, !tbaa !10
  %1873 = xor i32 %1868, %1872
  store i32 %1873, ptr %11, align 4, !tbaa !10
  %1874 = load i32, ptr %8, align 4, !tbaa !10
  %1875 = load ptr, ptr %6, align 8, !tbaa !5
  %1876 = getelementptr inbounds %struct.seed_key_st, ptr %1875, i32 0, i32 0
  %1877 = getelementptr inbounds [32 x i32], ptr %1876, i64 0, i64 5
  %1878 = load i32, ptr %1877, align 4, !tbaa !10
  %1879 = xor i32 %1874, %1878
  store i32 %1879, ptr %12, align 4, !tbaa !10
  %1880 = load i32, ptr %11, align 4, !tbaa !10
  %1881 = load i32, ptr %12, align 4, !tbaa !10
  %1882 = xor i32 %1881, %1880
  store i32 %1882, ptr %12, align 4, !tbaa !10
  %1883 = load i32, ptr %12, align 4, !tbaa !10
  %1884 = trunc i32 %1883 to i8
  %1885 = zext i8 %1884 to i32
  %1886 = and i32 %1885, 255
  %1887 = sext i32 %1886 to i64
  %1888 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1887
  %1889 = load i32, ptr %1888, align 4, !tbaa !10
  %1890 = load i32, ptr %12, align 4, !tbaa !10
  %1891 = lshr i32 %1890, 8
  %1892 = trunc i32 %1891 to i8
  %1893 = zext i8 %1892 to i32
  %1894 = and i32 %1893, 255
  %1895 = sext i32 %1894 to i64
  %1896 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1895
  %1897 = load i32, ptr %1896, align 4, !tbaa !10
  %1898 = xor i32 %1889, %1897
  %1899 = load i32, ptr %12, align 4, !tbaa !10
  %1900 = lshr i32 %1899, 16
  %1901 = trunc i32 %1900 to i8
  %1902 = zext i8 %1901 to i32
  %1903 = and i32 %1902, 255
  %1904 = sext i32 %1903 to i64
  %1905 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1904
  %1906 = load i32, ptr %1905, align 4, !tbaa !10
  %1907 = xor i32 %1898, %1906
  %1908 = load i32, ptr %12, align 4, !tbaa !10
  %1909 = lshr i32 %1908, 24
  %1910 = trunc i32 %1909 to i8
  %1911 = zext i8 %1910 to i32
  %1912 = and i32 %1911, 255
  %1913 = sext i32 %1912 to i64
  %1914 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1913
  %1915 = load i32, ptr %1914, align 4, !tbaa !10
  %1916 = xor i32 %1907, %1915
  store i32 %1916, ptr %12, align 4, !tbaa !10
  %1917 = load i32, ptr %11, align 4, !tbaa !10
  %1918 = load i32, ptr %12, align 4, !tbaa !10
  %1919 = add i32 %1917, %1918
  %1920 = and i32 %1919, -1
  store i32 %1920, ptr %11, align 4, !tbaa !10
  %1921 = load i32, ptr %11, align 4, !tbaa !10
  %1922 = trunc i32 %1921 to i8
  %1923 = zext i8 %1922 to i32
  %1924 = and i32 %1923, 255
  %1925 = sext i32 %1924 to i64
  %1926 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1925
  %1927 = load i32, ptr %1926, align 4, !tbaa !10
  %1928 = load i32, ptr %11, align 4, !tbaa !10
  %1929 = lshr i32 %1928, 8
  %1930 = trunc i32 %1929 to i8
  %1931 = zext i8 %1930 to i32
  %1932 = and i32 %1931, 255
  %1933 = sext i32 %1932 to i64
  %1934 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1933
  %1935 = load i32, ptr %1934, align 4, !tbaa !10
  %1936 = xor i32 %1927, %1935
  %1937 = load i32, ptr %11, align 4, !tbaa !10
  %1938 = lshr i32 %1937, 16
  %1939 = trunc i32 %1938 to i8
  %1940 = zext i8 %1939 to i32
  %1941 = and i32 %1940, 255
  %1942 = sext i32 %1941 to i64
  %1943 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1942
  %1944 = load i32, ptr %1943, align 4, !tbaa !10
  %1945 = xor i32 %1936, %1944
  %1946 = load i32, ptr %11, align 4, !tbaa !10
  %1947 = lshr i32 %1946, 24
  %1948 = trunc i32 %1947 to i8
  %1949 = zext i8 %1948 to i32
  %1950 = and i32 %1949, 255
  %1951 = sext i32 %1950 to i64
  %1952 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1951
  %1953 = load i32, ptr %1952, align 4, !tbaa !10
  %1954 = xor i32 %1945, %1953
  store i32 %1954, ptr %11, align 4, !tbaa !10
  %1955 = load i32, ptr %12, align 4, !tbaa !10
  %1956 = load i32, ptr %11, align 4, !tbaa !10
  %1957 = add i32 %1955, %1956
  %1958 = and i32 %1957, -1
  store i32 %1958, ptr %12, align 4, !tbaa !10
  %1959 = load i32, ptr %12, align 4, !tbaa !10
  %1960 = trunc i32 %1959 to i8
  %1961 = zext i8 %1960 to i32
  %1962 = and i32 %1961, 255
  %1963 = sext i32 %1962 to i64
  %1964 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1963
  %1965 = load i32, ptr %1964, align 4, !tbaa !10
  %1966 = load i32, ptr %12, align 4, !tbaa !10
  %1967 = lshr i32 %1966, 8
  %1968 = trunc i32 %1967 to i8
  %1969 = zext i8 %1968 to i32
  %1970 = and i32 %1969, 255
  %1971 = sext i32 %1970 to i64
  %1972 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %1971
  %1973 = load i32, ptr %1972, align 4, !tbaa !10
  %1974 = xor i32 %1965, %1973
  %1975 = load i32, ptr %12, align 4, !tbaa !10
  %1976 = lshr i32 %1975, 16
  %1977 = trunc i32 %1976 to i8
  %1978 = zext i8 %1977 to i32
  %1979 = and i32 %1978, 255
  %1980 = sext i32 %1979 to i64
  %1981 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %1980
  %1982 = load i32, ptr %1981, align 4, !tbaa !10
  %1983 = xor i32 %1974, %1982
  %1984 = load i32, ptr %12, align 4, !tbaa !10
  %1985 = lshr i32 %1984, 24
  %1986 = trunc i32 %1985 to i8
  %1987 = zext i8 %1986 to i32
  %1988 = and i32 %1987, 255
  %1989 = sext i32 %1988 to i64
  %1990 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %1989
  %1991 = load i32, ptr %1990, align 4, !tbaa !10
  %1992 = xor i32 %1983, %1991
  store i32 %1992, ptr %12, align 4, !tbaa !10
  %1993 = load i32, ptr %11, align 4, !tbaa !10
  %1994 = load i32, ptr %12, align 4, !tbaa !10
  %1995 = add i32 %1993, %1994
  %1996 = and i32 %1995, -1
  store i32 %1996, ptr %11, align 4, !tbaa !10
  %1997 = load i32, ptr %11, align 4, !tbaa !10
  %1998 = load i32, ptr %9, align 4, !tbaa !10
  %1999 = xor i32 %1998, %1997
  store i32 %1999, ptr %9, align 4, !tbaa !10
  %2000 = load i32, ptr %12, align 4, !tbaa !10
  %2001 = load i32, ptr %10, align 4, !tbaa !10
  %2002 = xor i32 %2001, %2000
  store i32 %2002, ptr %10, align 4, !tbaa !10
  %2003 = load i32, ptr %9, align 4, !tbaa !10
  %2004 = load ptr, ptr %6, align 8, !tbaa !5
  %2005 = getelementptr inbounds %struct.seed_key_st, ptr %2004, i32 0, i32 0
  %2006 = getelementptr inbounds [32 x i32], ptr %2005, i64 0, i64 2
  %2007 = load i32, ptr %2006, align 4, !tbaa !10
  %2008 = xor i32 %2003, %2007
  store i32 %2008, ptr %11, align 4, !tbaa !10
  %2009 = load i32, ptr %10, align 4, !tbaa !10
  %2010 = load ptr, ptr %6, align 8, !tbaa !5
  %2011 = getelementptr inbounds %struct.seed_key_st, ptr %2010, i32 0, i32 0
  %2012 = getelementptr inbounds [32 x i32], ptr %2011, i64 0, i64 3
  %2013 = load i32, ptr %2012, align 4, !tbaa !10
  %2014 = xor i32 %2009, %2013
  store i32 %2014, ptr %12, align 4, !tbaa !10
  %2015 = load i32, ptr %11, align 4, !tbaa !10
  %2016 = load i32, ptr %12, align 4, !tbaa !10
  %2017 = xor i32 %2016, %2015
  store i32 %2017, ptr %12, align 4, !tbaa !10
  %2018 = load i32, ptr %12, align 4, !tbaa !10
  %2019 = trunc i32 %2018 to i8
  %2020 = zext i8 %2019 to i32
  %2021 = and i32 %2020, 255
  %2022 = sext i32 %2021 to i64
  %2023 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %2022
  %2024 = load i32, ptr %2023, align 4, !tbaa !10
  %2025 = load i32, ptr %12, align 4, !tbaa !10
  %2026 = lshr i32 %2025, 8
  %2027 = trunc i32 %2026 to i8
  %2028 = zext i8 %2027 to i32
  %2029 = and i32 %2028, 255
  %2030 = sext i32 %2029 to i64
  %2031 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %2030
  %2032 = load i32, ptr %2031, align 4, !tbaa !10
  %2033 = xor i32 %2024, %2032
  %2034 = load i32, ptr %12, align 4, !tbaa !10
  %2035 = lshr i32 %2034, 16
  %2036 = trunc i32 %2035 to i8
  %2037 = zext i8 %2036 to i32
  %2038 = and i32 %2037, 255
  %2039 = sext i32 %2038 to i64
  %2040 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %2039
  %2041 = load i32, ptr %2040, align 4, !tbaa !10
  %2042 = xor i32 %2033, %2041
  %2043 = load i32, ptr %12, align 4, !tbaa !10
  %2044 = lshr i32 %2043, 24
  %2045 = trunc i32 %2044 to i8
  %2046 = zext i8 %2045 to i32
  %2047 = and i32 %2046, 255
  %2048 = sext i32 %2047 to i64
  %2049 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %2048
  %2050 = load i32, ptr %2049, align 4, !tbaa !10
  %2051 = xor i32 %2042, %2050
  store i32 %2051, ptr %12, align 4, !tbaa !10
  %2052 = load i32, ptr %11, align 4, !tbaa !10
  %2053 = load i32, ptr %12, align 4, !tbaa !10
  %2054 = add i32 %2052, %2053
  %2055 = and i32 %2054, -1
  store i32 %2055, ptr %11, align 4, !tbaa !10
  %2056 = load i32, ptr %11, align 4, !tbaa !10
  %2057 = trunc i32 %2056 to i8
  %2058 = zext i8 %2057 to i32
  %2059 = and i32 %2058, 255
  %2060 = sext i32 %2059 to i64
  %2061 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %2060
  %2062 = load i32, ptr %2061, align 4, !tbaa !10
  %2063 = load i32, ptr %11, align 4, !tbaa !10
  %2064 = lshr i32 %2063, 8
  %2065 = trunc i32 %2064 to i8
  %2066 = zext i8 %2065 to i32
  %2067 = and i32 %2066, 255
  %2068 = sext i32 %2067 to i64
  %2069 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %2068
  %2070 = load i32, ptr %2069, align 4, !tbaa !10
  %2071 = xor i32 %2062, %2070
  %2072 = load i32, ptr %11, align 4, !tbaa !10
  %2073 = lshr i32 %2072, 16
  %2074 = trunc i32 %2073 to i8
  %2075 = zext i8 %2074 to i32
  %2076 = and i32 %2075, 255
  %2077 = sext i32 %2076 to i64
  %2078 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %2077
  %2079 = load i32, ptr %2078, align 4, !tbaa !10
  %2080 = xor i32 %2071, %2079
  %2081 = load i32, ptr %11, align 4, !tbaa !10
  %2082 = lshr i32 %2081, 24
  %2083 = trunc i32 %2082 to i8
  %2084 = zext i8 %2083 to i32
  %2085 = and i32 %2084, 255
  %2086 = sext i32 %2085 to i64
  %2087 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %2086
  %2088 = load i32, ptr %2087, align 4, !tbaa !10
  %2089 = xor i32 %2080, %2088
  store i32 %2089, ptr %11, align 4, !tbaa !10
  %2090 = load i32, ptr %12, align 4, !tbaa !10
  %2091 = load i32, ptr %11, align 4, !tbaa !10
  %2092 = add i32 %2090, %2091
  %2093 = and i32 %2092, -1
  store i32 %2093, ptr %12, align 4, !tbaa !10
  %2094 = load i32, ptr %12, align 4, !tbaa !10
  %2095 = trunc i32 %2094 to i8
  %2096 = zext i8 %2095 to i32
  %2097 = and i32 %2096, 255
  %2098 = sext i32 %2097 to i64
  %2099 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %2098
  %2100 = load i32, ptr %2099, align 4, !tbaa !10
  %2101 = load i32, ptr %12, align 4, !tbaa !10
  %2102 = lshr i32 %2101, 8
  %2103 = trunc i32 %2102 to i8
  %2104 = zext i8 %2103 to i32
  %2105 = and i32 %2104, 255
  %2106 = sext i32 %2105 to i64
  %2107 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %2106
  %2108 = load i32, ptr %2107, align 4, !tbaa !10
  %2109 = xor i32 %2100, %2108
  %2110 = load i32, ptr %12, align 4, !tbaa !10
  %2111 = lshr i32 %2110, 16
  %2112 = trunc i32 %2111 to i8
  %2113 = zext i8 %2112 to i32
  %2114 = and i32 %2113, 255
  %2115 = sext i32 %2114 to i64
  %2116 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %2115
  %2117 = load i32, ptr %2116, align 4, !tbaa !10
  %2118 = xor i32 %2109, %2117
  %2119 = load i32, ptr %12, align 4, !tbaa !10
  %2120 = lshr i32 %2119, 24
  %2121 = trunc i32 %2120 to i8
  %2122 = zext i8 %2121 to i32
  %2123 = and i32 %2122, 255
  %2124 = sext i32 %2123 to i64
  %2125 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %2124
  %2126 = load i32, ptr %2125, align 4, !tbaa !10
  %2127 = xor i32 %2118, %2126
  store i32 %2127, ptr %12, align 4, !tbaa !10
  %2128 = load i32, ptr %11, align 4, !tbaa !10
  %2129 = load i32, ptr %12, align 4, !tbaa !10
  %2130 = add i32 %2128, %2129
  %2131 = and i32 %2130, -1
  store i32 %2131, ptr %11, align 4, !tbaa !10
  %2132 = load i32, ptr %11, align 4, !tbaa !10
  %2133 = load i32, ptr %7, align 4, !tbaa !10
  %2134 = xor i32 %2133, %2132
  store i32 %2134, ptr %7, align 4, !tbaa !10
  %2135 = load i32, ptr %12, align 4, !tbaa !10
  %2136 = load i32, ptr %8, align 4, !tbaa !10
  %2137 = xor i32 %2136, %2135
  store i32 %2137, ptr %8, align 4, !tbaa !10
  %2138 = load i32, ptr %7, align 4, !tbaa !10
  %2139 = load ptr, ptr %6, align 8, !tbaa !5
  %2140 = getelementptr inbounds %struct.seed_key_st, ptr %2139, i32 0, i32 0
  %2141 = getelementptr inbounds [32 x i32], ptr %2140, i64 0, i64 0
  %2142 = load i32, ptr %2141, align 4, !tbaa !10
  %2143 = xor i32 %2138, %2142
  store i32 %2143, ptr %11, align 4, !tbaa !10
  %2144 = load i32, ptr %8, align 4, !tbaa !10
  %2145 = load ptr, ptr %6, align 8, !tbaa !5
  %2146 = getelementptr inbounds %struct.seed_key_st, ptr %2145, i32 0, i32 0
  %2147 = getelementptr inbounds [32 x i32], ptr %2146, i64 0, i64 1
  %2148 = load i32, ptr %2147, align 4, !tbaa !10
  %2149 = xor i32 %2144, %2148
  store i32 %2149, ptr %12, align 4, !tbaa !10
  %2150 = load i32, ptr %11, align 4, !tbaa !10
  %2151 = load i32, ptr %12, align 4, !tbaa !10
  %2152 = xor i32 %2151, %2150
  store i32 %2152, ptr %12, align 4, !tbaa !10
  %2153 = load i32, ptr %12, align 4, !tbaa !10
  %2154 = trunc i32 %2153 to i8
  %2155 = zext i8 %2154 to i32
  %2156 = and i32 %2155, 255
  %2157 = sext i32 %2156 to i64
  %2158 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %2157
  %2159 = load i32, ptr %2158, align 4, !tbaa !10
  %2160 = load i32, ptr %12, align 4, !tbaa !10
  %2161 = lshr i32 %2160, 8
  %2162 = trunc i32 %2161 to i8
  %2163 = zext i8 %2162 to i32
  %2164 = and i32 %2163, 255
  %2165 = sext i32 %2164 to i64
  %2166 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %2165
  %2167 = load i32, ptr %2166, align 4, !tbaa !10
  %2168 = xor i32 %2159, %2167
  %2169 = load i32, ptr %12, align 4, !tbaa !10
  %2170 = lshr i32 %2169, 16
  %2171 = trunc i32 %2170 to i8
  %2172 = zext i8 %2171 to i32
  %2173 = and i32 %2172, 255
  %2174 = sext i32 %2173 to i64
  %2175 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %2174
  %2176 = load i32, ptr %2175, align 4, !tbaa !10
  %2177 = xor i32 %2168, %2176
  %2178 = load i32, ptr %12, align 4, !tbaa !10
  %2179 = lshr i32 %2178, 24
  %2180 = trunc i32 %2179 to i8
  %2181 = zext i8 %2180 to i32
  %2182 = and i32 %2181, 255
  %2183 = sext i32 %2182 to i64
  %2184 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %2183
  %2185 = load i32, ptr %2184, align 4, !tbaa !10
  %2186 = xor i32 %2177, %2185
  store i32 %2186, ptr %12, align 4, !tbaa !10
  %2187 = load i32, ptr %11, align 4, !tbaa !10
  %2188 = load i32, ptr %12, align 4, !tbaa !10
  %2189 = add i32 %2187, %2188
  %2190 = and i32 %2189, -1
  store i32 %2190, ptr %11, align 4, !tbaa !10
  %2191 = load i32, ptr %11, align 4, !tbaa !10
  %2192 = trunc i32 %2191 to i8
  %2193 = zext i8 %2192 to i32
  %2194 = and i32 %2193, 255
  %2195 = sext i32 %2194 to i64
  %2196 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %2195
  %2197 = load i32, ptr %2196, align 4, !tbaa !10
  %2198 = load i32, ptr %11, align 4, !tbaa !10
  %2199 = lshr i32 %2198, 8
  %2200 = trunc i32 %2199 to i8
  %2201 = zext i8 %2200 to i32
  %2202 = and i32 %2201, 255
  %2203 = sext i32 %2202 to i64
  %2204 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %2203
  %2205 = load i32, ptr %2204, align 4, !tbaa !10
  %2206 = xor i32 %2197, %2205
  %2207 = load i32, ptr %11, align 4, !tbaa !10
  %2208 = lshr i32 %2207, 16
  %2209 = trunc i32 %2208 to i8
  %2210 = zext i8 %2209 to i32
  %2211 = and i32 %2210, 255
  %2212 = sext i32 %2211 to i64
  %2213 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %2212
  %2214 = load i32, ptr %2213, align 4, !tbaa !10
  %2215 = xor i32 %2206, %2214
  %2216 = load i32, ptr %11, align 4, !tbaa !10
  %2217 = lshr i32 %2216, 24
  %2218 = trunc i32 %2217 to i8
  %2219 = zext i8 %2218 to i32
  %2220 = and i32 %2219, 255
  %2221 = sext i32 %2220 to i64
  %2222 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %2221
  %2223 = load i32, ptr %2222, align 4, !tbaa !10
  %2224 = xor i32 %2215, %2223
  store i32 %2224, ptr %11, align 4, !tbaa !10
  %2225 = load i32, ptr %12, align 4, !tbaa !10
  %2226 = load i32, ptr %11, align 4, !tbaa !10
  %2227 = add i32 %2225, %2226
  %2228 = and i32 %2227, -1
  store i32 %2228, ptr %12, align 4, !tbaa !10
  %2229 = load i32, ptr %12, align 4, !tbaa !10
  %2230 = trunc i32 %2229 to i8
  %2231 = zext i8 %2230 to i32
  %2232 = and i32 %2231, 255
  %2233 = sext i32 %2232 to i64
  %2234 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %2233
  %2235 = load i32, ptr %2234, align 4, !tbaa !10
  %2236 = load i32, ptr %12, align 4, !tbaa !10
  %2237 = lshr i32 %2236, 8
  %2238 = trunc i32 %2237 to i8
  %2239 = zext i8 %2238 to i32
  %2240 = and i32 %2239, 255
  %2241 = sext i32 %2240 to i64
  %2242 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 1), i64 0, i64 %2241
  %2243 = load i32, ptr %2242, align 4, !tbaa !10
  %2244 = xor i32 %2235, %2243
  %2245 = load i32, ptr %12, align 4, !tbaa !10
  %2246 = lshr i32 %2245, 16
  %2247 = trunc i32 %2246 to i8
  %2248 = zext i8 %2247 to i32
  %2249 = and i32 %2248, 255
  %2250 = sext i32 %2249 to i64
  %2251 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 2), i64 0, i64 %2250
  %2252 = load i32, ptr %2251, align 4, !tbaa !10
  %2253 = xor i32 %2244, %2252
  %2254 = load i32, ptr %12, align 4, !tbaa !10
  %2255 = lshr i32 %2254, 24
  %2256 = trunc i32 %2255 to i8
  %2257 = zext i8 %2256 to i32
  %2258 = and i32 %2257, 255
  %2259 = sext i32 %2258 to i64
  %2260 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds ([4 x [256 x i32]], ptr @SS, i64 0, i64 3), i64 0, i64 %2259
  %2261 = load i32, ptr %2260, align 4, !tbaa !10
  %2262 = xor i32 %2253, %2261
  store i32 %2262, ptr %12, align 4, !tbaa !10
  %2263 = load i32, ptr %11, align 4, !tbaa !10
  %2264 = load i32, ptr %12, align 4, !tbaa !10
  %2265 = add i32 %2263, %2264
  %2266 = and i32 %2265, -1
  store i32 %2266, ptr %11, align 4, !tbaa !10
  %2267 = load i32, ptr %11, align 4, !tbaa !10
  %2268 = load i32, ptr %9, align 4, !tbaa !10
  %2269 = xor i32 %2268, %2267
  store i32 %2269, ptr %9, align 4, !tbaa !10
  %2270 = load i32, ptr %12, align 4, !tbaa !10
  %2271 = load i32, ptr %10, align 4, !tbaa !10
  %2272 = xor i32 %2271, %2270
  store i32 %2272, ptr %10, align 4, !tbaa !10
  %2273 = load i32, ptr %9, align 4, !tbaa !10
  %2274 = lshr i32 %2273, 24
  %2275 = trunc i32 %2274 to i8
  %2276 = zext i8 %2275 to i32
  %2277 = and i32 %2276, 255
  %2278 = trunc i32 %2277 to i8
  %2279 = load ptr, ptr %5, align 8, !tbaa !5
  %2280 = getelementptr inbounds i8, ptr %2279, i64 0
  store i8 %2278, ptr %2280, align 1, !tbaa !9
  %2281 = load i32, ptr %9, align 4, !tbaa !10
  %2282 = lshr i32 %2281, 16
  %2283 = trunc i32 %2282 to i8
  %2284 = zext i8 %2283 to i32
  %2285 = and i32 %2284, 255
  %2286 = trunc i32 %2285 to i8
  %2287 = load ptr, ptr %5, align 8, !tbaa !5
  %2288 = getelementptr inbounds i8, ptr %2287, i64 1
  store i8 %2286, ptr %2288, align 1, !tbaa !9
  %2289 = load i32, ptr %9, align 4, !tbaa !10
  %2290 = lshr i32 %2289, 8
  %2291 = trunc i32 %2290 to i8
  %2292 = zext i8 %2291 to i32
  %2293 = and i32 %2292, 255
  %2294 = trunc i32 %2293 to i8
  %2295 = load ptr, ptr %5, align 8, !tbaa !5
  %2296 = getelementptr inbounds i8, ptr %2295, i64 2
  store i8 %2294, ptr %2296, align 1, !tbaa !9
  %2297 = load i32, ptr %9, align 4, !tbaa !10
  %2298 = trunc i32 %2297 to i8
  %2299 = zext i8 %2298 to i32
  %2300 = and i32 %2299, 255
  %2301 = trunc i32 %2300 to i8
  %2302 = load ptr, ptr %5, align 8, !tbaa !5
  %2303 = getelementptr inbounds i8, ptr %2302, i64 3
  store i8 %2301, ptr %2303, align 1, !tbaa !9
  %2304 = load i32, ptr %10, align 4, !tbaa !10
  %2305 = lshr i32 %2304, 24
  %2306 = trunc i32 %2305 to i8
  %2307 = zext i8 %2306 to i32
  %2308 = and i32 %2307, 255
  %2309 = trunc i32 %2308 to i8
  %2310 = load ptr, ptr %5, align 8, !tbaa !5
  %2311 = getelementptr inbounds i8, ptr %2310, i64 4
  %2312 = getelementptr inbounds i8, ptr %2311, i64 0
  store i8 %2309, ptr %2312, align 1, !tbaa !9
  %2313 = load i32, ptr %10, align 4, !tbaa !10
  %2314 = lshr i32 %2313, 16
  %2315 = trunc i32 %2314 to i8
  %2316 = zext i8 %2315 to i32
  %2317 = and i32 %2316, 255
  %2318 = trunc i32 %2317 to i8
  %2319 = load ptr, ptr %5, align 8, !tbaa !5
  %2320 = getelementptr inbounds i8, ptr %2319, i64 4
  %2321 = getelementptr inbounds i8, ptr %2320, i64 1
  store i8 %2318, ptr %2321, align 1, !tbaa !9
  %2322 = load i32, ptr %10, align 4, !tbaa !10
  %2323 = lshr i32 %2322, 8
  %2324 = trunc i32 %2323 to i8
  %2325 = zext i8 %2324 to i32
  %2326 = and i32 %2325, 255
  %2327 = trunc i32 %2326 to i8
  %2328 = load ptr, ptr %5, align 8, !tbaa !5
  %2329 = getelementptr inbounds i8, ptr %2328, i64 4
  %2330 = getelementptr inbounds i8, ptr %2329, i64 2
  store i8 %2327, ptr %2330, align 1, !tbaa !9
  %2331 = load i32, ptr %10, align 4, !tbaa !10
  %2332 = trunc i32 %2331 to i8
  %2333 = zext i8 %2332 to i32
  %2334 = and i32 %2333, 255
  %2335 = trunc i32 %2334 to i8
  %2336 = load ptr, ptr %5, align 8, !tbaa !5
  %2337 = getelementptr inbounds i8, ptr %2336, i64 4
  %2338 = getelementptr inbounds i8, ptr %2337, i64 3
  store i8 %2335, ptr %2338, align 1, !tbaa !9
  %2339 = load i32, ptr %7, align 4, !tbaa !10
  %2340 = lshr i32 %2339, 24
  %2341 = trunc i32 %2340 to i8
  %2342 = zext i8 %2341 to i32
  %2343 = and i32 %2342, 255
  %2344 = trunc i32 %2343 to i8
  %2345 = load ptr, ptr %5, align 8, !tbaa !5
  %2346 = getelementptr inbounds i8, ptr %2345, i64 8
  %2347 = getelementptr inbounds i8, ptr %2346, i64 0
  store i8 %2344, ptr %2347, align 1, !tbaa !9
  %2348 = load i32, ptr %7, align 4, !tbaa !10
  %2349 = lshr i32 %2348, 16
  %2350 = trunc i32 %2349 to i8
  %2351 = zext i8 %2350 to i32
  %2352 = and i32 %2351, 255
  %2353 = trunc i32 %2352 to i8
  %2354 = load ptr, ptr %5, align 8, !tbaa !5
  %2355 = getelementptr inbounds i8, ptr %2354, i64 8
  %2356 = getelementptr inbounds i8, ptr %2355, i64 1
  store i8 %2353, ptr %2356, align 1, !tbaa !9
  %2357 = load i32, ptr %7, align 4, !tbaa !10
  %2358 = lshr i32 %2357, 8
  %2359 = trunc i32 %2358 to i8
  %2360 = zext i8 %2359 to i32
  %2361 = and i32 %2360, 255
  %2362 = trunc i32 %2361 to i8
  %2363 = load ptr, ptr %5, align 8, !tbaa !5
  %2364 = getelementptr inbounds i8, ptr %2363, i64 8
  %2365 = getelementptr inbounds i8, ptr %2364, i64 2
  store i8 %2362, ptr %2365, align 1, !tbaa !9
  %2366 = load i32, ptr %7, align 4, !tbaa !10
  %2367 = trunc i32 %2366 to i8
  %2368 = zext i8 %2367 to i32
  %2369 = and i32 %2368, 255
  %2370 = trunc i32 %2369 to i8
  %2371 = load ptr, ptr %5, align 8, !tbaa !5
  %2372 = getelementptr inbounds i8, ptr %2371, i64 8
  %2373 = getelementptr inbounds i8, ptr %2372, i64 3
  store i8 %2370, ptr %2373, align 1, !tbaa !9
  %2374 = load i32, ptr %8, align 4, !tbaa !10
  %2375 = lshr i32 %2374, 24
  %2376 = trunc i32 %2375 to i8
  %2377 = zext i8 %2376 to i32
  %2378 = and i32 %2377, 255
  %2379 = trunc i32 %2378 to i8
  %2380 = load ptr, ptr %5, align 8, !tbaa !5
  %2381 = getelementptr inbounds i8, ptr %2380, i64 12
  %2382 = getelementptr inbounds i8, ptr %2381, i64 0
  store i8 %2379, ptr %2382, align 1, !tbaa !9
  %2383 = load i32, ptr %8, align 4, !tbaa !10
  %2384 = lshr i32 %2383, 16
  %2385 = trunc i32 %2384 to i8
  %2386 = zext i8 %2385 to i32
  %2387 = and i32 %2386, 255
  %2388 = trunc i32 %2387 to i8
  %2389 = load ptr, ptr %5, align 8, !tbaa !5
  %2390 = getelementptr inbounds i8, ptr %2389, i64 12
  %2391 = getelementptr inbounds i8, ptr %2390, i64 1
  store i8 %2388, ptr %2391, align 1, !tbaa !9
  %2392 = load i32, ptr %8, align 4, !tbaa !10
  %2393 = lshr i32 %2392, 8
  %2394 = trunc i32 %2393 to i8
  %2395 = zext i8 %2394 to i32
  %2396 = and i32 %2395, 255
  %2397 = trunc i32 %2396 to i8
  %2398 = load ptr, ptr %5, align 8, !tbaa !5
  %2399 = getelementptr inbounds i8, ptr %2398, i64 12
  %2400 = getelementptr inbounds i8, ptr %2399, i64 2
  store i8 %2397, ptr %2400, align 1, !tbaa !9
  %2401 = load i32, ptr %8, align 4, !tbaa !10
  %2402 = trunc i32 %2401 to i8
  %2403 = zext i8 %2402 to i32
  %2404 = and i32 %2403, 255
  %2405 = trunc i32 %2404 to i8
  %2406 = load ptr, ptr %5, align 8, !tbaa !5
  %2407 = getelementptr inbounds i8, ptr %2406, i64 12
  %2408 = getelementptr inbounds i8, ptr %2407, i64 3
  store i8 %2405, ptr %2408, align 1, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #2
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #2
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #2
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #2
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #2
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #2
  ret void
}

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 = { 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}
!10 = !{!11, !11, i64 0}
!11 = !{!"int", !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"

@SS = external hidden local_unnamed_addr constant [4 x [256 x i32]], align 16

; Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
define dso_local void @SEED_decrypt(ptr nocapture noundef readonly %0, ptr nocapture noundef writeonly %1, ptr nocapture noundef readonly %2) local_unnamed_addr #0 {
  %4 = load i8, ptr %0, align 1, !tbaa !5
  %5 = zext i8 %4 to i32
  %6 = shl nuw i32 %5, 24
  %7 = getelementptr inbounds i8, ptr %0, i64 1
  %8 = load i8, ptr %7, align 1, !tbaa !5
  %9 = zext i8 %8 to i32
  %10 = shl nuw nsw i32 %9, 16
  %11 = or disjoint i32 %10, %6
  %12 = getelementptr inbounds i8, ptr %0, i64 2
  %13 = load i8, ptr %12, align 1, !tbaa !5
  %14 = zext i8 %13 to i32
  %15 = shl nuw nsw i32 %14, 8
  %16 = or disjoint i32 %11, %15
  %17 = getelementptr inbounds i8, ptr %0, i64 3
  %18 = load i8, ptr %17, align 1, !tbaa !5
  %19 = zext i8 %18 to i32
  %20 = or disjoint i32 %16, %19
  %21 = getelementptr inbounds i8, ptr %0, i64 4
  %22 = load i8, ptr %21, align 1, !tbaa !5
  %23 = zext i8 %22 to i32
  %24 = shl nuw i32 %23, 24
  %25 = getelementptr inbounds i8, ptr %0, i64 5
  %26 = load i8, ptr %25, align 1, !tbaa !5
  %27 = zext i8 %26 to i32
  %28 = shl nuw nsw i32 %27, 16
  %29 = or disjoint i32 %28, %24
  %30 = getelementptr inbounds i8, ptr %0, i64 6
  %31 = load i8, ptr %30, align 1, !tbaa !5
  %32 = zext i8 %31 to i32
  %33 = shl nuw nsw i32 %32, 8
  %34 = or disjoint i32 %29, %33
  %35 = getelementptr inbounds i8, ptr %0, i64 7
  %36 = load i8, ptr %35, align 1, !tbaa !5
  %37 = zext i8 %36 to i32
  %38 = or disjoint i32 %34, %37
  %39 = getelementptr inbounds i8, ptr %0, i64 8
  %40 = load i8, ptr %39, align 1, !tbaa !5
  %41 = zext i8 %40 to i32
  %42 = shl nuw i32 %41, 24
  %43 = getelementptr inbounds i8, ptr %0, i64 9
  %44 = load i8, ptr %43, align 1, !tbaa !5
  %45 = zext i8 %44 to i32
  %46 = shl nuw nsw i32 %45, 16
  %47 = or disjoint i32 %46, %42
  %48 = getelementptr inbounds i8, ptr %0, i64 10
  %49 = load i8, ptr %48, align 1, !tbaa !5
  %50 = zext i8 %49 to i32
  %51 = shl nuw nsw i32 %50, 8
  %52 = or disjoint i32 %47, %51
  %53 = getelementptr inbounds i8, ptr %0, i64 11
  %54 = load i8, ptr %53, align 1, !tbaa !5
  %55 = zext i8 %54 to i32
  %56 = or disjoint i32 %52, %55
  %57 = getelementptr inbounds i8, ptr %0, i64 12
  %58 = load i8, ptr %57, align 1, !tbaa !5
  %59 = zext i8 %58 to i32
  %60 = shl nuw i32 %59, 24
  %61 = getelementptr inbounds i8, ptr %0, i64 13
  %62 = load i8, ptr %61, align 1, !tbaa !5
  %63 = zext i8 %62 to i32
  %64 = shl nuw nsw i32 %63, 16
  %65 = or disjoint i32 %64, %60
  %66 = getelementptr inbounds i8, ptr %0, i64 14
  %67 = load i8, ptr %66, align 1, !tbaa !5
  %68 = zext i8 %67 to i32
  %69 = shl nuw nsw i32 %68, 8
  %70 = or disjoint i32 %65, %69
  %71 = getelementptr inbounds i8, ptr %0, i64 15
  %72 = load i8, ptr %71, align 1, !tbaa !5
  %73 = zext i8 %72 to i32
  %74 = or disjoint i32 %70, %73
  %75 = getelementptr inbounds i8, ptr %2, i64 120
  %76 = load i32, ptr %75, align 4, !tbaa !8
  %77 = xor i32 %76, %56
  %78 = getelementptr inbounds i8, ptr %2, i64 124
  %79 = load i32, ptr %78, align 4, !tbaa !8
  %80 = xor i32 %77, %79
  %81 = xor i32 %80, %74
  %82 = and i32 %81, 255
  %83 = zext nneg i32 %82 to i64
  %84 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %83
  %85 = load i32, ptr %84, align 4, !tbaa !8
  %86 = lshr i32 %81, 8
  %87 = and i32 %86, 255
  %88 = zext nneg i32 %87 to i64
  %89 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %88
  %90 = load i32, ptr %89, align 4, !tbaa !8
  %91 = xor i32 %90, %85
  %92 = lshr i32 %81, 16
  %93 = and i32 %92, 255
  %94 = zext nneg i32 %93 to i64
  %95 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %94
  %96 = load i32, ptr %95, align 4, !tbaa !8
  %97 = xor i32 %91, %96
  %98 = lshr i32 %81, 24
  %99 = zext nneg i32 %98 to i64
  %100 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %99
  %101 = load i32, ptr %100, align 4, !tbaa !8
  %102 = xor i32 %97, %101
  %103 = add i32 %102, %77
  %104 = and i32 %103, 255
  %105 = zext nneg i32 %104 to i64
  %106 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %105
  %107 = load i32, ptr %106, align 4, !tbaa !8
  %108 = lshr i32 %103, 8
  %109 = and i32 %108, 255
  %110 = zext nneg i32 %109 to i64
  %111 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %110
  %112 = load i32, ptr %111, align 4, !tbaa !8
  %113 = xor i32 %112, %107
  %114 = lshr i32 %103, 16
  %115 = and i32 %114, 255
  %116 = zext nneg i32 %115 to i64
  %117 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %116
  %118 = load i32, ptr %117, align 4, !tbaa !8
  %119 = xor i32 %113, %118
  %120 = lshr i32 %103, 24
  %121 = zext nneg i32 %120 to i64
  %122 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %121
  %123 = load i32, ptr %122, align 4, !tbaa !8
  %124 = xor i32 %119, %123
  %125 = add i32 %124, %102
  %126 = and i32 %125, 255
  %127 = zext nneg i32 %126 to i64
  %128 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %127
  %129 = load i32, ptr %128, align 4, !tbaa !8
  %130 = lshr i32 %125, 8
  %131 = and i32 %130, 255
  %132 = zext nneg i32 %131 to i64
  %133 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %132
  %134 = load i32, ptr %133, align 4, !tbaa !8
  %135 = xor i32 %134, %129
  %136 = lshr i32 %125, 16
  %137 = and i32 %136, 255
  %138 = zext nneg i32 %137 to i64
  %139 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %138
  %140 = load i32, ptr %139, align 4, !tbaa !8
  %141 = xor i32 %135, %140
  %142 = lshr i32 %125, 24
  %143 = zext nneg i32 %142 to i64
  %144 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %143
  %145 = load i32, ptr %144, align 4, !tbaa !8
  %146 = xor i32 %141, %145
  %147 = add i32 %146, %124
  %148 = xor i32 %147, %20
  %149 = xor i32 %146, %38
  %150 = getelementptr inbounds i8, ptr %2, i64 112
  %151 = load i32, ptr %150, align 4, !tbaa !8
  %152 = xor i32 %148, %151
  %153 = getelementptr inbounds i8, ptr %2, i64 116
  %154 = load i32, ptr %153, align 4, !tbaa !8
  %155 = xor i32 %149, %154
  %156 = xor i32 %155, %152
  %157 = and i32 %156, 255
  %158 = zext nneg i32 %157 to i64
  %159 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %158
  %160 = load i32, ptr %159, align 4, !tbaa !8
  %161 = lshr i32 %156, 8
  %162 = and i32 %161, 255
  %163 = zext nneg i32 %162 to i64
  %164 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %163
  %165 = load i32, ptr %164, align 4, !tbaa !8
  %166 = xor i32 %165, %160
  %167 = lshr i32 %156, 16
  %168 = and i32 %167, 255
  %169 = zext nneg i32 %168 to i64
  %170 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %169
  %171 = load i32, ptr %170, align 4, !tbaa !8
  %172 = xor i32 %166, %171
  %173 = lshr i32 %156, 24
  %174 = zext nneg i32 %173 to i64
  %175 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %174
  %176 = load i32, ptr %175, align 4, !tbaa !8
  %177 = xor i32 %172, %176
  %178 = add i32 %177, %152
  %179 = and i32 %178, 255
  %180 = zext nneg i32 %179 to i64
  %181 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %180
  %182 = load i32, ptr %181, align 4, !tbaa !8
  %183 = lshr i32 %178, 8
  %184 = and i32 %183, 255
  %185 = zext nneg i32 %184 to i64
  %186 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %185
  %187 = load i32, ptr %186, align 4, !tbaa !8
  %188 = xor i32 %187, %182
  %189 = lshr i32 %178, 16
  %190 = and i32 %189, 255
  %191 = zext nneg i32 %190 to i64
  %192 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %191
  %193 = load i32, ptr %192, align 4, !tbaa !8
  %194 = xor i32 %188, %193
  %195 = lshr i32 %178, 24
  %196 = zext nneg i32 %195 to i64
  %197 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %196
  %198 = load i32, ptr %197, align 4, !tbaa !8
  %199 = xor i32 %194, %198
  %200 = add i32 %199, %177
  %201 = and i32 %200, 255
  %202 = zext nneg i32 %201 to i64
  %203 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %202
  %204 = load i32, ptr %203, align 4, !tbaa !8
  %205 = lshr i32 %200, 8
  %206 = and i32 %205, 255
  %207 = zext nneg i32 %206 to i64
  %208 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %207
  %209 = load i32, ptr %208, align 4, !tbaa !8
  %210 = xor i32 %209, %204
  %211 = lshr i32 %200, 16
  %212 = and i32 %211, 255
  %213 = zext nneg i32 %212 to i64
  %214 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %213
  %215 = load i32, ptr %214, align 4, !tbaa !8
  %216 = xor i32 %210, %215
  %217 = lshr i32 %200, 24
  %218 = zext nneg i32 %217 to i64
  %219 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %218
  %220 = load i32, ptr %219, align 4, !tbaa !8
  %221 = xor i32 %216, %220
  %222 = add i32 %221, %199
  %223 = xor i32 %222, %56
  %224 = xor i32 %221, %74
  %225 = getelementptr inbounds i8, ptr %2, i64 104
  %226 = load i32, ptr %225, align 4, !tbaa !8
  %227 = xor i32 %223, %226
  %228 = getelementptr inbounds i8, ptr %2, i64 108
  %229 = load i32, ptr %228, align 4, !tbaa !8
  %230 = xor i32 %224, %229
  %231 = xor i32 %230, %227
  %232 = and i32 %231, 255
  %233 = zext nneg i32 %232 to i64
  %234 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %233
  %235 = load i32, ptr %234, align 4, !tbaa !8
  %236 = lshr i32 %231, 8
  %237 = and i32 %236, 255
  %238 = zext nneg i32 %237 to i64
  %239 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %238
  %240 = load i32, ptr %239, align 4, !tbaa !8
  %241 = xor i32 %240, %235
  %242 = lshr i32 %231, 16
  %243 = and i32 %242, 255
  %244 = zext nneg i32 %243 to i64
  %245 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %244
  %246 = load i32, ptr %245, align 4, !tbaa !8
  %247 = xor i32 %241, %246
  %248 = lshr i32 %231, 24
  %249 = zext nneg i32 %248 to i64
  %250 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %249
  %251 = load i32, ptr %250, align 4, !tbaa !8
  %252 = xor i32 %247, %251
  %253 = add i32 %252, %227
  %254 = and i32 %253, 255
  %255 = zext nneg i32 %254 to i64
  %256 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %255
  %257 = load i32, ptr %256, align 4, !tbaa !8
  %258 = lshr i32 %253, 8
  %259 = and i32 %258, 255
  %260 = zext nneg i32 %259 to i64
  %261 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %260
  %262 = load i32, ptr %261, align 4, !tbaa !8
  %263 = xor i32 %262, %257
  %264 = lshr i32 %253, 16
  %265 = and i32 %264, 255
  %266 = zext nneg i32 %265 to i64
  %267 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %266
  %268 = load i32, ptr %267, align 4, !tbaa !8
  %269 = xor i32 %263, %268
  %270 = lshr i32 %253, 24
  %271 = zext nneg i32 %270 to i64
  %272 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %271
  %273 = load i32, ptr %272, align 4, !tbaa !8
  %274 = xor i32 %269, %273
  %275 = add i32 %274, %252
  %276 = and i32 %275, 255
  %277 = zext nneg i32 %276 to i64
  %278 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %277
  %279 = load i32, ptr %278, align 4, !tbaa !8
  %280 = lshr i32 %275, 8
  %281 = and i32 %280, 255
  %282 = zext nneg i32 %281 to i64
  %283 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %282
  %284 = load i32, ptr %283, align 4, !tbaa !8
  %285 = xor i32 %284, %279
  %286 = lshr i32 %275, 16
  %287 = and i32 %286, 255
  %288 = zext nneg i32 %287 to i64
  %289 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %288
  %290 = load i32, ptr %289, align 4, !tbaa !8
  %291 = xor i32 %285, %290
  %292 = lshr i32 %275, 24
  %293 = zext nneg i32 %292 to i64
  %294 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %293
  %295 = load i32, ptr %294, align 4, !tbaa !8
  %296 = xor i32 %291, %295
  %297 = add i32 %296, %274
  %298 = xor i32 %297, %148
  %299 = xor i32 %296, %149
  %300 = getelementptr inbounds i8, ptr %2, i64 96
  %301 = load i32, ptr %300, align 4, !tbaa !8
  %302 = xor i32 %298, %301
  %303 = getelementptr inbounds i8, ptr %2, i64 100
  %304 = load i32, ptr %303, align 4, !tbaa !8
  %305 = xor i32 %299, %304
  %306 = xor i32 %305, %302
  %307 = and i32 %306, 255
  %308 = zext nneg i32 %307 to i64
  %309 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %308
  %310 = load i32, ptr %309, align 4, !tbaa !8
  %311 = lshr i32 %306, 8
  %312 = and i32 %311, 255
  %313 = zext nneg i32 %312 to i64
  %314 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %313
  %315 = load i32, ptr %314, align 4, !tbaa !8
  %316 = xor i32 %315, %310
  %317 = lshr i32 %306, 16
  %318 = and i32 %317, 255
  %319 = zext nneg i32 %318 to i64
  %320 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %319
  %321 = load i32, ptr %320, align 4, !tbaa !8
  %322 = xor i32 %316, %321
  %323 = lshr i32 %306, 24
  %324 = zext nneg i32 %323 to i64
  %325 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %324
  %326 = load i32, ptr %325, align 4, !tbaa !8
  %327 = xor i32 %322, %326
  %328 = add i32 %327, %302
  %329 = and i32 %328, 255
  %330 = zext nneg i32 %329 to i64
  %331 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %330
  %332 = load i32, ptr %331, align 4, !tbaa !8
  %333 = lshr i32 %328, 8
  %334 = and i32 %333, 255
  %335 = zext nneg i32 %334 to i64
  %336 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %335
  %337 = load i32, ptr %336, align 4, !tbaa !8
  %338 = xor i32 %337, %332
  %339 = lshr i32 %328, 16
  %340 = and i32 %339, 255
  %341 = zext nneg i32 %340 to i64
  %342 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %341
  %343 = load i32, ptr %342, align 4, !tbaa !8
  %344 = xor i32 %338, %343
  %345 = lshr i32 %328, 24
  %346 = zext nneg i32 %345 to i64
  %347 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %346
  %348 = load i32, ptr %347, align 4, !tbaa !8
  %349 = xor i32 %344, %348
  %350 = add i32 %349, %327
  %351 = and i32 %350, 255
  %352 = zext nneg i32 %351 to i64
  %353 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %352
  %354 = load i32, ptr %353, align 4, !tbaa !8
  %355 = lshr i32 %350, 8
  %356 = and i32 %355, 255
  %357 = zext nneg i32 %356 to i64
  %358 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %357
  %359 = load i32, ptr %358, align 4, !tbaa !8
  %360 = xor i32 %359, %354
  %361 = lshr i32 %350, 16
  %362 = and i32 %361, 255
  %363 = zext nneg i32 %362 to i64
  %364 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %363
  %365 = load i32, ptr %364, align 4, !tbaa !8
  %366 = xor i32 %360, %365
  %367 = lshr i32 %350, 24
  %368 = zext nneg i32 %367 to i64
  %369 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %368
  %370 = load i32, ptr %369, align 4, !tbaa !8
  %371 = xor i32 %366, %370
  %372 = add i32 %371, %349
  %373 = xor i32 %372, %223
  %374 = xor i32 %371, %224
  %375 = getelementptr inbounds i8, ptr %2, i64 88
  %376 = load i32, ptr %375, align 4, !tbaa !8
  %377 = xor i32 %373, %376
  %378 = getelementptr inbounds i8, ptr %2, i64 92
  %379 = load i32, ptr %378, align 4, !tbaa !8
  %380 = xor i32 %374, %379
  %381 = xor i32 %380, %377
  %382 = and i32 %381, 255
  %383 = zext nneg i32 %382 to i64
  %384 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %383
  %385 = load i32, ptr %384, align 4, !tbaa !8
  %386 = lshr i32 %381, 8
  %387 = and i32 %386, 255
  %388 = zext nneg i32 %387 to i64
  %389 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %388
  %390 = load i32, ptr %389, align 4, !tbaa !8
  %391 = xor i32 %390, %385
  %392 = lshr i32 %381, 16
  %393 = and i32 %392, 255
  %394 = zext nneg i32 %393 to i64
  %395 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %394
  %396 = load i32, ptr %395, align 4, !tbaa !8
  %397 = xor i32 %391, %396
  %398 = lshr i32 %381, 24
  %399 = zext nneg i32 %398 to i64
  %400 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %399
  %401 = load i32, ptr %400, align 4, !tbaa !8
  %402 = xor i32 %397, %401
  %403 = add i32 %402, %377
  %404 = and i32 %403, 255
  %405 = zext nneg i32 %404 to i64
  %406 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %405
  %407 = load i32, ptr %406, align 4, !tbaa !8
  %408 = lshr i32 %403, 8
  %409 = and i32 %408, 255
  %410 = zext nneg i32 %409 to i64
  %411 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %410
  %412 = load i32, ptr %411, align 4, !tbaa !8
  %413 = xor i32 %412, %407
  %414 = lshr i32 %403, 16
  %415 = and i32 %414, 255
  %416 = zext nneg i32 %415 to i64
  %417 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %416
  %418 = load i32, ptr %417, align 4, !tbaa !8
  %419 = xor i32 %413, %418
  %420 = lshr i32 %403, 24
  %421 = zext nneg i32 %420 to i64
  %422 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %421
  %423 = load i32, ptr %422, align 4, !tbaa !8
  %424 = xor i32 %419, %423
  %425 = add i32 %424, %402
  %426 = and i32 %425, 255
  %427 = zext nneg i32 %426 to i64
  %428 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %427
  %429 = load i32, ptr %428, align 4, !tbaa !8
  %430 = lshr i32 %425, 8
  %431 = and i32 %430, 255
  %432 = zext nneg i32 %431 to i64
  %433 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %432
  %434 = load i32, ptr %433, align 4, !tbaa !8
  %435 = xor i32 %434, %429
  %436 = lshr i32 %425, 16
  %437 = and i32 %436, 255
  %438 = zext nneg i32 %437 to i64
  %439 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %438
  %440 = load i32, ptr %439, align 4, !tbaa !8
  %441 = xor i32 %435, %440
  %442 = lshr i32 %425, 24
  %443 = zext nneg i32 %442 to i64
  %444 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %443
  %445 = load i32, ptr %444, align 4, !tbaa !8
  %446 = xor i32 %441, %445
  %447 = add i32 %446, %424
  %448 = xor i32 %447, %298
  %449 = xor i32 %446, %299
  %450 = getelementptr inbounds i8, ptr %2, i64 80
  %451 = load i32, ptr %450, align 4, !tbaa !8
  %452 = xor i32 %448, %451
  %453 = getelementptr inbounds i8, ptr %2, i64 84
  %454 = load i32, ptr %453, align 4, !tbaa !8
  %455 = xor i32 %449, %454
  %456 = xor i32 %455, %452
  %457 = and i32 %456, 255
  %458 = zext nneg i32 %457 to i64
  %459 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %458
  %460 = load i32, ptr %459, align 4, !tbaa !8
  %461 = lshr i32 %456, 8
  %462 = and i32 %461, 255
  %463 = zext nneg i32 %462 to i64
  %464 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %463
  %465 = load i32, ptr %464, align 4, !tbaa !8
  %466 = xor i32 %465, %460
  %467 = lshr i32 %456, 16
  %468 = and i32 %467, 255
  %469 = zext nneg i32 %468 to i64
  %470 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %469
  %471 = load i32, ptr %470, align 4, !tbaa !8
  %472 = xor i32 %466, %471
  %473 = lshr i32 %456, 24
  %474 = zext nneg i32 %473 to i64
  %475 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %474
  %476 = load i32, ptr %475, align 4, !tbaa !8
  %477 = xor i32 %472, %476
  %478 = add i32 %477, %452
  %479 = and i32 %478, 255
  %480 = zext nneg i32 %479 to i64
  %481 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %480
  %482 = load i32, ptr %481, align 4, !tbaa !8
  %483 = lshr i32 %478, 8
  %484 = and i32 %483, 255
  %485 = zext nneg i32 %484 to i64
  %486 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %485
  %487 = load i32, ptr %486, align 4, !tbaa !8
  %488 = xor i32 %487, %482
  %489 = lshr i32 %478, 16
  %490 = and i32 %489, 255
  %491 = zext nneg i32 %490 to i64
  %492 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %491
  %493 = load i32, ptr %492, align 4, !tbaa !8
  %494 = xor i32 %488, %493
  %495 = lshr i32 %478, 24
  %496 = zext nneg i32 %495 to i64
  %497 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %496
  %498 = load i32, ptr %497, align 4, !tbaa !8
  %499 = xor i32 %494, %498
  %500 = add i32 %499, %477
  %501 = and i32 %500, 255
  %502 = zext nneg i32 %501 to i64
  %503 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %502
  %504 = load i32, ptr %503, align 4, !tbaa !8
  %505 = lshr i32 %500, 8
  %506 = and i32 %505, 255
  %507 = zext nneg i32 %506 to i64
  %508 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %507
  %509 = load i32, ptr %508, align 4, !tbaa !8
  %510 = xor i32 %509, %504
  %511 = lshr i32 %500, 16
  %512 = and i32 %511, 255
  %513 = zext nneg i32 %512 to i64
  %514 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %513
  %515 = load i32, ptr %514, align 4, !tbaa !8
  %516 = xor i32 %510, %515
  %517 = lshr i32 %500, 24
  %518 = zext nneg i32 %517 to i64
  %519 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %518
  %520 = load i32, ptr %519, align 4, !tbaa !8
  %521 = xor i32 %516, %520
  %522 = add i32 %521, %499
  %523 = xor i32 %522, %373
  %524 = xor i32 %521, %374
  %525 = getelementptr inbounds i8, ptr %2, i64 72
  %526 = load i32, ptr %525, align 4, !tbaa !8
  %527 = xor i32 %523, %526
  %528 = getelementptr inbounds i8, ptr %2, i64 76
  %529 = load i32, ptr %528, align 4, !tbaa !8
  %530 = xor i32 %524, %529
  %531 = xor i32 %530, %527
  %532 = and i32 %531, 255
  %533 = zext nneg i32 %532 to i64
  %534 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %533
  %535 = load i32, ptr %534, align 4, !tbaa !8
  %536 = lshr i32 %531, 8
  %537 = and i32 %536, 255
  %538 = zext nneg i32 %537 to i64
  %539 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %538
  %540 = load i32, ptr %539, align 4, !tbaa !8
  %541 = xor i32 %540, %535
  %542 = lshr i32 %531, 16
  %543 = and i32 %542, 255
  %544 = zext nneg i32 %543 to i64
  %545 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %544
  %546 = load i32, ptr %545, align 4, !tbaa !8
  %547 = xor i32 %541, %546
  %548 = lshr i32 %531, 24
  %549 = zext nneg i32 %548 to i64
  %550 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %549
  %551 = load i32, ptr %550, align 4, !tbaa !8
  %552 = xor i32 %547, %551
  %553 = add i32 %552, %527
  %554 = and i32 %553, 255
  %555 = zext nneg i32 %554 to i64
  %556 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %555
  %557 = load i32, ptr %556, align 4, !tbaa !8
  %558 = lshr i32 %553, 8
  %559 = and i32 %558, 255
  %560 = zext nneg i32 %559 to i64
  %561 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %560
  %562 = load i32, ptr %561, align 4, !tbaa !8
  %563 = xor i32 %562, %557
  %564 = lshr i32 %553, 16
  %565 = and i32 %564, 255
  %566 = zext nneg i32 %565 to i64
  %567 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %566
  %568 = load i32, ptr %567, align 4, !tbaa !8
  %569 = xor i32 %563, %568
  %570 = lshr i32 %553, 24
  %571 = zext nneg i32 %570 to i64
  %572 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %571
  %573 = load i32, ptr %572, align 4, !tbaa !8
  %574 = xor i32 %569, %573
  %575 = add i32 %574, %552
  %576 = and i32 %575, 255
  %577 = zext nneg i32 %576 to i64
  %578 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %577
  %579 = load i32, ptr %578, align 4, !tbaa !8
  %580 = lshr i32 %575, 8
  %581 = and i32 %580, 255
  %582 = zext nneg i32 %581 to i64
  %583 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %582
  %584 = load i32, ptr %583, align 4, !tbaa !8
  %585 = xor i32 %584, %579
  %586 = lshr i32 %575, 16
  %587 = and i32 %586, 255
  %588 = zext nneg i32 %587 to i64
  %589 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %588
  %590 = load i32, ptr %589, align 4, !tbaa !8
  %591 = xor i32 %585, %590
  %592 = lshr i32 %575, 24
  %593 = zext nneg i32 %592 to i64
  %594 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %593
  %595 = load i32, ptr %594, align 4, !tbaa !8
  %596 = xor i32 %591, %595
  %597 = add i32 %596, %574
  %598 = xor i32 %597, %448
  %599 = xor i32 %596, %449
  %600 = getelementptr inbounds i8, ptr %2, i64 64
  %601 = load i32, ptr %600, align 4, !tbaa !8
  %602 = xor i32 %598, %601
  %603 = getelementptr inbounds i8, ptr %2, i64 68
  %604 = load i32, ptr %603, align 4, !tbaa !8
  %605 = xor i32 %599, %604
  %606 = xor i32 %605, %602
  %607 = and i32 %606, 255
  %608 = zext nneg i32 %607 to i64
  %609 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %608
  %610 = load i32, ptr %609, align 4, !tbaa !8
  %611 = lshr i32 %606, 8
  %612 = and i32 %611, 255
  %613 = zext nneg i32 %612 to i64
  %614 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %613
  %615 = load i32, ptr %614, align 4, !tbaa !8
  %616 = xor i32 %615, %610
  %617 = lshr i32 %606, 16
  %618 = and i32 %617, 255
  %619 = zext nneg i32 %618 to i64
  %620 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %619
  %621 = load i32, ptr %620, align 4, !tbaa !8
  %622 = xor i32 %616, %621
  %623 = lshr i32 %606, 24
  %624 = zext nneg i32 %623 to i64
  %625 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %624
  %626 = load i32, ptr %625, align 4, !tbaa !8
  %627 = xor i32 %622, %626
  %628 = add i32 %627, %602
  %629 = and i32 %628, 255
  %630 = zext nneg i32 %629 to i64
  %631 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %630
  %632 = load i32, ptr %631, align 4, !tbaa !8
  %633 = lshr i32 %628, 8
  %634 = and i32 %633, 255
  %635 = zext nneg i32 %634 to i64
  %636 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %635
  %637 = load i32, ptr %636, align 4, !tbaa !8
  %638 = xor i32 %637, %632
  %639 = lshr i32 %628, 16
  %640 = and i32 %639, 255
  %641 = zext nneg i32 %640 to i64
  %642 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %641
  %643 = load i32, ptr %642, align 4, !tbaa !8
  %644 = xor i32 %638, %643
  %645 = lshr i32 %628, 24
  %646 = zext nneg i32 %645 to i64
  %647 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %646
  %648 = load i32, ptr %647, align 4, !tbaa !8
  %649 = xor i32 %644, %648
  %650 = add i32 %649, %627
  %651 = and i32 %650, 255
  %652 = zext nneg i32 %651 to i64
  %653 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %652
  %654 = load i32, ptr %653, align 4, !tbaa !8
  %655 = lshr i32 %650, 8
  %656 = and i32 %655, 255
  %657 = zext nneg i32 %656 to i64
  %658 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %657
  %659 = load i32, ptr %658, align 4, !tbaa !8
  %660 = xor i32 %659, %654
  %661 = lshr i32 %650, 16
  %662 = and i32 %661, 255
  %663 = zext nneg i32 %662 to i64
  %664 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %663
  %665 = load i32, ptr %664, align 4, !tbaa !8
  %666 = xor i32 %660, %665
  %667 = lshr i32 %650, 24
  %668 = zext nneg i32 %667 to i64
  %669 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %668
  %670 = load i32, ptr %669, align 4, !tbaa !8
  %671 = xor i32 %666, %670
  %672 = add i32 %671, %649
  %673 = xor i32 %672, %523
  %674 = xor i32 %671, %524
  %675 = getelementptr inbounds i8, ptr %2, i64 56
  %676 = load i32, ptr %675, align 4, !tbaa !8
  %677 = xor i32 %673, %676
  %678 = getelementptr inbounds i8, ptr %2, i64 60
  %679 = load i32, ptr %678, align 4, !tbaa !8
  %680 = xor i32 %674, %679
  %681 = xor i32 %680, %677
  %682 = and i32 %681, 255
  %683 = zext nneg i32 %682 to i64
  %684 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %683
  %685 = load i32, ptr %684, align 4, !tbaa !8
  %686 = lshr i32 %681, 8
  %687 = and i32 %686, 255
  %688 = zext nneg i32 %687 to i64
  %689 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %688
  %690 = load i32, ptr %689, align 4, !tbaa !8
  %691 = xor i32 %690, %685
  %692 = lshr i32 %681, 16
  %693 = and i32 %692, 255
  %694 = zext nneg i32 %693 to i64
  %695 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %694
  %696 = load i32, ptr %695, align 4, !tbaa !8
  %697 = xor i32 %691, %696
  %698 = lshr i32 %681, 24
  %699 = zext nneg i32 %698 to i64
  %700 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %699
  %701 = load i32, ptr %700, align 4, !tbaa !8
  %702 = xor i32 %697, %701
  %703 = add i32 %702, %677
  %704 = and i32 %703, 255
  %705 = zext nneg i32 %704 to i64
  %706 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %705
  %707 = load i32, ptr %706, align 4, !tbaa !8
  %708 = lshr i32 %703, 8
  %709 = and i32 %708, 255
  %710 = zext nneg i32 %709 to i64
  %711 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %710
  %712 = load i32, ptr %711, align 4, !tbaa !8
  %713 = xor i32 %712, %707
  %714 = lshr i32 %703, 16
  %715 = and i32 %714, 255
  %716 = zext nneg i32 %715 to i64
  %717 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %716
  %718 = load i32, ptr %717, align 4, !tbaa !8
  %719 = xor i32 %713, %718
  %720 = lshr i32 %703, 24
  %721 = zext nneg i32 %720 to i64
  %722 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %721
  %723 = load i32, ptr %722, align 4, !tbaa !8
  %724 = xor i32 %719, %723
  %725 = add i32 %724, %702
  %726 = and i32 %725, 255
  %727 = zext nneg i32 %726 to i64
  %728 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %727
  %729 = load i32, ptr %728, align 4, !tbaa !8
  %730 = lshr i32 %725, 8
  %731 = and i32 %730, 255
  %732 = zext nneg i32 %731 to i64
  %733 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %732
  %734 = load i32, ptr %733, align 4, !tbaa !8
  %735 = xor i32 %734, %729
  %736 = lshr i32 %725, 16
  %737 = and i32 %736, 255
  %738 = zext nneg i32 %737 to i64
  %739 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %738
  %740 = load i32, ptr %739, align 4, !tbaa !8
  %741 = xor i32 %735, %740
  %742 = lshr i32 %725, 24
  %743 = zext nneg i32 %742 to i64
  %744 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %743
  %745 = load i32, ptr %744, align 4, !tbaa !8
  %746 = xor i32 %741, %745
  %747 = add i32 %746, %724
  %748 = xor i32 %747, %598
  %749 = xor i32 %746, %599
  %750 = getelementptr inbounds i8, ptr %2, i64 48
  %751 = load i32, ptr %750, align 4, !tbaa !8
  %752 = xor i32 %748, %751
  %753 = getelementptr inbounds i8, ptr %2, i64 52
  %754 = load i32, ptr %753, align 4, !tbaa !8
  %755 = xor i32 %749, %754
  %756 = xor i32 %755, %752
  %757 = and i32 %756, 255
  %758 = zext nneg i32 %757 to i64
  %759 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %758
  %760 = load i32, ptr %759, align 4, !tbaa !8
  %761 = lshr i32 %756, 8
  %762 = and i32 %761, 255
  %763 = zext nneg i32 %762 to i64
  %764 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %763
  %765 = load i32, ptr %764, align 4, !tbaa !8
  %766 = xor i32 %765, %760
  %767 = lshr i32 %756, 16
  %768 = and i32 %767, 255
  %769 = zext nneg i32 %768 to i64
  %770 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %769
  %771 = load i32, ptr %770, align 4, !tbaa !8
  %772 = xor i32 %766, %771
  %773 = lshr i32 %756, 24
  %774 = zext nneg i32 %773 to i64
  %775 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %774
  %776 = load i32, ptr %775, align 4, !tbaa !8
  %777 = xor i32 %772, %776
  %778 = add i32 %777, %752
  %779 = and i32 %778, 255
  %780 = zext nneg i32 %779 to i64
  %781 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %780
  %782 = load i32, ptr %781, align 4, !tbaa !8
  %783 = lshr i32 %778, 8
  %784 = and i32 %783, 255
  %785 = zext nneg i32 %784 to i64
  %786 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %785
  %787 = load i32, ptr %786, align 4, !tbaa !8
  %788 = xor i32 %787, %782
  %789 = lshr i32 %778, 16
  %790 = and i32 %789, 255
  %791 = zext nneg i32 %790 to i64
  %792 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %791
  %793 = load i32, ptr %792, align 4, !tbaa !8
  %794 = xor i32 %788, %793
  %795 = lshr i32 %778, 24
  %796 = zext nneg i32 %795 to i64
  %797 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %796
  %798 = load i32, ptr %797, align 4, !tbaa !8
  %799 = xor i32 %794, %798
  %800 = add i32 %799, %777
  %801 = and i32 %800, 255
  %802 = zext nneg i32 %801 to i64
  %803 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %802
  %804 = load i32, ptr %803, align 4, !tbaa !8
  %805 = lshr i32 %800, 8
  %806 = and i32 %805, 255
  %807 = zext nneg i32 %806 to i64
  %808 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %807
  %809 = load i32, ptr %808, align 4, !tbaa !8
  %810 = xor i32 %809, %804
  %811 = lshr i32 %800, 16
  %812 = and i32 %811, 255
  %813 = zext nneg i32 %812 to i64
  %814 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %813
  %815 = load i32, ptr %814, align 4, !tbaa !8
  %816 = xor i32 %810, %815
  %817 = lshr i32 %800, 24
  %818 = zext nneg i32 %817 to i64
  %819 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %818
  %820 = load i32, ptr %819, align 4, !tbaa !8
  %821 = xor i32 %816, %820
  %822 = add i32 %821, %799
  %823 = xor i32 %822, %673
  %824 = xor i32 %821, %674
  %825 = getelementptr inbounds i8, ptr %2, i64 40
  %826 = load i32, ptr %825, align 4, !tbaa !8
  %827 = xor i32 %823, %826
  %828 = getelementptr inbounds i8, ptr %2, i64 44
  %829 = load i32, ptr %828, align 4, !tbaa !8
  %830 = xor i32 %824, %829
  %831 = xor i32 %830, %827
  %832 = and i32 %831, 255
  %833 = zext nneg i32 %832 to i64
  %834 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %833
  %835 = load i32, ptr %834, align 4, !tbaa !8
  %836 = lshr i32 %831, 8
  %837 = and i32 %836, 255
  %838 = zext nneg i32 %837 to i64
  %839 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %838
  %840 = load i32, ptr %839, align 4, !tbaa !8
  %841 = xor i32 %840, %835
  %842 = lshr i32 %831, 16
  %843 = and i32 %842, 255
  %844 = zext nneg i32 %843 to i64
  %845 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %844
  %846 = load i32, ptr %845, align 4, !tbaa !8
  %847 = xor i32 %841, %846
  %848 = lshr i32 %831, 24
  %849 = zext nneg i32 %848 to i64
  %850 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %849
  %851 = load i32, ptr %850, align 4, !tbaa !8
  %852 = xor i32 %847, %851
  %853 = add i32 %852, %827
  %854 = and i32 %853, 255
  %855 = zext nneg i32 %854 to i64
  %856 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %855
  %857 = load i32, ptr %856, align 4, !tbaa !8
  %858 = lshr i32 %853, 8
  %859 = and i32 %858, 255
  %860 = zext nneg i32 %859 to i64
  %861 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %860
  %862 = load i32, ptr %861, align 4, !tbaa !8
  %863 = xor i32 %862, %857
  %864 = lshr i32 %853, 16
  %865 = and i32 %864, 255
  %866 = zext nneg i32 %865 to i64
  %867 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %866
  %868 = load i32, ptr %867, align 4, !tbaa !8
  %869 = xor i32 %863, %868
  %870 = lshr i32 %853, 24
  %871 = zext nneg i32 %870 to i64
  %872 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %871
  %873 = load i32, ptr %872, align 4, !tbaa !8
  %874 = xor i32 %869, %873
  %875 = add i32 %874, %852
  %876 = and i32 %875, 255
  %877 = zext nneg i32 %876 to i64
  %878 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %877
  %879 = load i32, ptr %878, align 4, !tbaa !8
  %880 = lshr i32 %875, 8
  %881 = and i32 %880, 255
  %882 = zext nneg i32 %881 to i64
  %883 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %882
  %884 = load i32, ptr %883, align 4, !tbaa !8
  %885 = xor i32 %884, %879
  %886 = lshr i32 %875, 16
  %887 = and i32 %886, 255
  %888 = zext nneg i32 %887 to i64
  %889 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %888
  %890 = load i32, ptr %889, align 4, !tbaa !8
  %891 = xor i32 %885, %890
  %892 = lshr i32 %875, 24
  %893 = zext nneg i32 %892 to i64
  %894 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %893
  %895 = load i32, ptr %894, align 4, !tbaa !8
  %896 = xor i32 %891, %895
  %897 = add i32 %896, %874
  %898 = xor i32 %897, %748
  %899 = xor i32 %896, %749
  %900 = getelementptr inbounds i8, ptr %2, i64 32
  %901 = load i32, ptr %900, align 4, !tbaa !8
  %902 = xor i32 %898, %901
  %903 = getelementptr inbounds i8, ptr %2, i64 36
  %904 = load i32, ptr %903, align 4, !tbaa !8
  %905 = xor i32 %899, %904
  %906 = xor i32 %905, %902
  %907 = and i32 %906, 255
  %908 = zext nneg i32 %907 to i64
  %909 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %908
  %910 = load i32, ptr %909, align 4, !tbaa !8
  %911 = lshr i32 %906, 8
  %912 = and i32 %911, 255
  %913 = zext nneg i32 %912 to i64
  %914 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %913
  %915 = load i32, ptr %914, align 4, !tbaa !8
  %916 = xor i32 %915, %910
  %917 = lshr i32 %906, 16
  %918 = and i32 %917, 255
  %919 = zext nneg i32 %918 to i64
  %920 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %919
  %921 = load i32, ptr %920, align 4, !tbaa !8
  %922 = xor i32 %916, %921
  %923 = lshr i32 %906, 24
  %924 = zext nneg i32 %923 to i64
  %925 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %924
  %926 = load i32, ptr %925, align 4, !tbaa !8
  %927 = xor i32 %922, %926
  %928 = add i32 %927, %902
  %929 = and i32 %928, 255
  %930 = zext nneg i32 %929 to i64
  %931 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %930
  %932 = load i32, ptr %931, align 4, !tbaa !8
  %933 = lshr i32 %928, 8
  %934 = and i32 %933, 255
  %935 = zext nneg i32 %934 to i64
  %936 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %935
  %937 = load i32, ptr %936, align 4, !tbaa !8
  %938 = xor i32 %937, %932
  %939 = lshr i32 %928, 16
  %940 = and i32 %939, 255
  %941 = zext nneg i32 %940 to i64
  %942 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %941
  %943 = load i32, ptr %942, align 4, !tbaa !8
  %944 = xor i32 %938, %943
  %945 = lshr i32 %928, 24
  %946 = zext nneg i32 %945 to i64
  %947 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %946
  %948 = load i32, ptr %947, align 4, !tbaa !8
  %949 = xor i32 %944, %948
  %950 = add i32 %949, %927
  %951 = and i32 %950, 255
  %952 = zext nneg i32 %951 to i64
  %953 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %952
  %954 = load i32, ptr %953, align 4, !tbaa !8
  %955 = lshr i32 %950, 8
  %956 = and i32 %955, 255
  %957 = zext nneg i32 %956 to i64
  %958 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %957
  %959 = load i32, ptr %958, align 4, !tbaa !8
  %960 = xor i32 %959, %954
  %961 = lshr i32 %950, 16
  %962 = and i32 %961, 255
  %963 = zext nneg i32 %962 to i64
  %964 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %963
  %965 = load i32, ptr %964, align 4, !tbaa !8
  %966 = xor i32 %960, %965
  %967 = lshr i32 %950, 24
  %968 = zext nneg i32 %967 to i64
  %969 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %968
  %970 = load i32, ptr %969, align 4, !tbaa !8
  %971 = xor i32 %966, %970
  %972 = add i32 %971, %949
  %973 = xor i32 %972, %823
  %974 = xor i32 %971, %824
  %975 = getelementptr inbounds i8, ptr %2, i64 24
  %976 = load i32, ptr %975, align 4, !tbaa !8
  %977 = xor i32 %973, %976
  %978 = getelementptr inbounds i8, ptr %2, i64 28
  %979 = load i32, ptr %978, align 4, !tbaa !8
  %980 = xor i32 %974, %979
  %981 = xor i32 %980, %977
  %982 = and i32 %981, 255
  %983 = zext nneg i32 %982 to i64
  %984 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %983
  %985 = load i32, ptr %984, align 4, !tbaa !8
  %986 = lshr i32 %981, 8
  %987 = and i32 %986, 255
  %988 = zext nneg i32 %987 to i64
  %989 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %988
  %990 = load i32, ptr %989, align 4, !tbaa !8
  %991 = xor i32 %990, %985
  %992 = lshr i32 %981, 16
  %993 = and i32 %992, 255
  %994 = zext nneg i32 %993 to i64
  %995 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %994
  %996 = load i32, ptr %995, align 4, !tbaa !8
  %997 = xor i32 %991, %996
  %998 = lshr i32 %981, 24
  %999 = zext nneg i32 %998 to i64
  %1000 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %999
  %1001 = load i32, ptr %1000, align 4, !tbaa !8
  %1002 = xor i32 %997, %1001
  %1003 = add i32 %1002, %977
  %1004 = and i32 %1003, 255
  %1005 = zext nneg i32 %1004 to i64
  %1006 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1005
  %1007 = load i32, ptr %1006, align 4, !tbaa !8
  %1008 = lshr i32 %1003, 8
  %1009 = and i32 %1008, 255
  %1010 = zext nneg i32 %1009 to i64
  %1011 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %1010
  %1012 = load i32, ptr %1011, align 4, !tbaa !8
  %1013 = xor i32 %1012, %1007
  %1014 = lshr i32 %1003, 16
  %1015 = and i32 %1014, 255
  %1016 = zext nneg i32 %1015 to i64
  %1017 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %1016
  %1018 = load i32, ptr %1017, align 4, !tbaa !8
  %1019 = xor i32 %1013, %1018
  %1020 = lshr i32 %1003, 24
  %1021 = zext nneg i32 %1020 to i64
  %1022 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %1021
  %1023 = load i32, ptr %1022, align 4, !tbaa !8
  %1024 = xor i32 %1019, %1023
  %1025 = add i32 %1024, %1002
  %1026 = and i32 %1025, 255
  %1027 = zext nneg i32 %1026 to i64
  %1028 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1027
  %1029 = load i32, ptr %1028, align 4, !tbaa !8
  %1030 = lshr i32 %1025, 8
  %1031 = and i32 %1030, 255
  %1032 = zext nneg i32 %1031 to i64
  %1033 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %1032
  %1034 = load i32, ptr %1033, align 4, !tbaa !8
  %1035 = xor i32 %1034, %1029
  %1036 = lshr i32 %1025, 16
  %1037 = and i32 %1036, 255
  %1038 = zext nneg i32 %1037 to i64
  %1039 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %1038
  %1040 = load i32, ptr %1039, align 4, !tbaa !8
  %1041 = xor i32 %1035, %1040
  %1042 = lshr i32 %1025, 24
  %1043 = zext nneg i32 %1042 to i64
  %1044 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %1043
  %1045 = load i32, ptr %1044, align 4, !tbaa !8
  %1046 = xor i32 %1041, %1045
  %1047 = add i32 %1046, %1024
  %1048 = xor i32 %1047, %898
  %1049 = xor i32 %1046, %899
  %1050 = getelementptr inbounds i8, ptr %2, i64 16
  %1051 = load i32, ptr %1050, align 4, !tbaa !8
  %1052 = xor i32 %1048, %1051
  %1053 = getelementptr inbounds i8, ptr %2, i64 20
  %1054 = load i32, ptr %1053, align 4, !tbaa !8
  %1055 = xor i32 %1049, %1054
  %1056 = xor i32 %1055, %1052
  %1057 = and i32 %1056, 255
  %1058 = zext nneg i32 %1057 to i64
  %1059 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1058
  %1060 = load i32, ptr %1059, align 4, !tbaa !8
  %1061 = lshr i32 %1056, 8
  %1062 = and i32 %1061, 255
  %1063 = zext nneg i32 %1062 to i64
  %1064 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %1063
  %1065 = load i32, ptr %1064, align 4, !tbaa !8
  %1066 = xor i32 %1065, %1060
  %1067 = lshr i32 %1056, 16
  %1068 = and i32 %1067, 255
  %1069 = zext nneg i32 %1068 to i64
  %1070 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %1069
  %1071 = load i32, ptr %1070, align 4, !tbaa !8
  %1072 = xor i32 %1066, %1071
  %1073 = lshr i32 %1056, 24
  %1074 = zext nneg i32 %1073 to i64
  %1075 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %1074
  %1076 = load i32, ptr %1075, align 4, !tbaa !8
  %1077 = xor i32 %1072, %1076
  %1078 = add i32 %1077, %1052
  %1079 = and i32 %1078, 255
  %1080 = zext nneg i32 %1079 to i64
  %1081 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1080
  %1082 = load i32, ptr %1081, align 4, !tbaa !8
  %1083 = lshr i32 %1078, 8
  %1084 = and i32 %1083, 255
  %1085 = zext nneg i32 %1084 to i64
  %1086 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %1085
  %1087 = load i32, ptr %1086, align 4, !tbaa !8
  %1088 = xor i32 %1087, %1082
  %1089 = lshr i32 %1078, 16
  %1090 = and i32 %1089, 255
  %1091 = zext nneg i32 %1090 to i64
  %1092 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %1091
  %1093 = load i32, ptr %1092, align 4, !tbaa !8
  %1094 = xor i32 %1088, %1093
  %1095 = lshr i32 %1078, 24
  %1096 = zext nneg i32 %1095 to i64
  %1097 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %1096
  %1098 = load i32, ptr %1097, align 4, !tbaa !8
  %1099 = xor i32 %1094, %1098
  %1100 = add i32 %1099, %1077
  %1101 = and i32 %1100, 255
  %1102 = zext nneg i32 %1101 to i64
  %1103 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1102
  %1104 = load i32, ptr %1103, align 4, !tbaa !8
  %1105 = lshr i32 %1100, 8
  %1106 = and i32 %1105, 255
  %1107 = zext nneg i32 %1106 to i64
  %1108 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %1107
  %1109 = load i32, ptr %1108, align 4, !tbaa !8
  %1110 = xor i32 %1109, %1104
  %1111 = lshr i32 %1100, 16
  %1112 = and i32 %1111, 255
  %1113 = zext nneg i32 %1112 to i64
  %1114 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %1113
  %1115 = load i32, ptr %1114, align 4, !tbaa !8
  %1116 = xor i32 %1110, %1115
  %1117 = lshr i32 %1100, 24
  %1118 = zext nneg i32 %1117 to i64
  %1119 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %1118
  %1120 = load i32, ptr %1119, align 4, !tbaa !8
  %1121 = xor i32 %1116, %1120
  %1122 = add i32 %1121, %1099
  %1123 = xor i32 %1122, %973
  %1124 = xor i32 %1121, %974
  %1125 = getelementptr inbounds i8, ptr %2, i64 8
  %1126 = load i32, ptr %1125, align 4, !tbaa !8
  %1127 = xor i32 %1123, %1126
  %1128 = getelementptr inbounds i8, ptr %2, i64 12
  %1129 = load i32, ptr %1128, align 4, !tbaa !8
  %1130 = xor i32 %1124, %1129
  %1131 = xor i32 %1130, %1127
  %1132 = and i32 %1131, 255
  %1133 = zext nneg i32 %1132 to i64
  %1134 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1133
  %1135 = load i32, ptr %1134, align 4, !tbaa !8
  %1136 = lshr i32 %1131, 8
  %1137 = and i32 %1136, 255
  %1138 = zext nneg i32 %1137 to i64
  %1139 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %1138
  %1140 = load i32, ptr %1139, align 4, !tbaa !8
  %1141 = xor i32 %1140, %1135
  %1142 = lshr i32 %1131, 16
  %1143 = and i32 %1142, 255
  %1144 = zext nneg i32 %1143 to i64
  %1145 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %1144
  %1146 = load i32, ptr %1145, align 4, !tbaa !8
  %1147 = xor i32 %1141, %1146
  %1148 = lshr i32 %1131, 24
  %1149 = zext nneg i32 %1148 to i64
  %1150 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %1149
  %1151 = load i32, ptr %1150, align 4, !tbaa !8
  %1152 = xor i32 %1147, %1151
  %1153 = add i32 %1152, %1127
  %1154 = and i32 %1153, 255
  %1155 = zext nneg i32 %1154 to i64
  %1156 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1155
  %1157 = load i32, ptr %1156, align 4, !tbaa !8
  %1158 = lshr i32 %1153, 8
  %1159 = and i32 %1158, 255
  %1160 = zext nneg i32 %1159 to i64
  %1161 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %1160
  %1162 = load i32, ptr %1161, align 4, !tbaa !8
  %1163 = xor i32 %1162, %1157
  %1164 = lshr i32 %1153, 16
  %1165 = and i32 %1164, 255
  %1166 = zext nneg i32 %1165 to i64
  %1167 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %1166
  %1168 = load i32, ptr %1167, align 4, !tbaa !8
  %1169 = xor i32 %1163, %1168
  %1170 = lshr i32 %1153, 24
  %1171 = zext nneg i32 %1170 to i64
  %1172 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %1171
  %1173 = load i32, ptr %1172, align 4, !tbaa !8
  %1174 = xor i32 %1169, %1173
  %1175 = add i32 %1174, %1152
  %1176 = and i32 %1175, 255
  %1177 = zext nneg i32 %1176 to i64
  %1178 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1177
  %1179 = load i32, ptr %1178, align 4, !tbaa !8
  %1180 = lshr i32 %1175, 8
  %1181 = and i32 %1180, 255
  %1182 = zext nneg i32 %1181 to i64
  %1183 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %1182
  %1184 = load i32, ptr %1183, align 4, !tbaa !8
  %1185 = xor i32 %1184, %1179
  %1186 = lshr i32 %1175, 16
  %1187 = and i32 %1186, 255
  %1188 = zext nneg i32 %1187 to i64
  %1189 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %1188
  %1190 = load i32, ptr %1189, align 4, !tbaa !8
  %1191 = xor i32 %1185, %1190
  %1192 = lshr i32 %1175, 24
  %1193 = zext nneg i32 %1192 to i64
  %1194 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %1193
  %1195 = load i32, ptr %1194, align 4, !tbaa !8
  %1196 = xor i32 %1191, %1195
  %1197 = add i32 %1196, %1174
  %1198 = xor i32 %1197, %1048
  %1199 = xor i32 %1196, %1049
  %1200 = load i32, ptr %2, align 4, !tbaa !8
  %1201 = xor i32 %1198, %1200
  %1202 = getelementptr inbounds i8, ptr %2, i64 4
  %1203 = load i32, ptr %1202, align 4, !tbaa !8
  %1204 = xor i32 %1199, %1203
  %1205 = xor i32 %1204, %1201
  %1206 = and i32 %1205, 255
  %1207 = zext nneg i32 %1206 to i64
  %1208 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1207
  %1209 = load i32, ptr %1208, align 4, !tbaa !8
  %1210 = lshr i32 %1205, 8
  %1211 = and i32 %1210, 255
  %1212 = zext nneg i32 %1211 to i64
  %1213 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %1212
  %1214 = load i32, ptr %1213, align 4, !tbaa !8
  %1215 = xor i32 %1214, %1209
  %1216 = lshr i32 %1205, 16
  %1217 = and i32 %1216, 255
  %1218 = zext nneg i32 %1217 to i64
  %1219 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %1218
  %1220 = load i32, ptr %1219, align 4, !tbaa !8
  %1221 = xor i32 %1215, %1220
  %1222 = lshr i32 %1205, 24
  %1223 = zext nneg i32 %1222 to i64
  %1224 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %1223
  %1225 = load i32, ptr %1224, align 4, !tbaa !8
  %1226 = xor i32 %1221, %1225
  %1227 = add i32 %1226, %1201
  %1228 = and i32 %1227, 255
  %1229 = zext nneg i32 %1228 to i64
  %1230 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1229
  %1231 = load i32, ptr %1230, align 4, !tbaa !8
  %1232 = lshr i32 %1227, 8
  %1233 = and i32 %1232, 255
  %1234 = zext nneg i32 %1233 to i64
  %1235 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %1234
  %1236 = load i32, ptr %1235, align 4, !tbaa !8
  %1237 = xor i32 %1236, %1231
  %1238 = lshr i32 %1227, 16
  %1239 = and i32 %1238, 255
  %1240 = zext nneg i32 %1239 to i64
  %1241 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %1240
  %1242 = load i32, ptr %1241, align 4, !tbaa !8
  %1243 = xor i32 %1237, %1242
  %1244 = lshr i32 %1227, 24
  %1245 = zext nneg i32 %1244 to i64
  %1246 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %1245
  %1247 = load i32, ptr %1246, align 4, !tbaa !8
  %1248 = xor i32 %1243, %1247
  %1249 = add i32 %1248, %1226
  %1250 = and i32 %1249, 255
  %1251 = zext nneg i32 %1250 to i64
  %1252 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %1251
  %1253 = load i32, ptr %1252, align 4, !tbaa !8
  %1254 = lshr i32 %1249, 8
  %1255 = and i32 %1254, 255
  %1256 = zext nneg i32 %1255 to i64
  %1257 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %1256
  %1258 = load i32, ptr %1257, align 4, !tbaa !8
  %1259 = xor i32 %1258, %1253
  %1260 = lshr i32 %1249, 16
  %1261 = and i32 %1260, 255
  %1262 = zext nneg i32 %1261 to i64
  %1263 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %1262
  %1264 = load i32, ptr %1263, align 4, !tbaa !8
  %1265 = xor i32 %1259, %1264
  %1266 = lshr i32 %1249, 24
  %1267 = zext nneg i32 %1266 to i64
  %1268 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %1267
  %1269 = load i32, ptr %1268, align 4, !tbaa !8
  %1270 = xor i32 %1265, %1269
  %1271 = add i32 %1270, %1248
  %1272 = xor i32 %1271, %1123
  %1273 = xor i32 %1270, %1124
  %1274 = lshr i32 %1272, 24
  %1275 = trunc nuw i32 %1274 to i8
  store i8 %1275, ptr %1, align 1, !tbaa !5
  %1276 = lshr i32 %1272, 16
  %1277 = trunc i32 %1276 to i8
  %1278 = getelementptr inbounds i8, ptr %1, i64 1
  store i8 %1277, ptr %1278, align 1, !tbaa !5
  %1279 = lshr i32 %1272, 8
  %1280 = trunc i32 %1279 to i8
  %1281 = getelementptr inbounds i8, ptr %1, i64 2
  store i8 %1280, ptr %1281, align 1, !tbaa !5
  %1282 = trunc i32 %1272 to i8
  %1283 = getelementptr inbounds i8, ptr %1, i64 3
  store i8 %1282, ptr %1283, align 1, !tbaa !5
  %1284 = lshr i32 %1273, 24
  %1285 = trunc nuw i32 %1284 to i8
  %1286 = getelementptr inbounds i8, ptr %1, i64 4
  store i8 %1285, ptr %1286, align 1, !tbaa !5
  %1287 = lshr i32 %1273, 16
  %1288 = trunc i32 %1287 to i8
  %1289 = getelementptr inbounds i8, ptr %1, i64 5
  store i8 %1288, ptr %1289, align 1, !tbaa !5
  %1290 = lshr i32 %1273, 8
  %1291 = trunc i32 %1290 to i8
  %1292 = getelementptr inbounds i8, ptr %1, i64 6
  store i8 %1291, ptr %1292, align 1, !tbaa !5
  %1293 = trunc i32 %1273 to i8
  %1294 = getelementptr inbounds i8, ptr %1, i64 7
  store i8 %1293, ptr %1294, align 1, !tbaa !5
  %1295 = lshr i32 %1198, 24
  %1296 = trunc nuw i32 %1295 to i8
  %1297 = getelementptr inbounds i8, ptr %1, i64 8
  store i8 %1296, ptr %1297, align 1, !tbaa !5
  %1298 = lshr i32 %1198, 16
  %1299 = trunc i32 %1298 to i8
  %1300 = getelementptr inbounds i8, ptr %1, i64 9
  store i8 %1299, ptr %1300, align 1, !tbaa !5
  %1301 = lshr i32 %1198, 8
  %1302 = trunc i32 %1301 to i8
  %1303 = getelementptr inbounds i8, ptr %1, i64 10
  store i8 %1302, ptr %1303, align 1, !tbaa !5
  %1304 = trunc i32 %1198 to i8
  %1305 = getelementptr inbounds i8, ptr %1, i64 11
  store i8 %1304, ptr %1305, align 1, !tbaa !5
  %1306 = lshr i32 %1199, 24
  %1307 = trunc nuw i32 %1306 to i8
  %1308 = getelementptr inbounds i8, ptr %1, i64 12
  store i8 %1307, ptr %1308, align 1, !tbaa !5
  %1309 = lshr i32 %1199, 16
  %1310 = trunc i32 %1309 to i8
  %1311 = getelementptr inbounds i8, ptr %1, i64 13
  store i8 %1310, ptr %1311, align 1, !tbaa !5
  %1312 = lshr i32 %1199, 8
  %1313 = trunc i32 %1312 to i8
  %1314 = getelementptr inbounds i8, ptr %1, i64 14
  store i8 %1313, ptr %1314, align 1, !tbaa !5
  %1315 = trunc i32 %1199 to i8
  %1316 = getelementptr inbounds i8, ptr %1, i64 15
  store i8 %1315, ptr %1316, align 1, !tbaa !5
  ret void
}

attributes #0 = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) 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"}
!8 = !{!9, !9, i64 0}
!9 = !{!"int", !6, i64 0}


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