; LLVM IR from jgaeddert/liquid-dsp :: examples (scramble_example)

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

@.str = external hidden unnamed_addr constant [9 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [13 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [19 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [7 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local i32 @main() #0 {
  %1 = alloca i32, align 4
  %2 = alloca i32, align 4
  %3 = alloca ptr, align 8
  %4 = alloca i64, align 8
  %5 = alloca i64, align 8
  %6 = alloca i64, align 8
  %7 = alloca i32, align 4
  %8 = alloca float, align 4
  %9 = alloca float, align 4
  store i32 0, ptr %1, align 4
  call void @llvm.lifetime.start.p0(i64 4, ptr %2) #6
  store i32 32, ptr %2, align 4, !tbaa !5
  %10 = load i32, ptr %2, align 4, !tbaa !5
  %11 = zext i32 %10 to i64
  %12 = call ptr @llvm.stacksave.p0()
  store ptr %12, ptr %3, align 8
  %13 = alloca i8, i64 %11, align 16
  store i64 %11, ptr %4, align 8
  %14 = load i32, ptr %2, align 4, !tbaa !5
  %15 = zext i32 %14 to i64
  %16 = alloca i8, i64 %15, align 16
  store i64 %15, ptr %5, align 8
  %17 = load i32, ptr %2, align 4, !tbaa !5
  %18 = zext i32 %17 to i64
  %19 = alloca i8, i64 %18, align 16
  store i64 %18, ptr %6, align 8
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #6
  store i32 0, ptr %7, align 4, !tbaa !5
  br label %20

20:                                               ; preds = %34, %0
  %21 = load i32, ptr %7, align 4, !tbaa !5
  %22 = load i32, ptr %2, align 4, !tbaa !5
  %23 = icmp ult i32 %21, %22
  br i1 %23, label %24, label %37

24:                                               ; preds = %20
  %25 = call i32 @rand() #6
  %26 = srem i32 %25, 2
  %27 = icmp ne i32 %26, 0
  %28 = zext i1 %27 to i64
  %29 = select i1 %27, i32 15, i32 200
  %30 = trunc i32 %29 to i8
  %31 = load i32, ptr %7, align 4, !tbaa !5
  %32 = zext i32 %31 to i64
  %33 = getelementptr inbounds i8, ptr %13, i64 %32
  store i8 %30, ptr %33, align 1, !tbaa !9
  br label %34

34:                                               ; preds = %24
  %35 = load i32, ptr %7, align 4, !tbaa !5
  %36 = add i32 %35, 1
  store i32 %36, ptr %7, align 4, !tbaa !5
  br label %20, !llvm.loop !10

37:                                               ; preds = %20
  %38 = load i32, ptr %2, align 4, !tbaa !5
  %39 = zext i32 %38 to i64
  call void @llvm.memmove.p0.p0.i64(ptr align 16 %16, ptr align 16 %13, i64 %39, i1 false)
  %40 = load i32, ptr %2, align 4, !tbaa !5
  call void @scramble_data(ptr noundef %16, i32 noundef %40)
  %41 = load i32, ptr %2, align 4, !tbaa !5
  %42 = zext i32 %41 to i64
  call void @llvm.memmove.p0.p0.i64(ptr align 16 %19, ptr align 16 %16, i64 %42, i1 false)
  %43 = load i32, ptr %2, align 4, !tbaa !5
  call void @unscramble_data(ptr noundef %19, i32 noundef %43)
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #6
  %44 = load i32, ptr %2, align 4, !tbaa !5
  %45 = call float @compute_entropy(ptr noundef %13, i32 noundef %44)
  store float %45, ptr %8, align 4, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #6
  %46 = load i32, ptr %2, align 4, !tbaa !5
  %47 = call float @compute_entropy(ptr noundef %16, i32 noundef %46)
  store float %47, ptr %9, align 4, !tbaa !12
  %48 = call i32 (ptr, ...) @printf(ptr noundef @.str)
  %49 = call i32 (ptr, ...) @printf(ptr noundef @.str.1)
  store i32 0, ptr %7, align 4, !tbaa !5
  br label %50

50:                                               ; preds = %72, %37
  %51 = load i32, ptr %7, align 4, !tbaa !5
  %52 = load i32, ptr %2, align 4, !tbaa !5
  %53 = icmp ult i32 %51, %52
  br i1 %53, label %54, label %75

54:                                               ; preds = %50
  %55 = load i32, ptr %7, align 4, !tbaa !5
  %56 = load i32, ptr %7, align 4, !tbaa !5
  %57 = zext i32 %56 to i64
  %58 = getelementptr inbounds i8, ptr %13, i64 %57
  %59 = load i8, ptr %58, align 1, !tbaa !9
  %60 = zext i8 %59 to i32
  %61 = load i32, ptr %7, align 4, !tbaa !5
  %62 = zext i32 %61 to i64
  %63 = getelementptr inbounds i8, ptr %16, i64 %62
  %64 = load i8, ptr %63, align 1, !tbaa !9
  %65 = zext i8 %64 to i32
  %66 = load i32, ptr %7, align 4, !tbaa !5
  %67 = zext i32 %66 to i64
  %68 = getelementptr inbounds i8, ptr %19, i64 %67
  %69 = load i8, ptr %68, align 1, !tbaa !9
  %70 = zext i8 %69 to i32
  %71 = call i32 (ptr, ...) @printf(ptr noundef @.str.2, i32 noundef %55, i32 noundef %60, i32 noundef %65, i32 noundef %70)
  br label %72

72:                                               ; preds = %54
  %73 = load i32, ptr %7, align 4, !tbaa !5
  %74 = add i32 %73, 1
  store i32 %74, ptr %7, align 4, !tbaa !5
  br label %50, !llvm.loop !14

75:                                               ; preds = %50
  %76 = load float, ptr %8, align 4, !tbaa !12
  %77 = fpext float %76 to double
  %78 = call i32 (ptr, ...) @printf(ptr noundef @.str.3, double noundef %77)
  %79 = load float, ptr %9, align 4, !tbaa !12
  %80 = fpext float %79 to double
  %81 = call i32 (ptr, ...) @printf(ptr noundef @.str.4, double noundef %80)
  %82 = call i32 (ptr, ...) @printf(ptr noundef @.str.5)
  store i32 0, ptr %1, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #6
  %83 = load ptr, ptr %3, align 8
  call void @llvm.stackrestore.p0(ptr %83)
  call void @llvm.lifetime.end.p0(i64 4, ptr %2) #6
  %84 = load i32, ptr %1, align 4
  ret i32 %84
}

; 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
declare ptr @llvm.stacksave.p0() #2

; Function Attrs: nounwind
declare i32 @rand() #3

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memmove.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1 immarg) #4

declare void @scramble_data(ptr noundef, i32 noundef) #5

declare void @unscramble_data(ptr noundef, i32 noundef) #5

; Function Attrs: nounwind uwtable
declare dso_local float @compute_entropy(ptr noundef, i32 noundef) #0

declare i32 @printf(ptr noundef, ...) #5

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

; Function Attrs: nocallback nofree nosync nounwind willreturn
declare void @llvm.stackrestore.p0(ptr) #2

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { nocallback nofree nosync nounwind willreturn }
attributes #3 = { 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 #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #5 = { "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 #6 = { 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 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!7, !7, i64 0}
!10 = distinct !{!10, !11}
!11 = !{!"llvm.loop.mustprogress"}
!12 = !{!13, !13, i64 0}
!13 = !{!"float", !7, i64 0}
!14 = distinct !{!14, !11}


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

@.str = external hidden unnamed_addr constant [9 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [13 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [19 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [7 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local noundef i32 @main() local_unnamed_addr #0 {
  %1 = alloca [32 x i8], align 16
  %2 = alloca [32 x i8], align 16
  %3 = alloca [32 x i8], align 16
  %4 = tail call i32 @rand() #5
  %5 = tail call i32 @rand() #5
  %6 = getelementptr inbounds i8, ptr %1, i64 1
  %7 = tail call i32 @rand() #5
  %8 = getelementptr inbounds i8, ptr %1, i64 2
  %9 = tail call i32 @rand() #5
  %10 = getelementptr inbounds i8, ptr %1, i64 3
  %11 = tail call i32 @rand() #5
  %12 = getelementptr inbounds i8, ptr %1, i64 4
  %13 = tail call i32 @rand() #5
  %14 = getelementptr inbounds i8, ptr %1, i64 5
  %15 = tail call i32 @rand() #5
  %16 = getelementptr inbounds i8, ptr %1, i64 6
  %17 = tail call i32 @rand() #5
  %18 = getelementptr inbounds i8, ptr %1, i64 7
  %19 = tail call i32 @rand() #5
  %20 = getelementptr inbounds i8, ptr %1, i64 8
  %21 = tail call i32 @rand() #5
  %22 = getelementptr inbounds i8, ptr %1, i64 9
  %23 = tail call i32 @rand() #5
  %24 = getelementptr inbounds i8, ptr %1, i64 10
  %25 = tail call i32 @rand() #5
  %26 = getelementptr inbounds i8, ptr %1, i64 11
  %27 = tail call i32 @rand() #5
  %28 = getelementptr inbounds i8, ptr %1, i64 12
  %29 = tail call i32 @rand() #5
  %30 = getelementptr inbounds i8, ptr %1, i64 13
  %31 = tail call i32 @rand() #5
  %32 = getelementptr inbounds i8, ptr %1, i64 14
  %33 = tail call i32 @rand() #5
  %34 = getelementptr inbounds i8, ptr %1, i64 15
  %35 = insertelement <16 x i32> poison, i32 %4, i64 0
  %36 = insertelement <16 x i32> %35, i32 %5, i64 1
  %37 = insertelement <16 x i32> %36, i32 %7, i64 2
  %38 = insertelement <16 x i32> %37, i32 %9, i64 3
  %39 = insertelement <16 x i32> %38, i32 %11, i64 4
  %40 = insertelement <16 x i32> %39, i32 %13, i64 5
  %41 = insertelement <16 x i32> %40, i32 %15, i64 6
  %42 = insertelement <16 x i32> %41, i32 %17, i64 7
  %43 = insertelement <16 x i32> %42, i32 %19, i64 8
  %44 = insertelement <16 x i32> %43, i32 %21, i64 9
  %45 = insertelement <16 x i32> %44, i32 %23, i64 10
  %46 = insertelement <16 x i32> %45, i32 %25, i64 11
  %47 = insertelement <16 x i32> %46, i32 %27, i64 12
  %48 = insertelement <16 x i32> %47, i32 %29, i64 13
  %49 = insertelement <16 x i32> %48, i32 %31, i64 14
  %50 = insertelement <16 x i32> %49, i32 %33, i64 15
  %51 = and <16 x i32> %50, <i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1>
  %52 = icmp eq <16 x i32> %51, zeroinitializer
  %53 = select <16 x i1> %52, <16 x i8> <i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56>, <16 x i8> <i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15>
  store <16 x i8> %53, ptr %1, align 16, !tbaa !5
  %54 = tail call i32 @rand() #5
  %55 = getelementptr inbounds i8, ptr %1, i64 16
  %56 = tail call i32 @rand() #5
  %57 = getelementptr inbounds i8, ptr %1, i64 17
  %58 = tail call i32 @rand() #5
  %59 = getelementptr inbounds i8, ptr %1, i64 18
  %60 = tail call i32 @rand() #5
  %61 = getelementptr inbounds i8, ptr %1, i64 19
  %62 = tail call i32 @rand() #5
  %63 = getelementptr inbounds i8, ptr %1, i64 20
  %64 = tail call i32 @rand() #5
  %65 = getelementptr inbounds i8, ptr %1, i64 21
  %66 = tail call i32 @rand() #5
  %67 = getelementptr inbounds i8, ptr %1, i64 22
  %68 = tail call i32 @rand() #5
  %69 = getelementptr inbounds i8, ptr %1, i64 23
  %70 = tail call i32 @rand() #5
  %71 = getelementptr inbounds i8, ptr %1, i64 24
  %72 = tail call i32 @rand() #5
  %73 = getelementptr inbounds i8, ptr %1, i64 25
  %74 = tail call i32 @rand() #5
  %75 = getelementptr inbounds i8, ptr %1, i64 26
  %76 = tail call i32 @rand() #5
  %77 = getelementptr inbounds i8, ptr %1, i64 27
  %78 = tail call i32 @rand() #5
  %79 = getelementptr inbounds i8, ptr %1, i64 28
  %80 = tail call i32 @rand() #5
  %81 = getelementptr inbounds i8, ptr %1, i64 29
  %82 = tail call i32 @rand() #5
  %83 = getelementptr inbounds i8, ptr %1, i64 30
  %84 = tail call i32 @rand() #5
  %85 = getelementptr inbounds i8, ptr %1, i64 31
  %86 = insertelement <16 x i32> poison, i32 %54, i64 0
  %87 = insertelement <16 x i32> %86, i32 %56, i64 1
  %88 = insertelement <16 x i32> %87, i32 %58, i64 2
  %89 = insertelement <16 x i32> %88, i32 %60, i64 3
  %90 = insertelement <16 x i32> %89, i32 %62, i64 4
  %91 = insertelement <16 x i32> %90, i32 %64, i64 5
  %92 = insertelement <16 x i32> %91, i32 %66, i64 6
  %93 = insertelement <16 x i32> %92, i32 %68, i64 7
  %94 = insertelement <16 x i32> %93, i32 %70, i64 8
  %95 = insertelement <16 x i32> %94, i32 %72, i64 9
  %96 = insertelement <16 x i32> %95, i32 %74, i64 10
  %97 = insertelement <16 x i32> %96, i32 %76, i64 11
  %98 = insertelement <16 x i32> %97, i32 %78, i64 12
  %99 = insertelement <16 x i32> %98, i32 %80, i64 13
  %100 = insertelement <16 x i32> %99, i32 %82, i64 14
  %101 = insertelement <16 x i32> %100, i32 %84, i64 15
  %102 = and <16 x i32> %101, <i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1>
  %103 = icmp eq <16 x i32> %102, zeroinitializer
  %104 = select <16 x i1> %103, <16 x i8> <i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56, i8 -56>, <16 x i8> <i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15>
  store <16 x i8> %104, ptr %55, align 16, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(32) %2, ptr noundef nonnull align 16 dereferenceable(32) %1, i64 32, i1 false)
  call void @scramble_data(ptr noundef nonnull %2, i32 noundef 32) #5
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(32) %3, ptr noundef nonnull align 16 dereferenceable(32) %2, i64 32, i1 false)
  call void @unscramble_data(ptr noundef nonnull %3, i32 noundef 32) #5
  %105 = call float @compute_entropy(ptr noundef nonnull %1, i32 noundef 32)
  %106 = call float @compute_entropy(ptr noundef nonnull %2, i32 noundef 32)
  %107 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str)
  %108 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.1)
  %109 = load i8, ptr %1, align 16, !tbaa !5
  %110 = zext i8 %109 to i32
  %111 = load i8, ptr %2, align 16, !tbaa !5
  %112 = zext i8 %111 to i32
  %113 = load i8, ptr %3, align 16, !tbaa !5
  %114 = zext i8 %113 to i32
  %115 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 0, i32 noundef %110, i32 noundef %112, i32 noundef %114)
  %116 = load i8, ptr %6, align 1, !tbaa !5
  %117 = zext i8 %116 to i32
  %118 = getelementptr inbounds i8, ptr %2, i64 1
  %119 = load i8, ptr %118, align 1, !tbaa !5
  %120 = zext i8 %119 to i32
  %121 = getelementptr inbounds i8, ptr %3, i64 1
  %122 = load i8, ptr %121, align 1, !tbaa !5
  %123 = zext i8 %122 to i32
  %124 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 1, i32 noundef %117, i32 noundef %120, i32 noundef %123)
  %125 = load i8, ptr %8, align 2, !tbaa !5
  %126 = zext i8 %125 to i32
  %127 = getelementptr inbounds i8, ptr %2, i64 2
  %128 = load i8, ptr %127, align 2, !tbaa !5
  %129 = zext i8 %128 to i32
  %130 = getelementptr inbounds i8, ptr %3, i64 2
  %131 = load i8, ptr %130, align 2, !tbaa !5
  %132 = zext i8 %131 to i32
  %133 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 2, i32 noundef %126, i32 noundef %129, i32 noundef %132)
  %134 = load i8, ptr %10, align 1, !tbaa !5
  %135 = zext i8 %134 to i32
  %136 = getelementptr inbounds i8, ptr %2, i64 3
  %137 = load i8, ptr %136, align 1, !tbaa !5
  %138 = zext i8 %137 to i32
  %139 = getelementptr inbounds i8, ptr %3, i64 3
  %140 = load i8, ptr %139, align 1, !tbaa !5
  %141 = zext i8 %140 to i32
  %142 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 3, i32 noundef %135, i32 noundef %138, i32 noundef %141)
  %143 = load i8, ptr %12, align 4, !tbaa !5
  %144 = zext i8 %143 to i32
  %145 = getelementptr inbounds i8, ptr %2, i64 4
  %146 = load i8, ptr %145, align 4, !tbaa !5
  %147 = zext i8 %146 to i32
  %148 = getelementptr inbounds i8, ptr %3, i64 4
  %149 = load i8, ptr %148, align 4, !tbaa !5
  %150 = zext i8 %149 to i32
  %151 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 4, i32 noundef %144, i32 noundef %147, i32 noundef %150)
  %152 = load i8, ptr %14, align 1, !tbaa !5
  %153 = zext i8 %152 to i32
  %154 = getelementptr inbounds i8, ptr %2, i64 5
  %155 = load i8, ptr %154, align 1, !tbaa !5
  %156 = zext i8 %155 to i32
  %157 = getelementptr inbounds i8, ptr %3, i64 5
  %158 = load i8, ptr %157, align 1, !tbaa !5
  %159 = zext i8 %158 to i32
  %160 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 5, i32 noundef %153, i32 noundef %156, i32 noundef %159)
  %161 = load i8, ptr %16, align 2, !tbaa !5
  %162 = zext i8 %161 to i32
  %163 = getelementptr inbounds i8, ptr %2, i64 6
  %164 = load i8, ptr %163, align 2, !tbaa !5
  %165 = zext i8 %164 to i32
  %166 = getelementptr inbounds i8, ptr %3, i64 6
  %167 = load i8, ptr %166, align 2, !tbaa !5
  %168 = zext i8 %167 to i32
  %169 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 6, i32 noundef %162, i32 noundef %165, i32 noundef %168)
  %170 = load i8, ptr %18, align 1, !tbaa !5
  %171 = zext i8 %170 to i32
  %172 = getelementptr inbounds i8, ptr %2, i64 7
  %173 = load i8, ptr %172, align 1, !tbaa !5
  %174 = zext i8 %173 to i32
  %175 = getelementptr inbounds i8, ptr %3, i64 7
  %176 = load i8, ptr %175, align 1, !tbaa !5
  %177 = zext i8 %176 to i32
  %178 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 7, i32 noundef %171, i32 noundef %174, i32 noundef %177)
  %179 = load i8, ptr %20, align 8, !tbaa !5
  %180 = zext i8 %179 to i32
  %181 = getelementptr inbounds i8, ptr %2, i64 8
  %182 = load i8, ptr %181, align 8, !tbaa !5
  %183 = zext i8 %182 to i32
  %184 = getelementptr inbounds i8, ptr %3, i64 8
  %185 = load i8, ptr %184, align 8, !tbaa !5
  %186 = zext i8 %185 to i32
  %187 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 8, i32 noundef %180, i32 noundef %183, i32 noundef %186)
  %188 = load i8, ptr %22, align 1, !tbaa !5
  %189 = zext i8 %188 to i32
  %190 = getelementptr inbounds i8, ptr %2, i64 9
  %191 = load i8, ptr %190, align 1, !tbaa !5
  %192 = zext i8 %191 to i32
  %193 = getelementptr inbounds i8, ptr %3, i64 9
  %194 = load i8, ptr %193, align 1, !tbaa !5
  %195 = zext i8 %194 to i32
  %196 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 9, i32 noundef %189, i32 noundef %192, i32 noundef %195)
  %197 = load i8, ptr %24, align 2, !tbaa !5
  %198 = zext i8 %197 to i32
  %199 = getelementptr inbounds i8, ptr %2, i64 10
  %200 = load i8, ptr %199, align 2, !tbaa !5
  %201 = zext i8 %200 to i32
  %202 = getelementptr inbounds i8, ptr %3, i64 10
  %203 = load i8, ptr %202, align 2, !tbaa !5
  %204 = zext i8 %203 to i32
  %205 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 10, i32 noundef %198, i32 noundef %201, i32 noundef %204)
  %206 = load i8, ptr %26, align 1, !tbaa !5
  %207 = zext i8 %206 to i32
  %208 = getelementptr inbounds i8, ptr %2, i64 11
  %209 = load i8, ptr %208, align 1, !tbaa !5
  %210 = zext i8 %209 to i32
  %211 = getelementptr inbounds i8, ptr %3, i64 11
  %212 = load i8, ptr %211, align 1, !tbaa !5
  %213 = zext i8 %212 to i32
  %214 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 11, i32 noundef %207, i32 noundef %210, i32 noundef %213)
  %215 = load i8, ptr %28, align 4, !tbaa !5
  %216 = zext i8 %215 to i32
  %217 = getelementptr inbounds i8, ptr %2, i64 12
  %218 = load i8, ptr %217, align 4, !tbaa !5
  %219 = zext i8 %218 to i32
  %220 = getelementptr inbounds i8, ptr %3, i64 12
  %221 = load i8, ptr %220, align 4, !tbaa !5
  %222 = zext i8 %221 to i32
  %223 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 12, i32 noundef %216, i32 noundef %219, i32 noundef %222)
  %224 = load i8, ptr %30, align 1, !tbaa !5
  %225 = zext i8 %224 to i32
  %226 = getelementptr inbounds i8, ptr %2, i64 13
  %227 = load i8, ptr %226, align 1, !tbaa !5
  %228 = zext i8 %227 to i32
  %229 = getelementptr inbounds i8, ptr %3, i64 13
  %230 = load i8, ptr %229, align 1, !tbaa !5
  %231 = zext i8 %230 to i32
  %232 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 13, i32 noundef %225, i32 noundef %228, i32 noundef %231)
  %233 = load i8, ptr %32, align 2, !tbaa !5
  %234 = zext i8 %233 to i32
  %235 = getelementptr inbounds i8, ptr %2, i64 14
  %236 = load i8, ptr %235, align 2, !tbaa !5
  %237 = zext i8 %236 to i32
  %238 = getelementptr inbounds i8, ptr %3, i64 14
  %239 = load i8, ptr %238, align 2, !tbaa !5
  %240 = zext i8 %239 to i32
  %241 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 14, i32 noundef %234, i32 noundef %237, i32 noundef %240)
  %242 = load i8, ptr %34, align 1, !tbaa !5
  %243 = zext i8 %242 to i32
  %244 = getelementptr inbounds i8, ptr %2, i64 15
  %245 = load i8, ptr %244, align 1, !tbaa !5
  %246 = zext i8 %245 to i32
  %247 = getelementptr inbounds i8, ptr %3, i64 15
  %248 = load i8, ptr %247, align 1, !tbaa !5
  %249 = zext i8 %248 to i32
  %250 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 15, i32 noundef %243, i32 noundef %246, i32 noundef %249)
  %251 = load i8, ptr %55, align 16, !tbaa !5
  %252 = zext i8 %251 to i32
  %253 = getelementptr inbounds i8, ptr %2, i64 16
  %254 = load i8, ptr %253, align 16, !tbaa !5
  %255 = zext i8 %254 to i32
  %256 = getelementptr inbounds i8, ptr %3, i64 16
  %257 = load i8, ptr %256, align 16, !tbaa !5
  %258 = zext i8 %257 to i32
  %259 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 16, i32 noundef %252, i32 noundef %255, i32 noundef %258)
  %260 = load i8, ptr %57, align 1, !tbaa !5
  %261 = zext i8 %260 to i32
  %262 = getelementptr inbounds i8, ptr %2, i64 17
  %263 = load i8, ptr %262, align 1, !tbaa !5
  %264 = zext i8 %263 to i32
  %265 = getelementptr inbounds i8, ptr %3, i64 17
  %266 = load i8, ptr %265, align 1, !tbaa !5
  %267 = zext i8 %266 to i32
  %268 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 17, i32 noundef %261, i32 noundef %264, i32 noundef %267)
  %269 = load i8, ptr %59, align 2, !tbaa !5
  %270 = zext i8 %269 to i32
  %271 = getelementptr inbounds i8, ptr %2, i64 18
  %272 = load i8, ptr %271, align 2, !tbaa !5
  %273 = zext i8 %272 to i32
  %274 = getelementptr inbounds i8, ptr %3, i64 18
  %275 = load i8, ptr %274, align 2, !tbaa !5
  %276 = zext i8 %275 to i32
  %277 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 18, i32 noundef %270, i32 noundef %273, i32 noundef %276)
  %278 = load i8, ptr %61, align 1, !tbaa !5
  %279 = zext i8 %278 to i32
  %280 = getelementptr inbounds i8, ptr %2, i64 19
  %281 = load i8, ptr %280, align 1, !tbaa !5
  %282 = zext i8 %281 to i32
  %283 = getelementptr inbounds i8, ptr %3, i64 19
  %284 = load i8, ptr %283, align 1, !tbaa !5
  %285 = zext i8 %284 to i32
  %286 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 19, i32 noundef %279, i32 noundef %282, i32 noundef %285)
  %287 = load i8, ptr %63, align 4, !tbaa !5
  %288 = zext i8 %287 to i32
  %289 = getelementptr inbounds i8, ptr %2, i64 20
  %290 = load i8, ptr %289, align 4, !tbaa !5
  %291 = zext i8 %290 to i32
  %292 = getelementptr inbounds i8, ptr %3, i64 20
  %293 = load i8, ptr %292, align 4, !tbaa !5
  %294 = zext i8 %293 to i32
  %295 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 20, i32 noundef %288, i32 noundef %291, i32 noundef %294)
  %296 = load i8, ptr %65, align 1, !tbaa !5
  %297 = zext i8 %296 to i32
  %298 = getelementptr inbounds i8, ptr %2, i64 21
  %299 = load i8, ptr %298, align 1, !tbaa !5
  %300 = zext i8 %299 to i32
  %301 = getelementptr inbounds i8, ptr %3, i64 21
  %302 = load i8, ptr %301, align 1, !tbaa !5
  %303 = zext i8 %302 to i32
  %304 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 21, i32 noundef %297, i32 noundef %300, i32 noundef %303)
  %305 = load i8, ptr %67, align 2, !tbaa !5
  %306 = zext i8 %305 to i32
  %307 = getelementptr inbounds i8, ptr %2, i64 22
  %308 = load i8, ptr %307, align 2, !tbaa !5
  %309 = zext i8 %308 to i32
  %310 = getelementptr inbounds i8, ptr %3, i64 22
  %311 = load i8, ptr %310, align 2, !tbaa !5
  %312 = zext i8 %311 to i32
  %313 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 22, i32 noundef %306, i32 noundef %309, i32 noundef %312)
  %314 = load i8, ptr %69, align 1, !tbaa !5
  %315 = zext i8 %314 to i32
  %316 = getelementptr inbounds i8, ptr %2, i64 23
  %317 = load i8, ptr %316, align 1, !tbaa !5
  %318 = zext i8 %317 to i32
  %319 = getelementptr inbounds i8, ptr %3, i64 23
  %320 = load i8, ptr %319, align 1, !tbaa !5
  %321 = zext i8 %320 to i32
  %322 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 23, i32 noundef %315, i32 noundef %318, i32 noundef %321)
  %323 = load i8, ptr %71, align 8, !tbaa !5
  %324 = zext i8 %323 to i32
  %325 = getelementptr inbounds i8, ptr %2, i64 24
  %326 = load i8, ptr %325, align 8, !tbaa !5
  %327 = zext i8 %326 to i32
  %328 = getelementptr inbounds i8, ptr %3, i64 24
  %329 = load i8, ptr %328, align 8, !tbaa !5
  %330 = zext i8 %329 to i32
  %331 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 24, i32 noundef %324, i32 noundef %327, i32 noundef %330)
  %332 = load i8, ptr %73, align 1, !tbaa !5
  %333 = zext i8 %332 to i32
  %334 = getelementptr inbounds i8, ptr %2, i64 25
  %335 = load i8, ptr %334, align 1, !tbaa !5
  %336 = zext i8 %335 to i32
  %337 = getelementptr inbounds i8, ptr %3, i64 25
  %338 = load i8, ptr %337, align 1, !tbaa !5
  %339 = zext i8 %338 to i32
  %340 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 25, i32 noundef %333, i32 noundef %336, i32 noundef %339)
  %341 = load i8, ptr %75, align 2, !tbaa !5
  %342 = zext i8 %341 to i32
  %343 = getelementptr inbounds i8, ptr %2, i64 26
  %344 = load i8, ptr %343, align 2, !tbaa !5
  %345 = zext i8 %344 to i32
  %346 = getelementptr inbounds i8, ptr %3, i64 26
  %347 = load i8, ptr %346, align 2, !tbaa !5
  %348 = zext i8 %347 to i32
  %349 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 26, i32 noundef %342, i32 noundef %345, i32 noundef %348)
  %350 = load i8, ptr %77, align 1, !tbaa !5
  %351 = zext i8 %350 to i32
  %352 = getelementptr inbounds i8, ptr %2, i64 27
  %353 = load i8, ptr %352, align 1, !tbaa !5
  %354 = zext i8 %353 to i32
  %355 = getelementptr inbounds i8, ptr %3, i64 27
  %356 = load i8, ptr %355, align 1, !tbaa !5
  %357 = zext i8 %356 to i32
  %358 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 27, i32 noundef %351, i32 noundef %354, i32 noundef %357)
  %359 = load i8, ptr %79, align 4, !tbaa !5
  %360 = zext i8 %359 to i32
  %361 = getelementptr inbounds i8, ptr %2, i64 28
  %362 = load i8, ptr %361, align 4, !tbaa !5
  %363 = zext i8 %362 to i32
  %364 = getelementptr inbounds i8, ptr %3, i64 28
  %365 = load i8, ptr %364, align 4, !tbaa !5
  %366 = zext i8 %365 to i32
  %367 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 28, i32 noundef %360, i32 noundef %363, i32 noundef %366)
  %368 = load i8, ptr %81, align 1, !tbaa !5
  %369 = zext i8 %368 to i32
  %370 = getelementptr inbounds i8, ptr %2, i64 29
  %371 = load i8, ptr %370, align 1, !tbaa !5
  %372 = zext i8 %371 to i32
  %373 = getelementptr inbounds i8, ptr %3, i64 29
  %374 = load i8, ptr %373, align 1, !tbaa !5
  %375 = zext i8 %374 to i32
  %376 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 29, i32 noundef %369, i32 noundef %372, i32 noundef %375)
  %377 = load i8, ptr %83, align 2, !tbaa !5
  %378 = zext i8 %377 to i32
  %379 = getelementptr inbounds i8, ptr %2, i64 30
  %380 = load i8, ptr %379, align 2, !tbaa !5
  %381 = zext i8 %380 to i32
  %382 = getelementptr inbounds i8, ptr %3, i64 30
  %383 = load i8, ptr %382, align 2, !tbaa !5
  %384 = zext i8 %383 to i32
  %385 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 30, i32 noundef %378, i32 noundef %381, i32 noundef %384)
  %386 = load i8, ptr %85, align 1, !tbaa !5
  %387 = zext i8 %386 to i32
  %388 = getelementptr inbounds i8, ptr %2, i64 31
  %389 = load i8, ptr %388, align 1, !tbaa !5
  %390 = zext i8 %389 to i32
  %391 = getelementptr inbounds i8, ptr %3, i64 31
  %392 = load i8, ptr %391, align 1, !tbaa !5
  %393 = zext i8 %392 to i32
  %394 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, i32 noundef 31, i32 noundef %387, i32 noundef %390, i32 noundef %393)
  %395 = fpext float %105 to double
  %396 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.3, double noundef %395)
  %397 = fpext float %106 to double
  %398 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.4, double noundef %397)
  %399 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.5)
  ret i32 0
}

; Function Attrs: nounwind
declare i32 @rand() local_unnamed_addr #1

declare void @scramble_data(ptr noundef, i32 noundef) local_unnamed_addr #2

declare void @unscramble_data(ptr noundef, i32 noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare dso_local float @compute_entropy(ptr noundef, i32 noundef) local_unnamed_addr #0

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

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #4

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { 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 #2 = { "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 = { 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 #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #5 = { 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 = !{!"omnipotent char", !7, i64 0}
!7 = !{!"Simple C/C++ TBAA"}


; Effective O3 passes: EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,LoopRotatePass,MemCpyOptPass,PostOrderFunctionAttrsPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass