; LLVM IR from Aeternum-Veritas/Merry :: merry (merry_nreader)

; 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.MerryReader = type { i8, i8, i8, i8, %struct.MerryInstSection, %struct.MerryEAT, %struct.MerrySsT, %struct.MerryST, ptr, [2 x i64], i64, i64, ptr, i64, ptr, i64, ptr, ptr, ptr, ptr, i64, i64 }
%struct.MerryInstSection = type { i64, ptr, i64, i64 }
%struct.MerryEAT = type { ptr, i64, i64 }
%struct.MerrySsT = type { i64, i64, ptr, i8 }
%struct.MerryST = type { ptr, i64 }

@stdout = external global ptr, align 8
@stderr = external global ptr, align 8
@.str.11 = external hidden unnamed_addr constant [42 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [99 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [76 x i8], align 1

; Function Attrs: nounwind
declare i32 @fprintf(ptr noundef, ptr noundef, ...) #0

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

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

; Function Attrs: nounwind uwtable
define dso_local zeroext i8 @merry_reader_read_header(ptr noundef %0) #2 {
  %2 = alloca i8, align 1
  %3 = alloca ptr, align 8
  %4 = alloca [40 x i8], align 16
  %5 = alloca i32, align 4
  %6 = alloca i64, align 8
  store ptr %0, ptr %3, align 8, !tbaa !5
  %7 = load ptr, ptr @stdout, align 8, !tbaa !5
  %8 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %7, ptr noundef @.str.11, ptr noundef null) #4
  call void @llvm.lifetime.start.p0(i64 40, ptr %4) #4
  %9 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 0
  %10 = load ptr, ptr %3, align 8, !tbaa !5
  %11 = getelementptr inbounds %struct.MerryReader, ptr %10, i32 0, i32 12
  %12 = load ptr, ptr %11, align 8, !tbaa !9
  %13 = call i64 @fread(ptr noundef %9, i64 noundef 1, i64 noundef 40, ptr noundef %12)
  %14 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 0
  %15 = load i8, ptr %14, align 16, !tbaa !16
  %16 = zext i8 %15 to i32
  %17 = icmp ne i32 %16, 77
  br i1 %17, label %18, label %31

18:                                               ; preds = %1
  %19 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 1
  %20 = load i8, ptr %19, align 1, !tbaa !16
  %21 = zext i8 %20 to i32
  %22 = icmp ne i32 %21, 73
  br i1 %22, label %23, label %31

23:                                               ; preds = %18
  %24 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 2
  %25 = load i8, ptr %24, align 2, !tbaa !16
  %26 = zext i8 %25 to i32
  %27 = icmp ne i32 %26, 78
  br i1 %27, label %28, label %31

28:                                               ; preds = %23
  %29 = load ptr, ptr @stderr, align 8, !tbaa !5
  %30 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %29, ptr noundef @.str.12) #4
  store i8 1, ptr %2, align 1
  store i32 1, ptr %5, align 4
  br label %322

31:                                               ; preds = %23, %18, %1
  %32 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 7
  %33 = load i8, ptr %32, align 1, !tbaa !16
  %34 = zext i8 %33 to i32
  %35 = and i32 %34, 1
  %36 = icmp eq i32 %35, 1
  br i1 %36, label %37, label %40

37:                                               ; preds = %31
  %38 = load ptr, ptr %3, align 8, !tbaa !5
  %39 = getelementptr inbounds %struct.MerryReader, ptr %38, i32 0, i32 1
  store i8 1, ptr %39, align 1, !tbaa !17
  br label %40

40:                                               ; preds = %37, %31
  %41 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 6
  %42 = load i8, ptr %41, align 2, !tbaa !16
  %43 = zext i8 %42 to i32
  %44 = and i32 %43, 1
  %45 = icmp eq i32 %44, 1
  br i1 %45, label %46, label %49

46:                                               ; preds = %40
  %47 = load ptr, ptr %3, align 8, !tbaa !5
  %48 = getelementptr inbounds %struct.MerryReader, ptr %47, i32 0, i32 0
  store i8 1, ptr %48, align 8, !tbaa !18
  br label %49

49:                                               ; preds = %46, %40
  %50 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 6
  %51 = load i8, ptr %50, align 2, !tbaa !16
  %52 = zext i8 %51 to i32
  %53 = ashr i32 %52, 1
  %54 = and i32 %53, 1
  %55 = icmp eq i32 %54, 1
  br i1 %55, label %56, label %59

56:                                               ; preds = %49
  %57 = load ptr, ptr %3, align 8, !tbaa !5
  %58 = getelementptr inbounds %struct.MerryReader, ptr %57, i32 0, i32 2
  store i8 1, ptr %58, align 2, !tbaa !19
  br label %59

59:                                               ; preds = %56, %49
  %60 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 6
  %61 = load i8, ptr %60, align 2, !tbaa !16
  %62 = zext i8 %61 to i32
  %63 = ashr i32 %62, 2
  %64 = and i32 %63, 1
  %65 = icmp eq i32 %64, 1
  br i1 %65, label %66, label %69

66:                                               ; preds = %59
  %67 = load ptr, ptr %3, align 8, !tbaa !5
  %68 = getelementptr inbounds %struct.MerryReader, ptr %67, i32 0, i32 3
  store i8 1, ptr %68, align 1, !tbaa !20
  br label %69

69:                                               ; preds = %66, %59
  call void @llvm.lifetime.start.p0(i64 8, ptr %6) #4
  store i64 0, ptr %6, align 8, !tbaa !21
  %70 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 8
  %71 = load i8, ptr %70, align 8, !tbaa !16
  %72 = zext i8 %71 to i64
  store i64 %72, ptr %6, align 8, !tbaa !21
  %73 = load i64, ptr %6, align 8, !tbaa !21
  %74 = shl i64 %73, 8
  store i64 %74, ptr %6, align 8, !tbaa !21
  %75 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 9
  %76 = load i8, ptr %75, align 1, !tbaa !16
  %77 = zext i8 %76 to i64
  %78 = load i64, ptr %6, align 8, !tbaa !21
  %79 = or i64 %78, %77
  store i64 %79, ptr %6, align 8, !tbaa !21
  %80 = load i64, ptr %6, align 8, !tbaa !21
  %81 = shl i64 %80, 8
  store i64 %81, ptr %6, align 8, !tbaa !21
  %82 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 10
  %83 = load i8, ptr %82, align 2, !tbaa !16
  %84 = zext i8 %83 to i64
  %85 = load i64, ptr %6, align 8, !tbaa !21
  %86 = or i64 %85, %84
  store i64 %86, ptr %6, align 8, !tbaa !21
  %87 = load i64, ptr %6, align 8, !tbaa !21
  %88 = shl i64 %87, 8
  store i64 %88, ptr %6, align 8, !tbaa !21
  %89 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 11
  %90 = load i8, ptr %89, align 1, !tbaa !16
  %91 = zext i8 %90 to i64
  %92 = load i64, ptr %6, align 8, !tbaa !21
  %93 = or i64 %92, %91
  store i64 %93, ptr %6, align 8, !tbaa !21
  %94 = load i64, ptr %6, align 8, !tbaa !21
  %95 = shl i64 %94, 8
  store i64 %95, ptr %6, align 8, !tbaa !21
  %96 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 12
  %97 = load i8, ptr %96, align 4, !tbaa !16
  %98 = zext i8 %97 to i64
  %99 = load i64, ptr %6, align 8, !tbaa !21
  %100 = or i64 %99, %98
  store i64 %100, ptr %6, align 8, !tbaa !21
  %101 = load i64, ptr %6, align 8, !tbaa !21
  %102 = shl i64 %101, 8
  store i64 %102, ptr %6, align 8, !tbaa !21
  %103 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 13
  %104 = load i8, ptr %103, align 1, !tbaa !16
  %105 = zext i8 %104 to i64
  %106 = load i64, ptr %6, align 8, !tbaa !21
  %107 = or i64 %106, %105
  store i64 %107, ptr %6, align 8, !tbaa !21
  %108 = load i64, ptr %6, align 8, !tbaa !21
  %109 = shl i64 %108, 8
  store i64 %109, ptr %6, align 8, !tbaa !21
  %110 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 14
  %111 = load i8, ptr %110, align 2, !tbaa !16
  %112 = zext i8 %111 to i64
  %113 = load i64, ptr %6, align 8, !tbaa !21
  %114 = or i64 %113, %112
  store i64 %114, ptr %6, align 8, !tbaa !21
  %115 = load i64, ptr %6, align 8, !tbaa !21
  %116 = shl i64 %115, 8
  store i64 %116, ptr %6, align 8, !tbaa !21
  %117 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 15
  %118 = load i8, ptr %117, align 1, !tbaa !16
  %119 = zext i8 %118 to i64
  %120 = load i64, ptr %6, align 8, !tbaa !21
  %121 = or i64 %120, %119
  store i64 %121, ptr %6, align 8, !tbaa !21
  %122 = load i64, ptr %6, align 8, !tbaa !21
  %123 = load ptr, ptr %3, align 8, !tbaa !5
  %124 = getelementptr inbounds %struct.MerryReader, ptr %123, i32 0, i32 4
  %125 = getelementptr inbounds %struct.MerryInstSection, ptr %124, i32 0, i32 0
  store i64 %122, ptr %125, align 8, !tbaa !22
  %126 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 16
  %127 = load i8, ptr %126, align 16, !tbaa !16
  %128 = zext i8 %127 to i64
  store i64 %128, ptr %6, align 8, !tbaa !21
  %129 = load i64, ptr %6, align 8, !tbaa !21
  %130 = shl i64 %129, 8
  store i64 %130, ptr %6, align 8, !tbaa !21
  %131 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 17
  %132 = load i8, ptr %131, align 1, !tbaa !16
  %133 = zext i8 %132 to i64
  %134 = load i64, ptr %6, align 8, !tbaa !21
  %135 = or i64 %134, %133
  store i64 %135, ptr %6, align 8, !tbaa !21
  %136 = load i64, ptr %6, align 8, !tbaa !21
  %137 = shl i64 %136, 8
  store i64 %137, ptr %6, align 8, !tbaa !21
  %138 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 18
  %139 = load i8, ptr %138, align 2, !tbaa !16
  %140 = zext i8 %139 to i64
  %141 = load i64, ptr %6, align 8, !tbaa !21
  %142 = or i64 %141, %140
  store i64 %142, ptr %6, align 8, !tbaa !21
  %143 = load i64, ptr %6, align 8, !tbaa !21
  %144 = shl i64 %143, 8
  store i64 %144, ptr %6, align 8, !tbaa !21
  %145 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 19
  %146 = load i8, ptr %145, align 1, !tbaa !16
  %147 = zext i8 %146 to i64
  %148 = load i64, ptr %6, align 8, !tbaa !21
  %149 = or i64 %148, %147
  store i64 %149, ptr %6, align 8, !tbaa !21
  %150 = load i64, ptr %6, align 8, !tbaa !21
  %151 = shl i64 %150, 8
  store i64 %151, ptr %6, align 8, !tbaa !21
  %152 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 20
  %153 = load i8, ptr %152, align 4, !tbaa !16
  %154 = zext i8 %153 to i64
  %155 = load i64, ptr %6, align 8, !tbaa !21
  %156 = or i64 %155, %154
  store i64 %156, ptr %6, align 8, !tbaa !21
  %157 = load i64, ptr %6, align 8, !tbaa !21
  %158 = shl i64 %157, 8
  store i64 %158, ptr %6, align 8, !tbaa !21
  %159 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 21
  %160 = load i8, ptr %159, align 1, !tbaa !16
  %161 = zext i8 %160 to i64
  %162 = load i64, ptr %6, align 8, !tbaa !21
  %163 = or i64 %162, %161
  store i64 %163, ptr %6, align 8, !tbaa !21
  %164 = load i64, ptr %6, align 8, !tbaa !21
  %165 = shl i64 %164, 8
  store i64 %165, ptr %6, align 8, !tbaa !21
  %166 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 22
  %167 = load i8, ptr %166, align 2, !tbaa !16
  %168 = zext i8 %167 to i64
  %169 = load i64, ptr %6, align 8, !tbaa !21
  %170 = or i64 %169, %168
  store i64 %170, ptr %6, align 8, !tbaa !21
  %171 = load i64, ptr %6, align 8, !tbaa !21
  %172 = shl i64 %171, 8
  store i64 %172, ptr %6, align 8, !tbaa !21
  %173 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 23
  %174 = load i8, ptr %173, align 1, !tbaa !16
  %175 = zext i8 %174 to i64
  %176 = load i64, ptr %6, align 8, !tbaa !21
  %177 = or i64 %176, %175
  store i64 %177, ptr %6, align 8, !tbaa !21
  %178 = load i64, ptr %6, align 8, !tbaa !21
  %179 = load ptr, ptr %3, align 8, !tbaa !5
  %180 = getelementptr inbounds %struct.MerryReader, ptr %179, i32 0, i32 5
  %181 = getelementptr inbounds %struct.MerryEAT, ptr %180, i32 0, i32 2
  store i64 %178, ptr %181, align 8, !tbaa !23
  %182 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 24
  %183 = load i8, ptr %182, align 8, !tbaa !16
  %184 = zext i8 %183 to i64
  store i64 %184, ptr %6, align 8, !tbaa !21
  %185 = load i64, ptr %6, align 8, !tbaa !21
  %186 = shl i64 %185, 8
  store i64 %186, ptr %6, align 8, !tbaa !21
  %187 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 25
  %188 = load i8, ptr %187, align 1, !tbaa !16
  %189 = zext i8 %188 to i64
  %190 = load i64, ptr %6, align 8, !tbaa !21
  %191 = or i64 %190, %189
  store i64 %191, ptr %6, align 8, !tbaa !21
  %192 = load i64, ptr %6, align 8, !tbaa !21
  %193 = shl i64 %192, 8
  store i64 %193, ptr %6, align 8, !tbaa !21
  %194 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 26
  %195 = load i8, ptr %194, align 2, !tbaa !16
  %196 = zext i8 %195 to i64
  %197 = load i64, ptr %6, align 8, !tbaa !21
  %198 = or i64 %197, %196
  store i64 %198, ptr %6, align 8, !tbaa !21
  %199 = load i64, ptr %6, align 8, !tbaa !21
  %200 = shl i64 %199, 8
  store i64 %200, ptr %6, align 8, !tbaa !21
  %201 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 27
  %202 = load i8, ptr %201, align 1, !tbaa !16
  %203 = zext i8 %202 to i64
  %204 = load i64, ptr %6, align 8, !tbaa !21
  %205 = or i64 %204, %203
  store i64 %205, ptr %6, align 8, !tbaa !21
  %206 = load i64, ptr %6, align 8, !tbaa !21
  %207 = shl i64 %206, 8
  store i64 %207, ptr %6, align 8, !tbaa !21
  %208 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 28
  %209 = load i8, ptr %208, align 4, !tbaa !16
  %210 = zext i8 %209 to i64
  %211 = load i64, ptr %6, align 8, !tbaa !21
  %212 = or i64 %211, %210
  store i64 %212, ptr %6, align 8, !tbaa !21
  %213 = load i64, ptr %6, align 8, !tbaa !21
  %214 = shl i64 %213, 8
  store i64 %214, ptr %6, align 8, !tbaa !21
  %215 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 29
  %216 = load i8, ptr %215, align 1, !tbaa !16
  %217 = zext i8 %216 to i64
  %218 = load i64, ptr %6, align 8, !tbaa !21
  %219 = or i64 %218, %217
  store i64 %219, ptr %6, align 8, !tbaa !21
  %220 = load i64, ptr %6, align 8, !tbaa !21
  %221 = shl i64 %220, 8
  store i64 %221, ptr %6, align 8, !tbaa !21
  %222 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 30
  %223 = load i8, ptr %222, align 2, !tbaa !16
  %224 = zext i8 %223 to i64
  %225 = load i64, ptr %6, align 8, !tbaa !21
  %226 = or i64 %225, %224
  store i64 %226, ptr %6, align 8, !tbaa !21
  %227 = load i64, ptr %6, align 8, !tbaa !21
  %228 = shl i64 %227, 8
  store i64 %228, ptr %6, align 8, !tbaa !21
  %229 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 31
  %230 = load i8, ptr %229, align 1, !tbaa !16
  %231 = zext i8 %230 to i64
  %232 = load i64, ptr %6, align 8, !tbaa !21
  %233 = or i64 %232, %231
  store i64 %233, ptr %6, align 8, !tbaa !21
  %234 = load i64, ptr %6, align 8, !tbaa !21
  %235 = load ptr, ptr %3, align 8, !tbaa !5
  %236 = getelementptr inbounds %struct.MerryReader, ptr %235, i32 0, i32 6
  %237 = getelementptr inbounds %struct.MerrySsT, ptr %236, i32 0, i32 0
  store i64 %234, ptr %237, align 8, !tbaa !24
  %238 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 32
  %239 = load i8, ptr %238, align 16, !tbaa !16
  %240 = zext i8 %239 to i64
  store i64 %240, ptr %6, align 8, !tbaa !21
  %241 = load i64, ptr %6, align 8, !tbaa !21
  %242 = shl i64 %241, 8
  store i64 %242, ptr %6, align 8, !tbaa !21
  %243 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 33
  %244 = load i8, ptr %243, align 1, !tbaa !16
  %245 = zext i8 %244 to i64
  %246 = load i64, ptr %6, align 8, !tbaa !21
  %247 = or i64 %246, %245
  store i64 %247, ptr %6, align 8, !tbaa !21
  %248 = load i64, ptr %6, align 8, !tbaa !21
  %249 = shl i64 %248, 8
  store i64 %249, ptr %6, align 8, !tbaa !21
  %250 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 34
  %251 = load i8, ptr %250, align 2, !tbaa !16
  %252 = zext i8 %251 to i64
  %253 = load i64, ptr %6, align 8, !tbaa !21
  %254 = or i64 %253, %252
  store i64 %254, ptr %6, align 8, !tbaa !21
  %255 = load i64, ptr %6, align 8, !tbaa !21
  %256 = shl i64 %255, 8
  store i64 %256, ptr %6, align 8, !tbaa !21
  %257 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 35
  %258 = load i8, ptr %257, align 1, !tbaa !16
  %259 = zext i8 %258 to i64
  %260 = load i64, ptr %6, align 8, !tbaa !21
  %261 = or i64 %260, %259
  store i64 %261, ptr %6, align 8, !tbaa !21
  %262 = load i64, ptr %6, align 8, !tbaa !21
  %263 = shl i64 %262, 8
  store i64 %263, ptr %6, align 8, !tbaa !21
  %264 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 36
  %265 = load i8, ptr %264, align 4, !tbaa !16
  %266 = zext i8 %265 to i64
  %267 = load i64, ptr %6, align 8, !tbaa !21
  %268 = or i64 %267, %266
  store i64 %268, ptr %6, align 8, !tbaa !21
  %269 = load i64, ptr %6, align 8, !tbaa !21
  %270 = shl i64 %269, 8
  store i64 %270, ptr %6, align 8, !tbaa !21
  %271 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 37
  %272 = load i8, ptr %271, align 1, !tbaa !16
  %273 = zext i8 %272 to i64
  %274 = load i64, ptr %6, align 8, !tbaa !21
  %275 = or i64 %274, %273
  store i64 %275, ptr %6, align 8, !tbaa !21
  %276 = load i64, ptr %6, align 8, !tbaa !21
  %277 = shl i64 %276, 8
  store i64 %277, ptr %6, align 8, !tbaa !21
  %278 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 38
  %279 = load i8, ptr %278, align 2, !tbaa !16
  %280 = zext i8 %279 to i64
  %281 = load i64, ptr %6, align 8, !tbaa !21
  %282 = or i64 %281, %280
  store i64 %282, ptr %6, align 8, !tbaa !21
  %283 = load i64, ptr %6, align 8, !tbaa !21
  %284 = shl i64 %283, 8
  store i64 %284, ptr %6, align 8, !tbaa !21
  %285 = getelementptr inbounds [40 x i8], ptr %4, i64 0, i64 39
  %286 = load i8, ptr %285, align 1, !tbaa !16
  %287 = zext i8 %286 to i64
  %288 = load i64, ptr %6, align 8, !tbaa !21
  %289 = or i64 %288, %287
  store i64 %289, ptr %6, align 8, !tbaa !21
  %290 = load i64, ptr %6, align 8, !tbaa !21
  %291 = load ptr, ptr %3, align 8, !tbaa !5
  %292 = getelementptr inbounds %struct.MerryReader, ptr %291, i32 0, i32 7
  %293 = getelementptr inbounds %struct.MerryST, ptr %292, i32 0, i32 1
  store i64 %290, ptr %293, align 8, !tbaa !25
  %294 = load ptr, ptr %3, align 8, !tbaa !5
  %295 = getelementptr inbounds %struct.MerryReader, ptr %294, i32 0, i32 4
  %296 = getelementptr inbounds %struct.MerryInstSection, ptr %295, i32 0, i32 0
  %297 = load i64, ptr %296, align 8, !tbaa !22
  %298 = load ptr, ptr %3, align 8, !tbaa !5
  %299 = getelementptr inbounds %struct.MerryReader, ptr %298, i32 0, i32 5
  %300 = getelementptr inbounds %struct.MerryEAT, ptr %299, i32 0, i32 2
  %301 = load i64, ptr %300, align 8, !tbaa !23
  %302 = add i64 %297, %301
  %303 = load ptr, ptr %3, align 8, !tbaa !5
  %304 = getelementptr inbounds %struct.MerryReader, ptr %303, i32 0, i32 6
  %305 = getelementptr inbounds %struct.MerrySsT, ptr %304, i32 0, i32 0
  %306 = load i64, ptr %305, align 8, !tbaa !24
  %307 = add i64 %302, %306
  %308 = load ptr, ptr %3, align 8, !tbaa !5
  %309 = getelementptr inbounds %struct.MerryReader, ptr %308, i32 0, i32 7
  %310 = getelementptr inbounds %struct.MerryST, ptr %309, i32 0, i32 1
  %311 = load i64, ptr %310, align 8, !tbaa !25
  %312 = add i64 %307, %311
  %313 = load ptr, ptr %3, align 8, !tbaa !5
  %314 = getelementptr inbounds %struct.MerryReader, ptr %313, i32 0, i32 13
  %315 = load i64, ptr %314, align 8, !tbaa !26
  %316 = icmp ugt i64 %312, %315
  br i1 %316, label %317, label %320

317:                                              ; preds = %69
  %318 = load ptr, ptr @stderr, align 8, !tbaa !5
  %319 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %318, ptr noundef @.str.13) #4
  store i8 1, ptr %2, align 1
  store i32 1, ptr %5, align 4
  br label %321

320:                                              ; preds = %69
  store i8 0, ptr %2, align 1
  store i32 1, ptr %5, align 4
  br label %321

321:                                              ; preds = %320, %317
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #4
  br label %322

322:                                              ; preds = %321, %28
  call void @llvm.lifetime.end.p0(i64 40, ptr %4) #4
  %323 = load i8, ptr %2, align 1
  ret i8 %323
}

declare i64 @fread(ptr noundef, i64 noundef, i64 noundef, ptr noundef) #3

attributes #0 = { nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { "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 #4 = { 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, !6, i64 152}
!10 = !{!"MerryReader", !7, i64 0, !7, i64 1, !7, i64 2, !7, i64 3, !11, i64 8, !13, i64 40, !14, i64 64, !15, i64 96, !6, i64 112, !7, i64 120, !12, i64 136, !12, i64 144, !6, i64 152, !12, i64 160, !6, i64 168, !12, i64 176, !6, i64 184, !6, i64 192, !6, i64 200, !6, i64 208, !12, i64 216, !12, i64 224}
!11 = !{!"MerryInstSection", !12, i64 0, !6, i64 8, !12, i64 16, !12, i64 24}
!12 = !{!"long", !7, i64 0}
!13 = !{!"MerryEAT", !6, i64 0, !12, i64 8, !12, i64 16}
!14 = !{!"MerrySsT", !12, i64 0, !12, i64 8, !6, i64 16, !7, i64 24}
!15 = !{!"MerryST", !6, i64 0, !12, i64 8}
!16 = !{!7, !7, i64 0}
!17 = !{!10, !7, i64 1}
!18 = !{!10, !7, i64 0}
!19 = !{!10, !7, i64 2}
!20 = !{!10, !7, i64 3}
!21 = !{!12, !12, i64 0}
!22 = !{!10, !12, i64 8}
!23 = !{!10, !12, i64 56}
!24 = !{!10, !12, i64 64}
!25 = !{!10, !12, i64 104}
!26 = !{!10, !12, i64 160}


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

@stdout = external local_unnamed_addr global ptr, align 8
@stderr = external local_unnamed_addr global ptr, align 8
@.str.11 = external hidden unnamed_addr constant [42 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [99 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [76 x i8], align 1

; Function Attrs: nofree nounwind
declare noundef i32 @fprintf(ptr nocapture noundef, ptr nocapture noundef readonly, ...) local_unnamed_addr #0

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

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

; Function Attrs: nofree nounwind uwtable
define dso_local zeroext range(i8 0, 2) i8 @merry_reader_read_header(ptr nocapture noundef %0) local_unnamed_addr #2 {
  %2 = alloca [40 x i8], align 16
  %3 = load ptr, ptr @stdout, align 8, !tbaa !5
  %4 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %3, ptr noundef nonnull @.str.11, ptr noundef null) #3
  call void @llvm.lifetime.start.p0(i64 40, ptr nonnull %2) #3
  %5 = getelementptr inbounds i8, ptr %0, i64 152
  %6 = load ptr, ptr %5, align 8, !tbaa !9
  %7 = call i64 @fread(ptr noundef nonnull %2, i64 noundef 1, i64 noundef 40, ptr noundef %6)
  %8 = load i8, ptr %2, align 16, !tbaa !16
  %9 = icmp ne i8 %8, 77
  %10 = getelementptr inbounds i8, ptr %2, i64 1
  %11 = load i8, ptr %10, align 1
  %12 = icmp ne i8 %11, 73
  %or.cond = select i1 %9, i1 %12, i1 false
  %13 = getelementptr inbounds i8, ptr %2, i64 2
  %14 = load i8, ptr %13, align 2
  %15 = icmp ne i8 %14, 78
  %or.cond7 = select i1 %or.cond, i1 %15, i1 false
  br i1 %or.cond7, label %.sink.split, label %16

16:                                               ; preds = %1
  %17 = getelementptr inbounds i8, ptr %2, i64 7
  %18 = load i8, ptr %17, align 1, !tbaa !16
  %19 = and i8 %18, 1
  %.not = icmp eq i8 %19, 0
  br i1 %.not, label %22, label %20

20:                                               ; preds = %16
  %21 = getelementptr inbounds i8, ptr %0, i64 1
  store i8 1, ptr %21, align 1, !tbaa !17
  br label %22

22:                                               ; preds = %20, %16
  %23 = getelementptr inbounds i8, ptr %2, i64 6
  %24 = load i8, ptr %23, align 2, !tbaa !16
  %25 = and i8 %24, 1
  %.not81 = icmp eq i8 %25, 0
  br i1 %.not81, label %27, label %26

26:                                               ; preds = %22
  store i8 1, ptr %0, align 8, !tbaa !18
  br label %27

27:                                               ; preds = %26, %22
  %28 = and i8 %24, 2
  %.not82 = icmp eq i8 %28, 0
  br i1 %.not82, label %31, label %29

29:                                               ; preds = %27
  %30 = getelementptr inbounds i8, ptr %0, i64 2
  store i8 1, ptr %30, align 2, !tbaa !19
  br label %31

31:                                               ; preds = %29, %27
  %32 = and i8 %24, 4
  %.not83 = icmp eq i8 %32, 0
  br i1 %.not83, label %35, label %33

33:                                               ; preds = %31
  %34 = getelementptr inbounds i8, ptr %0, i64 3
  store i8 1, ptr %34, align 1, !tbaa !20
  br label %35

35:                                               ; preds = %33, %31
  %36 = getelementptr inbounds i8, ptr %2, i64 8
  %37 = load i8, ptr %36, align 8, !tbaa !16
  %38 = zext i8 %37 to i64
  %39 = getelementptr inbounds i8, ptr %2, i64 9
  %40 = load i8, ptr %39, align 1, !tbaa !16
  %41 = zext i8 %40 to i64
  %42 = shl nuw nsw i64 %38, 16
  %43 = shl nuw nsw i64 %41, 8
  %44 = or disjoint i64 %43, %42
  %45 = getelementptr inbounds i8, ptr %2, i64 10
  %46 = load i8, ptr %45, align 2, !tbaa !16
  %47 = zext i8 %46 to i64
  %48 = or disjoint i64 %44, %47
  %49 = getelementptr inbounds i8, ptr %2, i64 11
  %50 = load i8, ptr %49, align 1, !tbaa !16
  %51 = zext i8 %50 to i64
  %52 = getelementptr inbounds i8, ptr %2, i64 12
  %53 = load i8, ptr %52, align 4, !tbaa !16
  %54 = zext i8 %53 to i64
  %55 = getelementptr inbounds i8, ptr %2, i64 13
  %56 = load i8, ptr %55, align 1, !tbaa !16
  %57 = zext i8 %56 to i64
  %58 = shl nuw nsw i64 %48, 32
  %59 = shl nuw nsw i64 %51, 24
  %60 = shl nuw nsw i64 %54, 16
  %61 = or disjoint i64 %59, %60
  %62 = or disjoint i64 %58, %61
  %63 = shl nuw nsw i64 %57, 8
  %64 = getelementptr inbounds i8, ptr %2, i64 14
  %65 = load i8, ptr %64, align 2, !tbaa !16
  %66 = zext i8 %65 to i64
  %67 = or disjoint i64 %63, %66
  %68 = or disjoint i64 %67, %62
  %69 = shl nuw i64 %68, 8
  %70 = getelementptr inbounds i8, ptr %2, i64 15
  %71 = load i8, ptr %70, align 1, !tbaa !16
  %72 = zext i8 %71 to i64
  %73 = or disjoint i64 %69, %72
  %74 = getelementptr inbounds i8, ptr %0, i64 8
  store i64 %73, ptr %74, align 8, !tbaa !21
  %75 = getelementptr inbounds i8, ptr %2, i64 16
  %76 = load i8, ptr %75, align 16, !tbaa !16
  %77 = zext i8 %76 to i64
  %78 = getelementptr inbounds i8, ptr %2, i64 17
  %79 = load i8, ptr %78, align 1, !tbaa !16
  %80 = zext i8 %79 to i64
  %81 = shl nuw nsw i64 %77, 16
  %82 = shl nuw nsw i64 %80, 8
  %83 = or disjoint i64 %82, %81
  %84 = getelementptr inbounds i8, ptr %2, i64 18
  %85 = load i8, ptr %84, align 2, !tbaa !16
  %86 = zext i8 %85 to i64
  %87 = or disjoint i64 %83, %86
  %88 = getelementptr inbounds i8, ptr %2, i64 19
  %89 = load i8, ptr %88, align 1, !tbaa !16
  %90 = zext i8 %89 to i64
  %91 = getelementptr inbounds i8, ptr %2, i64 20
  %92 = load i8, ptr %91, align 4, !tbaa !16
  %93 = zext i8 %92 to i64
  %94 = getelementptr inbounds i8, ptr %2, i64 21
  %95 = load i8, ptr %94, align 1, !tbaa !16
  %96 = zext i8 %95 to i64
  %97 = shl nuw nsw i64 %87, 32
  %98 = shl nuw nsw i64 %90, 24
  %99 = shl nuw nsw i64 %93, 16
  %100 = or disjoint i64 %98, %99
  %101 = or disjoint i64 %97, %100
  %102 = shl nuw nsw i64 %96, 8
  %103 = getelementptr inbounds i8, ptr %2, i64 22
  %104 = load i8, ptr %103, align 2, !tbaa !16
  %105 = zext i8 %104 to i64
  %106 = or disjoint i64 %102, %105
  %107 = or disjoint i64 %106, %101
  %108 = shl nuw i64 %107, 8
  %109 = getelementptr inbounds i8, ptr %2, i64 23
  %110 = load i8, ptr %109, align 1, !tbaa !16
  %111 = zext i8 %110 to i64
  %112 = or disjoint i64 %108, %111
  %113 = getelementptr inbounds i8, ptr %0, i64 56
  store i64 %112, ptr %113, align 8, !tbaa !22
  %114 = getelementptr inbounds i8, ptr %2, i64 24
  %115 = load i8, ptr %114, align 8, !tbaa !16
  %116 = zext i8 %115 to i64
  %117 = getelementptr inbounds i8, ptr %2, i64 25
  %118 = load i8, ptr %117, align 1, !tbaa !16
  %119 = zext i8 %118 to i64
  %120 = shl nuw nsw i64 %116, 16
  %121 = shl nuw nsw i64 %119, 8
  %122 = or disjoint i64 %121, %120
  %123 = getelementptr inbounds i8, ptr %2, i64 26
  %124 = load i8, ptr %123, align 2, !tbaa !16
  %125 = zext i8 %124 to i64
  %126 = or disjoint i64 %122, %125
  %127 = getelementptr inbounds i8, ptr %2, i64 27
  %128 = load i8, ptr %127, align 1, !tbaa !16
  %129 = zext i8 %128 to i64
  %130 = getelementptr inbounds i8, ptr %2, i64 28
  %131 = load i8, ptr %130, align 4, !tbaa !16
  %132 = zext i8 %131 to i64
  %133 = getelementptr inbounds i8, ptr %2, i64 29
  %134 = load i8, ptr %133, align 1, !tbaa !16
  %135 = zext i8 %134 to i64
  %136 = shl nuw nsw i64 %126, 32
  %137 = shl nuw nsw i64 %129, 24
  %138 = shl nuw nsw i64 %132, 16
  %139 = or disjoint i64 %137, %138
  %140 = or disjoint i64 %136, %139
  %141 = shl nuw nsw i64 %135, 8
  %142 = getelementptr inbounds i8, ptr %2, i64 30
  %143 = load i8, ptr %142, align 2, !tbaa !16
  %144 = zext i8 %143 to i64
  %145 = or disjoint i64 %141, %144
  %146 = or disjoint i64 %145, %140
  %147 = shl nuw i64 %146, 8
  %148 = getelementptr inbounds i8, ptr %2, i64 31
  %149 = load i8, ptr %148, align 1, !tbaa !16
  %150 = zext i8 %149 to i64
  %151 = or disjoint i64 %147, %150
  %152 = getelementptr inbounds i8, ptr %0, i64 64
  store i64 %151, ptr %152, align 8, !tbaa !23
  %153 = getelementptr inbounds i8, ptr %2, i64 32
  %154 = load i8, ptr %153, align 16, !tbaa !16
  %155 = zext i8 %154 to i64
  %156 = getelementptr inbounds i8, ptr %2, i64 33
  %157 = load i8, ptr %156, align 1, !tbaa !16
  %158 = zext i8 %157 to i64
  %159 = shl nuw nsw i64 %155, 16
  %160 = shl nuw nsw i64 %158, 8
  %161 = or disjoint i64 %160, %159
  %162 = getelementptr inbounds i8, ptr %2, i64 34
  %163 = load i8, ptr %162, align 2, !tbaa !16
  %164 = zext i8 %163 to i64
  %165 = or disjoint i64 %161, %164
  %166 = getelementptr inbounds i8, ptr %2, i64 35
  %167 = load i8, ptr %166, align 1, !tbaa !16
  %168 = zext i8 %167 to i64
  %169 = getelementptr inbounds i8, ptr %2, i64 36
  %170 = load i8, ptr %169, align 4, !tbaa !16
  %171 = zext i8 %170 to i64
  %172 = getelementptr inbounds i8, ptr %2, i64 37
  %173 = load i8, ptr %172, align 1, !tbaa !16
  %174 = zext i8 %173 to i64
  %175 = shl nuw nsw i64 %165, 32
  %176 = shl nuw nsw i64 %168, 24
  %177 = shl nuw nsw i64 %171, 16
  %178 = or disjoint i64 %176, %177
  %179 = or disjoint i64 %175, %178
  %180 = shl nuw nsw i64 %174, 8
  %181 = getelementptr inbounds i8, ptr %2, i64 38
  %182 = load i8, ptr %181, align 2, !tbaa !16
  %183 = zext i8 %182 to i64
  %184 = or disjoint i64 %180, %183
  %185 = or disjoint i64 %184, %179
  %186 = shl nuw i64 %185, 8
  %187 = getelementptr inbounds i8, ptr %2, i64 39
  %188 = load i8, ptr %187, align 1, !tbaa !16
  %189 = zext i8 %188 to i64
  %190 = or disjoint i64 %186, %189
  %191 = getelementptr inbounds i8, ptr %0, i64 104
  store i64 %190, ptr %191, align 8, !tbaa !24
  %192 = add i64 %112, %73
  %193 = add i64 %192, %151
  %194 = add i64 %193, %190
  %195 = getelementptr inbounds i8, ptr %0, i64 160
  %196 = load i64, ptr %195, align 8, !tbaa !25
  %197 = icmp ugt i64 %194, %196
  br i1 %197, label %.sink.split, label %200

.sink.split:                                      ; preds = %35, %1
  %.str.13.sink = phi ptr [ @.str.12, %1 ], [ @.str.13, %35 ]
  %198 = load ptr, ptr @stderr, align 8, !tbaa !5
  %199 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %198, ptr noundef nonnull %.str.13.sink) #4
  br label %200

200:                                              ; preds = %.sink.split, %35
  %.1 = phi i8 [ 0, %35 ], [ 1, %.sink.split ]
  call void @llvm.lifetime.end.p0(i64 40, ptr nonnull %2) #3
  ret i8 %.1
}

; Function Attrs: nofree nounwind
declare noundef i64 @fread(ptr nocapture noundef, i64 noundef, i64 noundef, ptr nocapture noundef) local_unnamed_addr #0

attributes #0 = { nofree nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { nofree nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { nounwind }
attributes #4 = { cold 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, !6, i64 152}
!10 = !{!"MerryReader", !7, i64 0, !7, i64 1, !7, i64 2, !7, i64 3, !11, i64 8, !13, i64 40, !14, i64 64, !15, i64 96, !6, i64 112, !7, i64 120, !12, i64 136, !12, i64 144, !6, i64 152, !12, i64 160, !6, i64 168, !12, i64 176, !6, i64 184, !6, i64 192, !6, i64 200, !6, i64 208, !12, i64 216, !12, i64 224}
!11 = !{!"MerryInstSection", !12, i64 0, !6, i64 8, !12, i64 16, !12, i64 24}
!12 = !{!"long", !7, i64 0}
!13 = !{!"MerryEAT", !6, i64 0, !12, i64 8, !12, i64 16}
!14 = !{!"MerrySsT", !12, i64 0, !12, i64 8, !6, i64 16, !7, i64 24}
!15 = !{!"MerryST", !6, i64 0, !12, i64 8}
!16 = !{!7, !7, i64 0}
!17 = !{!10, !7, i64 1}
!18 = !{!10, !7, i64 0}
!19 = !{!10, !7, i64 2}
!20 = !{!10, !7, i64 3}
!21 = !{!10, !12, i64 8}
!22 = !{!10, !12, i64 56}
!23 = !{!10, !12, i64 64}
!24 = !{!10, !12, i64 104}
!25 = !{!10, !12, i64 160}


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