output.jl

julia> code_typed(DataFrame, (typeof(m),); debuginfo=:source)
1-element Array{Any,1}:
 CodeInfo(
1 ───        goto #3 if not false
2 ───        nothing::Nothing
3 ┄── %3   = π (false, Const(false, false))
└────        goto #5 if not %3
4 ───        nothing::Nothing
5 ┄── %6   = (DataFrames.applicable)(DataFrames.iterate, x)::Bool
└────        goto #61 if not %6
6 ─── %8   = %new(DataFrames.:(##326#328))::Const(##326#328(), false)
│     %9   = (Base.getfield)(x, :source)::EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}}
│     %10  = (Base.getfield)(%9, :source)::DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}
│     %11  = (Base.getfield)(%10, :x)::RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}
│     %12  = (Base.getfield)(%11, :len)::Int64
│     %13  = (Base.slt_int)(%12, 1)::Bool
└────        goto #8 if not %13
7 ───        goto #9
8 ─── %16  = (Base.getfield)(%11, :columns)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
└────        goto #9
9 ┄── %18  = φ (#7 => true, #8 => false)::Bool
│     %19  = φ (#8 => %16)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
│     %20  = φ (#8 => 1)::Int64
│     %21  = φ (#8 => %16)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
│     %22  = φ (#8 => 1)::Int64
│     %23  = φ (#8 => %16)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
│     %24  = φ (#8 => 1)::Int64
└────        goto #10
10 ──        goto #12 if not %18
11 ──        goto #13
12 ── %28  = (getfield)(%19, :a)::Array{Float64,1}
│     %29  = (Base.arrayref)(true, %28, %20)::Float64
│     %30  = (getfield)(%21, :b)::Array{Float64,1}
│     %31  = (Base.arrayref)(true, %30, %22)::Float64
│     %32  = (getfield)(%23, :c)::Array{Float64,1}
│     %33  = (Base.arrayref)(true, %32, %24)::Float64
│     %34  = %new(NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}, %29, %31, %33)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
└────        goto #13
13 ┄─ %36  = φ (#11 => true, #12 => false)::Bool
│     %37  = φ (#12 => %34)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
└────        goto #14
14 ──        goto #15
15 ──        goto #17 if not %36
16 ──        goto #18
17 ──        goto #18
18 ┄─ %43  = φ (#16 => true, #17 => false)::Bool
│     %44  = φ (#17 => %37)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
│     %45  = (Base.not_int)(%43)::Bool
└────        goto #20 if not %45
19 ──        invoke %8(%44::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}})::Bool
└────        goto #21
20 ──        goto #21
21 ┄─ %50  = φ (#19 => false, #20 => true)::Bool
└────        goto #22
22 ──        goto #61 if not %50
23 ──        goto #37 if not true
24 ┄─ %54  = φ (#23 => (Base.IsInfinite(), 2), #36 => %80)::Union{Nothing, Tuple{Union{IsInfinite, SizeUnknown},Int64}}
│     %55  = π (%54, Union{Tuple{IsInfinite,Int64}, Tuple{SizeUnknown,Int64}})
│     %56  = (Core.getfield)(%55, 1)::Union{IsInfinite, SizeUnknown}
│     %57  = (Core.getfield)(%55, 2)::Int64
│     %58  = (isa)(%56, IsInfinite)::Bool
└────        goto #26 if not %58
25 ──        goto #29
26 ── %61  = (isa)(%56, SizeUnknown)::Bool
└────        goto #28 if not %61
27 ──        goto #29
28 ──        (Core.throw)(ErrorException("fatal error in type inference (type bound)"))::Union{}
└────        $(Expr(:unreachable))::Union{}
29 ┄─ %66  = (Base.sle_int)(1, %57)::Bool
└────        goto #31 if not %66
30 ── %68  = (Base.sle_int)(%57, 2)::Bool
└────        goto #32
31 ──        nothing::Nothing
32 ┄─ %71  = φ (#30 => %68, #31 => false)::Bool
└────        goto #34 if not %71
33 ── %73  = (Base.getfield)((IsInfinite(), SizeUnknown()), %57, false)::Union{IsInfinite, SizeUnknown}
│     %74  = (Base.add_int)(%57, 1)::Int64
│     %75  = (Core.tuple)(%73, %74)::Tuple{Union{IsInfinite, SizeUnknown},Int64}
└────        goto #35
34 ── %77  = Base.nothing::Nothing
└────        goto #35
35 ┄─ %79  = φ (#33 => false, #34 => true)::Bool
│     %80  = φ (#33 => %75, #34 => %77)::Union{Nothing, Tuple{Union{IsInfinite, SizeUnknown},Int64}}
│     %81  = (Base.not_int)(%79)::Bool
└────        goto #37 if not %81
36 ──        goto #24
37 ┄─        goto #38
38 ──        goto #39
39 ──        goto #40
40 ──        goto #42 if not false
41 ──        nothing::Nothing
42 ┄─        goto #44 if not false
43 ──        nothing::Nothing
44 ┄─ %91  = (Base.getfield)(x, :source)::EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}}
│     %92  = (Base.getfield)(%91, :source)::DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}
│     %93  = (Base.getfield)(%92, :x)::RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}
│     %94  = (Base.getfield)(%93, :len)::Int64
│     %95  = $(Expr(:foreigncall, :(:jl_alloc_array_1d), Array{AbstractArray{T,1} where T,1}, svec(Any, Int64), :(:ccall), 2, Array{AbstractArray{T,1} where T,1}, :(%94), :(%94)))::Array{AbstractArray{T,1} where T,1}
│            (Base.arraysize)(%95, 1)::Int64
│     %97  = (Base.getfield)(x, :source)::EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}}
│     %98  = (Base.getfield)(%97, :source)::DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}
│     %99  = (Base.getfield)(%98, :x)::RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}
│     %100 = (Base.getfield)(%99, :len)::Int64
│     %101 = (Base.slt_int)(%100, 1)::Bool
└────        goto #46 if not %101
45 ──        goto #47
46 ── %104 = (Base.getfield)(%99, :columns)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
└────        goto #47
47 ┄─ %106 = φ (#45 => true, #46 => false)::Bool
│     %107 = φ (#46 => %104)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
│     %108 = φ (#46 => 1)::Int64
│     %109 = φ (#46 => %104)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
│     %110 = φ (#46 => 1)::Int64
│     %111 = φ (#46 => %104)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
│     %112 = φ (#46 => 1)::Int64
└────        goto #48
48 ──        goto #50 if not %106
49 ──        goto #51
50 ── %116 = (getfield)(%107, :a)::Array{Float64,1}
│            (Base.arrayref)(true, %116, %108)::Float64
│     %118 = (getfield)(%109, :b)::Array{Float64,1}
│            (Base.arrayref)(true, %118, %110)::Float64
│     %120 = (getfield)(%111, :c)::Array{Float64,1}
│     %121 = (Base.arrayref)(true, %120, %112)::Float64
└────        goto #51
51 ┄─ %123 = φ (#49 => true, #50 => false)::Bool
│     %124 = φ (#50 => %121)::Float64
└────        goto #52
52 ──        goto #53
53 ──        goto #55 if not %123
54 ──        goto #56
55 ──        goto #56
56 ┄─ %130 = φ (#54 => true, #55 => false)::Bool
│     %131 = φ (#55 => %124)::Float64
│     %132 = (Base.not_int)(%130)::Bool
└────        goto #60 if not %132
57 ──        goto #59 if not false
58 ──        nothing::Nothing
59 ┄─        invoke Base.setindex!(%95::Array{AbstractArray{T,1} where T,1}, %131::Float64, 1::Int64)::Union{}
└────        $(Expr(:unreachable))::Union{}
60 ┄─ %138 = %new(Generator{EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6},typeof(first)}, first, x)::Generator{EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6},typeof(first)}
│     %139 = invoke Base.collect(%138::Base.Generator{QueryOperators.EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},QueryOperators.EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},Tables.DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},Tables.RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},getfield(Main, Symbol("##4#6"))},typeof(first)})::Array{Float64,1}
│            (DataFrames.DataFrame)(%95, %139)::Union{}
└────        $(Expr(:unreachable))::Union{}
61 ┄─ %142 = (Core.tuple)(Base.Tuple, typeof(iterate))::Tuple{DataType,DataType}
│     %143 = (Base.getfield)(Tuple{EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, :parameters)::SimpleVector
│            (Core._apply)(Core.apply_type, %142, %143)::Type{Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}}
│     %145 = (Base.getfield)(typeof(iterate), :name)::TypeName
│     %146 = (Base.getfield)(%145, :mt)::Any
│     %147 = $(Expr(:foreigncall, :(:jl_method_exists), Int32, svec(Any, Any, UInt64), :(:ccall), 3, :(%146), Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, 0xffffffffffffffff, 0xffffffffffffffff))::Int32
│     %148 = (Core.sext_int)(Core.Int64, %147)::Int64
│     %149 = (%148 === 0)::Bool
│     %150 = (Base.not_int)(%149)::Bool
└────        goto #63 if not %150
62 ──        (NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}} <: TableTraits.NamedTuple)::Bool
└────        goto #64
63 ──        goto #64
64 ┄─ %155 = φ (#62 => true, #63 => false)::Bool
└────        goto #66 if not %155
65 ──        goto #67
66 ── %158 = (Core.tuple)(Base.Tuple, typeof(iterate))::Tuple{DataType,DataType}
│     %159 = (Base.getfield)(Tuple{EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, :parameters)::SimpleVector
│            (Core._apply)(Core.apply_type, %158, %159)::Type{Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}}
│     %161 = (Base.getfield)(typeof(iterate), :name)::TypeName
│     %162 = (Base.getfield)(%161, :mt)::Any
│     %163 = $(Expr(:foreigncall, :(:jl_method_exists), Int32, svec(Any, Any, UInt64), :(:ccall), 3, :(%162), Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, 0xffffffffffffffff, 0xffffffffffffffff))::Int32
│     %164 = (Core.sext_int)(Core.Int64, %163)::Int64
│     %165 = (%164 === 0)::Bool
│     %166 = (Base.not_int)(%165)::Bool
└────        goto #67
67 ┄─ %168 = φ (#65 => %155, #66 => %166)::Bool
└────        goto #144 if not %168
68 ── %170 = (Core.tuple)(Base.Tuple, typeof(iterate))::Tuple{DataType,DataType}
│     %171 = (Base.getfield)(Tuple{EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, :parameters)::SimpleVector
│            (Core._apply)(Core.apply_type, %170, %171)::Type{Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}}
│     %173 = (Base.getfield)(typeof(iterate), :name)::TypeName
│     %174 = (Base.getfield)(%173, :mt)::Any
│     %175 = $(Expr(:foreigncall, :(:jl_method_exists), Int32, svec(Any, Any, UInt64), :(:ccall), 3, :(%174), Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, 0xffffffffffffffff, 0xffffffffffffffff))::Int32
│     %176 = (Core.sext_int)(Core.Int64, %175)::Int64
│     %177 = (%176 === 0)::Bool
│     %178 = (Base.not_int)(%177)::Bool
└────        goto #70 if not %178
69 ──        (NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}} <: TableTraits.NamedTuple)::Bool
└────        goto #71
70 ──        goto #71
71 ┄─ %183 = φ (#69 => true, #70 => false)::Bool
└────        goto #73 if not %183
72 ──        goto #74
73 ── %186 = (Core.tuple)(Base.Tuple, typeof(iterate))::Tuple{DataType,DataType}
│     %187 = (Base.getfield)(Tuple{EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, :parameters)::SimpleVector
│            (Core._apply)(Core.apply_type, %186, %187)::Type{Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}}
│     %189 = (Base.getfield)(typeof(iterate), :name)::TypeName
│     %190 = (Base.getfield)(%189, :mt)::Any
│     %191 = $(Expr(:foreigncall, :(:jl_method_exists), Int32, svec(Any, Any, UInt64), :(:ccall), 3, :(%190), Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, 0xffffffffffffffff, 0xffffffffffffffff))::Int32
│     %192 = (Core.sext_int)(Core.Int64, %191)::Int64
│     %193 = (%192 === 0)::Bool
│     %194 = (Base.not_int)(%193)::Bool
└────        goto #74
74 ┄─ %196 = φ (#72 => %183, #73 => %194)::Bool
└────        goto #142 if not %196
75 ── %198 = (Core.tuple)(Base.Tuple, typeof(iterate))::Tuple{DataType,DataType}
│     %199 = (Base.getfield)(Tuple{EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, :parameters)::SimpleVector
│            (Core._apply)(Core.apply_type, %198, %199)::Type{Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}}
│     %201 = (Base.getfield)(typeof(iterate), :name)::TypeName
│     %202 = (Base.getfield)(%201, :mt)::Any
│     %203 = $(Expr(:foreigncall, :(:jl_method_exists), Int32, svec(Any, Any, UInt64), :(:ccall), 3, :(%202), Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, 0xffffffffffffffff, 0xffffffffffffffff))::Int32
│     %204 = (Core.sext_int)(Core.Int64, %203)::Int64
│     %205 = (%204 === 0)::Bool
│     %206 = (Base.not_int)(%205)::Bool
│     %207 = (Base.not_int)(%206)::Bool
└────        goto #77 if not %207
76 ──        invoke IteratorInterfaceExtensions.error("Can't get iterator for non iterable source."::String)::Union{}
└────        $(Expr(:unreachable))::Union{}
77 ┄─        goto #78
78 ──        (NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}} <: Tables.NamedTuple)::Bool
└────        goto #92 if not true
79 ┄─ %214 = φ (#78 => (Base.IsInfinite(), 2), #91 => %240)::Union{Nothing, Tuple{Union{IsInfinite, SizeUnknown},Int64}}
│     %215 = π (%214, Union{Tuple{IsInfinite,Int64}, Tuple{SizeUnknown,Int64}})
│     %216 = (Core.getfield)(%215, 1)::Union{IsInfinite, SizeUnknown}
│     %217 = (Core.getfield)(%215, 2)::Int64
│     %218 = (isa)(%216, IsInfinite)::Bool
└────        goto #81 if not %218
80 ──        goto #84
81 ── %221 = (isa)(%216, SizeUnknown)::Bool
└────        goto #83 if not %221
82 ──        goto #84
83 ──        (Core.throw)(ErrorException("fatal error in type inference (type bound)"))::Union{}
└────        $(Expr(:unreachable))::Union{}
84 ┄─ %226 = (Base.sle_int)(1, %217)::Bool
└────        goto #86 if not %226
85 ── %228 = (Base.sle_int)(%217, 2)::Bool
└────        goto #87
86 ──        nothing::Nothing
87 ┄─ %231 = φ (#85 => %228, #86 => false)::Bool
└────        goto #89 if not %231
88 ── %233 = (Base.getfield)((IsInfinite(), SizeUnknown()), %217, false)::Union{IsInfinite, SizeUnknown}
│     %234 = (Base.add_int)(%217, 1)::Int64
│     %235 = (Core.tuple)(%233, %234)::Tuple{Union{IsInfinite, SizeUnknown},Int64}
└────        goto #90
89 ── %237 = Base.nothing::Nothing
└────        goto #90
90 ┄─ %239 = φ (#88 => false, #89 => true)::Bool
│     %240 = φ (#88 => %235, #89 => %237)::Union{Nothing, Tuple{Union{IsInfinite, SizeUnknown},Int64}}
│     %241 = (Base.not_int)(%239)::Bool
└────        goto #92 if not %241
91 ──        goto #79
92 ┄─        goto #93
93 ──        goto #94
94 ──        goto #95
95 ── %247 = (Base.getfield)(x, :source)::EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}}
│     %248 = (Base.getfield)(%247, :source)::DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}
│     %249 = (Base.getfield)(%248, :x)::RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}
│     %250 = (Base.getfield)(%249, :len)::Int64
│     %251 = $(Expr(:foreigncall, :(:jl_alloc_array_1d), Array{Float64,1}, svec(Any, Int64), :(:ccall), 2, Array{Float64,1}, :(%250), :(%250)))::Array{Float64,1}
│     %252 = $(Expr(:foreigncall, :(:jl_alloc_array_1d), Array{Float64,1}, svec(Any, Int64), :(:ccall), 2, Array{Float64,1}, :(%250), :(%250)))::Array{Float64,1}
│     %253 = $(Expr(:foreigncall, :(:jl_alloc_array_1d), Array{Float64,1}, svec(Any, Int64), :(:ccall), 2, Array{Float64,1}, :(%250), :(%250)))::Array{Float64,1}
│     %254 = %new(NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}, %251, %252, %253)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
│     %255 = (Base.getfield)(x, :source)::EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}}
│     %256 = (Base.getfield)(%255, :source)::DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}
│     %257 = (Base.getfield)(%256, :x)::RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}
│     %258 = (Base.getfield)(%257, :len)::Int64
│     %259 = (Base.slt_int)(%258, 1)::Bool
└────        goto #97 if not %259
96 ──        goto #98
97 ── %262 = (Base.getfield)(%257, :columns)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
└────        goto #98
98 ┄─ %264 = φ (#96 => true, #97 => false)::Bool
│     %265 = φ (#97 => 2)::Int64
│     %266 = φ (#97 => %262)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
│     %267 = φ (#97 => 1)::Int64
│     %268 = φ (#97 => %262)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
│     %269 = φ (#97 => 1)::Int64
│     %270 = φ (#97 => %262)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
│     %271 = φ (#97 => 1)::Int64
└────        goto #99
99 ──        goto #101 if not %264
100 ─        goto #102
101 ─ %275 = (getfield)(%266, :a)::Array{Float64,1}
│     %276 = (Base.arrayref)(true, %275, %267)::Float64
│     %277 = (getfield)(%268, :b)::Array{Float64,1}
│     %278 = (Base.arrayref)(true, %277, %269)::Float64
│     %279 = (getfield)(%270, :c)::Array{Float64,1}
│     %280 = (Base.arrayref)(true, %279, %271)::Float64
│     %281 = %new(NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}, %276, %278, %280)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
└────        goto #102
102 ┄ %283 = φ (#100 => true, #101 => false)::Bool
│     %284 = φ (#101 => %281)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
│     %285 = φ (#101 => %265)::Int64
└────        goto #103
103 ─        goto #104
104 ─        goto #106 if not %283
105 ─        goto #107
106 ─        goto #107
107 ┄ %291 = φ (#105 => true, #106 => false)::Bool
│     %292 = φ (#106 => %284)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
│     %293 = φ (#106 => %285)::Int64
└────        goto #109 if not %291
108 ─        goto #110
109 ─        invoke Base.fieldcount(NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}::Any)::Any
│     %297 = (Base.getfield)(NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}, :parameters)::SimpleVector
│            invoke Base.getindex(%297::Core.SimpleVector, 1::Int64)::Tuple{Symbol,Symbol,Symbol}
│     %299 = (Base.getfield)(NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}, :parameters)::SimpleVector
│            invoke Base.getindex(%299::Core.SimpleVector, 1::Int64)::Tuple{Symbol,Symbol,Symbol}
└────        goto #110
110 ┄ %302 = φ (#108 => true, #109 => false)::Bool
│     %303 = φ (#109 => %292)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
│     %304 = φ (#109 => %293)::Int64
│     %305 = φ (#108 => true)::Bool
└────        goto #112 if not %302
111 ─        goto #113
112 ─        goto #113
113 ┄ %309 = φ (#111 => %305, #112 => false)::Bool
│     %310 = φ (#112 => 1)::Int64
│     %311 = φ (#112 => %303)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
│     %312 = φ (#112 => 2)::Int64
│     %313 = φ (#112 => %304)::Int64
└────        goto #114
114 ─ %315 = (Base.not_int)(%309)::Bool
└────        goto #140 if not %315
115 ┄ %317 = φ (#114 => %310, #139 => %391)::Int64
│     %318 = φ (#114 => %311, #139 => %392)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
│     %319 = φ (#114 => %312, #139 => %393)::Int64
│     %320 = φ (#114 => %313, #139 => %394)::Int64
└────        goto #121 if not true
116 ┄ %322 = φ (#115 => 0, #120 => %335)::Int64
│     %323 = φ (#115 => 0, #120 => %336)::Int64
│     %324 = (Base.add_int)(1, %322)::Int64
│     %325 = (Base.getfield)((:a, :b, :c), %324, false)::Symbol
│     %326 = (getfield)(%318, %325)::Float64
│     %327 = (Base.add_int)(1, %322)::Int64
│     %328 = (Base.getfield)(%254, %327)::Array{Float64,1}
│            (Base.arrayset)(true, %328, %326, %317)::Array{Float64,1}
│     %330 = (%323 === 2)::Bool
└────        goto #118 if not %330
117 ─        goto #119
118 ─ %333 = (Base.add_int)(%323, 1)::Int64
└────        goto #119
119 ┄ %335 = φ (#118 => %333)::Int64
│     %336 = φ (#118 => %333)::Int64
│     %337 = φ (#117 => true, #118 => false)::Bool
│     %338 = (Base.not_int)(%337)::Bool
└────        goto #121 if not %338
120 ─        goto #116
121 ┄        goto #122
122 ─ %342 = (Base.getfield)(x, :source)::EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}}
│     %343 = (Base.getfield)(%342, :source)::DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}
│     %344 = (Base.getfield)(%343, :x)::RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}
│     %345 = (Base.getfield)(%344, :len)::Int64
│     %346 = (Base.slt_int)(%345, %320)::Bool
└────        goto #124 if not %346
123 ─        goto #125
124 ─ %349 = (Base.getfield)(%344, :columns)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
│     %350 = (Base.add_int)(%320, 1)::Int64
└────        goto #125
125 ┄ %352 = φ (#123 => true, #124 => false)::Bool
│     %353 = φ (#124 => %350)::Int64
│     %354 = φ (#124 => %349)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
│     %355 = φ (#124 => %320)::Int64
│     %356 = φ (#124 => %349)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
│     %357 = φ (#124 => %320)::Int64
│     %358 = φ (#124 => %349)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
│     %359 = φ (#124 => %320)::Int64
└────        goto #127 if not %352
126 ─        goto #128
127 ─ %362 = (getfield)(%354, :a)::Array{Float64,1}
│     %363 = (Base.arrayref)(true, %362, %355)::Float64
│     %364 = (getfield)(%356, :b)::Array{Float64,1}
│     %365 = (Base.arrayref)(true, %364, %357)::Float64
│     %366 = (getfield)(%358, :c)::Array{Float64,1}
│     %367 = (Base.arrayref)(true, %366, %359)::Float64
│     %368 = %new(NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}, %363, %365, %367)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
└────        goto #128
128 ┄ %370 = φ (#126 => true, #127 => false)::Bool
│     %371 = φ (#127 => %368)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
│     %372 = φ (#127 => %353)::Int64
└────        goto #129
129 ─        goto #131 if not %370
130 ─        goto #132
131 ─        goto #132
132 ┄ %377 = φ (#130 => true, #131 => false)::Bool
│     %378 = φ (#131 => %371)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
│     %379 = φ (#131 => %372)::Int64
└────        goto #134 if not %377
133 ─        goto #135
134 ─        goto #135
135 ┄ %383 = φ (#133 => true, #134 => false)::Bool
│     %384 = φ (#134 => %378)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
│     %385 = φ (#134 => %379)::Int64
│     %386 = φ (#133 => true)::Bool
└────        goto #137 if not %383
136 ─        goto #138
137 ─ %389 = (Base.add_int)(%319, 1)::Int64
└────        goto #138
138 ┄ %391 = φ (#137 => %319)::Int64
│     %392 = φ (#137 => %384)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
│     %393 = φ (#137 => %389)::Int64
│     %394 = φ (#137 => %385)::Int64
│     %395 = φ (#136 => %386, #137 => false)::Bool
│     %396 = (Base.not_int)(%395)::Bool
└────        goto #140 if not %396
139 ─        goto #115
140 ┄        goto #141
141 ─        goto #143
142 ─ %401 = invoke Base.print_to_string("no default `Tables.columns` implementation for type: "::String, QueryOperators.EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},QueryOperators.EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},Tables.DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},Tables.RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},getfield(Main, Symbol("##4#6"))}::Vararg{Any,N} where N)::String
│     %402 = %new(Core.ArgumentError, %401)::ArgumentError
│            (Tables.throw)(%402)::Union{}
└────        $(Expr(:unreachable))::Union{}
143 ┄ %405 = invoke DataFrames.fromcolumns(%254::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}})::DataFrame
└────        return %405
144 ─ %407 = invoke Base.print_to_string("unable to construct DataFrame from "::String, QueryOperators.EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},QueryOperators.EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},Tables.DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},Tables.RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},getfield(Main, Symbol("##4#6"))}::Vararg{Any,N} where N)::String
│     %408 = %new(Core.ArgumentError, %407)::ArgumentError
│            (DataFrames.throw)(%408)::Union{}
└────        $(Expr(:unreachable))::Union{}
) => DataFrame

julia>