; LLVM IR from Northstrix/Encrypted_Data_Vault :: Raspberry_Pi_Pico_plus_ESP32/Firmware_for_Raspberry_Pi_Pico (serpent)

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

%union._serpent_blk_t = type { [8 x i64] }

@__const.serpent_subbytes.sbox = external hidden unnamed_addr constant [8 x [8 x i8]], align 16
@__const.serpent_subbytes.sbox_inv = external hidden unnamed_addr constant [8 x [8 x i8]], 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
declare dso_local void @permute(ptr noundef, ptr noundef, i32 noundef) #1

; Function Attrs: nounwind uwtable
define dso_local void @serpent_subbytes(ptr noundef %0, i32 noundef %1, i32 noundef %2) #1 {
  %4 = alloca ptr, align 8
  %5 = alloca i32, align 4
  %6 = alloca i32, align 4
  %7 = alloca %union._serpent_blk_t, align 8
  %8 = alloca %union._serpent_blk_t, align 8
  %9 = alloca ptr, align 8
  %10 = alloca i8, align 1
  %11 = alloca i8, align 1
  %12 = alloca [8 x [8 x i8]], align 16
  %13 = alloca [8 x [8 x i8]], align 16
  store ptr %0, ptr %4, align 8, !tbaa !5
  store i32 %1, ptr %5, align 4, !tbaa !9
  store i32 %2, ptr %6, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 64, ptr %7) #3
  call void @llvm.lifetime.start.p0(i64 64, ptr %8) #3
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #3
  call void @llvm.lifetime.start.p0(i64 1, ptr %10) #3
  call void @llvm.lifetime.start.p0(i64 1, ptr %11) #3
  call void @llvm.lifetime.start.p0(i64 64, ptr %12) #3
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %12, ptr align 16 @__const.serpent_subbytes.sbox, i64 64, i1 false)
  call void @llvm.lifetime.start.p0(i64 64, ptr %13) #3
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %13, ptr align 16 @__const.serpent_subbytes.sbox_inv, i64 64, i1 false)
  %14 = load i32, ptr %5, align 4, !tbaa !9
  %15 = and i32 %14, 7
  store i32 %15, ptr %5, align 4, !tbaa !9
  %16 = load i32, ptr %6, align 4, !tbaa !9
  %17 = icmp eq i32 %16, 0
  br i1 %17, label %18, label %23

18:                                               ; preds = %3
  %19 = load i32, ptr %5, align 4, !tbaa !9
  %20 = zext i32 %19 to i64
  %21 = getelementptr inbounds [8 x [8 x i8]], ptr %12, i64 0, i64 %20
  %22 = getelementptr inbounds [8 x i8], ptr %21, i64 0, i64 0
  store ptr %22, ptr %9, align 8, !tbaa !5
  br label %28

23:                                               ; preds = %3
  %24 = load i32, ptr %5, align 4, !tbaa !9
  %25 = zext i32 %24 to i64
  %26 = getelementptr inbounds [8 x [8 x i8]], ptr %13, i64 0, i64 %25
  %27 = getelementptr inbounds [8 x i8], ptr %26, i64 0, i64 0
  store ptr %27, ptr %9, align 8, !tbaa !5
  br label %28

28:                                               ; preds = %23, %18
  store i8 0, ptr %10, align 1, !tbaa !11
  br label %29

29:                                               ; preds = %60, %28
  %30 = load i8, ptr %10, align 1, !tbaa !11
  %31 = zext i8 %30 to i32
  %32 = icmp slt i32 %31, 16
  br i1 %32, label %33, label %65

33:                                               ; preds = %29
  %34 = load ptr, ptr %9, align 8, !tbaa !5
  %35 = load i8, ptr %10, align 1, !tbaa !11
  %36 = zext i8 %35 to i32
  %37 = sdiv i32 %36, 2
  %38 = sext i32 %37 to i64
  %39 = getelementptr inbounds i8, ptr %34, i64 %38
  %40 = load i8, ptr %39, align 1, !tbaa !11
  store i8 %40, ptr %11, align 1, !tbaa !11
  %41 = load i8, ptr %11, align 1, !tbaa !11
  %42 = zext i8 %41 to i32
  %43 = and i32 %42, 15
  %44 = trunc i32 %43 to i8
  %45 = load i8, ptr %10, align 1, !tbaa !11
  %46 = zext i8 %45 to i32
  %47 = add nsw i32 %46, 0
  %48 = sext i32 %47 to i64
  %49 = getelementptr inbounds [16 x i8], ptr %8, i64 0, i64 %48
  store i8 %44, ptr %49, align 1, !tbaa !11
  %50 = load i8, ptr %11, align 1, !tbaa !11
  %51 = zext i8 %50 to i32
  %52 = ashr i32 %51, 4
  %53 = and i32 %52, 15
  %54 = trunc i32 %53 to i8
  %55 = load i8, ptr %10, align 1, !tbaa !11
  %56 = zext i8 %55 to i32
  %57 = add nsw i32 %56, 1
  %58 = sext i32 %57 to i64
  %59 = getelementptr inbounds [16 x i8], ptr %8, i64 0, i64 %58
  store i8 %54, ptr %59, align 1, !tbaa !11
  br label %60

60:                                               ; preds = %33
  %61 = load i8, ptr %10, align 1, !tbaa !11
  %62 = zext i8 %61 to i32
  %63 = add nsw i32 %62, 2
  %64 = trunc i32 %63 to i8
  store i8 %64, ptr %10, align 1, !tbaa !11
  br label %29, !llvm.loop !12

65:                                               ; preds = %29
  %66 = load ptr, ptr %4, align 8, !tbaa !5
  call void @permute(ptr noundef %7, ptr noundef %66, i32 noundef 0)
  store i8 0, ptr %10, align 1, !tbaa !11
  br label %67

67:                                               ; preds = %97, %65
  %68 = load i8, ptr %10, align 1, !tbaa !11
  %69 = zext i8 %68 to i32
  %70 = icmp slt i32 %69, 16
  br i1 %70, label %71, label %100

71:                                               ; preds = %67
  %72 = load i8, ptr %10, align 1, !tbaa !11
  %73 = zext i8 %72 to i64
  %74 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 %73
  %75 = load i8, ptr %74, align 1, !tbaa !11
  store i8 %75, ptr %11, align 1, !tbaa !11
  %76 = load i8, ptr %11, align 1, !tbaa !11
  %77 = zext i8 %76 to i32
  %78 = ashr i32 %77, 4
  %79 = and i32 %78, 15
  %80 = sext i32 %79 to i64
  %81 = getelementptr inbounds [16 x i8], ptr %8, i64 0, i64 %80
  %82 = load i8, ptr %81, align 1, !tbaa !11
  %83 = zext i8 %82 to i32
  %84 = shl i32 %83, 4
  %85 = load i8, ptr %11, align 1, !tbaa !11
  %86 = zext i8 %85 to i32
  %87 = and i32 %86, 15
  %88 = sext i32 %87 to i64
  %89 = getelementptr inbounds [16 x i8], ptr %8, i64 0, i64 %88
  %90 = load i8, ptr %89, align 1, !tbaa !11
  %91 = zext i8 %90 to i32
  %92 = or i32 %84, %91
  %93 = trunc i32 %92 to i8
  %94 = load i8, ptr %10, align 1, !tbaa !11
  %95 = zext i8 %94 to i64
  %96 = getelementptr inbounds [16 x i8], ptr %7, i64 0, i64 %95
  store i8 %93, ptr %96, align 1, !tbaa !11
  br label %97

97:                                               ; preds = %71
  %98 = load i8, ptr %10, align 1, !tbaa !11
  %99 = add i8 %98, 1
  store i8 %99, ptr %10, align 1, !tbaa !11
  br label %67, !llvm.loop !14

100:                                              ; preds = %67
  %101 = load ptr, ptr %4, align 8, !tbaa !5
  call void @permute(ptr noundef %101, ptr noundef %7, i32 noundef 1)
  call void @llvm.lifetime.end.p0(i64 64, ptr %13) #3
  call void @llvm.lifetime.end.p0(i64 64, ptr %12) #3
  call void @llvm.lifetime.end.p0(i64 1, ptr %11) #3
  call void @llvm.lifetime.end.p0(i64 1, ptr %10) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #3
  call void @llvm.lifetime.end.p0(i64 64, ptr %8) #3
  call void @llvm.lifetime.end.p0(i64 64, ptr %7) #3
  ret void
}

; 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) #2

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 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #3 = { 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, !10, i64 0}
!10 = !{!"int", !7, i64 0}
!11 = !{!7, !7, i64 0}
!12 = distinct !{!12, !13}
!13 = !{!"llvm.loop.mustprogress"}
!14 = distinct !{!14, !13}


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

%union._serpent_blk_t = type { [8 x i64] }

@__const.serpent_subbytes.sbox = external hidden unnamed_addr constant [8 x [8 x i8]], align 16
@__const.serpent_subbytes.sbox_inv = external hidden unnamed_addr constant [8 x [8 x i8]], align 16

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

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

; Function Attrs: nounwind uwtable
declare dso_local void @permute(ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #1

; Function Attrs: nounwind uwtable
define dso_local void @serpent_subbytes(ptr noundef %0, i32 noundef %1, i32 noundef %2) local_unnamed_addr #1 {
  %4 = alloca %union._serpent_blk_t, align 8
  %5 = alloca %union._serpent_blk_t, align 16
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %4) #2
  call void @llvm.lifetime.start.p0(i64 64, ptr nonnull %5) #2
  %6 = and i32 %1, 7
  %7 = icmp eq i32 %2, 0
  %8 = zext nneg i32 %6 to i64
  %9 = getelementptr inbounds [8 x [8 x i8]], ptr @__const.serpent_subbytes.sbox, i64 0, i64 %8
  %10 = getelementptr inbounds [8 x [8 x i8]], ptr @__const.serpent_subbytes.sbox_inv, i64 0, i64 %8
  %.019 = select i1 %7, ptr %9, ptr %10
  %11 = load <8 x i8>, ptr %.019, align 8, !tbaa !5
  %12 = shufflevector <8 x i8> %11, <8 x i8> poison, <16 x i32> <i32 0, i32 0, i32 1, i32 1, i32 2, i32 2, i32 3, i32 3, i32 4, i32 4, i32 5, i32 5, i32 6, i32 6, i32 7, i32 7>
  %13 = and <16 x i8> %12, <i8 15, i8 poison, i8 15, i8 poison, i8 15, i8 poison, i8 15, i8 poison, i8 15, i8 poison, i8 15, i8 poison, i8 15, i8 poison, i8 15, i8 poison>
  %14 = lshr <16 x i8> %12, <i8 15, i8 4, i8 15, i8 4, i8 15, i8 4, i8 15, i8 4, i8 15, i8 4, i8 15, i8 4, i8 15, i8 4, i8 15, i8 4>
  %15 = shufflevector <16 x i8> %13, <16 x i8> %14, <16 x i32> <i32 0, i32 17, i32 2, i32 19, i32 4, i32 21, i32 6, i32 23, i32 8, i32 25, i32 10, i32 27, i32 12, i32 29, i32 14, i32 31>
  store <16 x i8> %15, ptr %5, align 16, !tbaa !5
  call void @permute(ptr noundef nonnull %4, ptr noundef %0, i32 noundef 0)
  %16 = load i8, ptr %4, align 8, !tbaa !5
  %17 = zext i8 %16 to i32
  %18 = lshr i32 %17, 4
  %19 = zext nneg i32 %18 to i64
  %20 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %19
  %21 = load i8, ptr %20, align 1, !tbaa !5
  %22 = shl i8 %21, 4
  %23 = and i32 %17, 15
  %24 = zext nneg i32 %23 to i64
  %25 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %24
  %26 = load i8, ptr %25, align 1, !tbaa !5
  %27 = or i8 %22, %26
  store i8 %27, ptr %4, align 8, !tbaa !5
  %28 = getelementptr inbounds i8, ptr %4, i64 1
  %29 = load i8, ptr %28, align 1, !tbaa !5
  %30 = zext i8 %29 to i32
  %31 = lshr i32 %30, 4
  %32 = zext nneg i32 %31 to i64
  %33 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %32
  %34 = load i8, ptr %33, align 1, !tbaa !5
  %35 = shl i8 %34, 4
  %36 = and i32 %30, 15
  %37 = zext nneg i32 %36 to i64
  %38 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %37
  %39 = load i8, ptr %38, align 1, !tbaa !5
  %40 = or i8 %35, %39
  store i8 %40, ptr %28, align 1, !tbaa !5
  %41 = getelementptr inbounds i8, ptr %4, i64 2
  %42 = load i8, ptr %41, align 2, !tbaa !5
  %43 = zext i8 %42 to i32
  %44 = lshr i32 %43, 4
  %45 = zext nneg i32 %44 to i64
  %46 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %45
  %47 = load i8, ptr %46, align 1, !tbaa !5
  %48 = shl i8 %47, 4
  %49 = and i32 %43, 15
  %50 = zext nneg i32 %49 to i64
  %51 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %50
  %52 = load i8, ptr %51, align 1, !tbaa !5
  %53 = or i8 %48, %52
  store i8 %53, ptr %41, align 2, !tbaa !5
  %54 = getelementptr inbounds i8, ptr %4, i64 3
  %55 = load i8, ptr %54, align 1, !tbaa !5
  %56 = zext i8 %55 to i32
  %57 = lshr i32 %56, 4
  %58 = zext nneg i32 %57 to i64
  %59 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %58
  %60 = load i8, ptr %59, align 1, !tbaa !5
  %61 = shl i8 %60, 4
  %62 = and i32 %56, 15
  %63 = zext nneg i32 %62 to i64
  %64 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %63
  %65 = load i8, ptr %64, align 1, !tbaa !5
  %66 = or i8 %61, %65
  store i8 %66, ptr %54, align 1, !tbaa !5
  %67 = getelementptr inbounds i8, ptr %4, i64 4
  %68 = load i8, ptr %67, align 4, !tbaa !5
  %69 = zext i8 %68 to i32
  %70 = lshr i32 %69, 4
  %71 = zext nneg i32 %70 to i64
  %72 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %71
  %73 = load i8, ptr %72, align 1, !tbaa !5
  %74 = shl i8 %73, 4
  %75 = and i32 %69, 15
  %76 = zext nneg i32 %75 to i64
  %77 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %76
  %78 = load i8, ptr %77, align 1, !tbaa !5
  %79 = or i8 %74, %78
  store i8 %79, ptr %67, align 4, !tbaa !5
  %80 = getelementptr inbounds i8, ptr %4, i64 5
  %81 = load i8, ptr %80, align 1, !tbaa !5
  %82 = zext i8 %81 to i32
  %83 = lshr i32 %82, 4
  %84 = zext nneg i32 %83 to i64
  %85 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %84
  %86 = load i8, ptr %85, align 1, !tbaa !5
  %87 = shl i8 %86, 4
  %88 = and i32 %82, 15
  %89 = zext nneg i32 %88 to i64
  %90 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %89
  %91 = load i8, ptr %90, align 1, !tbaa !5
  %92 = or i8 %87, %91
  store i8 %92, ptr %80, align 1, !tbaa !5
  %93 = getelementptr inbounds i8, ptr %4, i64 6
  %94 = load i8, ptr %93, align 2, !tbaa !5
  %95 = zext i8 %94 to i32
  %96 = lshr i32 %95, 4
  %97 = zext nneg i32 %96 to i64
  %98 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %97
  %99 = load i8, ptr %98, align 1, !tbaa !5
  %100 = shl i8 %99, 4
  %101 = and i32 %95, 15
  %102 = zext nneg i32 %101 to i64
  %103 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %102
  %104 = load i8, ptr %103, align 1, !tbaa !5
  %105 = or i8 %100, %104
  store i8 %105, ptr %93, align 2, !tbaa !5
  %106 = getelementptr inbounds i8, ptr %4, i64 7
  %107 = load i8, ptr %106, align 1, !tbaa !5
  %108 = zext i8 %107 to i32
  %109 = lshr i32 %108, 4
  %110 = zext nneg i32 %109 to i64
  %111 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %110
  %112 = load i8, ptr %111, align 1, !tbaa !5
  %113 = shl i8 %112, 4
  %114 = and i32 %108, 15
  %115 = zext nneg i32 %114 to i64
  %116 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %115
  %117 = load i8, ptr %116, align 1, !tbaa !5
  %118 = or i8 %113, %117
  store i8 %118, ptr %106, align 1, !tbaa !5
  %119 = getelementptr inbounds i8, ptr %4, i64 8
  %120 = load i8, ptr %119, align 8, !tbaa !5
  %121 = zext i8 %120 to i32
  %122 = lshr i32 %121, 4
  %123 = zext nneg i32 %122 to i64
  %124 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %123
  %125 = load i8, ptr %124, align 1, !tbaa !5
  %126 = shl i8 %125, 4
  %127 = and i32 %121, 15
  %128 = zext nneg i32 %127 to i64
  %129 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %128
  %130 = load i8, ptr %129, align 1, !tbaa !5
  %131 = or i8 %126, %130
  store i8 %131, ptr %119, align 8, !tbaa !5
  %132 = getelementptr inbounds i8, ptr %4, i64 9
  %133 = load i8, ptr %132, align 1, !tbaa !5
  %134 = zext i8 %133 to i32
  %135 = lshr i32 %134, 4
  %136 = zext nneg i32 %135 to i64
  %137 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %136
  %138 = load i8, ptr %137, align 1, !tbaa !5
  %139 = shl i8 %138, 4
  %140 = and i32 %134, 15
  %141 = zext nneg i32 %140 to i64
  %142 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %141
  %143 = load i8, ptr %142, align 1, !tbaa !5
  %144 = or i8 %139, %143
  store i8 %144, ptr %132, align 1, !tbaa !5
  %145 = getelementptr inbounds i8, ptr %4, i64 10
  %146 = load i8, ptr %145, align 2, !tbaa !5
  %147 = zext i8 %146 to i32
  %148 = lshr i32 %147, 4
  %149 = zext nneg i32 %148 to i64
  %150 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %149
  %151 = load i8, ptr %150, align 1, !tbaa !5
  %152 = shl i8 %151, 4
  %153 = and i32 %147, 15
  %154 = zext nneg i32 %153 to i64
  %155 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %154
  %156 = load i8, ptr %155, align 1, !tbaa !5
  %157 = or i8 %152, %156
  store i8 %157, ptr %145, align 2, !tbaa !5
  %158 = getelementptr inbounds i8, ptr %4, i64 11
  %159 = load i8, ptr %158, align 1, !tbaa !5
  %160 = zext i8 %159 to i32
  %161 = lshr i32 %160, 4
  %162 = zext nneg i32 %161 to i64
  %163 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %162
  %164 = load i8, ptr %163, align 1, !tbaa !5
  %165 = shl i8 %164, 4
  %166 = and i32 %160, 15
  %167 = zext nneg i32 %166 to i64
  %168 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %167
  %169 = load i8, ptr %168, align 1, !tbaa !5
  %170 = or i8 %165, %169
  store i8 %170, ptr %158, align 1, !tbaa !5
  %171 = getelementptr inbounds i8, ptr %4, i64 12
  %172 = load i8, ptr %171, align 4, !tbaa !5
  %173 = zext i8 %172 to i32
  %174 = lshr i32 %173, 4
  %175 = zext nneg i32 %174 to i64
  %176 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %175
  %177 = load i8, ptr %176, align 1, !tbaa !5
  %178 = shl i8 %177, 4
  %179 = and i32 %173, 15
  %180 = zext nneg i32 %179 to i64
  %181 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %180
  %182 = load i8, ptr %181, align 1, !tbaa !5
  %183 = or i8 %178, %182
  store i8 %183, ptr %171, align 4, !tbaa !5
  %184 = getelementptr inbounds i8, ptr %4, i64 13
  %185 = load i8, ptr %184, align 1, !tbaa !5
  %186 = zext i8 %185 to i32
  %187 = lshr i32 %186, 4
  %188 = zext nneg i32 %187 to i64
  %189 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %188
  %190 = load i8, ptr %189, align 1, !tbaa !5
  %191 = shl i8 %190, 4
  %192 = and i32 %186, 15
  %193 = zext nneg i32 %192 to i64
  %194 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %193
  %195 = load i8, ptr %194, align 1, !tbaa !5
  %196 = or i8 %191, %195
  store i8 %196, ptr %184, align 1, !tbaa !5
  %197 = getelementptr inbounds i8, ptr %4, i64 14
  %198 = load i8, ptr %197, align 2, !tbaa !5
  %199 = zext i8 %198 to i32
  %200 = lshr i32 %199, 4
  %201 = zext nneg i32 %200 to i64
  %202 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %201
  %203 = load i8, ptr %202, align 1, !tbaa !5
  %204 = shl i8 %203, 4
  %205 = and i32 %199, 15
  %206 = zext nneg i32 %205 to i64
  %207 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %206
  %208 = load i8, ptr %207, align 1, !tbaa !5
  %209 = or i8 %204, %208
  store i8 %209, ptr %197, align 2, !tbaa !5
  %210 = getelementptr inbounds i8, ptr %4, i64 15
  %211 = load i8, ptr %210, align 1, !tbaa !5
  %212 = zext i8 %211 to i32
  %213 = lshr i32 %212, 4
  %214 = zext nneg i32 %213 to i64
  %215 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %214
  %216 = load i8, ptr %215, align 1, !tbaa !5
  %217 = shl i8 %216, 4
  %218 = and i32 %212, 15
  %219 = zext nneg i32 %218 to i64
  %220 = getelementptr inbounds [16 x i8], ptr %5, i64 0, i64 %219
  %221 = load i8, ptr %220, align 1, !tbaa !5
  %222 = or i8 %217, %221
  store i8 %222, ptr %210, align 1, !tbaa !5
  call void @permute(ptr noundef %0, ptr noundef nonnull %4, i32 noundef 1)
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %5) #2
  call void @llvm.lifetime.end.p0(i64 64, ptr nonnull %4) #2
  ret void
}

attributes #0 = { mustprogress 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 = !{!"omnipotent char", !7, i64 0}
!7 = !{!"Simple C/C++ TBAA"}


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