// #target: mingw-x64
module test;

extern fn void printf(char*, ...);

fn void test(int x)
{
    int[10] y = { [0..3] = 4, [6..8] = x };
    foreach (int v : y)
    {
        printf("%d\n", v);
    }
}

fn void main()
{
    test(101);
}

/* #expect: test.ll

define void @test.test(i32 %0) #0 {
entry:
  %y = alloca [10 x i32], align 16
  %.anon = alloca i64, align 8
  %v = alloca i32, align 4
  call void @llvm.memset.p0.i64(ptr align 16 %y, i8 0, i64 40, i1 false)
  store i32 4, ptr %y, align 4
  %ptradd = getelementptr inbounds i8, ptr %y, i64 4
  store i32 4, ptr %ptradd, align 4
  %ptradd1 = getelementptr inbounds i8, ptr %y, i64 8
  store i32 4, ptr %ptradd1, align 4
  %ptradd2 = getelementptr inbounds i8, ptr %y, i64 12
  store i32 4, ptr %ptradd2, align 4
  %ptradd3 = getelementptr inbounds i8, ptr %y, i64 24
  store i32 %0, ptr %ptradd3, align 4
  %ptradd4 = getelementptr inbounds i8, ptr %y, i64 28
  store i32 %0, ptr %ptradd4, align 4
  %ptradd5 = getelementptr inbounds i8, ptr %y, i64 32
  store i32 %0, ptr %ptradd5, align 4
  store i64 0, ptr %.anon, align 8
  br label %loop.cond

loop.cond:                                        ; preds = %loop.body, %entry
  %1 = load i64, ptr %.anon, align 8
  %gt = icmp ugt i64 10, %1
  br i1 %gt, label %loop.body, label %loop.exit

loop.body:                                        ; preds = %loop.cond
  %2 = load i64, ptr %.anon, align 8
  %ptroffset = getelementptr inbounds [4 x i8], ptr %y, i64 %2
  %3 = load i32, ptr %ptroffset, align 4
  store i32 %3, ptr %v, align 4
  %4 = load i32, ptr %v, align 4
  call void (ptr, ...) @printf(ptr @.str, i32 %4)
  %5 = load i64, ptr %.anon, align 8
  %addnuw = add nuw i64 %5, 1
  store i64 %addnuw, ptr %.anon, align 8
  br label %loop.cond

loop.exit:                                        ; preds = %loop.cond
  ret void
}