; LLVM IR from CactiLab/Sherloc-Cortex-M-CFVD :: Sherloc_runtime/evaluation/src/rijndael (aes)

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

%struct.aes = type { i64, i64, [64 x i64], [64 x i64], i8 }

@it_tab = external dso_local constant [256 x i64], align 16
@il_tab = external dso_local constant [256 x i64], align 16

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

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

; Function Attrs: nounwind uwtable
define dso_local signext i16 @decrypt(ptr noundef %0, ptr noundef %1, ptr noundef %2) #1 {
  %4 = alloca i16, align 2
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca ptr, align 8
  %8 = alloca [4 x i64], align 16
  %9 = alloca [4 x i64], align 16
  %10 = alloca ptr, align 8
  %11 = alloca i32, align 4
  store ptr %0, ptr %5, align 8, !tbaa !5
  store ptr %1, ptr %6, align 8, !tbaa !5
  store ptr %2, ptr %7, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 32, ptr %8) #2
  call void @llvm.lifetime.start.p0(i64 32, ptr %9) #2
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #2
  %12 = load ptr, ptr %7, align 8, !tbaa !5
  %13 = getelementptr inbounds %struct.aes, ptr %12, i32 0, i32 3
  %14 = getelementptr inbounds [64 x i64], ptr %13, i64 0, i64 0
  store ptr %14, ptr %10, align 8, !tbaa !5
  %15 = load ptr, ptr %7, align 8, !tbaa !5
  %16 = getelementptr inbounds %struct.aes, ptr %15, i32 0, i32 4
  %17 = load i8, ptr %16, align 8, !tbaa !9
  %18 = zext i8 %17 to i32
  %19 = and i32 %18, 2
  %20 = icmp ne i32 %19, 0
  br i1 %20, label %22, label %21

21:                                               ; preds = %3
  store i16 0, ptr %4, align 2
  store i32 1, ptr %11, align 4
  br label %3716

22:                                               ; preds = %3
  %23 = load ptr, ptr %5, align 8, !tbaa !5
  %24 = getelementptr inbounds i8, ptr %23, i64 0
  %25 = load i64, ptr %24, align 8, !tbaa !12
  %26 = load ptr, ptr %10, align 8, !tbaa !5
  %27 = getelementptr inbounds i64, ptr %26, i64 0
  %28 = load i64, ptr %27, align 8, !tbaa !12
  %29 = xor i64 %25, %28
  %30 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  store i64 %29, ptr %30, align 16, !tbaa !12
  %31 = load ptr, ptr %5, align 8, !tbaa !5
  %32 = getelementptr inbounds i8, ptr %31, i64 4
  %33 = load i64, ptr %32, align 8, !tbaa !12
  %34 = load ptr, ptr %10, align 8, !tbaa !5
  %35 = getelementptr inbounds i64, ptr %34, i64 1
  %36 = load i64, ptr %35, align 8, !tbaa !12
  %37 = xor i64 %33, %36
  %38 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  store i64 %37, ptr %38, align 8, !tbaa !12
  %39 = load ptr, ptr %5, align 8, !tbaa !5
  %40 = getelementptr inbounds i8, ptr %39, i64 8
  %41 = load i64, ptr %40, align 8, !tbaa !12
  %42 = load ptr, ptr %10, align 8, !tbaa !5
  %43 = getelementptr inbounds i64, ptr %42, i64 2
  %44 = load i64, ptr %43, align 8, !tbaa !12
  %45 = xor i64 %41, %44
  %46 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  store i64 %45, ptr %46, align 16, !tbaa !12
  %47 = load ptr, ptr %5, align 8, !tbaa !5
  %48 = getelementptr inbounds i8, ptr %47, i64 12
  %49 = load i64, ptr %48, align 8, !tbaa !12
  %50 = load ptr, ptr %10, align 8, !tbaa !5
  %51 = getelementptr inbounds i64, ptr %50, i64 3
  %52 = load i64, ptr %51, align 8, !tbaa !12
  %53 = xor i64 %49, %52
  %54 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  store i64 %53, ptr %54, align 8, !tbaa !12
  %55 = load ptr, ptr %10, align 8, !tbaa !5
  %56 = getelementptr inbounds i64, ptr %55, i64 4
  store ptr %56, ptr %10, align 8, !tbaa !5
  %57 = load ptr, ptr %7, align 8, !tbaa !5
  %58 = getelementptr inbounds %struct.aes, ptr %57, i32 0, i32 1
  %59 = load i64, ptr %58, align 8, !tbaa !13
  switch i64 %59, label %3699 [
    i64 14, label %60
    i64 12, label %595
    i64 10, label %1130
  ]

60:                                               ; preds = %22
  %61 = load ptr, ptr %10, align 8, !tbaa !5
  %62 = getelementptr inbounds i64, ptr %61, i64 0
  %63 = load i64, ptr %62, align 8, !tbaa !12
  %64 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %65 = load i64, ptr %64, align 16, !tbaa !12
  %66 = lshr i64 %65, 0
  %67 = trunc i64 %66 to i8
  %68 = zext i8 %67 to i64
  %69 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %68
  %70 = load i64, ptr %69, align 8, !tbaa !12
  %71 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %72 = load i64, ptr %71, align 8, !tbaa !12
  %73 = lshr i64 %72, 8
  %74 = trunc i64 %73 to i8
  %75 = zext i8 %74 to i64
  %76 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %75
  %77 = load i64, ptr %76, align 8, !tbaa !12
  %78 = shl i64 %77, 8
  %79 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %80 = load i64, ptr %79, align 8, !tbaa !12
  %81 = lshr i64 %80, 8
  %82 = trunc i64 %81 to i8
  %83 = zext i8 %82 to i64
  %84 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %83
  %85 = load i64, ptr %84, align 8, !tbaa !12
  %86 = lshr i64 %85, 24
  %87 = or i64 %78, %86
  %88 = xor i64 %70, %87
  %89 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %90 = load i64, ptr %89, align 16, !tbaa !12
  %91 = lshr i64 %90, 16
  %92 = trunc i64 %91 to i8
  %93 = zext i8 %92 to i64
  %94 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %93
  %95 = load i64, ptr %94, align 8, !tbaa !12
  %96 = shl i64 %95, 16
  %97 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %98 = load i64, ptr %97, align 16, !tbaa !12
  %99 = lshr i64 %98, 16
  %100 = trunc i64 %99 to i8
  %101 = zext i8 %100 to i64
  %102 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %101
  %103 = load i64, ptr %102, align 8, !tbaa !12
  %104 = lshr i64 %103, 16
  %105 = or i64 %96, %104
  %106 = xor i64 %88, %105
  %107 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %108 = load i64, ptr %107, align 8, !tbaa !12
  %109 = lshr i64 %108, 24
  %110 = trunc i64 %109 to i8
  %111 = zext i8 %110 to i64
  %112 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %111
  %113 = load i64, ptr %112, align 8, !tbaa !12
  %114 = shl i64 %113, 24
  %115 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %116 = load i64, ptr %115, align 8, !tbaa !12
  %117 = lshr i64 %116, 24
  %118 = trunc i64 %117 to i8
  %119 = zext i8 %118 to i64
  %120 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %119
  %121 = load i64, ptr %120, align 8, !tbaa !12
  %122 = lshr i64 %121, 8
  %123 = or i64 %114, %122
  %124 = xor i64 %106, %123
  %125 = xor i64 %63, %124
  %126 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  store i64 %125, ptr %126, align 16, !tbaa !12
  %127 = load ptr, ptr %10, align 8, !tbaa !5
  %128 = getelementptr inbounds i64, ptr %127, i64 1
  %129 = load i64, ptr %128, align 8, !tbaa !12
  %130 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %131 = load i64, ptr %130, align 8, !tbaa !12
  %132 = lshr i64 %131, 0
  %133 = trunc i64 %132 to i8
  %134 = zext i8 %133 to i64
  %135 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %134
  %136 = load i64, ptr %135, align 8, !tbaa !12
  %137 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %138 = load i64, ptr %137, align 16, !tbaa !12
  %139 = lshr i64 %138, 8
  %140 = trunc i64 %139 to i8
  %141 = zext i8 %140 to i64
  %142 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %141
  %143 = load i64, ptr %142, align 8, !tbaa !12
  %144 = shl i64 %143, 8
  %145 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %146 = load i64, ptr %145, align 16, !tbaa !12
  %147 = lshr i64 %146, 8
  %148 = trunc i64 %147 to i8
  %149 = zext i8 %148 to i64
  %150 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %149
  %151 = load i64, ptr %150, align 8, !tbaa !12
  %152 = lshr i64 %151, 24
  %153 = or i64 %144, %152
  %154 = xor i64 %136, %153
  %155 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %156 = load i64, ptr %155, align 8, !tbaa !12
  %157 = lshr i64 %156, 16
  %158 = trunc i64 %157 to i8
  %159 = zext i8 %158 to i64
  %160 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %159
  %161 = load i64, ptr %160, align 8, !tbaa !12
  %162 = shl i64 %161, 16
  %163 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %164 = load i64, ptr %163, align 8, !tbaa !12
  %165 = lshr i64 %164, 16
  %166 = trunc i64 %165 to i8
  %167 = zext i8 %166 to i64
  %168 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %167
  %169 = load i64, ptr %168, align 8, !tbaa !12
  %170 = lshr i64 %169, 16
  %171 = or i64 %162, %170
  %172 = xor i64 %154, %171
  %173 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %174 = load i64, ptr %173, align 16, !tbaa !12
  %175 = lshr i64 %174, 24
  %176 = trunc i64 %175 to i8
  %177 = zext i8 %176 to i64
  %178 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %177
  %179 = load i64, ptr %178, align 8, !tbaa !12
  %180 = shl i64 %179, 24
  %181 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %182 = load i64, ptr %181, align 16, !tbaa !12
  %183 = lshr i64 %182, 24
  %184 = trunc i64 %183 to i8
  %185 = zext i8 %184 to i64
  %186 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %185
  %187 = load i64, ptr %186, align 8, !tbaa !12
  %188 = lshr i64 %187, 8
  %189 = or i64 %180, %188
  %190 = xor i64 %172, %189
  %191 = xor i64 %129, %190
  %192 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  store i64 %191, ptr %192, align 8, !tbaa !12
  %193 = load ptr, ptr %10, align 8, !tbaa !5
  %194 = getelementptr inbounds i64, ptr %193, i64 2
  %195 = load i64, ptr %194, align 8, !tbaa !12
  %196 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %197 = load i64, ptr %196, align 16, !tbaa !12
  %198 = lshr i64 %197, 0
  %199 = trunc i64 %198 to i8
  %200 = zext i8 %199 to i64
  %201 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %200
  %202 = load i64, ptr %201, align 8, !tbaa !12
  %203 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %204 = load i64, ptr %203, align 8, !tbaa !12
  %205 = lshr i64 %204, 8
  %206 = trunc i64 %205 to i8
  %207 = zext i8 %206 to i64
  %208 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %207
  %209 = load i64, ptr %208, align 8, !tbaa !12
  %210 = shl i64 %209, 8
  %211 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %212 = load i64, ptr %211, align 8, !tbaa !12
  %213 = lshr i64 %212, 8
  %214 = trunc i64 %213 to i8
  %215 = zext i8 %214 to i64
  %216 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %215
  %217 = load i64, ptr %216, align 8, !tbaa !12
  %218 = lshr i64 %217, 24
  %219 = or i64 %210, %218
  %220 = xor i64 %202, %219
  %221 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %222 = load i64, ptr %221, align 16, !tbaa !12
  %223 = lshr i64 %222, 16
  %224 = trunc i64 %223 to i8
  %225 = zext i8 %224 to i64
  %226 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %225
  %227 = load i64, ptr %226, align 8, !tbaa !12
  %228 = shl i64 %227, 16
  %229 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %230 = load i64, ptr %229, align 16, !tbaa !12
  %231 = lshr i64 %230, 16
  %232 = trunc i64 %231 to i8
  %233 = zext i8 %232 to i64
  %234 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %233
  %235 = load i64, ptr %234, align 8, !tbaa !12
  %236 = lshr i64 %235, 16
  %237 = or i64 %228, %236
  %238 = xor i64 %220, %237
  %239 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %240 = load i64, ptr %239, align 8, !tbaa !12
  %241 = lshr i64 %240, 24
  %242 = trunc i64 %241 to i8
  %243 = zext i8 %242 to i64
  %244 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %243
  %245 = load i64, ptr %244, align 8, !tbaa !12
  %246 = shl i64 %245, 24
  %247 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %248 = load i64, ptr %247, align 8, !tbaa !12
  %249 = lshr i64 %248, 24
  %250 = trunc i64 %249 to i8
  %251 = zext i8 %250 to i64
  %252 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %251
  %253 = load i64, ptr %252, align 8, !tbaa !12
  %254 = lshr i64 %253, 8
  %255 = or i64 %246, %254
  %256 = xor i64 %238, %255
  %257 = xor i64 %195, %256
  %258 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  store i64 %257, ptr %258, align 16, !tbaa !12
  %259 = load ptr, ptr %10, align 8, !tbaa !5
  %260 = getelementptr inbounds i64, ptr %259, i64 3
  %261 = load i64, ptr %260, align 8, !tbaa !12
  %262 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %263 = load i64, ptr %262, align 8, !tbaa !12
  %264 = lshr i64 %263, 0
  %265 = trunc i64 %264 to i8
  %266 = zext i8 %265 to i64
  %267 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %266
  %268 = load i64, ptr %267, align 8, !tbaa !12
  %269 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %270 = load i64, ptr %269, align 16, !tbaa !12
  %271 = lshr i64 %270, 8
  %272 = trunc i64 %271 to i8
  %273 = zext i8 %272 to i64
  %274 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %273
  %275 = load i64, ptr %274, align 8, !tbaa !12
  %276 = shl i64 %275, 8
  %277 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %278 = load i64, ptr %277, align 16, !tbaa !12
  %279 = lshr i64 %278, 8
  %280 = trunc i64 %279 to i8
  %281 = zext i8 %280 to i64
  %282 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %281
  %283 = load i64, ptr %282, align 8, !tbaa !12
  %284 = lshr i64 %283, 24
  %285 = or i64 %276, %284
  %286 = xor i64 %268, %285
  %287 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %288 = load i64, ptr %287, align 8, !tbaa !12
  %289 = lshr i64 %288, 16
  %290 = trunc i64 %289 to i8
  %291 = zext i8 %290 to i64
  %292 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %291
  %293 = load i64, ptr %292, align 8, !tbaa !12
  %294 = shl i64 %293, 16
  %295 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %296 = load i64, ptr %295, align 8, !tbaa !12
  %297 = lshr i64 %296, 16
  %298 = trunc i64 %297 to i8
  %299 = zext i8 %298 to i64
  %300 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %299
  %301 = load i64, ptr %300, align 8, !tbaa !12
  %302 = lshr i64 %301, 16
  %303 = or i64 %294, %302
  %304 = xor i64 %286, %303
  %305 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %306 = load i64, ptr %305, align 16, !tbaa !12
  %307 = lshr i64 %306, 24
  %308 = trunc i64 %307 to i8
  %309 = zext i8 %308 to i64
  %310 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %309
  %311 = load i64, ptr %310, align 8, !tbaa !12
  %312 = shl i64 %311, 24
  %313 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %314 = load i64, ptr %313, align 16, !tbaa !12
  %315 = lshr i64 %314, 24
  %316 = trunc i64 %315 to i8
  %317 = zext i8 %316 to i64
  %318 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %317
  %319 = load i64, ptr %318, align 8, !tbaa !12
  %320 = lshr i64 %319, 8
  %321 = or i64 %312, %320
  %322 = xor i64 %304, %321
  %323 = xor i64 %261, %322
  %324 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  store i64 %323, ptr %324, align 8, !tbaa !12
  %325 = load ptr, ptr %10, align 8, !tbaa !5
  %326 = getelementptr inbounds i64, ptr %325, i64 4
  %327 = getelementptr inbounds i64, ptr %326, i64 0
  %328 = load i64, ptr %327, align 8, !tbaa !12
  %329 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %330 = load i64, ptr %329, align 16, !tbaa !12
  %331 = lshr i64 %330, 0
  %332 = trunc i64 %331 to i8
  %333 = zext i8 %332 to i64
  %334 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %333
  %335 = load i64, ptr %334, align 8, !tbaa !12
  %336 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %337 = load i64, ptr %336, align 8, !tbaa !12
  %338 = lshr i64 %337, 8
  %339 = trunc i64 %338 to i8
  %340 = zext i8 %339 to i64
  %341 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %340
  %342 = load i64, ptr %341, align 8, !tbaa !12
  %343 = shl i64 %342, 8
  %344 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %345 = load i64, ptr %344, align 8, !tbaa !12
  %346 = lshr i64 %345, 8
  %347 = trunc i64 %346 to i8
  %348 = zext i8 %347 to i64
  %349 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %348
  %350 = load i64, ptr %349, align 8, !tbaa !12
  %351 = lshr i64 %350, 24
  %352 = or i64 %343, %351
  %353 = xor i64 %335, %352
  %354 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %355 = load i64, ptr %354, align 16, !tbaa !12
  %356 = lshr i64 %355, 16
  %357 = trunc i64 %356 to i8
  %358 = zext i8 %357 to i64
  %359 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %358
  %360 = load i64, ptr %359, align 8, !tbaa !12
  %361 = shl i64 %360, 16
  %362 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %363 = load i64, ptr %362, align 16, !tbaa !12
  %364 = lshr i64 %363, 16
  %365 = trunc i64 %364 to i8
  %366 = zext i8 %365 to i64
  %367 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %366
  %368 = load i64, ptr %367, align 8, !tbaa !12
  %369 = lshr i64 %368, 16
  %370 = or i64 %361, %369
  %371 = xor i64 %353, %370
  %372 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %373 = load i64, ptr %372, align 8, !tbaa !12
  %374 = lshr i64 %373, 24
  %375 = trunc i64 %374 to i8
  %376 = zext i8 %375 to i64
  %377 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %376
  %378 = load i64, ptr %377, align 8, !tbaa !12
  %379 = shl i64 %378, 24
  %380 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %381 = load i64, ptr %380, align 8, !tbaa !12
  %382 = lshr i64 %381, 24
  %383 = trunc i64 %382 to i8
  %384 = zext i8 %383 to i64
  %385 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %384
  %386 = load i64, ptr %385, align 8, !tbaa !12
  %387 = lshr i64 %386, 8
  %388 = or i64 %379, %387
  %389 = xor i64 %371, %388
  %390 = xor i64 %328, %389
  %391 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  store i64 %390, ptr %391, align 16, !tbaa !12
  %392 = load ptr, ptr %10, align 8, !tbaa !5
  %393 = getelementptr inbounds i64, ptr %392, i64 4
  %394 = getelementptr inbounds i64, ptr %393, i64 1
  %395 = load i64, ptr %394, align 8, !tbaa !12
  %396 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %397 = load i64, ptr %396, align 8, !tbaa !12
  %398 = lshr i64 %397, 0
  %399 = trunc i64 %398 to i8
  %400 = zext i8 %399 to i64
  %401 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %400
  %402 = load i64, ptr %401, align 8, !tbaa !12
  %403 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %404 = load i64, ptr %403, align 16, !tbaa !12
  %405 = lshr i64 %404, 8
  %406 = trunc i64 %405 to i8
  %407 = zext i8 %406 to i64
  %408 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %407
  %409 = load i64, ptr %408, align 8, !tbaa !12
  %410 = shl i64 %409, 8
  %411 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %412 = load i64, ptr %411, align 16, !tbaa !12
  %413 = lshr i64 %412, 8
  %414 = trunc i64 %413 to i8
  %415 = zext i8 %414 to i64
  %416 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %415
  %417 = load i64, ptr %416, align 8, !tbaa !12
  %418 = lshr i64 %417, 24
  %419 = or i64 %410, %418
  %420 = xor i64 %402, %419
  %421 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %422 = load i64, ptr %421, align 8, !tbaa !12
  %423 = lshr i64 %422, 16
  %424 = trunc i64 %423 to i8
  %425 = zext i8 %424 to i64
  %426 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %425
  %427 = load i64, ptr %426, align 8, !tbaa !12
  %428 = shl i64 %427, 16
  %429 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %430 = load i64, ptr %429, align 8, !tbaa !12
  %431 = lshr i64 %430, 16
  %432 = trunc i64 %431 to i8
  %433 = zext i8 %432 to i64
  %434 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %433
  %435 = load i64, ptr %434, align 8, !tbaa !12
  %436 = lshr i64 %435, 16
  %437 = or i64 %428, %436
  %438 = xor i64 %420, %437
  %439 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %440 = load i64, ptr %439, align 16, !tbaa !12
  %441 = lshr i64 %440, 24
  %442 = trunc i64 %441 to i8
  %443 = zext i8 %442 to i64
  %444 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %443
  %445 = load i64, ptr %444, align 8, !tbaa !12
  %446 = shl i64 %445, 24
  %447 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %448 = load i64, ptr %447, align 16, !tbaa !12
  %449 = lshr i64 %448, 24
  %450 = trunc i64 %449 to i8
  %451 = zext i8 %450 to i64
  %452 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %451
  %453 = load i64, ptr %452, align 8, !tbaa !12
  %454 = lshr i64 %453, 8
  %455 = or i64 %446, %454
  %456 = xor i64 %438, %455
  %457 = xor i64 %395, %456
  %458 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  store i64 %457, ptr %458, align 8, !tbaa !12
  %459 = load ptr, ptr %10, align 8, !tbaa !5
  %460 = getelementptr inbounds i64, ptr %459, i64 4
  %461 = getelementptr inbounds i64, ptr %460, i64 2
  %462 = load i64, ptr %461, align 8, !tbaa !12
  %463 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %464 = load i64, ptr %463, align 16, !tbaa !12
  %465 = lshr i64 %464, 0
  %466 = trunc i64 %465 to i8
  %467 = zext i8 %466 to i64
  %468 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %467
  %469 = load i64, ptr %468, align 8, !tbaa !12
  %470 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %471 = load i64, ptr %470, align 8, !tbaa !12
  %472 = lshr i64 %471, 8
  %473 = trunc i64 %472 to i8
  %474 = zext i8 %473 to i64
  %475 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %474
  %476 = load i64, ptr %475, align 8, !tbaa !12
  %477 = shl i64 %476, 8
  %478 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %479 = load i64, ptr %478, align 8, !tbaa !12
  %480 = lshr i64 %479, 8
  %481 = trunc i64 %480 to i8
  %482 = zext i8 %481 to i64
  %483 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %482
  %484 = load i64, ptr %483, align 8, !tbaa !12
  %485 = lshr i64 %484, 24
  %486 = or i64 %477, %485
  %487 = xor i64 %469, %486
  %488 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %489 = load i64, ptr %488, align 16, !tbaa !12
  %490 = lshr i64 %489, 16
  %491 = trunc i64 %490 to i8
  %492 = zext i8 %491 to i64
  %493 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %492
  %494 = load i64, ptr %493, align 8, !tbaa !12
  %495 = shl i64 %494, 16
  %496 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %497 = load i64, ptr %496, align 16, !tbaa !12
  %498 = lshr i64 %497, 16
  %499 = trunc i64 %498 to i8
  %500 = zext i8 %499 to i64
  %501 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %500
  %502 = load i64, ptr %501, align 8, !tbaa !12
  %503 = lshr i64 %502, 16
  %504 = or i64 %495, %503
  %505 = xor i64 %487, %504
  %506 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %507 = load i64, ptr %506, align 8, !tbaa !12
  %508 = lshr i64 %507, 24
  %509 = trunc i64 %508 to i8
  %510 = zext i8 %509 to i64
  %511 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %510
  %512 = load i64, ptr %511, align 8, !tbaa !12
  %513 = shl i64 %512, 24
  %514 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %515 = load i64, ptr %514, align 8, !tbaa !12
  %516 = lshr i64 %515, 24
  %517 = trunc i64 %516 to i8
  %518 = zext i8 %517 to i64
  %519 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %518
  %520 = load i64, ptr %519, align 8, !tbaa !12
  %521 = lshr i64 %520, 8
  %522 = or i64 %513, %521
  %523 = xor i64 %505, %522
  %524 = xor i64 %462, %523
  %525 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  store i64 %524, ptr %525, align 16, !tbaa !12
  %526 = load ptr, ptr %10, align 8, !tbaa !5
  %527 = getelementptr inbounds i64, ptr %526, i64 4
  %528 = getelementptr inbounds i64, ptr %527, i64 3
  %529 = load i64, ptr %528, align 8, !tbaa !12
  %530 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %531 = load i64, ptr %530, align 8, !tbaa !12
  %532 = lshr i64 %531, 0
  %533 = trunc i64 %532 to i8
  %534 = zext i8 %533 to i64
  %535 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %534
  %536 = load i64, ptr %535, align 8, !tbaa !12
  %537 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %538 = load i64, ptr %537, align 16, !tbaa !12
  %539 = lshr i64 %538, 8
  %540 = trunc i64 %539 to i8
  %541 = zext i8 %540 to i64
  %542 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %541
  %543 = load i64, ptr %542, align 8, !tbaa !12
  %544 = shl i64 %543, 8
  %545 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %546 = load i64, ptr %545, align 16, !tbaa !12
  %547 = lshr i64 %546, 8
  %548 = trunc i64 %547 to i8
  %549 = zext i8 %548 to i64
  %550 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %549
  %551 = load i64, ptr %550, align 8, !tbaa !12
  %552 = lshr i64 %551, 24
  %553 = or i64 %544, %552
  %554 = xor i64 %536, %553
  %555 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %556 = load i64, ptr %555, align 8, !tbaa !12
  %557 = lshr i64 %556, 16
  %558 = trunc i64 %557 to i8
  %559 = zext i8 %558 to i64
  %560 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %559
  %561 = load i64, ptr %560, align 8, !tbaa !12
  %562 = shl i64 %561, 16
  %563 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %564 = load i64, ptr %563, align 8, !tbaa !12
  %565 = lshr i64 %564, 16
  %566 = trunc i64 %565 to i8
  %567 = zext i8 %566 to i64
  %568 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %567
  %569 = load i64, ptr %568, align 8, !tbaa !12
  %570 = lshr i64 %569, 16
  %571 = or i64 %562, %570
  %572 = xor i64 %554, %571
  %573 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %574 = load i64, ptr %573, align 16, !tbaa !12
  %575 = lshr i64 %574, 24
  %576 = trunc i64 %575 to i8
  %577 = zext i8 %576 to i64
  %578 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %577
  %579 = load i64, ptr %578, align 8, !tbaa !12
  %580 = shl i64 %579, 24
  %581 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %582 = load i64, ptr %581, align 16, !tbaa !12
  %583 = lshr i64 %582, 24
  %584 = trunc i64 %583 to i8
  %585 = zext i8 %584 to i64
  %586 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %585
  %587 = load i64, ptr %586, align 8, !tbaa !12
  %588 = lshr i64 %587, 8
  %589 = or i64 %580, %588
  %590 = xor i64 %572, %589
  %591 = xor i64 %529, %590
  %592 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  store i64 %591, ptr %592, align 8, !tbaa !12
  %593 = load ptr, ptr %10, align 8, !tbaa !5
  %594 = getelementptr inbounds i64, ptr %593, i64 8
  store ptr %594, ptr %10, align 8, !tbaa !5
  br label %595

595:                                              ; preds = %60, %22
  %596 = load ptr, ptr %10, align 8, !tbaa !5
  %597 = getelementptr inbounds i64, ptr %596, i64 0
  %598 = load i64, ptr %597, align 8, !tbaa !12
  %599 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %600 = load i64, ptr %599, align 16, !tbaa !12
  %601 = lshr i64 %600, 0
  %602 = trunc i64 %601 to i8
  %603 = zext i8 %602 to i64
  %604 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %603
  %605 = load i64, ptr %604, align 8, !tbaa !12
  %606 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %607 = load i64, ptr %606, align 8, !tbaa !12
  %608 = lshr i64 %607, 8
  %609 = trunc i64 %608 to i8
  %610 = zext i8 %609 to i64
  %611 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %610
  %612 = load i64, ptr %611, align 8, !tbaa !12
  %613 = shl i64 %612, 8
  %614 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %615 = load i64, ptr %614, align 8, !tbaa !12
  %616 = lshr i64 %615, 8
  %617 = trunc i64 %616 to i8
  %618 = zext i8 %617 to i64
  %619 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %618
  %620 = load i64, ptr %619, align 8, !tbaa !12
  %621 = lshr i64 %620, 24
  %622 = or i64 %613, %621
  %623 = xor i64 %605, %622
  %624 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %625 = load i64, ptr %624, align 16, !tbaa !12
  %626 = lshr i64 %625, 16
  %627 = trunc i64 %626 to i8
  %628 = zext i8 %627 to i64
  %629 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %628
  %630 = load i64, ptr %629, align 8, !tbaa !12
  %631 = shl i64 %630, 16
  %632 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %633 = load i64, ptr %632, align 16, !tbaa !12
  %634 = lshr i64 %633, 16
  %635 = trunc i64 %634 to i8
  %636 = zext i8 %635 to i64
  %637 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %636
  %638 = load i64, ptr %637, align 8, !tbaa !12
  %639 = lshr i64 %638, 16
  %640 = or i64 %631, %639
  %641 = xor i64 %623, %640
  %642 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %643 = load i64, ptr %642, align 8, !tbaa !12
  %644 = lshr i64 %643, 24
  %645 = trunc i64 %644 to i8
  %646 = zext i8 %645 to i64
  %647 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %646
  %648 = load i64, ptr %647, align 8, !tbaa !12
  %649 = shl i64 %648, 24
  %650 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %651 = load i64, ptr %650, align 8, !tbaa !12
  %652 = lshr i64 %651, 24
  %653 = trunc i64 %652 to i8
  %654 = zext i8 %653 to i64
  %655 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %654
  %656 = load i64, ptr %655, align 8, !tbaa !12
  %657 = lshr i64 %656, 8
  %658 = or i64 %649, %657
  %659 = xor i64 %641, %658
  %660 = xor i64 %598, %659
  %661 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  store i64 %660, ptr %661, align 16, !tbaa !12
  %662 = load ptr, ptr %10, align 8, !tbaa !5
  %663 = getelementptr inbounds i64, ptr %662, i64 1
  %664 = load i64, ptr %663, align 8, !tbaa !12
  %665 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %666 = load i64, ptr %665, align 8, !tbaa !12
  %667 = lshr i64 %666, 0
  %668 = trunc i64 %667 to i8
  %669 = zext i8 %668 to i64
  %670 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %669
  %671 = load i64, ptr %670, align 8, !tbaa !12
  %672 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %673 = load i64, ptr %672, align 16, !tbaa !12
  %674 = lshr i64 %673, 8
  %675 = trunc i64 %674 to i8
  %676 = zext i8 %675 to i64
  %677 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %676
  %678 = load i64, ptr %677, align 8, !tbaa !12
  %679 = shl i64 %678, 8
  %680 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %681 = load i64, ptr %680, align 16, !tbaa !12
  %682 = lshr i64 %681, 8
  %683 = trunc i64 %682 to i8
  %684 = zext i8 %683 to i64
  %685 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %684
  %686 = load i64, ptr %685, align 8, !tbaa !12
  %687 = lshr i64 %686, 24
  %688 = or i64 %679, %687
  %689 = xor i64 %671, %688
  %690 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %691 = load i64, ptr %690, align 8, !tbaa !12
  %692 = lshr i64 %691, 16
  %693 = trunc i64 %692 to i8
  %694 = zext i8 %693 to i64
  %695 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %694
  %696 = load i64, ptr %695, align 8, !tbaa !12
  %697 = shl i64 %696, 16
  %698 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %699 = load i64, ptr %698, align 8, !tbaa !12
  %700 = lshr i64 %699, 16
  %701 = trunc i64 %700 to i8
  %702 = zext i8 %701 to i64
  %703 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %702
  %704 = load i64, ptr %703, align 8, !tbaa !12
  %705 = lshr i64 %704, 16
  %706 = or i64 %697, %705
  %707 = xor i64 %689, %706
  %708 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %709 = load i64, ptr %708, align 16, !tbaa !12
  %710 = lshr i64 %709, 24
  %711 = trunc i64 %710 to i8
  %712 = zext i8 %711 to i64
  %713 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %712
  %714 = load i64, ptr %713, align 8, !tbaa !12
  %715 = shl i64 %714, 24
  %716 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %717 = load i64, ptr %716, align 16, !tbaa !12
  %718 = lshr i64 %717, 24
  %719 = trunc i64 %718 to i8
  %720 = zext i8 %719 to i64
  %721 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %720
  %722 = load i64, ptr %721, align 8, !tbaa !12
  %723 = lshr i64 %722, 8
  %724 = or i64 %715, %723
  %725 = xor i64 %707, %724
  %726 = xor i64 %664, %725
  %727 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  store i64 %726, ptr %727, align 8, !tbaa !12
  %728 = load ptr, ptr %10, align 8, !tbaa !5
  %729 = getelementptr inbounds i64, ptr %728, i64 2
  %730 = load i64, ptr %729, align 8, !tbaa !12
  %731 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %732 = load i64, ptr %731, align 16, !tbaa !12
  %733 = lshr i64 %732, 0
  %734 = trunc i64 %733 to i8
  %735 = zext i8 %734 to i64
  %736 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %735
  %737 = load i64, ptr %736, align 8, !tbaa !12
  %738 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %739 = load i64, ptr %738, align 8, !tbaa !12
  %740 = lshr i64 %739, 8
  %741 = trunc i64 %740 to i8
  %742 = zext i8 %741 to i64
  %743 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %742
  %744 = load i64, ptr %743, align 8, !tbaa !12
  %745 = shl i64 %744, 8
  %746 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %747 = load i64, ptr %746, align 8, !tbaa !12
  %748 = lshr i64 %747, 8
  %749 = trunc i64 %748 to i8
  %750 = zext i8 %749 to i64
  %751 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %750
  %752 = load i64, ptr %751, align 8, !tbaa !12
  %753 = lshr i64 %752, 24
  %754 = or i64 %745, %753
  %755 = xor i64 %737, %754
  %756 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %757 = load i64, ptr %756, align 16, !tbaa !12
  %758 = lshr i64 %757, 16
  %759 = trunc i64 %758 to i8
  %760 = zext i8 %759 to i64
  %761 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %760
  %762 = load i64, ptr %761, align 8, !tbaa !12
  %763 = shl i64 %762, 16
  %764 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %765 = load i64, ptr %764, align 16, !tbaa !12
  %766 = lshr i64 %765, 16
  %767 = trunc i64 %766 to i8
  %768 = zext i8 %767 to i64
  %769 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %768
  %770 = load i64, ptr %769, align 8, !tbaa !12
  %771 = lshr i64 %770, 16
  %772 = or i64 %763, %771
  %773 = xor i64 %755, %772
  %774 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %775 = load i64, ptr %774, align 8, !tbaa !12
  %776 = lshr i64 %775, 24
  %777 = trunc i64 %776 to i8
  %778 = zext i8 %777 to i64
  %779 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %778
  %780 = load i64, ptr %779, align 8, !tbaa !12
  %781 = shl i64 %780, 24
  %782 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %783 = load i64, ptr %782, align 8, !tbaa !12
  %784 = lshr i64 %783, 24
  %785 = trunc i64 %784 to i8
  %786 = zext i8 %785 to i64
  %787 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %786
  %788 = load i64, ptr %787, align 8, !tbaa !12
  %789 = lshr i64 %788, 8
  %790 = or i64 %781, %789
  %791 = xor i64 %773, %790
  %792 = xor i64 %730, %791
  %793 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  store i64 %792, ptr %793, align 16, !tbaa !12
  %794 = load ptr, ptr %10, align 8, !tbaa !5
  %795 = getelementptr inbounds i64, ptr %794, i64 3
  %796 = load i64, ptr %795, align 8, !tbaa !12
  %797 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %798 = load i64, ptr %797, align 8, !tbaa !12
  %799 = lshr i64 %798, 0
  %800 = trunc i64 %799 to i8
  %801 = zext i8 %800 to i64
  %802 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %801
  %803 = load i64, ptr %802, align 8, !tbaa !12
  %804 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %805 = load i64, ptr %804, align 16, !tbaa !12
  %806 = lshr i64 %805, 8
  %807 = trunc i64 %806 to i8
  %808 = zext i8 %807 to i64
  %809 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %808
  %810 = load i64, ptr %809, align 8, !tbaa !12
  %811 = shl i64 %810, 8
  %812 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %813 = load i64, ptr %812, align 16, !tbaa !12
  %814 = lshr i64 %813, 8
  %815 = trunc i64 %814 to i8
  %816 = zext i8 %815 to i64
  %817 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %816
  %818 = load i64, ptr %817, align 8, !tbaa !12
  %819 = lshr i64 %818, 24
  %820 = or i64 %811, %819
  %821 = xor i64 %803, %820
  %822 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %823 = load i64, ptr %822, align 8, !tbaa !12
  %824 = lshr i64 %823, 16
  %825 = trunc i64 %824 to i8
  %826 = zext i8 %825 to i64
  %827 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %826
  %828 = load i64, ptr %827, align 8, !tbaa !12
  %829 = shl i64 %828, 16
  %830 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %831 = load i64, ptr %830, align 8, !tbaa !12
  %832 = lshr i64 %831, 16
  %833 = trunc i64 %832 to i8
  %834 = zext i8 %833 to i64
  %835 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %834
  %836 = load i64, ptr %835, align 8, !tbaa !12
  %837 = lshr i64 %836, 16
  %838 = or i64 %829, %837
  %839 = xor i64 %821, %838
  %840 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %841 = load i64, ptr %840, align 16, !tbaa !12
  %842 = lshr i64 %841, 24
  %843 = trunc i64 %842 to i8
  %844 = zext i8 %843 to i64
  %845 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %844
  %846 = load i64, ptr %845, align 8, !tbaa !12
  %847 = shl i64 %846, 24
  %848 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %849 = load i64, ptr %848, align 16, !tbaa !12
  %850 = lshr i64 %849, 24
  %851 = trunc i64 %850 to i8
  %852 = zext i8 %851 to i64
  %853 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %852
  %854 = load i64, ptr %853, align 8, !tbaa !12
  %855 = lshr i64 %854, 8
  %856 = or i64 %847, %855
  %857 = xor i64 %839, %856
  %858 = xor i64 %796, %857
  %859 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  store i64 %858, ptr %859, align 8, !tbaa !12
  %860 = load ptr, ptr %10, align 8, !tbaa !5
  %861 = getelementptr inbounds i64, ptr %860, i64 4
  %862 = getelementptr inbounds i64, ptr %861, i64 0
  %863 = load i64, ptr %862, align 8, !tbaa !12
  %864 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %865 = load i64, ptr %864, align 16, !tbaa !12
  %866 = lshr i64 %865, 0
  %867 = trunc i64 %866 to i8
  %868 = zext i8 %867 to i64
  %869 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %868
  %870 = load i64, ptr %869, align 8, !tbaa !12
  %871 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %872 = load i64, ptr %871, align 8, !tbaa !12
  %873 = lshr i64 %872, 8
  %874 = trunc i64 %873 to i8
  %875 = zext i8 %874 to i64
  %876 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %875
  %877 = load i64, ptr %876, align 8, !tbaa !12
  %878 = shl i64 %877, 8
  %879 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %880 = load i64, ptr %879, align 8, !tbaa !12
  %881 = lshr i64 %880, 8
  %882 = trunc i64 %881 to i8
  %883 = zext i8 %882 to i64
  %884 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %883
  %885 = load i64, ptr %884, align 8, !tbaa !12
  %886 = lshr i64 %885, 24
  %887 = or i64 %878, %886
  %888 = xor i64 %870, %887
  %889 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %890 = load i64, ptr %889, align 16, !tbaa !12
  %891 = lshr i64 %890, 16
  %892 = trunc i64 %891 to i8
  %893 = zext i8 %892 to i64
  %894 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %893
  %895 = load i64, ptr %894, align 8, !tbaa !12
  %896 = shl i64 %895, 16
  %897 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %898 = load i64, ptr %897, align 16, !tbaa !12
  %899 = lshr i64 %898, 16
  %900 = trunc i64 %899 to i8
  %901 = zext i8 %900 to i64
  %902 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %901
  %903 = load i64, ptr %902, align 8, !tbaa !12
  %904 = lshr i64 %903, 16
  %905 = or i64 %896, %904
  %906 = xor i64 %888, %905
  %907 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %908 = load i64, ptr %907, align 8, !tbaa !12
  %909 = lshr i64 %908, 24
  %910 = trunc i64 %909 to i8
  %911 = zext i8 %910 to i64
  %912 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %911
  %913 = load i64, ptr %912, align 8, !tbaa !12
  %914 = shl i64 %913, 24
  %915 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %916 = load i64, ptr %915, align 8, !tbaa !12
  %917 = lshr i64 %916, 24
  %918 = trunc i64 %917 to i8
  %919 = zext i8 %918 to i64
  %920 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %919
  %921 = load i64, ptr %920, align 8, !tbaa !12
  %922 = lshr i64 %921, 8
  %923 = or i64 %914, %922
  %924 = xor i64 %906, %923
  %925 = xor i64 %863, %924
  %926 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  store i64 %925, ptr %926, align 16, !tbaa !12
  %927 = load ptr, ptr %10, align 8, !tbaa !5
  %928 = getelementptr inbounds i64, ptr %927, i64 4
  %929 = getelementptr inbounds i64, ptr %928, i64 1
  %930 = load i64, ptr %929, align 8, !tbaa !12
  %931 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %932 = load i64, ptr %931, align 8, !tbaa !12
  %933 = lshr i64 %932, 0
  %934 = trunc i64 %933 to i8
  %935 = zext i8 %934 to i64
  %936 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %935
  %937 = load i64, ptr %936, align 8, !tbaa !12
  %938 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %939 = load i64, ptr %938, align 16, !tbaa !12
  %940 = lshr i64 %939, 8
  %941 = trunc i64 %940 to i8
  %942 = zext i8 %941 to i64
  %943 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %942
  %944 = load i64, ptr %943, align 8, !tbaa !12
  %945 = shl i64 %944, 8
  %946 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %947 = load i64, ptr %946, align 16, !tbaa !12
  %948 = lshr i64 %947, 8
  %949 = trunc i64 %948 to i8
  %950 = zext i8 %949 to i64
  %951 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %950
  %952 = load i64, ptr %951, align 8, !tbaa !12
  %953 = lshr i64 %952, 24
  %954 = or i64 %945, %953
  %955 = xor i64 %937, %954
  %956 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %957 = load i64, ptr %956, align 8, !tbaa !12
  %958 = lshr i64 %957, 16
  %959 = trunc i64 %958 to i8
  %960 = zext i8 %959 to i64
  %961 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %960
  %962 = load i64, ptr %961, align 8, !tbaa !12
  %963 = shl i64 %962, 16
  %964 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %965 = load i64, ptr %964, align 8, !tbaa !12
  %966 = lshr i64 %965, 16
  %967 = trunc i64 %966 to i8
  %968 = zext i8 %967 to i64
  %969 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %968
  %970 = load i64, ptr %969, align 8, !tbaa !12
  %971 = lshr i64 %970, 16
  %972 = or i64 %963, %971
  %973 = xor i64 %955, %972
  %974 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %975 = load i64, ptr %974, align 16, !tbaa !12
  %976 = lshr i64 %975, 24
  %977 = trunc i64 %976 to i8
  %978 = zext i8 %977 to i64
  %979 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %978
  %980 = load i64, ptr %979, align 8, !tbaa !12
  %981 = shl i64 %980, 24
  %982 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %983 = load i64, ptr %982, align 16, !tbaa !12
  %984 = lshr i64 %983, 24
  %985 = trunc i64 %984 to i8
  %986 = zext i8 %985 to i64
  %987 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %986
  %988 = load i64, ptr %987, align 8, !tbaa !12
  %989 = lshr i64 %988, 8
  %990 = or i64 %981, %989
  %991 = xor i64 %973, %990
  %992 = xor i64 %930, %991
  %993 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  store i64 %992, ptr %993, align 8, !tbaa !12
  %994 = load ptr, ptr %10, align 8, !tbaa !5
  %995 = getelementptr inbounds i64, ptr %994, i64 4
  %996 = getelementptr inbounds i64, ptr %995, i64 2
  %997 = load i64, ptr %996, align 8, !tbaa !12
  %998 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %999 = load i64, ptr %998, align 16, !tbaa !12
  %1000 = lshr i64 %999, 0
  %1001 = trunc i64 %1000 to i8
  %1002 = zext i8 %1001 to i64
  %1003 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1002
  %1004 = load i64, ptr %1003, align 8, !tbaa !12
  %1005 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %1006 = load i64, ptr %1005, align 8, !tbaa !12
  %1007 = lshr i64 %1006, 8
  %1008 = trunc i64 %1007 to i8
  %1009 = zext i8 %1008 to i64
  %1010 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1009
  %1011 = load i64, ptr %1010, align 8, !tbaa !12
  %1012 = shl i64 %1011, 8
  %1013 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %1014 = load i64, ptr %1013, align 8, !tbaa !12
  %1015 = lshr i64 %1014, 8
  %1016 = trunc i64 %1015 to i8
  %1017 = zext i8 %1016 to i64
  %1018 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1017
  %1019 = load i64, ptr %1018, align 8, !tbaa !12
  %1020 = lshr i64 %1019, 24
  %1021 = or i64 %1012, %1020
  %1022 = xor i64 %1004, %1021
  %1023 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %1024 = load i64, ptr %1023, align 16, !tbaa !12
  %1025 = lshr i64 %1024, 16
  %1026 = trunc i64 %1025 to i8
  %1027 = zext i8 %1026 to i64
  %1028 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1027
  %1029 = load i64, ptr %1028, align 8, !tbaa !12
  %1030 = shl i64 %1029, 16
  %1031 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %1032 = load i64, ptr %1031, align 16, !tbaa !12
  %1033 = lshr i64 %1032, 16
  %1034 = trunc i64 %1033 to i8
  %1035 = zext i8 %1034 to i64
  %1036 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1035
  %1037 = load i64, ptr %1036, align 8, !tbaa !12
  %1038 = lshr i64 %1037, 16
  %1039 = or i64 %1030, %1038
  %1040 = xor i64 %1022, %1039
  %1041 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %1042 = load i64, ptr %1041, align 8, !tbaa !12
  %1043 = lshr i64 %1042, 24
  %1044 = trunc i64 %1043 to i8
  %1045 = zext i8 %1044 to i64
  %1046 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1045
  %1047 = load i64, ptr %1046, align 8, !tbaa !12
  %1048 = shl i64 %1047, 24
  %1049 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %1050 = load i64, ptr %1049, align 8, !tbaa !12
  %1051 = lshr i64 %1050, 24
  %1052 = trunc i64 %1051 to i8
  %1053 = zext i8 %1052 to i64
  %1054 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1053
  %1055 = load i64, ptr %1054, align 8, !tbaa !12
  %1056 = lshr i64 %1055, 8
  %1057 = or i64 %1048, %1056
  %1058 = xor i64 %1040, %1057
  %1059 = xor i64 %997, %1058
  %1060 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  store i64 %1059, ptr %1060, align 16, !tbaa !12
  %1061 = load ptr, ptr %10, align 8, !tbaa !5
  %1062 = getelementptr inbounds i64, ptr %1061, i64 4
  %1063 = getelementptr inbounds i64, ptr %1062, i64 3
  %1064 = load i64, ptr %1063, align 8, !tbaa !12
  %1065 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %1066 = load i64, ptr %1065, align 8, !tbaa !12
  %1067 = lshr i64 %1066, 0
  %1068 = trunc i64 %1067 to i8
  %1069 = zext i8 %1068 to i64
  %1070 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1069
  %1071 = load i64, ptr %1070, align 8, !tbaa !12
  %1072 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %1073 = load i64, ptr %1072, align 16, !tbaa !12
  %1074 = lshr i64 %1073, 8
  %1075 = trunc i64 %1074 to i8
  %1076 = zext i8 %1075 to i64
  %1077 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1076
  %1078 = load i64, ptr %1077, align 8, !tbaa !12
  %1079 = shl i64 %1078, 8
  %1080 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %1081 = load i64, ptr %1080, align 16, !tbaa !12
  %1082 = lshr i64 %1081, 8
  %1083 = trunc i64 %1082 to i8
  %1084 = zext i8 %1083 to i64
  %1085 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1084
  %1086 = load i64, ptr %1085, align 8, !tbaa !12
  %1087 = lshr i64 %1086, 24
  %1088 = or i64 %1079, %1087
  %1089 = xor i64 %1071, %1088
  %1090 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %1091 = load i64, ptr %1090, align 8, !tbaa !12
  %1092 = lshr i64 %1091, 16
  %1093 = trunc i64 %1092 to i8
  %1094 = zext i8 %1093 to i64
  %1095 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1094
  %1096 = load i64, ptr %1095, align 8, !tbaa !12
  %1097 = shl i64 %1096, 16
  %1098 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %1099 = load i64, ptr %1098, align 8, !tbaa !12
  %1100 = lshr i64 %1099, 16
  %1101 = trunc i64 %1100 to i8
  %1102 = zext i8 %1101 to i64
  %1103 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1102
  %1104 = load i64, ptr %1103, align 8, !tbaa !12
  %1105 = lshr i64 %1104, 16
  %1106 = or i64 %1097, %1105
  %1107 = xor i64 %1089, %1106
  %1108 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %1109 = load i64, ptr %1108, align 16, !tbaa !12
  %1110 = lshr i64 %1109, 24
  %1111 = trunc i64 %1110 to i8
  %1112 = zext i8 %1111 to i64
  %1113 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1112
  %1114 = load i64, ptr %1113, align 8, !tbaa !12
  %1115 = shl i64 %1114, 24
  %1116 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %1117 = load i64, ptr %1116, align 16, !tbaa !12
  %1118 = lshr i64 %1117, 24
  %1119 = trunc i64 %1118 to i8
  %1120 = zext i8 %1119 to i64
  %1121 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1120
  %1122 = load i64, ptr %1121, align 8, !tbaa !12
  %1123 = lshr i64 %1122, 8
  %1124 = or i64 %1115, %1123
  %1125 = xor i64 %1107, %1124
  %1126 = xor i64 %1064, %1125
  %1127 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  store i64 %1126, ptr %1127, align 8, !tbaa !12
  %1128 = load ptr, ptr %10, align 8, !tbaa !5
  %1129 = getelementptr inbounds i64, ptr %1128, i64 8
  store ptr %1129, ptr %10, align 8, !tbaa !5
  br label %1130

1130:                                             ; preds = %595, %22
  %1131 = load ptr, ptr %10, align 8, !tbaa !5
  %1132 = getelementptr inbounds i64, ptr %1131, i64 0
  %1133 = load i64, ptr %1132, align 8, !tbaa !12
  %1134 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %1135 = load i64, ptr %1134, align 16, !tbaa !12
  %1136 = lshr i64 %1135, 0
  %1137 = trunc i64 %1136 to i8
  %1138 = zext i8 %1137 to i64
  %1139 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1138
  %1140 = load i64, ptr %1139, align 8, !tbaa !12
  %1141 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %1142 = load i64, ptr %1141, align 8, !tbaa !12
  %1143 = lshr i64 %1142, 8
  %1144 = trunc i64 %1143 to i8
  %1145 = zext i8 %1144 to i64
  %1146 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1145
  %1147 = load i64, ptr %1146, align 8, !tbaa !12
  %1148 = shl i64 %1147, 8
  %1149 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %1150 = load i64, ptr %1149, align 8, !tbaa !12
  %1151 = lshr i64 %1150, 8
  %1152 = trunc i64 %1151 to i8
  %1153 = zext i8 %1152 to i64
  %1154 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1153
  %1155 = load i64, ptr %1154, align 8, !tbaa !12
  %1156 = lshr i64 %1155, 24
  %1157 = or i64 %1148, %1156
  %1158 = xor i64 %1140, %1157
  %1159 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %1160 = load i64, ptr %1159, align 16, !tbaa !12
  %1161 = lshr i64 %1160, 16
  %1162 = trunc i64 %1161 to i8
  %1163 = zext i8 %1162 to i64
  %1164 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1163
  %1165 = load i64, ptr %1164, align 8, !tbaa !12
  %1166 = shl i64 %1165, 16
  %1167 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %1168 = load i64, ptr %1167, align 16, !tbaa !12
  %1169 = lshr i64 %1168, 16
  %1170 = trunc i64 %1169 to i8
  %1171 = zext i8 %1170 to i64
  %1172 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1171
  %1173 = load i64, ptr %1172, align 8, !tbaa !12
  %1174 = lshr i64 %1173, 16
  %1175 = or i64 %1166, %1174
  %1176 = xor i64 %1158, %1175
  %1177 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %1178 = load i64, ptr %1177, align 8, !tbaa !12
  %1179 = lshr i64 %1178, 24
  %1180 = trunc i64 %1179 to i8
  %1181 = zext i8 %1180 to i64
  %1182 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1181
  %1183 = load i64, ptr %1182, align 8, !tbaa !12
  %1184 = shl i64 %1183, 24
  %1185 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %1186 = load i64, ptr %1185, align 8, !tbaa !12
  %1187 = lshr i64 %1186, 24
  %1188 = trunc i64 %1187 to i8
  %1189 = zext i8 %1188 to i64
  %1190 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1189
  %1191 = load i64, ptr %1190, align 8, !tbaa !12
  %1192 = lshr i64 %1191, 8
  %1193 = or i64 %1184, %1192
  %1194 = xor i64 %1176, %1193
  %1195 = xor i64 %1133, %1194
  %1196 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  store i64 %1195, ptr %1196, align 16, !tbaa !12
  %1197 = load ptr, ptr %10, align 8, !tbaa !5
  %1198 = getelementptr inbounds i64, ptr %1197, i64 1
  %1199 = load i64, ptr %1198, align 8, !tbaa !12
  %1200 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %1201 = load i64, ptr %1200, align 8, !tbaa !12
  %1202 = lshr i64 %1201, 0
  %1203 = trunc i64 %1202 to i8
  %1204 = zext i8 %1203 to i64
  %1205 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1204
  %1206 = load i64, ptr %1205, align 8, !tbaa !12
  %1207 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %1208 = load i64, ptr %1207, align 16, !tbaa !12
  %1209 = lshr i64 %1208, 8
  %1210 = trunc i64 %1209 to i8
  %1211 = zext i8 %1210 to i64
  %1212 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1211
  %1213 = load i64, ptr %1212, align 8, !tbaa !12
  %1214 = shl i64 %1213, 8
  %1215 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %1216 = load i64, ptr %1215, align 16, !tbaa !12
  %1217 = lshr i64 %1216, 8
  %1218 = trunc i64 %1217 to i8
  %1219 = zext i8 %1218 to i64
  %1220 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1219
  %1221 = load i64, ptr %1220, align 8, !tbaa !12
  %1222 = lshr i64 %1221, 24
  %1223 = or i64 %1214, %1222
  %1224 = xor i64 %1206, %1223
  %1225 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %1226 = load i64, ptr %1225, align 8, !tbaa !12
  %1227 = lshr i64 %1226, 16
  %1228 = trunc i64 %1227 to i8
  %1229 = zext i8 %1228 to i64
  %1230 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1229
  %1231 = load i64, ptr %1230, align 8, !tbaa !12
  %1232 = shl i64 %1231, 16
  %1233 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %1234 = load i64, ptr %1233, align 8, !tbaa !12
  %1235 = lshr i64 %1234, 16
  %1236 = trunc i64 %1235 to i8
  %1237 = zext i8 %1236 to i64
  %1238 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1237
  %1239 = load i64, ptr %1238, align 8, !tbaa !12
  %1240 = lshr i64 %1239, 16
  %1241 = or i64 %1232, %1240
  %1242 = xor i64 %1224, %1241
  %1243 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %1244 = load i64, ptr %1243, align 16, !tbaa !12
  %1245 = lshr i64 %1244, 24
  %1246 = trunc i64 %1245 to i8
  %1247 = zext i8 %1246 to i64
  %1248 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1247
  %1249 = load i64, ptr %1248, align 8, !tbaa !12
  %1250 = shl i64 %1249, 24
  %1251 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %1252 = load i64, ptr %1251, align 16, !tbaa !12
  %1253 = lshr i64 %1252, 24
  %1254 = trunc i64 %1253 to i8
  %1255 = zext i8 %1254 to i64
  %1256 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1255
  %1257 = load i64, ptr %1256, align 8, !tbaa !12
  %1258 = lshr i64 %1257, 8
  %1259 = or i64 %1250, %1258
  %1260 = xor i64 %1242, %1259
  %1261 = xor i64 %1199, %1260
  %1262 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  store i64 %1261, ptr %1262, align 8, !tbaa !12
  %1263 = load ptr, ptr %10, align 8, !tbaa !5
  %1264 = getelementptr inbounds i64, ptr %1263, i64 2
  %1265 = load i64, ptr %1264, align 8, !tbaa !12
  %1266 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %1267 = load i64, ptr %1266, align 16, !tbaa !12
  %1268 = lshr i64 %1267, 0
  %1269 = trunc i64 %1268 to i8
  %1270 = zext i8 %1269 to i64
  %1271 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1270
  %1272 = load i64, ptr %1271, align 8, !tbaa !12
  %1273 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %1274 = load i64, ptr %1273, align 8, !tbaa !12
  %1275 = lshr i64 %1274, 8
  %1276 = trunc i64 %1275 to i8
  %1277 = zext i8 %1276 to i64
  %1278 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1277
  %1279 = load i64, ptr %1278, align 8, !tbaa !12
  %1280 = shl i64 %1279, 8
  %1281 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %1282 = load i64, ptr %1281, align 8, !tbaa !12
  %1283 = lshr i64 %1282, 8
  %1284 = trunc i64 %1283 to i8
  %1285 = zext i8 %1284 to i64
  %1286 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1285
  %1287 = load i64, ptr %1286, align 8, !tbaa !12
  %1288 = lshr i64 %1287, 24
  %1289 = or i64 %1280, %1288
  %1290 = xor i64 %1272, %1289
  %1291 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %1292 = load i64, ptr %1291, align 16, !tbaa !12
  %1293 = lshr i64 %1292, 16
  %1294 = trunc i64 %1293 to i8
  %1295 = zext i8 %1294 to i64
  %1296 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1295
  %1297 = load i64, ptr %1296, align 8, !tbaa !12
  %1298 = shl i64 %1297, 16
  %1299 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %1300 = load i64, ptr %1299, align 16, !tbaa !12
  %1301 = lshr i64 %1300, 16
  %1302 = trunc i64 %1301 to i8
  %1303 = zext i8 %1302 to i64
  %1304 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1303
  %1305 = load i64, ptr %1304, align 8, !tbaa !12
  %1306 = lshr i64 %1305, 16
  %1307 = or i64 %1298, %1306
  %1308 = xor i64 %1290, %1307
  %1309 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %1310 = load i64, ptr %1309, align 8, !tbaa !12
  %1311 = lshr i64 %1310, 24
  %1312 = trunc i64 %1311 to i8
  %1313 = zext i8 %1312 to i64
  %1314 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1313
  %1315 = load i64, ptr %1314, align 8, !tbaa !12
  %1316 = shl i64 %1315, 24
  %1317 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %1318 = load i64, ptr %1317, align 8, !tbaa !12
  %1319 = lshr i64 %1318, 24
  %1320 = trunc i64 %1319 to i8
  %1321 = zext i8 %1320 to i64
  %1322 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1321
  %1323 = load i64, ptr %1322, align 8, !tbaa !12
  %1324 = lshr i64 %1323, 8
  %1325 = or i64 %1316, %1324
  %1326 = xor i64 %1308, %1325
  %1327 = xor i64 %1265, %1326
  %1328 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  store i64 %1327, ptr %1328, align 16, !tbaa !12
  %1329 = load ptr, ptr %10, align 8, !tbaa !5
  %1330 = getelementptr inbounds i64, ptr %1329, i64 3
  %1331 = load i64, ptr %1330, align 8, !tbaa !12
  %1332 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %1333 = load i64, ptr %1332, align 8, !tbaa !12
  %1334 = lshr i64 %1333, 0
  %1335 = trunc i64 %1334 to i8
  %1336 = zext i8 %1335 to i64
  %1337 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1336
  %1338 = load i64, ptr %1337, align 8, !tbaa !12
  %1339 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %1340 = load i64, ptr %1339, align 16, !tbaa !12
  %1341 = lshr i64 %1340, 8
  %1342 = trunc i64 %1341 to i8
  %1343 = zext i8 %1342 to i64
  %1344 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1343
  %1345 = load i64, ptr %1344, align 8, !tbaa !12
  %1346 = shl i64 %1345, 8
  %1347 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %1348 = load i64, ptr %1347, align 16, !tbaa !12
  %1349 = lshr i64 %1348, 8
  %1350 = trunc i64 %1349 to i8
  %1351 = zext i8 %1350 to i64
  %1352 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1351
  %1353 = load i64, ptr %1352, align 8, !tbaa !12
  %1354 = lshr i64 %1353, 24
  %1355 = or i64 %1346, %1354
  %1356 = xor i64 %1338, %1355
  %1357 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %1358 = load i64, ptr %1357, align 8, !tbaa !12
  %1359 = lshr i64 %1358, 16
  %1360 = trunc i64 %1359 to i8
  %1361 = zext i8 %1360 to i64
  %1362 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1361
  %1363 = load i64, ptr %1362, align 8, !tbaa !12
  %1364 = shl i64 %1363, 16
  %1365 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %1366 = load i64, ptr %1365, align 8, !tbaa !12
  %1367 = lshr i64 %1366, 16
  %1368 = trunc i64 %1367 to i8
  %1369 = zext i8 %1368 to i64
  %1370 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1369
  %1371 = load i64, ptr %1370, align 8, !tbaa !12
  %1372 = lshr i64 %1371, 16
  %1373 = or i64 %1364, %1372
  %1374 = xor i64 %1356, %1373
  %1375 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %1376 = load i64, ptr %1375, align 16, !tbaa !12
  %1377 = lshr i64 %1376, 24
  %1378 = trunc i64 %1377 to i8
  %1379 = zext i8 %1378 to i64
  %1380 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1379
  %1381 = load i64, ptr %1380, align 8, !tbaa !12
  %1382 = shl i64 %1381, 24
  %1383 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %1384 = load i64, ptr %1383, align 16, !tbaa !12
  %1385 = lshr i64 %1384, 24
  %1386 = trunc i64 %1385 to i8
  %1387 = zext i8 %1386 to i64
  %1388 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1387
  %1389 = load i64, ptr %1388, align 8, !tbaa !12
  %1390 = lshr i64 %1389, 8
  %1391 = or i64 %1382, %1390
  %1392 = xor i64 %1374, %1391
  %1393 = xor i64 %1331, %1392
  %1394 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  store i64 %1393, ptr %1394, align 8, !tbaa !12
  %1395 = load ptr, ptr %10, align 8, !tbaa !5
  %1396 = getelementptr inbounds i64, ptr %1395, i64 4
  %1397 = getelementptr inbounds i64, ptr %1396, i64 0
  %1398 = load i64, ptr %1397, align 8, !tbaa !12
  %1399 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %1400 = load i64, ptr %1399, align 16, !tbaa !12
  %1401 = lshr i64 %1400, 0
  %1402 = trunc i64 %1401 to i8
  %1403 = zext i8 %1402 to i64
  %1404 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1403
  %1405 = load i64, ptr %1404, align 8, !tbaa !12
  %1406 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %1407 = load i64, ptr %1406, align 8, !tbaa !12
  %1408 = lshr i64 %1407, 8
  %1409 = trunc i64 %1408 to i8
  %1410 = zext i8 %1409 to i64
  %1411 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1410
  %1412 = load i64, ptr %1411, align 8, !tbaa !12
  %1413 = shl i64 %1412, 8
  %1414 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %1415 = load i64, ptr %1414, align 8, !tbaa !12
  %1416 = lshr i64 %1415, 8
  %1417 = trunc i64 %1416 to i8
  %1418 = zext i8 %1417 to i64
  %1419 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1418
  %1420 = load i64, ptr %1419, align 8, !tbaa !12
  %1421 = lshr i64 %1420, 24
  %1422 = or i64 %1413, %1421
  %1423 = xor i64 %1405, %1422
  %1424 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %1425 = load i64, ptr %1424, align 16, !tbaa !12
  %1426 = lshr i64 %1425, 16
  %1427 = trunc i64 %1426 to i8
  %1428 = zext i8 %1427 to i64
  %1429 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1428
  %1430 = load i64, ptr %1429, align 8, !tbaa !12
  %1431 = shl i64 %1430, 16
  %1432 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %1433 = load i64, ptr %1432, align 16, !tbaa !12
  %1434 = lshr i64 %1433, 16
  %1435 = trunc i64 %1434 to i8
  %1436 = zext i8 %1435 to i64
  %1437 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1436
  %1438 = load i64, ptr %1437, align 8, !tbaa !12
  %1439 = lshr i64 %1438, 16
  %1440 = or i64 %1431, %1439
  %1441 = xor i64 %1423, %1440
  %1442 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %1443 = load i64, ptr %1442, align 8, !tbaa !12
  %1444 = lshr i64 %1443, 24
  %1445 = trunc i64 %1444 to i8
  %1446 = zext i8 %1445 to i64
  %1447 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1446
  %1448 = load i64, ptr %1447, align 8, !tbaa !12
  %1449 = shl i64 %1448, 24
  %1450 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %1451 = load i64, ptr %1450, align 8, !tbaa !12
  %1452 = lshr i64 %1451, 24
  %1453 = trunc i64 %1452 to i8
  %1454 = zext i8 %1453 to i64
  %1455 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1454
  %1456 = load i64, ptr %1455, align 8, !tbaa !12
  %1457 = lshr i64 %1456, 8
  %1458 = or i64 %1449, %1457
  %1459 = xor i64 %1441, %1458
  %1460 = xor i64 %1398, %1459
  %1461 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  store i64 %1460, ptr %1461, align 16, !tbaa !12
  %1462 = load ptr, ptr %10, align 8, !tbaa !5
  %1463 = getelementptr inbounds i64, ptr %1462, i64 4
  %1464 = getelementptr inbounds i64, ptr %1463, i64 1
  %1465 = load i64, ptr %1464, align 8, !tbaa !12
  %1466 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %1467 = load i64, ptr %1466, align 8, !tbaa !12
  %1468 = lshr i64 %1467, 0
  %1469 = trunc i64 %1468 to i8
  %1470 = zext i8 %1469 to i64
  %1471 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1470
  %1472 = load i64, ptr %1471, align 8, !tbaa !12
  %1473 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %1474 = load i64, ptr %1473, align 16, !tbaa !12
  %1475 = lshr i64 %1474, 8
  %1476 = trunc i64 %1475 to i8
  %1477 = zext i8 %1476 to i64
  %1478 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1477
  %1479 = load i64, ptr %1478, align 8, !tbaa !12
  %1480 = shl i64 %1479, 8
  %1481 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %1482 = load i64, ptr %1481, align 16, !tbaa !12
  %1483 = lshr i64 %1482, 8
  %1484 = trunc i64 %1483 to i8
  %1485 = zext i8 %1484 to i64
  %1486 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1485
  %1487 = load i64, ptr %1486, align 8, !tbaa !12
  %1488 = lshr i64 %1487, 24
  %1489 = or i64 %1480, %1488
  %1490 = xor i64 %1472, %1489
  %1491 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %1492 = load i64, ptr %1491, align 8, !tbaa !12
  %1493 = lshr i64 %1492, 16
  %1494 = trunc i64 %1493 to i8
  %1495 = zext i8 %1494 to i64
  %1496 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1495
  %1497 = load i64, ptr %1496, align 8, !tbaa !12
  %1498 = shl i64 %1497, 16
  %1499 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %1500 = load i64, ptr %1499, align 8, !tbaa !12
  %1501 = lshr i64 %1500, 16
  %1502 = trunc i64 %1501 to i8
  %1503 = zext i8 %1502 to i64
  %1504 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1503
  %1505 = load i64, ptr %1504, align 8, !tbaa !12
  %1506 = lshr i64 %1505, 16
  %1507 = or i64 %1498, %1506
  %1508 = xor i64 %1490, %1507
  %1509 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %1510 = load i64, ptr %1509, align 16, !tbaa !12
  %1511 = lshr i64 %1510, 24
  %1512 = trunc i64 %1511 to i8
  %1513 = zext i8 %1512 to i64
  %1514 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1513
  %1515 = load i64, ptr %1514, align 8, !tbaa !12
  %1516 = shl i64 %1515, 24
  %1517 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %1518 = load i64, ptr %1517, align 16, !tbaa !12
  %1519 = lshr i64 %1518, 24
  %1520 = trunc i64 %1519 to i8
  %1521 = zext i8 %1520 to i64
  %1522 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1521
  %1523 = load i64, ptr %1522, align 8, !tbaa !12
  %1524 = lshr i64 %1523, 8
  %1525 = or i64 %1516, %1524
  %1526 = xor i64 %1508, %1525
  %1527 = xor i64 %1465, %1526
  %1528 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  store i64 %1527, ptr %1528, align 8, !tbaa !12
  %1529 = load ptr, ptr %10, align 8, !tbaa !5
  %1530 = getelementptr inbounds i64, ptr %1529, i64 4
  %1531 = getelementptr inbounds i64, ptr %1530, i64 2
  %1532 = load i64, ptr %1531, align 8, !tbaa !12
  %1533 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %1534 = load i64, ptr %1533, align 16, !tbaa !12
  %1535 = lshr i64 %1534, 0
  %1536 = trunc i64 %1535 to i8
  %1537 = zext i8 %1536 to i64
  %1538 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1537
  %1539 = load i64, ptr %1538, align 8, !tbaa !12
  %1540 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %1541 = load i64, ptr %1540, align 8, !tbaa !12
  %1542 = lshr i64 %1541, 8
  %1543 = trunc i64 %1542 to i8
  %1544 = zext i8 %1543 to i64
  %1545 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1544
  %1546 = load i64, ptr %1545, align 8, !tbaa !12
  %1547 = shl i64 %1546, 8
  %1548 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %1549 = load i64, ptr %1548, align 8, !tbaa !12
  %1550 = lshr i64 %1549, 8
  %1551 = trunc i64 %1550 to i8
  %1552 = zext i8 %1551 to i64
  %1553 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1552
  %1554 = load i64, ptr %1553, align 8, !tbaa !12
  %1555 = lshr i64 %1554, 24
  %1556 = or i64 %1547, %1555
  %1557 = xor i64 %1539, %1556
  %1558 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %1559 = load i64, ptr %1558, align 16, !tbaa !12
  %1560 = lshr i64 %1559, 16
  %1561 = trunc i64 %1560 to i8
  %1562 = zext i8 %1561 to i64
  %1563 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1562
  %1564 = load i64, ptr %1563, align 8, !tbaa !12
  %1565 = shl i64 %1564, 16
  %1566 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %1567 = load i64, ptr %1566, align 16, !tbaa !12
  %1568 = lshr i64 %1567, 16
  %1569 = trunc i64 %1568 to i8
  %1570 = zext i8 %1569 to i64
  %1571 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1570
  %1572 = load i64, ptr %1571, align 8, !tbaa !12
  %1573 = lshr i64 %1572, 16
  %1574 = or i64 %1565, %1573
  %1575 = xor i64 %1557, %1574
  %1576 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %1577 = load i64, ptr %1576, align 8, !tbaa !12
  %1578 = lshr i64 %1577, 24
  %1579 = trunc i64 %1578 to i8
  %1580 = zext i8 %1579 to i64
  %1581 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1580
  %1582 = load i64, ptr %1581, align 8, !tbaa !12
  %1583 = shl i64 %1582, 24
  %1584 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %1585 = load i64, ptr %1584, align 8, !tbaa !12
  %1586 = lshr i64 %1585, 24
  %1587 = trunc i64 %1586 to i8
  %1588 = zext i8 %1587 to i64
  %1589 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1588
  %1590 = load i64, ptr %1589, align 8, !tbaa !12
  %1591 = lshr i64 %1590, 8
  %1592 = or i64 %1583, %1591
  %1593 = xor i64 %1575, %1592
  %1594 = xor i64 %1532, %1593
  %1595 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  store i64 %1594, ptr %1595, align 16, !tbaa !12
  %1596 = load ptr, ptr %10, align 8, !tbaa !5
  %1597 = getelementptr inbounds i64, ptr %1596, i64 4
  %1598 = getelementptr inbounds i64, ptr %1597, i64 3
  %1599 = load i64, ptr %1598, align 8, !tbaa !12
  %1600 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %1601 = load i64, ptr %1600, align 8, !tbaa !12
  %1602 = lshr i64 %1601, 0
  %1603 = trunc i64 %1602 to i8
  %1604 = zext i8 %1603 to i64
  %1605 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1604
  %1606 = load i64, ptr %1605, align 8, !tbaa !12
  %1607 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %1608 = load i64, ptr %1607, align 16, !tbaa !12
  %1609 = lshr i64 %1608, 8
  %1610 = trunc i64 %1609 to i8
  %1611 = zext i8 %1610 to i64
  %1612 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1611
  %1613 = load i64, ptr %1612, align 8, !tbaa !12
  %1614 = shl i64 %1613, 8
  %1615 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %1616 = load i64, ptr %1615, align 16, !tbaa !12
  %1617 = lshr i64 %1616, 8
  %1618 = trunc i64 %1617 to i8
  %1619 = zext i8 %1618 to i64
  %1620 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1619
  %1621 = load i64, ptr %1620, align 8, !tbaa !12
  %1622 = lshr i64 %1621, 24
  %1623 = or i64 %1614, %1622
  %1624 = xor i64 %1606, %1623
  %1625 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %1626 = load i64, ptr %1625, align 8, !tbaa !12
  %1627 = lshr i64 %1626, 16
  %1628 = trunc i64 %1627 to i8
  %1629 = zext i8 %1628 to i64
  %1630 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1629
  %1631 = load i64, ptr %1630, align 8, !tbaa !12
  %1632 = shl i64 %1631, 16
  %1633 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %1634 = load i64, ptr %1633, align 8, !tbaa !12
  %1635 = lshr i64 %1634, 16
  %1636 = trunc i64 %1635 to i8
  %1637 = zext i8 %1636 to i64
  %1638 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1637
  %1639 = load i64, ptr %1638, align 8, !tbaa !12
  %1640 = lshr i64 %1639, 16
  %1641 = or i64 %1632, %1640
  %1642 = xor i64 %1624, %1641
  %1643 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %1644 = load i64, ptr %1643, align 16, !tbaa !12
  %1645 = lshr i64 %1644, 24
  %1646 = trunc i64 %1645 to i8
  %1647 = zext i8 %1646 to i64
  %1648 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1647
  %1649 = load i64, ptr %1648, align 8, !tbaa !12
  %1650 = shl i64 %1649, 24
  %1651 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %1652 = load i64, ptr %1651, align 16, !tbaa !12
  %1653 = lshr i64 %1652, 24
  %1654 = trunc i64 %1653 to i8
  %1655 = zext i8 %1654 to i64
  %1656 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1655
  %1657 = load i64, ptr %1656, align 8, !tbaa !12
  %1658 = lshr i64 %1657, 8
  %1659 = or i64 %1650, %1658
  %1660 = xor i64 %1642, %1659
  %1661 = xor i64 %1599, %1660
  %1662 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  store i64 %1661, ptr %1662, align 8, !tbaa !12
  %1663 = load ptr, ptr %10, align 8, !tbaa !5
  %1664 = getelementptr inbounds i64, ptr %1663, i64 8
  %1665 = getelementptr inbounds i64, ptr %1664, i64 0
  %1666 = load i64, ptr %1665, align 8, !tbaa !12
  %1667 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %1668 = load i64, ptr %1667, align 16, !tbaa !12
  %1669 = lshr i64 %1668, 0
  %1670 = trunc i64 %1669 to i8
  %1671 = zext i8 %1670 to i64
  %1672 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1671
  %1673 = load i64, ptr %1672, align 8, !tbaa !12
  %1674 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %1675 = load i64, ptr %1674, align 8, !tbaa !12
  %1676 = lshr i64 %1675, 8
  %1677 = trunc i64 %1676 to i8
  %1678 = zext i8 %1677 to i64
  %1679 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1678
  %1680 = load i64, ptr %1679, align 8, !tbaa !12
  %1681 = shl i64 %1680, 8
  %1682 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %1683 = load i64, ptr %1682, align 8, !tbaa !12
  %1684 = lshr i64 %1683, 8
  %1685 = trunc i64 %1684 to i8
  %1686 = zext i8 %1685 to i64
  %1687 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1686
  %1688 = load i64, ptr %1687, align 8, !tbaa !12
  %1689 = lshr i64 %1688, 24
  %1690 = or i64 %1681, %1689
  %1691 = xor i64 %1673, %1690
  %1692 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %1693 = load i64, ptr %1692, align 16, !tbaa !12
  %1694 = lshr i64 %1693, 16
  %1695 = trunc i64 %1694 to i8
  %1696 = zext i8 %1695 to i64
  %1697 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1696
  %1698 = load i64, ptr %1697, align 8, !tbaa !12
  %1699 = shl i64 %1698, 16
  %1700 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %1701 = load i64, ptr %1700, align 16, !tbaa !12
  %1702 = lshr i64 %1701, 16
  %1703 = trunc i64 %1702 to i8
  %1704 = zext i8 %1703 to i64
  %1705 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1704
  %1706 = load i64, ptr %1705, align 8, !tbaa !12
  %1707 = lshr i64 %1706, 16
  %1708 = or i64 %1699, %1707
  %1709 = xor i64 %1691, %1708
  %1710 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %1711 = load i64, ptr %1710, align 8, !tbaa !12
  %1712 = lshr i64 %1711, 24
  %1713 = trunc i64 %1712 to i8
  %1714 = zext i8 %1713 to i64
  %1715 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1714
  %1716 = load i64, ptr %1715, align 8, !tbaa !12
  %1717 = shl i64 %1716, 24
  %1718 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %1719 = load i64, ptr %1718, align 8, !tbaa !12
  %1720 = lshr i64 %1719, 24
  %1721 = trunc i64 %1720 to i8
  %1722 = zext i8 %1721 to i64
  %1723 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1722
  %1724 = load i64, ptr %1723, align 8, !tbaa !12
  %1725 = lshr i64 %1724, 8
  %1726 = or i64 %1717, %1725
  %1727 = xor i64 %1709, %1726
  %1728 = xor i64 %1666, %1727
  %1729 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  store i64 %1728, ptr %1729, align 16, !tbaa !12
  %1730 = load ptr, ptr %10, align 8, !tbaa !5
  %1731 = getelementptr inbounds i64, ptr %1730, i64 8
  %1732 = getelementptr inbounds i64, ptr %1731, i64 1
  %1733 = load i64, ptr %1732, align 8, !tbaa !12
  %1734 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %1735 = load i64, ptr %1734, align 8, !tbaa !12
  %1736 = lshr i64 %1735, 0
  %1737 = trunc i64 %1736 to i8
  %1738 = zext i8 %1737 to i64
  %1739 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1738
  %1740 = load i64, ptr %1739, align 8, !tbaa !12
  %1741 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %1742 = load i64, ptr %1741, align 16, !tbaa !12
  %1743 = lshr i64 %1742, 8
  %1744 = trunc i64 %1743 to i8
  %1745 = zext i8 %1744 to i64
  %1746 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1745
  %1747 = load i64, ptr %1746, align 8, !tbaa !12
  %1748 = shl i64 %1747, 8
  %1749 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %1750 = load i64, ptr %1749, align 16, !tbaa !12
  %1751 = lshr i64 %1750, 8
  %1752 = trunc i64 %1751 to i8
  %1753 = zext i8 %1752 to i64
  %1754 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1753
  %1755 = load i64, ptr %1754, align 8, !tbaa !12
  %1756 = lshr i64 %1755, 24
  %1757 = or i64 %1748, %1756
  %1758 = xor i64 %1740, %1757
  %1759 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %1760 = load i64, ptr %1759, align 8, !tbaa !12
  %1761 = lshr i64 %1760, 16
  %1762 = trunc i64 %1761 to i8
  %1763 = zext i8 %1762 to i64
  %1764 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1763
  %1765 = load i64, ptr %1764, align 8, !tbaa !12
  %1766 = shl i64 %1765, 16
  %1767 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %1768 = load i64, ptr %1767, align 8, !tbaa !12
  %1769 = lshr i64 %1768, 16
  %1770 = trunc i64 %1769 to i8
  %1771 = zext i8 %1770 to i64
  %1772 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1771
  %1773 = load i64, ptr %1772, align 8, !tbaa !12
  %1774 = lshr i64 %1773, 16
  %1775 = or i64 %1766, %1774
  %1776 = xor i64 %1758, %1775
  %1777 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %1778 = load i64, ptr %1777, align 16, !tbaa !12
  %1779 = lshr i64 %1778, 24
  %1780 = trunc i64 %1779 to i8
  %1781 = zext i8 %1780 to i64
  %1782 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1781
  %1783 = load i64, ptr %1782, align 8, !tbaa !12
  %1784 = shl i64 %1783, 24
  %1785 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %1786 = load i64, ptr %1785, align 16, !tbaa !12
  %1787 = lshr i64 %1786, 24
  %1788 = trunc i64 %1787 to i8
  %1789 = zext i8 %1788 to i64
  %1790 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1789
  %1791 = load i64, ptr %1790, align 8, !tbaa !12
  %1792 = lshr i64 %1791, 8
  %1793 = or i64 %1784, %1792
  %1794 = xor i64 %1776, %1793
  %1795 = xor i64 %1733, %1794
  %1796 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  store i64 %1795, ptr %1796, align 8, !tbaa !12
  %1797 = load ptr, ptr %10, align 8, !tbaa !5
  %1798 = getelementptr inbounds i64, ptr %1797, i64 8
  %1799 = getelementptr inbounds i64, ptr %1798, i64 2
  %1800 = load i64, ptr %1799, align 8, !tbaa !12
  %1801 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %1802 = load i64, ptr %1801, align 16, !tbaa !12
  %1803 = lshr i64 %1802, 0
  %1804 = trunc i64 %1803 to i8
  %1805 = zext i8 %1804 to i64
  %1806 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1805
  %1807 = load i64, ptr %1806, align 8, !tbaa !12
  %1808 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %1809 = load i64, ptr %1808, align 8, !tbaa !12
  %1810 = lshr i64 %1809, 8
  %1811 = trunc i64 %1810 to i8
  %1812 = zext i8 %1811 to i64
  %1813 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1812
  %1814 = load i64, ptr %1813, align 8, !tbaa !12
  %1815 = shl i64 %1814, 8
  %1816 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %1817 = load i64, ptr %1816, align 8, !tbaa !12
  %1818 = lshr i64 %1817, 8
  %1819 = trunc i64 %1818 to i8
  %1820 = zext i8 %1819 to i64
  %1821 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1820
  %1822 = load i64, ptr %1821, align 8, !tbaa !12
  %1823 = lshr i64 %1822, 24
  %1824 = or i64 %1815, %1823
  %1825 = xor i64 %1807, %1824
  %1826 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %1827 = load i64, ptr %1826, align 16, !tbaa !12
  %1828 = lshr i64 %1827, 16
  %1829 = trunc i64 %1828 to i8
  %1830 = zext i8 %1829 to i64
  %1831 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1830
  %1832 = load i64, ptr %1831, align 8, !tbaa !12
  %1833 = shl i64 %1832, 16
  %1834 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %1835 = load i64, ptr %1834, align 16, !tbaa !12
  %1836 = lshr i64 %1835, 16
  %1837 = trunc i64 %1836 to i8
  %1838 = zext i8 %1837 to i64
  %1839 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1838
  %1840 = load i64, ptr %1839, align 8, !tbaa !12
  %1841 = lshr i64 %1840, 16
  %1842 = or i64 %1833, %1841
  %1843 = xor i64 %1825, %1842
  %1844 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %1845 = load i64, ptr %1844, align 8, !tbaa !12
  %1846 = lshr i64 %1845, 24
  %1847 = trunc i64 %1846 to i8
  %1848 = zext i8 %1847 to i64
  %1849 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1848
  %1850 = load i64, ptr %1849, align 8, !tbaa !12
  %1851 = shl i64 %1850, 24
  %1852 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %1853 = load i64, ptr %1852, align 8, !tbaa !12
  %1854 = lshr i64 %1853, 24
  %1855 = trunc i64 %1854 to i8
  %1856 = zext i8 %1855 to i64
  %1857 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1856
  %1858 = load i64, ptr %1857, align 8, !tbaa !12
  %1859 = lshr i64 %1858, 8
  %1860 = or i64 %1851, %1859
  %1861 = xor i64 %1843, %1860
  %1862 = xor i64 %1800, %1861
  %1863 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  store i64 %1862, ptr %1863, align 16, !tbaa !12
  %1864 = load ptr, ptr %10, align 8, !tbaa !5
  %1865 = getelementptr inbounds i64, ptr %1864, i64 8
  %1866 = getelementptr inbounds i64, ptr %1865, i64 3
  %1867 = load i64, ptr %1866, align 8, !tbaa !12
  %1868 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %1869 = load i64, ptr %1868, align 8, !tbaa !12
  %1870 = lshr i64 %1869, 0
  %1871 = trunc i64 %1870 to i8
  %1872 = zext i8 %1871 to i64
  %1873 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1872
  %1874 = load i64, ptr %1873, align 8, !tbaa !12
  %1875 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %1876 = load i64, ptr %1875, align 16, !tbaa !12
  %1877 = lshr i64 %1876, 8
  %1878 = trunc i64 %1877 to i8
  %1879 = zext i8 %1878 to i64
  %1880 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1879
  %1881 = load i64, ptr %1880, align 8, !tbaa !12
  %1882 = shl i64 %1881, 8
  %1883 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %1884 = load i64, ptr %1883, align 16, !tbaa !12
  %1885 = lshr i64 %1884, 8
  %1886 = trunc i64 %1885 to i8
  %1887 = zext i8 %1886 to i64
  %1888 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1887
  %1889 = load i64, ptr %1888, align 8, !tbaa !12
  %1890 = lshr i64 %1889, 24
  %1891 = or i64 %1882, %1890
  %1892 = xor i64 %1874, %1891
  %1893 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %1894 = load i64, ptr %1893, align 8, !tbaa !12
  %1895 = lshr i64 %1894, 16
  %1896 = trunc i64 %1895 to i8
  %1897 = zext i8 %1896 to i64
  %1898 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1897
  %1899 = load i64, ptr %1898, align 8, !tbaa !12
  %1900 = shl i64 %1899, 16
  %1901 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %1902 = load i64, ptr %1901, align 8, !tbaa !12
  %1903 = lshr i64 %1902, 16
  %1904 = trunc i64 %1903 to i8
  %1905 = zext i8 %1904 to i64
  %1906 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1905
  %1907 = load i64, ptr %1906, align 8, !tbaa !12
  %1908 = lshr i64 %1907, 16
  %1909 = or i64 %1900, %1908
  %1910 = xor i64 %1892, %1909
  %1911 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %1912 = load i64, ptr %1911, align 16, !tbaa !12
  %1913 = lshr i64 %1912, 24
  %1914 = trunc i64 %1913 to i8
  %1915 = zext i8 %1914 to i64
  %1916 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1915
  %1917 = load i64, ptr %1916, align 8, !tbaa !12
  %1918 = shl i64 %1917, 24
  %1919 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %1920 = load i64, ptr %1919, align 16, !tbaa !12
  %1921 = lshr i64 %1920, 24
  %1922 = trunc i64 %1921 to i8
  %1923 = zext i8 %1922 to i64
  %1924 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1923
  %1925 = load i64, ptr %1924, align 8, !tbaa !12
  %1926 = lshr i64 %1925, 8
  %1927 = or i64 %1918, %1926
  %1928 = xor i64 %1910, %1927
  %1929 = xor i64 %1867, %1928
  %1930 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  store i64 %1929, ptr %1930, align 8, !tbaa !12
  %1931 = load ptr, ptr %10, align 8, !tbaa !5
  %1932 = getelementptr inbounds i64, ptr %1931, i64 12
  %1933 = getelementptr inbounds i64, ptr %1932, i64 0
  %1934 = load i64, ptr %1933, align 8, !tbaa !12
  %1935 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %1936 = load i64, ptr %1935, align 16, !tbaa !12
  %1937 = lshr i64 %1936, 0
  %1938 = trunc i64 %1937 to i8
  %1939 = zext i8 %1938 to i64
  %1940 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1939
  %1941 = load i64, ptr %1940, align 8, !tbaa !12
  %1942 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %1943 = load i64, ptr %1942, align 8, !tbaa !12
  %1944 = lshr i64 %1943, 8
  %1945 = trunc i64 %1944 to i8
  %1946 = zext i8 %1945 to i64
  %1947 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1946
  %1948 = load i64, ptr %1947, align 8, !tbaa !12
  %1949 = shl i64 %1948, 8
  %1950 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %1951 = load i64, ptr %1950, align 8, !tbaa !12
  %1952 = lshr i64 %1951, 8
  %1953 = trunc i64 %1952 to i8
  %1954 = zext i8 %1953 to i64
  %1955 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1954
  %1956 = load i64, ptr %1955, align 8, !tbaa !12
  %1957 = lshr i64 %1956, 24
  %1958 = or i64 %1949, %1957
  %1959 = xor i64 %1941, %1958
  %1960 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %1961 = load i64, ptr %1960, align 16, !tbaa !12
  %1962 = lshr i64 %1961, 16
  %1963 = trunc i64 %1962 to i8
  %1964 = zext i8 %1963 to i64
  %1965 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1964
  %1966 = load i64, ptr %1965, align 8, !tbaa !12
  %1967 = shl i64 %1966, 16
  %1968 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %1969 = load i64, ptr %1968, align 16, !tbaa !12
  %1970 = lshr i64 %1969, 16
  %1971 = trunc i64 %1970 to i8
  %1972 = zext i8 %1971 to i64
  %1973 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1972
  %1974 = load i64, ptr %1973, align 8, !tbaa !12
  %1975 = lshr i64 %1974, 16
  %1976 = or i64 %1967, %1975
  %1977 = xor i64 %1959, %1976
  %1978 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %1979 = load i64, ptr %1978, align 8, !tbaa !12
  %1980 = lshr i64 %1979, 24
  %1981 = trunc i64 %1980 to i8
  %1982 = zext i8 %1981 to i64
  %1983 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1982
  %1984 = load i64, ptr %1983, align 8, !tbaa !12
  %1985 = shl i64 %1984, 24
  %1986 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %1987 = load i64, ptr %1986, align 8, !tbaa !12
  %1988 = lshr i64 %1987, 24
  %1989 = trunc i64 %1988 to i8
  %1990 = zext i8 %1989 to i64
  %1991 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1990
  %1992 = load i64, ptr %1991, align 8, !tbaa !12
  %1993 = lshr i64 %1992, 8
  %1994 = or i64 %1985, %1993
  %1995 = xor i64 %1977, %1994
  %1996 = xor i64 %1934, %1995
  %1997 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  store i64 %1996, ptr %1997, align 16, !tbaa !12
  %1998 = load ptr, ptr %10, align 8, !tbaa !5
  %1999 = getelementptr inbounds i64, ptr %1998, i64 12
  %2000 = getelementptr inbounds i64, ptr %1999, i64 1
  %2001 = load i64, ptr %2000, align 8, !tbaa !12
  %2002 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %2003 = load i64, ptr %2002, align 8, !tbaa !12
  %2004 = lshr i64 %2003, 0
  %2005 = trunc i64 %2004 to i8
  %2006 = zext i8 %2005 to i64
  %2007 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2006
  %2008 = load i64, ptr %2007, align 8, !tbaa !12
  %2009 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %2010 = load i64, ptr %2009, align 16, !tbaa !12
  %2011 = lshr i64 %2010, 8
  %2012 = trunc i64 %2011 to i8
  %2013 = zext i8 %2012 to i64
  %2014 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2013
  %2015 = load i64, ptr %2014, align 8, !tbaa !12
  %2016 = shl i64 %2015, 8
  %2017 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %2018 = load i64, ptr %2017, align 16, !tbaa !12
  %2019 = lshr i64 %2018, 8
  %2020 = trunc i64 %2019 to i8
  %2021 = zext i8 %2020 to i64
  %2022 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2021
  %2023 = load i64, ptr %2022, align 8, !tbaa !12
  %2024 = lshr i64 %2023, 24
  %2025 = or i64 %2016, %2024
  %2026 = xor i64 %2008, %2025
  %2027 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %2028 = load i64, ptr %2027, align 8, !tbaa !12
  %2029 = lshr i64 %2028, 16
  %2030 = trunc i64 %2029 to i8
  %2031 = zext i8 %2030 to i64
  %2032 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2031
  %2033 = load i64, ptr %2032, align 8, !tbaa !12
  %2034 = shl i64 %2033, 16
  %2035 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %2036 = load i64, ptr %2035, align 8, !tbaa !12
  %2037 = lshr i64 %2036, 16
  %2038 = trunc i64 %2037 to i8
  %2039 = zext i8 %2038 to i64
  %2040 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2039
  %2041 = load i64, ptr %2040, align 8, !tbaa !12
  %2042 = lshr i64 %2041, 16
  %2043 = or i64 %2034, %2042
  %2044 = xor i64 %2026, %2043
  %2045 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %2046 = load i64, ptr %2045, align 16, !tbaa !12
  %2047 = lshr i64 %2046, 24
  %2048 = trunc i64 %2047 to i8
  %2049 = zext i8 %2048 to i64
  %2050 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2049
  %2051 = load i64, ptr %2050, align 8, !tbaa !12
  %2052 = shl i64 %2051, 24
  %2053 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %2054 = load i64, ptr %2053, align 16, !tbaa !12
  %2055 = lshr i64 %2054, 24
  %2056 = trunc i64 %2055 to i8
  %2057 = zext i8 %2056 to i64
  %2058 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2057
  %2059 = load i64, ptr %2058, align 8, !tbaa !12
  %2060 = lshr i64 %2059, 8
  %2061 = or i64 %2052, %2060
  %2062 = xor i64 %2044, %2061
  %2063 = xor i64 %2001, %2062
  %2064 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  store i64 %2063, ptr %2064, align 8, !tbaa !12
  %2065 = load ptr, ptr %10, align 8, !tbaa !5
  %2066 = getelementptr inbounds i64, ptr %2065, i64 12
  %2067 = getelementptr inbounds i64, ptr %2066, i64 2
  %2068 = load i64, ptr %2067, align 8, !tbaa !12
  %2069 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %2070 = load i64, ptr %2069, align 16, !tbaa !12
  %2071 = lshr i64 %2070, 0
  %2072 = trunc i64 %2071 to i8
  %2073 = zext i8 %2072 to i64
  %2074 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2073
  %2075 = load i64, ptr %2074, align 8, !tbaa !12
  %2076 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %2077 = load i64, ptr %2076, align 8, !tbaa !12
  %2078 = lshr i64 %2077, 8
  %2079 = trunc i64 %2078 to i8
  %2080 = zext i8 %2079 to i64
  %2081 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2080
  %2082 = load i64, ptr %2081, align 8, !tbaa !12
  %2083 = shl i64 %2082, 8
  %2084 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %2085 = load i64, ptr %2084, align 8, !tbaa !12
  %2086 = lshr i64 %2085, 8
  %2087 = trunc i64 %2086 to i8
  %2088 = zext i8 %2087 to i64
  %2089 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2088
  %2090 = load i64, ptr %2089, align 8, !tbaa !12
  %2091 = lshr i64 %2090, 24
  %2092 = or i64 %2083, %2091
  %2093 = xor i64 %2075, %2092
  %2094 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %2095 = load i64, ptr %2094, align 16, !tbaa !12
  %2096 = lshr i64 %2095, 16
  %2097 = trunc i64 %2096 to i8
  %2098 = zext i8 %2097 to i64
  %2099 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2098
  %2100 = load i64, ptr %2099, align 8, !tbaa !12
  %2101 = shl i64 %2100, 16
  %2102 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %2103 = load i64, ptr %2102, align 16, !tbaa !12
  %2104 = lshr i64 %2103, 16
  %2105 = trunc i64 %2104 to i8
  %2106 = zext i8 %2105 to i64
  %2107 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2106
  %2108 = load i64, ptr %2107, align 8, !tbaa !12
  %2109 = lshr i64 %2108, 16
  %2110 = or i64 %2101, %2109
  %2111 = xor i64 %2093, %2110
  %2112 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %2113 = load i64, ptr %2112, align 8, !tbaa !12
  %2114 = lshr i64 %2113, 24
  %2115 = trunc i64 %2114 to i8
  %2116 = zext i8 %2115 to i64
  %2117 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2116
  %2118 = load i64, ptr %2117, align 8, !tbaa !12
  %2119 = shl i64 %2118, 24
  %2120 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %2121 = load i64, ptr %2120, align 8, !tbaa !12
  %2122 = lshr i64 %2121, 24
  %2123 = trunc i64 %2122 to i8
  %2124 = zext i8 %2123 to i64
  %2125 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2124
  %2126 = load i64, ptr %2125, align 8, !tbaa !12
  %2127 = lshr i64 %2126, 8
  %2128 = or i64 %2119, %2127
  %2129 = xor i64 %2111, %2128
  %2130 = xor i64 %2068, %2129
  %2131 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  store i64 %2130, ptr %2131, align 16, !tbaa !12
  %2132 = load ptr, ptr %10, align 8, !tbaa !5
  %2133 = getelementptr inbounds i64, ptr %2132, i64 12
  %2134 = getelementptr inbounds i64, ptr %2133, i64 3
  %2135 = load i64, ptr %2134, align 8, !tbaa !12
  %2136 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %2137 = load i64, ptr %2136, align 8, !tbaa !12
  %2138 = lshr i64 %2137, 0
  %2139 = trunc i64 %2138 to i8
  %2140 = zext i8 %2139 to i64
  %2141 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2140
  %2142 = load i64, ptr %2141, align 8, !tbaa !12
  %2143 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %2144 = load i64, ptr %2143, align 16, !tbaa !12
  %2145 = lshr i64 %2144, 8
  %2146 = trunc i64 %2145 to i8
  %2147 = zext i8 %2146 to i64
  %2148 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2147
  %2149 = load i64, ptr %2148, align 8, !tbaa !12
  %2150 = shl i64 %2149, 8
  %2151 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %2152 = load i64, ptr %2151, align 16, !tbaa !12
  %2153 = lshr i64 %2152, 8
  %2154 = trunc i64 %2153 to i8
  %2155 = zext i8 %2154 to i64
  %2156 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2155
  %2157 = load i64, ptr %2156, align 8, !tbaa !12
  %2158 = lshr i64 %2157, 24
  %2159 = or i64 %2150, %2158
  %2160 = xor i64 %2142, %2159
  %2161 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %2162 = load i64, ptr %2161, align 8, !tbaa !12
  %2163 = lshr i64 %2162, 16
  %2164 = trunc i64 %2163 to i8
  %2165 = zext i8 %2164 to i64
  %2166 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2165
  %2167 = load i64, ptr %2166, align 8, !tbaa !12
  %2168 = shl i64 %2167, 16
  %2169 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %2170 = load i64, ptr %2169, align 8, !tbaa !12
  %2171 = lshr i64 %2170, 16
  %2172 = trunc i64 %2171 to i8
  %2173 = zext i8 %2172 to i64
  %2174 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2173
  %2175 = load i64, ptr %2174, align 8, !tbaa !12
  %2176 = lshr i64 %2175, 16
  %2177 = or i64 %2168, %2176
  %2178 = xor i64 %2160, %2177
  %2179 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %2180 = load i64, ptr %2179, align 16, !tbaa !12
  %2181 = lshr i64 %2180, 24
  %2182 = trunc i64 %2181 to i8
  %2183 = zext i8 %2182 to i64
  %2184 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2183
  %2185 = load i64, ptr %2184, align 8, !tbaa !12
  %2186 = shl i64 %2185, 24
  %2187 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %2188 = load i64, ptr %2187, align 16, !tbaa !12
  %2189 = lshr i64 %2188, 24
  %2190 = trunc i64 %2189 to i8
  %2191 = zext i8 %2190 to i64
  %2192 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2191
  %2193 = load i64, ptr %2192, align 8, !tbaa !12
  %2194 = lshr i64 %2193, 8
  %2195 = or i64 %2186, %2194
  %2196 = xor i64 %2178, %2195
  %2197 = xor i64 %2135, %2196
  %2198 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  store i64 %2197, ptr %2198, align 8, !tbaa !12
  %2199 = load ptr, ptr %10, align 8, !tbaa !5
  %2200 = getelementptr inbounds i64, ptr %2199, i64 16
  %2201 = getelementptr inbounds i64, ptr %2200, i64 0
  %2202 = load i64, ptr %2201, align 8, !tbaa !12
  %2203 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %2204 = load i64, ptr %2203, align 16, !tbaa !12
  %2205 = lshr i64 %2204, 0
  %2206 = trunc i64 %2205 to i8
  %2207 = zext i8 %2206 to i64
  %2208 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2207
  %2209 = load i64, ptr %2208, align 8, !tbaa !12
  %2210 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %2211 = load i64, ptr %2210, align 8, !tbaa !12
  %2212 = lshr i64 %2211, 8
  %2213 = trunc i64 %2212 to i8
  %2214 = zext i8 %2213 to i64
  %2215 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2214
  %2216 = load i64, ptr %2215, align 8, !tbaa !12
  %2217 = shl i64 %2216, 8
  %2218 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %2219 = load i64, ptr %2218, align 8, !tbaa !12
  %2220 = lshr i64 %2219, 8
  %2221 = trunc i64 %2220 to i8
  %2222 = zext i8 %2221 to i64
  %2223 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2222
  %2224 = load i64, ptr %2223, align 8, !tbaa !12
  %2225 = lshr i64 %2224, 24
  %2226 = or i64 %2217, %2225
  %2227 = xor i64 %2209, %2226
  %2228 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %2229 = load i64, ptr %2228, align 16, !tbaa !12
  %2230 = lshr i64 %2229, 16
  %2231 = trunc i64 %2230 to i8
  %2232 = zext i8 %2231 to i64
  %2233 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2232
  %2234 = load i64, ptr %2233, align 8, !tbaa !12
  %2235 = shl i64 %2234, 16
  %2236 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %2237 = load i64, ptr %2236, align 16, !tbaa !12
  %2238 = lshr i64 %2237, 16
  %2239 = trunc i64 %2238 to i8
  %2240 = zext i8 %2239 to i64
  %2241 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2240
  %2242 = load i64, ptr %2241, align 8, !tbaa !12
  %2243 = lshr i64 %2242, 16
  %2244 = or i64 %2235, %2243
  %2245 = xor i64 %2227, %2244
  %2246 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %2247 = load i64, ptr %2246, align 8, !tbaa !12
  %2248 = lshr i64 %2247, 24
  %2249 = trunc i64 %2248 to i8
  %2250 = zext i8 %2249 to i64
  %2251 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2250
  %2252 = load i64, ptr %2251, align 8, !tbaa !12
  %2253 = shl i64 %2252, 24
  %2254 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %2255 = load i64, ptr %2254, align 8, !tbaa !12
  %2256 = lshr i64 %2255, 24
  %2257 = trunc i64 %2256 to i8
  %2258 = zext i8 %2257 to i64
  %2259 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2258
  %2260 = load i64, ptr %2259, align 8, !tbaa !12
  %2261 = lshr i64 %2260, 8
  %2262 = or i64 %2253, %2261
  %2263 = xor i64 %2245, %2262
  %2264 = xor i64 %2202, %2263
  %2265 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  store i64 %2264, ptr %2265, align 16, !tbaa !12
  %2266 = load ptr, ptr %10, align 8, !tbaa !5
  %2267 = getelementptr inbounds i64, ptr %2266, i64 16
  %2268 = getelementptr inbounds i64, ptr %2267, i64 1
  %2269 = load i64, ptr %2268, align 8, !tbaa !12
  %2270 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %2271 = load i64, ptr %2270, align 8, !tbaa !12
  %2272 = lshr i64 %2271, 0
  %2273 = trunc i64 %2272 to i8
  %2274 = zext i8 %2273 to i64
  %2275 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2274
  %2276 = load i64, ptr %2275, align 8, !tbaa !12
  %2277 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %2278 = load i64, ptr %2277, align 16, !tbaa !12
  %2279 = lshr i64 %2278, 8
  %2280 = trunc i64 %2279 to i8
  %2281 = zext i8 %2280 to i64
  %2282 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2281
  %2283 = load i64, ptr %2282, align 8, !tbaa !12
  %2284 = shl i64 %2283, 8
  %2285 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %2286 = load i64, ptr %2285, align 16, !tbaa !12
  %2287 = lshr i64 %2286, 8
  %2288 = trunc i64 %2287 to i8
  %2289 = zext i8 %2288 to i64
  %2290 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2289
  %2291 = load i64, ptr %2290, align 8, !tbaa !12
  %2292 = lshr i64 %2291, 24
  %2293 = or i64 %2284, %2292
  %2294 = xor i64 %2276, %2293
  %2295 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %2296 = load i64, ptr %2295, align 8, !tbaa !12
  %2297 = lshr i64 %2296, 16
  %2298 = trunc i64 %2297 to i8
  %2299 = zext i8 %2298 to i64
  %2300 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2299
  %2301 = load i64, ptr %2300, align 8, !tbaa !12
  %2302 = shl i64 %2301, 16
  %2303 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %2304 = load i64, ptr %2303, align 8, !tbaa !12
  %2305 = lshr i64 %2304, 16
  %2306 = trunc i64 %2305 to i8
  %2307 = zext i8 %2306 to i64
  %2308 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2307
  %2309 = load i64, ptr %2308, align 8, !tbaa !12
  %2310 = lshr i64 %2309, 16
  %2311 = or i64 %2302, %2310
  %2312 = xor i64 %2294, %2311
  %2313 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %2314 = load i64, ptr %2313, align 16, !tbaa !12
  %2315 = lshr i64 %2314, 24
  %2316 = trunc i64 %2315 to i8
  %2317 = zext i8 %2316 to i64
  %2318 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2317
  %2319 = load i64, ptr %2318, align 8, !tbaa !12
  %2320 = shl i64 %2319, 24
  %2321 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %2322 = load i64, ptr %2321, align 16, !tbaa !12
  %2323 = lshr i64 %2322, 24
  %2324 = trunc i64 %2323 to i8
  %2325 = zext i8 %2324 to i64
  %2326 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2325
  %2327 = load i64, ptr %2326, align 8, !tbaa !12
  %2328 = lshr i64 %2327, 8
  %2329 = or i64 %2320, %2328
  %2330 = xor i64 %2312, %2329
  %2331 = xor i64 %2269, %2330
  %2332 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  store i64 %2331, ptr %2332, align 8, !tbaa !12
  %2333 = load ptr, ptr %10, align 8, !tbaa !5
  %2334 = getelementptr inbounds i64, ptr %2333, i64 16
  %2335 = getelementptr inbounds i64, ptr %2334, i64 2
  %2336 = load i64, ptr %2335, align 8, !tbaa !12
  %2337 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %2338 = load i64, ptr %2337, align 16, !tbaa !12
  %2339 = lshr i64 %2338, 0
  %2340 = trunc i64 %2339 to i8
  %2341 = zext i8 %2340 to i64
  %2342 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2341
  %2343 = load i64, ptr %2342, align 8, !tbaa !12
  %2344 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %2345 = load i64, ptr %2344, align 8, !tbaa !12
  %2346 = lshr i64 %2345, 8
  %2347 = trunc i64 %2346 to i8
  %2348 = zext i8 %2347 to i64
  %2349 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2348
  %2350 = load i64, ptr %2349, align 8, !tbaa !12
  %2351 = shl i64 %2350, 8
  %2352 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %2353 = load i64, ptr %2352, align 8, !tbaa !12
  %2354 = lshr i64 %2353, 8
  %2355 = trunc i64 %2354 to i8
  %2356 = zext i8 %2355 to i64
  %2357 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2356
  %2358 = load i64, ptr %2357, align 8, !tbaa !12
  %2359 = lshr i64 %2358, 24
  %2360 = or i64 %2351, %2359
  %2361 = xor i64 %2343, %2360
  %2362 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %2363 = load i64, ptr %2362, align 16, !tbaa !12
  %2364 = lshr i64 %2363, 16
  %2365 = trunc i64 %2364 to i8
  %2366 = zext i8 %2365 to i64
  %2367 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2366
  %2368 = load i64, ptr %2367, align 8, !tbaa !12
  %2369 = shl i64 %2368, 16
  %2370 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %2371 = load i64, ptr %2370, align 16, !tbaa !12
  %2372 = lshr i64 %2371, 16
  %2373 = trunc i64 %2372 to i8
  %2374 = zext i8 %2373 to i64
  %2375 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2374
  %2376 = load i64, ptr %2375, align 8, !tbaa !12
  %2377 = lshr i64 %2376, 16
  %2378 = or i64 %2369, %2377
  %2379 = xor i64 %2361, %2378
  %2380 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %2381 = load i64, ptr %2380, align 8, !tbaa !12
  %2382 = lshr i64 %2381, 24
  %2383 = trunc i64 %2382 to i8
  %2384 = zext i8 %2383 to i64
  %2385 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2384
  %2386 = load i64, ptr %2385, align 8, !tbaa !12
  %2387 = shl i64 %2386, 24
  %2388 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %2389 = load i64, ptr %2388, align 8, !tbaa !12
  %2390 = lshr i64 %2389, 24
  %2391 = trunc i64 %2390 to i8
  %2392 = zext i8 %2391 to i64
  %2393 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2392
  %2394 = load i64, ptr %2393, align 8, !tbaa !12
  %2395 = lshr i64 %2394, 8
  %2396 = or i64 %2387, %2395
  %2397 = xor i64 %2379, %2396
  %2398 = xor i64 %2336, %2397
  %2399 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  store i64 %2398, ptr %2399, align 16, !tbaa !12
  %2400 = load ptr, ptr %10, align 8, !tbaa !5
  %2401 = getelementptr inbounds i64, ptr %2400, i64 16
  %2402 = getelementptr inbounds i64, ptr %2401, i64 3
  %2403 = load i64, ptr %2402, align 8, !tbaa !12
  %2404 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %2405 = load i64, ptr %2404, align 8, !tbaa !12
  %2406 = lshr i64 %2405, 0
  %2407 = trunc i64 %2406 to i8
  %2408 = zext i8 %2407 to i64
  %2409 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2408
  %2410 = load i64, ptr %2409, align 8, !tbaa !12
  %2411 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %2412 = load i64, ptr %2411, align 16, !tbaa !12
  %2413 = lshr i64 %2412, 8
  %2414 = trunc i64 %2413 to i8
  %2415 = zext i8 %2414 to i64
  %2416 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2415
  %2417 = load i64, ptr %2416, align 8, !tbaa !12
  %2418 = shl i64 %2417, 8
  %2419 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %2420 = load i64, ptr %2419, align 16, !tbaa !12
  %2421 = lshr i64 %2420, 8
  %2422 = trunc i64 %2421 to i8
  %2423 = zext i8 %2422 to i64
  %2424 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2423
  %2425 = load i64, ptr %2424, align 8, !tbaa !12
  %2426 = lshr i64 %2425, 24
  %2427 = or i64 %2418, %2426
  %2428 = xor i64 %2410, %2427
  %2429 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %2430 = load i64, ptr %2429, align 8, !tbaa !12
  %2431 = lshr i64 %2430, 16
  %2432 = trunc i64 %2431 to i8
  %2433 = zext i8 %2432 to i64
  %2434 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2433
  %2435 = load i64, ptr %2434, align 8, !tbaa !12
  %2436 = shl i64 %2435, 16
  %2437 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %2438 = load i64, ptr %2437, align 8, !tbaa !12
  %2439 = lshr i64 %2438, 16
  %2440 = trunc i64 %2439 to i8
  %2441 = zext i8 %2440 to i64
  %2442 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2441
  %2443 = load i64, ptr %2442, align 8, !tbaa !12
  %2444 = lshr i64 %2443, 16
  %2445 = or i64 %2436, %2444
  %2446 = xor i64 %2428, %2445
  %2447 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %2448 = load i64, ptr %2447, align 16, !tbaa !12
  %2449 = lshr i64 %2448, 24
  %2450 = trunc i64 %2449 to i8
  %2451 = zext i8 %2450 to i64
  %2452 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2451
  %2453 = load i64, ptr %2452, align 8, !tbaa !12
  %2454 = shl i64 %2453, 24
  %2455 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %2456 = load i64, ptr %2455, align 16, !tbaa !12
  %2457 = lshr i64 %2456, 24
  %2458 = trunc i64 %2457 to i8
  %2459 = zext i8 %2458 to i64
  %2460 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2459
  %2461 = load i64, ptr %2460, align 8, !tbaa !12
  %2462 = lshr i64 %2461, 8
  %2463 = or i64 %2454, %2462
  %2464 = xor i64 %2446, %2463
  %2465 = xor i64 %2403, %2464
  %2466 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  store i64 %2465, ptr %2466, align 8, !tbaa !12
  %2467 = load ptr, ptr %10, align 8, !tbaa !5
  %2468 = getelementptr inbounds i64, ptr %2467, i64 20
  %2469 = getelementptr inbounds i64, ptr %2468, i64 0
  %2470 = load i64, ptr %2469, align 8, !tbaa !12
  %2471 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %2472 = load i64, ptr %2471, align 16, !tbaa !12
  %2473 = lshr i64 %2472, 0
  %2474 = trunc i64 %2473 to i8
  %2475 = zext i8 %2474 to i64
  %2476 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2475
  %2477 = load i64, ptr %2476, align 8, !tbaa !12
  %2478 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %2479 = load i64, ptr %2478, align 8, !tbaa !12
  %2480 = lshr i64 %2479, 8
  %2481 = trunc i64 %2480 to i8
  %2482 = zext i8 %2481 to i64
  %2483 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2482
  %2484 = load i64, ptr %2483, align 8, !tbaa !12
  %2485 = shl i64 %2484, 8
  %2486 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %2487 = load i64, ptr %2486, align 8, !tbaa !12
  %2488 = lshr i64 %2487, 8
  %2489 = trunc i64 %2488 to i8
  %2490 = zext i8 %2489 to i64
  %2491 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2490
  %2492 = load i64, ptr %2491, align 8, !tbaa !12
  %2493 = lshr i64 %2492, 24
  %2494 = or i64 %2485, %2493
  %2495 = xor i64 %2477, %2494
  %2496 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %2497 = load i64, ptr %2496, align 16, !tbaa !12
  %2498 = lshr i64 %2497, 16
  %2499 = trunc i64 %2498 to i8
  %2500 = zext i8 %2499 to i64
  %2501 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2500
  %2502 = load i64, ptr %2501, align 8, !tbaa !12
  %2503 = shl i64 %2502, 16
  %2504 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %2505 = load i64, ptr %2504, align 16, !tbaa !12
  %2506 = lshr i64 %2505, 16
  %2507 = trunc i64 %2506 to i8
  %2508 = zext i8 %2507 to i64
  %2509 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2508
  %2510 = load i64, ptr %2509, align 8, !tbaa !12
  %2511 = lshr i64 %2510, 16
  %2512 = or i64 %2503, %2511
  %2513 = xor i64 %2495, %2512
  %2514 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %2515 = load i64, ptr %2514, align 8, !tbaa !12
  %2516 = lshr i64 %2515, 24
  %2517 = trunc i64 %2516 to i8
  %2518 = zext i8 %2517 to i64
  %2519 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2518
  %2520 = load i64, ptr %2519, align 8, !tbaa !12
  %2521 = shl i64 %2520, 24
  %2522 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %2523 = load i64, ptr %2522, align 8, !tbaa !12
  %2524 = lshr i64 %2523, 24
  %2525 = trunc i64 %2524 to i8
  %2526 = zext i8 %2525 to i64
  %2527 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2526
  %2528 = load i64, ptr %2527, align 8, !tbaa !12
  %2529 = lshr i64 %2528, 8
  %2530 = or i64 %2521, %2529
  %2531 = xor i64 %2513, %2530
  %2532 = xor i64 %2470, %2531
  %2533 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  store i64 %2532, ptr %2533, align 16, !tbaa !12
  %2534 = load ptr, ptr %10, align 8, !tbaa !5
  %2535 = getelementptr inbounds i64, ptr %2534, i64 20
  %2536 = getelementptr inbounds i64, ptr %2535, i64 1
  %2537 = load i64, ptr %2536, align 8, !tbaa !12
  %2538 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %2539 = load i64, ptr %2538, align 8, !tbaa !12
  %2540 = lshr i64 %2539, 0
  %2541 = trunc i64 %2540 to i8
  %2542 = zext i8 %2541 to i64
  %2543 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2542
  %2544 = load i64, ptr %2543, align 8, !tbaa !12
  %2545 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %2546 = load i64, ptr %2545, align 16, !tbaa !12
  %2547 = lshr i64 %2546, 8
  %2548 = trunc i64 %2547 to i8
  %2549 = zext i8 %2548 to i64
  %2550 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2549
  %2551 = load i64, ptr %2550, align 8, !tbaa !12
  %2552 = shl i64 %2551, 8
  %2553 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %2554 = load i64, ptr %2553, align 16, !tbaa !12
  %2555 = lshr i64 %2554, 8
  %2556 = trunc i64 %2555 to i8
  %2557 = zext i8 %2556 to i64
  %2558 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2557
  %2559 = load i64, ptr %2558, align 8, !tbaa !12
  %2560 = lshr i64 %2559, 24
  %2561 = or i64 %2552, %2560
  %2562 = xor i64 %2544, %2561
  %2563 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %2564 = load i64, ptr %2563, align 8, !tbaa !12
  %2565 = lshr i64 %2564, 16
  %2566 = trunc i64 %2565 to i8
  %2567 = zext i8 %2566 to i64
  %2568 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2567
  %2569 = load i64, ptr %2568, align 8, !tbaa !12
  %2570 = shl i64 %2569, 16
  %2571 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %2572 = load i64, ptr %2571, align 8, !tbaa !12
  %2573 = lshr i64 %2572, 16
  %2574 = trunc i64 %2573 to i8
  %2575 = zext i8 %2574 to i64
  %2576 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2575
  %2577 = load i64, ptr %2576, align 8, !tbaa !12
  %2578 = lshr i64 %2577, 16
  %2579 = or i64 %2570, %2578
  %2580 = xor i64 %2562, %2579
  %2581 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %2582 = load i64, ptr %2581, align 16, !tbaa !12
  %2583 = lshr i64 %2582, 24
  %2584 = trunc i64 %2583 to i8
  %2585 = zext i8 %2584 to i64
  %2586 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2585
  %2587 = load i64, ptr %2586, align 8, !tbaa !12
  %2588 = shl i64 %2587, 24
  %2589 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %2590 = load i64, ptr %2589, align 16, !tbaa !12
  %2591 = lshr i64 %2590, 24
  %2592 = trunc i64 %2591 to i8
  %2593 = zext i8 %2592 to i64
  %2594 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2593
  %2595 = load i64, ptr %2594, align 8, !tbaa !12
  %2596 = lshr i64 %2595, 8
  %2597 = or i64 %2588, %2596
  %2598 = xor i64 %2580, %2597
  %2599 = xor i64 %2537, %2598
  %2600 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  store i64 %2599, ptr %2600, align 8, !tbaa !12
  %2601 = load ptr, ptr %10, align 8, !tbaa !5
  %2602 = getelementptr inbounds i64, ptr %2601, i64 20
  %2603 = getelementptr inbounds i64, ptr %2602, i64 2
  %2604 = load i64, ptr %2603, align 8, !tbaa !12
  %2605 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %2606 = load i64, ptr %2605, align 16, !tbaa !12
  %2607 = lshr i64 %2606, 0
  %2608 = trunc i64 %2607 to i8
  %2609 = zext i8 %2608 to i64
  %2610 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2609
  %2611 = load i64, ptr %2610, align 8, !tbaa !12
  %2612 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %2613 = load i64, ptr %2612, align 8, !tbaa !12
  %2614 = lshr i64 %2613, 8
  %2615 = trunc i64 %2614 to i8
  %2616 = zext i8 %2615 to i64
  %2617 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2616
  %2618 = load i64, ptr %2617, align 8, !tbaa !12
  %2619 = shl i64 %2618, 8
  %2620 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %2621 = load i64, ptr %2620, align 8, !tbaa !12
  %2622 = lshr i64 %2621, 8
  %2623 = trunc i64 %2622 to i8
  %2624 = zext i8 %2623 to i64
  %2625 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2624
  %2626 = load i64, ptr %2625, align 8, !tbaa !12
  %2627 = lshr i64 %2626, 24
  %2628 = or i64 %2619, %2627
  %2629 = xor i64 %2611, %2628
  %2630 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %2631 = load i64, ptr %2630, align 16, !tbaa !12
  %2632 = lshr i64 %2631, 16
  %2633 = trunc i64 %2632 to i8
  %2634 = zext i8 %2633 to i64
  %2635 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2634
  %2636 = load i64, ptr %2635, align 8, !tbaa !12
  %2637 = shl i64 %2636, 16
  %2638 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %2639 = load i64, ptr %2638, align 16, !tbaa !12
  %2640 = lshr i64 %2639, 16
  %2641 = trunc i64 %2640 to i8
  %2642 = zext i8 %2641 to i64
  %2643 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2642
  %2644 = load i64, ptr %2643, align 8, !tbaa !12
  %2645 = lshr i64 %2644, 16
  %2646 = or i64 %2637, %2645
  %2647 = xor i64 %2629, %2646
  %2648 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %2649 = load i64, ptr %2648, align 8, !tbaa !12
  %2650 = lshr i64 %2649, 24
  %2651 = trunc i64 %2650 to i8
  %2652 = zext i8 %2651 to i64
  %2653 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2652
  %2654 = load i64, ptr %2653, align 8, !tbaa !12
  %2655 = shl i64 %2654, 24
  %2656 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %2657 = load i64, ptr %2656, align 8, !tbaa !12
  %2658 = lshr i64 %2657, 24
  %2659 = trunc i64 %2658 to i8
  %2660 = zext i8 %2659 to i64
  %2661 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2660
  %2662 = load i64, ptr %2661, align 8, !tbaa !12
  %2663 = lshr i64 %2662, 8
  %2664 = or i64 %2655, %2663
  %2665 = xor i64 %2647, %2664
  %2666 = xor i64 %2604, %2665
  %2667 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  store i64 %2666, ptr %2667, align 16, !tbaa !12
  %2668 = load ptr, ptr %10, align 8, !tbaa !5
  %2669 = getelementptr inbounds i64, ptr %2668, i64 20
  %2670 = getelementptr inbounds i64, ptr %2669, i64 3
  %2671 = load i64, ptr %2670, align 8, !tbaa !12
  %2672 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %2673 = load i64, ptr %2672, align 8, !tbaa !12
  %2674 = lshr i64 %2673, 0
  %2675 = trunc i64 %2674 to i8
  %2676 = zext i8 %2675 to i64
  %2677 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2676
  %2678 = load i64, ptr %2677, align 8, !tbaa !12
  %2679 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %2680 = load i64, ptr %2679, align 16, !tbaa !12
  %2681 = lshr i64 %2680, 8
  %2682 = trunc i64 %2681 to i8
  %2683 = zext i8 %2682 to i64
  %2684 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2683
  %2685 = load i64, ptr %2684, align 8, !tbaa !12
  %2686 = shl i64 %2685, 8
  %2687 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %2688 = load i64, ptr %2687, align 16, !tbaa !12
  %2689 = lshr i64 %2688, 8
  %2690 = trunc i64 %2689 to i8
  %2691 = zext i8 %2690 to i64
  %2692 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2691
  %2693 = load i64, ptr %2692, align 8, !tbaa !12
  %2694 = lshr i64 %2693, 24
  %2695 = or i64 %2686, %2694
  %2696 = xor i64 %2678, %2695
  %2697 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %2698 = load i64, ptr %2697, align 8, !tbaa !12
  %2699 = lshr i64 %2698, 16
  %2700 = trunc i64 %2699 to i8
  %2701 = zext i8 %2700 to i64
  %2702 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2701
  %2703 = load i64, ptr %2702, align 8, !tbaa !12
  %2704 = shl i64 %2703, 16
  %2705 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %2706 = load i64, ptr %2705, align 8, !tbaa !12
  %2707 = lshr i64 %2706, 16
  %2708 = trunc i64 %2707 to i8
  %2709 = zext i8 %2708 to i64
  %2710 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2709
  %2711 = load i64, ptr %2710, align 8, !tbaa !12
  %2712 = lshr i64 %2711, 16
  %2713 = or i64 %2704, %2712
  %2714 = xor i64 %2696, %2713
  %2715 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %2716 = load i64, ptr %2715, align 16, !tbaa !12
  %2717 = lshr i64 %2716, 24
  %2718 = trunc i64 %2717 to i8
  %2719 = zext i8 %2718 to i64
  %2720 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2719
  %2721 = load i64, ptr %2720, align 8, !tbaa !12
  %2722 = shl i64 %2721, 24
  %2723 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %2724 = load i64, ptr %2723, align 16, !tbaa !12
  %2725 = lshr i64 %2724, 24
  %2726 = trunc i64 %2725 to i8
  %2727 = zext i8 %2726 to i64
  %2728 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2727
  %2729 = load i64, ptr %2728, align 8, !tbaa !12
  %2730 = lshr i64 %2729, 8
  %2731 = or i64 %2722, %2730
  %2732 = xor i64 %2714, %2731
  %2733 = xor i64 %2671, %2732
  %2734 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  store i64 %2733, ptr %2734, align 8, !tbaa !12
  %2735 = load ptr, ptr %10, align 8, !tbaa !5
  %2736 = getelementptr inbounds i64, ptr %2735, i64 24
  %2737 = getelementptr inbounds i64, ptr %2736, i64 0
  %2738 = load i64, ptr %2737, align 8, !tbaa !12
  %2739 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %2740 = load i64, ptr %2739, align 16, !tbaa !12
  %2741 = lshr i64 %2740, 0
  %2742 = trunc i64 %2741 to i8
  %2743 = zext i8 %2742 to i64
  %2744 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2743
  %2745 = load i64, ptr %2744, align 8, !tbaa !12
  %2746 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %2747 = load i64, ptr %2746, align 8, !tbaa !12
  %2748 = lshr i64 %2747, 8
  %2749 = trunc i64 %2748 to i8
  %2750 = zext i8 %2749 to i64
  %2751 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2750
  %2752 = load i64, ptr %2751, align 8, !tbaa !12
  %2753 = shl i64 %2752, 8
  %2754 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %2755 = load i64, ptr %2754, align 8, !tbaa !12
  %2756 = lshr i64 %2755, 8
  %2757 = trunc i64 %2756 to i8
  %2758 = zext i8 %2757 to i64
  %2759 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2758
  %2760 = load i64, ptr %2759, align 8, !tbaa !12
  %2761 = lshr i64 %2760, 24
  %2762 = or i64 %2753, %2761
  %2763 = xor i64 %2745, %2762
  %2764 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %2765 = load i64, ptr %2764, align 16, !tbaa !12
  %2766 = lshr i64 %2765, 16
  %2767 = trunc i64 %2766 to i8
  %2768 = zext i8 %2767 to i64
  %2769 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2768
  %2770 = load i64, ptr %2769, align 8, !tbaa !12
  %2771 = shl i64 %2770, 16
  %2772 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %2773 = load i64, ptr %2772, align 16, !tbaa !12
  %2774 = lshr i64 %2773, 16
  %2775 = trunc i64 %2774 to i8
  %2776 = zext i8 %2775 to i64
  %2777 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2776
  %2778 = load i64, ptr %2777, align 8, !tbaa !12
  %2779 = lshr i64 %2778, 16
  %2780 = or i64 %2771, %2779
  %2781 = xor i64 %2763, %2780
  %2782 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %2783 = load i64, ptr %2782, align 8, !tbaa !12
  %2784 = lshr i64 %2783, 24
  %2785 = trunc i64 %2784 to i8
  %2786 = zext i8 %2785 to i64
  %2787 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2786
  %2788 = load i64, ptr %2787, align 8, !tbaa !12
  %2789 = shl i64 %2788, 24
  %2790 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %2791 = load i64, ptr %2790, align 8, !tbaa !12
  %2792 = lshr i64 %2791, 24
  %2793 = trunc i64 %2792 to i8
  %2794 = zext i8 %2793 to i64
  %2795 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2794
  %2796 = load i64, ptr %2795, align 8, !tbaa !12
  %2797 = lshr i64 %2796, 8
  %2798 = or i64 %2789, %2797
  %2799 = xor i64 %2781, %2798
  %2800 = xor i64 %2738, %2799
  %2801 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  store i64 %2800, ptr %2801, align 16, !tbaa !12
  %2802 = load ptr, ptr %10, align 8, !tbaa !5
  %2803 = getelementptr inbounds i64, ptr %2802, i64 24
  %2804 = getelementptr inbounds i64, ptr %2803, i64 1
  %2805 = load i64, ptr %2804, align 8, !tbaa !12
  %2806 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %2807 = load i64, ptr %2806, align 8, !tbaa !12
  %2808 = lshr i64 %2807, 0
  %2809 = trunc i64 %2808 to i8
  %2810 = zext i8 %2809 to i64
  %2811 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2810
  %2812 = load i64, ptr %2811, align 8, !tbaa !12
  %2813 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %2814 = load i64, ptr %2813, align 16, !tbaa !12
  %2815 = lshr i64 %2814, 8
  %2816 = trunc i64 %2815 to i8
  %2817 = zext i8 %2816 to i64
  %2818 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2817
  %2819 = load i64, ptr %2818, align 8, !tbaa !12
  %2820 = shl i64 %2819, 8
  %2821 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %2822 = load i64, ptr %2821, align 16, !tbaa !12
  %2823 = lshr i64 %2822, 8
  %2824 = trunc i64 %2823 to i8
  %2825 = zext i8 %2824 to i64
  %2826 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2825
  %2827 = load i64, ptr %2826, align 8, !tbaa !12
  %2828 = lshr i64 %2827, 24
  %2829 = or i64 %2820, %2828
  %2830 = xor i64 %2812, %2829
  %2831 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %2832 = load i64, ptr %2831, align 8, !tbaa !12
  %2833 = lshr i64 %2832, 16
  %2834 = trunc i64 %2833 to i8
  %2835 = zext i8 %2834 to i64
  %2836 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2835
  %2837 = load i64, ptr %2836, align 8, !tbaa !12
  %2838 = shl i64 %2837, 16
  %2839 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %2840 = load i64, ptr %2839, align 8, !tbaa !12
  %2841 = lshr i64 %2840, 16
  %2842 = trunc i64 %2841 to i8
  %2843 = zext i8 %2842 to i64
  %2844 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2843
  %2845 = load i64, ptr %2844, align 8, !tbaa !12
  %2846 = lshr i64 %2845, 16
  %2847 = or i64 %2838, %2846
  %2848 = xor i64 %2830, %2847
  %2849 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %2850 = load i64, ptr %2849, align 16, !tbaa !12
  %2851 = lshr i64 %2850, 24
  %2852 = trunc i64 %2851 to i8
  %2853 = zext i8 %2852 to i64
  %2854 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2853
  %2855 = load i64, ptr %2854, align 8, !tbaa !12
  %2856 = shl i64 %2855, 24
  %2857 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %2858 = load i64, ptr %2857, align 16, !tbaa !12
  %2859 = lshr i64 %2858, 24
  %2860 = trunc i64 %2859 to i8
  %2861 = zext i8 %2860 to i64
  %2862 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2861
  %2863 = load i64, ptr %2862, align 8, !tbaa !12
  %2864 = lshr i64 %2863, 8
  %2865 = or i64 %2856, %2864
  %2866 = xor i64 %2848, %2865
  %2867 = xor i64 %2805, %2866
  %2868 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  store i64 %2867, ptr %2868, align 8, !tbaa !12
  %2869 = load ptr, ptr %10, align 8, !tbaa !5
  %2870 = getelementptr inbounds i64, ptr %2869, i64 24
  %2871 = getelementptr inbounds i64, ptr %2870, i64 2
  %2872 = load i64, ptr %2871, align 8, !tbaa !12
  %2873 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %2874 = load i64, ptr %2873, align 16, !tbaa !12
  %2875 = lshr i64 %2874, 0
  %2876 = trunc i64 %2875 to i8
  %2877 = zext i8 %2876 to i64
  %2878 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2877
  %2879 = load i64, ptr %2878, align 8, !tbaa !12
  %2880 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %2881 = load i64, ptr %2880, align 8, !tbaa !12
  %2882 = lshr i64 %2881, 8
  %2883 = trunc i64 %2882 to i8
  %2884 = zext i8 %2883 to i64
  %2885 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2884
  %2886 = load i64, ptr %2885, align 8, !tbaa !12
  %2887 = shl i64 %2886, 8
  %2888 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %2889 = load i64, ptr %2888, align 8, !tbaa !12
  %2890 = lshr i64 %2889, 8
  %2891 = trunc i64 %2890 to i8
  %2892 = zext i8 %2891 to i64
  %2893 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2892
  %2894 = load i64, ptr %2893, align 8, !tbaa !12
  %2895 = lshr i64 %2894, 24
  %2896 = or i64 %2887, %2895
  %2897 = xor i64 %2879, %2896
  %2898 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %2899 = load i64, ptr %2898, align 16, !tbaa !12
  %2900 = lshr i64 %2899, 16
  %2901 = trunc i64 %2900 to i8
  %2902 = zext i8 %2901 to i64
  %2903 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2902
  %2904 = load i64, ptr %2903, align 8, !tbaa !12
  %2905 = shl i64 %2904, 16
  %2906 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %2907 = load i64, ptr %2906, align 16, !tbaa !12
  %2908 = lshr i64 %2907, 16
  %2909 = trunc i64 %2908 to i8
  %2910 = zext i8 %2909 to i64
  %2911 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2910
  %2912 = load i64, ptr %2911, align 8, !tbaa !12
  %2913 = lshr i64 %2912, 16
  %2914 = or i64 %2905, %2913
  %2915 = xor i64 %2897, %2914
  %2916 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %2917 = load i64, ptr %2916, align 8, !tbaa !12
  %2918 = lshr i64 %2917, 24
  %2919 = trunc i64 %2918 to i8
  %2920 = zext i8 %2919 to i64
  %2921 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2920
  %2922 = load i64, ptr %2921, align 8, !tbaa !12
  %2923 = shl i64 %2922, 24
  %2924 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %2925 = load i64, ptr %2924, align 8, !tbaa !12
  %2926 = lshr i64 %2925, 24
  %2927 = trunc i64 %2926 to i8
  %2928 = zext i8 %2927 to i64
  %2929 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2928
  %2930 = load i64, ptr %2929, align 8, !tbaa !12
  %2931 = lshr i64 %2930, 8
  %2932 = or i64 %2923, %2931
  %2933 = xor i64 %2915, %2932
  %2934 = xor i64 %2872, %2933
  %2935 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  store i64 %2934, ptr %2935, align 16, !tbaa !12
  %2936 = load ptr, ptr %10, align 8, !tbaa !5
  %2937 = getelementptr inbounds i64, ptr %2936, i64 24
  %2938 = getelementptr inbounds i64, ptr %2937, i64 3
  %2939 = load i64, ptr %2938, align 8, !tbaa !12
  %2940 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %2941 = load i64, ptr %2940, align 8, !tbaa !12
  %2942 = lshr i64 %2941, 0
  %2943 = trunc i64 %2942 to i8
  %2944 = zext i8 %2943 to i64
  %2945 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2944
  %2946 = load i64, ptr %2945, align 8, !tbaa !12
  %2947 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %2948 = load i64, ptr %2947, align 16, !tbaa !12
  %2949 = lshr i64 %2948, 8
  %2950 = trunc i64 %2949 to i8
  %2951 = zext i8 %2950 to i64
  %2952 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2951
  %2953 = load i64, ptr %2952, align 8, !tbaa !12
  %2954 = shl i64 %2953, 8
  %2955 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %2956 = load i64, ptr %2955, align 16, !tbaa !12
  %2957 = lshr i64 %2956, 8
  %2958 = trunc i64 %2957 to i8
  %2959 = zext i8 %2958 to i64
  %2960 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2959
  %2961 = load i64, ptr %2960, align 8, !tbaa !12
  %2962 = lshr i64 %2961, 24
  %2963 = or i64 %2954, %2962
  %2964 = xor i64 %2946, %2963
  %2965 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %2966 = load i64, ptr %2965, align 8, !tbaa !12
  %2967 = lshr i64 %2966, 16
  %2968 = trunc i64 %2967 to i8
  %2969 = zext i8 %2968 to i64
  %2970 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2969
  %2971 = load i64, ptr %2970, align 8, !tbaa !12
  %2972 = shl i64 %2971, 16
  %2973 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %2974 = load i64, ptr %2973, align 8, !tbaa !12
  %2975 = lshr i64 %2974, 16
  %2976 = trunc i64 %2975 to i8
  %2977 = zext i8 %2976 to i64
  %2978 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2977
  %2979 = load i64, ptr %2978, align 8, !tbaa !12
  %2980 = lshr i64 %2979, 16
  %2981 = or i64 %2972, %2980
  %2982 = xor i64 %2964, %2981
  %2983 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %2984 = load i64, ptr %2983, align 16, !tbaa !12
  %2985 = lshr i64 %2984, 24
  %2986 = trunc i64 %2985 to i8
  %2987 = zext i8 %2986 to i64
  %2988 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2987
  %2989 = load i64, ptr %2988, align 8, !tbaa !12
  %2990 = shl i64 %2989, 24
  %2991 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %2992 = load i64, ptr %2991, align 16, !tbaa !12
  %2993 = lshr i64 %2992, 24
  %2994 = trunc i64 %2993 to i8
  %2995 = zext i8 %2994 to i64
  %2996 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %2995
  %2997 = load i64, ptr %2996, align 8, !tbaa !12
  %2998 = lshr i64 %2997, 8
  %2999 = or i64 %2990, %2998
  %3000 = xor i64 %2982, %2999
  %3001 = xor i64 %2939, %3000
  %3002 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  store i64 %3001, ptr %3002, align 8, !tbaa !12
  %3003 = load ptr, ptr %10, align 8, !tbaa !5
  %3004 = getelementptr inbounds i64, ptr %3003, i64 28
  %3005 = getelementptr inbounds i64, ptr %3004, i64 0
  %3006 = load i64, ptr %3005, align 8, !tbaa !12
  %3007 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %3008 = load i64, ptr %3007, align 16, !tbaa !12
  %3009 = lshr i64 %3008, 0
  %3010 = trunc i64 %3009 to i8
  %3011 = zext i8 %3010 to i64
  %3012 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3011
  %3013 = load i64, ptr %3012, align 8, !tbaa !12
  %3014 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %3015 = load i64, ptr %3014, align 8, !tbaa !12
  %3016 = lshr i64 %3015, 8
  %3017 = trunc i64 %3016 to i8
  %3018 = zext i8 %3017 to i64
  %3019 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3018
  %3020 = load i64, ptr %3019, align 8, !tbaa !12
  %3021 = shl i64 %3020, 8
  %3022 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %3023 = load i64, ptr %3022, align 8, !tbaa !12
  %3024 = lshr i64 %3023, 8
  %3025 = trunc i64 %3024 to i8
  %3026 = zext i8 %3025 to i64
  %3027 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3026
  %3028 = load i64, ptr %3027, align 8, !tbaa !12
  %3029 = lshr i64 %3028, 24
  %3030 = or i64 %3021, %3029
  %3031 = xor i64 %3013, %3030
  %3032 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %3033 = load i64, ptr %3032, align 16, !tbaa !12
  %3034 = lshr i64 %3033, 16
  %3035 = trunc i64 %3034 to i8
  %3036 = zext i8 %3035 to i64
  %3037 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3036
  %3038 = load i64, ptr %3037, align 8, !tbaa !12
  %3039 = shl i64 %3038, 16
  %3040 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %3041 = load i64, ptr %3040, align 16, !tbaa !12
  %3042 = lshr i64 %3041, 16
  %3043 = trunc i64 %3042 to i8
  %3044 = zext i8 %3043 to i64
  %3045 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3044
  %3046 = load i64, ptr %3045, align 8, !tbaa !12
  %3047 = lshr i64 %3046, 16
  %3048 = or i64 %3039, %3047
  %3049 = xor i64 %3031, %3048
  %3050 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %3051 = load i64, ptr %3050, align 8, !tbaa !12
  %3052 = lshr i64 %3051, 24
  %3053 = trunc i64 %3052 to i8
  %3054 = zext i8 %3053 to i64
  %3055 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3054
  %3056 = load i64, ptr %3055, align 8, !tbaa !12
  %3057 = shl i64 %3056, 24
  %3058 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %3059 = load i64, ptr %3058, align 8, !tbaa !12
  %3060 = lshr i64 %3059, 24
  %3061 = trunc i64 %3060 to i8
  %3062 = zext i8 %3061 to i64
  %3063 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3062
  %3064 = load i64, ptr %3063, align 8, !tbaa !12
  %3065 = lshr i64 %3064, 8
  %3066 = or i64 %3057, %3065
  %3067 = xor i64 %3049, %3066
  %3068 = xor i64 %3006, %3067
  %3069 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  store i64 %3068, ptr %3069, align 16, !tbaa !12
  %3070 = load ptr, ptr %10, align 8, !tbaa !5
  %3071 = getelementptr inbounds i64, ptr %3070, i64 28
  %3072 = getelementptr inbounds i64, ptr %3071, i64 1
  %3073 = load i64, ptr %3072, align 8, !tbaa !12
  %3074 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %3075 = load i64, ptr %3074, align 8, !tbaa !12
  %3076 = lshr i64 %3075, 0
  %3077 = trunc i64 %3076 to i8
  %3078 = zext i8 %3077 to i64
  %3079 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3078
  %3080 = load i64, ptr %3079, align 8, !tbaa !12
  %3081 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %3082 = load i64, ptr %3081, align 16, !tbaa !12
  %3083 = lshr i64 %3082, 8
  %3084 = trunc i64 %3083 to i8
  %3085 = zext i8 %3084 to i64
  %3086 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3085
  %3087 = load i64, ptr %3086, align 8, !tbaa !12
  %3088 = shl i64 %3087, 8
  %3089 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %3090 = load i64, ptr %3089, align 16, !tbaa !12
  %3091 = lshr i64 %3090, 8
  %3092 = trunc i64 %3091 to i8
  %3093 = zext i8 %3092 to i64
  %3094 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3093
  %3095 = load i64, ptr %3094, align 8, !tbaa !12
  %3096 = lshr i64 %3095, 24
  %3097 = or i64 %3088, %3096
  %3098 = xor i64 %3080, %3097
  %3099 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %3100 = load i64, ptr %3099, align 8, !tbaa !12
  %3101 = lshr i64 %3100, 16
  %3102 = trunc i64 %3101 to i8
  %3103 = zext i8 %3102 to i64
  %3104 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3103
  %3105 = load i64, ptr %3104, align 8, !tbaa !12
  %3106 = shl i64 %3105, 16
  %3107 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %3108 = load i64, ptr %3107, align 8, !tbaa !12
  %3109 = lshr i64 %3108, 16
  %3110 = trunc i64 %3109 to i8
  %3111 = zext i8 %3110 to i64
  %3112 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3111
  %3113 = load i64, ptr %3112, align 8, !tbaa !12
  %3114 = lshr i64 %3113, 16
  %3115 = or i64 %3106, %3114
  %3116 = xor i64 %3098, %3115
  %3117 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %3118 = load i64, ptr %3117, align 16, !tbaa !12
  %3119 = lshr i64 %3118, 24
  %3120 = trunc i64 %3119 to i8
  %3121 = zext i8 %3120 to i64
  %3122 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3121
  %3123 = load i64, ptr %3122, align 8, !tbaa !12
  %3124 = shl i64 %3123, 24
  %3125 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %3126 = load i64, ptr %3125, align 16, !tbaa !12
  %3127 = lshr i64 %3126, 24
  %3128 = trunc i64 %3127 to i8
  %3129 = zext i8 %3128 to i64
  %3130 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3129
  %3131 = load i64, ptr %3130, align 8, !tbaa !12
  %3132 = lshr i64 %3131, 8
  %3133 = or i64 %3124, %3132
  %3134 = xor i64 %3116, %3133
  %3135 = xor i64 %3073, %3134
  %3136 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  store i64 %3135, ptr %3136, align 8, !tbaa !12
  %3137 = load ptr, ptr %10, align 8, !tbaa !5
  %3138 = getelementptr inbounds i64, ptr %3137, i64 28
  %3139 = getelementptr inbounds i64, ptr %3138, i64 2
  %3140 = load i64, ptr %3139, align 8, !tbaa !12
  %3141 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %3142 = load i64, ptr %3141, align 16, !tbaa !12
  %3143 = lshr i64 %3142, 0
  %3144 = trunc i64 %3143 to i8
  %3145 = zext i8 %3144 to i64
  %3146 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3145
  %3147 = load i64, ptr %3146, align 8, !tbaa !12
  %3148 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %3149 = load i64, ptr %3148, align 8, !tbaa !12
  %3150 = lshr i64 %3149, 8
  %3151 = trunc i64 %3150 to i8
  %3152 = zext i8 %3151 to i64
  %3153 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3152
  %3154 = load i64, ptr %3153, align 8, !tbaa !12
  %3155 = shl i64 %3154, 8
  %3156 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %3157 = load i64, ptr %3156, align 8, !tbaa !12
  %3158 = lshr i64 %3157, 8
  %3159 = trunc i64 %3158 to i8
  %3160 = zext i8 %3159 to i64
  %3161 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3160
  %3162 = load i64, ptr %3161, align 8, !tbaa !12
  %3163 = lshr i64 %3162, 24
  %3164 = or i64 %3155, %3163
  %3165 = xor i64 %3147, %3164
  %3166 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %3167 = load i64, ptr %3166, align 16, !tbaa !12
  %3168 = lshr i64 %3167, 16
  %3169 = trunc i64 %3168 to i8
  %3170 = zext i8 %3169 to i64
  %3171 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3170
  %3172 = load i64, ptr %3171, align 8, !tbaa !12
  %3173 = shl i64 %3172, 16
  %3174 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %3175 = load i64, ptr %3174, align 16, !tbaa !12
  %3176 = lshr i64 %3175, 16
  %3177 = trunc i64 %3176 to i8
  %3178 = zext i8 %3177 to i64
  %3179 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3178
  %3180 = load i64, ptr %3179, align 8, !tbaa !12
  %3181 = lshr i64 %3180, 16
  %3182 = or i64 %3173, %3181
  %3183 = xor i64 %3165, %3182
  %3184 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %3185 = load i64, ptr %3184, align 8, !tbaa !12
  %3186 = lshr i64 %3185, 24
  %3187 = trunc i64 %3186 to i8
  %3188 = zext i8 %3187 to i64
  %3189 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3188
  %3190 = load i64, ptr %3189, align 8, !tbaa !12
  %3191 = shl i64 %3190, 24
  %3192 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %3193 = load i64, ptr %3192, align 8, !tbaa !12
  %3194 = lshr i64 %3193, 24
  %3195 = trunc i64 %3194 to i8
  %3196 = zext i8 %3195 to i64
  %3197 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3196
  %3198 = load i64, ptr %3197, align 8, !tbaa !12
  %3199 = lshr i64 %3198, 8
  %3200 = or i64 %3191, %3199
  %3201 = xor i64 %3183, %3200
  %3202 = xor i64 %3140, %3201
  %3203 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  store i64 %3202, ptr %3203, align 16, !tbaa !12
  %3204 = load ptr, ptr %10, align 8, !tbaa !5
  %3205 = getelementptr inbounds i64, ptr %3204, i64 28
  %3206 = getelementptr inbounds i64, ptr %3205, i64 3
  %3207 = load i64, ptr %3206, align 8, !tbaa !12
  %3208 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %3209 = load i64, ptr %3208, align 8, !tbaa !12
  %3210 = lshr i64 %3209, 0
  %3211 = trunc i64 %3210 to i8
  %3212 = zext i8 %3211 to i64
  %3213 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3212
  %3214 = load i64, ptr %3213, align 8, !tbaa !12
  %3215 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %3216 = load i64, ptr %3215, align 16, !tbaa !12
  %3217 = lshr i64 %3216, 8
  %3218 = trunc i64 %3217 to i8
  %3219 = zext i8 %3218 to i64
  %3220 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3219
  %3221 = load i64, ptr %3220, align 8, !tbaa !12
  %3222 = shl i64 %3221, 8
  %3223 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %3224 = load i64, ptr %3223, align 16, !tbaa !12
  %3225 = lshr i64 %3224, 8
  %3226 = trunc i64 %3225 to i8
  %3227 = zext i8 %3226 to i64
  %3228 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3227
  %3229 = load i64, ptr %3228, align 8, !tbaa !12
  %3230 = lshr i64 %3229, 24
  %3231 = or i64 %3222, %3230
  %3232 = xor i64 %3214, %3231
  %3233 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %3234 = load i64, ptr %3233, align 8, !tbaa !12
  %3235 = lshr i64 %3234, 16
  %3236 = trunc i64 %3235 to i8
  %3237 = zext i8 %3236 to i64
  %3238 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3237
  %3239 = load i64, ptr %3238, align 8, !tbaa !12
  %3240 = shl i64 %3239, 16
  %3241 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %3242 = load i64, ptr %3241, align 8, !tbaa !12
  %3243 = lshr i64 %3242, 16
  %3244 = trunc i64 %3243 to i8
  %3245 = zext i8 %3244 to i64
  %3246 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3245
  %3247 = load i64, ptr %3246, align 8, !tbaa !12
  %3248 = lshr i64 %3247, 16
  %3249 = or i64 %3240, %3248
  %3250 = xor i64 %3232, %3249
  %3251 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %3252 = load i64, ptr %3251, align 16, !tbaa !12
  %3253 = lshr i64 %3252, 24
  %3254 = trunc i64 %3253 to i8
  %3255 = zext i8 %3254 to i64
  %3256 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3255
  %3257 = load i64, ptr %3256, align 8, !tbaa !12
  %3258 = shl i64 %3257, 24
  %3259 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %3260 = load i64, ptr %3259, align 16, !tbaa !12
  %3261 = lshr i64 %3260, 24
  %3262 = trunc i64 %3261 to i8
  %3263 = zext i8 %3262 to i64
  %3264 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3263
  %3265 = load i64, ptr %3264, align 8, !tbaa !12
  %3266 = lshr i64 %3265, 8
  %3267 = or i64 %3258, %3266
  %3268 = xor i64 %3250, %3267
  %3269 = xor i64 %3207, %3268
  %3270 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  store i64 %3269, ptr %3270, align 8, !tbaa !12
  %3271 = load ptr, ptr %10, align 8, !tbaa !5
  %3272 = getelementptr inbounds i64, ptr %3271, i64 32
  %3273 = getelementptr inbounds i64, ptr %3272, i64 0
  %3274 = load i64, ptr %3273, align 8, !tbaa !12
  %3275 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %3276 = load i64, ptr %3275, align 16, !tbaa !12
  %3277 = lshr i64 %3276, 0
  %3278 = trunc i64 %3277 to i8
  %3279 = zext i8 %3278 to i64
  %3280 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3279
  %3281 = load i64, ptr %3280, align 8, !tbaa !12
  %3282 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %3283 = load i64, ptr %3282, align 8, !tbaa !12
  %3284 = lshr i64 %3283, 8
  %3285 = trunc i64 %3284 to i8
  %3286 = zext i8 %3285 to i64
  %3287 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3286
  %3288 = load i64, ptr %3287, align 8, !tbaa !12
  %3289 = shl i64 %3288, 8
  %3290 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %3291 = load i64, ptr %3290, align 8, !tbaa !12
  %3292 = lshr i64 %3291, 8
  %3293 = trunc i64 %3292 to i8
  %3294 = zext i8 %3293 to i64
  %3295 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3294
  %3296 = load i64, ptr %3295, align 8, !tbaa !12
  %3297 = lshr i64 %3296, 24
  %3298 = or i64 %3289, %3297
  %3299 = xor i64 %3281, %3298
  %3300 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %3301 = load i64, ptr %3300, align 16, !tbaa !12
  %3302 = lshr i64 %3301, 16
  %3303 = trunc i64 %3302 to i8
  %3304 = zext i8 %3303 to i64
  %3305 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3304
  %3306 = load i64, ptr %3305, align 8, !tbaa !12
  %3307 = shl i64 %3306, 16
  %3308 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %3309 = load i64, ptr %3308, align 16, !tbaa !12
  %3310 = lshr i64 %3309, 16
  %3311 = trunc i64 %3310 to i8
  %3312 = zext i8 %3311 to i64
  %3313 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3312
  %3314 = load i64, ptr %3313, align 8, !tbaa !12
  %3315 = lshr i64 %3314, 16
  %3316 = or i64 %3307, %3315
  %3317 = xor i64 %3299, %3316
  %3318 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %3319 = load i64, ptr %3318, align 8, !tbaa !12
  %3320 = lshr i64 %3319, 24
  %3321 = trunc i64 %3320 to i8
  %3322 = zext i8 %3321 to i64
  %3323 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3322
  %3324 = load i64, ptr %3323, align 8, !tbaa !12
  %3325 = shl i64 %3324, 24
  %3326 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %3327 = load i64, ptr %3326, align 8, !tbaa !12
  %3328 = lshr i64 %3327, 24
  %3329 = trunc i64 %3328 to i8
  %3330 = zext i8 %3329 to i64
  %3331 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3330
  %3332 = load i64, ptr %3331, align 8, !tbaa !12
  %3333 = lshr i64 %3332, 8
  %3334 = or i64 %3325, %3333
  %3335 = xor i64 %3317, %3334
  %3336 = xor i64 %3274, %3335
  %3337 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  store i64 %3336, ptr %3337, align 16, !tbaa !12
  %3338 = load ptr, ptr %10, align 8, !tbaa !5
  %3339 = getelementptr inbounds i64, ptr %3338, i64 32
  %3340 = getelementptr inbounds i64, ptr %3339, i64 1
  %3341 = load i64, ptr %3340, align 8, !tbaa !12
  %3342 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %3343 = load i64, ptr %3342, align 8, !tbaa !12
  %3344 = lshr i64 %3343, 0
  %3345 = trunc i64 %3344 to i8
  %3346 = zext i8 %3345 to i64
  %3347 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3346
  %3348 = load i64, ptr %3347, align 8, !tbaa !12
  %3349 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %3350 = load i64, ptr %3349, align 16, !tbaa !12
  %3351 = lshr i64 %3350, 8
  %3352 = trunc i64 %3351 to i8
  %3353 = zext i8 %3352 to i64
  %3354 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3353
  %3355 = load i64, ptr %3354, align 8, !tbaa !12
  %3356 = shl i64 %3355, 8
  %3357 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %3358 = load i64, ptr %3357, align 16, !tbaa !12
  %3359 = lshr i64 %3358, 8
  %3360 = trunc i64 %3359 to i8
  %3361 = zext i8 %3360 to i64
  %3362 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3361
  %3363 = load i64, ptr %3362, align 8, !tbaa !12
  %3364 = lshr i64 %3363, 24
  %3365 = or i64 %3356, %3364
  %3366 = xor i64 %3348, %3365
  %3367 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %3368 = load i64, ptr %3367, align 8, !tbaa !12
  %3369 = lshr i64 %3368, 16
  %3370 = trunc i64 %3369 to i8
  %3371 = zext i8 %3370 to i64
  %3372 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3371
  %3373 = load i64, ptr %3372, align 8, !tbaa !12
  %3374 = shl i64 %3373, 16
  %3375 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %3376 = load i64, ptr %3375, align 8, !tbaa !12
  %3377 = lshr i64 %3376, 16
  %3378 = trunc i64 %3377 to i8
  %3379 = zext i8 %3378 to i64
  %3380 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3379
  %3381 = load i64, ptr %3380, align 8, !tbaa !12
  %3382 = lshr i64 %3381, 16
  %3383 = or i64 %3374, %3382
  %3384 = xor i64 %3366, %3383
  %3385 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %3386 = load i64, ptr %3385, align 16, !tbaa !12
  %3387 = lshr i64 %3386, 24
  %3388 = trunc i64 %3387 to i8
  %3389 = zext i8 %3388 to i64
  %3390 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3389
  %3391 = load i64, ptr %3390, align 8, !tbaa !12
  %3392 = shl i64 %3391, 24
  %3393 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %3394 = load i64, ptr %3393, align 16, !tbaa !12
  %3395 = lshr i64 %3394, 24
  %3396 = trunc i64 %3395 to i8
  %3397 = zext i8 %3396 to i64
  %3398 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3397
  %3399 = load i64, ptr %3398, align 8, !tbaa !12
  %3400 = lshr i64 %3399, 8
  %3401 = or i64 %3392, %3400
  %3402 = xor i64 %3384, %3401
  %3403 = xor i64 %3341, %3402
  %3404 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  store i64 %3403, ptr %3404, align 8, !tbaa !12
  %3405 = load ptr, ptr %10, align 8, !tbaa !5
  %3406 = getelementptr inbounds i64, ptr %3405, i64 32
  %3407 = getelementptr inbounds i64, ptr %3406, i64 2
  %3408 = load i64, ptr %3407, align 8, !tbaa !12
  %3409 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %3410 = load i64, ptr %3409, align 16, !tbaa !12
  %3411 = lshr i64 %3410, 0
  %3412 = trunc i64 %3411 to i8
  %3413 = zext i8 %3412 to i64
  %3414 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3413
  %3415 = load i64, ptr %3414, align 8, !tbaa !12
  %3416 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %3417 = load i64, ptr %3416, align 8, !tbaa !12
  %3418 = lshr i64 %3417, 8
  %3419 = trunc i64 %3418 to i8
  %3420 = zext i8 %3419 to i64
  %3421 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3420
  %3422 = load i64, ptr %3421, align 8, !tbaa !12
  %3423 = shl i64 %3422, 8
  %3424 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %3425 = load i64, ptr %3424, align 8, !tbaa !12
  %3426 = lshr i64 %3425, 8
  %3427 = trunc i64 %3426 to i8
  %3428 = zext i8 %3427 to i64
  %3429 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3428
  %3430 = load i64, ptr %3429, align 8, !tbaa !12
  %3431 = lshr i64 %3430, 24
  %3432 = or i64 %3423, %3431
  %3433 = xor i64 %3415, %3432
  %3434 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %3435 = load i64, ptr %3434, align 16, !tbaa !12
  %3436 = lshr i64 %3435, 16
  %3437 = trunc i64 %3436 to i8
  %3438 = zext i8 %3437 to i64
  %3439 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3438
  %3440 = load i64, ptr %3439, align 8, !tbaa !12
  %3441 = shl i64 %3440, 16
  %3442 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %3443 = load i64, ptr %3442, align 16, !tbaa !12
  %3444 = lshr i64 %3443, 16
  %3445 = trunc i64 %3444 to i8
  %3446 = zext i8 %3445 to i64
  %3447 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3446
  %3448 = load i64, ptr %3447, align 8, !tbaa !12
  %3449 = lshr i64 %3448, 16
  %3450 = or i64 %3441, %3449
  %3451 = xor i64 %3433, %3450
  %3452 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %3453 = load i64, ptr %3452, align 8, !tbaa !12
  %3454 = lshr i64 %3453, 24
  %3455 = trunc i64 %3454 to i8
  %3456 = zext i8 %3455 to i64
  %3457 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3456
  %3458 = load i64, ptr %3457, align 8, !tbaa !12
  %3459 = shl i64 %3458, 24
  %3460 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %3461 = load i64, ptr %3460, align 8, !tbaa !12
  %3462 = lshr i64 %3461, 24
  %3463 = trunc i64 %3462 to i8
  %3464 = zext i8 %3463 to i64
  %3465 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3464
  %3466 = load i64, ptr %3465, align 8, !tbaa !12
  %3467 = lshr i64 %3466, 8
  %3468 = or i64 %3459, %3467
  %3469 = xor i64 %3451, %3468
  %3470 = xor i64 %3408, %3469
  %3471 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  store i64 %3470, ptr %3471, align 16, !tbaa !12
  %3472 = load ptr, ptr %10, align 8, !tbaa !5
  %3473 = getelementptr inbounds i64, ptr %3472, i64 32
  %3474 = getelementptr inbounds i64, ptr %3473, i64 3
  %3475 = load i64, ptr %3474, align 8, !tbaa !12
  %3476 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %3477 = load i64, ptr %3476, align 8, !tbaa !12
  %3478 = lshr i64 %3477, 0
  %3479 = trunc i64 %3478 to i8
  %3480 = zext i8 %3479 to i64
  %3481 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3480
  %3482 = load i64, ptr %3481, align 8, !tbaa !12
  %3483 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %3484 = load i64, ptr %3483, align 16, !tbaa !12
  %3485 = lshr i64 %3484, 8
  %3486 = trunc i64 %3485 to i8
  %3487 = zext i8 %3486 to i64
  %3488 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3487
  %3489 = load i64, ptr %3488, align 8, !tbaa !12
  %3490 = shl i64 %3489, 8
  %3491 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %3492 = load i64, ptr %3491, align 16, !tbaa !12
  %3493 = lshr i64 %3492, 8
  %3494 = trunc i64 %3493 to i8
  %3495 = zext i8 %3494 to i64
  %3496 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3495
  %3497 = load i64, ptr %3496, align 8, !tbaa !12
  %3498 = lshr i64 %3497, 24
  %3499 = or i64 %3490, %3498
  %3500 = xor i64 %3482, %3499
  %3501 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %3502 = load i64, ptr %3501, align 8, !tbaa !12
  %3503 = lshr i64 %3502, 16
  %3504 = trunc i64 %3503 to i8
  %3505 = zext i8 %3504 to i64
  %3506 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3505
  %3507 = load i64, ptr %3506, align 8, !tbaa !12
  %3508 = shl i64 %3507, 16
  %3509 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %3510 = load i64, ptr %3509, align 8, !tbaa !12
  %3511 = lshr i64 %3510, 16
  %3512 = trunc i64 %3511 to i8
  %3513 = zext i8 %3512 to i64
  %3514 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3513
  %3515 = load i64, ptr %3514, align 8, !tbaa !12
  %3516 = lshr i64 %3515, 16
  %3517 = or i64 %3508, %3516
  %3518 = xor i64 %3500, %3517
  %3519 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %3520 = load i64, ptr %3519, align 16, !tbaa !12
  %3521 = lshr i64 %3520, 24
  %3522 = trunc i64 %3521 to i8
  %3523 = zext i8 %3522 to i64
  %3524 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3523
  %3525 = load i64, ptr %3524, align 8, !tbaa !12
  %3526 = shl i64 %3525, 24
  %3527 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %3528 = load i64, ptr %3527, align 16, !tbaa !12
  %3529 = lshr i64 %3528, 24
  %3530 = trunc i64 %3529 to i8
  %3531 = zext i8 %3530 to i64
  %3532 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %3531
  %3533 = load i64, ptr %3532, align 8, !tbaa !12
  %3534 = lshr i64 %3533, 8
  %3535 = or i64 %3526, %3534
  %3536 = xor i64 %3518, %3535
  %3537 = xor i64 %3475, %3536
  %3538 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  store i64 %3537, ptr %3538, align 8, !tbaa !12
  %3539 = load ptr, ptr %10, align 8, !tbaa !5
  %3540 = getelementptr inbounds i64, ptr %3539, i64 36
  %3541 = getelementptr inbounds i64, ptr %3540, i64 0
  %3542 = load i64, ptr %3541, align 8, !tbaa !12
  %3543 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %3544 = load i64, ptr %3543, align 16, !tbaa !12
  %3545 = lshr i64 %3544, 0
  %3546 = trunc i64 %3545 to i8
  %3547 = zext i8 %3546 to i64
  %3548 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3547
  %3549 = load i64, ptr %3548, align 8, !tbaa !12
  %3550 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %3551 = load i64, ptr %3550, align 8, !tbaa !12
  %3552 = lshr i64 %3551, 8
  %3553 = trunc i64 %3552 to i8
  %3554 = zext i8 %3553 to i64
  %3555 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3554
  %3556 = load i64, ptr %3555, align 8, !tbaa !12
  %3557 = shl i64 %3556, 8
  %3558 = xor i64 %3549, %3557
  %3559 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %3560 = load i64, ptr %3559, align 16, !tbaa !12
  %3561 = lshr i64 %3560, 16
  %3562 = trunc i64 %3561 to i8
  %3563 = zext i8 %3562 to i64
  %3564 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3563
  %3565 = load i64, ptr %3564, align 8, !tbaa !12
  %3566 = shl i64 %3565, 16
  %3567 = xor i64 %3558, %3566
  %3568 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %3569 = load i64, ptr %3568, align 8, !tbaa !12
  %3570 = lshr i64 %3569, 24
  %3571 = trunc i64 %3570 to i8
  %3572 = zext i8 %3571 to i64
  %3573 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3572
  %3574 = load i64, ptr %3573, align 8, !tbaa !12
  %3575 = shl i64 %3574, 24
  %3576 = xor i64 %3567, %3575
  %3577 = xor i64 %3542, %3576
  %3578 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  store i64 %3577, ptr %3578, align 16, !tbaa !12
  %3579 = load ptr, ptr %10, align 8, !tbaa !5
  %3580 = getelementptr inbounds i64, ptr %3579, i64 36
  %3581 = getelementptr inbounds i64, ptr %3580, i64 1
  %3582 = load i64, ptr %3581, align 8, !tbaa !12
  %3583 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %3584 = load i64, ptr %3583, align 8, !tbaa !12
  %3585 = lshr i64 %3584, 0
  %3586 = trunc i64 %3585 to i8
  %3587 = zext i8 %3586 to i64
  %3588 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3587
  %3589 = load i64, ptr %3588, align 8, !tbaa !12
  %3590 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %3591 = load i64, ptr %3590, align 16, !tbaa !12
  %3592 = lshr i64 %3591, 8
  %3593 = trunc i64 %3592 to i8
  %3594 = zext i8 %3593 to i64
  %3595 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3594
  %3596 = load i64, ptr %3595, align 8, !tbaa !12
  %3597 = shl i64 %3596, 8
  %3598 = xor i64 %3589, %3597
  %3599 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %3600 = load i64, ptr %3599, align 8, !tbaa !12
  %3601 = lshr i64 %3600, 16
  %3602 = trunc i64 %3601 to i8
  %3603 = zext i8 %3602 to i64
  %3604 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3603
  %3605 = load i64, ptr %3604, align 8, !tbaa !12
  %3606 = shl i64 %3605, 16
  %3607 = xor i64 %3598, %3606
  %3608 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %3609 = load i64, ptr %3608, align 16, !tbaa !12
  %3610 = lshr i64 %3609, 24
  %3611 = trunc i64 %3610 to i8
  %3612 = zext i8 %3611 to i64
  %3613 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3612
  %3614 = load i64, ptr %3613, align 8, !tbaa !12
  %3615 = shl i64 %3614, 24
  %3616 = xor i64 %3607, %3615
  %3617 = xor i64 %3582, %3616
  %3618 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  store i64 %3617, ptr %3618, align 8, !tbaa !12
  %3619 = load ptr, ptr %10, align 8, !tbaa !5
  %3620 = getelementptr inbounds i64, ptr %3619, i64 36
  %3621 = getelementptr inbounds i64, ptr %3620, i64 2
  %3622 = load i64, ptr %3621, align 8, !tbaa !12
  %3623 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %3624 = load i64, ptr %3623, align 16, !tbaa !12
  %3625 = lshr i64 %3624, 0
  %3626 = trunc i64 %3625 to i8
  %3627 = zext i8 %3626 to i64
  %3628 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3627
  %3629 = load i64, ptr %3628, align 8, !tbaa !12
  %3630 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %3631 = load i64, ptr %3630, align 8, !tbaa !12
  %3632 = lshr i64 %3631, 8
  %3633 = trunc i64 %3632 to i8
  %3634 = zext i8 %3633 to i64
  %3635 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3634
  %3636 = load i64, ptr %3635, align 8, !tbaa !12
  %3637 = shl i64 %3636, 8
  %3638 = xor i64 %3629, %3637
  %3639 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %3640 = load i64, ptr %3639, align 16, !tbaa !12
  %3641 = lshr i64 %3640, 16
  %3642 = trunc i64 %3641 to i8
  %3643 = zext i8 %3642 to i64
  %3644 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3643
  %3645 = load i64, ptr %3644, align 8, !tbaa !12
  %3646 = shl i64 %3645, 16
  %3647 = xor i64 %3638, %3646
  %3648 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %3649 = load i64, ptr %3648, align 8, !tbaa !12
  %3650 = lshr i64 %3649, 24
  %3651 = trunc i64 %3650 to i8
  %3652 = zext i8 %3651 to i64
  %3653 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3652
  %3654 = load i64, ptr %3653, align 8, !tbaa !12
  %3655 = shl i64 %3654, 24
  %3656 = xor i64 %3647, %3655
  %3657 = xor i64 %3622, %3656
  %3658 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  store i64 %3657, ptr %3658, align 16, !tbaa !12
  %3659 = load ptr, ptr %10, align 8, !tbaa !5
  %3660 = getelementptr inbounds i64, ptr %3659, i64 36
  %3661 = getelementptr inbounds i64, ptr %3660, i64 3
  %3662 = load i64, ptr %3661, align 8, !tbaa !12
  %3663 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 3
  %3664 = load i64, ptr %3663, align 8, !tbaa !12
  %3665 = lshr i64 %3664, 0
  %3666 = trunc i64 %3665 to i8
  %3667 = zext i8 %3666 to i64
  %3668 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3667
  %3669 = load i64, ptr %3668, align 8, !tbaa !12
  %3670 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 2
  %3671 = load i64, ptr %3670, align 16, !tbaa !12
  %3672 = lshr i64 %3671, 8
  %3673 = trunc i64 %3672 to i8
  %3674 = zext i8 %3673 to i64
  %3675 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3674
  %3676 = load i64, ptr %3675, align 8, !tbaa !12
  %3677 = shl i64 %3676, 8
  %3678 = xor i64 %3669, %3677
  %3679 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 1
  %3680 = load i64, ptr %3679, align 8, !tbaa !12
  %3681 = lshr i64 %3680, 16
  %3682 = trunc i64 %3681 to i8
  %3683 = zext i8 %3682 to i64
  %3684 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3683
  %3685 = load i64, ptr %3684, align 8, !tbaa !12
  %3686 = shl i64 %3685, 16
  %3687 = xor i64 %3678, %3686
  %3688 = getelementptr inbounds [4 x i64], ptr %8, i64 0, i64 0
  %3689 = load i64, ptr %3688, align 16, !tbaa !12
  %3690 = lshr i64 %3689, 24
  %3691 = trunc i64 %3690 to i8
  %3692 = zext i8 %3691 to i64
  %3693 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %3692
  %3694 = load i64, ptr %3693, align 8, !tbaa !12
  %3695 = shl i64 %3694, 24
  %3696 = xor i64 %3687, %3695
  %3697 = xor i64 %3662, %3696
  %3698 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  store i64 %3697, ptr %3698, align 8, !tbaa !12
  br label %3699

3699:                                             ; preds = %1130, %22
  %3700 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 0
  %3701 = load i64, ptr %3700, align 16, !tbaa !12
  %3702 = load ptr, ptr %6, align 8, !tbaa !5
  %3703 = getelementptr inbounds i8, ptr %3702, i64 0
  store i64 %3701, ptr %3703, align 8, !tbaa !12
  %3704 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 1
  %3705 = load i64, ptr %3704, align 8, !tbaa !12
  %3706 = load ptr, ptr %6, align 8, !tbaa !5
  %3707 = getelementptr inbounds i8, ptr %3706, i64 4
  store i64 %3705, ptr %3707, align 8, !tbaa !12
  %3708 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 2
  %3709 = load i64, ptr %3708, align 16, !tbaa !12
  %3710 = load ptr, ptr %6, align 8, !tbaa !5
  %3711 = getelementptr inbounds i8, ptr %3710, i64 8
  store i64 %3709, ptr %3711, align 8, !tbaa !12
  %3712 = getelementptr inbounds [4 x i64], ptr %9, i64 0, i64 3
  %3713 = load i64, ptr %3712, align 8, !tbaa !12
  %3714 = load ptr, ptr %6, align 8, !tbaa !5
  %3715 = getelementptr inbounds i8, ptr %3714, i64 12
  store i64 %3713, ptr %3715, align 8, !tbaa !12
  store i16 1, ptr %4, align 2
  store i32 1, ptr %11, align 4
  br label %3716

3716:                                             ; preds = %3699, %21
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #2
  call void @llvm.lifetime.end.p0(i64 32, ptr %9) #2
  call void @llvm.lifetime.end.p0(i64 32, ptr %8) #2
  %3717 = load i16, ptr %4, align 2
  ret i16 %3717
}

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !7, i64 1040}
!10 = !{!"", !11, i64 0, !11, i64 8, !7, i64 16, !7, i64 528, !7, i64 1040}
!11 = !{!"long", !7, i64 0}
!12 = !{!11, !11, i64 0}
!13 = !{!10, !11, i64 8}


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

@it_tab = external dso_local local_unnamed_addr constant [256 x i64], align 16
@il_tab = external dso_local local_unnamed_addr constant [256 x i64], align 16

; Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read, argmem: readwrite, inaccessiblemem: none) uwtable
define dso_local signext range(i16 0, 2) i16 @decrypt(ptr nocapture noundef readonly %0, ptr nocapture noundef writeonly %1, ptr noundef readonly %2) local_unnamed_addr #0 {
  %4 = getelementptr inbounds i8, ptr %2, i64 1040
  %5 = load i8, ptr %4, align 8, !tbaa !5
  %6 = and i8 %5, 2
  %.not = icmp eq i8 %6, 0
  br i1 %.not, label %1692, label %7

7:                                                ; preds = %3
  %8 = getelementptr inbounds i8, ptr %2, i64 528
  %9 = load i64, ptr %0, align 8, !tbaa !10
  %10 = load i64, ptr %8, align 8, !tbaa !10
  %11 = xor i64 %10, %9
  %12 = getelementptr inbounds i8, ptr %0, i64 4
  %13 = load i64, ptr %12, align 8, !tbaa !10
  %14 = getelementptr inbounds i8, ptr %2, i64 536
  %15 = load i64, ptr %14, align 8, !tbaa !10
  %16 = xor i64 %15, %13
  %17 = getelementptr inbounds i8, ptr %0, i64 8
  %18 = load i64, ptr %17, align 8, !tbaa !10
  %19 = getelementptr inbounds i8, ptr %2, i64 544
  %20 = load i64, ptr %19, align 8, !tbaa !10
  %21 = xor i64 %20, %18
  %22 = getelementptr inbounds i8, ptr %0, i64 12
  %23 = load i64, ptr %22, align 8, !tbaa !10
  %24 = getelementptr inbounds i8, ptr %2, i64 552
  %25 = load i64, ptr %24, align 8, !tbaa !10
  %26 = xor i64 %25, %23
  %27 = getelementptr inbounds i8, ptr %2, i64 560
  %28 = getelementptr inbounds i8, ptr %2, i64 8
  %29 = load i64, ptr %28, align 8, !tbaa !11
  switch i64 %29, label %1688 [
    i64 14, label %30
    i64 12, label %271
    i64 10, label %512
  ]

30:                                               ; preds = %7
  %31 = load i64, ptr %27, align 8, !tbaa !10
  %32 = and i64 %11, 255
  %33 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %32
  %34 = load i64, ptr %33, align 8, !tbaa !10
  %35 = lshr i64 %26, 8
  %36 = and i64 %35, 255
  %37 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %36
  %38 = load i64, ptr %37, align 8, !tbaa !10
  %39 = shl i64 %38, 8
  %40 = lshr i64 %38, 24
  %41 = or i64 %39, %40
  %42 = lshr i64 %21, 16
  %43 = and i64 %42, 255
  %44 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %43
  %45 = load i64, ptr %44, align 8, !tbaa !10
  %46 = shl i64 %45, 16
  %47 = lshr i64 %45, 16
  %48 = or i64 %46, %47
  %49 = lshr i64 %16, 24
  %50 = and i64 %49, 255
  %51 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %50
  %52 = load i64, ptr %51, align 8, !tbaa !10
  %53 = shl i64 %52, 24
  %54 = lshr i64 %52, 8
  %55 = or i64 %53, %54
  %56 = xor i64 %34, %31
  %57 = xor i64 %56, %41
  %58 = xor i64 %57, %48
  %59 = xor i64 %58, %55
  %60 = getelementptr inbounds i8, ptr %2, i64 568
  %61 = load i64, ptr %60, align 8, !tbaa !10
  %62 = and i64 %16, 255
  %63 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %62
  %64 = load i64, ptr %63, align 8, !tbaa !10
  %65 = lshr i64 %11, 8
  %66 = and i64 %65, 255
  %67 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %66
  %68 = load i64, ptr %67, align 8, !tbaa !10
  %69 = shl i64 %68, 8
  %70 = lshr i64 %68, 24
  %71 = or i64 %69, %70
  %72 = lshr i64 %26, 16
  %73 = and i64 %72, 255
  %74 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %73
  %75 = load i64, ptr %74, align 8, !tbaa !10
  %76 = shl i64 %75, 16
  %77 = lshr i64 %75, 16
  %78 = or i64 %76, %77
  %79 = lshr i64 %21, 24
  %80 = and i64 %79, 255
  %81 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %80
  %82 = load i64, ptr %81, align 8, !tbaa !10
  %83 = shl i64 %82, 24
  %84 = lshr i64 %82, 8
  %85 = or i64 %83, %84
  %86 = xor i64 %64, %61
  %87 = xor i64 %86, %71
  %88 = xor i64 %87, %78
  %89 = xor i64 %88, %85
  %90 = getelementptr inbounds i8, ptr %2, i64 576
  %91 = load i64, ptr %90, align 8, !tbaa !10
  %92 = and i64 %21, 255
  %93 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %92
  %94 = load i64, ptr %93, align 8, !tbaa !10
  %95 = lshr i64 %16, 8
  %96 = and i64 %95, 255
  %97 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %96
  %98 = load i64, ptr %97, align 8, !tbaa !10
  %99 = shl i64 %98, 8
  %100 = lshr i64 %98, 24
  %101 = or i64 %99, %100
  %102 = lshr i64 %11, 16
  %103 = and i64 %102, 255
  %104 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %103
  %105 = load i64, ptr %104, align 8, !tbaa !10
  %106 = shl i64 %105, 16
  %107 = lshr i64 %105, 16
  %108 = or i64 %106, %107
  %109 = lshr i64 %26, 24
  %110 = and i64 %109, 255
  %111 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %110
  %112 = load i64, ptr %111, align 8, !tbaa !10
  %113 = shl i64 %112, 24
  %114 = lshr i64 %112, 8
  %115 = or i64 %113, %114
  %116 = xor i64 %94, %91
  %117 = xor i64 %116, %101
  %118 = xor i64 %117, %108
  %119 = xor i64 %118, %115
  %120 = getelementptr inbounds i8, ptr %2, i64 584
  %121 = load i64, ptr %120, align 8, !tbaa !10
  %122 = and i64 %26, 255
  %123 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %122
  %124 = load i64, ptr %123, align 8, !tbaa !10
  %125 = lshr i64 %21, 8
  %126 = and i64 %125, 255
  %127 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %126
  %128 = load i64, ptr %127, align 8, !tbaa !10
  %129 = shl i64 %128, 8
  %130 = lshr i64 %128, 24
  %131 = or i64 %129, %130
  %132 = lshr i64 %16, 16
  %133 = and i64 %132, 255
  %134 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %133
  %135 = load i64, ptr %134, align 8, !tbaa !10
  %136 = shl i64 %135, 16
  %137 = lshr i64 %135, 16
  %138 = or i64 %136, %137
  %139 = lshr i64 %11, 24
  %140 = and i64 %139, 255
  %141 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %140
  %142 = load i64, ptr %141, align 8, !tbaa !10
  %143 = shl i64 %142, 24
  %144 = lshr i64 %142, 8
  %145 = or i64 %143, %144
  %146 = xor i64 %124, %121
  %147 = xor i64 %146, %131
  %148 = xor i64 %147, %138
  %149 = xor i64 %148, %145
  %150 = getelementptr inbounds i8, ptr %2, i64 592
  %151 = load i64, ptr %150, align 8, !tbaa !10
  %152 = and i64 %59, 255
  %153 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %152
  %154 = load i64, ptr %153, align 8, !tbaa !10
  %155 = lshr i64 %149, 8
  %156 = and i64 %155, 255
  %157 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %156
  %158 = load i64, ptr %157, align 8, !tbaa !10
  %159 = shl i64 %158, 8
  %160 = lshr i64 %158, 24
  %161 = or i64 %159, %160
  %162 = lshr i64 %119, 16
  %163 = and i64 %162, 255
  %164 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %163
  %165 = load i64, ptr %164, align 8, !tbaa !10
  %166 = shl i64 %165, 16
  %167 = lshr i64 %165, 16
  %168 = or i64 %166, %167
  %169 = lshr i64 %89, 24
  %170 = and i64 %169, 255
  %171 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %170
  %172 = load i64, ptr %171, align 8, !tbaa !10
  %173 = shl i64 %172, 24
  %174 = lshr i64 %172, 8
  %175 = or i64 %173, %174
  %176 = xor i64 %154, %151
  %177 = xor i64 %176, %161
  %178 = xor i64 %177, %168
  %179 = xor i64 %178, %175
  %180 = getelementptr inbounds i8, ptr %2, i64 600
  %181 = load i64, ptr %180, align 8, !tbaa !10
  %182 = and i64 %89, 255
  %183 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %182
  %184 = load i64, ptr %183, align 8, !tbaa !10
  %185 = lshr i64 %59, 8
  %186 = and i64 %185, 255
  %187 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %186
  %188 = load i64, ptr %187, align 8, !tbaa !10
  %189 = shl i64 %188, 8
  %190 = lshr i64 %188, 24
  %191 = or i64 %189, %190
  %192 = lshr i64 %149, 16
  %193 = and i64 %192, 255
  %194 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %193
  %195 = load i64, ptr %194, align 8, !tbaa !10
  %196 = shl i64 %195, 16
  %197 = lshr i64 %195, 16
  %198 = or i64 %196, %197
  %199 = lshr i64 %119, 24
  %200 = and i64 %199, 255
  %201 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %200
  %202 = load i64, ptr %201, align 8, !tbaa !10
  %203 = shl i64 %202, 24
  %204 = lshr i64 %202, 8
  %205 = or i64 %203, %204
  %206 = xor i64 %184, %181
  %207 = xor i64 %206, %191
  %208 = xor i64 %207, %198
  %209 = xor i64 %208, %205
  %210 = getelementptr inbounds i8, ptr %2, i64 608
  %211 = load i64, ptr %210, align 8, !tbaa !10
  %212 = and i64 %119, 255
  %213 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %212
  %214 = load i64, ptr %213, align 8, !tbaa !10
  %215 = lshr i64 %89, 8
  %216 = and i64 %215, 255
  %217 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %216
  %218 = load i64, ptr %217, align 8, !tbaa !10
  %219 = shl i64 %218, 8
  %220 = lshr i64 %218, 24
  %221 = or i64 %219, %220
  %222 = lshr i64 %59, 16
  %223 = and i64 %222, 255
  %224 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %223
  %225 = load i64, ptr %224, align 8, !tbaa !10
  %226 = shl i64 %225, 16
  %227 = lshr i64 %225, 16
  %228 = or i64 %226, %227
  %229 = lshr i64 %149, 24
  %230 = and i64 %229, 255
  %231 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %230
  %232 = load i64, ptr %231, align 8, !tbaa !10
  %233 = shl i64 %232, 24
  %234 = lshr i64 %232, 8
  %235 = or i64 %233, %234
  %236 = xor i64 %214, %211
  %237 = xor i64 %236, %221
  %238 = xor i64 %237, %228
  %239 = xor i64 %238, %235
  %240 = getelementptr inbounds i8, ptr %2, i64 616
  %241 = load i64, ptr %240, align 8, !tbaa !10
  %242 = and i64 %149, 255
  %243 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %242
  %244 = load i64, ptr %243, align 8, !tbaa !10
  %245 = lshr i64 %119, 8
  %246 = and i64 %245, 255
  %247 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %246
  %248 = load i64, ptr %247, align 8, !tbaa !10
  %249 = shl i64 %248, 8
  %250 = lshr i64 %248, 24
  %251 = or i64 %249, %250
  %252 = lshr i64 %89, 16
  %253 = and i64 %252, 255
  %254 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %253
  %255 = load i64, ptr %254, align 8, !tbaa !10
  %256 = shl i64 %255, 16
  %257 = lshr i64 %255, 16
  %258 = or i64 %256, %257
  %259 = lshr i64 %59, 24
  %260 = and i64 %259, 255
  %261 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %260
  %262 = load i64, ptr %261, align 8, !tbaa !10
  %263 = shl i64 %262, 24
  %264 = lshr i64 %262, 8
  %265 = or i64 %263, %264
  %266 = xor i64 %244, %241
  %267 = xor i64 %266, %251
  %268 = xor i64 %267, %258
  %269 = xor i64 %268, %265
  %270 = getelementptr inbounds i8, ptr %2, i64 624
  br label %271

271:                                              ; preds = %30, %7
  %.sroa.176.0 = phi i64 [ %26, %7 ], [ %269, %30 ]
  %.sroa.118.0 = phi i64 [ %21, %7 ], [ %239, %30 ]
  %.sroa.60.0 = phi i64 [ %16, %7 ], [ %209, %30 ]
  %.sroa.0.0 = phi i64 [ %11, %7 ], [ %179, %30 ]
  %.0 = phi ptr [ %27, %7 ], [ %270, %30 ]
  %272 = load i64, ptr %.0, align 8, !tbaa !10
  %273 = and i64 %.sroa.0.0, 255
  %274 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %273
  %275 = load i64, ptr %274, align 8, !tbaa !10
  %276 = lshr i64 %.sroa.176.0, 8
  %277 = and i64 %276, 255
  %278 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %277
  %279 = load i64, ptr %278, align 8, !tbaa !10
  %280 = shl i64 %279, 8
  %281 = lshr i64 %279, 24
  %282 = or i64 %280, %281
  %283 = lshr i64 %.sroa.118.0, 16
  %284 = and i64 %283, 255
  %285 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %284
  %286 = load i64, ptr %285, align 8, !tbaa !10
  %287 = shl i64 %286, 16
  %288 = lshr i64 %286, 16
  %289 = or i64 %287, %288
  %290 = lshr i64 %.sroa.60.0, 24
  %291 = and i64 %290, 255
  %292 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %291
  %293 = load i64, ptr %292, align 8, !tbaa !10
  %294 = shl i64 %293, 24
  %295 = lshr i64 %293, 8
  %296 = or i64 %294, %295
  %297 = xor i64 %275, %272
  %298 = xor i64 %297, %282
  %299 = xor i64 %298, %289
  %300 = xor i64 %299, %296
  %301 = getelementptr inbounds i8, ptr %.0, i64 8
  %302 = load i64, ptr %301, align 8, !tbaa !10
  %303 = and i64 %.sroa.60.0, 255
  %304 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %303
  %305 = load i64, ptr %304, align 8, !tbaa !10
  %306 = lshr i64 %.sroa.0.0, 8
  %307 = and i64 %306, 255
  %308 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %307
  %309 = load i64, ptr %308, align 8, !tbaa !10
  %310 = shl i64 %309, 8
  %311 = lshr i64 %309, 24
  %312 = or i64 %310, %311
  %313 = lshr i64 %.sroa.176.0, 16
  %314 = and i64 %313, 255
  %315 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %314
  %316 = load i64, ptr %315, align 8, !tbaa !10
  %317 = shl i64 %316, 16
  %318 = lshr i64 %316, 16
  %319 = or i64 %317, %318
  %320 = lshr i64 %.sroa.118.0, 24
  %321 = and i64 %320, 255
  %322 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %321
  %323 = load i64, ptr %322, align 8, !tbaa !10
  %324 = shl i64 %323, 24
  %325 = lshr i64 %323, 8
  %326 = or i64 %324, %325
  %327 = xor i64 %305, %302
  %328 = xor i64 %327, %312
  %329 = xor i64 %328, %319
  %330 = xor i64 %329, %326
  %331 = getelementptr inbounds i8, ptr %.0, i64 16
  %332 = load i64, ptr %331, align 8, !tbaa !10
  %333 = and i64 %.sroa.118.0, 255
  %334 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %333
  %335 = load i64, ptr %334, align 8, !tbaa !10
  %336 = lshr i64 %.sroa.60.0, 8
  %337 = and i64 %336, 255
  %338 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %337
  %339 = load i64, ptr %338, align 8, !tbaa !10
  %340 = shl i64 %339, 8
  %341 = lshr i64 %339, 24
  %342 = or i64 %340, %341
  %343 = lshr i64 %.sroa.0.0, 16
  %344 = and i64 %343, 255
  %345 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %344
  %346 = load i64, ptr %345, align 8, !tbaa !10
  %347 = shl i64 %346, 16
  %348 = lshr i64 %346, 16
  %349 = or i64 %347, %348
  %350 = lshr i64 %.sroa.176.0, 24
  %351 = and i64 %350, 255
  %352 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %351
  %353 = load i64, ptr %352, align 8, !tbaa !10
  %354 = shl i64 %353, 24
  %355 = lshr i64 %353, 8
  %356 = or i64 %354, %355
  %357 = xor i64 %335, %332
  %358 = xor i64 %357, %342
  %359 = xor i64 %358, %349
  %360 = xor i64 %359, %356
  %361 = getelementptr inbounds i8, ptr %.0, i64 24
  %362 = load i64, ptr %361, align 8, !tbaa !10
  %363 = and i64 %.sroa.176.0, 255
  %364 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %363
  %365 = load i64, ptr %364, align 8, !tbaa !10
  %366 = lshr i64 %.sroa.118.0, 8
  %367 = and i64 %366, 255
  %368 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %367
  %369 = load i64, ptr %368, align 8, !tbaa !10
  %370 = shl i64 %369, 8
  %371 = lshr i64 %369, 24
  %372 = or i64 %370, %371
  %373 = lshr i64 %.sroa.60.0, 16
  %374 = and i64 %373, 255
  %375 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %374
  %376 = load i64, ptr %375, align 8, !tbaa !10
  %377 = shl i64 %376, 16
  %378 = lshr i64 %376, 16
  %379 = or i64 %377, %378
  %380 = lshr i64 %.sroa.0.0, 24
  %381 = and i64 %380, 255
  %382 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %381
  %383 = load i64, ptr %382, align 8, !tbaa !10
  %384 = shl i64 %383, 24
  %385 = lshr i64 %383, 8
  %386 = or i64 %384, %385
  %387 = xor i64 %365, %362
  %388 = xor i64 %387, %372
  %389 = xor i64 %388, %379
  %390 = xor i64 %389, %386
  %391 = getelementptr inbounds i8, ptr %.0, i64 32
  %392 = load i64, ptr %391, align 8, !tbaa !10
  %393 = and i64 %300, 255
  %394 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %393
  %395 = load i64, ptr %394, align 8, !tbaa !10
  %396 = lshr i64 %390, 8
  %397 = and i64 %396, 255
  %398 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %397
  %399 = load i64, ptr %398, align 8, !tbaa !10
  %400 = shl i64 %399, 8
  %401 = lshr i64 %399, 24
  %402 = or i64 %400, %401
  %403 = lshr i64 %360, 16
  %404 = and i64 %403, 255
  %405 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %404
  %406 = load i64, ptr %405, align 8, !tbaa !10
  %407 = shl i64 %406, 16
  %408 = lshr i64 %406, 16
  %409 = or i64 %407, %408
  %410 = lshr i64 %330, 24
  %411 = and i64 %410, 255
  %412 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %411
  %413 = load i64, ptr %412, align 8, !tbaa !10
  %414 = shl i64 %413, 24
  %415 = lshr i64 %413, 8
  %416 = or i64 %414, %415
  %417 = xor i64 %395, %392
  %418 = xor i64 %417, %402
  %419 = xor i64 %418, %409
  %420 = xor i64 %419, %416
  %421 = getelementptr inbounds i8, ptr %.0, i64 40
  %422 = load i64, ptr %421, align 8, !tbaa !10
  %423 = and i64 %330, 255
  %424 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %423
  %425 = load i64, ptr %424, align 8, !tbaa !10
  %426 = lshr i64 %300, 8
  %427 = and i64 %426, 255
  %428 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %427
  %429 = load i64, ptr %428, align 8, !tbaa !10
  %430 = shl i64 %429, 8
  %431 = lshr i64 %429, 24
  %432 = or i64 %430, %431
  %433 = lshr i64 %390, 16
  %434 = and i64 %433, 255
  %435 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %434
  %436 = load i64, ptr %435, align 8, !tbaa !10
  %437 = shl i64 %436, 16
  %438 = lshr i64 %436, 16
  %439 = or i64 %437, %438
  %440 = lshr i64 %360, 24
  %441 = and i64 %440, 255
  %442 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %441
  %443 = load i64, ptr %442, align 8, !tbaa !10
  %444 = shl i64 %443, 24
  %445 = lshr i64 %443, 8
  %446 = or i64 %444, %445
  %447 = xor i64 %425, %422
  %448 = xor i64 %447, %432
  %449 = xor i64 %448, %439
  %450 = xor i64 %449, %446
  %451 = getelementptr inbounds i8, ptr %.0, i64 48
  %452 = load i64, ptr %451, align 8, !tbaa !10
  %453 = and i64 %360, 255
  %454 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %453
  %455 = load i64, ptr %454, align 8, !tbaa !10
  %456 = lshr i64 %330, 8
  %457 = and i64 %456, 255
  %458 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %457
  %459 = load i64, ptr %458, align 8, !tbaa !10
  %460 = shl i64 %459, 8
  %461 = lshr i64 %459, 24
  %462 = or i64 %460, %461
  %463 = lshr i64 %300, 16
  %464 = and i64 %463, 255
  %465 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %464
  %466 = load i64, ptr %465, align 8, !tbaa !10
  %467 = shl i64 %466, 16
  %468 = lshr i64 %466, 16
  %469 = or i64 %467, %468
  %470 = lshr i64 %390, 24
  %471 = and i64 %470, 255
  %472 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %471
  %473 = load i64, ptr %472, align 8, !tbaa !10
  %474 = shl i64 %473, 24
  %475 = lshr i64 %473, 8
  %476 = or i64 %474, %475
  %477 = xor i64 %455, %452
  %478 = xor i64 %477, %462
  %479 = xor i64 %478, %469
  %480 = xor i64 %479, %476
  %481 = getelementptr inbounds i8, ptr %.0, i64 56
  %482 = load i64, ptr %481, align 8, !tbaa !10
  %483 = and i64 %390, 255
  %484 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %483
  %485 = load i64, ptr %484, align 8, !tbaa !10
  %486 = lshr i64 %360, 8
  %487 = and i64 %486, 255
  %488 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %487
  %489 = load i64, ptr %488, align 8, !tbaa !10
  %490 = shl i64 %489, 8
  %491 = lshr i64 %489, 24
  %492 = or i64 %490, %491
  %493 = lshr i64 %330, 16
  %494 = and i64 %493, 255
  %495 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %494
  %496 = load i64, ptr %495, align 8, !tbaa !10
  %497 = shl i64 %496, 16
  %498 = lshr i64 %496, 16
  %499 = or i64 %497, %498
  %500 = lshr i64 %300, 24
  %501 = and i64 %500, 255
  %502 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %501
  %503 = load i64, ptr %502, align 8, !tbaa !10
  %504 = shl i64 %503, 24
  %505 = lshr i64 %503, 8
  %506 = or i64 %504, %505
  %507 = xor i64 %485, %482
  %508 = xor i64 %507, %492
  %509 = xor i64 %508, %499
  %510 = xor i64 %509, %506
  %511 = getelementptr inbounds i8, ptr %.0, i64 64
  br label %512

512:                                              ; preds = %271, %7
  %.sroa.176.1 = phi i64 [ %26, %7 ], [ %510, %271 ]
  %.sroa.118.1 = phi i64 [ %21, %7 ], [ %480, %271 ]
  %.sroa.60.1 = phi i64 [ %16, %7 ], [ %450, %271 ]
  %.sroa.0.1 = phi i64 [ %11, %7 ], [ %420, %271 ]
  %.1 = phi ptr [ %27, %7 ], [ %511, %271 ]
  %513 = load i64, ptr %.1, align 8, !tbaa !10
  %514 = and i64 %.sroa.0.1, 255
  %515 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %514
  %516 = load i64, ptr %515, align 8, !tbaa !10
  %517 = lshr i64 %.sroa.176.1, 8
  %518 = and i64 %517, 255
  %519 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %518
  %520 = load i64, ptr %519, align 8, !tbaa !10
  %521 = shl i64 %520, 8
  %522 = lshr i64 %520, 24
  %523 = or i64 %521, %522
  %524 = lshr i64 %.sroa.118.1, 16
  %525 = and i64 %524, 255
  %526 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %525
  %527 = load i64, ptr %526, align 8, !tbaa !10
  %528 = shl i64 %527, 16
  %529 = lshr i64 %527, 16
  %530 = or i64 %528, %529
  %531 = lshr i64 %.sroa.60.1, 24
  %532 = and i64 %531, 255
  %533 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %532
  %534 = load i64, ptr %533, align 8, !tbaa !10
  %535 = shl i64 %534, 24
  %536 = lshr i64 %534, 8
  %537 = or i64 %535, %536
  %538 = xor i64 %516, %513
  %539 = xor i64 %538, %523
  %540 = xor i64 %539, %530
  %541 = xor i64 %540, %537
  %542 = getelementptr inbounds i8, ptr %.1, i64 8
  %543 = load i64, ptr %542, align 8, !tbaa !10
  %544 = and i64 %.sroa.60.1, 255
  %545 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %544
  %546 = load i64, ptr %545, align 8, !tbaa !10
  %547 = lshr i64 %.sroa.0.1, 8
  %548 = and i64 %547, 255
  %549 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %548
  %550 = load i64, ptr %549, align 8, !tbaa !10
  %551 = shl i64 %550, 8
  %552 = lshr i64 %550, 24
  %553 = or i64 %551, %552
  %554 = lshr i64 %.sroa.176.1, 16
  %555 = and i64 %554, 255
  %556 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %555
  %557 = load i64, ptr %556, align 8, !tbaa !10
  %558 = shl i64 %557, 16
  %559 = lshr i64 %557, 16
  %560 = or i64 %558, %559
  %561 = lshr i64 %.sroa.118.1, 24
  %562 = and i64 %561, 255
  %563 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %562
  %564 = load i64, ptr %563, align 8, !tbaa !10
  %565 = shl i64 %564, 24
  %566 = lshr i64 %564, 8
  %567 = or i64 %565, %566
  %568 = xor i64 %546, %543
  %569 = xor i64 %568, %553
  %570 = xor i64 %569, %560
  %571 = xor i64 %570, %567
  %572 = getelementptr inbounds i8, ptr %.1, i64 16
  %573 = load i64, ptr %572, align 8, !tbaa !10
  %574 = and i64 %.sroa.118.1, 255
  %575 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %574
  %576 = load i64, ptr %575, align 8, !tbaa !10
  %577 = lshr i64 %.sroa.60.1, 8
  %578 = and i64 %577, 255
  %579 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %578
  %580 = load i64, ptr %579, align 8, !tbaa !10
  %581 = shl i64 %580, 8
  %582 = lshr i64 %580, 24
  %583 = or i64 %581, %582
  %584 = lshr i64 %.sroa.0.1, 16
  %585 = and i64 %584, 255
  %586 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %585
  %587 = load i64, ptr %586, align 8, !tbaa !10
  %588 = shl i64 %587, 16
  %589 = lshr i64 %587, 16
  %590 = or i64 %588, %589
  %591 = lshr i64 %.sroa.176.1, 24
  %592 = and i64 %591, 255
  %593 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %592
  %594 = load i64, ptr %593, align 8, !tbaa !10
  %595 = shl i64 %594, 24
  %596 = lshr i64 %594, 8
  %597 = or i64 %595, %596
  %598 = xor i64 %576, %573
  %599 = xor i64 %598, %583
  %600 = xor i64 %599, %590
  %601 = xor i64 %600, %597
  %602 = getelementptr inbounds i8, ptr %.1, i64 24
  %603 = load i64, ptr %602, align 8, !tbaa !10
  %604 = and i64 %.sroa.176.1, 255
  %605 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %604
  %606 = load i64, ptr %605, align 8, !tbaa !10
  %607 = lshr i64 %.sroa.118.1, 8
  %608 = and i64 %607, 255
  %609 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %608
  %610 = load i64, ptr %609, align 8, !tbaa !10
  %611 = shl i64 %610, 8
  %612 = lshr i64 %610, 24
  %613 = or i64 %611, %612
  %614 = lshr i64 %.sroa.60.1, 16
  %615 = and i64 %614, 255
  %616 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %615
  %617 = load i64, ptr %616, align 8, !tbaa !10
  %618 = shl i64 %617, 16
  %619 = lshr i64 %617, 16
  %620 = or i64 %618, %619
  %621 = lshr i64 %.sroa.0.1, 24
  %622 = and i64 %621, 255
  %623 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %622
  %624 = load i64, ptr %623, align 8, !tbaa !10
  %625 = shl i64 %624, 24
  %626 = lshr i64 %624, 8
  %627 = or i64 %625, %626
  %628 = xor i64 %606, %603
  %629 = xor i64 %628, %613
  %630 = xor i64 %629, %620
  %631 = xor i64 %630, %627
  %632 = getelementptr inbounds i8, ptr %.1, i64 32
  %633 = load i64, ptr %632, align 8, !tbaa !10
  %634 = and i64 %541, 255
  %635 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %634
  %636 = load i64, ptr %635, align 8, !tbaa !10
  %637 = lshr i64 %631, 8
  %638 = and i64 %637, 255
  %639 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %638
  %640 = load i64, ptr %639, align 8, !tbaa !10
  %641 = shl i64 %640, 8
  %642 = lshr i64 %640, 24
  %643 = or i64 %641, %642
  %644 = lshr i64 %601, 16
  %645 = and i64 %644, 255
  %646 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %645
  %647 = load i64, ptr %646, align 8, !tbaa !10
  %648 = shl i64 %647, 16
  %649 = lshr i64 %647, 16
  %650 = or i64 %648, %649
  %651 = lshr i64 %571, 24
  %652 = and i64 %651, 255
  %653 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %652
  %654 = load i64, ptr %653, align 8, !tbaa !10
  %655 = shl i64 %654, 24
  %656 = lshr i64 %654, 8
  %657 = or i64 %655, %656
  %658 = xor i64 %636, %633
  %659 = xor i64 %658, %643
  %660 = xor i64 %659, %650
  %661 = xor i64 %660, %657
  %662 = getelementptr inbounds i8, ptr %.1, i64 40
  %663 = load i64, ptr %662, align 8, !tbaa !10
  %664 = and i64 %571, 255
  %665 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %664
  %666 = load i64, ptr %665, align 8, !tbaa !10
  %667 = lshr i64 %541, 8
  %668 = and i64 %667, 255
  %669 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %668
  %670 = load i64, ptr %669, align 8, !tbaa !10
  %671 = shl i64 %670, 8
  %672 = lshr i64 %670, 24
  %673 = or i64 %671, %672
  %674 = lshr i64 %631, 16
  %675 = and i64 %674, 255
  %676 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %675
  %677 = load i64, ptr %676, align 8, !tbaa !10
  %678 = shl i64 %677, 16
  %679 = lshr i64 %677, 16
  %680 = or i64 %678, %679
  %681 = lshr i64 %601, 24
  %682 = and i64 %681, 255
  %683 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %682
  %684 = load i64, ptr %683, align 8, !tbaa !10
  %685 = shl i64 %684, 24
  %686 = lshr i64 %684, 8
  %687 = or i64 %685, %686
  %688 = xor i64 %666, %663
  %689 = xor i64 %688, %673
  %690 = xor i64 %689, %680
  %691 = xor i64 %690, %687
  %692 = getelementptr inbounds i8, ptr %.1, i64 48
  %693 = load i64, ptr %692, align 8, !tbaa !10
  %694 = and i64 %601, 255
  %695 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %694
  %696 = load i64, ptr %695, align 8, !tbaa !10
  %697 = lshr i64 %571, 8
  %698 = and i64 %697, 255
  %699 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %698
  %700 = load i64, ptr %699, align 8, !tbaa !10
  %701 = shl i64 %700, 8
  %702 = lshr i64 %700, 24
  %703 = or i64 %701, %702
  %704 = lshr i64 %541, 16
  %705 = and i64 %704, 255
  %706 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %705
  %707 = load i64, ptr %706, align 8, !tbaa !10
  %708 = shl i64 %707, 16
  %709 = lshr i64 %707, 16
  %710 = or i64 %708, %709
  %711 = lshr i64 %631, 24
  %712 = and i64 %711, 255
  %713 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %712
  %714 = load i64, ptr %713, align 8, !tbaa !10
  %715 = shl i64 %714, 24
  %716 = lshr i64 %714, 8
  %717 = or i64 %715, %716
  %718 = xor i64 %696, %693
  %719 = xor i64 %718, %703
  %720 = xor i64 %719, %710
  %721 = xor i64 %720, %717
  %722 = getelementptr inbounds i8, ptr %.1, i64 56
  %723 = load i64, ptr %722, align 8, !tbaa !10
  %724 = and i64 %631, 255
  %725 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %724
  %726 = load i64, ptr %725, align 8, !tbaa !10
  %727 = lshr i64 %601, 8
  %728 = and i64 %727, 255
  %729 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %728
  %730 = load i64, ptr %729, align 8, !tbaa !10
  %731 = shl i64 %730, 8
  %732 = lshr i64 %730, 24
  %733 = or i64 %731, %732
  %734 = lshr i64 %571, 16
  %735 = and i64 %734, 255
  %736 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %735
  %737 = load i64, ptr %736, align 8, !tbaa !10
  %738 = shl i64 %737, 16
  %739 = lshr i64 %737, 16
  %740 = or i64 %738, %739
  %741 = lshr i64 %541, 24
  %742 = and i64 %741, 255
  %743 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %742
  %744 = load i64, ptr %743, align 8, !tbaa !10
  %745 = shl i64 %744, 24
  %746 = lshr i64 %744, 8
  %747 = or i64 %745, %746
  %748 = xor i64 %726, %723
  %749 = xor i64 %748, %733
  %750 = xor i64 %749, %740
  %751 = xor i64 %750, %747
  %752 = getelementptr inbounds i8, ptr %.1, i64 64
  %753 = load i64, ptr %752, align 8, !tbaa !10
  %754 = and i64 %661, 255
  %755 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %754
  %756 = load i64, ptr %755, align 8, !tbaa !10
  %757 = lshr i64 %751, 8
  %758 = and i64 %757, 255
  %759 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %758
  %760 = load i64, ptr %759, align 8, !tbaa !10
  %761 = shl i64 %760, 8
  %762 = lshr i64 %760, 24
  %763 = or i64 %761, %762
  %764 = lshr i64 %721, 16
  %765 = and i64 %764, 255
  %766 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %765
  %767 = load i64, ptr %766, align 8, !tbaa !10
  %768 = shl i64 %767, 16
  %769 = lshr i64 %767, 16
  %770 = or i64 %768, %769
  %771 = lshr i64 %691, 24
  %772 = and i64 %771, 255
  %773 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %772
  %774 = load i64, ptr %773, align 8, !tbaa !10
  %775 = shl i64 %774, 24
  %776 = lshr i64 %774, 8
  %777 = or i64 %775, %776
  %778 = xor i64 %756, %753
  %779 = xor i64 %778, %763
  %780 = xor i64 %779, %770
  %781 = xor i64 %780, %777
  %782 = getelementptr inbounds i8, ptr %.1, i64 72
  %783 = load i64, ptr %782, align 8, !tbaa !10
  %784 = and i64 %691, 255
  %785 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %784
  %786 = load i64, ptr %785, align 8, !tbaa !10
  %787 = lshr i64 %661, 8
  %788 = and i64 %787, 255
  %789 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %788
  %790 = load i64, ptr %789, align 8, !tbaa !10
  %791 = shl i64 %790, 8
  %792 = lshr i64 %790, 24
  %793 = or i64 %791, %792
  %794 = lshr i64 %751, 16
  %795 = and i64 %794, 255
  %796 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %795
  %797 = load i64, ptr %796, align 8, !tbaa !10
  %798 = shl i64 %797, 16
  %799 = lshr i64 %797, 16
  %800 = or i64 %798, %799
  %801 = lshr i64 %721, 24
  %802 = and i64 %801, 255
  %803 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %802
  %804 = load i64, ptr %803, align 8, !tbaa !10
  %805 = shl i64 %804, 24
  %806 = lshr i64 %804, 8
  %807 = or i64 %805, %806
  %808 = xor i64 %786, %783
  %809 = xor i64 %808, %793
  %810 = xor i64 %809, %800
  %811 = xor i64 %810, %807
  %812 = getelementptr inbounds i8, ptr %.1, i64 80
  %813 = load i64, ptr %812, align 8, !tbaa !10
  %814 = and i64 %721, 255
  %815 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %814
  %816 = load i64, ptr %815, align 8, !tbaa !10
  %817 = lshr i64 %691, 8
  %818 = and i64 %817, 255
  %819 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %818
  %820 = load i64, ptr %819, align 8, !tbaa !10
  %821 = shl i64 %820, 8
  %822 = lshr i64 %820, 24
  %823 = or i64 %821, %822
  %824 = lshr i64 %661, 16
  %825 = and i64 %824, 255
  %826 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %825
  %827 = load i64, ptr %826, align 8, !tbaa !10
  %828 = shl i64 %827, 16
  %829 = lshr i64 %827, 16
  %830 = or i64 %828, %829
  %831 = lshr i64 %751, 24
  %832 = and i64 %831, 255
  %833 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %832
  %834 = load i64, ptr %833, align 8, !tbaa !10
  %835 = shl i64 %834, 24
  %836 = lshr i64 %834, 8
  %837 = or i64 %835, %836
  %838 = xor i64 %816, %813
  %839 = xor i64 %838, %823
  %840 = xor i64 %839, %830
  %841 = xor i64 %840, %837
  %842 = getelementptr inbounds i8, ptr %.1, i64 88
  %843 = load i64, ptr %842, align 8, !tbaa !10
  %844 = and i64 %751, 255
  %845 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %844
  %846 = load i64, ptr %845, align 8, !tbaa !10
  %847 = lshr i64 %721, 8
  %848 = and i64 %847, 255
  %849 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %848
  %850 = load i64, ptr %849, align 8, !tbaa !10
  %851 = shl i64 %850, 8
  %852 = lshr i64 %850, 24
  %853 = or i64 %851, %852
  %854 = lshr i64 %691, 16
  %855 = and i64 %854, 255
  %856 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %855
  %857 = load i64, ptr %856, align 8, !tbaa !10
  %858 = shl i64 %857, 16
  %859 = lshr i64 %857, 16
  %860 = or i64 %858, %859
  %861 = lshr i64 %661, 24
  %862 = and i64 %861, 255
  %863 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %862
  %864 = load i64, ptr %863, align 8, !tbaa !10
  %865 = shl i64 %864, 24
  %866 = lshr i64 %864, 8
  %867 = or i64 %865, %866
  %868 = xor i64 %846, %843
  %869 = xor i64 %868, %853
  %870 = xor i64 %869, %860
  %871 = xor i64 %870, %867
  %872 = getelementptr inbounds i8, ptr %.1, i64 96
  %873 = load i64, ptr %872, align 8, !tbaa !10
  %874 = and i64 %781, 255
  %875 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %874
  %876 = load i64, ptr %875, align 8, !tbaa !10
  %877 = lshr i64 %871, 8
  %878 = and i64 %877, 255
  %879 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %878
  %880 = load i64, ptr %879, align 8, !tbaa !10
  %881 = shl i64 %880, 8
  %882 = lshr i64 %880, 24
  %883 = or i64 %881, %882
  %884 = lshr i64 %841, 16
  %885 = and i64 %884, 255
  %886 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %885
  %887 = load i64, ptr %886, align 8, !tbaa !10
  %888 = shl i64 %887, 16
  %889 = lshr i64 %887, 16
  %890 = or i64 %888, %889
  %891 = lshr i64 %811, 24
  %892 = and i64 %891, 255
  %893 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %892
  %894 = load i64, ptr %893, align 8, !tbaa !10
  %895 = shl i64 %894, 24
  %896 = lshr i64 %894, 8
  %897 = or i64 %895, %896
  %898 = xor i64 %876, %873
  %899 = xor i64 %898, %883
  %900 = xor i64 %899, %890
  %901 = xor i64 %900, %897
  %902 = getelementptr inbounds i8, ptr %.1, i64 104
  %903 = load i64, ptr %902, align 8, !tbaa !10
  %904 = and i64 %811, 255
  %905 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %904
  %906 = load i64, ptr %905, align 8, !tbaa !10
  %907 = lshr i64 %781, 8
  %908 = and i64 %907, 255
  %909 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %908
  %910 = load i64, ptr %909, align 8, !tbaa !10
  %911 = shl i64 %910, 8
  %912 = lshr i64 %910, 24
  %913 = or i64 %911, %912
  %914 = lshr i64 %871, 16
  %915 = and i64 %914, 255
  %916 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %915
  %917 = load i64, ptr %916, align 8, !tbaa !10
  %918 = shl i64 %917, 16
  %919 = lshr i64 %917, 16
  %920 = or i64 %918, %919
  %921 = lshr i64 %841, 24
  %922 = and i64 %921, 255
  %923 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %922
  %924 = load i64, ptr %923, align 8, !tbaa !10
  %925 = shl i64 %924, 24
  %926 = lshr i64 %924, 8
  %927 = or i64 %925, %926
  %928 = xor i64 %906, %903
  %929 = xor i64 %928, %913
  %930 = xor i64 %929, %920
  %931 = xor i64 %930, %927
  %932 = getelementptr inbounds i8, ptr %.1, i64 112
  %933 = load i64, ptr %932, align 8, !tbaa !10
  %934 = and i64 %841, 255
  %935 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %934
  %936 = load i64, ptr %935, align 8, !tbaa !10
  %937 = lshr i64 %811, 8
  %938 = and i64 %937, 255
  %939 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %938
  %940 = load i64, ptr %939, align 8, !tbaa !10
  %941 = shl i64 %940, 8
  %942 = lshr i64 %940, 24
  %943 = or i64 %941, %942
  %944 = lshr i64 %781, 16
  %945 = and i64 %944, 255
  %946 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %945
  %947 = load i64, ptr %946, align 8, !tbaa !10
  %948 = shl i64 %947, 16
  %949 = lshr i64 %947, 16
  %950 = or i64 %948, %949
  %951 = lshr i64 %871, 24
  %952 = and i64 %951, 255
  %953 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %952
  %954 = load i64, ptr %953, align 8, !tbaa !10
  %955 = shl i64 %954, 24
  %956 = lshr i64 %954, 8
  %957 = or i64 %955, %956
  %958 = xor i64 %936, %933
  %959 = xor i64 %958, %943
  %960 = xor i64 %959, %950
  %961 = xor i64 %960, %957
  %962 = getelementptr inbounds i8, ptr %.1, i64 120
  %963 = load i64, ptr %962, align 8, !tbaa !10
  %964 = and i64 %871, 255
  %965 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %964
  %966 = load i64, ptr %965, align 8, !tbaa !10
  %967 = lshr i64 %841, 8
  %968 = and i64 %967, 255
  %969 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %968
  %970 = load i64, ptr %969, align 8, !tbaa !10
  %971 = shl i64 %970, 8
  %972 = lshr i64 %970, 24
  %973 = or i64 %971, %972
  %974 = lshr i64 %811, 16
  %975 = and i64 %974, 255
  %976 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %975
  %977 = load i64, ptr %976, align 8, !tbaa !10
  %978 = shl i64 %977, 16
  %979 = lshr i64 %977, 16
  %980 = or i64 %978, %979
  %981 = lshr i64 %781, 24
  %982 = and i64 %981, 255
  %983 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %982
  %984 = load i64, ptr %983, align 8, !tbaa !10
  %985 = shl i64 %984, 24
  %986 = lshr i64 %984, 8
  %987 = or i64 %985, %986
  %988 = xor i64 %966, %963
  %989 = xor i64 %988, %973
  %990 = xor i64 %989, %980
  %991 = xor i64 %990, %987
  %992 = getelementptr inbounds i8, ptr %.1, i64 128
  %993 = load i64, ptr %992, align 8, !tbaa !10
  %994 = and i64 %901, 255
  %995 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %994
  %996 = load i64, ptr %995, align 8, !tbaa !10
  %997 = lshr i64 %991, 8
  %998 = and i64 %997, 255
  %999 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %998
  %1000 = load i64, ptr %999, align 8, !tbaa !10
  %1001 = shl i64 %1000, 8
  %1002 = lshr i64 %1000, 24
  %1003 = or i64 %1001, %1002
  %1004 = lshr i64 %961, 16
  %1005 = and i64 %1004, 255
  %1006 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1005
  %1007 = load i64, ptr %1006, align 8, !tbaa !10
  %1008 = shl i64 %1007, 16
  %1009 = lshr i64 %1007, 16
  %1010 = or i64 %1008, %1009
  %1011 = lshr i64 %931, 24
  %1012 = and i64 %1011, 255
  %1013 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1012
  %1014 = load i64, ptr %1013, align 8, !tbaa !10
  %1015 = shl i64 %1014, 24
  %1016 = lshr i64 %1014, 8
  %1017 = or i64 %1015, %1016
  %1018 = xor i64 %996, %993
  %1019 = xor i64 %1018, %1003
  %1020 = xor i64 %1019, %1010
  %1021 = xor i64 %1020, %1017
  %1022 = getelementptr inbounds i8, ptr %.1, i64 136
  %1023 = load i64, ptr %1022, align 8, !tbaa !10
  %1024 = and i64 %931, 255
  %1025 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1024
  %1026 = load i64, ptr %1025, align 8, !tbaa !10
  %1027 = lshr i64 %901, 8
  %1028 = and i64 %1027, 255
  %1029 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1028
  %1030 = load i64, ptr %1029, align 8, !tbaa !10
  %1031 = shl i64 %1030, 8
  %1032 = lshr i64 %1030, 24
  %1033 = or i64 %1031, %1032
  %1034 = lshr i64 %991, 16
  %1035 = and i64 %1034, 255
  %1036 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1035
  %1037 = load i64, ptr %1036, align 8, !tbaa !10
  %1038 = shl i64 %1037, 16
  %1039 = lshr i64 %1037, 16
  %1040 = or i64 %1038, %1039
  %1041 = lshr i64 %961, 24
  %1042 = and i64 %1041, 255
  %1043 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1042
  %1044 = load i64, ptr %1043, align 8, !tbaa !10
  %1045 = shl i64 %1044, 24
  %1046 = lshr i64 %1044, 8
  %1047 = or i64 %1045, %1046
  %1048 = xor i64 %1026, %1023
  %1049 = xor i64 %1048, %1033
  %1050 = xor i64 %1049, %1040
  %1051 = xor i64 %1050, %1047
  %1052 = getelementptr inbounds i8, ptr %.1, i64 144
  %1053 = load i64, ptr %1052, align 8, !tbaa !10
  %1054 = and i64 %961, 255
  %1055 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1054
  %1056 = load i64, ptr %1055, align 8, !tbaa !10
  %1057 = lshr i64 %931, 8
  %1058 = and i64 %1057, 255
  %1059 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1058
  %1060 = load i64, ptr %1059, align 8, !tbaa !10
  %1061 = shl i64 %1060, 8
  %1062 = lshr i64 %1060, 24
  %1063 = or i64 %1061, %1062
  %1064 = lshr i64 %901, 16
  %1065 = and i64 %1064, 255
  %1066 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1065
  %1067 = load i64, ptr %1066, align 8, !tbaa !10
  %1068 = shl i64 %1067, 16
  %1069 = lshr i64 %1067, 16
  %1070 = or i64 %1068, %1069
  %1071 = lshr i64 %991, 24
  %1072 = and i64 %1071, 255
  %1073 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1072
  %1074 = load i64, ptr %1073, align 8, !tbaa !10
  %1075 = shl i64 %1074, 24
  %1076 = lshr i64 %1074, 8
  %1077 = or i64 %1075, %1076
  %1078 = xor i64 %1056, %1053
  %1079 = xor i64 %1078, %1063
  %1080 = xor i64 %1079, %1070
  %1081 = xor i64 %1080, %1077
  %1082 = getelementptr inbounds i8, ptr %.1, i64 152
  %1083 = load i64, ptr %1082, align 8, !tbaa !10
  %1084 = and i64 %991, 255
  %1085 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1084
  %1086 = load i64, ptr %1085, align 8, !tbaa !10
  %1087 = lshr i64 %961, 8
  %1088 = and i64 %1087, 255
  %1089 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1088
  %1090 = load i64, ptr %1089, align 8, !tbaa !10
  %1091 = shl i64 %1090, 8
  %1092 = lshr i64 %1090, 24
  %1093 = or i64 %1091, %1092
  %1094 = lshr i64 %931, 16
  %1095 = and i64 %1094, 255
  %1096 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1095
  %1097 = load i64, ptr %1096, align 8, !tbaa !10
  %1098 = shl i64 %1097, 16
  %1099 = lshr i64 %1097, 16
  %1100 = or i64 %1098, %1099
  %1101 = lshr i64 %901, 24
  %1102 = and i64 %1101, 255
  %1103 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1102
  %1104 = load i64, ptr %1103, align 8, !tbaa !10
  %1105 = shl i64 %1104, 24
  %1106 = lshr i64 %1104, 8
  %1107 = or i64 %1105, %1106
  %1108 = xor i64 %1086, %1083
  %1109 = xor i64 %1108, %1093
  %1110 = xor i64 %1109, %1100
  %1111 = xor i64 %1110, %1107
  %1112 = getelementptr inbounds i8, ptr %.1, i64 160
  %1113 = load i64, ptr %1112, align 8, !tbaa !10
  %1114 = and i64 %1021, 255
  %1115 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1114
  %1116 = load i64, ptr %1115, align 8, !tbaa !10
  %1117 = lshr i64 %1111, 8
  %1118 = and i64 %1117, 255
  %1119 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1118
  %1120 = load i64, ptr %1119, align 8, !tbaa !10
  %1121 = shl i64 %1120, 8
  %1122 = lshr i64 %1120, 24
  %1123 = or i64 %1121, %1122
  %1124 = lshr i64 %1081, 16
  %1125 = and i64 %1124, 255
  %1126 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1125
  %1127 = load i64, ptr %1126, align 8, !tbaa !10
  %1128 = shl i64 %1127, 16
  %1129 = lshr i64 %1127, 16
  %1130 = or i64 %1128, %1129
  %1131 = lshr i64 %1051, 24
  %1132 = and i64 %1131, 255
  %1133 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1132
  %1134 = load i64, ptr %1133, align 8, !tbaa !10
  %1135 = shl i64 %1134, 24
  %1136 = lshr i64 %1134, 8
  %1137 = or i64 %1135, %1136
  %1138 = xor i64 %1116, %1113
  %1139 = xor i64 %1138, %1123
  %1140 = xor i64 %1139, %1130
  %1141 = xor i64 %1140, %1137
  %1142 = getelementptr inbounds i8, ptr %.1, i64 168
  %1143 = load i64, ptr %1142, align 8, !tbaa !10
  %1144 = and i64 %1051, 255
  %1145 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1144
  %1146 = load i64, ptr %1145, align 8, !tbaa !10
  %1147 = lshr i64 %1021, 8
  %1148 = and i64 %1147, 255
  %1149 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1148
  %1150 = load i64, ptr %1149, align 8, !tbaa !10
  %1151 = shl i64 %1150, 8
  %1152 = lshr i64 %1150, 24
  %1153 = or i64 %1151, %1152
  %1154 = lshr i64 %1111, 16
  %1155 = and i64 %1154, 255
  %1156 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1155
  %1157 = load i64, ptr %1156, align 8, !tbaa !10
  %1158 = shl i64 %1157, 16
  %1159 = lshr i64 %1157, 16
  %1160 = or i64 %1158, %1159
  %1161 = lshr i64 %1081, 24
  %1162 = and i64 %1161, 255
  %1163 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1162
  %1164 = load i64, ptr %1163, align 8, !tbaa !10
  %1165 = shl i64 %1164, 24
  %1166 = lshr i64 %1164, 8
  %1167 = or i64 %1165, %1166
  %1168 = xor i64 %1146, %1143
  %1169 = xor i64 %1168, %1153
  %1170 = xor i64 %1169, %1160
  %1171 = xor i64 %1170, %1167
  %1172 = getelementptr inbounds i8, ptr %.1, i64 176
  %1173 = load i64, ptr %1172, align 8, !tbaa !10
  %1174 = and i64 %1081, 255
  %1175 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1174
  %1176 = load i64, ptr %1175, align 8, !tbaa !10
  %1177 = lshr i64 %1051, 8
  %1178 = and i64 %1177, 255
  %1179 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1178
  %1180 = load i64, ptr %1179, align 8, !tbaa !10
  %1181 = shl i64 %1180, 8
  %1182 = lshr i64 %1180, 24
  %1183 = or i64 %1181, %1182
  %1184 = lshr i64 %1021, 16
  %1185 = and i64 %1184, 255
  %1186 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1185
  %1187 = load i64, ptr %1186, align 8, !tbaa !10
  %1188 = shl i64 %1187, 16
  %1189 = lshr i64 %1187, 16
  %1190 = or i64 %1188, %1189
  %1191 = lshr i64 %1111, 24
  %1192 = and i64 %1191, 255
  %1193 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1192
  %1194 = load i64, ptr %1193, align 8, !tbaa !10
  %1195 = shl i64 %1194, 24
  %1196 = lshr i64 %1194, 8
  %1197 = or i64 %1195, %1196
  %1198 = xor i64 %1176, %1173
  %1199 = xor i64 %1198, %1183
  %1200 = xor i64 %1199, %1190
  %1201 = xor i64 %1200, %1197
  %1202 = getelementptr inbounds i8, ptr %.1, i64 184
  %1203 = load i64, ptr %1202, align 8, !tbaa !10
  %1204 = and i64 %1111, 255
  %1205 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1204
  %1206 = load i64, ptr %1205, align 8, !tbaa !10
  %1207 = lshr i64 %1081, 8
  %1208 = and i64 %1207, 255
  %1209 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1208
  %1210 = load i64, ptr %1209, align 8, !tbaa !10
  %1211 = shl i64 %1210, 8
  %1212 = lshr i64 %1210, 24
  %1213 = or i64 %1211, %1212
  %1214 = lshr i64 %1051, 16
  %1215 = and i64 %1214, 255
  %1216 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1215
  %1217 = load i64, ptr %1216, align 8, !tbaa !10
  %1218 = shl i64 %1217, 16
  %1219 = lshr i64 %1217, 16
  %1220 = or i64 %1218, %1219
  %1221 = lshr i64 %1021, 24
  %1222 = and i64 %1221, 255
  %1223 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1222
  %1224 = load i64, ptr %1223, align 8, !tbaa !10
  %1225 = shl i64 %1224, 24
  %1226 = lshr i64 %1224, 8
  %1227 = or i64 %1225, %1226
  %1228 = xor i64 %1206, %1203
  %1229 = xor i64 %1228, %1213
  %1230 = xor i64 %1229, %1220
  %1231 = xor i64 %1230, %1227
  %1232 = getelementptr inbounds i8, ptr %.1, i64 192
  %1233 = load i64, ptr %1232, align 8, !tbaa !10
  %1234 = and i64 %1141, 255
  %1235 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1234
  %1236 = load i64, ptr %1235, align 8, !tbaa !10
  %1237 = lshr i64 %1231, 8
  %1238 = and i64 %1237, 255
  %1239 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1238
  %1240 = load i64, ptr %1239, align 8, !tbaa !10
  %1241 = shl i64 %1240, 8
  %1242 = lshr i64 %1240, 24
  %1243 = or i64 %1241, %1242
  %1244 = lshr i64 %1201, 16
  %1245 = and i64 %1244, 255
  %1246 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1245
  %1247 = load i64, ptr %1246, align 8, !tbaa !10
  %1248 = shl i64 %1247, 16
  %1249 = lshr i64 %1247, 16
  %1250 = or i64 %1248, %1249
  %1251 = lshr i64 %1171, 24
  %1252 = and i64 %1251, 255
  %1253 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1252
  %1254 = load i64, ptr %1253, align 8, !tbaa !10
  %1255 = shl i64 %1254, 24
  %1256 = lshr i64 %1254, 8
  %1257 = or i64 %1255, %1256
  %1258 = xor i64 %1236, %1233
  %1259 = xor i64 %1258, %1243
  %1260 = xor i64 %1259, %1250
  %1261 = xor i64 %1260, %1257
  %1262 = getelementptr inbounds i8, ptr %.1, i64 200
  %1263 = load i64, ptr %1262, align 8, !tbaa !10
  %1264 = and i64 %1171, 255
  %1265 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1264
  %1266 = load i64, ptr %1265, align 8, !tbaa !10
  %1267 = lshr i64 %1141, 8
  %1268 = and i64 %1267, 255
  %1269 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1268
  %1270 = load i64, ptr %1269, align 8, !tbaa !10
  %1271 = shl i64 %1270, 8
  %1272 = lshr i64 %1270, 24
  %1273 = or i64 %1271, %1272
  %1274 = lshr i64 %1231, 16
  %1275 = and i64 %1274, 255
  %1276 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1275
  %1277 = load i64, ptr %1276, align 8, !tbaa !10
  %1278 = shl i64 %1277, 16
  %1279 = lshr i64 %1277, 16
  %1280 = or i64 %1278, %1279
  %1281 = lshr i64 %1201, 24
  %1282 = and i64 %1281, 255
  %1283 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1282
  %1284 = load i64, ptr %1283, align 8, !tbaa !10
  %1285 = shl i64 %1284, 24
  %1286 = lshr i64 %1284, 8
  %1287 = or i64 %1285, %1286
  %1288 = xor i64 %1266, %1263
  %1289 = xor i64 %1288, %1273
  %1290 = xor i64 %1289, %1280
  %1291 = xor i64 %1290, %1287
  %1292 = getelementptr inbounds i8, ptr %.1, i64 208
  %1293 = load i64, ptr %1292, align 8, !tbaa !10
  %1294 = and i64 %1201, 255
  %1295 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1294
  %1296 = load i64, ptr %1295, align 8, !tbaa !10
  %1297 = lshr i64 %1171, 8
  %1298 = and i64 %1297, 255
  %1299 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1298
  %1300 = load i64, ptr %1299, align 8, !tbaa !10
  %1301 = shl i64 %1300, 8
  %1302 = lshr i64 %1300, 24
  %1303 = or i64 %1301, %1302
  %1304 = lshr i64 %1141, 16
  %1305 = and i64 %1304, 255
  %1306 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1305
  %1307 = load i64, ptr %1306, align 8, !tbaa !10
  %1308 = shl i64 %1307, 16
  %1309 = lshr i64 %1307, 16
  %1310 = or i64 %1308, %1309
  %1311 = lshr i64 %1231, 24
  %1312 = and i64 %1311, 255
  %1313 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1312
  %1314 = load i64, ptr %1313, align 8, !tbaa !10
  %1315 = shl i64 %1314, 24
  %1316 = lshr i64 %1314, 8
  %1317 = or i64 %1315, %1316
  %1318 = xor i64 %1296, %1293
  %1319 = xor i64 %1318, %1303
  %1320 = xor i64 %1319, %1310
  %1321 = xor i64 %1320, %1317
  %1322 = getelementptr inbounds i8, ptr %.1, i64 216
  %1323 = load i64, ptr %1322, align 8, !tbaa !10
  %1324 = and i64 %1231, 255
  %1325 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1324
  %1326 = load i64, ptr %1325, align 8, !tbaa !10
  %1327 = lshr i64 %1201, 8
  %1328 = and i64 %1327, 255
  %1329 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1328
  %1330 = load i64, ptr %1329, align 8, !tbaa !10
  %1331 = shl i64 %1330, 8
  %1332 = lshr i64 %1330, 24
  %1333 = or i64 %1331, %1332
  %1334 = lshr i64 %1171, 16
  %1335 = and i64 %1334, 255
  %1336 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1335
  %1337 = load i64, ptr %1336, align 8, !tbaa !10
  %1338 = shl i64 %1337, 16
  %1339 = lshr i64 %1337, 16
  %1340 = or i64 %1338, %1339
  %1341 = lshr i64 %1141, 24
  %1342 = and i64 %1341, 255
  %1343 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1342
  %1344 = load i64, ptr %1343, align 8, !tbaa !10
  %1345 = shl i64 %1344, 24
  %1346 = lshr i64 %1344, 8
  %1347 = or i64 %1345, %1346
  %1348 = xor i64 %1326, %1323
  %1349 = xor i64 %1348, %1333
  %1350 = xor i64 %1349, %1340
  %1351 = xor i64 %1350, %1347
  %1352 = getelementptr inbounds i8, ptr %.1, i64 224
  %1353 = load i64, ptr %1352, align 8, !tbaa !10
  %1354 = and i64 %1261, 255
  %1355 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1354
  %1356 = load i64, ptr %1355, align 8, !tbaa !10
  %1357 = lshr i64 %1351, 8
  %1358 = and i64 %1357, 255
  %1359 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1358
  %1360 = load i64, ptr %1359, align 8, !tbaa !10
  %1361 = shl i64 %1360, 8
  %1362 = lshr i64 %1360, 24
  %1363 = or i64 %1361, %1362
  %1364 = lshr i64 %1321, 16
  %1365 = and i64 %1364, 255
  %1366 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1365
  %1367 = load i64, ptr %1366, align 8, !tbaa !10
  %1368 = shl i64 %1367, 16
  %1369 = lshr i64 %1367, 16
  %1370 = or i64 %1368, %1369
  %1371 = lshr i64 %1291, 24
  %1372 = and i64 %1371, 255
  %1373 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1372
  %1374 = load i64, ptr %1373, align 8, !tbaa !10
  %1375 = shl i64 %1374, 24
  %1376 = lshr i64 %1374, 8
  %1377 = or i64 %1375, %1376
  %1378 = xor i64 %1356, %1353
  %1379 = xor i64 %1378, %1363
  %1380 = xor i64 %1379, %1370
  %1381 = xor i64 %1380, %1377
  %1382 = getelementptr inbounds i8, ptr %.1, i64 232
  %1383 = load i64, ptr %1382, align 8, !tbaa !10
  %1384 = and i64 %1291, 255
  %1385 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1384
  %1386 = load i64, ptr %1385, align 8, !tbaa !10
  %1387 = lshr i64 %1261, 8
  %1388 = and i64 %1387, 255
  %1389 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1388
  %1390 = load i64, ptr %1389, align 8, !tbaa !10
  %1391 = shl i64 %1390, 8
  %1392 = lshr i64 %1390, 24
  %1393 = or i64 %1391, %1392
  %1394 = lshr i64 %1351, 16
  %1395 = and i64 %1394, 255
  %1396 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1395
  %1397 = load i64, ptr %1396, align 8, !tbaa !10
  %1398 = shl i64 %1397, 16
  %1399 = lshr i64 %1397, 16
  %1400 = or i64 %1398, %1399
  %1401 = lshr i64 %1321, 24
  %1402 = and i64 %1401, 255
  %1403 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1402
  %1404 = load i64, ptr %1403, align 8, !tbaa !10
  %1405 = shl i64 %1404, 24
  %1406 = lshr i64 %1404, 8
  %1407 = or i64 %1405, %1406
  %1408 = xor i64 %1386, %1383
  %1409 = xor i64 %1408, %1393
  %1410 = xor i64 %1409, %1400
  %1411 = xor i64 %1410, %1407
  %1412 = getelementptr inbounds i8, ptr %.1, i64 240
  %1413 = load i64, ptr %1412, align 8, !tbaa !10
  %1414 = and i64 %1321, 255
  %1415 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1414
  %1416 = load i64, ptr %1415, align 8, !tbaa !10
  %1417 = lshr i64 %1291, 8
  %1418 = and i64 %1417, 255
  %1419 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1418
  %1420 = load i64, ptr %1419, align 8, !tbaa !10
  %1421 = shl i64 %1420, 8
  %1422 = lshr i64 %1420, 24
  %1423 = or i64 %1421, %1422
  %1424 = lshr i64 %1261, 16
  %1425 = and i64 %1424, 255
  %1426 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1425
  %1427 = load i64, ptr %1426, align 8, !tbaa !10
  %1428 = shl i64 %1427, 16
  %1429 = lshr i64 %1427, 16
  %1430 = or i64 %1428, %1429
  %1431 = lshr i64 %1351, 24
  %1432 = and i64 %1431, 255
  %1433 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1432
  %1434 = load i64, ptr %1433, align 8, !tbaa !10
  %1435 = shl i64 %1434, 24
  %1436 = lshr i64 %1434, 8
  %1437 = or i64 %1435, %1436
  %1438 = xor i64 %1416, %1413
  %1439 = xor i64 %1438, %1423
  %1440 = xor i64 %1439, %1430
  %1441 = xor i64 %1440, %1437
  %1442 = getelementptr inbounds i8, ptr %.1, i64 248
  %1443 = load i64, ptr %1442, align 8, !tbaa !10
  %1444 = and i64 %1351, 255
  %1445 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1444
  %1446 = load i64, ptr %1445, align 8, !tbaa !10
  %1447 = lshr i64 %1321, 8
  %1448 = and i64 %1447, 255
  %1449 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1448
  %1450 = load i64, ptr %1449, align 8, !tbaa !10
  %1451 = shl i64 %1450, 8
  %1452 = lshr i64 %1450, 24
  %1453 = or i64 %1451, %1452
  %1454 = lshr i64 %1291, 16
  %1455 = and i64 %1454, 255
  %1456 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1455
  %1457 = load i64, ptr %1456, align 8, !tbaa !10
  %1458 = shl i64 %1457, 16
  %1459 = lshr i64 %1457, 16
  %1460 = or i64 %1458, %1459
  %1461 = lshr i64 %1261, 24
  %1462 = and i64 %1461, 255
  %1463 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1462
  %1464 = load i64, ptr %1463, align 8, !tbaa !10
  %1465 = shl i64 %1464, 24
  %1466 = lshr i64 %1464, 8
  %1467 = or i64 %1465, %1466
  %1468 = xor i64 %1446, %1443
  %1469 = xor i64 %1468, %1453
  %1470 = xor i64 %1469, %1460
  %1471 = xor i64 %1470, %1467
  %1472 = getelementptr inbounds i8, ptr %.1, i64 256
  %1473 = load i64, ptr %1472, align 8, !tbaa !10
  %1474 = and i64 %1381, 255
  %1475 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1474
  %1476 = load i64, ptr %1475, align 8, !tbaa !10
  %1477 = lshr i64 %1471, 8
  %1478 = and i64 %1477, 255
  %1479 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1478
  %1480 = load i64, ptr %1479, align 8, !tbaa !10
  %1481 = shl i64 %1480, 8
  %1482 = lshr i64 %1480, 24
  %1483 = or i64 %1481, %1482
  %1484 = lshr i64 %1441, 16
  %1485 = and i64 %1484, 255
  %1486 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1485
  %1487 = load i64, ptr %1486, align 8, !tbaa !10
  %1488 = shl i64 %1487, 16
  %1489 = lshr i64 %1487, 16
  %1490 = or i64 %1488, %1489
  %1491 = lshr i64 %1411, 24
  %1492 = and i64 %1491, 255
  %1493 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1492
  %1494 = load i64, ptr %1493, align 8, !tbaa !10
  %1495 = shl i64 %1494, 24
  %1496 = lshr i64 %1494, 8
  %1497 = or i64 %1495, %1496
  %1498 = xor i64 %1476, %1473
  %1499 = xor i64 %1498, %1483
  %1500 = xor i64 %1499, %1490
  %1501 = xor i64 %1500, %1497
  %1502 = getelementptr inbounds i8, ptr %.1, i64 264
  %1503 = load i64, ptr %1502, align 8, !tbaa !10
  %1504 = and i64 %1411, 255
  %1505 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1504
  %1506 = load i64, ptr %1505, align 8, !tbaa !10
  %1507 = lshr i64 %1381, 8
  %1508 = and i64 %1507, 255
  %1509 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1508
  %1510 = load i64, ptr %1509, align 8, !tbaa !10
  %1511 = shl i64 %1510, 8
  %1512 = lshr i64 %1510, 24
  %1513 = or i64 %1511, %1512
  %1514 = lshr i64 %1471, 16
  %1515 = and i64 %1514, 255
  %1516 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1515
  %1517 = load i64, ptr %1516, align 8, !tbaa !10
  %1518 = shl i64 %1517, 16
  %1519 = lshr i64 %1517, 16
  %1520 = or i64 %1518, %1519
  %1521 = lshr i64 %1441, 24
  %1522 = and i64 %1521, 255
  %1523 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1522
  %1524 = load i64, ptr %1523, align 8, !tbaa !10
  %1525 = shl i64 %1524, 24
  %1526 = lshr i64 %1524, 8
  %1527 = or i64 %1525, %1526
  %1528 = xor i64 %1506, %1503
  %1529 = xor i64 %1528, %1513
  %1530 = xor i64 %1529, %1520
  %1531 = xor i64 %1530, %1527
  %1532 = getelementptr inbounds i8, ptr %.1, i64 272
  %1533 = load i64, ptr %1532, align 8, !tbaa !10
  %1534 = and i64 %1441, 255
  %1535 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1534
  %1536 = load i64, ptr %1535, align 8, !tbaa !10
  %1537 = lshr i64 %1411, 8
  %1538 = and i64 %1537, 255
  %1539 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1538
  %1540 = load i64, ptr %1539, align 8, !tbaa !10
  %1541 = shl i64 %1540, 8
  %1542 = lshr i64 %1540, 24
  %1543 = or i64 %1541, %1542
  %1544 = lshr i64 %1381, 16
  %1545 = and i64 %1544, 255
  %1546 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1545
  %1547 = load i64, ptr %1546, align 8, !tbaa !10
  %1548 = shl i64 %1547, 16
  %1549 = lshr i64 %1547, 16
  %1550 = or i64 %1548, %1549
  %1551 = lshr i64 %1471, 24
  %1552 = and i64 %1551, 255
  %1553 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1552
  %1554 = load i64, ptr %1553, align 8, !tbaa !10
  %1555 = shl i64 %1554, 24
  %1556 = lshr i64 %1554, 8
  %1557 = or i64 %1555, %1556
  %1558 = xor i64 %1536, %1533
  %1559 = xor i64 %1558, %1543
  %1560 = xor i64 %1559, %1550
  %1561 = xor i64 %1560, %1557
  %1562 = getelementptr inbounds i8, ptr %.1, i64 280
  %1563 = load i64, ptr %1562, align 8, !tbaa !10
  %1564 = and i64 %1471, 255
  %1565 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1564
  %1566 = load i64, ptr %1565, align 8, !tbaa !10
  %1567 = lshr i64 %1441, 8
  %1568 = and i64 %1567, 255
  %1569 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1568
  %1570 = load i64, ptr %1569, align 8, !tbaa !10
  %1571 = shl i64 %1570, 8
  %1572 = lshr i64 %1570, 24
  %1573 = or i64 %1571, %1572
  %1574 = lshr i64 %1411, 16
  %1575 = and i64 %1574, 255
  %1576 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1575
  %1577 = load i64, ptr %1576, align 8, !tbaa !10
  %1578 = shl i64 %1577, 16
  %1579 = lshr i64 %1577, 16
  %1580 = or i64 %1578, %1579
  %1581 = lshr i64 %1381, 24
  %1582 = and i64 %1581, 255
  %1583 = getelementptr inbounds [256 x i64], ptr @it_tab, i64 0, i64 %1582
  %1584 = load i64, ptr %1583, align 8, !tbaa !10
  %1585 = shl i64 %1584, 24
  %1586 = lshr i64 %1584, 8
  %1587 = or i64 %1585, %1586
  %1588 = xor i64 %1566, %1563
  %1589 = xor i64 %1588, %1573
  %1590 = xor i64 %1589, %1580
  %1591 = xor i64 %1590, %1587
  %1592 = getelementptr inbounds i8, ptr %.1, i64 288
  %1593 = load i64, ptr %1592, align 8, !tbaa !10
  %1594 = and i64 %1501, 255
  %1595 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1594
  %1596 = load i64, ptr %1595, align 8, !tbaa !10
  %1597 = lshr i64 %1591, 8
  %1598 = and i64 %1597, 255
  %1599 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1598
  %1600 = load i64, ptr %1599, align 8, !tbaa !10
  %1601 = shl i64 %1600, 8
  %1602 = lshr i64 %1561, 16
  %1603 = and i64 %1602, 255
  %1604 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1603
  %1605 = load i64, ptr %1604, align 8, !tbaa !10
  %1606 = shl i64 %1605, 16
  %1607 = lshr i64 %1531, 24
  %1608 = and i64 %1607, 255
  %1609 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1608
  %1610 = load i64, ptr %1609, align 8, !tbaa !10
  %1611 = shl i64 %1610, 24
  %1612 = xor i64 %1596, %1593
  %1613 = xor i64 %1612, %1601
  %1614 = xor i64 %1613, %1606
  %1615 = xor i64 %1614, %1611
  %1616 = getelementptr inbounds i8, ptr %.1, i64 296
  %1617 = load i64, ptr %1616, align 8, !tbaa !10
  %1618 = and i64 %1531, 255
  %1619 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1618
  %1620 = load i64, ptr %1619, align 8, !tbaa !10
  %1621 = lshr i64 %1501, 8
  %1622 = and i64 %1621, 255
  %1623 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1622
  %1624 = load i64, ptr %1623, align 8, !tbaa !10
  %1625 = shl i64 %1624, 8
  %1626 = lshr i64 %1591, 16
  %1627 = and i64 %1626, 255
  %1628 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1627
  %1629 = load i64, ptr %1628, align 8, !tbaa !10
  %1630 = shl i64 %1629, 16
  %1631 = lshr i64 %1561, 24
  %1632 = and i64 %1631, 255
  %1633 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1632
  %1634 = load i64, ptr %1633, align 8, !tbaa !10
  %1635 = shl i64 %1634, 24
  %1636 = xor i64 %1620, %1617
  %1637 = xor i64 %1636, %1625
  %1638 = xor i64 %1637, %1630
  %1639 = xor i64 %1638, %1635
  %1640 = getelementptr inbounds i8, ptr %.1, i64 304
  %1641 = load i64, ptr %1640, align 8, !tbaa !10
  %1642 = and i64 %1561, 255
  %1643 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1642
  %1644 = load i64, ptr %1643, align 8, !tbaa !10
  %1645 = lshr i64 %1531, 8
  %1646 = and i64 %1645, 255
  %1647 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1646
  %1648 = load i64, ptr %1647, align 8, !tbaa !10
  %1649 = shl i64 %1648, 8
  %1650 = lshr i64 %1501, 16
  %1651 = and i64 %1650, 255
  %1652 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1651
  %1653 = load i64, ptr %1652, align 8, !tbaa !10
  %1654 = shl i64 %1653, 16
  %1655 = lshr i64 %1591, 24
  %1656 = and i64 %1655, 255
  %1657 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1656
  %1658 = load i64, ptr %1657, align 8, !tbaa !10
  %1659 = shl i64 %1658, 24
  %1660 = xor i64 %1644, %1641
  %1661 = xor i64 %1660, %1649
  %1662 = xor i64 %1661, %1654
  %1663 = xor i64 %1662, %1659
  %1664 = getelementptr inbounds i8, ptr %.1, i64 312
  %1665 = load i64, ptr %1664, align 8, !tbaa !10
  %1666 = and i64 %1591, 255
  %1667 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1666
  %1668 = load i64, ptr %1667, align 8, !tbaa !10
  %1669 = lshr i64 %1561, 8
  %1670 = and i64 %1669, 255
  %1671 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1670
  %1672 = load i64, ptr %1671, align 8, !tbaa !10
  %1673 = shl i64 %1672, 8
  %1674 = lshr i64 %1531, 16
  %1675 = and i64 %1674, 255
  %1676 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1675
  %1677 = load i64, ptr %1676, align 8, !tbaa !10
  %1678 = shl i64 %1677, 16
  %1679 = lshr i64 %1501, 24
  %1680 = and i64 %1679, 255
  %1681 = getelementptr inbounds [256 x i64], ptr @il_tab, i64 0, i64 %1680
  %1682 = load i64, ptr %1681, align 8, !tbaa !10
  %1683 = shl i64 %1682, 24
  %1684 = xor i64 %1668, %1665
  %1685 = xor i64 %1684, %1673
  %1686 = xor i64 %1685, %1678
  %1687 = xor i64 %1686, %1683
  br label %1688

1688:                                             ; preds = %512, %7
  %.sroa.176.2 = phi i64 [ %26, %7 ], [ %1687, %512 ]
  %.sroa.118.2 = phi i64 [ %21, %7 ], [ %1663, %512 ]
  %.sroa.60.2 = phi i64 [ %16, %7 ], [ %1639, %512 ]
  %.sroa.0.2 = phi i64 [ %11, %7 ], [ %1615, %512 ]
  store i64 %.sroa.0.2, ptr %1, align 8, !tbaa !10
  %1689 = getelementptr inbounds i8, ptr %1, i64 4
  store i64 %.sroa.60.2, ptr %1689, align 8, !tbaa !10
  %1690 = getelementptr inbounds i8, ptr %1, i64 8
  store i64 %.sroa.118.2, ptr %1690, align 8, !tbaa !10
  %1691 = getelementptr inbounds i8, ptr %1, i64 12
  store i64 %.sroa.176.2, ptr %1691, align 8, !tbaa !10
  br label %1692

1692:                                             ; preds = %3, %1688
  %.0451 = phi i16 [ 1, %1688 ], [ 0, %3 ]
  ret i16 %.0451
}

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !8, i64 1040}
!6 = !{!"", !7, i64 0, !7, i64 8, !8, i64 16, !8, i64 528, !8, i64 1040}
!7 = !{!"long", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!7, !7, i64 0}
!11 = !{!6, !7, i64 8}


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