Skip to content

Instantly share code, notes, and snippets.

@ffreyer

ffreyer/code_native2.asm Secret

Last active September 2, 2022 18:46
Show Gist options
  • Save ffreyer/d63a95c21857678e8b76f40fff457a4a to your computer and use it in GitHub Desktop.
Save ffreyer/d63a95c21857678e8b76f40fff457a4a to your computer and use it in GitHub Desktop.
Download ZIP
With inlines StridedIndex
Raw
code_native2.asm
julia> @code_native debuginfo = :none syntax = :intel reflectorApply!(x, τ, y)
.text
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
and rsp, -32
sub rsp, 576
vmovq qword ptr [rsp + 472], xmm0
mov qword ptr [rsp + 400], rsi
mov qword ptr [rsp + 408], rdi
vpxor xmm0, xmm0, xmm0
vmovdqa ymmword ptr [rsp + 352], ymm0
vmovdqa ymmword ptr [rsp + 320], ymm0
vmovdqa ymmword ptr [rsp + 288], ymm0
vmovdqa ymmword ptr [rsp + 256], ymm0
vmovdqa ymmword ptr [rsp + 224], ymm0
vmovdqa ymmword ptr [rsp + 192], ymm0
vmovdqa ymmword ptr [rsp + 160], ymm0
mov rax, qword ptr fs:[0]
mov rsi, qword ptr [rax - 8]
mov qword ptr [rsp + 160], 104
mov rax, qword ptr [rsi]
mov qword ptr [rsp + 168], rax
lea rax, [rsp + 160]
mov qword ptr [rsp + 392], rsi
mov qword ptr [rsi], rax
mov rbx, qword ptr [rcx + 32]
mov qword ptr [rsp + 56], rcx
mov rcx, qword ptr [rcx + 24]
mov rax, rcx
mov qword ptr [rsp + 80], rcx
sub rbx, rcx
inc rbx
test rbx, rbx
jle L2391
mov rcx, qword ptr [rsp + 56]
mov r15, qword ptr [rcx + 8]
mov rsi, qword ptr [rcx + 16]
sub rsi, r15
inc rsi
mov rdi, rsi
sar rdi, 63
andn rdi, rdi, rsi
mov rsi, rbx
sar rsi, 63
andn rsi, rsi, rbx
mov qword ptr [rsp + 464], rsi
mov r9, qword ptr [rcx]
mov rbx, qword ptr [r9 + 24]
mov r10, qword ptr [rdx]
mov r12, qword ptr [rdx + 24]
dec r12
imul r12, qword ptr [r10 + 24]
mov rsi, qword ptr [rsp + 80]
lea r8, [rsi - 1]
mov qword ptr [rsp + 456], rbx
imul r8, rbx
lea rsi, [r15 + r8]
dec rsi
shl rsi, 3
mov qword ptr [rsp + 440], rsi
lea rsi, [rdi - 2]
cmp rdi, 18
setl r11b
mov qword ptr [rsp + 104], rsi
cmp rsi, 15
setne bl
and bl, r11b
mov byte ptr [rsp + 31], bl
lea rax, [rdi - 1]
mov r14, rax
and r14, -16
and rax, -8
lea ecx, [rdi + 2]
and ecx, 3
xor esi, esi
cmp rdi, 1
mov ebx, 3
cmovg rbx, rcx
vmovq xmm0, rbx
cmovle r14, rsi
cmovle rax, rsi
mov qword ptr [rsp + 72], rax
lea rax, [r15 - 1]
mov qword ptr [rsp + 432], rax
shl r15, 3
lea rax, [r15 + 8*r8]
add rax, 96
mov qword ptr [rsp + 88], rax
mov rax, qword ptr [rdx + 8]
lea rdx, [rax + r12]
shl rax, 3
lea rax, [rax + 8*r12]
mov qword ptr [rsp + 448], r10
mov rcx, qword ptr [r10]
lea rdx, [rcx + 8*rdx]
mov qword ptr [rsp + 40], rdx
lea r12, [rcx + rax + 96]
movabs rax, offset .rodata.cst8
vpbroadcastq ymm1, qword ptr [rax]
movabs rax, offset .rodata.cst32
vmovdqa ymm2, ymmword ptr [rax]
vpbroadcastq ymm0, xmm0
vpxor ymm0, ymm0, ymm1
lea rax, [rdi - 6]
mov qword ptr [rsp + 64], rax
lea rax, [rdi - 10]
mov qword ptr [rsp + 424], rax
add rdi, -14
mov qword ptr [rsp + 416], rdi
vpcmpgtq ymm1, ymm2, ymm0
vpcmpeqd ymm0, ymm0, ymm0
vmovdqa ymmword ptr [rsp + 512], ymm1
vpxor ymm0, ymm1, ymm0
vmovdqa ymmword ptr [rsp + 480], ymm0
mov qword ptr [rsp + 112], r9
mov rax, qword ptr [r9]
mov qword ptr [rsp + 96], rax
mov ecx, 1
jmp L680
nop word ptr cs:[rax + rax]
L608:
mov rax, qword ptr [rsp + 40]
vmovapd ymm3, ymmword ptr [rsp + 480]
vmaskmovpd ymm0, ymm3, ymmword ptr [rax + 8*r14]
mov rax, qword ptr [rsp + 32]
vmaskmovpd ymm1, ymm3, ymmword ptr [rax + 8*r14]
vbroadcastsd ymm2, xmm7
vfnmadd213pd ymm2, ymm0, ymm1 # ymm2 = -(ymm0 * ymm2) + ymm1
vmaskmovpd ymmword ptr [rax + 8*r14], ymm3, ymm2
L655:
lea rax, [rcx + 1]
add rsi, 8
cmp rcx, qword ptr [rsp + 464]
mov rcx, rax
je L2391
L680:
mov qword ptr [rsp + 136], rcx
mov qword ptr [rsp + 128], rsi
mov rax, qword ptr [rsp + 80]
add rcx, rax
add rcx, -2
imul rcx, qword ptr [rsp + 456]
add rcx, qword ptr [rsp + 432]
mov rax, qword ptr [rsp + 96]
mov qword ptr [rsp + 48], rcx
vmovsd xmm0, qword ptr [rax + 8*rcx] # xmm0 = mem[0],zero
vmovsd qword ptr [rsp + 144], xmm0
movabs r13, offset jl_system_image_data
mov qword ptr [rsp + 280], r13
mov rax, qword ptr [rsp + 448]
mov qword ptr [rsp + 376], rax
mov rax, qword ptr [rsp + 112]
mov qword ptr [rsp + 368], rax
mov esi, 1
lea rdi, [rsp + 280]
movabs r15, offset "#1"
vzeroupper
call r15
mov qword ptr [rsp + 296], r13
mov esi, 2
lea rdi, [rsp + 296]
call r15
mov qword ptr [rsp + 320], r13
mov esi, 1
lea rdi, [rsp + 320]
call r15
mov qword ptr [rsp + 360], r13
mov esi, 2
lea rdi, [rsp + 360]
call r15
mov qword ptr [rsp + 272], r13
mov esi, 1
lea rdi, [rsp + 272]
call r15
mov qword ptr [rsp + 232], r13
movabs rbx, offset jl_system_image_data
mov esi, 2
lea rdi, [rsp + 232]
call r15
mov r13, qword ptr [rsp + 112]
mov rcx, qword ptr [r13]
mov rax, qword ptr [rsp + 440]
mov qword ptr [rsp + 120], rcx
add rax, rcx
mov qword ptr [rsp + 32], rax
mov qword ptr [rsp + 312], rbx
mov esi, 1
lea rdi, [rsp + 312]
call r15
mov qword ptr [rsp + 176], rbx
mov esi, 2
lea rdi, [rsp + 176]
call r15
mov qword ptr [rsp + 352], rbx
mov esi, 1
lea rdi, [rsp + 352]
call r15
mov qword ptr [rsp + 200], rbx
mov esi, 2
lea rdi, [rsp + 200]
call r15
mov qword ptr [rsp + 248], rbx
mov esi, 1
lea rdi, [rsp + 248]
call r15
mov qword ptr [rsp + 304], rbx
mov esi, 2
lea rdi, [rsp + 304]
call r15
mov rbx, qword ptr [r13 + 24]
mov rax, qword ptr [rsp + 136]
lea rax, [8*rax - 8]
imul rax, rbx
cmp byte ptr [rsp + 31], 0
je L1200
vxorpd xmm0, xmm0, xmm0
xor ecx, ecx
vpxor xmm1, xmm1, xmm1
mov rdx, qword ptr [rsp + 72]
vmovsd xmm5, qword ptr [rsp + 144] # xmm5 = mem[0],zero
mov rdi, qword ptr [rsp + 32]
jmp L1341
nop word ptr [rax + rax]
L1200:
mov rcx, qword ptr [rsp + 88]
mov rsi, qword ptr [rsp + 120]
lea rdx, [rsi + rcx]
mov rcx, rbx
imul rcx, qword ptr [rsp + 128]
add rcx, rdx
vpxor xmm1, xmm1, xmm1
vxorpd xmm0, xmm0, xmm0
vpxor xmm2, xmm2, xmm2
vxorpd xmm3, xmm3, xmm3
xor edx, edx
nop
L1248:
vmovupd ymm4, ymmword ptr [r12 + 8*rdx - 96]
vmovupd ymm5, ymmword ptr [r12 + 8*rdx - 64]
vmovupd ymm6, ymmword ptr [r12 + 8*rdx - 32]
vmovupd ymm7, ymmword ptr [r12 + 8*rdx]
vfmadd231pd ymm3, ymm4, ymmword ptr [rcx + 8*rdx - 96] # ymm3 = (ymm4 * mem) + ymm3
vfmadd231pd ymm2, ymm5, ymmword ptr [rcx + 8*rdx - 64] # ymm2 = (ymm5 * mem) + ymm2
vfmadd231pd ymm0, ymm6, ymmword ptr [rcx + 8*rdx - 32] # ymm0 = (ymm6 * mem) + ymm0
vfmadd231pd ymm1, ymm7, ymmword ptr [rcx + 8*rdx] # ymm1 = (ymm7 * mem) + ymm1
add rdx, 16
cmp r14, rdx
jne L1248
vaddpd ymm0, ymm3, ymm0
vaddpd ymm1, ymm2, ymm1
mov rcx, r14
mov rdx, qword ptr [rsp + 72]
vmovsd xmm5, qword ptr [rsp + 144] # xmm5 = mem[0],zero
mov rdi, qword ptr [rsp + 32]
L1341:
add rdi, rax
add rdi, 8
cmp rcx, rdx
jne L1360
mov rcx, rdx
jmp L1393
nop
L1360:
mov rax, qword ptr [rsp + 40]
vmovupd ymm2, ymmword ptr [rax + 8*rcx]
vmovupd ymm3, ymmword ptr [rax + 8*rcx + 32]
vfmadd231pd ymm0, ymm2, ymmword ptr [rdi + 8*rcx] # ymm0 = (ymm2 * mem) + ymm0
vfmadd231pd ymm1, ymm3, ymmword ptr [rdi + 8*rcx + 32] # ymm1 = (ymm3 * mem) + ymm1
or rcx, 8
L1393:
cmp rcx, qword ptr [rsp + 104]
mov qword ptr [rsp + 32], rdi
jle L1424
mov rcx, qword ptr [rsp + 48]
jmp L1552
nop word ptr [rax + rax]
L1424:
cmp qword ptr [rsp + 64], rcx
jge L1488
mov rax, qword ptr [rsp + 40]
vmovapd ymm3, ymmword ptr [rsp + 480]
vmaskmovpd ymm2, ymm3, ymmword ptr [rax + 8*rcx]
vmaskmovpd ymm3, ymm3, ymmword ptr [rdi + 8*rcx]
vfmadd213pd ymm3, ymm2, ymm0 # ymm3 = (ymm2 * ymm3) + ymm0
vmovapd ymm2, ymmword ptr [rsp + 512]
vblendvpd ymm0, ymm3, ymm0, ymm2
mov rcx, qword ptr [rsp + 48]
jmp L1552
nop dword ptr [rax]
L1488:
mov rax, qword ptr [rsp + 40]
vmovapd ymm3, ymmword ptr [rsp + 480]
vmaskmovpd ymm2, ymm3, ymmword ptr [rax + 8*rcx + 32]
vmaskmovpd ymm3, ymm3, ymmword ptr [rdi + 8*rcx + 32]
vmovupd ymm4, ymmword ptr [rax + 8*rcx]
vfmadd231pd ymm0, ymm4, ymmword ptr [rdi + 8*rcx] # ymm0 = (ymm4 * mem) + ymm0
vfmadd213pd ymm3, ymm2, ymm1 # ymm3 = (ymm2 * ymm3) + ymm1
vmovapd ymm2, ymmword ptr [rsp + 512]
vblendvpd ymm1, ymm3, ymm1, ymm2
mov rcx, qword ptr [rsp + 48]
L1552:
vaddpd ymm0, ymm0, ymm1
vextractf128 xmm1, ymm0, 1
vaddpd xmm0, xmm0, xmm1
vpermilpd xmm1, xmm0, 1 # xmm1 = xmm0[1,0]
vaddsd xmm0, xmm0, xmm1
vaddsd xmm0, xmm5, xmm0
vmulsd xmm1, xmm0, qword ptr [rsp + 472]
vmovapd xmmword ptr [rsp + 144], xmm1
mov rax, qword ptr [rsp + 96]
vmovsd xmm0, qword ptr [rax + 8*rcx] # xmm0 = mem[0],zero
vsubsd xmm0, xmm0, xmm1
vmovsd qword ptr [rax + 8*rcx], xmm0
movabs r15, offset jl_system_image_data
mov qword ptr [rsp + 216], r15
mov esi, 1
lea rdi, [rsp + 216]
movabs r13, offset "#1"
vzeroupper
call r13
mov qword ptr [rsp + 288], r15
mov esi, 2
lea rdi, [rsp + 288]
call r13
mov qword ptr [rsp + 344], r15
mov esi, 1
lea rdi, [rsp + 344]
call r13
mov qword ptr [rsp + 208], r15
mov esi, 2
lea rdi, [rsp + 208]
call r13
mov qword ptr [rsp + 224], r15
mov esi, 1
lea rdi, [rsp + 224]
call r13
mov qword ptr [rsp + 240], r15
mov esi, 2
lea rdi, [rsp + 240]
call r13
movabs r15, offset jl_system_image_data
mov qword ptr [rsp + 192], r15
mov esi, 1
lea rdi, [rsp + 192]
call r13
mov qword ptr [rsp + 256], r15
mov esi, 2
lea rdi, [rsp + 256]
call r13
mov qword ptr [rsp + 336], r15
mov esi, 1
lea rdi, [rsp + 336]
call r13
mov qword ptr [rsp + 328], r15
mov esi, 2
lea rdi, [rsp + 328]
call r13
mov qword ptr [rsp + 264], r15
mov esi, 1
lea rdi, [rsp + 264]
call r13
mov qword ptr [rsp + 184], r15
mov esi, 2
lea rdi, [rsp + 184]
call r13
vmovapd xmm7, xmmword ptr [rsp + 144]
test r14, r14
mov rsi, qword ptr [rsp + 128]
je L2070
vbroadcastsd ymm0, xmm7
mov rax, qword ptr [rsp + 120]
add rax, qword ptr [rsp + 88]
imul rbx, rsi
add rbx, rax
xor eax, eax
L1984:
vmovupd ymm1, ymmword ptr [r12 + 8*rax - 96]
vmovupd ymm2, ymmword ptr [r12 + 8*rax - 64]
vmovupd ymm3, ymmword ptr [r12 + 8*rax - 32]
vmovupd ymm4, ymmword ptr [r12 + 8*rax]
vfnmadd213pd ymm1, ymm0, ymmword ptr [rbx + 8*rax - 96] # ymm1 = -(ymm0 * ymm1) + mem
vfnmadd213pd ymm2, ymm0, ymmword ptr [rbx + 8*rax - 64] # ymm2 = -(ymm0 * ymm2) + mem
vfnmadd213pd ymm3, ymm0, ymmword ptr [rbx + 8*rax - 32] # ymm3 = -(ymm0 * ymm3) + mem
vfnmadd213pd ymm4, ymm0, ymmword ptr [rbx + 8*rax] # ymm4 = -(ymm0 * ymm4) + mem
vmovupd ymmword ptr [rbx + 8*rax - 96], ymm1
vmovupd ymmword ptr [rbx + 8*rax - 64], ymm2
vmovupd ymmword ptr [rbx + 8*rax - 32], ymm3
vmovupd ymmword ptr [rbx + 8*rax], ymm4
add rax, 16
cmp r14, rax
jne L1984
L2070:
cmp r14, qword ptr [rsp + 104]
mov rcx, qword ptr [rsp + 136]
jg L655
cmp qword ptr [rsp + 64], r14
jl L608
cmp qword ptr [rsp + 424], r14
jge L2183
mov rax, qword ptr [rsp + 40]
vmovapd ymm4, ymmword ptr [rsp + 480]
vmaskmovpd ymm0, ymm4, ymmword ptr [rax + 8*r14 + 32]
vmovupd ymm1, ymmword ptr [rax + 8*r14]
mov rax, qword ptr [rsp + 32]
vmaskmovpd ymm2, ymm4, ymmword ptr [rax + 8*r14 + 32]
vbroadcastsd ymm3, xmm7
vfnmadd213pd ymm1, ymm3, ymmword ptr [rax + 8*r14] # ymm1 = -(ymm3 * ymm1) + mem
vfnmadd231pd ymm2, ymm3, ymm0 # ymm2 = -(ymm3 * ymm0) + ymm2
vmovupd ymmword ptr [rax + 8*r14], ymm1
vmaskmovpd ymmword ptr [rax + 8*r14 + 32], ymm4, ymm2
jmp L655
L2183:
mov rax, qword ptr [rsp + 40]
vmovupd ymm1, ymmword ptr [rax + 8*r14]
vmovupd ymm0, ymmword ptr [rax + 8*r14 + 32]
cmp qword ptr [rsp + 416], r14
jge L2293
lea rax, [rax + 8*r14]
add rax, 64
vmovapd ymm5, ymmword ptr [rsp + 480]
vmaskmovpd ymm2, ymm5, ymmword ptr [rax]
mov rax, qword ptr [rsp + 32]
vmaskmovpd ymm3, ymm5, ymmword ptr [rax + 8*r14 + 64]
vbroadcastsd ymm4, xmm7
vfnmadd213pd ymm1, ymm4, ymmword ptr [rax + 8*r14] # ymm1 = -(ymm4 * ymm1) + mem
vfnmadd213pd ymm0, ymm4, ymmword ptr [rax + 8*r14 + 32] # ymm0 = -(ymm4 * ymm0) + mem
vfnmadd231pd ymm3, ymm4, ymm2 # ymm3 = -(ymm4 * ymm2) + ymm3
vmovupd ymmword ptr [rax + 8*r14], ymm1
vmovupd ymmword ptr [rax + 8*r14 + 32], ymm0
vmaskmovpd ymmword ptr [rax + 8*r14 + 64], ymm5, ymm3
jmp L655
L2293:
lea rax, [rax + 8*r14]
vmovapd ymm6, ymmword ptr [rsp + 480]
vmaskmovpd ymm2, ymm6, ymmword ptr [rax + 96]
mov rdx, qword ptr [rsp + 32]
vmaskmovpd ymm3, ymm6, ymmword ptr [rdx + 8*r14 + 96]
vbroadcastsd ymm4, xmm7
vfnmadd213pd ymm1, ymm4, ymmword ptr [rdx + 8*r14] # ymm1 = -(ymm4 * ymm1) + mem
vfnmadd213pd ymm0, ymm4, ymmword ptr [rdx + 8*r14 + 32] # ymm0 = -(ymm4 * ymm0) + mem
vmovupd ymm5, ymmword ptr [rax + 64]
vfnmadd213pd ymm5, ymm4, ymmword ptr [rdx + 8*r14 + 64] # ymm5 = -(ymm4 * ymm5) + mem
vfnmadd231pd ymm3, ymm4, ymm2 # ymm3 = -(ymm4 * ymm2) + ymm3
vmovupd ymmword ptr [rdx + 8*r14], ymm1
vmovupd ymmword ptr [rdx + 8*r14 + 32], ymm0
vmovupd ymmword ptr [rdx + 8*r14 + 64], ymm5
vmaskmovpd ymmword ptr [rdx + 8*r14 + 96], ymm6, ymm3
jmp L655
L2391:
mov rcx, qword ptr [rsp + 56]
mov rax, qword ptr [rcx]
mov rdx, qword ptr [rsp + 400]
mov qword ptr [rdx], rax
vmovups ymm0, ymmword ptr [rcx]
vmovups ymm1, ymmword ptr [rcx + 24]
mov rax, qword ptr [rsp + 408]
vmovups ymmword ptr [rax + 24], ymm1
vmovups ymmword ptr [rax], ymm0
mov rcx, qword ptr [rsp + 168]
mov rdx, qword ptr [rsp + 392]
mov qword ptr [rdx], rcx
lea rsp, [rbp - 40]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
vzeroupper
ret
nop dword ptr [rax]
Raw
code_typed.jl
julia> @code_typed reflectorApply!(x, τ, y)
CodeInfo(
1 ─── %1 = Base.getfield(A, :indices)::Tuple{UnitRange{Int64}, UnitRange{Int64}}
│ %2 = Core.getfield(%1, 1)::UnitRange{Int64}
│ %3 = Core.getfield(%1, 2)::UnitRange{Int64}
│ %4 = Base.getfield(%2, :stop)::Int64
│ %5 = Base.getfield(%2, :start)::Int64
│ %6 = Base.sub_int(%4, %5)::Int64
│ %7 = Base.add_int(%6, 1)::Int64
│ %8 = Base.slt_int(%7, 0)::Bool
│ %9 = Base.ifelse(%8, 0, %7)::Int64
│ %10 = Base.getfield(%3, :stop)::Int64
│ %11 = Base.getfield(%3, :start)::Int64
│ %12 = Base.sub_int(%10, %11)::Int64
│ %13 = Base.add_int(%12, 1)::Int64
│ %14 = Base.slt_int(%13, 0)::Bool
│ %15 = Base.ifelse(%14, 0, %13)::Int64
│ %16 = Base.sle_int(1, %15)::Bool
│ %17 = Base.ifelse(%16, %15, 0)::Int64
│ %18 = Base.slt_int(%17, 1)::Bool
└──── goto #3 if not %18
2 ─── Base.nothing::Nothing
└──── goto #4
3 ─── goto #4
4 ┄── %23 = φ (#2 => true, #3 => false)::Bool
│ %24 = φ (#3 => 1)::Int64
│ %25 = φ (#3 => 1)::Int64
│ %26 = Base.not_int(%23)::Bool
└──── goto #151 if not %26
5 ┄── %28 = φ (#4 => %24, #150 => %738)::Int64
│ %29 = φ (#4 => %25, #150 => %739)::Int64
└──── goto #10 if not false
6 ─── %31 = Core.tuple(1, %28)::Tuple{Int64, Int64}
│ %32 = Base.getfield(A, :indices)::Tuple{UnitRange{Int64}, UnitRange{Int64}}
│ %33 = Core.getfield(%32, 1)::UnitRange{Int64}
│ %34 = Core.getfield(%32, 2)::UnitRange{Int64}
│ %35 = Base.getfield(%33, :stop)::Int64
│ %36 = Base.getfield(%33, :start)::Int64
│ %37 = Base.sub_int(%35, %36)::Int64
│ %38 = Base.add_int(%37, 1)::Int64
│ %39 = Base.slt_int(%38, 0)::Bool
│ %40 = Base.ifelse(%39, 0, %38)::Int64
│ %41 = Base.getfield(%34, :stop)::Int64
│ %42 = Base.getfield(%34, :start)::Int64
│ %43 = Base.sub_int(%41, %42)::Int64
│ %44 = Base.add_int(%43, 1)::Int64
│ %45 = Base.slt_int(%44, 0)::Bool
│ %46 = Base.ifelse(%45, 0, %44)::Int64
│ %47 = Base.sle_int(1, 1)::Bool
│ %48 = Base.sle_int(1, %40)::Bool
│ %49 = Base.and_int(%47, %48)::Bool
│ %50 = Base.sle_int(1, %28)::Bool
│ %51 = Base.sle_int(%28, %46)::Bool
│ %52 = Base.and_int(%50, %51)::Bool
│ %53 = Base.and_int(%52, true)::Bool
│ %54 = Base.and_int(%49, %53)::Bool
└──── goto #8 if not %54
7 ─── Base.nothing::Nothing
└──── goto #9
8 ─── invoke Base.throw_boundserror(A::SubArray{Float64, 2, Matrix{Float64}, Tuple{UnitRange{Int64}, UnitRange{Int64}}, false}, %31::Tuple{Int64, Int64})::Union{}
└──── unreachable
9 ─── nothing::Nothing
10 ┄─ %61 = Base.getfield(A, :indices)::Tuple{UnitRange{Int64}, UnitRange{Int64}}
│ %62 = Base.getfield(%61, 1, false)::UnitRange{Int64}
│ %63 = Base.getfield(%62, :start)::Int64
│ %64 = Base.sub_int(1, 1)::Int64
│ %65 = Base.add_int(%63, %64)::Int64
└──── goto #19 if not false
11 ── %67 = Base.slt_int(0, 1)::Bool
└──── goto #15 if not %67
12 ── %69 = Base.getfield(%62, :stop)::Int64
│ %70 = Base.sle_int(%65, %69)::Bool
└──── goto #14 if not %70
13 ── %72 = Base.getfield(%62, :start)::Int64
│ %73 = Base.sle_int(%72, %65)::Bool
└──── goto #16
14 ── goto #16
15 ── goto #16
16 ┄─ %77 = φ (#13 => %73, #14 => false, #15 => false)::Bool
└──── goto #18 if not %77
17 ── goto #19
18 ── invoke Base.throw_boundserror(%62::UnitRange{Int64}, 1::Int64)::Union{}
└──── unreachable
19 ┄─ goto #20
20 ── %83 = Core.getfield(%61, 2)::UnitRange{Int64}
│ %84 = Base.getfield(%83, :start)::Int64
│ %85 = Base.sub_int(%28, 1)::Int64
│ %86 = Base.add_int(%84, %85)::Int64
└──── goto #29 if not false
21 ── %88 = Base.slt_int(0, %28)::Bool
└──── goto #25 if not %88
22 ── %90 = Base.getfield(%83, :stop)::Int64
│ %91 = Base.sle_int(%86, %90)::Bool
└──── goto #24 if not %91
23 ── %93 = Base.getfield(%83, :start)::Int64
│ %94 = Base.sle_int(%93, %86)::Bool
└──── goto #26
24 ── goto #26
25 ── goto #26
26 ┄─ %98 = φ (#23 => %94, #24 => false, #25 => false)::Bool
└──── goto #28 if not %98
27 ── goto #29
28 ── invoke Base.throw_boundserror(%83::UnitRange{Int64}, %28::Int64)::Union{}
└──── unreachable
29 ┄─ goto #30
30 ── goto #31
31 ── goto #32
32 ── %106 = Base.getfield(A, :parent)::Matrix{Float64}
│ %107 = Base.arrayref(false, %106, %65, %86)::Float64
└──── goto #33
33 ── %109 = Base.slt_int(%9, 2)::Bool
└──── goto #35 if not %109
34 ── goto #36
35 ── goto #36
36 ┄─ goto #37
37 ── goto #38
38 ── %115 = Base.getfield(x, :parent)::Matrix{Float64}
│ %116 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%115)))::Ptr{Float64}
│ %117 = Base.getfield(x, :parent)::Matrix{Float64}
│ %118 = Base.getfield(x, :indices)::Tuple{UnitRange{Int64}, Int64}
│ %119 = LayoutPointers.getfield(%118, 1, false)::UnitRange{Int64}
│ %120 = Base.getfield(%119, :start)::Int64
│ %121 = Base.sub_int(%120, 1)::Int64
│ %122 = Core.getfield(%118, 2)::Int64
│ %123 = Base.sub_int(%122, 1)::Int64
│ %124 = Base.arraysize(%117, 1)::Int64
│ Base.arraysize(%117, 2)::Int64
│ %126 = Base.mul_int(1, %124)::Int64
│ %127 = Base.mul_int(%121, 1)::Int64
│ %128 = Base.mul_int(%123, %126)::Int64
│ %129 = Base.add_int(%127, %128)::Int64
│ %130 = Base.mul_int(8, %129)::Int64
│ %131 = Core.bitcast(Core.UInt, %116)::UInt64
│ %132 = Base.bitcast(UInt64, %130)::UInt64
│ %133 = Base.add_ptr(%131, %132)::UInt64
│ %134 = Core.bitcast(Ptr{Float64}, %133)::Ptr{Float64}
│ %135 = ArrayInterfaceCore.is_splat_index::typeof(ArrayInterfaceCore.is_splat_index)
│ %136 = %new(ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}, %135, Tuple{UnitRange{Int64}, Int64})::ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}
│ invoke %136(1::Int64)::Bool
│ invoke %136(2::Int64)::Bool
│ %139 = ArrayInterfaceCore.is_splat_index::typeof(ArrayInterfaceCore.is_splat_index)
│ %140 = %new(ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}, %139, Tuple{UnitRange{Int64}, Int64})::ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}
│ invoke %140(1::Int64)::Bool
│ invoke %140(2::Int64)::Bool
│ %143 = ArrayInterfaceCore.is_splat_index::typeof(ArrayInterfaceCore.is_splat_index)
│ %144 = %new(ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}, %143, Tuple{UnitRange{Int64}, Int64})::ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}
│ invoke %144(1::Int64)::Bool
│ invoke %144(2::Int64)::Bool
│ %147 = Base.getfield(x, :parent)::Matrix{Float64}
│ Base.arraysize(%147, 1)::Int64
│ Base.arraysize(%147, 2)::Int64
│ %150 = Base.getfield(A, :parent)::Matrix{Float64}
│ %151 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%150)))::Ptr{Float64}
│ %152 = Base.getfield(A, :parent)::Matrix{Float64}
│ %153 = Base.getfield(A, :indices)::Tuple{UnitRange{Int64}, UnitRange{Int64}}
│ %154 = LayoutPointers.getfield(%153, 1, false)::UnitRange{Int64}
│ %155 = Base.getfield(%154, :start)::Int64
│ %156 = Base.sub_int(%155, 1)::Int64
│ %157 = Core.getfield(%153, 2)::UnitRange{Int64}
│ %158 = Base.getfield(%157, :start)::Int64
│ %159 = Base.sub_int(%158, 1)::Int64
│ %160 = Base.arraysize(%152, 1)::Int64
│ Base.arraysize(%152, 2)::Int64
│ %162 = Base.mul_int(1, %160)::Int64
│ %163 = Base.mul_int(%156, 1)::Int64
│ %164 = Base.mul_int(%159, %162)::Int64
│ %165 = Base.add_int(%163, %164)::Int64
│ %166 = Base.mul_int(8, %165)::Int64
│ %167 = Core.bitcast(Core.UInt, %151)::UInt64
│ %168 = Base.bitcast(UInt64, %166)::UInt64
│ %169 = Base.add_ptr(%167, %168)::UInt64
│ %170 = Core.bitcast(Ptr{Float64}, %169)::Ptr{Float64}
│ %171 = ArrayInterfaceCore.is_splat_index::typeof(ArrayInterfaceCore.is_splat_index)
│ %172 = %new(ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}, %171, Tuple{UnitRange{Int64}, UnitRange{Int64}})::ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}
│ invoke %172(1::Int64)::Bool
│ invoke %172(2::Int64)::Bool
│ %175 = ArrayInterfaceCore.is_splat_index::typeof(ArrayInterfaceCore.is_splat_index)
│ %176 = %new(ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}, %175, Tuple{UnitRange{Int64}, UnitRange{Int64}})::ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}
│ invoke %176(1::Int64)::Bool
│ invoke %176(2::Int64)::Bool
│ %179 = ArrayInterfaceCore.is_splat_index::typeof(ArrayInterfaceCore.is_splat_index)
│ %180 = %new(ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}, %179, Tuple{UnitRange{Int64}, UnitRange{Int64}})::ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}
│ invoke %180(1::Int64)::Bool
│ invoke %180(2::Int64)::Bool
│ %183 = Base.getfield(A, :parent)::Matrix{Float64}
│ %184 = Base.arraysize(%183, 1)::Int64
│ Base.arraysize(%183, 2)::Int64
│ %186 = Base.mul_int(1, %184)::Int64
│ %187 = Base.mul_int(1, %186)::Int64
│ %188 = Base.mul_int(8, %187)::Int64
│ %189 = Base.llvmcall("%res = sub nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, %28, 1)::Int64
│ %190 = Base.llvmcall("%res = mul nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, %189, %188)::Int64
│ %191 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to i8*\n%ptr.1 = getelementptr inbounds i8, i8* %ptr.0, i64 %1\n%ptr.2 = ptrtoint i8* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %170, %190)::Ptr{Float64}
│ %192 = Base.llvmcall((" \n\n define i64 @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}}, %134)::Ptr{Float64}
│ %193 = Base.llvmcall((" \n\n define i64 @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}}, %191)::Ptr{Float64}
│ %194 = $(Expr(:gc_preserve_begin, :(%115), :(%150)))
│ %195 = Base.sub_int(%9, 2)::Int64
│ %196 = Base.slt_int(%195, 0)::Bool
└──── goto #40 if not %196
39 ── goto #41
40 ── %199 = Base.sub_int(%195, 0)::Int64
│ %200 = Base.add_int(%199, 1)::Int64
└──── goto #41
41 ┄─ %202 = φ (#39 => 0, #40 => %200)::Int64
└──── goto #42
42 ── goto #43
43 ── %205 = Base.slt_int(0, %195)::Bool
│ %206 = (0 === %195)::Bool
│ %207 = Base.or_int(%205, %206)::Bool
│ Base.llvmcall((" declare void @llvm.assume(i1)\n\n define void @entry(i8) alwaysinline {\n top:\n %b = trunc i8 %0 to i1\ncall void @llvm.assume(i1 %b)\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Bool}, %207)::Nothing
│ %209 = Base.slt_int(15, %195)::Bool
│ %210 = (15 === %195)::Bool
│ %211 = Base.or_int(%209, %210)::Bool
└──── goto #52 if not %211
44 ── %213 = Base.llvmcall("ret <4 x double> zeroinitializer", NTuple{4, VecElement{Float64}}, Tuple{})::NTuple{4, VecElement{Float64}}
│ %214 = Base.llvmcall("ret <4 x double> zeroinitializer", NTuple{4, VecElement{Float64}}, Tuple{})::NTuple{4, VecElement{Float64}}
│ %215 = Base.llvmcall("ret <4 x double> zeroinitializer", NTuple{4, VecElement{Float64}}, Tuple{})::NTuple{4, VecElement{Float64}}
└──── %216 = Base.llvmcall("ret <4 x double> zeroinitializer", NTuple{4, VecElement{Float64}}, Tuple{})::NTuple{4, VecElement{Float64}}
45 ┄─ %217 = φ (#44 => 0, #50 => %242)::Int64
│ %218 = φ (#44 => true, #50 => %252)::Bool
│ %219 = φ (#44 => %213, #50 => %238)::NTuple{4, VecElement{Float64}}
│ %220 = φ (#44 => %214, #50 => %239)::NTuple{4, VecElement{Float64}}
│ %221 = φ (#44 => %215, #50 => %240)::NTuple{4, VecElement{Float64}}
│ %222 = φ (#44 => %216, #50 => %241)::NTuple{4, VecElement{Float64}}
│ %223 = φ (#44 => %213, #50 => %238)::NTuple{4, VecElement{Float64}}
│ %224 = φ (#44 => %215, #50 => %240)::NTuple{4, VecElement{Float64}}
│ %225 = φ (#44 => %214, #50 => %239)::NTuple{4, VecElement{Float64}}
│ %226 = φ (#44 => %216, #50 => %241)::NTuple{4, VecElement{Float64}}
└──── goto #51 if not %218
46 ── %228 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %192, %217)::Ptr{Float64}
│ %229 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.1, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %228)::NTuple{4, VecElement{Float64}}
│ %230 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %228)::NTuple{4, VecElement{Float64}}
│ %231 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 8\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %228)::NTuple{4, VecElement{Float64}}
│ %232 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 12\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %228)::NTuple{4, VecElement{Float64}}
│ %233 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %193, %217)::Ptr{Float64}
│ %234 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.1, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %233)::NTuple{4, VecElement{Float64}}
│ %235 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %233)::NTuple{4, VecElement{Float64}}
│ %236 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 8\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %233)::NTuple{4, VecElement{Float64}}
│ %237 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 12\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %233)::NTuple{4, VecElement{Float64}}
│ %238 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %229, %234, %219)::NTuple{4, VecElement{Float64}}
│ %239 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %230, %235, %220)::NTuple{4, VecElement{Float64}}
│ %240 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %231, %236, %221)::NTuple{4, VecElement{Float64}}
│ %241 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %232, %237, %222)::NTuple{4, VecElement{Float64}}
│ %242 = Base.llvmcall("%res = add nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, 16, %217)::Int64
│ %243 = Base.slt_int(%195, 0)::Bool
└──── goto #48 if not %243
47 ── goto #49
48 ── %246 = Base.sub_int(%195, 0)::Int64
│ %247 = Base.add_int(%246, 1)::Int64
└──── goto #49
49 ┄─ %249 = φ (#47 => 0, #48 => %247)::Int64
│ %250 = Base.and_int(%249, -16)::Int64
│ %251 = (%242 === %250)::Bool
│ %252 = Base.not_int(%251)::Bool
└──── goto #50
50 ── goto #45
51 ── %255 = Base.llvmcall("%res = fadd nsz contract <4 x double> %0, %1\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %223, %224)::NTuple{4, VecElement{Float64}}
│ %256 = Base.llvmcall("%res = fadd nsz contract <4 x double> %0, %1\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %225, %226)::NTuple{4, VecElement{Float64}}
└──── goto #53
52 ── %258 = Base.llvmcall("ret <4 x double> zeroinitializer", NTuple{4, VecElement{Float64}}, Tuple{})::NTuple{4, VecElement{Float64}}
└──── %259 = Base.llvmcall("ret <4 x double> zeroinitializer", NTuple{4, VecElement{Float64}}, Tuple{})::NTuple{4, VecElement{Float64}}
53 ┄─ %260 = φ (#51 => %217, #52 => 0)::Int64
│ %261 = φ (#51 => %255, #52 => %258)::NTuple{4, VecElement{Float64}}
│ %262 = φ (#51 => %256, #52 => %259)::NTuple{4, VecElement{Float64}}
│ %263 = φ (#51 => %255, #52 => %258)::NTuple{4, VecElement{Float64}}
│ %264 = φ (#51 => %255, #52 => %258)::NTuple{4, VecElement{Float64}}
│ %265 = φ (#51 => %255, #52 => %258)::NTuple{4, VecElement{Float64}}
│ %266 = φ (#51 => %256, #52 => %259)::NTuple{4, VecElement{Float64}}
│ %267 = φ (#51 => %256, #52 => %259)::NTuple{4, VecElement{Float64}}
│ %268 = φ (#51 => %255, #52 => %258)::NTuple{4, VecElement{Float64}}
│ %269 = φ (#51 => %256, #52 => %259)::NTuple{4, VecElement{Float64}}
│ %270 = φ (#51 => %256, #52 => %259)::NTuple{4, VecElement{Float64}}
│ %271 = Base.slt_int(%195, 0)::Bool
└──── goto #55 if not %271
54 ── goto #56
55 ── %274 = Base.sub_int(%195, 0)::Int64
│ %275 = Base.add_int(%274, 1)::Int64
└──── goto #56
56 ┄─ %277 = φ (#54 => 0, #55 => %275)::Int64
│ %278 = Base.and_int(%277, -8)::Int64
│ %279 = (%260 === %278)::Bool
│ %280 = Base.not_int(%279)::Bool
└──── goto #57
57 ── goto #59 if not %280
58 ── %283 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %192, %260)::Ptr{Float64}
│ %284 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.1, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %283)::NTuple{4, VecElement{Float64}}
│ %285 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %283)::NTuple{4, VecElement{Float64}}
│ %286 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %193, %260)::Ptr{Float64}
│ %287 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.1, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %286)::NTuple{4, VecElement{Float64}}
│ %288 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %286)::NTuple{4, VecElement{Float64}}
│ %289 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %284, %287, %261)::NTuple{4, VecElement{Float64}}
│ %290 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %285, %288, %262)::NTuple{4, VecElement{Float64}}
└──── %291 = Base.llvmcall("%res = add nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, 8, %260)::Int64
59 ┄─ %292 = φ (#58 => %289, #57 => %263)::NTuple{4, VecElement{Float64}}
│ %293 = φ (#58 => %289, #57 => %264)::NTuple{4, VecElement{Float64}}
│ %294 = φ (#58 => %289, #57 => %265)::NTuple{4, VecElement{Float64}}
│ %295 = φ (#58 => %290, #57 => %266)::NTuple{4, VecElement{Float64}}
│ %296 = φ (#58 => %290, #57 => %267)::NTuple{4, VecElement{Float64}}
│ %297 = φ (#58 => %289, #57 => %268)::NTuple{4, VecElement{Float64}}
│ %298 = φ (#58 => %290, #57 => %269)::NTuple{4, VecElement{Float64}}
│ %299 = φ (#58 => %290, #57 => %270)::NTuple{4, VecElement{Float64}}
│ %300 = φ (#58 => %291, #57 => %260)::Int64
│ %301 = Base.sle_int(%300, %195)::Bool
└──── goto #63 if not %301
60 ── %303 = Base.bitcast(UInt64, %202)::UInt64
│ %304 = Base.llvmcall("%res = sub nsw nuw i64 %0, %1\nret i64 %res", UInt64, Tuple{UInt64, UInt64}, %303, 0x0000000000000001)::UInt64
│ %305 = Base.and_int(%304, 0x0000000000000003)::UInt64
│ %306 = Base.llvmcall(" %ie = insertelement <4 x i64> undef, i64 %0, i32 0\n %v = shufflevector <4 x i64> %ie, <4 x i64> undef, <4 x i32> zeroinitializer\n ret <4 x i64> %v\n", NTuple{4, VecElement{UInt64}}, Tuple{UInt64}, %305)::NTuple{4, VecElement{UInt64}}
│ %307 = Base.llvmcall(" %ie = insertelement <4 x i64> undef, i64 %0, i32 0\n %v = shufflevector <4 x i64> %ie, <4 x i64> undef, <4 x i32> zeroinitializer\n %res = add nsw <4 x i64> %v, <i64 0, i64 1, i64 2, i64 3>\n ret <4 x i64> %res\n", NTuple{4, VecElement{UInt64}}, Tuple{UInt64}, 0x0000000000000000)::NTuple{4, VecElement{UInt64}}
│ %308 = Base.llvmcall("%m = icmp uge <4 x i64> %0, %1\n%restrunc.0 = bitcast <4 x i1> %m to i4\n%res.0 = zext i4 %restrunc.0 to i8\nret i8 %res.0", VectorizationBase.UInt8, Tuple{NTuple{4, VecElement{UInt64}}, NTuple{4, VecElement{UInt64}}}, %306, %307)::UInt8
│ Base.llvmcall("%res = add nsw nuw i64 %0, %1\nret i64 %res", UInt64, Tuple{UInt64, UInt64}, %305, 0x0000000000000001)::UInt64
│ %310 = Base.llvmcall("%res = sub nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, %195, 4)::Int64
│ %311 = Base.slt_int(%310, %300)::Bool
└──── goto #62 if not %311
61 ── %313 = Base.llvmcall("%res = mul nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, 8, %300)::Int64
│ %314 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\ndeclare <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>)\n\n define <4 x double> @entry(i64, i64, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to i8*\n%ptr.1 = getelementptr inbounds i8, i8* %ptr.0, i64 %1\n%ptr.2 = bitcast i8* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %2 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\n%res = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0, <4 x double> zeroinitializer), !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}, Int64, UInt8}, %192, %313, %308)::NTuple{4, VecElement{Float64}}
│ %315 = Base.llvmcall("%res = mul nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, 8, %300)::Int64
│ %316 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\ndeclare <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>)\n\n define <4 x double> @entry(i64, i64, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to i8*\n%ptr.1 = getelementptr inbounds i8, i8* %ptr.0, i64 %1\n%ptr.2 = bitcast i8* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %2 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\n%res = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0, <4 x double> zeroinitializer), !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}, Int64, UInt8}, %193, %315, %308)::NTuple{4, VecElement{Float64}}
│ %317 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %314, %316, %292)::NTuple{4, VecElement{Float64}}
│ %318 = Base.llvmcall("%masktrunc.0 = trunc i8 %0 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\n%res = select nsz arcp contract reassoc <4 x i1> %mask.0, <4 x double> %1, <4 x double> %2\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{UInt8, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %308, %317, %293)::NTuple{4, VecElement{Float64}}
│ Base.llvmcall("%res = add nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, 4, %300)::Int64
└──── goto #63
62 ── %321 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %192, %300)::Ptr{Float64}
│ %322 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.1, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %321)::NTuple{4, VecElement{Float64}}
│ %323 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\ndeclare <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>)\n\n define <4 x double> @entry(i64, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %1 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\n%res = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0, <4 x double> zeroinitializer), !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}, UInt8}, %321, %308)::NTuple{4, VecElement{Float64}}
│ %324 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %193, %300)::Ptr{Float64}
│ %325 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.1, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %324)::NTuple{4, VecElement{Float64}}
│ %326 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\ndeclare <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>)\n\n define <4 x double> @entry(i64, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %1 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\n%res = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0, <4 x double> zeroinitializer), !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}, UInt8}, %324, %308)::NTuple{4, VecElement{Float64}}
│ %327 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %322, %325, %294)::NTuple{4, VecElement{Float64}}
│ %328 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %323, %326, %295)::NTuple{4, VecElement{Float64}}
│ %329 = Base.llvmcall("%masktrunc.0 = trunc i8 %0 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\n%res = select nsz arcp contract reassoc <4 x i1> %mask.0, <4 x double> %1, <4 x double> %2\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{UInt8, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %308, %328, %296)::NTuple{4, VecElement{Float64}}
└──── Base.llvmcall("%res = add nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, 8, %300)::Int64
63 ┄─ %331 = φ (#61 => %318, #62 => %327, #59 => %297)::NTuple{4, VecElement{Float64}}
│ %332 = φ (#61 => %299, #62 => %329, #59 => %298)::NTuple{4, VecElement{Float64}}
│ %333 = Base.llvmcall("%res = fadd nsz contract <4 x double> %0, %1\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %331, %332)::NTuple{4, VecElement{Float64}}
└──── goto #64
64 ── $(Expr(:gc_preserve_end, :(%194)))
│ %336 = Base.llvmcall((" declare double @llvm.vector.reduce.fadd.v4f64(double, <4 x double>)\n\n define double @entry(double, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc double @llvm.vector.reduce.fadd.v4f64(double %0, <4 x double> %1)\nret double %res\n }\n", "entry"), VectorizationBase.Float64, Tuple{Float64, NTuple{4, VecElement{Float64}}}, %107, %333)::Float64
│ %337 = Base.mul_float(τ, %336)::Float64
└──── goto #69 if not false
65 ── %339 = Core.tuple(1, %28)::Tuple{Int64, Int64}
│ %340 = Base.getfield(A, :indices)::Tuple{UnitRange{Int64}, UnitRange{Int64}}
│ %341 = Core.getfield(%340, 1)::UnitRange{Int64}
│ %342 = Core.getfield(%340, 2)::UnitRange{Int64}
│ %343 = Base.getfield(%341, :stop)::Int64
│ %344 = Base.getfield(%341, :start)::Int64
│ %345 = Base.sub_int(%343, %344)::Int64
│ %346 = Base.add_int(%345, 1)::Int64
│ %347 = Base.slt_int(%346, 0)::Bool
│ %348 = Base.ifelse(%347, 0, %346)::Int64
│ %349 = Base.getfield(%342, :stop)::Int64
│ %350 = Base.getfield(%342, :start)::Int64
│ %351 = Base.sub_int(%349, %350)::Int64
│ %352 = Base.add_int(%351, 1)::Int64
│ %353 = Base.slt_int(%352, 0)::Bool
│ %354 = Base.ifelse(%353, 0, %352)::Int64
│ %355 = Base.sle_int(1, 1)::Bool
│ %356 = Base.sle_int(1, %348)::Bool
│ %357 = Base.and_int(%355, %356)::Bool
│ %358 = Base.sle_int(1, %28)::Bool
│ %359 = Base.sle_int(%28, %354)::Bool
│ %360 = Base.and_int(%358, %359)::Bool
│ %361 = Base.and_int(%360, true)::Bool
│ %362 = Base.and_int(%357, %361)::Bool
└──── goto #67 if not %362
66 ── Base.nothing::Nothing
└──── goto #68
67 ── invoke Base.throw_boundserror(A::SubArray{Float64, 2, Matrix{Float64}, Tuple{UnitRange{Int64}, UnitRange{Int64}}, false}, %339::Tuple{Int64, Int64})::Union{}
└──── unreachable
68 ── nothing::Nothing
69 ┄─ %369 = Base.getfield(A, :indices)::Tuple{UnitRange{Int64}, UnitRange{Int64}}
│ %370 = Base.getfield(%369, 1, false)::UnitRange{Int64}
│ %371 = Base.getfield(%370, :start)::Int64
│ %372 = Base.sub_int(1, 1)::Int64
│ %373 = Base.add_int(%371, %372)::Int64
└──── goto #78 if not false
70 ── %375 = Base.slt_int(0, 1)::Bool
└──── goto #74 if not %375
71 ── %377 = Base.getfield(%370, :stop)::Int64
│ %378 = Base.sle_int(%373, %377)::Bool
└──── goto #73 if not %378
72 ── %380 = Base.getfield(%370, :start)::Int64
│ %381 = Base.sle_int(%380, %373)::Bool
└──── goto #75
73 ── goto #75
74 ── goto #75
75 ┄─ %385 = φ (#72 => %381, #73 => false, #74 => false)::Bool
└──── goto #77 if not %385
76 ── goto #78
77 ── invoke Base.throw_boundserror(%370::UnitRange{Int64}, 1::Int64)::Union{}
└──── unreachable
78 ┄─ goto #79
79 ── %391 = Core.getfield(%369, 2)::UnitRange{Int64}
│ %392 = Base.getfield(%391, :start)::Int64
│ %393 = Base.sub_int(%28, 1)::Int64
│ %394 = Base.add_int(%392, %393)::Int64
└──── goto #88 if not false
80 ── %396 = Base.slt_int(0, %28)::Bool
└──── goto #84 if not %396
81 ── %398 = Base.getfield(%391, :stop)::Int64
│ %399 = Base.sle_int(%394, %398)::Bool
└──── goto #83 if not %399
82 ── %401 = Base.getfield(%391, :start)::Int64
│ %402 = Base.sle_int(%401, %394)::Bool
└──── goto #85
83 ── goto #85
84 ── goto #85
85 ┄─ %406 = φ (#82 => %402, #83 => false, #84 => false)::Bool
└──── goto #87 if not %406
86 ── goto #88
87 ── invoke Base.throw_boundserror(%391::UnitRange{Int64}, %28::Int64)::Union{}
└──── unreachable
88 ┄─ goto #89
89 ── goto #90
90 ── goto #91
91 ── %414 = Base.getfield(A, :parent)::Matrix{Float64}
│ %415 = Base.arrayref(false, %414, %373, %394)::Float64
└──── goto #92
92 ── %417 = Base.sub_float(%415, %337)::Float64
└──── goto #97 if not false
93 ── %419 = Core.tuple(1, %28)::Tuple{Int64, Int64}
│ %420 = Base.getfield(A, :indices)::Tuple{UnitRange{Int64}, UnitRange{Int64}}
│ %421 = Core.getfield(%420, 1)::UnitRange{Int64}
│ %422 = Core.getfield(%420, 2)::UnitRange{Int64}
│ %423 = Base.getfield(%421, :stop)::Int64
│ %424 = Base.getfield(%421, :start)::Int64
│ %425 = Base.sub_int(%423, %424)::Int64
│ %426 = Base.add_int(%425, 1)::Int64
│ %427 = Base.slt_int(%426, 0)::Bool
│ %428 = Base.ifelse(%427, 0, %426)::Int64
│ %429 = Base.getfield(%422, :stop)::Int64
│ %430 = Base.getfield(%422, :start)::Int64
│ %431 = Base.sub_int(%429, %430)::Int64
│ %432 = Base.add_int(%431, 1)::Int64
│ %433 = Base.slt_int(%432, 0)::Bool
│ %434 = Base.ifelse(%433, 0, %432)::Int64
│ %435 = Base.sle_int(1, 1)::Bool
│ %436 = Base.sle_int(1, %428)::Bool
│ %437 = Base.and_int(%435, %436)::Bool
│ %438 = Base.sle_int(1, %28)::Bool
│ %439 = Base.sle_int(%28, %434)::Bool
│ %440 = Base.and_int(%438, %439)::Bool
│ %441 = Base.and_int(%440, true)::Bool
│ %442 = Base.and_int(%437, %441)::Bool
└──── goto #95 if not %442
94 ── Base.nothing::Nothing
└──── goto #96
95 ── invoke Base.throw_boundserror(A::SubArray{Float64, 2, Matrix{Float64}, Tuple{UnitRange{Int64}, UnitRange{Int64}}, false}, %419::Tuple{Int64, Int64})::Union{}
└──── unreachable
96 ── nothing::Nothing
97 ┄─ %449 = Base.getfield(A, :indices)::Tuple{UnitRange{Int64}, UnitRange{Int64}}
│ %450 = Base.getfield(%449, 1, false)::UnitRange{Int64}
│ %451 = Base.getfield(%450, :start)::Int64
│ %452 = Base.sub_int(1, 1)::Int64
│ %453 = Base.add_int(%451, %452)::Int64
└──── goto #106 if not false
98 ── %455 = Base.slt_int(0, 1)::Bool
└──── goto #102 if not %455
99 ── %457 = Base.getfield(%450, :stop)::Int64
│ %458 = Base.sle_int(%453, %457)::Bool
└──── goto #101 if not %458
100 ─ %460 = Base.getfield(%450, :start)::Int64
│ %461 = Base.sle_int(%460, %453)::Bool
└──── goto #103
101 ─ goto #103
102 ─ goto #103
103 ┄ %465 = φ (#100 => %461, #101 => false, #102 => false)::Bool
└──── goto #105 if not %465
104 ─ goto #106
105 ─ invoke Base.throw_boundserror(%450::UnitRange{Int64}, 1::Int64)::Union{}
└──── unreachable
106 ┄ goto #107
107 ─ %471 = Core.getfield(%449, 2)::UnitRange{Int64}
│ %472 = Base.getfield(%471, :start)::Int64
│ %473 = Base.sub_int(%28, 1)::Int64
│ %474 = Base.add_int(%472, %473)::Int64
└──── goto #116 if not false
108 ─ %476 = Base.slt_int(0, %28)::Bool
└──── goto #112 if not %476
109 ─ %478 = Base.getfield(%471, :stop)::Int64
│ %479 = Base.sle_int(%474, %478)::Bool
└──── goto #111 if not %479
110 ─ %481 = Base.getfield(%471, :start)::Int64
│ %482 = Base.sle_int(%481, %474)::Bool
└──── goto #113
111 ─ goto #113
112 ─ goto #113
113 ┄ %486 = φ (#110 => %482, #111 => false, #112 => false)::Bool
└──── goto #115 if not %486
114 ─ goto #116
115 ─ invoke Base.throw_boundserror(%471::UnitRange{Int64}, %28::Int64)::Union{}
└──── unreachable
116 ┄ goto #117
117 ─ goto #118
118 ─ goto #119
119 ─ %494 = Base.getfield(A, :parent)::Matrix{Float64}
│ Base.arrayset(false, %494, %417, %453, %474)::Matrix{Float64}
└──── goto #120
120 ─ %497 = Base.slt_int(%9, 2)::Bool
└──── goto #122 if not %497
121 ─ goto #123
122 ─ goto #123
123 ┄ goto #124
124 ─ goto #125
125 ─ %503 = Base.getfield(A, :parent)::Matrix{Float64}
│ %504 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%503)))::Ptr{Float64}
│ %505 = Base.getfield(A, :parent)::Matrix{Float64}
│ %506 = Base.getfield(A, :indices)::Tuple{UnitRange{Int64}, UnitRange{Int64}}
│ %507 = LayoutPointers.getfield(%506, 1, false)::UnitRange{Int64}
│ %508 = Base.getfield(%507, :start)::Int64
│ %509 = Base.sub_int(%508, 1)::Int64
│ %510 = Core.getfield(%506, 2)::UnitRange{Int64}
│ %511 = Base.getfield(%510, :start)::Int64
│ %512 = Base.sub_int(%511, 1)::Int64
│ %513 = Base.arraysize(%505, 1)::Int64
│ Base.arraysize(%505, 2)::Int64
│ %515 = Base.mul_int(1, %513)::Int64
│ %516 = Base.mul_int(%509, 1)::Int64
│ %517 = Base.mul_int(%512, %515)::Int64
│ %518 = Base.add_int(%516, %517)::Int64
│ %519 = Base.mul_int(8, %518)::Int64
│ %520 = Core.bitcast(Core.UInt, %504)::UInt64
│ %521 = Base.bitcast(UInt64, %519)::UInt64
│ %522 = Base.add_ptr(%520, %521)::UInt64
│ %523 = Core.bitcast(Ptr{Float64}, %522)::Ptr{Float64}
│ %524 = ArrayInterfaceCore.is_splat_index::typeof(ArrayInterfaceCore.is_splat_index)
│ %525 = %new(ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}, %524, Tuple{UnitRange{Int64}, UnitRange{Int64}})::ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}
│ invoke %525(1::Int64)::Bool
│ invoke %525(2::Int64)::Bool
│ %528 = ArrayInterfaceCore.is_splat_index::typeof(ArrayInterfaceCore.is_splat_index)
│ %529 = %new(ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}, %528, Tuple{UnitRange{Int64}, UnitRange{Int64}})::ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}
│ invoke %529(1::Int64)::Bool
│ invoke %529(2::Int64)::Bool
│ %532 = ArrayInterfaceCore.is_splat_index::typeof(ArrayInterfaceCore.is_splat_index)
│ %533 = %new(ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}, %532, Tuple{UnitRange{Int64}, UnitRange{Int64}})::ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}
│ invoke %533(1::Int64)::Bool
│ invoke %533(2::Int64)::Bool
│ %536 = Base.getfield(A, :parent)::Matrix{Float64}
│ %537 = Base.arraysize(%536, 1)::Int64
│ Base.arraysize(%536, 2)::Int64
│ %539 = Base.mul_int(1, %537)::Int64
│ %540 = Base.mul_int(1, %539)::Int64
│ %541 = Base.mul_int(8, %540)::Int64
│ %542 = Base.llvmcall("%res = sub nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, %28, 1)::Int64
│ %543 = Base.llvmcall("%res = mul nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, %542, %541)::Int64
│ Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to i8*\n%ptr.1 = getelementptr inbounds i8, i8* %ptr.0, i64 %1\n%ptr.2 = ptrtoint i8* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %523, %543)::Ptr{Float64}
│ %545 = Base.getfield(x, :parent)::Matrix{Float64}
│ %546 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%545)))::Ptr{Float64}
│ %547 = Base.getfield(x, :parent)::Matrix{Float64}
│ %548 = Base.getfield(x, :indices)::Tuple{UnitRange{Int64}, Int64}
│ %549 = LayoutPointers.getfield(%548, 1, false)::UnitRange{Int64}
│ %550 = Base.getfield(%549, :start)::Int64
│ %551 = Base.sub_int(%550, 1)::Int64
│ %552 = Core.getfield(%548, 2)::Int64
│ %553 = Base.sub_int(%552, 1)::Int64
│ %554 = Base.arraysize(%547, 1)::Int64
│ Base.arraysize(%547, 2)::Int64
│ %556 = Base.mul_int(1, %554)::Int64
│ %557 = Base.mul_int(%551, 1)::Int64
│ %558 = Base.mul_int(%553, %556)::Int64
│ %559 = Base.add_int(%557, %558)::Int64
│ %560 = Base.mul_int(8, %559)::Int64
│ %561 = Core.bitcast(Core.UInt, %546)::UInt64
│ %562 = Base.bitcast(UInt64, %560)::UInt64
│ %563 = Base.add_ptr(%561, %562)::UInt64
│ %564 = Core.bitcast(Ptr{Float64}, %563)::Ptr{Float64}
│ %565 = ArrayInterfaceCore.is_splat_index::typeof(ArrayInterfaceCore.is_splat_index)
│ %566 = %new(ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}, %565, Tuple{UnitRange{Int64}, Int64})::ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}
│ invoke %566(1::Int64)::Bool
│ invoke %566(2::Int64)::Bool
│ %569 = ArrayInterfaceCore.is_splat_index::typeof(ArrayInterfaceCore.is_splat_index)
│ %570 = %new(ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}, %569, Tuple{UnitRange{Int64}, Int64})::ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}
│ invoke %570(1::Int64)::Bool
│ invoke %570(2::Int64)::Bool
│ %573 = ArrayInterfaceCore.is_splat_index::typeof(ArrayInterfaceCore.is_splat_index)
│ %574 = %new(ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}, %573, Tuple{UnitRange{Int64}, Int64})::ArrayInterfaceCore.var"#1#2"{typeof(ArrayInterfaceCore.is_splat_index), DataType}
│ invoke %574(1::Int64)::Bool
│ invoke %574(2::Int64)::Bool
│ %577 = Base.getfield(x, :parent)::Matrix{Float64}
│ Base.arraysize(%577, 1)::Int64
│ Base.arraysize(%577, 2)::Int64
│ %580 = Base.llvmcall("%res = sub nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, %28, 1)::Int64
│ %581 = Base.llvmcall("%res = mul nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, %580, %541)::Int64
│ %582 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to i8*\n%ptr.1 = getelementptr inbounds i8, i8* %ptr.0, i64 %1\n%ptr.2 = ptrtoint i8* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %523, %581)::Ptr{Float64}
│ %583 = Base.llvmcall((" \n\n define i64 @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}}, %564)::Ptr{Float64}
│ %584 = Base.llvmcall((" \n\n define i64 @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}}, %582)::Ptr{Float64}
│ %585 = $(Expr(:gc_preserve_begin, :(%545), :(%503)))
│ %586 = Base.sub_int(%9, 2)::Int64
│ %587 = Base.slt_int(%586, 0)::Bool
└──── goto #127 if not %587
126 ─ goto #128
127 ─ %590 = Base.sub_int(%586, 0)::Int64
│ %591 = Base.add_int(%590, 1)::Int64
└──── goto #128
128 ┄ %593 = φ (#126 => 0, #127 => %591)::Int64
└──── goto #129
129 ─ goto #130
130 ─ %596 = Base.slt_int(0, %586)::Bool
│ %597 = (0 === %586)::Bool
│ %598 = Base.or_int(%596, %597)::Bool
└──── Base.llvmcall((" declare void @llvm.assume(i1)\n\n define void @entry(i8) alwaysinline {\n top:\n %b = trunc i8 %0 to i1\ncall void @llvm.assume(i1 %b)\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Bool}, %598)::Nothing
131 ┄ %600 = φ (#130 => 0, #136 => %637)::Int64
│ %601 = Base.slt_int(%586, 0)::Bool
└──── goto #133 if not %601
132 ─ goto #134
133 ─ %604 = Base.sub_int(%586, 0)::Int64
│ %605 = Base.add_int(%604, 1)::Int64
└──── goto #134
134 ┄ %607 = φ (#132 => 0, #133 => %605)::Int64
│ %608 = Base.and_int(%607, -16)::Int64
│ %609 = (%600 === %608)::Bool
│ %610 = Base.not_int(%609)::Bool
└──── goto #135
135 ─ goto #137 if not %610
136 ─ %613 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %583, %600)::Ptr{Float64}
│ %614 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.1, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %613)::NTuple{4, VecElement{Float64}}
│ %615 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %613)::NTuple{4, VecElement{Float64}}
│ %616 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 8\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %613)::NTuple{4, VecElement{Float64}}
│ %617 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 12\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %613)::NTuple{4, VecElement{Float64}}
│ %618 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %584, %600)::Ptr{Float64}
│ %619 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.1, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %618)::NTuple{4, VecElement{Float64}}
│ %620 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %618)::NTuple{4, VecElement{Float64}}
│ %621 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 8\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %618)::NTuple{4, VecElement{Float64}}
│ %622 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 12\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %618)::NTuple{4, VecElement{Float64}}
│ %623 = Base.llvmcall("%res = fneg nsz arcp contract afn reassoc <4 x double> %0\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}}, %614)::NTuple{4, VecElement{Float64}}
│ %624 = Base.llvmcall("%res = fneg nsz arcp contract afn reassoc <4 x double> %0\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}}, %615)::NTuple{4, VecElement{Float64}}
│ %625 = Base.llvmcall("%res = fneg nsz arcp contract afn reassoc <4 x double> %0\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}}, %616)::NTuple{4, VecElement{Float64}}
│ %626 = Base.llvmcall("%res = fneg nsz arcp contract afn reassoc <4 x double> %0\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}}, %617)::NTuple{4, VecElement{Float64}}
│ %627 = Base.llvmcall(" %ie = insertelement <4 x double> undef, double %0, i32 0\n %v = shufflevector <4 x double> %ie, <4 x double> undef, <4 x i32> zeroinitializer\n ret <4 x double> %v\n", NTuple{4, VecElement{Float64}}, Tuple{Float64}, %337)::NTuple{4, VecElement{Float64}}
│ %628 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %623, %627, %619)::NTuple{4, VecElement{Float64}}
│ %629 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %624, %627, %620)::NTuple{4, VecElement{Float64}}
│ %630 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %625, %627, %621)::NTuple{4, VecElement{Float64}}
│ %631 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %626, %627, %622)::NTuple{4, VecElement{Float64}}
│ %632 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %584, %600)::Ptr{Float64}
│ Base.llvmcall((" \n\n define void @entry(i64, <4 x double>) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\nstore <4 x double> %1, <4 x double>* %ptr.1, align 8\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Ptr{Float64}, NTuple{4, VecElement{Float64}}}, %632, %628)::Nothing
│ Base.llvmcall((" \n\n define void @entry(i64, <4 x double>) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\nstore <4 x double> %1, <4 x double>* %ptr.2, align 8\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Ptr{Float64}, NTuple{4, VecElement{Float64}}}, %632, %629)::Nothing
│ Base.llvmcall((" \n\n define void @entry(i64, <4 x double>) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 8\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\nstore <4 x double> %1, <4 x double>* %ptr.2, align 8\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Ptr{Float64}, NTuple{4, VecElement{Float64}}}, %632, %630)::Nothing
│ Base.llvmcall((" \n\n define void @entry(i64, <4 x double>) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 12\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\nstore <4 x double> %1, <4 x double>* %ptr.2, align 8\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Ptr{Float64}, NTuple{4, VecElement{Float64}}}, %632, %631)::Nothing
│ %637 = Base.llvmcall("%res = add nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, 16, %600)::Int64
└──── goto #131
137 ─ %639 = Base.sle_int(%600, %586)::Bool
└──── goto #145 if not %639
138 ─ %641 = Base.bitcast(UInt64, %593)::UInt64
│ %642 = Base.llvmcall("%res = sub nsw nuw i64 %0, %1\nret i64 %res", UInt64, Tuple{UInt64, UInt64}, %641, 0x0000000000000001)::UInt64
│ %643 = Base.and_int(%642, 0x0000000000000003)::UInt64
│ %644 = Base.llvmcall(" %ie = insertelement <4 x i64> undef, i64 %0, i32 0\n %v = shufflevector <4 x i64> %ie, <4 x i64> undef, <4 x i32> zeroinitializer\n ret <4 x i64> %v\n", NTuple{4, VecElement{UInt64}}, Tuple{UInt64}, %643)::NTuple{4, VecElement{UInt64}}
│ %645 = Base.llvmcall(" %ie = insertelement <4 x i64> undef, i64 %0, i32 0\n %v = shufflevector <4 x i64> %ie, <4 x i64> undef, <4 x i32> zeroinitializer\n %res = add nsw <4 x i64> %v, <i64 0, i64 1, i64 2, i64 3>\n ret <4 x i64> %res\n", NTuple{4, VecElement{UInt64}}, Tuple{UInt64}, 0x0000000000000000)::NTuple{4, VecElement{UInt64}}
│ %646 = Base.llvmcall("%m = icmp uge <4 x i64> %0, %1\n%restrunc.0 = bitcast <4 x i1> %m to i4\n%res.0 = zext i4 %restrunc.0 to i8\nret i8 %res.0", VectorizationBase.UInt8, Tuple{NTuple{4, VecElement{UInt64}}, NTuple{4, VecElement{UInt64}}}, %644, %645)::UInt8
│ Base.llvmcall("%res = add nsw nuw i64 %0, %1\nret i64 %res", UInt64, Tuple{UInt64, UInt64}, %643, 0x0000000000000001)::UInt64
│ %648 = Base.llvmcall("%res = sub nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, %586, 4)::Int64
│ %649 = Base.slt_int(%648, %600)::Bool
└──── goto #140 if not %649
139 ─ %651 = Base.llvmcall("%res = mul nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, 8, %600)::Int64
│ %652 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\ndeclare <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>)\n\n define <4 x double> @entry(i64, i64, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to i8*\n%ptr.1 = getelementptr inbounds i8, i8* %ptr.0, i64 %1\n%ptr.2 = bitcast i8* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %2 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\n%res = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0, <4 x double> zeroinitializer), !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}, Int64, UInt8}, %583, %651, %646)::NTuple{4, VecElement{Float64}}
│ %653 = Base.llvmcall("%res = mul nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, 8, %600)::Int64
│ %654 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\ndeclare <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>)\n\n define <4 x double> @entry(i64, i64, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to i8*\n%ptr.1 = getelementptr inbounds i8, i8* %ptr.0, i64 %1\n%ptr.2 = bitcast i8* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %2 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\n%res = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0, <4 x double> zeroinitializer), !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}, Int64, UInt8}, %584, %653, %646)::NTuple{4, VecElement{Float64}}
│ %655 = Base.llvmcall("%res = fneg nsz arcp contract afn reassoc <4 x double> %0\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}}, %652)::NTuple{4, VecElement{Float64}}
│ %656 = Base.llvmcall(" %ie = insertelement <4 x double> undef, double %0, i32 0\n %v = shufflevector <4 x double> %ie, <4 x double> undef, <4 x i32> zeroinitializer\n ret <4 x double> %v\n", NTuple{4, VecElement{Float64}}, Tuple{Float64}, %337)::NTuple{4, VecElement{Float64}}
│ %657 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %655, %656, %654)::NTuple{4, VecElement{Float64}}
│ %658 = Base.llvmcall("%res = mul nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, 8, %600)::Int64
│ Base.llvmcall((" declare void @llvm.masked.store.v4f64.p0v4f64(<4 x double>, <4 x double>*, i32, <4 x i1>)\n\n define void @entry(i64, <4 x double>, i64, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to i8*\n%ptr.1 = getelementptr inbounds i8, i8* %ptr.0, i64 %2\n%ptr.2 = bitcast i8* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %3 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\ncall void @llvm.masked.store.v4f64.p0v4f64(<4 x double> %1, <4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0)\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Ptr{Float64}, NTuple{4, VecElement{Float64}}, Int64, UInt8}, %584, %657, %658, %646)::Nothing
│ Base.llvmcall("%res = add nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, 4, %600)::Int64
└──── goto #145
140 ─ %662 = Base.llvmcall("%res = sub nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, %586, 8)::Int64
│ %663 = Base.slt_int(%662, %600)::Bool
└──── goto #142 if not %663
141 ─ %665 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %583, %600)::Ptr{Float64}
│ %666 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.1, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %665)::NTuple{4, VecElement{Float64}}
│ %667 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\ndeclare <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>)\n\n define <4 x double> @entry(i64, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %1 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\n%res = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0, <4 x double> zeroinitializer), !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}, UInt8}, %665, %646)::NTuple{4, VecElement{Float64}}
│ %668 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %584, %600)::Ptr{Float64}
│ %669 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.1, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %668)::NTuple{4, VecElement{Float64}}
│ %670 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\ndeclare <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>)\n\n define <4 x double> @entry(i64, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %1 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\n%res = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0, <4 x double> zeroinitializer), !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}, UInt8}, %668, %646)::NTuple{4, VecElement{Float64}}
│ %671 = Base.llvmcall("%res = fneg nsz arcp contract afn reassoc <4 x double> %0\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}}, %666)::NTuple{4, VecElement{Float64}}
│ %672 = Base.llvmcall("%res = fneg nsz arcp contract afn reassoc <4 x double> %0\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}}, %667)::NTuple{4, VecElement{Float64}}
│ %673 = Base.llvmcall(" %ie = insertelement <4 x double> undef, double %0, i32 0\n %v = shufflevector <4 x double> %ie, <4 x double> undef, <4 x i32> zeroinitializer\n ret <4 x double> %v\n", NTuple{4, VecElement{Float64}}, Tuple{Float64}, %337)::NTuple{4, VecElement{Float64}}
│ %674 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %671, %673, %669)::NTuple{4, VecElement{Float64}}
│ %675 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %672, %673, %670)::NTuple{4, VecElement{Float64}}
│ %676 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %584, %600)::Ptr{Float64}
│ Base.llvmcall((" \n\n define void @entry(i64, <4 x double>) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\nstore <4 x double> %1, <4 x double>* %ptr.1, align 8\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Ptr{Float64}, NTuple{4, VecElement{Float64}}}, %676, %674)::Nothing
│ Base.llvmcall((" declare void @llvm.masked.store.v4f64.p0v4f64(<4 x double>, <4 x double>*, i32, <4 x i1>)\n\n define void @entry(i64, <4 x double>, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %2 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\ncall void @llvm.masked.store.v4f64.p0v4f64(<4 x double> %1, <4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0)\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Ptr{Float64}, NTuple{4, VecElement{Float64}}, UInt8}, %676, %675, %646)::Nothing
│ Base.llvmcall("%res = add nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, 8, %600)::Int64
└──── goto #145
142 ─ %681 = Base.llvmcall("%res = sub nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, %586, 12)::Int64
│ %682 = Base.slt_int(%681, %600)::Bool
└──── goto #144 if not %682
143 ─ %684 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %583, %600)::Ptr{Float64}
│ %685 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.1, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %684)::NTuple{4, VecElement{Float64}}
│ %686 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %684)::NTuple{4, VecElement{Float64}}
│ %687 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\ndeclare <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>)\n\n define <4 x double> @entry(i64, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 8\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %1 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\n%res = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0, <4 x double> zeroinitializer), !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}, UInt8}, %684, %646)::NTuple{4, VecElement{Float64}}
│ %688 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %584, %600)::Ptr{Float64}
│ %689 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.1, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %688)::NTuple{4, VecElement{Float64}}
│ %690 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %688)::NTuple{4, VecElement{Float64}}
│ %691 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\ndeclare <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>)\n\n define <4 x double> @entry(i64, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 8\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %1 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\n%res = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0, <4 x double> zeroinitializer), !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}, UInt8}, %688, %646)::NTuple{4, VecElement{Float64}}
│ %692 = Base.llvmcall("%res = fneg nsz arcp contract afn reassoc <4 x double> %0\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}}, %685)::NTuple{4, VecElement{Float64}}
│ %693 = Base.llvmcall("%res = fneg nsz arcp contract afn reassoc <4 x double> %0\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}}, %686)::NTuple{4, VecElement{Float64}}
│ %694 = Base.llvmcall("%res = fneg nsz arcp contract afn reassoc <4 x double> %0\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}}, %687)::NTuple{4, VecElement{Float64}}
│ %695 = Base.llvmcall(" %ie = insertelement <4 x double> undef, double %0, i32 0\n %v = shufflevector <4 x double> %ie, <4 x double> undef, <4 x i32> zeroinitializer\n ret <4 x double> %v\n", NTuple{4, VecElement{Float64}}, Tuple{Float64}, %337)::NTuple{4, VecElement{Float64}}
│ %696 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %692, %695, %689)::NTuple{4, VecElement{Float64}}
│ %697 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %693, %695, %690)::NTuple{4, VecElement{Float64}}
│ %698 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %694, %695, %691)::NTuple{4, VecElement{Float64}}
│ %699 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %584, %600)::Ptr{Float64}
│ Base.llvmcall((" \n\n define void @entry(i64, <4 x double>) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\nstore <4 x double> %1, <4 x double>* %ptr.1, align 8\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Ptr{Float64}, NTuple{4, VecElement{Float64}}}, %699, %696)::Nothing
│ Base.llvmcall((" \n\n define void @entry(i64, <4 x double>) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\nstore <4 x double> %1, <4 x double>* %ptr.2, align 8\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Ptr{Float64}, NTuple{4, VecElement{Float64}}}, %699, %697)::Nothing
│ Base.llvmcall((" declare void @llvm.masked.store.v4f64.p0v4f64(<4 x double>, <4 x double>*, i32, <4 x i1>)\n\n define void @entry(i64, <4 x double>, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 8\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %2 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\ncall void @llvm.masked.store.v4f64.p0v4f64(<4 x double> %1, <4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0)\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Ptr{Float64}, NTuple{4, VecElement{Float64}}, UInt8}, %699, %698, %646)::Nothing
│ Base.llvmcall("%res = add nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, 12, %600)::Int64
└──── goto #145
144 ─ %705 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %583, %600)::Ptr{Float64}
│ %706 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.1, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %705)::NTuple{4, VecElement{Float64}}
│ %707 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %705)::NTuple{4, VecElement{Float64}}
│ %708 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 8\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %705)::NTuple{4, VecElement{Float64}}
│ %709 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\ndeclare <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>)\n\n define <4 x double> @entry(i64, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 12\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %1 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\n%res = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0, <4 x double> zeroinitializer), !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}, UInt8}, %705, %646)::NTuple{4, VecElement{Float64}}
│ %710 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %584, %600)::Ptr{Float64}
│ %711 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.1, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %710)::NTuple{4, VecElement{Float64}}
│ %712 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %710)::NTuple{4, VecElement{Float64}}
│ %713 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\n\n\n define <4 x double> @entry(i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 8\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%res = load <4 x double>, <4 x double>* %ptr.2, align 8, !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}}, %710)::NTuple{4, VecElement{Float64}}
│ %714 = Base.llvmcall((" !1 = !{!\"noaliasdomain\"}\n!2 = !{!\"noaliasscope\", !1}\n!3 = !{!2}\ndeclare <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>)\n\n define <4 x double> @entry(i64, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 12\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %1 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\n%res = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0, <4 x double> zeroinitializer), !alias.scope !3\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{Ptr{Float64}, UInt8}, %710, %646)::NTuple{4, VecElement{Float64}}
│ %715 = Base.llvmcall("%res = fneg nsz arcp contract afn reassoc <4 x double> %0\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}}, %706)::NTuple{4, VecElement{Float64}}
│ %716 = Base.llvmcall("%res = fneg nsz arcp contract afn reassoc <4 x double> %0\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}}, %707)::NTuple{4, VecElement{Float64}}
│ %717 = Base.llvmcall("%res = fneg nsz arcp contract afn reassoc <4 x double> %0\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}}, %708)::NTuple{4, VecElement{Float64}}
│ %718 = Base.llvmcall("%res = fneg nsz arcp contract afn reassoc <4 x double> %0\nret <4 x double> %res", NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}}, %709)::NTuple{4, VecElement{Float64}}
│ %719 = Base.llvmcall(" %ie = insertelement <4 x double> undef, double %0, i32 0\n %v = shufflevector <4 x double> %ie, <4 x double> undef, <4 x i32> zeroinitializer\n ret <4 x double> %v\n", NTuple{4, VecElement{Float64}}, Tuple{Float64}, %337)::NTuple{4, VecElement{Float64}}
│ %720 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %715, %719, %711)::NTuple{4, VecElement{Float64}}
│ %721 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %716, %719, %712)::NTuple{4, VecElement{Float64}}
│ %722 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %717, %719, %713)::NTuple{4, VecElement{Float64}}
│ %723 = Base.llvmcall((" declare <4 x double> @llvm.fmuladd.v4f64(<4 x double>, <4 x double>, <4 x double>)\n\n define <4 x double> @entry(<4 x double>, <4 x double>, <4 x double>) alwaysinline {\n top:\n %res = call nsz arcp contract afn reassoc <4 x double> @llvm.fmuladd.v4f64(<4 x double> %0, <4 x double> %1, <4 x double> %2)\nret <4 x double> %res\n }\n", "entry"), NTuple{4, VecElement{Float64}}, Tuple{NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}, NTuple{4, VecElement{Float64}}}, %718, %719, %714)::NTuple{4, VecElement{Float64}}
│ %724 = Base.llvmcall((" \n\n define i64 @entry(i64, i64) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i64 %1\n%ptr.2 = ptrtoint double* %ptr.1 to i64\nret i64 %ptr.2\n }\n", "entry"), Ptr{Float64}, Tuple{Ptr{Float64}, Int64}, %584, %600)::Ptr{Float64}
│ Base.llvmcall((" \n\n define void @entry(i64, <4 x double>) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = bitcast double* %ptr.0 to <4 x double>*\nstore <4 x double> %1, <4 x double>* %ptr.1, align 8\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Ptr{Float64}, NTuple{4, VecElement{Float64}}}, %724, %720)::Nothing
│ Base.llvmcall((" \n\n define void @entry(i64, <4 x double>) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 4\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\nstore <4 x double> %1, <4 x double>* %ptr.2, align 8\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Ptr{Float64}, NTuple{4, VecElement{Float64}}}, %724, %721)::Nothing
│ Base.llvmcall((" \n\n define void @entry(i64, <4 x double>) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 8\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\nstore <4 x double> %1, <4 x double>* %ptr.2, align 8\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Ptr{Float64}, NTuple{4, VecElement{Float64}}}, %724, %722)::Nothing
│ Base.llvmcall((" declare void @llvm.masked.store.v4f64.p0v4f64(<4 x double>, <4 x double>*, i32, <4 x i1>)\n\n define void @entry(i64, <4 x double>, i8) alwaysinline {\n top:\n %ptr.0 = inttoptr i64 %0 to double*\n%ptr.1 = getelementptr inbounds double, double* %ptr.0, i32 12\n%ptr.2 = bitcast double* %ptr.1 to <4 x double>*\n%masktrunc.0 = trunc i8 %2 to i4\n%mask.0 = bitcast i4 %masktrunc.0 to <4 x i1>\ncall void @llvm.masked.store.v4f64.p0v4f64(<4 x double> %1, <4 x double>* %ptr.2, i32 8, <4 x i1> %mask.0)\nret void\n }\n", "entry"), VectorizationBase.Cvoid, Tuple{Ptr{Float64}, NTuple{4, VecElement{Float64}}, UInt8}, %724, %723, %646)::Nothing
└──── Base.llvmcall("%res = add nsw i64 %0, %1\nret i64 %res", Int64, Tuple{Int64, Int64}, 16, %600)::Int64
145 ┄ goto #146
146 ─ $(Expr(:gc_preserve_end, :(%585)))
│ %732 = (%29 === %17)::Bool
└──── goto #148 if not %732
147 ─ Base.nothing::Nothing
└──── goto #149
148 ─ %736 = Base.add_int(%29, 1)::Int64
└──── goto #149
149 ┄ %738 = φ (#148 => %736)::Int64
│ %739 = φ (#148 => %736)::Int64
│ %740 = φ (#147 => true, #148 => false)::Bool
│ %741 = Base.not_int(%740)::Bool
└──── goto #151 if not %741
150 ─ goto #5
151 ┄ return A
) => SubArray{Float64, 2, Matrix{Float64}, Tuple{UnitRange{Int64}, UnitRange{Int64}}, false}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment