; LLVM IR from marcobambini/gravity :: src/compiler (gravity_ircode)

; 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.ircode_t = type { ptr, %struct.uint32_r, %struct.uint32_r, %struct.uint32_r, i32, i32, i32, i16, i8, [256 x i8], [256 x i8], %struct.uint32_r, %struct.context_r }
%struct.uint32_r = type { i64, i64, ptr }
%struct.context_r = type { i64, i64, ptr }

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

; Function Attrs: nounwind
declare void @free(ptr noundef) #1

; 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 void @ircode_pop_context(ptr noundef %0) #2 {
  %2 = alloca ptr, align 8
  %3 = alloca ptr, align 8
  %4 = alloca i32, align 4
  store ptr %0, ptr %2, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %3) #3
  %5 = load ptr, ptr %2, align 8, !tbaa !5
  %6 = getelementptr inbounds %struct.ircode_t, ptr %5, i32 0, i32 12
  %7 = getelementptr inbounds %struct.context_r, ptr %6, i32 0, i32 2
  %8 = load ptr, ptr %7, align 8, !tbaa !9
  %9 = load ptr, ptr %2, align 8, !tbaa !5
  %10 = getelementptr inbounds %struct.ircode_t, ptr %9, i32 0, i32 12
  %11 = getelementptr inbounds %struct.context_r, ptr %10, i32 0, i32 0
  %12 = load i64, ptr %11, align 8, !tbaa !16
  %13 = add i64 %12, -1
  store i64 %13, ptr %11, align 8, !tbaa !16
  %14 = getelementptr inbounds ptr, ptr %8, i64 %13
  %15 = load ptr, ptr %14, align 8, !tbaa !5
  store ptr %15, ptr %3, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %4) #3
  store i32 0, ptr %4, align 4, !tbaa !17
  br label %16

16:                                               ; preds = %34, %1
  %17 = load i32, ptr %4, align 4, !tbaa !17
  %18 = icmp ult i32 %17, 256
  br i1 %18, label %20, label %19

19:                                               ; preds = %16
  call void @llvm.lifetime.end.p0(i64 4, ptr %4) #3
  br label %37

20:                                               ; preds = %16
  %21 = load ptr, ptr %3, align 8, !tbaa !5
  %22 = load i32, ptr %4, align 4, !tbaa !17
  %23 = zext i32 %22 to i64
  %24 = getelementptr inbounds i8, ptr %21, i64 %23
  %25 = load i8, ptr %24, align 1, !tbaa !18, !range !19, !noundef !20
  %26 = trunc i8 %25 to i1
  br i1 %26, label %27, label %33

27:                                               ; preds = %20
  %28 = load ptr, ptr %2, align 8, !tbaa !5
  %29 = getelementptr inbounds %struct.ircode_t, ptr %28, i32 0, i32 9
  %30 = load i32, ptr %4, align 4, !tbaa !17
  %31 = zext i32 %30 to i64
  %32 = getelementptr inbounds [256 x i8], ptr %29, i64 0, i64 %31
  store i8 0, ptr %32, align 1, !tbaa !18
  br label %33

33:                                               ; preds = %27, %20
  br label %34

34:                                               ; preds = %33
  %35 = load i32, ptr %4, align 4, !tbaa !17
  %36 = add i32 %35, 1
  store i32 %36, ptr %4, align 4, !tbaa !17
  br label %16, !llvm.loop !21

37:                                               ; preds = %19
  %38 = load ptr, ptr %3, align 8, !tbaa !5
  call void @free(ptr noundef %38) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %3) #3
  ret void
}

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
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 = { 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 }

!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 648}
!10 = !{!"ircode_t", !6, i64 0, !11, i64 8, !11, i64 32, !11, i64 56, !13, i64 80, !13, i64 84, !13, i64 88, !14, i64 92, !15, i64 94, !7, i64 95, !7, i64 351, !11, i64 608, !11, i64 632}
!11 = !{!"", !12, i64 0, !12, i64 8, !6, i64 16}
!12 = !{!"long", !7, i64 0}
!13 = !{!"int", !7, i64 0}
!14 = !{!"short", !7, i64 0}
!15 = !{!"_Bool", !7, i64 0}
!16 = !{!10, !12, i64 632}
!17 = !{!13, !13, i64 0}
!18 = !{!15, !15, i64 0}
!19 = !{i8 0, i8 2}
!20 = !{}
!21 = distinct !{!21, !22}
!22 = !{!"llvm.loop.mustprogress"}


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

; Function Attrs: mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite)
declare void @free(ptr allocptr nocapture noundef) local_unnamed_addr #0

; Function Attrs: nounwind uwtable
define dso_local void @ircode_pop_context(ptr nocapture noundef %0) local_unnamed_addr #1 {
vector.memcheck:
  %1 = getelementptr inbounds i8, ptr %0, i64 632
  %2 = getelementptr inbounds i8, ptr %0, i64 648
  %3 = load ptr, ptr %2, align 8, !tbaa !5
  %4 = load i64, ptr %1, align 8, !tbaa !15
  %5 = add i64 %4, -1
  store i64 %5, ptr %1, align 8, !tbaa !15
  %6 = getelementptr inbounds ptr, ptr %3, i64 %5
  %7 = load ptr, ptr %6, align 8, !tbaa !16
  %8 = getelementptr inbounds i8, ptr %0, i64 95
  %9 = ptrtoint ptr %7 to i64
  %10 = ptrtoint ptr %0 to i64
  %11 = add i64 %10, 95
  %12 = sub i64 %11, %9
  %diff.check = icmp ult i64 %12, 32
  br i1 %diff.check, label %scalar.ph, label %vector.body

vector.body:                                      ; preds = %vector.memcheck, %pred.store.continue72
  %index = phi i64 [ %index.next, %pred.store.continue72 ], [ 0, %vector.memcheck ]
  %13 = or disjoint i64 %index, 16
  %14 = getelementptr inbounds i8, ptr %7, i64 %index
  %15 = getelementptr inbounds i8, ptr %14, i64 16
  %wide.load = load <16 x i8>, ptr %14, align 1, !tbaa !17
  %wide.load10 = load <16 x i8>, ptr %15, align 1, !tbaa !17
  %16 = trunc <16 x i8> %wide.load to <16 x i1>
  %17 = trunc <16 x i8> %wide.load10 to <16 x i1>
  %18 = extractelement <16 x i1> %16, i64 0
  br i1 %18, label %pred.store.if, label %pred.store.continue

pred.store.if:                                    ; preds = %vector.body
  %19 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %index
  store i8 0, ptr %19, align 1, !tbaa !17
  br label %pred.store.continue

pred.store.continue:                              ; preds = %pred.store.if, %vector.body
  %20 = extractelement <16 x i1> %16, i64 1
  br i1 %20, label %pred.store.if11, label %pred.store.continue12

pred.store.if11:                                  ; preds = %pred.store.continue
  %21 = or disjoint i64 %index, 1
  %22 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %21
  store i8 0, ptr %22, align 1, !tbaa !17
  br label %pred.store.continue12

pred.store.continue12:                            ; preds = %pred.store.if11, %pred.store.continue
  %23 = extractelement <16 x i1> %16, i64 2
  br i1 %23, label %pred.store.if13, label %pred.store.continue14

pred.store.if13:                                  ; preds = %pred.store.continue12
  %24 = or disjoint i64 %index, 2
  %25 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %24
  store i8 0, ptr %25, align 1, !tbaa !17
  br label %pred.store.continue14

pred.store.continue14:                            ; preds = %pred.store.if13, %pred.store.continue12
  %26 = extractelement <16 x i1> %16, i64 3
  br i1 %26, label %pred.store.if15, label %pred.store.continue16

pred.store.if15:                                  ; preds = %pred.store.continue14
  %27 = or disjoint i64 %index, 3
  %28 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %27
  store i8 0, ptr %28, align 1, !tbaa !17
  br label %pred.store.continue16

pred.store.continue16:                            ; preds = %pred.store.if15, %pred.store.continue14
  %29 = extractelement <16 x i1> %16, i64 4
  br i1 %29, label %pred.store.if17, label %pred.store.continue18

pred.store.if17:                                  ; preds = %pred.store.continue16
  %30 = or disjoint i64 %index, 4
  %31 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %30
  store i8 0, ptr %31, align 1, !tbaa !17
  br label %pred.store.continue18

pred.store.continue18:                            ; preds = %pred.store.if17, %pred.store.continue16
  %32 = extractelement <16 x i1> %16, i64 5
  br i1 %32, label %pred.store.if19, label %pred.store.continue20

pred.store.if19:                                  ; preds = %pred.store.continue18
  %33 = or disjoint i64 %index, 5
  %34 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %33
  store i8 0, ptr %34, align 1, !tbaa !17
  br label %pred.store.continue20

pred.store.continue20:                            ; preds = %pred.store.if19, %pred.store.continue18
  %35 = extractelement <16 x i1> %16, i64 6
  br i1 %35, label %pred.store.if21, label %pred.store.continue22

pred.store.if21:                                  ; preds = %pred.store.continue20
  %36 = or disjoint i64 %index, 6
  %37 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %36
  store i8 0, ptr %37, align 1, !tbaa !17
  br label %pred.store.continue22

pred.store.continue22:                            ; preds = %pred.store.if21, %pred.store.continue20
  %38 = extractelement <16 x i1> %16, i64 7
  br i1 %38, label %pred.store.if23, label %pred.store.continue24

pred.store.if23:                                  ; preds = %pred.store.continue22
  %39 = or disjoint i64 %index, 7
  %40 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %39
  store i8 0, ptr %40, align 1, !tbaa !17
  br label %pred.store.continue24

pred.store.continue24:                            ; preds = %pred.store.if23, %pred.store.continue22
  %41 = extractelement <16 x i1> %16, i64 8
  br i1 %41, label %pred.store.if25, label %pred.store.continue26

pred.store.if25:                                  ; preds = %pred.store.continue24
  %42 = or disjoint i64 %index, 8
  %43 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %42
  store i8 0, ptr %43, align 1, !tbaa !17
  br label %pred.store.continue26

pred.store.continue26:                            ; preds = %pred.store.if25, %pred.store.continue24
  %44 = extractelement <16 x i1> %16, i64 9
  br i1 %44, label %pred.store.if27, label %pred.store.continue28

pred.store.if27:                                  ; preds = %pred.store.continue26
  %45 = or disjoint i64 %index, 9
  %46 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %45
  store i8 0, ptr %46, align 1, !tbaa !17
  br label %pred.store.continue28

pred.store.continue28:                            ; preds = %pred.store.if27, %pred.store.continue26
  %47 = extractelement <16 x i1> %16, i64 10
  br i1 %47, label %pred.store.if29, label %pred.store.continue30

pred.store.if29:                                  ; preds = %pred.store.continue28
  %48 = or disjoint i64 %index, 10
  %49 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %48
  store i8 0, ptr %49, align 1, !tbaa !17
  br label %pred.store.continue30

pred.store.continue30:                            ; preds = %pred.store.if29, %pred.store.continue28
  %50 = extractelement <16 x i1> %16, i64 11
  br i1 %50, label %pred.store.if31, label %pred.store.continue32

pred.store.if31:                                  ; preds = %pred.store.continue30
  %51 = or disjoint i64 %index, 11
  %52 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %51
  store i8 0, ptr %52, align 1, !tbaa !17
  br label %pred.store.continue32

pred.store.continue32:                            ; preds = %pred.store.if31, %pred.store.continue30
  %53 = extractelement <16 x i1> %16, i64 12
  br i1 %53, label %pred.store.if33, label %pred.store.continue34

pred.store.if33:                                  ; preds = %pred.store.continue32
  %54 = or disjoint i64 %index, 12
  %55 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %54
  store i8 0, ptr %55, align 1, !tbaa !17
  br label %pred.store.continue34

pred.store.continue34:                            ; preds = %pred.store.if33, %pred.store.continue32
  %56 = extractelement <16 x i1> %16, i64 13
  br i1 %56, label %pred.store.if35, label %pred.store.continue36

pred.store.if35:                                  ; preds = %pred.store.continue34
  %57 = or disjoint i64 %index, 13
  %58 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %57
  store i8 0, ptr %58, align 1, !tbaa !17
  br label %pred.store.continue36

pred.store.continue36:                            ; preds = %pred.store.if35, %pred.store.continue34
  %59 = extractelement <16 x i1> %16, i64 14
  br i1 %59, label %pred.store.if37, label %pred.store.continue38

pred.store.if37:                                  ; preds = %pred.store.continue36
  %60 = or disjoint i64 %index, 14
  %61 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %60
  store i8 0, ptr %61, align 1, !tbaa !17
  br label %pred.store.continue38

pred.store.continue38:                            ; preds = %pred.store.if37, %pred.store.continue36
  %62 = extractelement <16 x i1> %16, i64 15
  br i1 %62, label %pred.store.if39, label %pred.store.continue40

pred.store.if39:                                  ; preds = %pred.store.continue38
  %63 = or disjoint i64 %index, 15
  %64 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %63
  store i8 0, ptr %64, align 1, !tbaa !17
  br label %pred.store.continue40

pred.store.continue40:                            ; preds = %pred.store.if39, %pred.store.continue38
  %65 = extractelement <16 x i1> %17, i64 0
  br i1 %65, label %pred.store.if41, label %pred.store.continue42

pred.store.if41:                                  ; preds = %pred.store.continue40
  %66 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %13
  store i8 0, ptr %66, align 1, !tbaa !17
  br label %pred.store.continue42

pred.store.continue42:                            ; preds = %pred.store.if41, %pred.store.continue40
  %67 = extractelement <16 x i1> %17, i64 1
  br i1 %67, label %pred.store.if43, label %pred.store.continue44

pred.store.if43:                                  ; preds = %pred.store.continue42
  %68 = or disjoint i64 %index, 17
  %69 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %68
  store i8 0, ptr %69, align 1, !tbaa !17
  br label %pred.store.continue44

pred.store.continue44:                            ; preds = %pred.store.if43, %pred.store.continue42
  %70 = extractelement <16 x i1> %17, i64 2
  br i1 %70, label %pred.store.if45, label %pred.store.continue46

pred.store.if45:                                  ; preds = %pred.store.continue44
  %71 = or disjoint i64 %index, 18
  %72 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %71
  store i8 0, ptr %72, align 1, !tbaa !17
  br label %pred.store.continue46

pred.store.continue46:                            ; preds = %pred.store.if45, %pred.store.continue44
  %73 = extractelement <16 x i1> %17, i64 3
  br i1 %73, label %pred.store.if47, label %pred.store.continue48

pred.store.if47:                                  ; preds = %pred.store.continue46
  %74 = or disjoint i64 %index, 19
  %75 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %74
  store i8 0, ptr %75, align 1, !tbaa !17
  br label %pred.store.continue48

pred.store.continue48:                            ; preds = %pred.store.if47, %pred.store.continue46
  %76 = extractelement <16 x i1> %17, i64 4
  br i1 %76, label %pred.store.if49, label %pred.store.continue50

pred.store.if49:                                  ; preds = %pred.store.continue48
  %77 = or disjoint i64 %index, 20
  %78 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %77
  store i8 0, ptr %78, align 1, !tbaa !17
  br label %pred.store.continue50

pred.store.continue50:                            ; preds = %pred.store.if49, %pred.store.continue48
  %79 = extractelement <16 x i1> %17, i64 5
  br i1 %79, label %pred.store.if51, label %pred.store.continue52

pred.store.if51:                                  ; preds = %pred.store.continue50
  %80 = or disjoint i64 %index, 21
  %81 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %80
  store i8 0, ptr %81, align 1, !tbaa !17
  br label %pred.store.continue52

pred.store.continue52:                            ; preds = %pred.store.if51, %pred.store.continue50
  %82 = extractelement <16 x i1> %17, i64 6
  br i1 %82, label %pred.store.if53, label %pred.store.continue54

pred.store.if53:                                  ; preds = %pred.store.continue52
  %83 = or disjoint i64 %index, 22
  %84 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %83
  store i8 0, ptr %84, align 1, !tbaa !17
  br label %pred.store.continue54

pred.store.continue54:                            ; preds = %pred.store.if53, %pred.store.continue52
  %85 = extractelement <16 x i1> %17, i64 7
  br i1 %85, label %pred.store.if55, label %pred.store.continue56

pred.store.if55:                                  ; preds = %pred.store.continue54
  %86 = or disjoint i64 %index, 23
  %87 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %86
  store i8 0, ptr %87, align 1, !tbaa !17
  br label %pred.store.continue56

pred.store.continue56:                            ; preds = %pred.store.if55, %pred.store.continue54
  %88 = extractelement <16 x i1> %17, i64 8
  br i1 %88, label %pred.store.if57, label %pred.store.continue58

pred.store.if57:                                  ; preds = %pred.store.continue56
  %89 = or disjoint i64 %index, 24
  %90 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %89
  store i8 0, ptr %90, align 1, !tbaa !17
  br label %pred.store.continue58

pred.store.continue58:                            ; preds = %pred.store.if57, %pred.store.continue56
  %91 = extractelement <16 x i1> %17, i64 9
  br i1 %91, label %pred.store.if59, label %pred.store.continue60

pred.store.if59:                                  ; preds = %pred.store.continue58
  %92 = or disjoint i64 %index, 25
  %93 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %92
  store i8 0, ptr %93, align 1, !tbaa !17
  br label %pred.store.continue60

pred.store.continue60:                            ; preds = %pred.store.if59, %pred.store.continue58
  %94 = extractelement <16 x i1> %17, i64 10
  br i1 %94, label %pred.store.if61, label %pred.store.continue62

pred.store.if61:                                  ; preds = %pred.store.continue60
  %95 = or disjoint i64 %index, 26
  %96 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %95
  store i8 0, ptr %96, align 1, !tbaa !17
  br label %pred.store.continue62

pred.store.continue62:                            ; preds = %pred.store.if61, %pred.store.continue60
  %97 = extractelement <16 x i1> %17, i64 11
  br i1 %97, label %pred.store.if63, label %pred.store.continue64

pred.store.if63:                                  ; preds = %pred.store.continue62
  %98 = or disjoint i64 %index, 27
  %99 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %98
  store i8 0, ptr %99, align 1, !tbaa !17
  br label %pred.store.continue64

pred.store.continue64:                            ; preds = %pred.store.if63, %pred.store.continue62
  %100 = extractelement <16 x i1> %17, i64 12
  br i1 %100, label %pred.store.if65, label %pred.store.continue66

pred.store.if65:                                  ; preds = %pred.store.continue64
  %101 = or disjoint i64 %index, 28
  %102 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %101
  store i8 0, ptr %102, align 1, !tbaa !17
  br label %pred.store.continue66

pred.store.continue66:                            ; preds = %pred.store.if65, %pred.store.continue64
  %103 = extractelement <16 x i1> %17, i64 13
  br i1 %103, label %pred.store.if67, label %pred.store.continue68

pred.store.if67:                                  ; preds = %pred.store.continue66
  %104 = or disjoint i64 %index, 29
  %105 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %104
  store i8 0, ptr %105, align 1, !tbaa !17
  br label %pred.store.continue68

pred.store.continue68:                            ; preds = %pred.store.if67, %pred.store.continue66
  %106 = extractelement <16 x i1> %17, i64 14
  br i1 %106, label %pred.store.if69, label %pred.store.continue70

pred.store.if69:                                  ; preds = %pred.store.continue68
  %107 = or disjoint i64 %index, 30
  %108 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %107
  store i8 0, ptr %108, align 1, !tbaa !17
  br label %pred.store.continue70

pred.store.continue70:                            ; preds = %pred.store.if69, %pred.store.continue68
  %109 = extractelement <16 x i1> %17, i64 15
  br i1 %109, label %pred.store.if71, label %pred.store.continue72

pred.store.if71:                                  ; preds = %pred.store.continue70
  %110 = or disjoint i64 %index, 31
  %111 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %110
  store i8 0, ptr %111, align 1, !tbaa !17
  br label %pred.store.continue72

pred.store.continue72:                            ; preds = %pred.store.if71, %pred.store.continue70
  %index.next = add nuw i64 %index, 32
  %112 = icmp eq i64 %index.next, 256
  br i1 %112, label %middle.block, label %vector.body, !llvm.loop !18

middle.block:                                     ; preds = %pred.store.continue72, %133
  tail call void @free(ptr noundef nonnull %7) #2
  ret void

scalar.ph:                                        ; preds = %vector.memcheck, %133
  %indvars.iv = phi i64 [ %indvars.iv.next.3, %133 ], [ 0, %vector.memcheck ]
  %113 = getelementptr inbounds i8, ptr %7, i64 %indvars.iv
  %114 = load i8, ptr %113, align 1, !tbaa !17, !range !22, !noundef !23
  %115 = trunc nuw i8 %114 to i1
  br i1 %115, label %116, label %scalar.ph.1

116:                                              ; preds = %scalar.ph
  %117 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %indvars.iv
  store i8 0, ptr %117, align 1, !tbaa !17
  br label %scalar.ph.1

scalar.ph.1:                                      ; preds = %scalar.ph, %116
  %indvars.iv.next = or disjoint i64 %indvars.iv, 1
  %118 = getelementptr inbounds i8, ptr %7, i64 %indvars.iv.next
  %119 = load i8, ptr %118, align 1, !tbaa !17, !range !22, !noundef !23
  %120 = trunc nuw i8 %119 to i1
  br i1 %120, label %121, label %scalar.ph.2

121:                                              ; preds = %scalar.ph.1
  %122 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %indvars.iv.next
  store i8 0, ptr %122, align 1, !tbaa !17
  br label %scalar.ph.2

scalar.ph.2:                                      ; preds = %121, %scalar.ph.1
  %indvars.iv.next.1 = or disjoint i64 %indvars.iv, 2
  %123 = getelementptr inbounds i8, ptr %7, i64 %indvars.iv.next.1
  %124 = load i8, ptr %123, align 1, !tbaa !17, !range !22, !noundef !23
  %125 = trunc nuw i8 %124 to i1
  br i1 %125, label %126, label %scalar.ph.3

126:                                              ; preds = %scalar.ph.2
  %127 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %indvars.iv.next.1
  store i8 0, ptr %127, align 1, !tbaa !17
  br label %scalar.ph.3

scalar.ph.3:                                      ; preds = %126, %scalar.ph.2
  %indvars.iv.next.2 = or disjoint i64 %indvars.iv, 3
  %128 = getelementptr inbounds i8, ptr %7, i64 %indvars.iv.next.2
  %129 = load i8, ptr %128, align 1, !tbaa !17, !range !22, !noundef !23
  %130 = trunc nuw i8 %129 to i1
  br i1 %130, label %131, label %133

131:                                              ; preds = %scalar.ph.3
  %132 = getelementptr inbounds [256 x i8], ptr %8, i64 0, i64 %indvars.iv.next.2
  store i8 0, ptr %132, align 1, !tbaa !17
  br label %133

133:                                              ; preds = %131, %scalar.ph.3
  %indvars.iv.next.3 = add nuw nsw i64 %indvars.iv, 4
  %exitcond.not.3 = icmp eq i64 %indvars.iv.next.3, 256
  br i1 %exitcond.not.3, label %middle.block, label %scalar.ph, !llvm.loop !24
}

attributes #0 = { mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" "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 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, !7, i64 648}
!6 = !{!"ircode_t", !7, i64 0, !10, i64 8, !10, i64 32, !10, i64 56, !12, i64 80, !12, i64 84, !12, i64 88, !13, i64 92, !14, i64 94, !8, i64 95, !8, i64 351, !10, i64 608, !10, i64 632}
!7 = !{!"any pointer", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"", !11, i64 0, !11, i64 8, !7, i64 16}
!11 = !{!"long", !8, i64 0}
!12 = !{!"int", !8, i64 0}
!13 = !{!"short", !8, i64 0}
!14 = !{!"_Bool", !8, i64 0}
!15 = !{!6, !11, i64 632}
!16 = !{!7, !7, i64 0}
!17 = !{!14, !14, i64 0}
!18 = distinct !{!18, !19, !20, !21}
!19 = !{!"llvm.loop.mustprogress"}
!20 = !{!"llvm.loop.isvectorized", i32 1}
!21 = !{!"llvm.loop.unroll.runtime.disable"}
!22 = !{i8 0, i8 2}
!23 = !{}
!24 = distinct !{!24, !19, !20}


; Effective O3 passes: CorrelatedValuePropagationPass,EarlyCSEPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,LICMPass,LoopLoadEliminationPass,LoopRotatePass,LoopUnrollPass,LoopVectorizePass,PostOrderFunctionAttrsPass,SROAPass,SimplifyCFGPass,TailCallElimPass