Support running with the existing CI cache? #670
Description
Taken from JuliaLang/julia#59563, this is an example of bad cache effects that cause descend to diverge meaningfully from code_typed:
julia> using Cthulhu
julia> using StatsBase, LinearAlgebra
julia> const ytransform = ZScoreTransform(2, 1, Float64[0.0, 1.0], Float64[1.0, 0.5])
julia> _reconstruct(states) = StatsBase.reconstruct(ytransform, states)
julia> _reconstruct.((randn(1,2), randn(1,2)))
([-0.01623343775574428 1.2672825718831577], [-0.10777771594605709 1.4198235087432005])Running the above code poisons the CI cache, so that this code (which itself would not normally have a widened recursive loop) now contains a dynamic invoke in the NativeInterpreter:
julia> code_typed(broadcast!, (StatsBase.var"#reconstruct!##0#reconstruct!##1", LinearAlgebra.Adjoint{Float64, Array{Float64, 2}}, LinearAlgebra.Adjoint{Float64, Array{Float64, 2}}, LinearAlgebra.Adjoint{Float64, Array{Float64, 1}}, LinearAlgebra.Adjoint{Float64, Array{Float64, 1}}))
1-element Vector{Any}:
CodeInfo(
...
│ dynamic invoke Base.Broadcast.copyto!(dest::Adjoint{Float64, Matrix{Float64}}, %98::Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, StatsBase.var"#reconstruct!##0#reconstruct!##1", Tuple{Adjoint{Float64, Matrix{Float64}}, Adjoint{Float64, Vector{Float64}}, Adjoint{Float64, Vector{Float64}}}})::Adjoint{Float64, Matrix{Float64}}
...
) => Adjoint{Float64, Matrix{Float64}}In contrast with code_typed above, the descend output is much more optimistic - it runs with a fresh cache, so it was not poisoned by the _reconstruct.(...) call and successfully inlines the copyto! call:
Cthulhu `descend` output
broadcast!(f::Tf, dest, As::Vararg{Any, N}) where {Tf, N} @ Base.Broadcast broadcast.jl:871
Body::Adjoint{Float64, Matrix{Float64}}
1 ─── %1 = builtin Core.getfield(As, 1)::Adjoint{Float64, Matrix{Float64}}
│ %2 = builtin Core.getfield(As, 2)::Adjoint{Float64, Vector{Float64}}
│ %3 = builtin Core.getfield(As, 3)::Adjoint{Float64, Vector{Float64}}
│ %4 = builtin Base.getfield(dest, :parent)::Matrix{Float64}
│ %5 = builtin Base.getfield(%4, :size)::Tuple{Int64, Int64}
│ %6 = $(Expr(:boundscheck, true))::Bool
│ %7 = builtin Base.getfield(%5, 1, %6)::Int64
│ %8 = %new(Base.OneTo{Int64}, %7)::Base.OneTo{Int64}
│ %9 = $(Expr(:boundscheck, true))::Bool
│ %10 = builtin Base.getfield(%5, 2, %9)::Int64
│ %11 = %new(Base.OneTo{Int64}, %10)::Base.OneTo{Int64}
│ %12 = builtin Core.tuple(%11, %8)::Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}
│ %13 = builtin Base.getfield(%1, :parent)::Matrix{Float64}
│ %14 = builtin Base.getfield(%13, :size)::Tuple{Int64, Int64}
│ %15 = $(Expr(:boundscheck, true))::Bool
│ %16 = builtin Base.getfield(%14, 1, %15)::Int64
│ %17 = $(Expr(:boundscheck, true))::Bool
│ %18 = builtin Base.getfield(%14, 2, %17)::Int64
│ %19 = builtin (%10 === %18)::Bool
└──── goto #3 if not %19
2 ─── goto #4
3 ─── %22 = builtin (%18 === 1)::Bool
└──── goto #4
4 ┄── %24 = φ (#2 => %19, #3 => %22)::Bool
└──── goto #12 if not %24
5 ─── %26 = builtin (%7 === %16)::Bool
└──── goto #7 if not %26
6 ─── goto #8
7 ─── %29 = builtin (%16 === 1)::Bool
└──── goto #8
8 ┄── %31 = φ (#6 => %26, #7 => %29)::Bool
└──── goto #11 if not %31
9 ─── %33 = builtin Base.getfield(%2, :parent)::Vector{Float64}
│ %34 = builtin Base.getfield(%33, :size)::Tuple{Int64}
│ %35 = $(Expr(:boundscheck, true))::Bool
│ %36 = builtin Base.getfield(%34, 1, %35)::Int64
│ %37 = builtin (%10 === 1)::Bool
└──── goto #13 if not %37
10 ── goto #14
11 ── %40 = invoke Base.Broadcast.DimensionMismatch("array could not be broadcast to match destination"::String)::Core.Const(DimensionMismatch("array could not be broadcast to match destination"))
│ builtin Base.Broadcast.throw(%40)
└──── unreachable
12 ── %43 = invoke Base.Broadcast.DimensionMismatch("array could not be broadcast to match destination"::String)::Core.Const(DimensionMismatch("array could not be broadcast to match destination"))
│ builtin Base.Broadcast.throw(%43)
└──── unreachable
13 ── goto #14
14 ┄─ %47 = φ (#10 => %37, #13 => true)::Bool
└──── goto #22 if not %47
15 ── %49 = builtin (%7 === %36)::Bool
└──── goto #17 if not %49
16 ── goto #18
17 ── %52 = builtin (%36 === 1)::Bool
└──── goto #18
18 ┄─ %54 = φ (#16 => %49, #17 => %52)::Bool
└──── goto #21 if not %54
19 ── %56 = builtin Base.getfield(%3, :parent)::Vector{Float64}
│ %57 = builtin Base.getfield(%56, :size)::Tuple{Int64}
│ %58 = $(Expr(:boundscheck, true))::Bool
│ %59 = builtin Base.getfield(%57, 1, %58)::Int64
│ %60 = builtin (%10 === 1)::Bool
└──── goto #23 if not %60
20 ── goto #24
21 ── %63 = invoke Base.Broadcast.DimensionMismatch("array could not be broadcast to match destination"::String)::Core.Const(DimensionMismatch("array could not be broadcast to match destination"))
│ builtin Base.Broadcast.throw(%63)
└──── unreachable
22 ── %66 = invoke Base.Broadcast.DimensionMismatch("array could not be broadcast to match destination"::String)::Core.Const(DimensionMismatch("array could not be broadcast to match destination"))
│ builtin Base.Broadcast.throw(%66)
└──── unreachable
23 ── goto #24
24 ┄─ %70 = φ (#20 => %60, #23 => true)::Bool
└──── goto #32 if not %70
25 ── %72 = builtin (%7 === %59)::Bool
└──── goto #27 if not %72
26 ── goto #28
27 ── %75 = builtin (%59 === 1)::Bool
└──── goto #28
28 ┄─ %77 = φ (#26 => %72, #27 => %75)::Bool
└──── goto #31 if not %77
29 ── %79 = builtin Base.getfield(dest, :parent)::Matrix{Float64}
│ %80 = builtin Base.getfield(%79, :size)::Tuple{Int64, Int64}
│ %81 = $(Expr(:boundscheck, true))::Bool
│ %82 = builtin Base.getfield(%80, 1, %81)::Int64
│ %83 = $(Expr(:boundscheck, true))::Bool
│ %84 = builtin Base.getfield(%80, 2, %83)::Int64
│ %85 = builtin (%84 === %10)::Bool
│ %86 = builtin (%85 === false)::Bool
└──── goto #33 if not %86
30 ── goto #37
31 ── %89 = invoke Base.Broadcast.DimensionMismatch("array could not be broadcast to match destination"::String)::Core.Const(DimensionMismatch("array could not be broadcast to match destination"))
│ builtin Base.Broadcast.throw(%89)
└──── unreachable
32 ── %92 = invoke Base.Broadcast.DimensionMismatch("array could not be broadcast to match destination"::String)::Core.Const(DimensionMismatch("array could not be broadcast to match destination"))
│ builtin Base.Broadcast.throw(%92)
└──── unreachable
33 ── %95 = builtin (%82 === %7)::Bool
│ %96 = builtin (%95 === false)::Bool
└──── goto #35 if not %96
34 ── goto #36
35 ── goto #36
36 ┄─ %100 = φ (#34 => false, #35 => true)::Bool
└──── goto #37
37 ┄─ %102 = φ (#30 => false, #36 => %100)::Bool
└──── goto #136 if not %102
38 ── %104 = builtin (dest === %1)::Bool
└──── goto #40 if not %104
39 ── goto #56
40 ── %107 = builtin Base.getfield(dest, :parent)::Matrix{Float64}
│ %108 = builtin Base.getfield(%107, :size)::Tuple{Int64, Int64}
│ %109 = $(Expr(:boundscheck, true))::Bool
│ %110 = builtin Base.getfield(%108, 1, %109)::Int64
│ %111 = $(Expr(:boundscheck, true))::Bool
│ %112 = builtin Base.getfield(%108, 2, %111)::Int64
│ %113 = intrinsic Base.mul_int(%110, %112)::Int64
│ %114 = builtin (%113 === 0)::Bool
│ %115 = intrinsic Base.not_int(%114)::Bool
└──── goto #44 if not %115
41 ── %117 = builtin Base.getfield(%1, :parent)::Matrix{Float64}
│ %118 = builtin Base.getfield(%117, :size)::Tuple{Int64, Int64}
│ %119 = $(Expr(:boundscheck, true))::Bool
│ %120 = builtin Base.getfield(%118, 1, %119)::Int64
│ %121 = $(Expr(:boundscheck, true))::Bool
│ %122 = builtin Base.getfield(%118, 2, %121)::Int64
│ %123 = intrinsic Base.mul_int(%120, %122)::Int64
│ %124 = builtin (%123 === 0)::Bool
│ %125 = intrinsic Base.not_int(%124)::Bool
└──── goto #43 if not %125
42 ── %127 = builtin Base.getfield(dest, :parent)::Matrix{Float64}
│ %128 = builtin Base.getfield(%127, :ref)::MemoryRef{Float64}
│ %129 = builtin Base.getfield(%128, :mem)::Memory{Float64}
│ %130 = builtin Base.getfield(%129, :ptr)::Ptr{Nothing}
│ %131 = intrinsic Core.bitcast(Core.UInt, %130)::UInt64
│ %132 = builtin Base.getfield(%1, :parent)::Matrix{Float64}
│ %133 = builtin Base.getfield(%132, :ref)::MemoryRef{Float64}
│ %134 = builtin Base.getfield(%133, :mem)::Memory{Float64}
│ %135 = builtin Base.getfield(%134, :ptr)::Ptr{Nothing}
│ %136 = intrinsic Core.bitcast(Core.UInt, %135)::UInt64
│ %137 = builtin (%131 === %136)::Bool
│ %138 = intrinsic Base.not_int(%137)::Bool
│ %139 = intrinsic Base.not_int(%138)::Bool
└──── goto #45
43 ── goto #45
44 ── goto #45
45 ┄─ %143 = φ (#42 => %139, #43 => false, #44 => false)::Bool
└──── goto #54 if not %143
46 ── %145 = builtin Base.getfield(%1, :parent)::Matrix{Float64}
│ %146 = builtin Base.getfield(%145, :ref)::MemoryRef{Float64}
│ %147 = builtin Base.getfield(%145, :size)::Tuple{Int64, Int64}
│ %148 = $(Expr(:boundscheck, true))::Bool
│ %149 = builtin Base.getfield(%147, 1, %148)::Int64
│ %150 = $(Expr(:boundscheck, true))::Bool
│ %151 = builtin Base.getfield(%147, 2, %150)::Int64
│ %152 = intrinsic Base.mul_int(%149, %151)::Int64
│ %153 = builtin Core.memorynew(Memory{Float64}, %152)::Core.PartialStruct(Memory{Float64}, Any[Int64, Ptr{Nothing}])
│ %154 = builtin Core.memoryrefnew(%153)::MemoryRef{Float64}
│ %155 = builtin Base.getfield(%145, :size)::Tuple{Int64, Int64}
│ %156 = $(Expr(:boundscheck, true))::Bool
│ %157 = builtin Base.getfield(%155, 1, %156)::Int64
│ %158 = $(Expr(:boundscheck, true))::Bool
│ %159 = builtin Base.getfield(%155, 2, %158)::Int64
│ %160 = intrinsic Base.mul_int(%157, %159)::Int64
│ %161 = builtin (%160 === 0)::Bool
└──── goto #48 if not %161
47 ── goto #53
48 ── %164 = $(Expr(:boundscheck, false))::Bool
└──── goto #50 if not %164
49 ── %166 = $(Expr(:boundscheck, true))::Bool
│ builtin Core.memoryrefnew(%154, %160, %166)
│ %168 = $(Expr(:boundscheck, true))::Bool
└──── builtin Core.memoryrefnew(%146, %160, %168)
50 ┄─ %170 = $(Expr(:gc_preserve_begin, :(%154)))
│ %171 = $(Expr(:gc_preserve_begin, :(%146)))
│ %172 = builtin Base.getfield(%154, :ptr_or_offset)::Ptr{Nothing}
│ %173 = builtin Base.getfield(%146, :ptr_or_offset)::Ptr{Nothing}
│ %174 = intrinsic Base.mul_int(8, %160)::Int64
│ %175 = intrinsic Core.lshr_int(%174, 63)::Int64
│ %176 = intrinsic Core.trunc_int(Core.UInt8, %175)::UInt8
│ %177 = intrinsic Core.eq_int(%176, 0x01)::Bool
└──── goto #52 if not %177
51 ── dynamic invoke Core.throw_inexacterror(:convert::Symbol, UInt64::Type, %174::Int64)
└──── unreachable
52 ── %181 = intrinsic Core.bitcast(Core.UInt64, %174)::UInt64
│ $(Expr(:foreigncall, :(:memmove), Ptr{Nothing}, svec(Ptr{Nothing}, Ptr{Nothing}, UInt64), 0, :(:ccall), :(%172), :(%173), :(%181), :(%181), :(%173), :(%172)))
│ $(Expr(:gc_preserve_end, :(%170)))
│ $(Expr(:gc_preserve_end, :(%171)))
└──── goto #53
53 ┄─ %186 = builtin Core.memoryrefnew(%153)::MemoryRef{Float64}
│ %187 = builtin Base.getfield(%145, :size)::Tuple{Int64, Int64}
│ %188 = %new(Matrix{Float64}, %186, %187)::Matrix{Float64}
│ %189 = %new(Adjoint{Float64, Matrix{Float64}}, %188)::Adjoint{Float64, Matrix{Float64}}
└──── goto #55
54 ── goto #55
55 ┄─ %192 = φ (#53 => %189, #54 => %1)::Adjoint{Float64, Matrix{Float64}}
└──── goto #56
56 ┄─ %194 = φ (#39 => %1, #55 => %192)::Adjoint{Float64, Matrix{Float64}}
│ %195 = builtin Base.getfield(%194, :parent)::Matrix{Float64}
│ %196 = builtin Base.getfield(%195, :size)::Tuple{Int64, Int64}
│ %197 = $(Expr(:boundscheck, true))::Bool
│ %198 = builtin Base.getfield(%196, 1, %197)::Int64
│ %199 = $(Expr(:boundscheck, true))::Bool
│ %200 = builtin Base.getfield(%196, 2, %199)::Int64
│ %201 = builtin (%198 === 1)::Bool
│ %202 = intrinsic Base.not_int(%201)::Bool
│ %203 = builtin (%200 === 1)::Bool
│ %204 = intrinsic Base.not_int(%203)::Bool
│ %205 = builtin Core.tuple(%204, %202)::Tuple{Bool, Bool}
│ %206 = %new(Base.Broadcast.Extruded{Adjoint{Float64, Matrix{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, %194, %205, (1, 1))::Core.PartialStruct(Base.Broadcast.Extruded{Adjoint{Float64, Matrix{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Any[Adjoint{Float64, Matrix{Float64}}, Tuple{Bool, Bool}, Core.Const((1, 1))])
│ %207 = builtin Base.getfield(dest, :parent)::Matrix{Float64}
│ %208 = builtin Base.getfield(%207, :size)::Tuple{Int64, Int64}
│ %209 = $(Expr(:boundscheck, true))::Bool
│ %210 = builtin Base.getfield(%208, 1, %209)::Int64
│ %211 = $(Expr(:boundscheck, true))::Bool
│ %212 = builtin Base.getfield(%208, 2, %211)::Int64
│ %213 = intrinsic Base.mul_int(%210, %212)::Int64
│ %214 = builtin (%213 === 0)::Bool
│ %215 = intrinsic Base.not_int(%214)::Bool
└──── goto #60 if not %215
57 ── %217 = builtin Base.getfield(%2, :parent)::Vector{Float64}
│ %218 = builtin Base.getfield(%217, :size)::Tuple{Int64}
│ %219 = $(Expr(:boundscheck, true))::Bool
│ %220 = builtin Base.getfield(%218, 1, %219)::Int64
│ %221 = builtin (%220 === 0)::Bool
│ %222 = intrinsic Base.not_int(%221)::Bool
└──── goto #59 if not %222
58 ── %224 = builtin Base.getfield(dest, :parent)::Matrix{Float64}
│ %225 = builtin Base.getfield(%224, :ref)::MemoryRef{Float64}
│ %226 = builtin Base.getfield(%225, :mem)::Memory{Float64}
│ %227 = builtin Base.getfield(%226, :ptr)::Ptr{Nothing}
│ %228 = intrinsic Core.bitcast(Core.UInt, %227)::UInt64
│ %229 = builtin Base.getfield(%2, :parent)::Vector{Float64}
│ %230 = builtin Base.getfield(%229, :ref)::MemoryRef{Float64}
│ %231 = builtin Base.getfield(%230, :mem)::Memory{Float64}
│ %232 = builtin Base.getfield(%231, :ptr)::Ptr{Nothing}
│ %233 = intrinsic Core.bitcast(Core.UInt, %232)::UInt64
│ %234 = builtin (%228 === %233)::Bool
│ %235 = intrinsic Base.not_int(%234)::Bool
│ %236 = intrinsic Base.not_int(%235)::Bool
└──── goto #61
59 ── goto #61
60 ── goto #61
61 ┄─ %240 = φ (#58 => %236, #59 => false, #60 => false)::Bool
└──── goto #70 if not %240
62 ── %242 = builtin Base.getfield(%2, :parent)::Vector{Float64}
│ %243 = builtin Base.getfield(%242, :ref)::MemoryRef{Float64}
│ %244 = builtin Base.getfield(%242, :size)::Tuple{Int64}
│ %245 = $(Expr(:boundscheck, true))::Bool
│ %246 = builtin Base.getfield(%244, 1, %245)::Int64
│ %247 = builtin Core.memorynew(Memory{Float64}, %246)::Core.PartialStruct(Memory{Float64}, Any[Int64, Ptr{Nothing}])
│ %248 = builtin Core.memoryrefnew(%247)::MemoryRef{Float64}
│ %249 = builtin Base.getfield(%242, :size)::Tuple{Int64}
│ %250 = $(Expr(:boundscheck, true))::Bool
│ %251 = builtin Base.getfield(%249, 1, %250)::Int64
│ %252 = builtin (%251 === 0)::Bool
└──── goto #64 if not %252
63 ── goto #69
64 ── %255 = $(Expr(:boundscheck, false))::Bool
└──── goto #66 if not %255
65 ── %257 = $(Expr(:boundscheck, true))::Bool
│ builtin Core.memoryrefnew(%248, %251, %257)
│ %259 = $(Expr(:boundscheck, true))::Bool
└──── builtin Core.memoryrefnew(%243, %251, %259)
66 ┄─ %261 = $(Expr(:gc_preserve_begin, :(%248)))
│ %262 = $(Expr(:gc_preserve_begin, :(%243)))
│ %263 = builtin Base.getfield(%248, :ptr_or_offset)::Ptr{Nothing}
│ %264 = builtin Base.getfield(%243, :ptr_or_offset)::Ptr{Nothing}
│ %265 = intrinsic Base.mul_int(8, %251)::Int64
│ %266 = intrinsic Core.lshr_int(%265, 63)::Int64
│ %267 = intrinsic Core.trunc_int(Core.UInt8, %266)::UInt8
│ %268 = intrinsic Core.eq_int(%267, 0x01)::Bool
└──── goto #68 if not %268
67 ── dynamic invoke Core.throw_inexacterror(:convert::Symbol, UInt64::Type, %265::Int64)
└──── unreachable
68 ── %272 = intrinsic Core.bitcast(Core.UInt64, %265)::UInt64
│ $(Expr(:foreigncall, :(:memmove), Ptr{Nothing}, svec(Ptr{Nothing}, Ptr{Nothing}, UInt64), 0, :(:ccall), :(%263), :(%264), :(%272), :(%272), :(%264), :(%263)))
│ $(Expr(:gc_preserve_end, :(%261)))
│ $(Expr(:gc_preserve_end, :(%262)))
└──── goto #69
69 ┄─ %277 = builtin Core.memoryrefnew(%247)::MemoryRef{Float64}
│ %278 = builtin Base.getfield(%242, :size)::Tuple{Int64}
│ %279 = %new(Vector{Float64}, %277, %278)::Vector{Float64}
│ %280 = %new(Adjoint{Float64, Vector{Float64}}, %279)::Adjoint{Float64, Vector{Float64}}
└──── goto #71
70 ── goto #71
71 ┄─ %283 = φ (#69 => %280, #70 => %2)::Adjoint{Float64, Vector{Float64}}
│ %284 = builtin Base.getfield(%283, :parent)::Vector{Float64}
│ %285 = builtin Base.getfield(%284, :size)::Tuple{Int64}
│ %286 = $(Expr(:boundscheck, true))::Bool
│ %287 = builtin Base.getfield(%285, 1, %286)::Int64
│ %288 = builtin (%287 === 1)::Bool
│ %289 = intrinsic Base.not_int(%288)::Bool
│ %290 = builtin Core.tuple(false, %289)::Core.PartialStruct(Tuple{Bool, Bool}, Any[Core.Const(false), Bool])
│ %291 = %new(Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, %283, %290, (1, 1))::Core.PartialStruct(Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Any[Adjoint{Float64, Vector{Float64}}, Core.PartialStruct(Tuple{Bool, Bool}, Any[Core.Const(false), Bool]), Core.Const((1, 1))])
│ %292 = builtin Base.getfield(dest, :parent)::Matrix{Float64}
│ %293 = builtin Base.getfield(%292, :size)::Tuple{Int64, Int64}
│ %294 = $(Expr(:boundscheck, true))::Bool
│ %295 = builtin Base.getfield(%293, 1, %294)::Int64
│ %296 = $(Expr(:boundscheck, true))::Bool
│ %297 = builtin Base.getfield(%293, 2, %296)::Int64
│ %298 = intrinsic Base.mul_int(%295, %297)::Int64
│ %299 = builtin (%298 === 0)::Bool
│ %300 = intrinsic Base.not_int(%299)::Bool
└──── goto #75 if not %300
72 ── %302 = builtin Base.getfield(%3, :parent)::Vector{Float64}
│ %303 = builtin Base.getfield(%302, :size)::Tuple{Int64}
│ %304 = $(Expr(:boundscheck, true))::Bool
│ %305 = builtin Base.getfield(%303, 1, %304)::Int64
│ %306 = builtin (%305 === 0)::Bool
│ %307 = intrinsic Base.not_int(%306)::Bool
└──── goto #74 if not %307
73 ── %309 = builtin Base.getfield(dest, :parent)::Matrix{Float64}
│ %310 = builtin Base.getfield(%309, :ref)::MemoryRef{Float64}
│ %311 = builtin Base.getfield(%310, :mem)::Memory{Float64}
│ %312 = builtin Base.getfield(%311, :ptr)::Ptr{Nothing}
│ %313 = intrinsic Core.bitcast(Core.UInt, %312)::UInt64
│ %314 = builtin Base.getfield(%3, :parent)::Vector{Float64}
│ %315 = builtin Base.getfield(%314, :ref)::MemoryRef{Float64}
│ %316 = builtin Base.getfield(%315, :mem)::Memory{Float64}
│ %317 = builtin Base.getfield(%316, :ptr)::Ptr{Nothing}
│ %318 = intrinsic Core.bitcast(Core.UInt, %317)::UInt64
│ %319 = builtin (%313 === %318)::Bool
│ %320 = intrinsic Base.not_int(%319)::Bool
│ %321 = intrinsic Base.not_int(%320)::Bool
└──── goto #76
74 ── goto #76
75 ── goto #76
76 ┄─ %325 = φ (#73 => %321, #74 => false, #75 => false)::Bool
└──── goto #85 if not %325
77 ── %327 = builtin Base.getfield(%3, :parent)::Vector{Float64}
│ %328 = builtin Base.getfield(%327, :ref)::MemoryRef{Float64}
│ %329 = builtin Base.getfield(%327, :size)::Tuple{Int64}
│ %330 = $(Expr(:boundscheck, true))::Bool
│ %331 = builtin Base.getfield(%329, 1, %330)::Int64
│ %332 = builtin Core.memorynew(Memory{Float64}, %331)::Core.PartialStruct(Memory{Float64}, Any[Int64, Ptr{Nothing}])
│ %333 = builtin Core.memoryrefnew(%332)::MemoryRef{Float64}
│ %334 = builtin Base.getfield(%327, :size)::Tuple{Int64}
│ %335 = $(Expr(:boundscheck, true))::Bool
│ %336 = builtin Base.getfield(%334, 1, %335)::Int64
│ %337 = builtin (%336 === 0)::Bool
└──── goto #79 if not %337
78 ── goto #84
79 ── %340 = $(Expr(:boundscheck, false))::Bool
└──── goto #81 if not %340
80 ── %342 = $(Expr(:boundscheck, true))::Bool
│ builtin Core.memoryrefnew(%333, %336, %342)
│ %344 = $(Expr(:boundscheck, true))::Bool
└──── builtin Core.memoryrefnew(%328, %336, %344)
81 ┄─ %346 = $(Expr(:gc_preserve_begin, :(%333)))
│ %347 = $(Expr(:gc_preserve_begin, :(%328)))
│ %348 = builtin Base.getfield(%333, :ptr_or_offset)::Ptr{Nothing}
│ %349 = builtin Base.getfield(%328, :ptr_or_offset)::Ptr{Nothing}
│ %350 = intrinsic Base.mul_int(8, %336)::Int64
│ %351 = intrinsic Core.lshr_int(%350, 63)::Int64
│ %352 = intrinsic Core.trunc_int(Core.UInt8, %351)::UInt8
│ %353 = intrinsic Core.eq_int(%352, 0x01)::Bool
└──── goto #83 if not %353
82 ── dynamic invoke Core.throw_inexacterror(:convert::Symbol, UInt64::Type, %350::Int64)
└──── unreachable
83 ── %357 = intrinsic Core.bitcast(Core.UInt64, %350)::UInt64
│ $(Expr(:foreigncall, :(:memmove), Ptr{Nothing}, svec(Ptr{Nothing}, Ptr{Nothing}, UInt64), 0, :(:ccall), :(%348), :(%349), :(%357), :(%357), :(%349), :(%348)))
│ $(Expr(:gc_preserve_end, :(%346)))
│ $(Expr(:gc_preserve_end, :(%347)))
└──── goto #84
84 ┄─ %362 = builtin Core.memoryrefnew(%332)::MemoryRef{Float64}
│ %363 = builtin Base.getfield(%327, :size)::Tuple{Int64}
│ %364 = %new(Vector{Float64}, %362, %363)::Vector{Float64}
│ %365 = %new(Adjoint{Float64, Vector{Float64}}, %364)::Adjoint{Float64, Vector{Float64}}
└──── goto #86
85 ── goto #86
86 ┄─ %368 = φ (#84 => %365, #85 => %3)::Adjoint{Float64, Vector{Float64}}
│ %369 = builtin Base.getfield(%368, :parent)::Vector{Float64}
│ %370 = builtin Base.getfield(%369, :size)::Tuple{Int64}
│ %371 = $(Expr(:boundscheck, true))::Bool
│ %372 = builtin Base.getfield(%370, 1, %371)::Int64
│ %373 = builtin (%372 === 1)::Bool
│ %374 = intrinsic Base.not_int(%373)::Bool
│ %375 = builtin Core.tuple(false, %374)::Core.PartialStruct(Tuple{Bool, Bool}, Any[Core.Const(false), Bool])
│ %376 = %new(Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, %368, %375, (1, 1))::Core.PartialStruct(Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Any[Adjoint{Float64, Vector{Float64}}, Core.PartialStruct(Tuple{Bool, Bool}, Any[Core.Const(false), Bool]), Core.Const((1, 1))])
│ %377 = builtin Core.tuple(%206, %291, %376)::Core.PartialStruct(Tuple{Base.Broadcast.Extruded{Adjoint{Float64, Matrix{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}}, Any[Core.PartialStruct(Base.Broadcast.Extruded{Adjoint{Float64, Matrix{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Any[Adjoint{Float64, Matrix{Float64}}, Tuple{Bool, Bool}, Core.Const((1, 1))]), Core.PartialStruct(Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Any[Adjoint{Float64, Vector{Float64}}, Core.PartialStruct(Tuple{Bool, Bool}, Any[Core.Const(false), Bool]), Core.Const((1, 1))]), Core.PartialStruct(Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Any[Adjoint{Float64, Vector{Float64}}, Core.PartialStruct(Tuple{Bool, Bool}, Any[Core.Const(false), Bool]), Core.Const((1, 1))])])
│ %378 = %new(Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, StatsBase.var"#reconstruct!##0#reconstruct!##1", Tuple{Base.Broadcast.Extruded{Adjoint{Float64, Matrix{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}}}, nothing, StatsBase.var"#reconstruct!##0#reconstruct!##1"(), %377, %12)::Core.PartialStruct(Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, StatsBase.var"#reconstruct!##0#reconstruct!##1", Tuple{Base.Broadcast.Extruded{Adjoint{Float64, Matrix{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}}}, Any[Core.Const(nothing), Core.Const(StatsBase.var"#reconstruct!##0#reconstruct!##1"()), Core.PartialStruct(Tuple{Base.Broadcast.Extruded{Adjoint{Float64, Matrix{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}}, Any[Core.PartialStruct(Base.Broadcast.Extruded{Adjoint{Float64, Matrix{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Any[Adjoint{Float64, Matrix{Float64}}, Tuple{Bool, Bool}, Core.Const((1, 1))]), Core.PartialStruct(Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Any[Adjoint{Float64, Vector{Float64}}, Core.PartialStruct(Tuple{Bool, Bool}, Any[Core.Const(false), Bool]), Core.Const((1, 1))]), Core.PartialStruct(Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Any[Adjoint{Float64, Vector{Float64}}, Core.PartialStruct(Tuple{Bool, Bool}, Any[Core.Const(false), Bool]), Core.Const((1, 1))])]), Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}])
│ %379 = intrinsic Base.sle_int(1, %7)::Bool
│ %380 = intrinsic Base.and_int(true, %379)::Bool
│ %381 = intrinsic Base.not_int(%380)::Bool
└──── goto #88 if not %381
87 ── goto #89
88 ── goto #89
89 ┄─ %385 = φ (#87 => true, #88 => false)::Bool
│ %386 = φ (#88 => 1)::Int64
│ %387 = φ (#88 => 1)::Int64
│ %388 = φ (#88 => 1)::Int64
│ %389 = intrinsic Base.not_int(%385)::Bool
└──── goto #135 if not %389
90 ┄─ %391 = φ (#89 => %386, #134 => %618)::Int64
│ %392 = φ (#89 => %387, #134 => %617)::Int64
│ %393 = φ (#89 => %388, #134 => %616)::Int64
│ %394 = intrinsic Base.slt_int(0, %10)::Bool
└──── goto #130 if not %394
91 ── nothing
92 ┄─ %397 = φ (#91 => 0, #128 => %605)::Int64
│ %398 = intrinsic Base.slt_int(%397, %10)::Bool
└──── goto #130 if not %398
93 ── %400 = intrinsic Base.add_int(%397, 1)::Int64
│ %401 = $(Expr(:boundscheck, false))::Bool
└──── goto #96 if not %401
94 ── %403 = builtin Core.tuple(%400)::Tuple{Int64}
│ %404 = intrinsic Base.sub_int(%400, 1)::Int64
│ %405 = intrinsic Base.bitcast(UInt64, %404)::UInt64
│ %406 = intrinsic Base.bitcast(UInt64, %10)::UInt64
│ %407 = intrinsic Base.ult_int(%405, %406)::Bool
└──── goto #105 if not %407
95 ── nothing
96 ┄─ %410 = builtin Core.tuple(%400, %391)::Tuple{Int64, Int64}
│ %411 = %new(CartesianIndex{2}, %410)::CartesianIndex{2}
│ %412 = $(Expr(:boundscheck, false))::Bool
└──── goto #99 if not %412
97 ── %414 = intrinsic Base.sub_int(%400, 1)::Int64
│ %415 = intrinsic Base.bitcast(UInt64, %414)::UInt64
│ %416 = intrinsic Base.bitcast(UInt64, %10)::UInt64
│ %417 = intrinsic Base.ult_int(%415, %416)::Bool
│ %418 = intrinsic Base.sub_int(%391, 1)::Int64
│ %419 = intrinsic Base.bitcast(UInt64, %418)::UInt64
│ %420 = intrinsic Base.bitcast(UInt64, %7)::UInt64
│ %421 = intrinsic Base.ult_int(%419, %420)::Bool
│ %422 = intrinsic Base.and_int(%421, true)::Bool
│ %423 = intrinsic Base.and_int(%417, %422)::Bool
│ %424 = intrinsic Base.and_int(%423, true)::Bool
└──── goto #106 if not %424
98 ── nothing
99 ┄─ %427 = builtin (Core.ifelse)(%204, %400, 1)::Int64
│ %428 = builtin (Core.ifelse)(%202, %391, 1)::Int64
│ %429 = builtin Base.getfield(%194, :parent)::Matrix{Float64}
│ %430 = $(Expr(:boundscheck, false))::Bool
└──── goto #102 if not %430
100 ─ %432 = builtin Core.tuple(%428, %427)::Tuple{Int64, Int64}
│ %433 = builtin Base.getfield(%429, :size)::Tuple{Int64, Int64}
│ %434 = $(Expr(:boundscheck, true))::Bool
│ %435 = builtin Base.getfield(%433, 1, %434)::Int64
│ %436 = $(Expr(:boundscheck, true))::Bool
│ %437 = builtin Base.getfield(%433, 2, %436)::Int64
│ %438 = intrinsic Base.sub_int(%428, 1)::Int64
│ %439 = intrinsic Base.bitcast(UInt64, %438)::UInt64
│ %440 = intrinsic Base.bitcast(UInt64, %435)::UInt64
│ %441 = intrinsic Base.ult_int(%439, %440)::Bool
│ %442 = intrinsic Base.sub_int(%427, 1)::Int64
│ %443 = intrinsic Base.bitcast(UInt64, %442)::UInt64
│ %444 = intrinsic Base.bitcast(UInt64, %437)::UInt64
│ %445 = intrinsic Base.ult_int(%443, %444)::Bool
│ %446 = intrinsic Base.and_int(%445, true)::Bool
│ %447 = intrinsic Base.and_int(%441, %446)::Bool
└──── goto #107 if not %447
101 ─ nothing
102 ┄ %450 = builtin Base.getfield(%429, :size)::Tuple{Int64, Int64}
│ %451 = $(Expr(:boundscheck, true))::Bool
│ %452 = builtin Base.getfield(%450, 1, %451)::Int64
│ %453 = intrinsic Base.mul_int(1, %452)::Int64
│ %454 = intrinsic Base.sub_int(%428, 1)::Int64
│ %455 = intrinsic Base.mul_int(%454, 1)::Int64
│ %456 = intrinsic Base.add_int(1, %455)::Int64
│ %457 = intrinsic Base.sub_int(%427, 1)::Int64
│ %458 = intrinsic Base.mul_int(%457, %453)::Int64
│ %459 = intrinsic Base.add_int(%456, %458)::Int64
│ %460 = $(Expr(:boundscheck, false))::Bool
└──── goto #109 if not %460
103 ─ %462 = intrinsic Base.sub_int(%459, 1)::Int64
│ %463 = intrinsic Base.bitcast(Base.UInt, %462)::UInt64
│ %464 = builtin Base.getfield(%429, :size)::Tuple{Int64, Int64}
│ %465 = $(Expr(:boundscheck, true))::Bool
│ %466 = builtin Base.getfield(%464, 1, %465)::Int64
│ %467 = $(Expr(:boundscheck, true))::Bool
│ %468 = builtin Base.getfield(%464, 2, %467)::Int64
│ %469 = intrinsic Base.mul_int(%466, %468)::Int64
│ %470 = intrinsic Base.bitcast(Base.UInt, %469)::UInt64
│ %471 = intrinsic Base.ult_int(%463, %470)::Bool
└──── goto #108 if not %471
104 ─ goto #109
105 ─ invoke Base.throw_boundserror(%11::Base.OneTo{Int64}, %403::Tuple{Int64})
└──── unreachable
106 ─ %476 = builtin Core.tuple(%411)::Tuple{CartesianIndex{2}}
│ invoke Base.throw_boundserror(%378::Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, StatsBase.var"#reconstruct!##0#reconstruct!##1", Tuple{Base.Broadcast.Extruded{Adjoint{Float64, Matrix{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}, Base.Broadcast.Extruded{Adjoint{Float64, Vector{Float64}}, Tuple{Bool, Bool}, Tuple{Int64, Int64}}}}, %476::Tuple{CartesianIndex{2}})
└──── unreachable
107 ─ invoke Base.throw_boundserror(%429::Matrix{Float64}, %432::Tuple{Int64, Int64})
└──── unreachable
108 ─ %481 = builtin Core.tuple(%459)::Tuple{Int64}
│ invoke Base.throw_boundserror(%429::Matrix{Float64}, %481::Tuple{Int64})
└──── unreachable
109 ┄ %484 = builtin Base.getfield(%429, :ref)::MemoryRef{Float64}
│ %485 = builtin Base.memoryrefnew(%484, %459, false)::MemoryRef{Float64}
│ %486 = builtin Base.memoryrefget(%485, :not_atomic, false)::Float64
│ %487 = builtin (Core.ifelse)(%289, %391, 1)::Int64
│ %488 = $(Expr(:boundscheck, false))::Bool
└──── goto #112 if not %488
110 ─ %490 = builtin Core.tuple(1, %487)::Core.PartialStruct(Tuple{Int64, Int64}, Any[Core.Const(1), Int64])
│ %491 = builtin Base.getfield(%283, :parent)::Vector{Float64}
│ %492 = builtin Base.getfield(%491, :size)::Tuple{Int64}
│ %493 = $(Expr(:boundscheck, true))::Bool
│ %494 = builtin Base.getfield(%492, 1, %493)::Int64
│ %495 = intrinsic Base.sub_int(%487, 1)::Int64
│ %496 = intrinsic Base.bitcast(UInt64, %495)::UInt64
│ %497 = intrinsic Base.bitcast(UInt64, %494)::UInt64
│ %498 = intrinsic Base.ult_int(%496, %497)::Bool
│ %499 = intrinsic Base.and_int(%498, true)::Bool
│ %500 = intrinsic Base.and_int(true, %499)::Bool
└──── goto #115 if not %500
111 ─ nothing
112 ┄ %503 = intrinsic Base.sub_int(%487, 1)::Int64
│ %504 = intrinsic Base.mul_int(%503, 1)::Int64
│ %505 = intrinsic Base.add_int(1, %504)::Int64
│ %506 = builtin Base.getfield(%283, :parent)::Vector{Float64}
│ %507 = intrinsic Base.sub_int(%505, 1)::Int64
│ %508 = intrinsic Base.add_int(%507, 1)::Int64
│ %509 = $(Expr(:boundscheck, false))::Bool
└──── goto #117 if not %509
113 ─ %511 = intrinsic Base.sub_int(%508, 1)::Int64
│ %512 = intrinsic Base.bitcast(Base.UInt, %511)::UInt64
│ %513 = builtin Base.getfield(%506, :size)::Tuple{Int64}
│ %514 = $(Expr(:boundscheck, true))::Bool
│ %515 = builtin Base.getfield(%513, 1, %514)::Int64
│ %516 = intrinsic Base.bitcast(Base.UInt, %515)::UInt64
│ %517 = intrinsic Base.ult_int(%512, %516)::Bool
└──── goto #116 if not %517
114 ─ goto #117
115 ─ invoke Base.throw_boundserror(%283::Adjoint{Float64, Vector{Float64}}, %490::Tuple{Int64, Int64})
└──── unreachable
116 ─ %522 = builtin Core.tuple(%508)::Tuple{Int64}
│ invoke Base.throw_boundserror(%506::Vector{Float64}, %522::Tuple{Int64})
└──── unreachable
117 ┄ %525 = builtin Base.getfield(%506, :ref)::MemoryRef{Float64}
│ %526 = builtin Base.memoryrefnew(%525, %508, false)::MemoryRef{Float64}
│ %527 = builtin Base.memoryrefget(%526, :not_atomic, false)::Float64
│ %528 = builtin (Core.ifelse)(%374, %391, 1)::Int64
│ %529 = $(Expr(:boundscheck, false))::Bool
└──── goto #120 if not %529
118 ─ %531 = builtin Core.tuple(1, %528)::Core.PartialStruct(Tuple{Int64, Int64}, Any[Core.Const(1), Int64])
│ %532 = builtin Base.getfield(%368, :parent)::Vector{Float64}
│ %533 = builtin Base.getfield(%532, :size)::Tuple{Int64}
│ %534 = $(Expr(:boundscheck, true))::Bool
│ %535 = builtin Base.getfield(%533, 1, %534)::Int64
│ %536 = intrinsic Base.sub_int(%528, 1)::Int64
│ %537 = intrinsic Base.bitcast(UInt64, %536)::UInt64
│ %538 = intrinsic Base.bitcast(UInt64, %535)::UInt64
│ %539 = intrinsic Base.ult_int(%537, %538)::Bool
│ %540 = intrinsic Base.and_int(%539, true)::Bool
│ %541 = intrinsic Base.and_int(true, %540)::Bool
└──── goto #123 if not %541
119 ─ nothing
120 ┄ %544 = intrinsic Base.sub_int(%528, 1)::Int64
│ %545 = intrinsic Base.mul_int(%544, 1)::Int64
│ %546 = intrinsic Base.add_int(1, %545)::Int64
│ %547 = builtin Base.getfield(%368, :parent)::Vector{Float64}
│ %548 = intrinsic Base.sub_int(%546, 1)::Int64
│ %549 = intrinsic Base.add_int(%548, 1)::Int64
│ %550 = $(Expr(:boundscheck, false))::Bool
└──── goto #125 if not %550
121 ─ %552 = intrinsic Base.sub_int(%549, 1)::Int64
│ %553 = intrinsic Base.bitcast(Base.UInt, %552)::UInt64
│ %554 = builtin Base.getfield(%547, :size)::Tuple{Int64}
│ %555 = $(Expr(:boundscheck, true))::Bool
│ %556 = builtin Base.getfield(%554, 1, %555)::Int64
│ %557 = intrinsic Base.bitcast(Base.UInt, %556)::UInt64
│ %558 = intrinsic Base.ult_int(%553, %557)::Bool
└──── goto #124 if not %558
122 ─ goto #125
123 ─ invoke Base.throw_boundserror(%368::Adjoint{Float64, Vector{Float64}}, %531::Tuple{Int64, Int64})
└──── unreachable
124 ─ %563 = builtin Core.tuple(%549)::Tuple{Int64}
│ invoke Base.throw_boundserror(%547::Vector{Float64}, %563::Tuple{Int64})
└──── unreachable
125 ┄ %566 = builtin Base.getfield(%547, :ref)::MemoryRef{Float64}
│ %567 = builtin Base.memoryrefnew(%566, %549, false)::MemoryRef{Float64}
│ %568 = builtin Base.memoryrefget(%567, :not_atomic, false)::Float64
│ %569 = intrinsic Base.mul_float(%486, %568)::Float64
│ %570 = intrinsic Base.add_float(%569, %527)::Float64
│ %571 = builtin Base.getfield(dest, :parent)::Matrix{Float64}
│ %572 = $(Expr(:boundscheck, false))::Bool
└──── goto #128 if not %572
126 ─ %574 = builtin Core.tuple(%391, %400)::Tuple{Int64, Int64}
│ %575 = builtin Base.getfield(%571, :size)::Tuple{Int64, Int64}
│ %576 = $(Expr(:boundscheck, true))::Bool
│ %577 = builtin Base.getfield(%575, 1, %576)::Int64
│ %578 = $(Expr(:boundscheck, true))::Bool
│ %579 = builtin Base.getfield(%575, 2, %578)::Int64
│ %580 = intrinsic Base.sub_int(%391, 1)::Int64
│ %581 = intrinsic Base.bitcast(UInt64, %580)::UInt64
│ %582 = intrinsic Base.bitcast(UInt64, %577)::UInt64
│ %583 = intrinsic Base.ult_int(%581, %582)::Bool
│ %584 = intrinsic Base.sub_int(%400, 1)::Int64
│ %585 = intrinsic Base.bitcast(UInt64, %584)::UInt64
│ %586 = intrinsic Base.bitcast(UInt64, %579)::UInt64
│ %587 = intrinsic Base.ult_int(%585, %586)::Bool
│ %588 = intrinsic Base.and_int(%587, true)::Bool
│ %589 = intrinsic Base.and_int(%583, %588)::Bool
└──── goto #129 if not %589
127 ─ nothing
128 ┄ %592 = builtin Base.getfield(%571, :ref)::MemoryRef{Float64}
│ %593 = builtin Base.getfield(%571, :size)::Tuple{Int64, Int64}
│ %594 = $(Expr(:boundscheck, true))::Bool
│ %595 = builtin Base.getfield(%593, 1, %594)::Int64
│ %596 = intrinsic Base.mul_int(1, %595)::Int64
│ %597 = intrinsic Base.sub_int(%391, 1)::Int64
│ %598 = intrinsic Base.mul_int(%597, 1)::Int64
│ %599 = intrinsic Base.add_int(1, %598)::Int64
│ %600 = intrinsic Base.sub_int(%400, 1)::Int64
│ %601 = intrinsic Base.mul_int(%600, %596)::Int64
│ %602 = intrinsic Base.add_int(%599, %601)::Int64
│ %603 = builtin Base.memoryrefnew(%592, %602, false)::MemoryRef{Float64}
│ builtin Base.memoryrefset!(%603, %570, :not_atomic, false)
│ %605 = intrinsic Base.add_int(%397, 1)::Int64
│ $(Expr(:loopinfo, Symbol("julia.simdloop"), nothing))
└──── goto #92
129 ─ invoke Base.throw_boundserror(%571::Matrix{Float64}, %574::Tuple{Int64, Int64})
└──── unreachable
130 ┄ %610 = intrinsic Base.add_int(%392, 1)::Int64
│ %611 = builtin (%393 === %7)::Bool
│ %612 = intrinsic Base.not_int(%611)::Bool
└──── goto #132 if not %612
131 ─ goto #133
132 ─ goto #133
133 ┄ %616 = φ (#131 => %610)::Int64
│ %617 = φ (#131 => %610)::Int64
│ %618 = φ (#131 => %610)::Int64
│ %619 = φ (#131 => false, #132 => true)::Bool
│ %620 = intrinsic Base.not_int(%619)::Bool
└──── goto #135 if not %620
134 ─ goto #90
135 ┄ return dest
136 ─ %624 = builtin Base.getfield(dest, :parent)::Matrix{Float64}
│ %625 = builtin Base.getfield(%624, :size)::Tuple{Int64, Int64}
│ %626 = $(Expr(:boundscheck, true))::Bool
│ %627 = builtin Base.getfield(%625, 1, %626)::Int64
│ %628 = %new(Base.OneTo{Int64}, %627)::Base.OneTo{Int64}
│ %629 = $(Expr(:boundscheck, true))::Bool
│ %630 = builtin Base.getfield(%625, 2, %629)::Int64
│ %631 = %new(Base.OneTo{Int64}, %630)::Base.OneTo{Int64}
│ %632 = builtin Core.tuple(%631, %628)::Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}
│ invoke Base.Broadcast.throwdm(%632::Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, %12::Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}})
└──── unreachableDepending on the debugging you're doing, this may / may not be useful. For --trim failures and similar, it would be very useful to be able to use Cthulhu with the native CI cache, so these cache effects are observable (they cause verification failures, as in the parent issue)