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

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

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

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!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_set_key(ptr nocapture noundef readonly %0, ptr nocapture noundef writeonly %1) local_unnamed_addr #0 {
  %3 = load i8, ptr %0, align 1, !tbaa !5
  %4 = zext i8 %3 to i32
  %5 = shl nuw i32 %4, 24
  %6 = getelementptr inbounds i8, ptr %0, i64 1
  %7 = load i8, ptr %6, align 1, !tbaa !5
  %8 = zext i8 %7 to i32
  %9 = shl nuw nsw i32 %8, 16
  %10 = or disjoint i32 %9, %5
  %11 = getelementptr inbounds i8, ptr %0, i64 2
  %12 = load i8, ptr %11, align 1, !tbaa !5
  %13 = zext i8 %12 to i32
  %14 = shl nuw nsw i32 %13, 8
  %15 = or disjoint i32 %10, %14
  %16 = getelementptr inbounds i8, ptr %0, i64 3
  %17 = load i8, ptr %16, align 1, !tbaa !5
  %18 = zext i8 %17 to i32
  %19 = or disjoint i32 %15, %18
  %20 = getelementptr inbounds i8, ptr %0, i64 4
  %21 = load i8, ptr %20, align 1, !tbaa !5
  %22 = zext i8 %21 to i32
  %23 = shl nuw i32 %22, 24
  %24 = getelementptr inbounds i8, ptr %0, i64 5
  %25 = load i8, ptr %24, align 1, !tbaa !5
  %26 = zext i8 %25 to i32
  %27 = shl nuw nsw i32 %26, 16
  %28 = or disjoint i32 %27, %23
  %29 = getelementptr inbounds i8, ptr %0, i64 6
  %30 = load i8, ptr %29, align 1, !tbaa !5
  %31 = zext i8 %30 to i32
  %32 = shl nuw nsw i32 %31, 8
  %33 = or disjoint i32 %28, %32
  %34 = getelementptr inbounds i8, ptr %0, i64 7
  %35 = load i8, ptr %34, align 1, !tbaa !5
  %36 = zext i8 %35 to i32
  %37 = or disjoint i32 %33, %36
  %38 = getelementptr inbounds i8, ptr %0, i64 8
  %39 = load i8, ptr %38, align 1, !tbaa !5
  %40 = zext i8 %39 to i32
  %41 = shl nuw i32 %40, 24
  %42 = getelementptr inbounds i8, ptr %0, i64 9
  %43 = load i8, ptr %42, align 1, !tbaa !5
  %44 = zext i8 %43 to i32
  %45 = shl nuw nsw i32 %44, 16
  %46 = getelementptr inbounds i8, ptr %0, i64 10
  %47 = load i8, ptr %46, align 1, !tbaa !5
  %48 = zext i8 %47 to i32
  %49 = shl nuw nsw i32 %48, 8
  %50 = getelementptr inbounds i8, ptr %0, i64 11
  %51 = load i8, ptr %50, align 1, !tbaa !5
  %52 = zext i8 %51 to i32
  %53 = or disjoint i32 %45, %41
  %54 = or disjoint i32 %53, %52
  %55 = or disjoint i32 %54, %49
  %56 = getelementptr inbounds i8, ptr %0, i64 12
  %57 = load i8, ptr %56, align 1, !tbaa !5
  %58 = zext i8 %57 to i32
  %59 = shl nuw i32 %58, 24
  %60 = getelementptr inbounds i8, ptr %0, i64 13
  %61 = load i8, ptr %60, align 1, !tbaa !5
  %62 = zext i8 %61 to i32
  %63 = shl nuw nsw i32 %62, 16
  %64 = getelementptr inbounds i8, ptr %0, i64 14
  %65 = load i8, ptr %64, align 1, !tbaa !5
  %66 = zext i8 %65 to i32
  %67 = shl nuw nsw i32 %66, 8
  %68 = getelementptr inbounds i8, ptr %0, i64 15
  %69 = load i8, ptr %68, align 1, !tbaa !5
  %70 = zext i8 %69 to i32
  %71 = or disjoint i32 %63, %59
  %72 = or disjoint i32 %71, %70
  %73 = or disjoint i32 %72, %67
  %74 = add i32 %19, 1640531527
  %75 = add i32 %74, %55
  %76 = sub i32 %37, %73
  %77 = add i32 %76, -1640531527
  %78 = and i32 %75, 255
  %79 = zext nneg i32 %78 to i64
  %80 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %79
  %81 = load i32, ptr %80, align 4, !tbaa !8
  %82 = lshr i32 %75, 8
  %83 = and i32 %82, 255
  %84 = zext nneg i32 %83 to i64
  %85 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %84
  %86 = load i32, ptr %85, align 4, !tbaa !8
  %87 = xor i32 %86, %81
  %88 = lshr i32 %75, 16
  %89 = and i32 %88, 255
  %90 = zext nneg i32 %89 to i64
  %91 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %90
  %92 = load i32, ptr %91, align 4, !tbaa !8
  %93 = xor i32 %87, %92
  %94 = lshr i32 %75, 24
  %95 = zext nneg i32 %94 to i64
  %96 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %95
  %97 = load i32, ptr %96, align 4, !tbaa !8
  %98 = xor i32 %93, %97
  store i32 %98, ptr %1, align 4, !tbaa !8
  %99 = and i32 %77, 255
  %100 = zext nneg i32 %99 to i64
  %101 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %100
  %102 = load i32, ptr %101, align 4, !tbaa !8
  %103 = lshr i32 %77, 8
  %104 = and i32 %103, 255
  %105 = zext nneg i32 %104 to i64
  %106 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %105
  %107 = load i32, ptr %106, align 4, !tbaa !8
  %108 = xor i32 %107, %102
  %109 = lshr i32 %77, 16
  %110 = and i32 %109, 255
  %111 = zext nneg i32 %110 to i64
  %112 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %111
  %113 = load i32, ptr %112, align 4, !tbaa !8
  %114 = xor i32 %108, %113
  %115 = lshr i32 %77, 24
  %116 = zext nneg i32 %115 to i64
  %117 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %116
  %118 = load i32, ptr %117, align 4, !tbaa !8
  %119 = xor i32 %114, %118
  %120 = getelementptr inbounds i8, ptr %1, i64 4
  store i32 %119, ptr %120, align 4, !tbaa !8
  %121 = tail call i32 @llvm.fshl.i32(i32 %36, i32 %15, i32 24)
  %122 = tail call i32 @llvm.fshl.i32(i32 %18, i32 %33, i32 24)
  %123 = add i32 %121, -1013904243
  %124 = add i32 %123, %55
  %125 = add i32 %122, 1013904243
  %126 = sub i32 %125, %73
  %127 = and i32 %124, 255
  %128 = zext nneg i32 %127 to i64
  %129 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %128
  %130 = load i32, ptr %129, align 4, !tbaa !8
  %131 = lshr i32 %124, 8
  %132 = and i32 %131, 255
  %133 = zext nneg i32 %132 to i64
  %134 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %133
  %135 = load i32, ptr %134, align 4, !tbaa !8
  %136 = xor i32 %135, %130
  %137 = lshr i32 %124, 16
  %138 = and i32 %137, 255
  %139 = zext nneg i32 %138 to i64
  %140 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %139
  %141 = load i32, ptr %140, align 4, !tbaa !8
  %142 = xor i32 %136, %141
  %143 = lshr i32 %124, 24
  %144 = zext nneg i32 %143 to i64
  %145 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %144
  %146 = load i32, ptr %145, align 4, !tbaa !8
  %147 = xor i32 %142, %146
  %148 = getelementptr inbounds i8, ptr %1, i64 8
  store i32 %147, ptr %148, align 4, !tbaa !8
  %149 = and i32 %126, 255
  %150 = zext nneg i32 %149 to i64
  %151 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %150
  %152 = load i32, ptr %151, align 4, !tbaa !8
  %153 = lshr i32 %126, 8
  %154 = and i32 %153, 255
  %155 = zext nneg i32 %154 to i64
  %156 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %155
  %157 = load i32, ptr %156, align 4, !tbaa !8
  %158 = xor i32 %157, %152
  %159 = lshr i32 %126, 16
  %160 = and i32 %159, 255
  %161 = zext nneg i32 %160 to i64
  %162 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %161
  %163 = load i32, ptr %162, align 4, !tbaa !8
  %164 = xor i32 %158, %163
  %165 = lshr i32 %126, 24
  %166 = zext nneg i32 %165 to i64
  %167 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %166
  %168 = load i32, ptr %167, align 4, !tbaa !8
  %169 = xor i32 %164, %168
  %170 = getelementptr inbounds i8, ptr %1, i64 12
  store i32 %169, ptr %170, align 4, !tbaa !8
  %171 = shl i32 %55, 8
  %172 = or disjoint i32 %171, %58
  %173 = shl i32 %73, 8
  %174 = or disjoint i32 %173, %40
  %175 = add i32 %121, -2027808486
  %176 = add i32 %175, %172
  %177 = add i32 %122, 2027808486
  %178 = sub i32 %177, %174
  %179 = and i32 %176, 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 %176, 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 %176, 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 %176, 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 = getelementptr inbounds i8, ptr %1, i64 16
  store i32 %199, ptr %200, align 4, !tbaa !8
  %201 = and i32 %178, 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 %178, 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 %178, 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 %178, 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 = getelementptr inbounds i8, ptr %1, i64 20
  store i32 %221, ptr %222, align 4, !tbaa !8
  %223 = tail call i32 @llvm.fshl.i32(i32 %122, i32 %121, i32 24)
  %224 = tail call i32 @llvm.fshl.i32(i32 %121, i32 %122, i32 24)
  %225 = add i32 %223, 239350324
  %226 = add i32 %225, %172
  %227 = add i32 %224, -239350324
  %228 = sub i32 %227, %174
  %229 = and i32 %226, 255
  %230 = zext nneg i32 %229 to i64
  %231 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %230
  %232 = load i32, ptr %231, align 4, !tbaa !8
  %233 = lshr i32 %226, 8
  %234 = and i32 %233, 255
  %235 = zext nneg i32 %234 to i64
  %236 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %235
  %237 = load i32, ptr %236, align 4, !tbaa !8
  %238 = xor i32 %237, %232
  %239 = lshr i32 %226, 16
  %240 = and i32 %239, 255
  %241 = zext nneg i32 %240 to i64
  %242 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %241
  %243 = load i32, ptr %242, align 4, !tbaa !8
  %244 = xor i32 %238, %243
  %245 = lshr i32 %226, 24
  %246 = zext nneg i32 %245 to i64
  %247 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %246
  %248 = load i32, ptr %247, align 4, !tbaa !8
  %249 = xor i32 %244, %248
  %250 = getelementptr inbounds i8, ptr %1, i64 24
  store i32 %249, ptr %250, align 4, !tbaa !8
  %251 = and i32 %228, 255
  %252 = zext nneg i32 %251 to i64
  %253 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %252
  %254 = load i32, ptr %253, align 4, !tbaa !8
  %255 = lshr i32 %228, 8
  %256 = and i32 %255, 255
  %257 = zext nneg i32 %256 to i64
  %258 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %257
  %259 = load i32, ptr %258, align 4, !tbaa !8
  %260 = xor i32 %259, %254
  %261 = lshr i32 %228, 16
  %262 = and i32 %261, 255
  %263 = zext nneg i32 %262 to i64
  %264 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %263
  %265 = load i32, ptr %264, align 4, !tbaa !8
  %266 = xor i32 %260, %265
  %267 = lshr i32 %228, 24
  %268 = zext nneg i32 %267 to i64
  %269 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %268
  %270 = load i32, ptr %269, align 4, !tbaa !8
  %271 = xor i32 %266, %270
  %272 = getelementptr inbounds i8, ptr %1, i64 28
  store i32 %271, ptr %272, align 4, !tbaa !8
  %273 = tail call i32 @llvm.fshl.i32(i32 %172, i32 %173, i32 8)
  %274 = tail call i32 @llvm.fshl.i32(i32 %174, i32 %171, i32 8)
  %275 = add i32 %223, 478700647
  %276 = add i32 %275, %273
  %277 = add i32 %224, -478700647
  %278 = sub i32 %277, %274
  %279 = and i32 %276, 255
  %280 = zext nneg i32 %279 to i64
  %281 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %280
  %282 = load i32, ptr %281, align 4, !tbaa !8
  %283 = lshr i32 %276, 8
  %284 = and i32 %283, 255
  %285 = zext nneg i32 %284 to i64
  %286 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %285
  %287 = load i32, ptr %286, align 4, !tbaa !8
  %288 = xor i32 %287, %282
  %289 = lshr i32 %276, 16
  %290 = and i32 %289, 255
  %291 = zext nneg i32 %290 to i64
  %292 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %291
  %293 = load i32, ptr %292, align 4, !tbaa !8
  %294 = xor i32 %288, %293
  %295 = lshr i32 %276, 24
  %296 = zext nneg i32 %295 to i64
  %297 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %296
  %298 = load i32, ptr %297, align 4, !tbaa !8
  %299 = xor i32 %294, %298
  %300 = getelementptr inbounds i8, ptr %1, i64 32
  store i32 %299, ptr %300, align 4, !tbaa !8
  %301 = and i32 %278, 255
  %302 = zext nneg i32 %301 to i64
  %303 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %302
  %304 = load i32, ptr %303, align 4, !tbaa !8
  %305 = lshr i32 %278, 8
  %306 = and i32 %305, 255
  %307 = zext nneg i32 %306 to i64
  %308 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %307
  %309 = load i32, ptr %308, align 4, !tbaa !8
  %310 = xor i32 %309, %304
  %311 = lshr i32 %278, 16
  %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 2048), i64 0, i64 %313
  %315 = load i32, ptr %314, align 4, !tbaa !8
  %316 = xor i32 %310, %315
  %317 = lshr i32 %278, 24
  %318 = zext nneg i32 %317 to i64
  %319 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %318
  %320 = load i32, ptr %319, align 4, !tbaa !8
  %321 = xor i32 %316, %320
  %322 = getelementptr inbounds i8, ptr %1, i64 36
  store i32 %321, ptr %322, align 4, !tbaa !8
  %323 = tail call i32 @llvm.fshl.i32(i32 %224, i32 %223, i32 24)
  %324 = tail call i32 @llvm.fshl.i32(i32 %223, i32 %224, i32 24)
  %325 = add i32 %323, 957401293
  %326 = add i32 %325, %273
  %327 = add i32 %324, -957401293
  %328 = sub i32 %327, %274
  %329 = and i32 %326, 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 %326, 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 %326, 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 %326, 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 = getelementptr inbounds i8, ptr %1, i64 40
  store i32 %349, ptr %350, align 4, !tbaa !8
  %351 = and i32 %328, 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 %328, 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 %328, 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 %328, 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 = getelementptr inbounds i8, ptr %1, i64 44
  store i32 %371, ptr %372, align 4, !tbaa !8
  %373 = tail call i32 @llvm.fshl.i32(i32 %273, i32 %274, i32 8)
  %374 = tail call i32 @llvm.fshl.i32(i32 %274, i32 %273, i32 8)
  %375 = add i32 %323, 1914802585
  %376 = add i32 %375, %373
  %377 = add i32 %324, -1914802585
  %378 = sub i32 %377, %374
  %379 = and i32 %376, 255
  %380 = zext nneg i32 %379 to i64
  %381 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %380
  %382 = load i32, ptr %381, align 4, !tbaa !8
  %383 = lshr i32 %376, 8
  %384 = and i32 %383, 255
  %385 = zext nneg i32 %384 to i64
  %386 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %385
  %387 = load i32, ptr %386, align 4, !tbaa !8
  %388 = xor i32 %387, %382
  %389 = lshr i32 %376, 16
  %390 = and i32 %389, 255
  %391 = zext nneg i32 %390 to i64
  %392 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %391
  %393 = load i32, ptr %392, align 4, !tbaa !8
  %394 = xor i32 %388, %393
  %395 = lshr i32 %376, 24
  %396 = zext nneg i32 %395 to i64
  %397 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %396
  %398 = load i32, ptr %397, align 4, !tbaa !8
  %399 = xor i32 %394, %398
  %400 = getelementptr inbounds i8, ptr %1, i64 48
  store i32 %399, ptr %400, align 4, !tbaa !8
  %401 = and i32 %378, 255
  %402 = zext nneg i32 %401 to i64
  %403 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %402
  %404 = load i32, ptr %403, align 4, !tbaa !8
  %405 = lshr i32 %378, 8
  %406 = and i32 %405, 255
  %407 = zext nneg i32 %406 to i64
  %408 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %407
  %409 = load i32, ptr %408, align 4, !tbaa !8
  %410 = xor i32 %409, %404
  %411 = lshr i32 %378, 16
  %412 = and i32 %411, 255
  %413 = zext nneg i32 %412 to i64
  %414 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %413
  %415 = load i32, ptr %414, align 4, !tbaa !8
  %416 = xor i32 %410, %415
  %417 = lshr i32 %378, 24
  %418 = zext nneg i32 %417 to i64
  %419 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %418
  %420 = load i32, ptr %419, align 4, !tbaa !8
  %421 = xor i32 %416, %420
  %422 = getelementptr inbounds i8, ptr %1, i64 52
  store i32 %421, ptr %422, align 4, !tbaa !8
  %423 = tail call i32 @llvm.fshl.i32(i32 %324, i32 %323, i32 24)
  %424 = tail call i32 @llvm.fshl.i32(i32 %323, i32 %324, i32 24)
  %425 = add i32 %423, -465362127
  %426 = add i32 %425, %373
  %427 = add i32 %424, 465362127
  %428 = sub i32 %427, %374
  %429 = and i32 %426, 255
  %430 = zext nneg i32 %429 to i64
  %431 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %430
  %432 = load i32, ptr %431, align 4, !tbaa !8
  %433 = lshr i32 %426, 8
  %434 = and i32 %433, 255
  %435 = zext nneg i32 %434 to i64
  %436 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %435
  %437 = load i32, ptr %436, align 4, !tbaa !8
  %438 = xor i32 %437, %432
  %439 = lshr i32 %426, 16
  %440 = and i32 %439, 255
  %441 = zext nneg i32 %440 to i64
  %442 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %441
  %443 = load i32, ptr %442, align 4, !tbaa !8
  %444 = xor i32 %438, %443
  %445 = lshr i32 %426, 24
  %446 = zext nneg i32 %445 to i64
  %447 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %446
  %448 = load i32, ptr %447, align 4, !tbaa !8
  %449 = xor i32 %444, %448
  %450 = getelementptr inbounds i8, ptr %1, i64 56
  store i32 %449, ptr %450, align 4, !tbaa !8
  %451 = and i32 %428, 255
  %452 = zext nneg i32 %451 to i64
  %453 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %452
  %454 = load i32, ptr %453, align 4, !tbaa !8
  %455 = lshr i32 %428, 8
  %456 = and i32 %455, 255
  %457 = zext nneg i32 %456 to i64
  %458 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %457
  %459 = load i32, ptr %458, align 4, !tbaa !8
  %460 = xor i32 %459, %454
  %461 = lshr i32 %428, 16
  %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 2048), i64 0, i64 %463
  %465 = load i32, ptr %464, align 4, !tbaa !8
  %466 = xor i32 %460, %465
  %467 = lshr i32 %428, 24
  %468 = zext nneg i32 %467 to i64
  %469 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %468
  %470 = load i32, ptr %469, align 4, !tbaa !8
  %471 = xor i32 %466, %470
  %472 = getelementptr inbounds i8, ptr %1, i64 60
  store i32 %471, ptr %472, align 4, !tbaa !8
  %473 = tail call i32 @llvm.fshl.i32(i32 %373, i32 %374, i32 8)
  %474 = tail call i32 @llvm.fshl.i32(i32 %374, i32 %373, i32 8)
  %475 = add i32 %423, -930724254
  %476 = add i32 %475, %473
  %477 = add i32 %424, 930724254
  %478 = sub i32 %477, %474
  %479 = and i32 %476, 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 %476, 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 %476, 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 %476, 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 = getelementptr inbounds i8, ptr %1, i64 64
  store i32 %499, ptr %500, align 4, !tbaa !8
  %501 = and i32 %478, 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 %478, 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 %478, 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 %478, 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 = getelementptr inbounds i8, ptr %1, i64 68
  store i32 %521, ptr %522, align 4, !tbaa !8
  %523 = tail call i32 @llvm.fshl.i32(i32 %424, i32 %423, i32 24)
  %524 = tail call i32 @llvm.fshl.i32(i32 %423, i32 %424, i32 24)
  %525 = add i32 %523, -1861448508
  %526 = add i32 %525, %473
  %527 = add i32 %524, 1861448508
  %528 = sub i32 %527, %474
  %529 = and i32 %526, 255
  %530 = zext nneg i32 %529 to i64
  %531 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %530
  %532 = load i32, ptr %531, align 4, !tbaa !8
  %533 = lshr i32 %526, 8
  %534 = and i32 %533, 255
  %535 = zext nneg i32 %534 to i64
  %536 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %535
  %537 = load i32, ptr %536, align 4, !tbaa !8
  %538 = xor i32 %537, %532
  %539 = lshr i32 %526, 16
  %540 = and i32 %539, 255
  %541 = zext nneg i32 %540 to i64
  %542 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %541
  %543 = load i32, ptr %542, align 4, !tbaa !8
  %544 = xor i32 %538, %543
  %545 = lshr i32 %526, 24
  %546 = zext nneg i32 %545 to i64
  %547 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %546
  %548 = load i32, ptr %547, align 4, !tbaa !8
  %549 = xor i32 %544, %548
  %550 = getelementptr inbounds i8, ptr %1, i64 72
  store i32 %549, ptr %550, align 4, !tbaa !8
  %551 = and i32 %528, 255
  %552 = zext nneg i32 %551 to i64
  %553 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %552
  %554 = load i32, ptr %553, align 4, !tbaa !8
  %555 = lshr i32 %528, 8
  %556 = and i32 %555, 255
  %557 = zext nneg i32 %556 to i64
  %558 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %557
  %559 = load i32, ptr %558, align 4, !tbaa !8
  %560 = xor i32 %559, %554
  %561 = lshr i32 %528, 16
  %562 = and i32 %561, 255
  %563 = zext nneg i32 %562 to i64
  %564 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %563
  %565 = load i32, ptr %564, align 4, !tbaa !8
  %566 = xor i32 %560, %565
  %567 = lshr i32 %528, 24
  %568 = zext nneg i32 %567 to i64
  %569 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %568
  %570 = load i32, ptr %569, align 4, !tbaa !8
  %571 = xor i32 %566, %570
  %572 = getelementptr inbounds i8, ptr %1, i64 76
  store i32 %571, ptr %572, align 4, !tbaa !8
  %573 = tail call i32 @llvm.fshl.i32(i32 %473, i32 %474, i32 8)
  %574 = tail call i32 @llvm.fshl.i32(i32 %474, i32 %473, i32 8)
  %575 = add i32 %523, 572070280
  %576 = add i32 %575, %573
  %577 = add i32 %524, -572070280
  %578 = sub i32 %577, %574
  %579 = and i32 %576, 255
  %580 = zext nneg i32 %579 to i64
  %581 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %580
  %582 = load i32, ptr %581, align 4, !tbaa !8
  %583 = lshr i32 %576, 8
  %584 = and i32 %583, 255
  %585 = zext nneg i32 %584 to i64
  %586 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %585
  %587 = load i32, ptr %586, align 4, !tbaa !8
  %588 = xor i32 %587, %582
  %589 = lshr i32 %576, 16
  %590 = and i32 %589, 255
  %591 = zext nneg i32 %590 to i64
  %592 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %591
  %593 = load i32, ptr %592, align 4, !tbaa !8
  %594 = xor i32 %588, %593
  %595 = lshr i32 %576, 24
  %596 = zext nneg i32 %595 to i64
  %597 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %596
  %598 = load i32, ptr %597, align 4, !tbaa !8
  %599 = xor i32 %594, %598
  %600 = getelementptr inbounds i8, ptr %1, i64 80
  store i32 %599, ptr %600, align 4, !tbaa !8
  %601 = and i32 %578, 255
  %602 = zext nneg i32 %601 to i64
  %603 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %602
  %604 = load i32, ptr %603, align 4, !tbaa !8
  %605 = lshr i32 %578, 8
  %606 = and i32 %605, 255
  %607 = zext nneg i32 %606 to i64
  %608 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %607
  %609 = load i32, ptr %608, align 4, !tbaa !8
  %610 = xor i32 %609, %604
  %611 = lshr i32 %578, 16
  %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 2048), i64 0, i64 %613
  %615 = load i32, ptr %614, align 4, !tbaa !8
  %616 = xor i32 %610, %615
  %617 = lshr i32 %578, 24
  %618 = zext nneg i32 %617 to i64
  %619 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %618
  %620 = load i32, ptr %619, align 4, !tbaa !8
  %621 = xor i32 %616, %620
  %622 = getelementptr inbounds i8, ptr %1, i64 84
  store i32 %621, ptr %622, align 4, !tbaa !8
  %623 = tail call i32 @llvm.fshl.i32(i32 %524, i32 %523, i32 24)
  %624 = tail call i32 @llvm.fshl.i32(i32 %523, i32 %524, i32 24)
  %625 = add i32 %623, 1144140559
  %626 = add i32 %625, %573
  %627 = add i32 %624, -1144140559
  %628 = sub i32 %627, %574
  %629 = and i32 %626, 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 %626, 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 %626, 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 %626, 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 = getelementptr inbounds i8, ptr %1, i64 88
  store i32 %649, ptr %650, align 4, !tbaa !8
  %651 = and i32 %628, 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 %628, 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 %628, 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 %628, 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 = getelementptr inbounds i8, ptr %1, i64 92
  store i32 %671, ptr %672, align 4, !tbaa !8
  %673 = tail call i32 @llvm.fshl.i32(i32 %573, i32 %574, i32 8)
  %674 = tail call i32 @llvm.fshl.i32(i32 %574, i32 %573, i32 8)
  %675 = add i32 %623, -2006686179
  %676 = add i32 %675, %673
  %677 = add i32 %624, 2006686179
  %678 = sub i32 %677, %674
  %679 = and i32 %676, 255
  %680 = zext nneg i32 %679 to i64
  %681 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %680
  %682 = load i32, ptr %681, align 4, !tbaa !8
  %683 = lshr i32 %676, 8
  %684 = and i32 %683, 255
  %685 = zext nneg i32 %684 to i64
  %686 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %685
  %687 = load i32, ptr %686, align 4, !tbaa !8
  %688 = xor i32 %687, %682
  %689 = lshr i32 %676, 16
  %690 = and i32 %689, 255
  %691 = zext nneg i32 %690 to i64
  %692 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %691
  %693 = load i32, ptr %692, align 4, !tbaa !8
  %694 = xor i32 %688, %693
  %695 = lshr i32 %676, 24
  %696 = zext nneg i32 %695 to i64
  %697 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %696
  %698 = load i32, ptr %697, align 4, !tbaa !8
  %699 = xor i32 %694, %698
  %700 = getelementptr inbounds i8, ptr %1, i64 96
  store i32 %699, ptr %700, align 4, !tbaa !8
  %701 = and i32 %678, 255
  %702 = zext nneg i32 %701 to i64
  %703 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %702
  %704 = load i32, ptr %703, align 4, !tbaa !8
  %705 = lshr i32 %678, 8
  %706 = and i32 %705, 255
  %707 = zext nneg i32 %706 to i64
  %708 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %707
  %709 = load i32, ptr %708, align 4, !tbaa !8
  %710 = xor i32 %709, %704
  %711 = lshr i32 %678, 16
  %712 = and i32 %711, 255
  %713 = zext nneg i32 %712 to i64
  %714 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %713
  %715 = load i32, ptr %714, align 4, !tbaa !8
  %716 = xor i32 %710, %715
  %717 = lshr i32 %678, 24
  %718 = zext nneg i32 %717 to i64
  %719 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %718
  %720 = load i32, ptr %719, align 4, !tbaa !8
  %721 = xor i32 %716, %720
  %722 = getelementptr inbounds i8, ptr %1, i64 100
  store i32 %721, ptr %722, align 4, !tbaa !8
  %723 = tail call i32 @llvm.fshl.i32(i32 %624, i32 %623, i32 24)
  %724 = tail call i32 @llvm.fshl.i32(i32 %623, i32 %624, i32 24)
  %725 = add i32 %723, 281594938
  %726 = add i32 %725, %673
  %727 = add i32 %724, -281594938
  %728 = sub i32 %727, %674
  %729 = and i32 %726, 255
  %730 = zext nneg i32 %729 to i64
  %731 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %730
  %732 = load i32, ptr %731, align 4, !tbaa !8
  %733 = lshr i32 %726, 8
  %734 = and i32 %733, 255
  %735 = zext nneg i32 %734 to i64
  %736 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %735
  %737 = load i32, ptr %736, align 4, !tbaa !8
  %738 = xor i32 %737, %732
  %739 = lshr i32 %726, 16
  %740 = and i32 %739, 255
  %741 = zext nneg i32 %740 to i64
  %742 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %741
  %743 = load i32, ptr %742, align 4, !tbaa !8
  %744 = xor i32 %738, %743
  %745 = lshr i32 %726, 24
  %746 = zext nneg i32 %745 to i64
  %747 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %746
  %748 = load i32, ptr %747, align 4, !tbaa !8
  %749 = xor i32 %744, %748
  %750 = getelementptr inbounds i8, ptr %1, i64 104
  store i32 %749, ptr %750, align 4, !tbaa !8
  %751 = and i32 %728, 255
  %752 = zext nneg i32 %751 to i64
  %753 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %752
  %754 = load i32, ptr %753, align 4, !tbaa !8
  %755 = lshr i32 %728, 8
  %756 = and i32 %755, 255
  %757 = zext nneg i32 %756 to i64
  %758 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %757
  %759 = load i32, ptr %758, align 4, !tbaa !8
  %760 = xor i32 %759, %754
  %761 = lshr i32 %728, 16
  %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 2048), i64 0, i64 %763
  %765 = load i32, ptr %764, align 4, !tbaa !8
  %766 = xor i32 %760, %765
  %767 = lshr i32 %728, 24
  %768 = zext nneg i32 %767 to i64
  %769 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %768
  %770 = load i32, ptr %769, align 4, !tbaa !8
  %771 = xor i32 %766, %770
  %772 = getelementptr inbounds i8, ptr %1, i64 108
  store i32 %771, ptr %772, align 4, !tbaa !8
  %773 = tail call i32 @llvm.fshl.i32(i32 %673, i32 %674, i32 8)
  %774 = tail call i32 @llvm.fshl.i32(i32 %674, i32 %673, i32 8)
  %775 = add i32 %723, 563189875
  %776 = add i32 %775, %773
  %777 = add i32 %724, -563189875
  %778 = sub i32 %777, %774
  %779 = and i32 %776, 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 %776, 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 %776, 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 %776, 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 = getelementptr inbounds i8, ptr %1, i64 112
  store i32 %799, ptr %800, align 4, !tbaa !8
  %801 = and i32 %778, 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 %778, 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 %778, 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 %778, 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 = getelementptr inbounds i8, ptr %1, i64 116
  store i32 %821, ptr %822, align 4, !tbaa !8
  %823 = tail call i32 @llvm.fshl.i32(i32 %724, i32 %723, i32 24)
  %824 = tail call i32 @llvm.fshl.i32(i32 %723, i32 %724, i32 24)
  %825 = add i32 %823, 1126379749
  %826 = add i32 %825, %773
  %827 = add i32 %824, -1126379749
  %828 = sub i32 %827, %774
  %829 = and i32 %826, 255
  %830 = zext nneg i32 %829 to i64
  %831 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %830
  %832 = load i32, ptr %831, align 4, !tbaa !8
  %833 = lshr i32 %826, 8
  %834 = and i32 %833, 255
  %835 = zext nneg i32 %834 to i64
  %836 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %835
  %837 = load i32, ptr %836, align 4, !tbaa !8
  %838 = xor i32 %837, %832
  %839 = lshr i32 %826, 16
  %840 = and i32 %839, 255
  %841 = zext nneg i32 %840 to i64
  %842 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %841
  %843 = load i32, ptr %842, align 4, !tbaa !8
  %844 = xor i32 %838, %843
  %845 = lshr i32 %826, 24
  %846 = zext nneg i32 %845 to i64
  %847 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %846
  %848 = load i32, ptr %847, align 4, !tbaa !8
  %849 = xor i32 %844, %848
  %850 = getelementptr inbounds i8, ptr %1, i64 120
  store i32 %849, ptr %850, align 4, !tbaa !8
  %851 = and i32 %828, 255
  %852 = zext nneg i32 %851 to i64
  %853 = getelementptr inbounds [256 x i32], ptr @SS, i64 0, i64 %852
  %854 = load i32, ptr %853, align 4, !tbaa !8
  %855 = lshr i32 %828, 8
  %856 = and i32 %855, 255
  %857 = zext nneg i32 %856 to i64
  %858 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 1024), i64 0, i64 %857
  %859 = load i32, ptr %858, align 4, !tbaa !8
  %860 = xor i32 %859, %854
  %861 = lshr i32 %828, 16
  %862 = and i32 %861, 255
  %863 = zext nneg i32 %862 to i64
  %864 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 2048), i64 0, i64 %863
  %865 = load i32, ptr %864, align 4, !tbaa !8
  %866 = xor i32 %860, %865
  %867 = lshr i32 %828, 24
  %868 = zext nneg i32 %867 to i64
  %869 = getelementptr inbounds [256 x i32], ptr getelementptr inbounds (i8, ptr @SS, i64 3072), i64 0, i64 %868
  %870 = load i32, ptr %869, align 4, !tbaa !8
  %871 = xor i32 %866, %870
  %872 = getelementptr inbounds i8, ptr %1, i64 124
  store i32 %871, ptr %872, align 4, !tbaa !8
  ret void
}

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.fshl.i32(i32, i32, i32) #1

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" }
attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }

!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,TailCallElimPass