**** New definitions: r8s, type: r8*
**** New definitions: r4s, type: r4*
**** New definitions: i8s, type: i8*
**** New definitions: i4s, type: i4*
**** New definitions: i2s, type: i2*
**** New definitions: i1s, type: i1*
**** New definitions: u8s, type: u8*
**** New definitions: u4s, type: u4*
**** New definitions: u2s, type: u2*
**** New definitions: u1s, type: u1*
**** New definitions: bs, type: b*
**** New definitions: bis, type: i*
**** New definitions: r8n, type: r8*
**** New definitions: r4n, type: r4*
**** New definitions: i8n, type: i8*
**** New definitions: i4n, type: i4*
**** New definitions: i2n, type: i2*
**** New definitions: i1n, type: i1*
**** New definitions: u8n, type: u8*
**** New definitions: u4n, type: u4*
**** New definitions: u2n, type: u2*
**** New definitions: u1n, type: u1*
**** New definitions: bn, type: b*
**** New definitions: bin, type: i*
**** New definitions: qr8s, type: r8?*
**** New definitions: qr4s, type: r4?*
**** New definitions: qi8s, type: i8?*
**** New definitions: qi4s, type: i4?*
**** New definitions: qi2s, type: i2?*
**** New definitions: qi1s, type: i1?*
**** New definitions: qu8s, type: u8?*
**** New definitions: qu4s, type: u4?*
**** New definitions: qu2s, type: u2?*
**** New definitions: qu1s, type: u1?*
**** New definitions: qbs, type: b?*
**** New definitions: qbis, type: i?*
**** New definitions: or8s, type: r8?*
**** New definitions: or4s, type: r4?*
**** New definitions: oi8s, type: i8?*
**** New definitions: oi4s, type: i4?*
**** New definitions: oi2s, type: i2?*
**** New definitions: oi1s, type: i1?*
**** New definitions: ou8s, type: u8?*
**** New definitions: ou4s, type: u4?*
**** New definitions: ou2s, type: u2?*
**** New definitions: ou1s, type: u1?*
**** New definitions: obs, type: b?*
**** New definitions: obis, type: i?*
**** New definitions: qr8n, type: r8?*
**** New definitions: qr4n, type: r4?*
**** New definitions: qi8n, type: i8?*
**** New definitions: qi4n, type: i4?*
**** New definitions: qi2n, type: i2?*
**** New definitions: qi1n, type: i1?*
**** New definitions: qu8n, type: u8?*
**** New definitions: qu4n, type: u4?*
**** New definitions: qu2n, type: u2?*
**** New definitions: qu1n, type: u1?*
**** New definitions: qbn, type: b?*
**** New definitions: qbin, type: i?*

> r8s->Sum()
r8s->Sum() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Global(r8s)):r8))
// (<ctx>, ∂.r8s:r8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(r8s)
###
> r4s->Sum()
r4s->Sum() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Global(r4s)):r8))
// (<ctx>, ∂.r4s:r4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<r4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(r4s)
###
> i8s->Sum()
i8s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(i8s)):i8))
// (<ctx>, ∂.i8s:i8*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i8s:i8*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(i8s)
###
> i4s->Sum()
i4s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(i4s)):i8))
// (<ctx>, ∂.i4s:i4*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<i4>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i4s:i4*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(i4s)
###
> i2s->Sum()
i2s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(i2s)):i8))
// (<ctx>, ∂.i2s:i2*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.1 [Seq<i2>]
      1) ldloc.1 [Seq<i2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<i2>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i2s:i2*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(i2s)
###
> i1s->Sum()
i1s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(i1s)):i8))
// (<ctx>, ∂.i1s:i1*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i1>
      1) stloc.1 [Seq<i1>]
      1) ldloc.1 [Seq<i1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<i1>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i1s:i1*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(i1s)
###
> u8s->Sum()
u8s->Sum() : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum(Global(u8s)):u8))
// (<ctx>, ∂.u8s:u8*) : u8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<u8>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u8s:u8*) to u8
Type: u8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(u8s)
###
> u4s->Sum()
u4s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(u4s)):i8))
// (<ctx>, ∂.u4s:u4*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<u4>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u4s:u4*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(u4s)
###
> u2s->Sum()
u2s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(u2s)):i8))
// (<ctx>, ∂.u2s:u2*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.1 [Seq<u2>]
      1) ldloc.1 [Seq<u2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<u2>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u2s:u2*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(u2s)
###
> u1s->Sum()
u1s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(u1s)):i8))
// (<ctx>, ∂.u1s:u1*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u1>
      1) stloc.1 [Seq<u1>]
      1) ldloc.1 [Seq<u1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<u1>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u1s:u1*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(u1s)
###
> bs->Sum()
bs->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(bs)):i8))
// (<ctx>, ∂.bs:b*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<bool>
      1) stloc.1 [Seq<bool>]
      1) ldloc.1 [Seq<bool>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<bool>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bs:b*) to i8
Type: i8, Value: 5
*** Ctx ping count: 11
    [0](11): Sum(bs)
###
> bis->Sum()
bis->Sum() : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum(Global(bis)):i))
// (<ctx>, ∂.bis:i*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bis:i*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(bis)
###
> r8s->SumBig()
r8s->SumBig() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig(Global(r8s)):r8))
// (<ctx>, ∂.r8s:r8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(r8s)
###
> r4s->SumBig()
r4s->SumBig() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig(Global(r4s)):r8))
// (<ctx>, ∂.r4s:r4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<r4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(r4s)
###
> i8s->SumBig()
i8s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(i8s)):i))
// (<ctx>, ∂.i8s:i8*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<i8>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i8s:i8*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(i8s)
###
> i4s->SumBig()
i4s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(i4s)):i))
// (<ctx>, ∂.i4s:i4*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<i4>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i4s:i4*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(i4s)
###
> i2s->SumBig()
i2s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(i2s)):i))
// (<ctx>, ∂.i2s:i2*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.1 [Seq<i2>]
      1) ldloc.1 [Seq<i2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<i2>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i2s:i2*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(i2s)
###
> i1s->SumBig()
i1s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(i1s)):i))
// (<ctx>, ∂.i1s:i1*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i1>
      1) stloc.1 [Seq<i1>]
      1) ldloc.1 [Seq<i1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<i1>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i1s:i1*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(i1s)
###
> u8s->SumBig()
u8s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(u8s)):i))
// (<ctx>, ∂.u8s:u8*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<u8>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u8s:u8*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(u8s)
###
> u4s->SumBig()
u4s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(u4s)):i))
// (<ctx>, ∂.u4s:u4*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<u4>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u4s:u4*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(u4s)
###
> u2s->SumBig()
u2s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(u2s)):i))
// (<ctx>, ∂.u2s:u2*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.1 [Seq<u2>]
      1) ldloc.1 [Seq<u2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<u2>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u2s:u2*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(u2s)
###
> u1s->SumBig()
u1s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(u1s)):i))
// (<ctx>, ∂.u1s:u1*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u1>
      1) stloc.1 [Seq<u1>]
      1) ldloc.1 [Seq<u1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<u1>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u1s:u1*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(u1s)
###
> bs->SumBig()
bs->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(bs)):i))
// (<ctx>, ∂.bs:b*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<bool>
      1) stloc.1 [Seq<bool>]
      1) ldloc.1 [Seq<bool>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<bool>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bs:b*) to i
Type: ia, Value: 5
*** Ctx ping count: 11
    [0](11): SumBig(bs)
###
> bis->SumBig()
bis->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(bis)):i))
// (<ctx>, ∂.bis:i*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bis:i*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(bis)
###
> r8s->SumK()
r8s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(r8s)):r8))
// (<ctx>, ∂.r8s:r8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(r8s)
###
> r4s->SumK()
r4s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(r4s)):r8))
// (<ctx>, ∂.r4s:r4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<r4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(r4s)
###
> i8s->SumK()
i8s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(i8s)):r8))
// (<ctx>, ∂.i8s:i8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<i8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i8s:i8*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(i8s)
###
> i4s->SumK()
i4s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(i4s)):r8))
// (<ctx>, ∂.i4s:i4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<i4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i4s:i4*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(i4s)
###
> i2s->SumK()
i2s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(i2s)):r8))
// (<ctx>, ∂.i2s:i2*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.1 [Seq<i2>]
      1) ldloc.1 [Seq<i2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<i2>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i2s:i2*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(i2s)
###
> i1s->SumK()
i1s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(i1s)):r8))
// (<ctx>, ∂.i1s:i1*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i1>
      1) stloc.1 [Seq<i1>]
      1) ldloc.1 [Seq<i1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<i1>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i1s:i1*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(i1s)
###
> u8s->SumK()
u8s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(u8s)):r8))
// (<ctx>, ∂.u8s:u8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<u8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u8s:u8*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(u8s)
###
> u4s->SumK()
u4s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(u4s)):r8))
// (<ctx>, ∂.u4s:u4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<u4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u4s:u4*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(u4s)
###
> u2s->SumK()
u2s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(u2s)):r8))
// (<ctx>, ∂.u2s:u2*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.1 [Seq<u2>]
      1) ldloc.1 [Seq<u2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<u2>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u2s:u2*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(u2s)
###
> u1s->SumK()
u1s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(u1s)):r8))
// (<ctx>, ∂.u1s:u1*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u1>
      1) stloc.1 [Seq<u1>]
      1) ldloc.1 [Seq<u1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<u1>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u1s:u1*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(u1s)
###
> bs->SumK()
bs->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(bs)):r8))
// (<ctx>, ∂.bs:b*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<bool>
      1) stloc.1 [Seq<bool>]
      1) ldloc.1 [Seq<bool>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<bool>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bs:b*) to r8
Type: r8, Value: 5
*** Ctx ping count: 11
    [0](11): SumK(bs)
###
> bis->SumK()
bis->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(bis)):r8))
// (<ctx>, ∂.bis:i*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<ia>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bis:i*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(bis)
###
> r8s->Mean()
r8s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(r8s)):r8))
// (<ctx>, ∂.r8s:r8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(r8s)
###
> r4s->Mean()
r4s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(r4s)):r8))
// (<ctx>, ∂.r4s:r4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<r4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(r4s)
###
> i8s->Mean()
i8s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(i8s)):r8))
// (<ctx>, ∂.i8s:i8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i8s:i8*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(i8s)
###
> i4s->Mean()
i4s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(i4s)):r8))
// (<ctx>, ∂.i4s:i4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i4s:i4*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(i4s)
###
> i2s->Mean()
i2s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(i2s)):r8))
// (<ctx>, ∂.i2s:i2*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.1 [Seq<i2>]
      1) ldloc.1 [Seq<i2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i2>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i2s:i2*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(i2s)
###
> i1s->Mean()
i1s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(i1s)):r8))
// (<ctx>, ∂.i1s:i1*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i1>
      1) stloc.1 [Seq<i1>]
      1) ldloc.1 [Seq<i1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i1>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i1s:i1*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(i1s)
###
> u8s->Mean()
u8s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(u8s)):r8))
// (<ctx>, ∂.u8s:u8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u8s:u8*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(u8s)
###
> u4s->Mean()
u4s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(u4s)):r8))
// (<ctx>, ∂.u4s:u4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u4s:u4*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(u4s)
###
> u2s->Mean()
u2s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(u2s)):r8))
// (<ctx>, ∂.u2s:u2*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.1 [Seq<u2>]
      1) ldloc.1 [Seq<u2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u2>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u2s:u2*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(u2s)
###
> u1s->Mean()
u1s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(u1s)):r8))
// (<ctx>, ∂.u1s:u1*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u1>
      1) stloc.1 [Seq<u1>]
      1) ldloc.1 [Seq<u1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u1>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u1s:u1*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(u1s)
###
> bs->Mean()
bs->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(bs)):r8))
// (<ctx>, ∂.bs:b*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<bool>
      1) stloc.1 [Seq<bool>]
      1) ldloc.1 [Seq<bool>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<bool>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bs:b*) to r8
Type: r8, Value: 0.5
*** Ctx ping count: 11
    [0](11): Mean(bs)
###
> bis->Mean()
bis->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(bis)):r8))
// (<ctx>, ∂.bis:i*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<ia>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bis:i*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(bis)
###
> r8s->Sum(it * it)
r8s->Sum(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum([map:1] Global(r8s), Mul(Scope(1), Scope(1))):r8))
// (<ctx>, ∂.r8s:r8*) : r8
Sum_1(Arr<obj>, r8):r8
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<r8>, Func<r8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*1: r8s, Mul(*1, *1))
###
> r4s->Sum(it * it)
r4s->Sum(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum([map:1] Global(r4s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1)))):r8))
// (<ctx>, ∂.r4s:r4*) : r8
Sum_1(Arr<obj>, r4):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<r4>, Func<r4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*1: r4s, Mul(Num<r8>(*1), Num<r8>(*1)))
###
> i8s->Sum(it * it)
i8s->Sum(it * it) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(i8s), Mul(Scope(1), Scope(1))):i8))
// (<ctx>, ∂.i8s:i8*) : i8
Sum_1(Arr<obj>, i8):i8
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<i8>, Func<i8,i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*1: i8s, Mul(*1, *1))
###
> i4s->Sum(it * it)
i4s->Sum(it * it) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(i4s), Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))):i8))
// (<ctx>, ∂.i4s:i4*) : i8
Sum_1(Arr<obj>, i4):i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<i4>, Func<i4,i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*1: i4s, Mul(Num<i8>(*1), Num<i8>(*1)))
###
> u8s->Sum(it * it)
u8s->Sum(it * it) : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum([map:1] Global(u8s), Mul(Scope(1), Scope(1))):u8))
// (<ctx>, ∂.u8s:u8*) : u8
Sum_1(Arr<obj>, u8):u8
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<u8>, Func<u8,u8>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to u8
Type: u8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*1: u8s, Mul(*1, *1))
###
> u4s->Sum(it * it)
u4s->Sum(it * it) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(u4s), Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))):i8))
// (<ctx>, ∂.u4s:u4*) : i8
Sum_1(Arr<obj>, u4):i8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<u4>, Func<u4,i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*1: u4s, Mul(Num<i8>(*1), Num<i8>(*1)))
###
> bis->Sum(it * it)
bis->Sum(it * it) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum([map:1] Global(bis), Mul(Scope(1), Scope(1))):i))
// (<ctx>, ∂.bis:i*) : i
Sum_1(Arr<obj>, ia):ia
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      1) ret
  Total Size: 8

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<ia>, Func<ia,ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*1: bis, Mul(*1, *1))
###
> r8s->SumBig(it * it)
r8s->SumBig(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig([map:1] Global(r8s), Mul(Scope(1), Scope(1))):r8))
// (<ctx>, ∂.r8s:r8*) : r8
SumBig_1(Arr<obj>, r8):r8
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<r8>, Func<r8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*1: r8s, Mul(*1, *1))
###
> r4s->SumBig(it * it)
r4s->SumBig(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig([map:1] Global(r4s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1)))):r8))
// (<ctx>, ∂.r4s:r4*) : r8
SumBig_1(Arr<obj>, r4):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<r4>, Func<r4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*1: r4s, Mul(Num<r8>(*1), Num<r8>(*1)))
###
> i8s->SumBig(it * it)
i8s->SumBig(it * it) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:1] Global(i8s), Num<i>(Mul(Scope(1), Scope(1)))):i))
// (<ctx>, ∂.i8s:i8*) : i
SumBig_1(Arr<obj>, i8):ia
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<i8>, Func<i8,ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*1: i8s, Num<i>(Mul(*1, *1)))
###
> i4s->SumBig(it * it)
i4s->SumBig(it * it) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:1] Global(i4s), Num<i>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1))))):i))
// (<ctx>, ∂.i4s:i4*) : i
SumBig_1(Arr<obj>, i4):ia
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<i4>, Func<i4,ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*1: i4s, Num<i>(Mul(Num<i8>(*1), Num<i8>(*1))))
###
> u8s->SumBig(it * it)
u8s->SumBig(it * it) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:1] Global(u8s), Num<i>(Mul(Scope(1), Scope(1)))):i))
// (<ctx>, ∂.u8s:u8*) : i
SumBig_1(Arr<obj>, u8):ia
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      5) newobj ia(u8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<u8>, Func<u8,ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*1: u8s, Num<i>(Mul(*1, *1)))
###
> u4s->SumBig(it * it)
u4s->SumBig(it * it) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:1] Global(u4s), Num<i>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1))))):i))
// (<ctx>, ∂.u4s:u4*) : i
SumBig_1(Arr<obj>, u4):ia
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<u4>, Func<u4,ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*1: u4s, Num<i>(Mul(Num<i8>(*1), Num<i8>(*1))))
###
> bis->SumBig(it * it)
bis->SumBig(it * it) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:1] Global(bis), Mul(Scope(1), Scope(1))):i))
// (<ctx>, ∂.bis:i*) : i
SumBig_1(Arr<obj>, ia):ia
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      1) ret
  Total Size: 8

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<ia>, Func<ia,ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*1: bis, Mul(*1, *1))
###
> r8s->SumK(it * it)
r8s->SumK(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:1] Global(r8s), Mul(Scope(1), Scope(1))):r8))
// (<ctx>, ∂.r8s:r8*) : r8
SumK_1(Arr<obj>, r8):r8
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<r8>, Func<r8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*1: r8s, Mul(*1, *1))
###
> r4s->SumK(it * it)
r4s->SumK(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:1] Global(r4s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1)))):r8))
// (<ctx>, ∂.r4s:r4*) : r8
SumK_1(Arr<obj>, r4):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<r4>, Func<r4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*1: r4s, Mul(Num<r8>(*1), Num<r8>(*1)))
###
> i8s->SumK(it * it)
i8s->SumK(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:1] Global(i8s), Num<r8>(Mul(Scope(1), Scope(1)))):r8))
// (<ctx>, ∂.i8s:i8*) : r8
SumK_1(Arr<obj>, i8):r8
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<i8>, Func<i8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*1: i8s, Num<r8>(Mul(*1, *1)))
###
> i4s->SumK(it * it)
i4s->SumK(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:1] Global(i4s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1))))):r8))
// (<ctx>, ∂.i4s:i4*) : r8
SumK_1(Arr<obj>, i4):r8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<i4>, Func<i4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*1: i4s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*1))))
###
> u8s->SumK(it * it)
u8s->SumK(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:1] Global(u8s), Num<r8>(Mul(Scope(1), Scope(1)))):r8))
// (<ctx>, ∂.u8s:u8*) : r8
SumK_1(Arr<obj>, u8):r8
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<u8>, Func<u8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*1: u8s, Num<r8>(Mul(*1, *1)))
###
> u4s->SumK(it * it)
u4s->SumK(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:1] Global(u4s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1))))):r8))
// (<ctx>, ∂.u4s:u4*) : r8
SumK_1(Arr<obj>, u4):r8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<u4>, Func<u4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*1: u4s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*1))))
###
> bis->SumK(it * it)
bis->SumK(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:1] Global(bis), Num<r8>(Mul(Scope(1), Scope(1)))):r8))
// (<ctx>, ∂.bis:i*) : r8
SumK_1(Arr<obj>, ia):r8
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<ia>, Func<ia,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*1: bis, Num<r8>(Mul(*1, *1)))
###
> r8s->Mean(it * it)
r8s->Mean(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(r8s), Mul(Scope(1), Scope(1))):r8))
// (<ctx>, ∂.r8s:r8*) : r8
Mean_1(Arr<obj>, r8):r8
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, Func<r8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*1: r8s, Mul(*1, *1))
###
> r4s->Mean(it * it)
r4s->Mean(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(r4s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1)))):r8))
// (<ctx>, ∂.r4s:r4*) : r8
Mean_1(Arr<obj>, r4):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<r4>, Func<r4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*1: r4s, Mul(Num<r8>(*1), Num<r8>(*1)))
###
> i8s->Mean(it * it)
i8s->Mean(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(i8s), Num<r8>(Mul(Scope(1), Scope(1)))):r8))
// (<ctx>, ∂.i8s:i8*) : r8
Mean_1(Arr<obj>, i8):r8
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i8>, Func<i8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*1: i8s, Num<r8>(Mul(*1, *1)))
###
> i4s->Mean(it * it)
i4s->Mean(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(i4s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1))))):r8))
// (<ctx>, ∂.i4s:i4*) : r8
Mean_1(Arr<obj>, i4):r8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i4>, Func<i4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*1: i4s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*1))))
###
> u8s->Mean(it * it)
u8s->Mean(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(u8s), Num<r8>(Mul(Scope(1), Scope(1)))):r8))
// (<ctx>, ∂.u8s:u8*) : r8
Mean_1(Arr<obj>, u8):r8
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u8>, Func<u8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*1: u8s, Num<r8>(Mul(*1, *1)))
###
> u4s->Mean(it * it)
u4s->Mean(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(u4s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1))))):r8))
// (<ctx>, ∂.u4s:u4*) : r8
Mean_1(Arr<obj>, u4):r8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u4>, Func<u4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*1: u4s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*1))))
###
> bis->Mean(it * it)
bis->Mean(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(bis), Num<r8>(Mul(Scope(1), Scope(1)))):r8))
// (<ctx>, ∂.bis:i*) : r8
Mean_1(Arr<obj>, ia):r8
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<ia>, Func<ia,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*1: bis, Num<r8>(Mul(*1, *1)))
###
> r8s->Sum(it * #it)
r8s->Sum(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum([map:2] Global(r8s), Mul(Scope(2), Num<r8>(Scope(1)))):r8))
// (<ctx>, ∂.r8s:r8*) : r8
Sum_1(Arr<obj>, i8, r8):r8
      1) ldarg.2 [r8]
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<r8>, Func<i8,r8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*2: r8s, Mul(*2, Num<r8>(#1)))
###
> r4s->Sum(it * #it)
r4s->Sum(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum([map:2] Global(r4s), Mul(Num<r8>(Scope(2)), Num<r8>(Scope(1)))):r8))
// (<ctx>, ∂.r4s:r4*) : r8
Sum_1(Arr<obj>, i8, r4):r8
      1) ldarg.2 [r4]
      1) conv.r8
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<r4>, Func<i8,r4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*2: r4s, Mul(Num<r8>(*2), Num<r8>(#1)))
###
> i8s->Sum(it * #it)
i8s->Sum(it * #it) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:2] Global(i8s), Mul(Scope(2), Scope(1))):i8))
// (<ctx>, ∂.i8s:i8*) : i8
Sum_1(Arr<obj>, i8, i8):i8
      1) ldarg.2 [i8]
      1) ldarg.1 [i8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i8,i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<i8>, Func<i8,i8,i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*2: i8s, Mul(*2, #1))
###
> i4s->Sum(it * #it)
i4s->Sum(it * #it) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:2] Global(i4s), Mul(Num<i8>(Scope(2)), Scope(1))):i8))
// (<ctx>, ∂.i4s:i4*) : i8
Sum_1(Arr<obj>, i8, i4):i8
      1) ldarg.2 [i4]
      1) conv.i8
      1) ldarg.1 [i8]
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i4,i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<i4>, Func<i8,i4,i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*2: i4s, Mul(Num<i8>(*2), #1))
###
> u8s->Sum(it * #it)
u8s->Sum(it * #it) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:2] Global(u8s), Mul(Num<i8>(Scope(2)), Scope(1))):i8))
*** Warning: (9,11) Node: it, Message: Conversion from unsigned to signed integer can reinterpret large values as negative
// (<ctx>, ∂.u8s:u8*) : i8
Sum_1(Arr<obj>, i8, u8):i8
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<u8>, Func<i8,u8,i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*2: u8s, Mul(Num<i8>(*2), #1))
###
> u8s->Sum(it * #it->CastU8())
u8s->Sum(it * #it->CastU8()) : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum([map:2] Global(u8s), Mul(Scope(2), Call(∂.CastU8(Scope(1)):u8))):u8))
// (<ctx>, ∂.u8s:u8*) : u8
Sum_1(Arr<obj>, i8, u8):u8
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<u8>, Func<i8,u8,u8>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to u8
Type: u8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*2: u8s, Mul(*2, CastU8(#1)))
###
> u4s->Sum(it * #it)
u4s->Sum(it * #it) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:2] Global(u4s), Mul(Num<i8>(Scope(2)), Scope(1))):i8))
// (<ctx>, ∂.u4s:u4*) : i8
Sum_1(Arr<obj>, i8, u4):i8
      1) ldarg.2 [u4]
      1) conv.u8
      1) ldarg.1 [i8]
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u4,i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<u4>, Func<i8,u4,i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*2: u4s, Mul(Num<i8>(*2), #1))
###
> bis->Sum(it * #it)
bis->Sum(it * #it) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum([map:2] Global(bis), Mul(Scope(2), Num<i>(Scope(1)))):i))
// (<ctx>, ∂.bis:i*) : i
Sum_1(Arr<obj>, i8, ia):ia
      1) ldarg.2 [ia]
      1) ldarg.1 [i8]
      5) newobj ia(i8)
      5) call static ia::op_Multiply(ia, ia):ia
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,ia,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<ia>, Func<i8,ia,ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*2: bis, Mul(*2, Num<i>(#1)))
###
> r8s->SumBig(it * #it)
r8s->SumBig(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig([map:2] Global(r8s), Mul(Scope(2), Num<r8>(Scope(1)))):r8))
// (<ctx>, ∂.r8s:r8*) : r8
SumBig_1(Arr<obj>, i8, r8):r8
      1) ldarg.2 [r8]
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<r8>, Func<i8,r8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*2: r8s, Mul(*2, Num<r8>(#1)))
###
> r4s->SumBig(it * #it)
r4s->SumBig(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig([map:2] Global(r4s), Mul(Num<r8>(Scope(2)), Num<r8>(Scope(1)))):r8))
// (<ctx>, ∂.r4s:r4*) : r8
SumBig_1(Arr<obj>, i8, r4):r8
      1) ldarg.2 [r4]
      1) conv.r8
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<r4>, Func<i8,r4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*2: r4s, Mul(Num<r8>(*2), Num<r8>(#1)))
###
> i8s->SumBig(it * #it)
i8s->SumBig(it * #it) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:2] Global(i8s), Num<i>(Mul(Scope(2), Scope(1)))):i))
// (<ctx>, ∂.i8s:i8*) : i
SumBig_1(Arr<obj>, i8, i8):ia
      1) ldarg.2 [i8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i8,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<i8>, Func<i8,i8,ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*2: i8s, Num<i>(Mul(*2, #1)))
###
> i4s->SumBig(it * #it)
i4s->SumBig(it * #it) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:2] Global(i4s), Num<i>(Mul(Num<i8>(Scope(2)), Scope(1)))):i))
// (<ctx>, ∂.i4s:i4*) : i
SumBig_1(Arr<obj>, i8, i4):ia
      1) ldarg.2 [i4]
      1) conv.i8
      1) ldarg.1 [i8]
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i4,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<i4>, Func<i8,i4,ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*2: i4s, Num<i>(Mul(Num<i8>(*2), #1)))
###
> u8s->SumBig(it * #it)
u8s->SumBig(it * #it) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:2] Global(u8s), Num<i>(Mul(Num<i8>(Scope(2)), Scope(1)))):i))
*** Warning: (12,14) Node: it, Message: Conversion from unsigned to signed integer can reinterpret large values as negative
// (<ctx>, ∂.u8s:u8*) : i
SumBig_1(Arr<obj>, i8, u8):ia
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<u8>, Func<i8,u8,ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*2: u8s, Num<i>(Mul(Num<i8>(*2), #1)))
###
> u8s->SumBig(it * #it->CastU8())
u8s->SumBig(it * #it->CastU8()) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:2] Global(u8s), Num<i>(Mul(Scope(2), Call(∂.CastU8(Scope(1)):u8)))):i))
// (<ctx>, ∂.u8s:u8*) : i
SumBig_1(Arr<obj>, i8, u8):ia
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj ia(u8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<u8>, Func<i8,u8,ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*2: u8s, Num<i>(Mul(*2, CastU8(#1))))
###
> u4s->SumBig(it * #it)
u4s->SumBig(it * #it) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:2] Global(u4s), Num<i>(Mul(Num<i8>(Scope(2)), Scope(1)))):i))
// (<ctx>, ∂.u4s:u4*) : i
SumBig_1(Arr<obj>, i8, u4):ia
      1) ldarg.2 [u4]
      1) conv.u8
      1) ldarg.1 [i8]
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u4,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<u4>, Func<i8,u4,ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*2: u4s, Num<i>(Mul(Num<i8>(*2), #1)))
###
> bis->SumBig(it * #it)
bis->SumBig(it * #it) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:2] Global(bis), Mul(Scope(2), Num<i>(Scope(1)))):i))
// (<ctx>, ∂.bis:i*) : i
SumBig_1(Arr<obj>, i8, ia):ia
      1) ldarg.2 [ia]
      1) ldarg.1 [i8]
      5) newobj ia(i8)
      5) call static ia::op_Multiply(ia, ia):ia
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,ia,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<ia>, Func<i8,ia,ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(*2: bis, Mul(*2, Num<i>(#1)))
###
> r8s->SumK(it * #it)
r8s->SumK(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(r8s), Mul(Scope(2), Num<r8>(Scope(1)))):r8))
// (<ctx>, ∂.r8s:r8*) : r8
SumK_1(Arr<obj>, i8, r8):r8
      1) ldarg.2 [r8]
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<r8>, Func<i8,r8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*2: r8s, Mul(*2, Num<r8>(#1)))
###
> r4s->SumK(it * #it)
r4s->SumK(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(r4s), Mul(Num<r8>(Scope(2)), Num<r8>(Scope(1)))):r8))
// (<ctx>, ∂.r4s:r4*) : r8
SumK_1(Arr<obj>, i8, r4):r8
      1) ldarg.2 [r4]
      1) conv.r8
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<r4>, Func<i8,r4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*2: r4s, Mul(Num<r8>(*2), Num<r8>(#1)))
###
> i8s->SumK(it * #it)
i8s->SumK(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(i8s), Num<r8>(Mul(Scope(2), Scope(1)))):r8))
// (<ctx>, ∂.i8s:i8*) : r8
SumK_1(Arr<obj>, i8, i8):r8
      1) ldarg.2 [i8]
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<i8>, Func<i8,i8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*2: i8s, Num<r8>(Mul(*2, #1)))
###
> i4s->SumK(it * #it)
i4s->SumK(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(i4s), Num<r8>(Mul(Num<i8>(Scope(2)), Scope(1)))):r8))
// (<ctx>, ∂.i4s:i4*) : r8
SumK_1(Arr<obj>, i8, i4):r8
      1) ldarg.2 [i4]
      1) conv.i8
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<i4>, Func<i8,i4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*2: i4s, Num<r8>(Mul(Num<i8>(*2), #1)))
###
> u8s->SumK(it * #it)
u8s->SumK(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(u8s), Num<r8>(Mul(Num<i8>(Scope(2)), Scope(1)))):r8))
*** Warning: (10,12) Node: it, Message: Conversion from unsigned to signed integer can reinterpret large values as negative
// (<ctx>, ∂.u8s:u8*) : r8
SumK_1(Arr<obj>, i8, u8):r8
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<u8>, Func<i8,u8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*2: u8s, Num<r8>(Mul(Num<i8>(*2), #1)))
###
> u8s->SumK(it * #it->CastU8())
u8s->SumK(it * #it->CastU8()) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(u8s), Num<r8>(Mul(Scope(2), Call(∂.CastU8(Scope(1)):u8)))):r8))
// (<ctx>, ∂.u8s:u8*) : r8
SumK_1(Arr<obj>, i8, u8):r8
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<u8>, Func<i8,u8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*2: u8s, Num<r8>(Mul(*2, CastU8(#1))))
###
> u4s->SumK(it * #it)
u4s->SumK(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(u4s), Num<r8>(Mul(Num<i8>(Scope(2)), Scope(1)))):r8))
// (<ctx>, ∂.u4s:u4*) : r8
SumK_1(Arr<obj>, i8, u4):r8
      1) ldarg.2 [u4]
      1) conv.u8
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<u4>, Func<i8,u4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*2: u4s, Num<r8>(Mul(Num<i8>(*2), #1)))
###
> bis->SumK(it * #it)
bis->SumK(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(bis), Num<r8>(Mul(Scope(2), Num<i>(Scope(1))))):r8))
// (<ctx>, ∂.bis:i*) : r8
SumK_1(Arr<obj>, i8, ia):r8
      1) ldarg.2 [ia]
      1) ldarg.1 [i8]
      5) newobj ia(i8)
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      1) ret
  Total Size: 18

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,ia,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<ia>, Func<i8,ia,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(*2: bis, Num<r8>(Mul(*2, Num<i>(#1))))
###
> r8s->Mean(it * #it)
r8s->Mean(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(r8s), Mul(Scope(2), Num<r8>(Scope(1)))):r8))
// (<ctx>, ∂.r8s:r8*) : r8
Mean_1(Arr<obj>, i8, r8):r8
      1) ldarg.2 [r8]
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<r8>, Func<i8,r8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*2: r8s, Mul(*2, Num<r8>(#1)))
###
> r4s->Mean(it * #it)
r4s->Mean(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(r4s), Mul(Num<r8>(Scope(2)), Num<r8>(Scope(1)))):r8))
// (<ctx>, ∂.r4s:r4*) : r8
Mean_1(Arr<obj>, i8, r4):r8
      1) ldarg.2 [r4]
      1) conv.r8
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<r4>, Func<i8,r4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*2: r4s, Mul(Num<r8>(*2), Num<r8>(#1)))
###
> i8s->Mean(it * #it)
i8s->Mean(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(i8s), Num<r8>(Mul(Scope(2), Scope(1)))):r8))
// (<ctx>, ∂.i8s:i8*) : r8
Mean_1(Arr<obj>, i8, i8):r8
      1) ldarg.2 [i8]
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<i8>, Func<i8,i8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*2: i8s, Num<r8>(Mul(*2, #1)))
###
> i4s->Mean(it * #it)
i4s->Mean(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(i4s), Num<r8>(Mul(Num<i8>(Scope(2)), Scope(1)))):r8))
// (<ctx>, ∂.i4s:i4*) : r8
Mean_1(Arr<obj>, i8, i4):r8
      1) ldarg.2 [i4]
      1) conv.i8
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<i4>, Func<i8,i4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*2: i4s, Num<r8>(Mul(Num<i8>(*2), #1)))
###
> u8s->Mean(it * #it)
u8s->Mean(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(u8s), Num<r8>(Mul(Num<i8>(Scope(2)), Scope(1)))):r8))
*** Warning: (10,12) Node: it, Message: Conversion from unsigned to signed integer can reinterpret large values as negative
// (<ctx>, ∂.u8s:u8*) : r8
Mean_1(Arr<obj>, i8, u8):r8
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<u8>, Func<i8,u8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*2: u8s, Num<r8>(Mul(Num<i8>(*2), #1)))
###
> u8s->Mean(it * #it->CastU8())
u8s->Mean(it * #it->CastU8()) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(u8s), Num<r8>(Mul(Scope(2), Call(∂.CastU8(Scope(1)):u8)))):r8))
// (<ctx>, ∂.u8s:u8*) : r8
Mean_1(Arr<obj>, i8, u8):r8
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<u8>, Func<i8,u8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*2: u8s, Num<r8>(Mul(*2, CastU8(#1))))
###
> u4s->Mean(it * #it)
u4s->Mean(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(u4s), Num<r8>(Mul(Num<i8>(Scope(2)), Scope(1)))):r8))
// (<ctx>, ∂.u4s:u4*) : r8
Mean_1(Arr<obj>, i8, u4):r8
      1) ldarg.2 [u4]
      1) conv.u8
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<u4>, Func<i8,u4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*2: u4s, Num<r8>(Mul(Num<i8>(*2), #1)))
###
> bis->Mean(it * #it)
bis->Mean(it * #it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(bis), Num<r8>(Mul(Scope(2), Num<i>(Scope(1))))):r8))
// (<ctx>, ∂.bis:i*) : r8
Mean_1(Arr<obj>, i8, ia):r8
      1) ldarg.2 [ia]
      1) ldarg.1 [i8]
      5) newobj ia(i8)
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      1) ret
  Total Size: 18

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,ia,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<ia>, Func<i8,ia,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*2: bis, Num<r8>(Mul(*2, Num<i>(#1))))
###
> Sum(a: r8s, b: i2s, a * b)
Sum(a : r8s, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2s), Mul(Scope(1), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r8s:r8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):r8
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8s:r8*, i2s:i2*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: r8s, *2: i2s, Mul(*1, Num<r8>(*2))))
###
> Sum(a: r4s, b: i2s, a * b)
Sum(a : r4s, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r4s:r4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4s:r4*, i2s:i2*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: r4s, *2: i2s, Mul(Num<r8>(*1), Num<r8>(*2))))
###
> Sum(a: i8s, b: i2s, a * b)
Sum(a : i8s, b : i2s, a * b) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2s), Mul(Scope(1), Num<i8>(Scope(2)))):i8*)):i8))
// (<ctx>, ∂.i8s:i8*, ∂.i2s:i2*) : i8
ForEach_2(Arr<obj>, i8, i2):i8
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,i8>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,i8>):Seq<i8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<i8>):Seq<i8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8s:i8*, i2s:i2*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: i8s, *2: i2s, Mul(*1, Num<i8>(*2))))
###
> Sum(a: i4s, b: i2s, a * b)
Sum(a : i4s, b : i2s, a * b) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2s), Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))):i8*)):i8))
// (<ctx>, ∂.i4s:i4*, ∂.i2s:i2*) : i8
ForEach_2(Arr<obj>, i4, i2):i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,i8>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,i8>):Seq<i8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<i8>):Seq<i8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4s:i4*, i2s:i2*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: i4s, *2: i2s, Mul(Num<i8>(*1), Num<i8>(*2))))
###
> Sum(a: u8s, b: u2s, a * b)
Sum(a : u8s, b : u2s, a * b) : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2s), Mul(Scope(1), Num<u8>(Scope(2)))):u8*)):u8))
// (<ctx>, ∂.u8s:u8*, ∂.u2s:u2*) : u8
ForEach_2(Arr<obj>, u8, u2):u8
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,u8>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,u8>):Seq<u8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<u8>):Seq<u8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<u8>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8s:u8*, u2s:u2*) to u8
Type: u8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: u8s, *2: u2s, Mul(*1, Num<u8>(*2))))
###
> Sum(a: u4s, b: u2s, a * b)
Sum(a : u4s, b : u2s, a * b) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2s), Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))):i8*)):i8))
// (<ctx>, ∂.u4s:u4*, ∂.u2s:u2*) : i8
ForEach_2(Arr<obj>, u4, u2):i8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,i8>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,i8>):Seq<i8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<i8>):Seq<i8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4s:u4*, u2s:u2*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: u4s, *2: u2s, Mul(Num<i8>(*1), Num<i8>(*2))))
###
> Sum(a: bis, b: i2s, a * b)
Sum(a : bis, b : i2s, a * b) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2s), Mul(Scope(1), Num<i>(Scope(2)))):i*)):i))
// (<ctx>, ∂.bis:i*, ∂.i2s:i2*) : i
ForEach_2(Arr<obj>, ia, i2):ia
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,ia>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,ia>):Seq<ia>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<ia>):Seq<ia>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bis:i*, i2s:i2*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: bis, *2: i2s, Mul(*1, Num<i>(*2))))
###
> SumBig(a: r8s, b: i2s, a * b)
SumBig(a : r8s, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2s), Mul(Scope(1), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r8s:r8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):r8
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8s:r8*, i2s:i2*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(ForEach(*1: r8s, *2: i2s, Mul(*1, Num<r8>(*2))))
###
> SumBig(a: r4s, b: i2s, a * b)
SumBig(a : r4s, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r4s:r4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4s:r4*, i2s:i2*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(ForEach(*1: r4s, *2: i2s, Mul(Num<r8>(*1), Num<r8>(*2))))
###
> SumBig(a: i8s, b: i2s, a * b)
SumBig(a : i8s, b : i2s, a * b) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2s), Num<i>(Mul(Scope(1), Num<i8>(Scope(2))))):i*)):i))
// (<ctx>, ∂.i8s:i8*, ∂.i2s:i2*) : i
ForEach_2(Arr<obj>, i8, i2):ia
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,ia>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,ia>):Seq<ia>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<ia>):Seq<ia>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8s:i8*, i2s:i2*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(ForEach(*1: i8s, *2: i2s, Num<i>(Mul(*1, Num<i8>(*2)))))
###
> SumBig(a: i4s, b: i2s, a * b)
SumBig(a : i4s, b : i2s, a * b) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2s), Num<i>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):i*)):i))
// (<ctx>, ∂.i4s:i4*, ∂.i2s:i2*) : i
ForEach_2(Arr<obj>, i4, i2):ia
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,ia>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,ia>):Seq<ia>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<ia>):Seq<ia>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4s:i4*, i2s:i2*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(ForEach(*1: i4s, *2: i2s, Num<i>(Mul(Num<i8>(*1), Num<i8>(*2)))))
###
> SumBig(a: u8s, b: u2s, a * b)
SumBig(a : u8s, b : u2s, a * b) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2s), Num<i>(Mul(Scope(1), Num<u8>(Scope(2))))):i*)):i))
// (<ctx>, ∂.u8s:u8*, ∂.u2s:u2*) : i
ForEach_2(Arr<obj>, u8, u2):ia
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) newobj ia(u8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,ia>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,ia>):Seq<ia>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<ia>):Seq<ia>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8s:u8*, u2s:u2*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(ForEach(*1: u8s, *2: u2s, Num<i>(Mul(*1, Num<u8>(*2)))))
###
> SumBig(a: u4s, b: u2s, a * b)
SumBig(a : u4s, b : u2s, a * b) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2s), Num<i>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):i*)):i))
// (<ctx>, ∂.u4s:u4*, ∂.u2s:u2*) : i
ForEach_2(Arr<obj>, u4, u2):ia
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,ia>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,ia>):Seq<ia>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<ia>):Seq<ia>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4s:u4*, u2s:u2*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(ForEach(*1: u4s, *2: u2s, Num<i>(Mul(Num<i8>(*1), Num<i8>(*2)))))
###
> SumBig(a: bis, b: i2s, a * b)
SumBig(a : bis, b : i2s, a * b) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2s), Mul(Scope(1), Num<i>(Scope(2)))):i*)):i))
// (<ctx>, ∂.bis:i*, ∂.i2s:i2*) : i
ForEach_2(Arr<obj>, ia, i2):ia
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,ia>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,ia>):Seq<ia>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<ia>):Seq<ia>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bis:i*, i2s:i2*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): SumBig(ForEach(*1: bis, *2: i2s, Mul(*1, Num<i>(*2))))
###
> SumK(a: r8s, b: i2s, a * b)
SumK(a : r8s, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2s), Mul(Scope(1), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r8s:r8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):r8
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8s:r8*, i2s:i2*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(ForEach(*1: r8s, *2: i2s, Mul(*1, Num<r8>(*2))))
###
> SumK(a: r4s, b: i2s, a * b)
SumK(a : r4s, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r4s:r4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4s:r4*, i2s:i2*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(ForEach(*1: r4s, *2: i2s, Mul(Num<r8>(*1), Num<r8>(*2))))
###
> SumK(a: i8s, b: i2s, a * b)
SumK(a : i8s, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2s), Num<r8>(Mul(Scope(1), Num<i8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.i8s:i8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, i8, i2):r8
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8s:i8*, i2s:i2*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(ForEach(*1: i8s, *2: i2s, Num<r8>(Mul(*1, Num<i8>(*2)))))
###
> SumK(a: i4s, b: i2s, a * b)
SumK(a : i4s, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.i4s:i4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, i4, i2):r8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4s:i4*, i2s:i2*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(ForEach(*1: i4s, *2: i2s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*2)))))
###
> SumK(a: u8s, b: u2s, a * b)
SumK(a : u8s, b : u2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2s), Num<r8>(Mul(Scope(1), Num<u8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.u8s:u8*, ∂.u2s:u2*) : r8
ForEach_2(Arr<obj>, u8, u2):r8
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,r8>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8s:u8*, u2s:u2*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(ForEach(*1: u8s, *2: u2s, Num<r8>(Mul(*1, Num<u8>(*2)))))
###
> SumK(a: u4s, b: u2s, a * b)
SumK(a : u4s, b : u2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.u4s:u4*, ∂.u2s:u2*) : r8
ForEach_2(Arr<obj>, u4, u2):r8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,r8>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4s:u4*, u2s:u2*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(ForEach(*1: u4s, *2: u2s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*2)))))
###
> SumK(a: bis, b: i2s, a * b)
SumK(a : bis, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2s), Num<r8>(Mul(Scope(1), Num<i>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.bis:i*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, ia, i2):r8
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      1) ret
  Total Size: 18

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,r8>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bis:i*, i2s:i2*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): SumK(ForEach(*1: bis, *2: i2s, Num<r8>(Mul(*1, Num<i>(*2)))))
###
> Mean(a: r8s, b: i2s, a * b)
Mean(a : r8s, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2s), Mul(Scope(1), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r8s:r8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):r8
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8s:r8*, i2s:i2*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: r8s, *2: i2s, Mul(*1, Num<r8>(*2))))
###
> Mean(a: r4s, b: i2s, a * b)
Mean(a : r4s, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r4s:r4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4s:r4*, i2s:i2*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: r4s, *2: i2s, Mul(Num<r8>(*1), Num<r8>(*2))))
###
> Mean(a: i8s, b: i2s, a * b)
Mean(a : i8s, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2s), Num<r8>(Mul(Scope(1), Num<i8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.i8s:i8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, i8, i2):r8
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8s:i8*, i2s:i2*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: i8s, *2: i2s, Num<r8>(Mul(*1, Num<i8>(*2)))))
###
> Mean(a: i4s, b: i2s, a * b)
Mean(a : i4s, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.i4s:i4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, i4, i2):r8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4s:i4*, i2s:i2*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: i4s, *2: i2s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*2)))))
###
> Mean(a: u8s, b: u2s, a * b)
Mean(a : u8s, b : u2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2s), Num<r8>(Mul(Scope(1), Num<u8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.u8s:u8*, ∂.u2s:u2*) : r8
ForEach_2(Arr<obj>, u8, u2):r8
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,r8>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8s:u8*, u2s:u2*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: u8s, *2: u2s, Num<r8>(Mul(*1, Num<u8>(*2)))))
###
> Mean(a: u4s, b: u2s, a * b)
Mean(a : u4s, b : u2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.u4s:u4*, ∂.u2s:u2*) : r8
ForEach_2(Arr<obj>, u4, u2):r8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,r8>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4s:u4*, u2s:u2*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: u4s, *2: u2s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*2)))))
###
> Mean(a: bis, b: i2s, a * b)
Mean(a : bis, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2s), Num<r8>(Mul(Scope(1), Num<i>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.bis:i*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, ia, i2):r8
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      1) ret
  Total Size: 18

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,r8>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bis:i*, i2s:i2*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: bis, *2: i2s, Num<r8>(Mul(*1, Num<i>(*2)))))
###
> qr8s->Sum()
qr8s->Sum() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Global(qr8s)):r8))
// (<ctx>, ∂.qr8s:r8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr8s:r8?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(qr8s)
###
> qr4s->Sum()
qr4s->Sum() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Global(qr4s)):r8))
// (<ctx>, ∂.qr4s:r4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr4s:r4?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(qr4s)
###
> qi8s->Sum()
qi8s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qi8s)):i8))
// (<ctx>, ∂.qi8s:i8?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi8s:i8?*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(qi8s)
###
> qi4s->Sum()
qi4s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qi4s)):i8))
// (<ctx>, ∂.qi4s:i4?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<i4>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi4s:i4?*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(qi4s)
###
> qi2s->Sum()
qi2s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qi2s)):i8))
// (<ctx>, ∂.qi2s:i2?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<i2>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi2s:i2?*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(qi2s)
###
> qi1s->Sum()
qi1s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qi1s)):i8))
// (<ctx>, ∂.qi1s:i1?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<i1>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi1s:i1?*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(qi1s)
###
> qu8s->Sum()
qu8s->Sum() : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum(Global(qu8s)):u8))
// (<ctx>, ∂.qu8s:u8?*) : u8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<u8>>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu8s:u8?*) to u8
Type: u8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(qu8s)
###
> qu4s->Sum()
qu4s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qu4s)):i8))
// (<ctx>, ∂.qu4s:u4?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<u4>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu4s:u4?*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(qu4s)
###
> qu2s->Sum()
qu2s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qu2s)):i8))
// (<ctx>, ∂.qu2s:u2?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<u2>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu2s:u2?*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(qu2s)
###
> qu1s->Sum()
qu1s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qu1s)):i8))
// (<ctx>, ∂.qu1s:u1?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<u1>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu1s:u1?*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(qu1s)
###
> qbis->Sum()
qbis->Sum() : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum(Global(qbis)):i))
// (<ctx>, ∂.qbis:i?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qbis:i?*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): Sum(qbis)
###
> qr8s->SumBig()
qr8s->SumBig() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig(Global(qr8s)):r8))
// (<ctx>, ∂.qr8s:r8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr8s:r8?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(qr8s)
###
> qr4s->SumBig()
qr4s->SumBig() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig(Global(qr4s)):r8))
// (<ctx>, ∂.qr4s:r4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr4s:r4?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(qr4s)
###
> qi8s->SumBig()
qi8s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qi8s)):i))
// (<ctx>, ∂.qi8s:i8?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<i8>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi8s:i8?*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(qi8s)
###
> qi4s->SumBig()
qi4s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qi4s)):i))
// (<ctx>, ∂.qi4s:i4?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<i4>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi4s:i4?*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(qi4s)
###
> qi2s->SumBig()
qi2s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qi2s)):i))
// (<ctx>, ∂.qi2s:i2?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<i2>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi2s:i2?*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(qi2s)
###
> qi1s->SumBig()
qi1s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qi1s)):i))
// (<ctx>, ∂.qi1s:i1?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<i1>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi1s:i1?*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(qi1s)
###
> qu8s->SumBig()
qu8s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qu8s)):i))
// (<ctx>, ∂.qu8s:u8?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<u8>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu8s:u8?*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(qu8s)
###
> qu4s->SumBig()
qu4s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qu4s)):i))
// (<ctx>, ∂.qu4s:u4?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<u4>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu4s:u4?*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(qu4s)
###
> qu2s->SumBig()
qu2s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qu2s)):i))
// (<ctx>, ∂.qu2s:u2?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<u2>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu2s:u2?*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(qu2s)
###
> qu1s->SumBig()
qu1s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qu1s)):i))
// (<ctx>, ∂.qu1s:u1?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<u1>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu1s:u1?*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(qu1s)
###
> qbis->SumBig()
qbis->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qbis)):i))
// (<ctx>, ∂.qbis:i?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qbis:i?*) to i
Type: ia, Value: 45
*** Ctx ping count: 11
    [0](11): SumBig(qbis)
###
> qr8s->SumK()
qr8s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qr8s)):r8))
// (<ctx>, ∂.qr8s:r8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr8s:r8?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(qr8s)
###
> qr4s->SumK()
qr4s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qr4s)):r8))
// (<ctx>, ∂.qr4s:r4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr4s:r4?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(qr4s)
###
> qi8s->SumK()
qi8s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qi8s)):r8))
// (<ctx>, ∂.qi8s:i8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<i8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi8s:i8?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(qi8s)
###
> qi4s->SumK()
qi4s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qi4s)):r8))
// (<ctx>, ∂.qi4s:i4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<i4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi4s:i4?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(qi4s)
###
> qi2s->SumK()
qi2s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qi2s)):r8))
// (<ctx>, ∂.qi2s:i2?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<i2>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi2s:i2?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(qi2s)
###
> qi1s->SumK()
qi1s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qi1s)):r8))
// (<ctx>, ∂.qi1s:i1?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<i1>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi1s:i1?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(qi1s)
###
> qu8s->SumK()
qu8s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qu8s)):r8))
// (<ctx>, ∂.qu8s:u8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<u8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu8s:u8?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(qu8s)
###
> qu4s->SumK()
qu4s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qu4s)):r8))
// (<ctx>, ∂.qu4s:u4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<u4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu4s:u4?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(qu4s)
###
> qu2s->SumK()
qu2s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qu2s)):r8))
// (<ctx>, ∂.qu2s:u2?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<u2>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu2s:u2?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(qu2s)
###
> qu1s->SumK()
qu1s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qu1s)):r8))
// (<ctx>, ∂.qu1s:u1?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<u1>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu1s:u1?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(qu1s)
###
> qbis->SumK()
qbis->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qbis)):r8))
// (<ctx>, ∂.qbis:i?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<ia>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qbis:i?*) to r8
Type: r8, Value: 45
*** Ctx ping count: 11
    [0](11): SumK(qbis)
###
> qr8s->Mean()
qr8s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qr8s)):r8))
// (<ctx>, ∂.qr8s:r8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr8s:r8?*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(qr8s)
###
> qr4s->Mean()
qr4s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qr4s)):r8))
// (<ctx>, ∂.qr4s:r4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr4s:r4?*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(qr4s)
###
> qi8s->Mean()
qi8s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qi8s)):r8))
// (<ctx>, ∂.qi8s:i8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<i8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi8s:i8?*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(qi8s)
###
> qi4s->Mean()
qi4s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qi4s)):r8))
// (<ctx>, ∂.qi4s:i4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<i4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi4s:i4?*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(qi4s)
###
> qi2s->Mean()
qi2s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qi2s)):r8))
// (<ctx>, ∂.qi2s:i2?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<i2>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi2s:i2?*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(qi2s)
###
> qi1s->Mean()
qi1s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qi1s)):r8))
// (<ctx>, ∂.qi1s:i1?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<i1>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi1s:i1?*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(qi1s)
###
> qu8s->Mean()
qu8s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qu8s)):r8))
// (<ctx>, ∂.qu8s:u8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<u8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu8s:u8?*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(qu8s)
###
> qu4s->Mean()
qu4s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qu4s)):r8))
// (<ctx>, ∂.qu4s:u4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<u4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu4s:u4?*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(qu4s)
###
> qu2s->Mean()
qu2s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qu2s)):r8))
// (<ctx>, ∂.qu2s:u2?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<u2>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu2s:u2?*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(qu2s)
###
> qu1s->Mean()
qu1s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qu1s)):r8))
// (<ctx>, ∂.qu1s:u1?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<u1>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu1s:u1?*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(qu1s)
###
> qbis->Mean()
qbis->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qbis)):r8))
// (<ctx>, ∂.qbis:i?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<ia>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qbis:i?*) to r8
Type: r8, Value: 4.5
*** Ctx ping count: 11
    [0](11): Mean(qbis)
###
> or8s->Sum()
or8s->Sum() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Global(or8s)):r8))
// (<ctx>, ∂.or8s:r8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, or8s:r8?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): Sum(or8s)
###
> or4s->Sum()
or4s->Sum() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Global(or4s)):r8))
// (<ctx>, ∂.or4s:r4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, or4s:r4?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): Sum(or4s)
###
> oi8s->Sum()
oi8s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(oi8s)):i8))
// (<ctx>, ∂.oi8s:i8?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi8s:i8?*) to i8
Type: i8, Value: 40
*** Ctx ping count: 11
    [0](11): Sum(oi8s)
###
> oi4s->Sum()
oi4s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(oi4s)):i8))
// (<ctx>, ∂.oi4s:i4?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<i4>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi4s:i4?*) to i8
Type: i8, Value: 40
*** Ctx ping count: 11
    [0](11): Sum(oi4s)
###
> oi2s->Sum()
oi2s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(oi2s)):i8))
// (<ctx>, ∂.oi2s:i2?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<i2>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi2s:i2?*) to i8
Type: i8, Value: 40
*** Ctx ping count: 11
    [0](11): Sum(oi2s)
###
> oi1s->Sum()
oi1s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(oi1s)):i8))
// (<ctx>, ∂.oi1s:i1?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<i1>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi1s:i1?*) to i8
Type: i8, Value: 40
*** Ctx ping count: 11
    [0](11): Sum(oi1s)
###
> ou8s->Sum()
ou8s->Sum() : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum(Global(ou8s)):u8))
// (<ctx>, ∂.ou8s:u8?*) : u8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<u8>>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou8s:u8?*) to u8
Type: u8, Value: 40
*** Ctx ping count: 11
    [0](11): Sum(ou8s)
###
> ou4s->Sum()
ou4s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(ou4s)):i8))
// (<ctx>, ∂.ou4s:u4?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<u4>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou4s:u4?*) to i8
Type: i8, Value: 40
*** Ctx ping count: 11
    [0](11): Sum(ou4s)
###
> ou2s->Sum()
ou2s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(ou2s)):i8))
// (<ctx>, ∂.ou2s:u2?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<u2>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou2s:u2?*) to i8
Type: i8, Value: 40
*** Ctx ping count: 11
    [0](11): Sum(ou2s)
###
> ou1s->Sum()
ou1s->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(ou1s)):i8))
// (<ctx>, ∂.ou1s:u1?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<u1>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou1s:u1?*) to i8
Type: i8, Value: 40
*** Ctx ping count: 11
    [0](11): Sum(ou1s)
###
> obis->Sum()
obis->Sum() : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum(Global(obis)):i))
// (<ctx>, ∂.obis:i?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, obis:i?*) to i
Type: ia, Value: 40
*** Ctx ping count: 11
    [0](11): Sum(obis)
###
> or8s->SumBig()
or8s->SumBig() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig(Global(or8s)):r8))
// (<ctx>, ∂.or8s:r8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, or8s:r8?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): SumBig(or8s)
###
> or4s->SumBig()
or4s->SumBig() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig(Global(or4s)):r8))
// (<ctx>, ∂.or4s:r4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, or4s:r4?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): SumBig(or4s)
###
> oi8s->SumBig()
oi8s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(oi8s)):i))
// (<ctx>, ∂.oi8s:i8?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<i8>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi8s:i8?*) to i
Type: ia, Value: 40
*** Ctx ping count: 11
    [0](11): SumBig(oi8s)
###
> oi4s->SumBig()
oi4s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(oi4s)):i))
// (<ctx>, ∂.oi4s:i4?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<i4>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi4s:i4?*) to i
Type: ia, Value: 40
*** Ctx ping count: 11
    [0](11): SumBig(oi4s)
###
> oi2s->SumBig()
oi2s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(oi2s)):i))
// (<ctx>, ∂.oi2s:i2?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<i2>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi2s:i2?*) to i
Type: ia, Value: 40
*** Ctx ping count: 11
    [0](11): SumBig(oi2s)
###
> oi1s->SumBig()
oi1s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(oi1s)):i))
// (<ctx>, ∂.oi1s:i1?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<i1>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi1s:i1?*) to i
Type: ia, Value: 40
*** Ctx ping count: 11
    [0](11): SumBig(oi1s)
###
> ou8s->SumBig()
ou8s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(ou8s)):i))
// (<ctx>, ∂.ou8s:u8?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<u8>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou8s:u8?*) to i
Type: ia, Value: 40
*** Ctx ping count: 11
    [0](11): SumBig(ou8s)
###
> ou4s->SumBig()
ou4s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(ou4s)):i))
// (<ctx>, ∂.ou4s:u4?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<u4>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou4s:u4?*) to i
Type: ia, Value: 40
*** Ctx ping count: 11
    [0](11): SumBig(ou4s)
###
> ou2s->SumBig()
ou2s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(ou2s)):i))
// (<ctx>, ∂.ou2s:u2?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<u2>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou2s:u2?*) to i
Type: ia, Value: 40
*** Ctx ping count: 11
    [0](11): SumBig(ou2s)
###
> ou1s->SumBig()
ou1s->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(ou1s)):i))
// (<ctx>, ∂.ou1s:u1?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<u1>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou1s:u1?*) to i
Type: ia, Value: 40
*** Ctx ping count: 11
    [0](11): SumBig(ou1s)
###
> obis->SumBig()
obis->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(obis)):i))
// (<ctx>, ∂.obis:i?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, obis:i?*) to i
Type: ia, Value: 40
*** Ctx ping count: 11
    [0](11): SumBig(obis)
###
> or8s->SumK()
or8s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(or8s)):r8))
// (<ctx>, ∂.or8s:r8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, or8s:r8?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): SumK(or8s)
###
> or4s->SumK()
or4s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(or4s)):r8))
// (<ctx>, ∂.or4s:r4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, or4s:r4?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): SumK(or4s)
###
> oi8s->SumK()
oi8s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(oi8s)):r8))
// (<ctx>, ∂.oi8s:i8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<i8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi8s:i8?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): SumK(oi8s)
###
> oi4s->SumK()
oi4s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(oi4s)):r8))
// (<ctx>, ∂.oi4s:i4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<i4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi4s:i4?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): SumK(oi4s)
###
> oi2s->SumK()
oi2s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(oi2s)):r8))
// (<ctx>, ∂.oi2s:i2?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<i2>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi2s:i2?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): SumK(oi2s)
###
> oi1s->SumK()
oi1s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(oi1s)):r8))
// (<ctx>, ∂.oi1s:i1?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<i1>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi1s:i1?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): SumK(oi1s)
###
> ou8s->SumK()
ou8s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(ou8s)):r8))
// (<ctx>, ∂.ou8s:u8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<u8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou8s:u8?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): SumK(ou8s)
###
> ou4s->SumK()
ou4s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(ou4s)):r8))
// (<ctx>, ∂.ou4s:u4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<u4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou4s:u4?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): SumK(ou4s)
###
> ou2s->SumK()
ou2s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(ou2s)):r8))
// (<ctx>, ∂.ou2s:u2?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<u2>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou2s:u2?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): SumK(ou2s)
###
> ou1s->SumK()
ou1s->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(ou1s)):r8))
// (<ctx>, ∂.ou1s:u1?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<u1>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou1s:u1?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): SumK(ou1s)
###
> obis->SumK()
obis->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(obis)):r8))
// (<ctx>, ∂.obis:i?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<ia>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, obis:i?*) to r8
Type: r8, Value: 40
*** Ctx ping count: 11
    [0](11): SumK(obis)
###
> or8s->Mean()
or8s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(or8s)):r8))
// (<ctx>, ∂.or8s:r8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, or8s:r8?*) to r8
Type: r8, Value: 4.444444444444445
*** Ctx ping count: 11
    [0](11): Mean(or8s)
###
> or4s->Mean()
or4s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(or4s)):r8))
// (<ctx>, ∂.or4s:r4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, or4s:r4?*) to r8
Type: r8, Value: 4.444444444444445
*** Ctx ping count: 11
    [0](11): Mean(or4s)
###
> oi8s->Mean()
oi8s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(oi8s)):r8))
// (<ctx>, ∂.oi8s:i8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<i8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi8s:i8?*) to r8
Type: r8, Value: 4.444444444444445
*** Ctx ping count: 11
    [0](11): Mean(oi8s)
###
> oi4s->Mean()
oi4s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(oi4s)):r8))
// (<ctx>, ∂.oi4s:i4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<i4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi4s:i4?*) to r8
Type: r8, Value: 4.444444444444445
*** Ctx ping count: 11
    [0](11): Mean(oi4s)
###
> oi2s->Mean()
oi2s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(oi2s)):r8))
// (<ctx>, ∂.oi2s:i2?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<i2>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi2s:i2?*) to r8
Type: r8, Value: 4.444444444444445
*** Ctx ping count: 11
    [0](11): Mean(oi2s)
###
> oi1s->Mean()
oi1s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(oi1s)):r8))
// (<ctx>, ∂.oi1s:i1?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<i1>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, oi1s:i1?*) to r8
Type: r8, Value: 4.444444444444445
*** Ctx ping count: 11
    [0](11): Mean(oi1s)
###
> ou8s->Mean()
ou8s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(ou8s)):r8))
// (<ctx>, ∂.ou8s:u8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<u8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou8s:u8?*) to r8
Type: r8, Value: 4.444444444444445
*** Ctx ping count: 11
    [0](11): Mean(ou8s)
###
> ou4s->Mean()
ou4s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(ou4s)):r8))
// (<ctx>, ∂.ou4s:u4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<u4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou4s:u4?*) to r8
Type: r8, Value: 4.444444444444445
*** Ctx ping count: 11
    [0](11): Mean(ou4s)
###
> ou2s->Mean()
ou2s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(ou2s)):r8))
// (<ctx>, ∂.ou2s:u2?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<u2>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou2s:u2?*) to r8
Type: r8, Value: 4.444444444444445
*** Ctx ping count: 11
    [0](11): Mean(ou2s)
###
> ou1s->Mean()
ou1s->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(ou1s)):r8))
// (<ctx>, ∂.ou1s:u1?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<u1>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, ou1s:u1?*) to r8
Type: r8, Value: 4.444444444444445
*** Ctx ping count: 11
    [0](11): Mean(ou1s)
###
> obis->Mean()
obis->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(obis)):r8))
// (<ctx>, ∂.obis:i?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<ia>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, obis:i?*) to r8
Type: r8, Value: 4.444444444444445
*** Ctx ping count: 11
    [0](11): Mean(obis)
###
> r8s->Sum (Opt(it * it))
r8s->Sum(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum([map:1] Global(r8s), Opt<r8?>(Mul(Scope(1), Scope(1)))):r8))
// (<ctx>, ∂.r8s:r8*) : r8
Sum_1(Arr<obj>, r8):Opt<r8>
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<r8>, Func<r8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*1: r8s, Opt<r8?>(Mul(*1, *1)))
###
> r4s->Sum (Opt(it * it))
r4s->Sum(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum([map:1] Global(r4s), Opt<r8?>(Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1))))):r8))
// (<ctx>, ∂.r4s:r4*) : r8
Sum_1(Arr<obj>, r4):Opt<r8>
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<r4>, Func<r4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*1: r4s, Opt<r8?>(Mul(Num<r8>(*1), Num<r8>(*1))))
###
> i8s->Sum (Opt(it * it))
i8s->Sum(Opt(it * it)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(i8s), Opt<i8?>(Mul(Scope(1), Scope(1)))):i8))
// (<ctx>, ∂.i8s:i8*) : i8
Sum_1(Arr<obj>, i8):Opt<i8>
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<i8>, Func<i8,Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*1: i8s, Opt<i8?>(Mul(*1, *1)))
###
> i4s->Sum (Opt(it * it))
i4s->Sum(Opt(it * it)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(i4s), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1))))):i8))
// (<ctx>, ∂.i4s:i4*) : i8
Sum_1(Arr<obj>, i4):Opt<i8>
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<i4>, Func<i4,Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*1: i4s, Opt<i8?>(Mul(Num<i8>(*1), Num<i8>(*1))))
###
> u8s->Sum (Opt(it * it))
u8s->Sum(Opt(it * it)) : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum([map:1] Global(u8s), Opt<u8?>(Mul(Scope(1), Scope(1)))):u8))
// (<ctx>, ∂.u8s:u8*) : u8
Sum_1(Arr<obj>, u8):Opt<u8>
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      5) newobj Opt<u8>(u8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<u8>, Func<u8,Opt<u8>>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to u8
Type: u8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*1: u8s, Opt<u8?>(Mul(*1, *1)))
###
> u4s->Sum (Opt(it * it))
u4s->Sum(Opt(it * it)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(u4s), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1))))):i8))
// (<ctx>, ∂.u4s:u4*) : i8
Sum_1(Arr<obj>, u4):Opt<i8>
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<u4>, Func<u4,Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*1: u4s, Opt<i8?>(Mul(Num<i8>(*1), Num<i8>(*1))))
###
> bis->Sum (Opt(it * it))
bis->Sum(Opt(it * it)) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum([map:1] Global(bis), Opt<i?>(Mul(Scope(1), Scope(1)))):i))
// (<ctx>, ∂.bis:i*) : i
Sum_1(Arr<obj>, ia):Opt<ia>
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      5) newobj Opt<ia>(ia)
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<ia>, Func<ia,Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(*1: bis, Opt<i?>(Mul(*1, *1)))
###
> r8s->Mean(Opt(it * it))
r8s->Mean(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(r8s), Opt<r8?>(Mul(Scope(1), Scope(1)))):r8))
// (<ctx>, ∂.r8s:r8*) : r8
Mean_1(Arr<obj>, r8):Opt<r8>
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, Func<r8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*1: r8s, Opt<r8?>(Mul(*1, *1)))
###
> r4s->Mean(Opt(it * it))
r4s->Mean(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(r4s), Opt<r8?>(Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1))))):r8))
// (<ctx>, ∂.r4s:r4*) : r8
Mean_1(Arr<obj>, r4):Opt<r8>
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<r4>, Func<r4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*1: r4s, Opt<r8?>(Mul(Num<r8>(*1), Num<r8>(*1))))
###
> i8s->Mean(Opt(it * it))
i8s->Mean(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(i8s), Opt<r8?>(Num<r8>(Mul(Scope(1), Scope(1))))):r8))
// (<ctx>, ∂.i8s:i8*) : r8
Mean_1(Arr<obj>, i8):Opt<r8>
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i8>, Func<i8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*1: i8s, Opt<r8?>(Num<r8>(Mul(*1, *1))))
###
> i4s->Mean(Opt(it * it))
i4s->Mean(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(i4s), Opt<r8?>(Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))))):r8))
// (<ctx>, ∂.i4s:i4*) : r8
Mean_1(Arr<obj>, i4):Opt<r8>
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 12

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i4>, Func<i4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*1: i4s, Opt<r8?>(Num<r8>(Mul(Num<i8>(*1), Num<i8>(*1)))))
###
> u8s->Mean(Opt(it * it))
u8s->Mean(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(u8s), Opt<r8?>(Num<r8>(Mul(Scope(1), Scope(1))))):r8))
// (<ctx>, ∂.u8s:u8*) : r8
Mean_1(Arr<obj>, u8):Opt<r8>
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 14

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u8>, Func<u8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*1: u8s, Opt<r8?>(Num<r8>(Mul(*1, *1))))
###
> u4s->Mean(Opt(it * it))
u4s->Mean(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(u4s), Opt<r8?>(Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))))):r8))
// (<ctx>, ∂.u4s:u4*) : r8
Mean_1(Arr<obj>, u4):Opt<r8>
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 12

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u4>, Func<u4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*1: u4s, Opt<r8?>(Num<r8>(Mul(Num<i8>(*1), Num<i8>(*1)))))
###
> bis->Mean(Opt(it * it))
bis->Mean(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(bis), Opt<r8?>(Num<r8>(Mul(Scope(1), Scope(1))))):r8))
// (<ctx>, ∂.bis:i*) : r8
Mean_1(Arr<obj>, ia):Opt<r8>
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 18

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<ia>, Func<ia,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(*1: bis, Opt<r8?>(Num<r8>(Mul(*1, *1))))
###
> r8s->Sum (it * it if it != 5i4 else null)
r8s->Sum(it * it if it !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum([map:1] Global(r8s), If(Cmp(Scope(1) !@= 5:r8), Opt<r8?>(Mul(Scope(1), Scope(1))), null:r8?)):r8))
// (<ctx>, ∂.r8s:r8*) : r8
Sum_1(Arr<obj>, r8):Opt<r8>
      1) ldarg.1 [r8]
      9) ldc.r8 [5]
      5) call static NumUtil::Eq(r8, r8):bool
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 42

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<r8>, Func<r8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 260
*** Ctx ping count: 11
    [0](11): Sum(*1: r8s, If(*1 !@= 5, Opt<r8?>(Mul(*1, *1)), null))
###
> r4s->Sum (it * it if it != 5i4 else null)
r4s->Sum(it * it if it !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum([map:1] Global(r4s), If(Cmp(Scope(1) !@= 5:r4), Opt<r8?>(Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1)))), null:r8?)):r8))
// (<ctx>, ∂.r4s:r4*) : r8
Sum_1(Arr<obj>, r4):Opt<r8>
      1) ldarg.1 [r4]
      5) ldc.r4 [5]
      5) call static NumUtil::Eq(r4, r4):bool
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 40

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<r4>, Func<r4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 260
*** Ctx ping count: 11
    [0](11): Sum(*1: r4s, If(*1 !@= 5, Opt<r8?>(Mul(Num<r8>(*1), Num<r8>(*1))), null))
###
> i8s->Sum (it * it if it != 5i4 else null)
i8s->Sum(it * it if it !@= 5 else null) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(i8s), If(Cmp(Scope(1) !@= 5:i8), Opt<i8?>(Mul(Scope(1), Scope(1))), null:i8?)):i8))
// (<ctx>, ∂.i8s:i8*) : i8
Sum_1(Arr<obj>, i8):Opt<i8>
      1) ldarg.1 [i8]
      1) ldc.i4.5
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [1]:
      1) ret
  Total Size: 32

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<i8>, Func<i8,Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to i8
Type: i8, Value: 260
*** Ctx ping count: 11
    [0](11): Sum(*1: i8s, If(*1 !@= 5, Opt<i8?>(Mul(*1, *1)), null))
###
> i4s->Sum (it * it if it != 5i4 else null)
i4s->Sum(it * it if it !@= 5 else null) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(i4s), If(Cmp(Scope(1) !@= 5:i4), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))), null:i8?)):i8))
// (<ctx>, ∂.i4s:i4*) : i8
Sum_1(Arr<obj>, i4):Opt<i8>
      1) ldarg.1 [i4]
      1) ldc.i4.5
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [1]:
      1) ret
  Total Size: 33

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<i4>, Func<i4,Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to i8
Type: i8, Value: 260
*** Ctx ping count: 11
    [0](11): Sum(*1: i4s, If(*1 !@= 5, Opt<i8?>(Mul(Num<i8>(*1), Num<i8>(*1))), null))
###
> u8s->Sum (it * it if it != 5u8 else null)
u8s->Sum(it * it if it !@= 5 else null) : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum([map:1] Global(u8s), If(Cmp(Scope(1) !@= 5:u8), Opt<u8?>(Mul(Scope(1), Scope(1))), null:u8?)):u8))
// (<ctx>, ∂.u8s:u8*) : u8
Sum_1(Arr<obj>, u8):Opt<u8>
      1) ldarg.1 [u8]
      1) ldc.i4.5
      1) conv.u8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      5) newobj Opt<u8>(u8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<u8>
  Label [1]:
      1) ret
  Total Size: 32

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<u8>, Func<u8,Opt<u8>>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to u8
Type: u8, Value: 260
*** Ctx ping count: 11
    [0](11): Sum(*1: u8s, If(*1 !@= 5, Opt<u8?>(Mul(*1, *1)), null))
###
> u4s->Sum (it * it if it != 5i4 else null)
u4s->Sum(it * it if it !@= 5 else null) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(u4s), If(Cmp(Num<i8>(Scope(1)) !@= 5:i8), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))), null:i8?)):i8))
// (<ctx>, ∂.u4s:u4*) : i8
Sum_1(Arr<obj>, u4):Opt<i8>
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldc.i4.5
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [1]:
      1) ret
  Total Size: 35

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<u4>, Func<u4,Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to i8
Type: i8, Value: 260
*** Ctx ping count: 11
    [0](11): Sum(*1: u4s, If(Num<i8>(*1) !@= 5, Opt<i8?>(Mul(Num<i8>(*1), Num<i8>(*1))), null))
###
> bis->Sum (it * it if it != 5i4 else null)
bis->Sum(it * it if it !@= 5 else null) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum([map:1] Global(bis), If(Cmp(Scope(1) !@= 5:i), Opt<i?>(Mul(Scope(1), Scope(1))), null:i?)):i))
// (<ctx>, ∂.bis:i*) : i
Sum_1(Arr<obj>, ia):Opt<ia>
      1) ldarg.1 [ia]
      1) ldc.i4.5
      5) newobj ia(i4)
      5) call static ia::op_Inequality(ia, ia):bool
      5) brfalse [0]
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      5) newobj Opt<ia>(ia)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<ia>
  Label [1]:
      1) ret
  Total Size: 40

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<ia>, Func<ia,Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to i
Type: ia, Value: 260
*** Ctx ping count: 11
    [0](11): Sum(*1: bis, If(*1 !@= 5, Opt<i?>(Mul(*1, *1)), null))
###
> r8s->Mean(it * it if it != 5i4 else null)
r8s->Mean(it * it if it !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(r8s), If(Cmp(Scope(1) !@= 5:r8), Opt<r8?>(Mul(Scope(1), Scope(1))), null:r8?)):r8))
// (<ctx>, ∂.r8s:r8*) : r8
Mean_1(Arr<obj>, r8):Opt<r8>
      1) ldarg.1 [r8]
      9) ldc.r8 [5]
      5) call static NumUtil::Eq(r8, r8):bool
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 42

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, Func<r8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 28.88888888888889
*** Ctx ping count: 11
    [0](11): Mean(*1: r8s, If(*1 !@= 5, Opt<r8?>(Mul(*1, *1)), null))
###
> r4s->Mean(it * it if it != 5i4 else null)
r4s->Mean(it * it if it !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(r4s), If(Cmp(Scope(1) !@= 5:r4), Opt<r8?>(Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1)))), null:r8?)):r8))
// (<ctx>, ∂.r4s:r4*) : r8
Mean_1(Arr<obj>, r4):Opt<r8>
      1) ldarg.1 [r4]
      5) ldc.r4 [5]
      5) call static NumUtil::Eq(r4, r4):bool
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 40

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<r4>, Func<r4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 28.88888888888889
*** Ctx ping count: 11
    [0](11): Mean(*1: r4s, If(*1 !@= 5, Opt<r8?>(Mul(Num<r8>(*1), Num<r8>(*1))), null))
###
> i8s->Mean(it * it if it != 5i4 else null)
i8s->Mean(it * it if it !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(i8s), Call(∂.Guard([guard:2] If(Cmp(Scope(1) !@= 5:i8), Opt<i8?>(Mul(Scope(1), Scope(1))), null:i8?), Num<r8>(Scope(2))):r8?)):r8))
// (<ctx>, ∂.i8s:i8*) : r8
Mean_1(Arr<obj>, i8):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.5
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      1) conv.r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 70

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i8>, Func<i8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to r8
Type: r8, Value: 28.88888888888889
*** Ctx ping count: 11
    [0](11): Mean(*1: i8s, Guard(?2: If(*1 !@= 5, Opt<i8?>(Mul(*1, *1)), null), Num<r8>(?2)))
###
> i4s->Mean(it * it if it != 5i4 else null)
i4s->Mean(it * it if it !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(i4s), Call(∂.Guard([guard:2] If(Cmp(Scope(1) !@= 5:i4), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))), null:i8?), Num<r8>(Scope(2))):r8?)):r8))
// (<ctx>, ∂.i4s:i4*) : r8
Mean_1(Arr<obj>, i4):Opt<r8>
      1) ldarg.1 [i4]
      1) ldc.i4.5
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      1) conv.r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 71

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i4>, Func<i4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to r8
Type: r8, Value: 28.88888888888889
*** Ctx ping count: 11
    [0](11): Mean(*1: i4s, Guard(?2: If(*1 !@= 5, Opt<i8?>(Mul(Num<i8>(*1), Num<i8>(*1))), null), Num<r8>(?2)))
###
> u8s->Mean(it * it if it != 5u8 else null)
u8s->Mean(it * it if it !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(u8s), Call(∂.Guard([guard:2] If(Cmp(Scope(1) !@= 5:u8), Opt<u8?>(Mul(Scope(1), Scope(1))), null:u8?), Num<r8>(Scope(2))):r8?)):r8))
// (<ctx>, ∂.u8s:u8*) : r8
Mean_1(Arr<obj>, u8):Opt<r8>
      1) ldarg.1 [u8]
      1) ldc.i4.5
      1) conv.u8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      5) newobj Opt<u8>(u8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<u8>
  Label [2]:
      1) stloc.1 [Opt<u8>]
      2) ldloca.s [Opt<u8> (1)]
      5) call Opt<u8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<u8> (1)]
      5) call Opt<u8>::GetValueOrDefault():u8
      1) stloc.0 [u8]
      1) ldloc.0 [u8]
      5) call static NumUtil::ToR8(u8):r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 74

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u8>, Func<u8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to r8
Type: r8, Value: 28.88888888888889
*** Ctx ping count: 11
    [0](11): Mean(*1: u8s, Guard(?2: If(*1 !@= 5, Opt<u8?>(Mul(*1, *1)), null), Num<r8>(?2)))
###
> u4s->Mean(it * it if it != 5i4 else null)
u4s->Mean(it * it if it !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(u4s), Call(∂.Guard([guard:2] If(Cmp(Num<i8>(Scope(1)) !@= 5:i8), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))), null:i8?), Num<r8>(Scope(2))):r8?)):r8))
// (<ctx>, ∂.u4s:u4*) : r8
Mean_1(Arr<obj>, u4):Opt<r8>
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldc.i4.5
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      1) conv.r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 73

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u4>, Func<u4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to r8
Type: r8, Value: 28.88888888888889
*** Ctx ping count: 11
    [0](11): Mean(*1: u4s, Guard(?2: If(Num<i8>(*1) !@= 5, Opt<i8?>(Mul(Num<i8>(*1), Num<i8>(*1))), null), Num<r8>(?2)))
###
> bis->Mean(it * it if it != 5i4 else null)
bis->Mean(it * it if it !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(bis), Call(∂.Guard([guard:2] If(Cmp(Scope(1) !@= 5:i), Opt<i?>(Mul(Scope(1), Scope(1))), null:i?), Num<r8>(Scope(2))):r8?)):r8))
// (<ctx>, ∂.bis:i*) : r8
Mean_1(Arr<obj>, ia):Opt<r8>
      1) ldarg.1 [ia]
      1) ldc.i4.5
      5) newobj ia(i4)
      5) call static ia::op_Inequality(ia, ia):bool
      5) brfalse [1]
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      5) newobj Opt<ia>(ia)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<ia>
  Label [2]:
      1) stloc.1 [Opt<ia>]
      2) ldloca.s [Opt<ia> (1)]
      5) call Opt<ia>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<ia> (1)]
      5) call Opt<ia>::GetValueOrDefault():ia
      1) stloc.0 [ia]
      1) ldloc.0 [ia]
      5) call static NumUtil::ToR8(ia):r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 82

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<ia>, Func<ia,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to r8
Type: r8, Value: 28.88888888888889
*** Ctx ping count: 11
    [0](11): Mean(*1: bis, Guard(?2: If(*1 !@= 5, Opt<i?>(Mul(*1, *1)), null), Num<r8>(?2)))
###
> r8s->Sum(it * #it if #it mod 2 != 0 else null)
r8s->Sum(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum([map:2] Global(r8s), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<r8?>(Mul(Scope(2), Num<r8>(Scope(1)))), null:r8?)):r8))
// (<ctx>, ∂.r8s:r8*) : r8
Sum_1(Arr<obj>, i8, r8):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [r8]
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 36

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<r8>, Func<i8,r8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 165
*** Ctx ping count: 11
    [0](11): Sum(*2: r8s, If(IntMod(#1, 2) !@= 0, Opt<r8?>(Mul(*2, Num<r8>(#1))), null))
###
> r4s->Sum(it * #it if #it mod 2 != 0 else null)
r4s->Sum(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum([map:2] Global(r4s), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<r8?>(Mul(Num<r8>(Scope(2)), Num<r8>(Scope(1)))), null:r8?)):r8))
// (<ctx>, ∂.r4s:r4*) : r8
Sum_1(Arr<obj>, i8, r4):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [r4]
      1) conv.r8
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 37

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<r4>, Func<i8,r4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 165
*** Ctx ping count: 11
    [0](11): Sum(*2: r4s, If(IntMod(#1, 2) !@= 0, Opt<r8?>(Mul(Num<r8>(*2), Num<r8>(#1))), null))
###
> i8s->Sum(it * #it if #it mod 2 != 0 else null)
i8s->Sum(it * #it if #it mod 2 !@= 0 else null) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:2] Global(i8s), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Scope(2), Scope(1))), null:i8?)):i8))
// (<ctx>, ∂.i8s:i8*) : i8
Sum_1(Arr<obj>, i8, i8):Opt<i8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [i8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [1]:
      1) ret
  Total Size: 35

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i8,Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<i8>, Func<i8,i8,Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to i8
Type: i8, Value: 165
*** Ctx ping count: 11
    [0](11): Sum(*2: i8s, If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(*2, #1)), null))
###
> i4s->Sum(it * #it if #it mod 2 != 0 else null)
i4s->Sum(it * #it if #it mod 2 !@= 0 else null) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:2] Global(i4s), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Num<i8>(Scope(2)), Scope(1))), null:i8?)):i8))
// (<ctx>, ∂.i4s:i4*) : i8
Sum_1(Arr<obj>, i8, i4):Opt<i8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [i4]
      1) conv.i8
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [1]:
      1) ret
  Total Size: 36

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i4,Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<i4>, Func<i8,i4,Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to i8
Type: i8, Value: 165
*** Ctx ping count: 11
    [0](11): Sum(*2: i4s, If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(Num<i8>(*2), #1)), null))
###
> u8s->Sum(it * #it if #it mod 2 != 0 else null)
u8s->Sum(it * #it if #it mod 2 !@= 0 else null) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:2] Global(u8s), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Num<i8>(Scope(2)), Scope(1))), null:i8?)):i8))
*** Warning: (9,11) Node: it, Message: Conversion from unsigned to signed integer can reinterpret large values as negative
// (<ctx>, ∂.u8s:u8*) : i8
Sum_1(Arr<obj>, i8, u8):Opt<i8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [1]:
      1) ret
  Total Size: 35

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<u8>, Func<i8,u8,Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to i8
Type: i8, Value: 165
*** Ctx ping count: 11
    [0](11): Sum(*2: u8s, If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(Num<i8>(*2), #1)), null))
###
> u8s->Sum(it * CastU8(#it) if #it mod 2 != 0 else null)
u8s->Sum(it * CastU8(#it) if #it mod 2 !@= 0 else null) : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum([map:2] Global(u8s), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<u8?>(Mul(Scope(2), Call(∂.CastU8(Scope(1)):u8))), null:u8?)):u8))
// (<ctx>, ∂.u8s:u8*) : u8
Sum_1(Arr<obj>, i8, u8):Opt<u8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<u8>(u8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<u8>
  Label [1]:
      1) ret
  Total Size: 35

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<u8>, Func<i8,u8,Opt<u8>>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to u8
Type: u8, Value: 165
*** Ctx ping count: 11
    [0](11): Sum(*2: u8s, If(IntMod(#1, 2) !@= 0, Opt<u8?>(Mul(*2, CastU8(#1))), null))
###
> u4s->Sum(it * #it if #it mod 2 != 0 else null)
u4s->Sum(it * #it if #it mod 2 !@= 0 else null) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:2] Global(u4s), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Num<i8>(Scope(2)), Scope(1))), null:i8?)):i8))
// (<ctx>, ∂.u4s:u4*) : i8
Sum_1(Arr<obj>, i8, u4):Opt<i8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [u4]
      1) conv.u8
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [1]:
      1) ret
  Total Size: 36

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u4,Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<u4>, Func<i8,u4,Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to i8
Type: i8, Value: 165
*** Ctx ping count: 11
    [0](11): Sum(*2: u4s, If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(Num<i8>(*2), #1)), null))
###
> bis->Sum(it * #it if #it mod 2 != 0 else null)
bis->Sum(it * #it if #it mod 2 !@= 0 else null) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum([map:2] Global(bis), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i?>(Mul(Scope(2), Num<i>(Scope(1)))), null:i?)):i))
// (<ctx>, ∂.bis:i*) : i
Sum_1(Arr<obj>, i8, ia):Opt<ia>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [ia]
      1) ldarg.1 [i8]
      5) newobj ia(i8)
      5) call static ia::op_Multiply(ia, ia):ia
      5) newobj Opt<ia>(ia)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<ia>
  Label [1]:
      1) ret
  Total Size: 44

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,ia,Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<ia>, Func<i8,ia,Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to i
Type: ia, Value: 165
*** Ctx ping count: 11
    [0](11): Sum(*2: bis, If(IntMod(#1, 2) !@= 0, Opt<i?>(Mul(*2, Num<i>(#1))), null))
###
> r8s->SumBig(it * #it if #it mod 2 != 0 else null)
r8s->SumBig(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig([map:2] Global(r8s), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<r8?>(Mul(Scope(2), Num<r8>(Scope(1)))), null:r8?)):r8))
// (<ctx>, ∂.r8s:r8*) : r8
SumBig_1(Arr<obj>, i8, r8):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [r8]
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 36

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<r8>, Func<i8,r8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 165
*** Ctx ping count: 11
    [0](11): SumBig(*2: r8s, If(IntMod(#1, 2) !@= 0, Opt<r8?>(Mul(*2, Num<r8>(#1))), null))
###
> r4s->SumBig(it * #it if #it mod 2 != 0 else null)
r4s->SumBig(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig([map:2] Global(r4s), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<r8?>(Mul(Num<r8>(Scope(2)), Num<r8>(Scope(1)))), null:r8?)):r8))
// (<ctx>, ∂.r4s:r4*) : r8
SumBig_1(Arr<obj>, i8, r4):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [r4]
      1) conv.r8
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 37

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<r4>, Func<i8,r4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 165
*** Ctx ping count: 11
    [0](11): SumBig(*2: r4s, If(IntMod(#1, 2) !@= 0, Opt<r8?>(Mul(Num<r8>(*2), Num<r8>(#1))), null))
###
> i8s->SumBig(it * #it if #it mod 2 != 0 else null)
i8s->SumBig(it * #it if #it mod 2 !@= 0 else null) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:2] Global(i8s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Scope(2), Scope(1))), null:i8?), Num<i>(Scope(3))):i?)):i))
// (<ctx>, ∂.i8s:i8*) : i
SumBig_1(Arr<obj>, i8, i8):Opt<ia>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [i8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      5) newobj ia(i8)
      5) newobj Opt<ia>(ia)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<ia>
  Label [3]:
      1) ret
  Total Size: 77

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i8,Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<i8>, Func<i8,i8,Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to i
Type: ia, Value: 165
*** Ctx ping count: 11
    [0](11): SumBig(*2: i8s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(*2, #1)), null), Num<i>(?3)))
###
> i4s->SumBig(it * #it if #it mod 2 != 0 else null)
i4s->SumBig(it * #it if #it mod 2 !@= 0 else null) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:2] Global(i4s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Num<i8>(Scope(2)), Scope(1))), null:i8?), Num<i>(Scope(3))):i?)):i))
// (<ctx>, ∂.i4s:i4*) : i
SumBig_1(Arr<obj>, i8, i4):Opt<ia>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [i4]
      1) conv.i8
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      5) newobj ia(i8)
      5) newobj Opt<ia>(ia)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<ia>
  Label [3]:
      1) ret
  Total Size: 78

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i4,Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<i4>, Func<i8,i4,Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to i
Type: ia, Value: 165
*** Ctx ping count: 11
    [0](11): SumBig(*2: i4s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(Num<i8>(*2), #1)), null), Num<i>(?3)))
###
> u8s->SumBig(it * #it if #it mod 2 != 0 else null)
u8s->SumBig(it * #it if #it mod 2 !@= 0 else null) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:2] Global(u8s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Num<i8>(Scope(2)), Scope(1))), null:i8?), Num<i>(Scope(3))):i?)):i))
*** Warning: (12,14) Node: it, Message: Conversion from unsigned to signed integer can reinterpret large values as negative
// (<ctx>, ∂.u8s:u8*) : i
SumBig_1(Arr<obj>, i8, u8):Opt<ia>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      5) newobj ia(i8)
      5) newobj Opt<ia>(ia)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<ia>
  Label [3]:
      1) ret
  Total Size: 77

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<u8>, Func<i8,u8,Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to i
Type: ia, Value: 165
*** Ctx ping count: 11
    [0](11): SumBig(*2: u8s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(Num<i8>(*2), #1)), null), Num<i>(?3)))
###
> u8s->SumBig(it * CastU8(#it) if #it mod 2 != 0 else null)
u8s->SumBig(it * CastU8(#it) if #it mod 2 !@= 0 else null) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:2] Global(u8s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<u8?>(Mul(Scope(2), Call(∂.CastU8(Scope(1)):u8))), null:u8?), Num<i>(Scope(3))):i?)):i))
// (<ctx>, ∂.u8s:u8*) : i
SumBig_1(Arr<obj>, i8, u8):Opt<ia>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<u8>(u8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<u8>
  Label [2]:
      1) stloc.1 [Opt<u8>]
      2) ldloca.s [Opt<u8> (1)]
      5) call Opt<u8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<u8> (1)]
      5) call Opt<u8>::GetValueOrDefault():u8
      1) stloc.0 [u8]
      1) ldloc.0 [u8]
      5) newobj ia(u8)
      5) newobj Opt<ia>(ia)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<ia>
  Label [3]:
      1) ret
  Total Size: 77

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<u8>, Func<i8,u8,Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to i
Type: ia, Value: 165
*** Ctx ping count: 11
    [0](11): SumBig(*2: u8s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<u8?>(Mul(*2, CastU8(#1))), null), Num<i>(?3)))
###
> u4s->SumBig(it * #it if #it mod 2 != 0 else null)
u4s->SumBig(it * #it if #it mod 2 !@= 0 else null) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:2] Global(u4s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Num<i8>(Scope(2)), Scope(1))), null:i8?), Num<i>(Scope(3))):i?)):i))
// (<ctx>, ∂.u4s:u4*) : i
SumBig_1(Arr<obj>, i8, u4):Opt<ia>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [u4]
      1) conv.u8
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      5) newobj ia(i8)
      5) newobj Opt<ia>(ia)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<ia>
  Label [3]:
      1) ret
  Total Size: 78

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u4,Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<u4>, Func<i8,u4,Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to i
Type: ia, Value: 165
*** Ctx ping count: 11
    [0](11): SumBig(*2: u4s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(Num<i8>(*2), #1)), null), Num<i>(?3)))
###
> bis->SumBig(it * #it if #it mod 2 != 0 else null)
bis->SumBig(it * #it if #it mod 2 !@= 0 else null) : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig([map:2] Global(bis), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i?>(Mul(Scope(2), Num<i>(Scope(1)))), null:i?)):i))
// (<ctx>, ∂.bis:i*) : i
SumBig_1(Arr<obj>, i8, ia):Opt<ia>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [ia]
      1) ldarg.1 [i8]
      5) newobj ia(i8)
      5) call static ia::op_Multiply(ia, ia):ia
      5) newobj Opt<ia>(ia)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<ia>
  Label [1]:
      1) ret
  Total Size: 44

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,ia,Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecInd(Seq<ia>, Func<i8,ia,Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to i
Type: ia, Value: 165
*** Ctx ping count: 11
    [0](11): SumBig(*2: bis, If(IntMod(#1, 2) !@= 0, Opt<i?>(Mul(*2, Num<i>(#1))), null))
###
> r8s->SumK(it * #it if #it mod 2 != 0 else null)
r8s->SumK(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(r8s), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<r8?>(Mul(Scope(2), Num<r8>(Scope(1)))), null:r8?)):r8))
// (<ctx>, ∂.r8s:r8*) : r8
SumK_1(Arr<obj>, i8, r8):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [r8]
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 36

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<r8>, Func<i8,r8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 165
*** Ctx ping count: 11
    [0](11): SumK(*2: r8s, If(IntMod(#1, 2) !@= 0, Opt<r8?>(Mul(*2, Num<r8>(#1))), null))
###
> r4s->SumK(it * #it if #it mod 2 != 0 else null)
r4s->SumK(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(r4s), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<r8?>(Mul(Num<r8>(Scope(2)), Num<r8>(Scope(1)))), null:r8?)):r8))
// (<ctx>, ∂.r4s:r4*) : r8
SumK_1(Arr<obj>, i8, r4):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [r4]
      1) conv.r8
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 37

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<r4>, Func<i8,r4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 165
*** Ctx ping count: 11
    [0](11): SumK(*2: r4s, If(IntMod(#1, 2) !@= 0, Opt<r8?>(Mul(Num<r8>(*2), Num<r8>(#1))), null))
###
> i8s->SumK(it * #it if #it mod 2 != 0 else null)
i8s->SumK(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(i8s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Scope(2), Scope(1))), null:i8?), Num<r8>(Scope(3))):r8?)):r8))
// (<ctx>, ∂.i8s:i8*) : r8
SumK_1(Arr<obj>, i8, i8):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [i8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      1) conv.r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 73

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<i8>, Func<i8,i8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to r8
Type: r8, Value: 165
*** Ctx ping count: 11
    [0](11): SumK(*2: i8s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(*2, #1)), null), Num<r8>(?3)))
###
> i4s->SumK(it * #it if #it mod 2 != 0 else null)
i4s->SumK(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(i4s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Num<i8>(Scope(2)), Scope(1))), null:i8?), Num<r8>(Scope(3))):r8?)):r8))
// (<ctx>, ∂.i4s:i4*) : r8
SumK_1(Arr<obj>, i8, i4):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [i4]
      1) conv.i8
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      1) conv.r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 74

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<i4>, Func<i8,i4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to r8
Type: r8, Value: 165
*** Ctx ping count: 11
    [0](11): SumK(*2: i4s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(Num<i8>(*2), #1)), null), Num<r8>(?3)))
###
> u8s->SumK(it * #it if #it mod 2 != 0 else null)
u8s->SumK(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(u8s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Num<i8>(Scope(2)), Scope(1))), null:i8?), Num<r8>(Scope(3))):r8?)):r8))
*** Warning: (10,12) Node: it, Message: Conversion from unsigned to signed integer can reinterpret large values as negative
// (<ctx>, ∂.u8s:u8*) : r8
SumK_1(Arr<obj>, i8, u8):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      1) conv.r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 73

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<u8>, Func<i8,u8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to r8
Type: r8, Value: 165
*** Ctx ping count: 11
    [0](11): SumK(*2: u8s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(Num<i8>(*2), #1)), null), Num<r8>(?3)))
###
> u8s->SumK(it * CastU8(#it) if #it mod 2 != 0 else null)
u8s->SumK(it * CastU8(#it) if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(u8s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<u8?>(Mul(Scope(2), Call(∂.CastU8(Scope(1)):u8))), null:u8?), Num<r8>(Scope(3))):r8?)):r8))
// (<ctx>, ∂.u8s:u8*) : r8
SumK_1(Arr<obj>, i8, u8):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<u8>(u8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<u8>
  Label [2]:
      1) stloc.1 [Opt<u8>]
      2) ldloca.s [Opt<u8> (1)]
      5) call Opt<u8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<u8> (1)]
      5) call Opt<u8>::GetValueOrDefault():u8
      1) stloc.0 [u8]
      1) ldloc.0 [u8]
      5) call static NumUtil::ToR8(u8):r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 77

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<u8>, Func<i8,u8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to r8
Type: r8, Value: 165
*** Ctx ping count: 11
    [0](11): SumK(*2: u8s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<u8?>(Mul(*2, CastU8(#1))), null), Num<r8>(?3)))
###
> u4s->SumK(it * #it if #it mod 2 != 0 else null)
u4s->SumK(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(u4s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Num<i8>(Scope(2)), Scope(1))), null:i8?), Num<r8>(Scope(3))):r8?)):r8))
// (<ctx>, ∂.u4s:u4*) : r8
SumK_1(Arr<obj>, i8, u4):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [u4]
      1) conv.u8
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      1) conv.r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 74

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<u4>, Func<i8,u4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to r8
Type: r8, Value: 165
*** Ctx ping count: 11
    [0](11): SumK(*2: u4s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(Num<i8>(*2), #1)), null), Num<r8>(?3)))
###
> bis->SumK(it * #it if #it mod 2 != 0 else null)
bis->SumK(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK([map:2] Global(bis), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i?>(Mul(Scope(2), Num<i>(Scope(1)))), null:i?), Num<r8>(Scope(3))):r8?)):r8))
// (<ctx>, ∂.bis:i*) : r8
SumK_1(Arr<obj>, i8, ia):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [ia]
      1) ldarg.1 [i8]
      5) newobj ia(i8)
      5) call static ia::op_Multiply(ia, ia):ia
      5) newobj Opt<ia>(ia)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<ia>
  Label [2]:
      1) stloc.1 [Opt<ia>]
      2) ldloca.s [Opt<ia> (1)]
      5) call Opt<ia>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<ia> (1)]
      5) call Opt<ia>::GetValueOrDefault():ia
      1) stloc.0 [ia]
      1) ldloc.0 [ia]
      5) call static NumUtil::ToR8(ia):r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 86

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,ia,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndK(Seq<ia>, Func<i8,ia,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to r8
Type: r8, Value: 165
*** Ctx ping count: 11
    [0](11): SumK(*2: bis, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<i?>(Mul(*2, Num<i>(#1))), null), Num<r8>(?3)))
###
> r8s->Mean(it * #it if #it mod 2 != 0 else null)
r8s->Mean(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(r8s), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<r8?>(Mul(Scope(2), Num<r8>(Scope(1)))), null:r8?)):r8))
// (<ctx>, ∂.r8s:r8*) : r8
Mean_1(Arr<obj>, i8, r8):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [r8]
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 36

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<r8>, Func<i8,r8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8s:r8*) to r8
Type: r8, Value: 33
*** Ctx ping count: 11
    [0](11): Mean(*2: r8s, If(IntMod(#1, 2) !@= 0, Opt<r8?>(Mul(*2, Num<r8>(#1))), null))
###
> r4s->Mean(it * #it if #it mod 2 != 0 else null)
r4s->Mean(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(r4s), If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<r8?>(Mul(Num<r8>(Scope(2)), Num<r8>(Scope(1)))), null:r8?)):r8))
// (<ctx>, ∂.r4s:r4*) : r8
Mean_1(Arr<obj>, i8, r4):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.2 [r4]
      1) conv.r8
      1) ldarg.1 [i8]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 37

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<r4>, Func<i8,r4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4s:r4*) to r8
Type: r8, Value: 33
*** Ctx ping count: 11
    [0](11): Mean(*2: r4s, If(IntMod(#1, 2) !@= 0, Opt<r8?>(Mul(Num<r8>(*2), Num<r8>(#1))), null))
###
> i8s->Mean(it * #it if #it mod 2 != 0 else null)
i8s->Mean(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(i8s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Scope(2), Scope(1))), null:i8?), Num<r8>(Scope(3))):r8?)):r8))
// (<ctx>, ∂.i8s:i8*) : r8
Mean_1(Arr<obj>, i8, i8):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [i8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      1) conv.r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 73

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<i8>, Func<i8,i8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8s:i8*) to r8
Type: r8, Value: 33
*** Ctx ping count: 11
    [0](11): Mean(*2: i8s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(*2, #1)), null), Num<r8>(?3)))
###
> i4s->Mean(it * #it if #it mod 2 != 0 else null)
i4s->Mean(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(i4s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Num<i8>(Scope(2)), Scope(1))), null:i8?), Num<r8>(Scope(3))):r8?)):r8))
// (<ctx>, ∂.i4s:i4*) : r8
Mean_1(Arr<obj>, i8, i4):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [i4]
      1) conv.i8
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      1) conv.r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 74

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<i4>, Func<i8,i4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4s:i4*) to r8
Type: r8, Value: 33
*** Ctx ping count: 11
    [0](11): Mean(*2: i4s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(Num<i8>(*2), #1)), null), Num<r8>(?3)))
###
> u8s->Mean(it * #it if #it mod 2 != 0 else null)
u8s->Mean(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(u8s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Num<i8>(Scope(2)), Scope(1))), null:i8?), Num<r8>(Scope(3))):r8?)):r8))
*** Warning: (10,12) Node: it, Message: Conversion from unsigned to signed integer can reinterpret large values as negative
// (<ctx>, ∂.u8s:u8*) : r8
Mean_1(Arr<obj>, i8, u8):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      1) conv.r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 73

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<u8>, Func<i8,u8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to r8
Type: r8, Value: 33
*** Ctx ping count: 11
    [0](11): Mean(*2: u8s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(Num<i8>(*2), #1)), null), Num<r8>(?3)))
###
> u8s->Mean(it * CastU8(#it) if #it mod 2 != 0 else null)
u8s->Mean(it * CastU8(#it) if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(u8s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<u8?>(Mul(Scope(2), Call(∂.CastU8(Scope(1)):u8))), null:u8?), Num<r8>(Scope(3))):r8?)):r8))
// (<ctx>, ∂.u8s:u8*) : r8
Mean_1(Arr<obj>, i8, u8):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [u8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<u8>(u8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<u8>
  Label [2]:
      1) stloc.1 [Opt<u8>]
      2) ldloca.s [Opt<u8> (1)]
      5) call Opt<u8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<u8> (1)]
      5) call Opt<u8>::GetValueOrDefault():u8
      1) stloc.0 [u8]
      1) ldloc.0 [u8]
      5) call static NumUtil::ToR8(u8):r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 77

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<u8>, Func<i8,u8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8s:u8*) to r8
Type: r8, Value: 33
*** Ctx ping count: 11
    [0](11): Mean(*2: u8s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<u8?>(Mul(*2, CastU8(#1))), null), Num<r8>(?3)))
###
> u4s->Mean(it * #it if #it mod 2 != 0 else null)
u4s->Mean(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(u4s), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i8?>(Mul(Num<i8>(Scope(2)), Scope(1))), null:i8?), Num<r8>(Scope(3))):r8?)):r8))
// (<ctx>, ∂.u4s:u4*) : r8
Mean_1(Arr<obj>, i8, u4):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [u4]
      1) conv.u8
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      1) conv.r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 74

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,u4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<u4>, Func<i8,u4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4s:u4*) to r8
Type: r8, Value: 33
*** Ctx ping count: 11
    [0](11): Mean(*2: u4s, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<i8?>(Mul(Num<i8>(*2), #1)), null), Num<r8>(?3)))
###
> bis->Mean(it * #it if #it mod 2 != 0 else null)
bis->Mean(it * #it if #it mod 2 !@= 0 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:2] Global(bis), Call(∂.Guard([guard:3] If(Cmp(IntMod(Scope(1), 2:i8) !@= 0:i8), Opt<i?>(Mul(Scope(2), Num<i>(Scope(1)))), null:i?), Num<r8>(Scope(3))):r8?)):r8))
// (<ctx>, ∂.bis:i*) : r8
Mean_1(Arr<obj>, i8, ia):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.2
      1) conv.i8
      1) rem
      1) ldc.i4.0
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.2 [ia]
      1) ldarg.1 [i8]
      5) newobj ia(i8)
      5) call static ia::op_Multiply(ia, ia):ia
      5) newobj Opt<ia>(ia)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<ia>
  Label [2]:
      1) stloc.1 [Opt<ia>]
      2) ldloca.s [Opt<ia> (1)]
      5) call Opt<ia>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<ia> (1)]
      5) call Opt<ia>::GetValueOrDefault():ia
      1) stloc.0 [ia]
      1) ldloc.0 [ia]
      5) call static NumUtil::ToR8(ia):r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 86

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,ia,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecIndMean(Seq<ia>, Func<i8,ia,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bis:i*) to r8
Type: r8, Value: 33
*** Ctx ping count: 11
    [0](11): Mean(*2: bis, Guard(?3: If(IntMod(#1, 2) !@= 0, Opt<i?>(Mul(*2, Num<i>(#1))), null), Num<r8>(?3)))
###
> Sum (a: r8s, b: i2s, Opt(a * b))
Sum(a : r8s, b : i2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2s), Opt<r8?>(Mul(Scope(1), Num<r8>(Scope(2))))):r8?*)):r8))
// (<ctx>, ∂.r8s:r8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):Opt<r8>
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8s:r8*, i2s:i2*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: r8s, *2: i2s, Opt<r8?>(Mul(*1, Num<r8>(*2)))))
###
> Sum (a: r4s, b: i2s, Opt(a * b))
Sum(a : r4s, b : i2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2s), Opt<r8?>(Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2))))):r8?*)):r8))
// (<ctx>, ∂.r4s:r4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):Opt<r8>
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4s:r4*, i2s:i2*) to r8
Type: r8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: r4s, *2: i2s, Opt<r8?>(Mul(Num<r8>(*1), Num<r8>(*2)))))
###
> Sum (a: i8s, b: i2s, Opt(a * b))
Sum(a : i8s, b : i2s, Opt(a * b)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2s), Opt<i8?>(Mul(Scope(1), Num<i8>(Scope(2))))):i8?*)):i8))
// (<ctx>, ∂.i8s:i8*, ∂.i2s:i2*) : i8
ForEach_2(Arr<obj>, i8, i2):Opt<i8>
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,Opt<i8>>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,Opt<i8>>):Seq<Opt<i8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<i8>>):Seq<Opt<i8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8s:i8*, i2s:i2*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: i8s, *2: i2s, Opt<i8?>(Mul(*1, Num<i8>(*2)))))
###
> Sum (a: i4s, b: i2s, Opt(a * b))
Sum(a : i4s, b : i2s, Opt(a * b)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2s), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):i8?*)):i8))
// (<ctx>, ∂.i4s:i4*, ∂.i2s:i2*) : i8
ForEach_2(Arr<obj>, i4, i2):Opt<i8>
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,Opt<i8>>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,Opt<i8>>):Seq<Opt<i8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<i8>>):Seq<Opt<i8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4s:i4*, i2s:i2*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: i4s, *2: i2s, Opt<i8?>(Mul(Num<i8>(*1), Num<i8>(*2)))))
###
> Sum (a: u8s, b: u2s, Opt(a * b))
Sum(a : u8s, b : u2s, Opt(a * b)) : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2s), Opt<u8?>(Mul(Scope(1), Num<u8>(Scope(2))))):u8?*)):u8))
// (<ctx>, ∂.u8s:u8*, ∂.u2s:u2*) : u8
ForEach_2(Arr<obj>, u8, u2):Opt<u8>
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) newobj Opt<u8>(u8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,Opt<u8>>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,Opt<u8>>):Seq<Opt<u8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<u8>>):Seq<Opt<u8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<u8>>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8s:u8*, u2s:u2*) to u8
Type: u8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: u8s, *2: u2s, Opt<u8?>(Mul(*1, Num<u8>(*2)))))
###
> Sum (a: u4s, b: u2s, Opt(a * b))
Sum(a : u4s, b : u2s, Opt(a * b)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2s), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):i8?*)):i8))
// (<ctx>, ∂.u4s:u4*, ∂.u2s:u2*) : i8
ForEach_2(Arr<obj>, u4, u2):Opt<i8>
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,Opt<i8>>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,Opt<i8>>):Seq<Opt<i8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<i8>>):Seq<Opt<i8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4s:u4*, u2s:u2*) to i8
Type: i8, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: u4s, *2: u2s, Opt<i8?>(Mul(Num<i8>(*1), Num<i8>(*2)))))
###
> Sum (a: bis, b: i2s, Opt(a * b))
Sum(a : bis, b : i2s, Opt(a * b)) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2s), Opt<i?>(Mul(Scope(1), Num<i>(Scope(2))))):i?*)):i))
// (<ctx>, ∂.bis:i*, ∂.i2s:i2*) : i
ForEach_2(Arr<obj>, ia, i2):Opt<ia>
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      5) newobj Opt<ia>(ia)
      1) ret
  Total Size: 18

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,Opt<ia>>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,Opt<ia>>):Seq<Opt<ia>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<ia>>):Seq<Opt<ia>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bis:i*, i2s:i2*) to i
Type: ia, Value: 285
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: bis, *2: i2s, Opt<i?>(Mul(*1, Num<i>(*2)))))
###
> Mean(a: r8s, b: i2s, Opt(a * b))
Mean(a : r8s, b : i2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2s), Opt<r8?>(Mul(Scope(1), Num<r8>(Scope(2))))):r8?*)):r8))
// (<ctx>, ∂.r8s:r8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):Opt<r8>
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8s:r8*, i2s:i2*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: r8s, *2: i2s, Opt<r8?>(Mul(*1, Num<r8>(*2)))))
###
> Mean(a: r4s, b: i2s, Opt(a * b))
Mean(a : r4s, b : i2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2s), Opt<r8?>(Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2))))):r8?*)):r8))
// (<ctx>, ∂.r4s:r4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):Opt<r8>
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4s:r4*, i2s:i2*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: r4s, *2: i2s, Opt<r8?>(Mul(Num<r8>(*1), Num<r8>(*2)))))
###
> Mean(a: i8s, b: i2s, Opt(a * b))
Mean(a : i8s, b : i2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2s), Opt<r8?>(Num<r8>(Mul(Scope(1), Num<i8>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.i8s:i8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, i8, i2):Opt<r8>
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8s:i8*, i2s:i2*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: i8s, *2: i2s, Opt<r8?>(Num<r8>(Mul(*1, Num<i8>(*2))))))
###
> Mean(a: i4s, b: i2s, Opt(a * b))
Mean(a : i4s, b : i2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2s), Opt<r8?>(Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.i4s:i4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, i4, i2):Opt<r8>
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 12

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4s:i4*, i2s:i2*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: i4s, *2: i2s, Opt<r8?>(Num<r8>(Mul(Num<i8>(*1), Num<i8>(*2))))))
###
> Mean(a: u8s, b: u2s, Opt(a * b))
Mean(a : u8s, b : u2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2s), Opt<r8?>(Num<r8>(Mul(Scope(1), Num<u8>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.u8s:u8*, ∂.u2s:u2*) : r8
ForEach_2(Arr<obj>, u8, u2):Opt<r8>
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 15

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8s:u8*, u2s:u2*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: u8s, *2: u2s, Opt<r8?>(Num<r8>(Mul(*1, Num<u8>(*2))))))
###
> Mean(a: u4s, b: u2s, Opt(a * b))
Mean(a : u4s, b : u2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2s), Opt<r8?>(Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.u4s:u4*, ∂.u2s:u2*) : r8
ForEach_2(Arr<obj>, u4, u2):Opt<r8>
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 12

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4s:u4*, u2s:u2*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: u4s, *2: u2s, Opt<r8?>(Num<r8>(Mul(Num<i8>(*1), Num<i8>(*2))))))
###
> Mean(a: bis, b: i2s, Opt(a * b))
Mean(a : bis, b : i2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2s), Opt<r8?>(Num<r8>(Mul(Scope(1), Num<i>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.bis:i*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, ia, i2):Opt<r8>
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 23

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bis:i*, i2s:i2*) to r8
Type: r8, Value: 28.5
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: bis, *2: i2s, Opt<r8?>(Num<r8>(Mul(*1, Num<i>(*2))))))
###
> Sum (a: r8s, b: i2s, a * b if a != 5i4 else null)
Sum(a : r8s, b : i2s, a * b if a !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2s), If(Cmp(Scope(1) !@= 5:r8), Opt<r8?>(Mul(Scope(1), Num<r8>(Scope(2)))), null:r8?)):r8?*)):r8))
// (<ctx>, ∂.r8s:r8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):Opt<r8>
      1) ldarg.1 [r8]
      9) ldc.r8 [5]
      5) call static NumUtil::Eq(r8, r8):bool
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 43

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8s:r8*, i2s:i2*) to r8
Type: r8, Value: 260
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: r8s, *2: i2s, If(*1 !@= 5, Opt<r8?>(Mul(*1, Num<r8>(*2))), null)))
###
> Sum (a: r4s, b: i2s, a * b if a != 5i4 else null)
Sum(a : r4s, b : i2s, a * b if a !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2s), If(Cmp(Scope(1) !@= 5:r4), Opt<r8?>(Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2)))), null:r8?)):r8?*)):r8))
// (<ctx>, ∂.r4s:r4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):Opt<r8>
      1) ldarg.1 [r4]
      5) ldc.r4 [5]
      5) call static NumUtil::Eq(r4, r4):bool
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 40

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4s:r4*, i2s:i2*) to r8
Type: r8, Value: 260
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: r4s, *2: i2s, If(*1 !@= 5, Opt<r8?>(Mul(Num<r8>(*1), Num<r8>(*2))), null)))
###
> Sum (a: i8s, b: i2s, a * b if a != 5i4 else null)
Sum(a : i8s, b : i2s, a * b if a !@= 5 else null) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2s), If(Cmp(Scope(1) !@= 5:i8), Opt<i8?>(Mul(Scope(1), Num<i8>(Scope(2)))), null:i8?)):i8?*)):i8))
// (<ctx>, ∂.i8s:i8*, ∂.i2s:i2*) : i8
ForEach_2(Arr<obj>, i8, i2):Opt<i8>
      1) ldarg.1 [i8]
      1) ldc.i4.5
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [1]:
      1) ret
  Total Size: 33

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,Opt<i8>>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,Opt<i8>>):Seq<Opt<i8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<i8>>):Seq<Opt<i8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8s:i8*, i2s:i2*) to i8
Type: i8, Value: 260
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: i8s, *2: i2s, If(*1 !@= 5, Opt<i8?>(Mul(*1, Num<i8>(*2))), null)))
###
> Sum (a: i4s, b: i2s, a * b if a != 5i4 else null)
Sum(a : i4s, b : i2s, a * b if a !@= 5 else null) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2s), If(Cmp(Scope(1) !@= 5:i4), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))), null:i8?)):i8?*)):i8))
// (<ctx>, ∂.i4s:i4*, ∂.i2s:i2*) : i8
ForEach_2(Arr<obj>, i4, i2):Opt<i8>
      1) ldarg.1 [i4]
      1) ldc.i4.5
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [1]:
      1) ret
  Total Size: 33

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,Opt<i8>>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,Opt<i8>>):Seq<Opt<i8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<i8>>):Seq<Opt<i8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4s:i4*, i2s:i2*) to i8
Type: i8, Value: 260
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: i4s, *2: i2s, If(*1 !@= 5, Opt<i8?>(Mul(Num<i8>(*1), Num<i8>(*2))), null)))
###
> Sum (a: u8s, b: u2s, a * b if a != 5u8 else null)
Sum(a : u8s, b : u2s, a * b if a !@= 5 else null) : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2s), If(Cmp(Scope(1) !@= 5:u8), Opt<u8?>(Mul(Scope(1), Num<u8>(Scope(2)))), null:u8?)):u8?*)):u8))
// (<ctx>, ∂.u8s:u8*, ∂.u2s:u2*) : u8
ForEach_2(Arr<obj>, u8, u2):Opt<u8>
      1) ldarg.1 [u8]
      1) ldc.i4.5
      1) conv.u8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) newobj Opt<u8>(u8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<u8>
  Label [1]:
      1) ret
  Total Size: 33

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,Opt<u8>>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,Opt<u8>>):Seq<Opt<u8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<u8>>):Seq<Opt<u8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<u8>>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8s:u8*, u2s:u2*) to u8
Type: u8, Value: 260
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: u8s, *2: u2s, If(*1 !@= 5, Opt<u8?>(Mul(*1, Num<u8>(*2))), null)))
###
> Sum (a: u4s, b: u2s, a * b if a != 5i4 else null)
Sum(a : u4s, b : u2s, a * b if a !@= 5 else null) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2s), If(Cmp(Num<i8>(Scope(1)) !@= 5:i8), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))), null:i8?)):i8?*)):i8))
// (<ctx>, ∂.u4s:u4*, ∂.u2s:u2*) : i8
ForEach_2(Arr<obj>, u4, u2):Opt<i8>
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldc.i4.5
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [1]:
      1) ret
  Total Size: 35

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,Opt<i8>>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,Opt<i8>>):Seq<Opt<i8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<i8>>):Seq<Opt<i8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4s:u4*, u2s:u2*) to i8
Type: i8, Value: 260
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: u4s, *2: u2s, If(Num<i8>(*1) !@= 5, Opt<i8?>(Mul(Num<i8>(*1), Num<i8>(*2))), null)))
###
> Sum (a: bis, b: i2s, a * b if a != 5i4 else null)
Sum(a : bis, b : i2s, a * b if a !@= 5 else null) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2s), If(Cmp(Scope(1) !@= 5:i), Opt<i?>(Mul(Scope(1), Num<i>(Scope(2)))), null:i?)):i?*)):i))
// (<ctx>, ∂.bis:i*, ∂.i2s:i2*) : i
ForEach_2(Arr<obj>, ia, i2):Opt<ia>
      1) ldarg.1 [ia]
      1) ldc.i4.5
      5) newobj ia(i4)
      5) call static ia::op_Inequality(ia, ia):bool
      5) brfalse [0]
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      5) newobj Opt<ia>(ia)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<ia>
  Label [1]:
      1) ret
  Total Size: 45

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,Opt<ia>>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,Opt<ia>>):Seq<Opt<ia>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<ia>>):Seq<Opt<ia>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bis:i*, i2s:i2*) to i
Type: ia, Value: 260
*** Ctx ping count: 11
    [0](11): Sum(ForEach(*1: bis, *2: i2s, If(*1 !@= 5, Opt<i?>(Mul(*1, Num<i>(*2))), null)))
###
> Mean(a: r8s, b: i2s, a * b if a != 5i4 else null)
Mean(a : r8s, b : i2s, a * b if a !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2s), If(Cmp(Scope(1) !@= 5:r8), Opt<r8?>(Mul(Scope(1), Num<r8>(Scope(2)))), null:r8?)):r8?*)):r8))
// (<ctx>, ∂.r8s:r8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):Opt<r8>
      1) ldarg.1 [r8]
      9) ldc.r8 [5]
      5) call static NumUtil::Eq(r8, r8):bool
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 43

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8s:r8*, i2s:i2*) to r8
Type: r8, Value: 28.88888888888889
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: r8s, *2: i2s, If(*1 !@= 5, Opt<r8?>(Mul(*1, Num<r8>(*2))), null)))
###
> Mean(a: r4s, b: i2s, a * b if a != 5i4 else null)
Mean(a : r4s, b : i2s, a * b if a !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2s), If(Cmp(Scope(1) !@= 5:r4), Opt<r8?>(Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2)))), null:r8?)):r8?*)):r8))
// (<ctx>, ∂.r4s:r4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):Opt<r8>
      1) ldarg.1 [r4]
      5) ldc.r4 [5]
      5) call static NumUtil::Eq(r4, r4):bool
      1) ldc.i4.0
      2) ceq
      5) brfalse [0]
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      5) br [1]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [1]:
      1) ret
  Total Size: 40

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4s:r4*, i2s:i2*) to r8
Type: r8, Value: 28.88888888888889
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: r4s, *2: i2s, If(*1 !@= 5, Opt<r8?>(Mul(Num<r8>(*1), Num<r8>(*2))), null)))
###
> Mean(a: i8s, b: i2s, a * b if a != 5i4 else null)
Mean(a : i8s, b : i2s, a * b if a !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2s), Call(∂.Guard([guard:3] If(Cmp(Scope(1) !@= 5:i8), Opt<i8?>(Mul(Scope(1), Num<i8>(Scope(2)))), null:i8?), Num<r8>(Scope(3))):r8?)):r8?*)):r8))
// (<ctx>, ∂.i8s:i8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, i8, i2):Opt<r8>
      1) ldarg.1 [i8]
      1) ldc.i4.5
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      1) conv.r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 71

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8s:i8*, i2s:i2*) to r8
Type: r8, Value: 28.88888888888889
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: i8s, *2: i2s, Guard(?3: If(*1 !@= 5, Opt<i8?>(Mul(*1, Num<i8>(*2))), null), Num<r8>(?3))))
###
> Mean(a: i4s, b: i2s, a * b if a != 5i4 else null)
Mean(a : i4s, b : i2s, a * b if a !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2s), Call(∂.Guard([guard:3] If(Cmp(Scope(1) !@= 5:i4), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))), null:i8?), Num<r8>(Scope(3))):r8?)):r8?*)):r8))
// (<ctx>, ∂.i4s:i4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, i4, i2):Opt<r8>
      1) ldarg.1 [i4]
      1) ldc.i4.5
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      1) conv.r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 71

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4s:i4*, i2s:i2*) to r8
Type: r8, Value: 28.88888888888889
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: i4s, *2: i2s, Guard(?3: If(*1 !@= 5, Opt<i8?>(Mul(Num<i8>(*1), Num<i8>(*2))), null), Num<r8>(?3))))
###
> Mean(a: u8s, b: u2s, a * b if a != 5u8 else null)
Mean(a : u8s, b : u2s, a * b if a !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2s), Call(∂.Guard([guard:3] If(Cmp(Scope(1) !@= 5:u8), Opt<u8?>(Mul(Scope(1), Num<u8>(Scope(2)))), null:u8?), Num<r8>(Scope(3))):r8?)):r8?*)):r8))
// (<ctx>, ∂.u8s:u8*, ∂.u2s:u2*) : r8
ForEach_2(Arr<obj>, u8, u2):Opt<r8>
      1) ldarg.1 [u8]
      1) ldc.i4.5
      1) conv.u8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) newobj Opt<u8>(u8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<u8>
  Label [2]:
      1) stloc.1 [Opt<u8>]
      2) ldloca.s [Opt<u8> (1)]
      5) call Opt<u8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<u8> (1)]
      5) call Opt<u8>::GetValueOrDefault():u8
      1) stloc.0 [u8]
      1) ldloc.0 [u8]
      5) call static NumUtil::ToR8(u8):r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 75

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8s:u8*, u2s:u2*) to r8
Type: r8, Value: 28.88888888888889
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: u8s, *2: u2s, Guard(?3: If(*1 !@= 5, Opt<u8?>(Mul(*1, Num<u8>(*2))), null), Num<r8>(?3))))
###
> Mean(a: u4s, b: u2s, a * b if a != 5i4 else null)
Mean(a : u4s, b : u2s, a * b if a !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2s), Call(∂.Guard([guard:3] If(Cmp(Num<i8>(Scope(1)) !@= 5:i8), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))), null:i8?), Num<r8>(Scope(3))):r8?)):r8?*)):r8))
// (<ctx>, ∂.u4s:u4*, ∂.u2s:u2*) : r8
ForEach_2(Arr<obj>, u4, u2):Opt<r8>
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldc.i4.5
      1) conv.i8
      2) ceq
      1) ldc.i4.0
      2) ceq
      5) brfalse [1]
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) newobj Opt<i8>(i8)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<i8>
  Label [2]:
      1) stloc.1 [Opt<i8>]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<i8> (1)]
      5) call Opt<i8>::GetValueOrDefault():i8
      1) stloc.0 [i8]
      1) ldloc.0 [i8]
      1) conv.r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 73

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4s:u4*, u2s:u2*) to r8
Type: r8, Value: 28.88888888888889
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: u4s, *2: u2s, Guard(?3: If(Num<i8>(*1) !@= 5, Opt<i8?>(Mul(Num<i8>(*1), Num<i8>(*2))), null), Num<r8>(?3))))
###
> Mean(a: bis, b: i2s, a * b if a != 5i4 else null)
Mean(a : bis, b : i2s, a * b if a !@= 5 else null) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2s), Call(∂.Guard([guard:3] If(Cmp(Scope(1) !@= 5:i), Opt<i?>(Mul(Scope(1), Num<i>(Scope(2)))), null:i?), Num<r8>(Scope(3))):r8?)):r8?*)):r8))
// (<ctx>, ∂.bis:i*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, ia, i2):Opt<r8>
      1) ldarg.1 [ia]
      1) ldc.i4.5
      5) newobj ia(i4)
      5) call static ia::op_Inequality(ia, ia):bool
      5) brfalse [1]
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      5) newobj Opt<ia>(ia)
      5) br [2]
  Label [1]:
      5) call static CodeGenUtil::GetDefault():Opt<ia>
  Label [2]:
      1) stloc.1 [Opt<ia>]
      2) ldloca.s [Opt<ia> (1)]
      5) call Opt<ia>::get_HasValue():bool
      5) brfalse [0]
      2) ldloca.s [Opt<ia> (1)]
      5) call Opt<ia>::GetValueOrDefault():ia
      1) stloc.0 [ia]
      1) ldloc.0 [ia]
      5) call static NumUtil::ToR8(ia):r8
      5) newobj Opt<r8>(r8)
      5) br [3]
  Label [0]:
      5) call static CodeGenUtil::GetDefault():Opt<r8>
  Label [3]:
      1) ret
  Total Size: 87

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bis:i*, i2s:i2*) to r8
Type: r8, Value: 28.88888888888889
*** Ctx ping count: 11
    [0](11): Mean(ForEach(*1: bis, *2: i2s, Guard(?3: If(*1 !@= 5, Opt<i?>(Mul(*1, Num<i>(*2))), null), Num<r8>(?3))))
###
> r8n->Sum()
r8n->Sum() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Global(r8n)):r8))
// (<ctx>, ∂.r8n:r8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r8n:r8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> r4n->Sum()
r4n->Sum() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Global(r4n)):r8))
// (<ctx>, ∂.r4n:r4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<r4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r4n:r4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i8n->Sum()
i8n->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(i8n)):i8))
// (<ctx>, ∂.i8n:i8*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i8n:i8*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> i4n->Sum()
i4n->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(i4n)):i8))
// (<ctx>, ∂.i4n:i4*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<i4>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i4n:i4*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> i2n->Sum()
i2n->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(i2n)):i8))
// (<ctx>, ∂.i2n:i2*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.1 [Seq<i2>]
      1) ldloc.1 [Seq<i2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<i2>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i2n:i2*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> i1n->Sum()
i1n->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(i1n)):i8))
// (<ctx>, ∂.i1n:i1*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i1>
      1) stloc.1 [Seq<i1>]
      1) ldloc.1 [Seq<i1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<i1>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i1n:i1*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> u8n->Sum()
u8n->Sum() : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum(Global(u8n)):u8))
// (<ctx>, ∂.u8n:u8*) : u8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<u8>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u8n:u8*) to u8
Type: u8, Value: 0
*** Ctx ping count: 0
###
> u4n->Sum()
u4n->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(u4n)):i8))
// (<ctx>, ∂.u4n:u4*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<u4>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u4n:u4*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> u2n->Sum()
u2n->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(u2n)):i8))
// (<ctx>, ∂.u2n:u2*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.1 [Seq<u2>]
      1) ldloc.1 [Seq<u2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<u2>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u2n:u2*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> u1n->Sum()
u1n->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(u1n)):i8))
// (<ctx>, ∂.u1n:u1*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u1>
      1) stloc.1 [Seq<u1>]
      1) ldloc.1 [Seq<u1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<u1>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u1n:u1*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> bn->Sum()
bn->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(bn)):i8))
// (<ctx>, ∂.bn:b*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<bool>
      1) stloc.1 [Seq<bool>]
      1) ldloc.1 [Seq<bool>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<bool>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bn:b*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> bin->Sum()
bin->Sum() : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum(Global(bin)):i))
// (<ctx>, ∂.bin:i*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bin:i*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> r8n->SumBig()
r8n->SumBig() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig(Global(r8n)):r8))
// (<ctx>, ∂.r8n:r8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r8n:r8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> r4n->SumBig()
r4n->SumBig() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig(Global(r4n)):r8))
// (<ctx>, ∂.r4n:r4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<r4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r4n:r4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i8n->SumBig()
i8n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(i8n)):i))
// (<ctx>, ∂.i8n:i8*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<i8>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i8n:i8*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> i4n->SumBig()
i4n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(i4n)):i))
// (<ctx>, ∂.i4n:i4*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<i4>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i4n:i4*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> i2n->SumBig()
i2n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(i2n)):i))
// (<ctx>, ∂.i2n:i2*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.1 [Seq<i2>]
      1) ldloc.1 [Seq<i2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<i2>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i2n:i2*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> i1n->SumBig()
i1n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(i1n)):i))
// (<ctx>, ∂.i1n:i1*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i1>
      1) stloc.1 [Seq<i1>]
      1) ldloc.1 [Seq<i1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<i1>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i1n:i1*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> u8n->SumBig()
u8n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(u8n)):i))
// (<ctx>, ∂.u8n:u8*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<u8>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u8n:u8*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> u4n->SumBig()
u4n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(u4n)):i))
// (<ctx>, ∂.u4n:u4*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<u4>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u4n:u4*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> u2n->SumBig()
u2n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(u2n)):i))
// (<ctx>, ∂.u2n:u2*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.1 [Seq<u2>]
      1) ldloc.1 [Seq<u2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<u2>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u2n:u2*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> u1n->SumBig()
u1n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(u1n)):i))
// (<ctx>, ∂.u1n:u1*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u1>
      1) stloc.1 [Seq<u1>]
      1) ldloc.1 [Seq<u1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<u1>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u1n:u1*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> bn->SumBig()
bn->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(bn)):i))
// (<ctx>, ∂.bn:b*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<bool>
      1) stloc.1 [Seq<bool>]
      1) ldloc.1 [Seq<bool>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<bool>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bn:b*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> bin->SumBig()
bin->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(bin)):i))
// (<ctx>, ∂.bin:i*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bin:i*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> r8n->SumK()
r8n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(r8n)):r8))
// (<ctx>, ∂.r8n:r8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r8n:r8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> r4n->SumK()
r4n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(r4n)):r8))
// (<ctx>, ∂.r4n:r4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<r4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r4n:r4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i8n->SumK()
i8n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(i8n)):r8))
// (<ctx>, ∂.i8n:i8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<i8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i8n:i8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i4n->SumK()
i4n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(i4n)):r8))
// (<ctx>, ∂.i4n:i4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<i4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i4n:i4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i2n->SumK()
i2n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(i2n)):r8))
// (<ctx>, ∂.i2n:i2*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.1 [Seq<i2>]
      1) ldloc.1 [Seq<i2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<i2>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i1n->SumK()
i1n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(i1n)):r8))
// (<ctx>, ∂.i1n:i1*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i1>
      1) stloc.1 [Seq<i1>]
      1) ldloc.1 [Seq<i1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<i1>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i1n:i1*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> u8n->SumK()
u8n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(u8n)):r8))
// (<ctx>, ∂.u8n:u8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<u8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u8n:u8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> u4n->SumK()
u4n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(u4n)):r8))
// (<ctx>, ∂.u4n:u4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<u4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u4n:u4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> u2n->SumK()
u2n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(u2n)):r8))
// (<ctx>, ∂.u2n:u2*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.1 [Seq<u2>]
      1) ldloc.1 [Seq<u2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<u2>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u2n:u2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> u1n->SumK()
u1n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(u1n)):r8))
// (<ctx>, ∂.u1n:u1*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u1>
      1) stloc.1 [Seq<u1>]
      1) ldloc.1 [Seq<u1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<u1>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u1n:u1*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> bin->SumK()
bin->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(bin)):r8))
// (<ctx>, ∂.bin:i*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<ia>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bin:i*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> r8n->Mean()
r8n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(r8n)):r8))
// (<ctx>, ∂.r8n:r8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r8n:r8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> r4n->Mean()
r4n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(r4n)):r8))
// (<ctx>, ∂.r4n:r4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<r4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, r4n:r4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i8n->Mean()
i8n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(i8n)):r8))
// (<ctx>, ∂.i8n:i8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i8n:i8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i4n->Mean()
i4n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(i4n)):r8))
// (<ctx>, ∂.i4n:i4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i4n:i4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i2n->Mean()
i2n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(i2n)):r8))
// (<ctx>, ∂.i2n:i2*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.1 [Seq<i2>]
      1) ldloc.1 [Seq<i2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i2>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i1n->Mean()
i1n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(i1n)):r8))
// (<ctx>, ∂.i1n:i1*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i1>
      1) stloc.1 [Seq<i1>]
      1) ldloc.1 [Seq<i1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i1>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, i1n:i1*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> u8n->Mean()
u8n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(u8n)):r8))
// (<ctx>, ∂.u8n:u8*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u8n:u8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> u4n->Mean()
u4n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(u4n)):r8))
// (<ctx>, ∂.u4n:u4*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u4>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u4n:u4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> u2n->Mean()
u2n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(u2n)):r8))
// (<ctx>, ∂.u2n:u2*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.1 [Seq<u2>]
      1) ldloc.1 [Seq<u2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u2>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u2n:u2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> u1n->Mean()
u1n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(u1n)):r8))
// (<ctx>, ∂.u1n:u1*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u1>
      1) stloc.1 [Seq<u1>]
      1) ldloc.1 [Seq<u1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u1>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, u1n:u1*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> bn->Mean()
bn->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(bn)):r8))
// (<ctx>, ∂.bn:b*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<bool>
      1) stloc.1 [Seq<bool>]
      1) ldloc.1 [Seq<bool>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<bool>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bn:b*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> bin->Mean()
bin->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(bin)):r8))
// (<ctx>, ∂.bin:i*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<ia>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, bin:i*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> r8n->Sum(it * it)
r8n->Sum(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum([map:1] Global(r8n), Mul(Scope(1), Scope(1))):r8))
// (<ctx>, ∂.r8n:r8*) : r8
Sum_1(Arr<obj>, r8):r8
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<r8>, Func<r8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8n:r8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> r4n->Sum(it * it)
r4n->Sum(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum([map:1] Global(r4n), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1)))):r8))
// (<ctx>, ∂.r4n:r4*) : r8
Sum_1(Arr<obj>, r4):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<r4>, Func<r4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4n:r4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i8n->Sum(it * it)
i8n->Sum(it * it) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(i8n), Mul(Scope(1), Scope(1))):i8))
// (<ctx>, ∂.i8n:i8*) : i8
Sum_1(Arr<obj>, i8):i8
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<i8>, Func<i8,i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8n:i8*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> i4n->Sum(it * it)
i4n->Sum(it * it) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(i4n), Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))):i8))
// (<ctx>, ∂.i4n:i4*) : i8
Sum_1(Arr<obj>, i4):i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<i4>, Func<i4,i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4n:i4*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> u8n->Sum(it * it)
u8n->Sum(it * it) : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum([map:1] Global(u8n), Mul(Scope(1), Scope(1))):u8))
// (<ctx>, ∂.u8n:u8*) : u8
Sum_1(Arr<obj>, u8):u8
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<u8>, Func<u8,u8>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8n:u8*) to u8
Type: u8, Value: 0
*** Ctx ping count: 0
###
> u4n->Sum(it * it)
u4n->Sum(it * it) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(u4n), Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))):i8))
// (<ctx>, ∂.u4n:u4*) : i8
Sum_1(Arr<obj>, u4):i8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<u4>, Func<u4,i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4n:u4*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> bin->Sum(it * it)
bin->Sum(it * it) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum([map:1] Global(bin), Mul(Scope(1), Scope(1))):i))
// (<ctx>, ∂.bin:i*) : i
Sum_1(Arr<obj>, ia):ia
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      1) ret
  Total Size: 8

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<ia>, Func<ia,ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bin:i*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> r8n->Mean(it * it)
r8n->Mean(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(r8n), Mul(Scope(1), Scope(1))):r8))
// (<ctx>, ∂.r8n:r8*) : r8
Mean_1(Arr<obj>, r8):r8
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, Func<r8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8n:r8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> r4n->Mean(it * it)
r4n->Mean(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(r4n), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1)))):r8))
// (<ctx>, ∂.r4n:r4*) : r8
Mean_1(Arr<obj>, r4):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<r4>, Func<r4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4n:r4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i8n->Mean(it * it)
i8n->Mean(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(i8n), Num<r8>(Mul(Scope(1), Scope(1)))):r8))
// (<ctx>, ∂.i8n:i8*) : r8
Mean_1(Arr<obj>, i8):r8
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i8>, Func<i8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8n:i8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i4n->Mean(it * it)
i4n->Mean(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(i4n), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1))))):r8))
// (<ctx>, ∂.i4n:i4*) : r8
Mean_1(Arr<obj>, i4):r8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i4>, Func<i4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4n:i4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> u8n->Mean(it * it)
u8n->Mean(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(u8n), Num<r8>(Mul(Scope(1), Scope(1)))):r8))
// (<ctx>, ∂.u8n:u8*) : r8
Mean_1(Arr<obj>, u8):r8
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u8>, Func<u8,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8n:u8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> u4n->Mean(it * it)
u4n->Mean(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(u4n), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1))))):r8))
// (<ctx>, ∂.u4n:u4*) : r8
Mean_1(Arr<obj>, u4):r8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u4>, Func<u4,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4n:u4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> bin->Mean(it * it)
bin->Mean(it * it) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(bin), Num<r8>(Mul(Scope(1), Scope(1)))):r8))
// (<ctx>, ∂.bin:i*) : r8
Mean_1(Arr<obj>, ia):r8
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<ia>, Func<ia,r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bin:i*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Sum(a: r8n, b: i2s, a * b)
Sum(a : r8n, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(r8n), [map:2] Global(i2s), Mul(Scope(1), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r8n:r8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):r8
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8n:r8*, i2s:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Sum(a: r4n, b: i2s, a * b)
Sum(a : r4n, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(r4n), [map:2] Global(i2s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r4n:r4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4n:r4*, i2s:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Sum(a: i8n, b: i2s, a * b)
Sum(a : i8n, b : i2s, a * b) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(i8n), [map:2] Global(i2s), Mul(Scope(1), Num<i8>(Scope(2)))):i8*)):i8))
// (<ctx>, ∂.i8n:i8*, ∂.i2s:i2*) : i8
ForEach_2(Arr<obj>, i8, i2):i8
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,i8>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,i8>):Seq<i8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<i8>):Seq<i8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8n:i8*, i2s:i2*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> Sum(a: i4n, b: i2s, a * b)
Sum(a : i4n, b : i2s, a * b) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(i4n), [map:2] Global(i2s), Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))):i8*)):i8))
// (<ctx>, ∂.i4n:i4*, ∂.i2s:i2*) : i8
ForEach_2(Arr<obj>, i4, i2):i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,i8>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,i8>):Seq<i8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<i8>):Seq<i8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4n:i4*, i2s:i2*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> Sum(a: u8n, b: u2s, a * b)
Sum(a : u8n, b : u2s, a * b) : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(u8n), [map:2] Global(u2s), Mul(Scope(1), Num<u8>(Scope(2)))):u8*)):u8))
// (<ctx>, ∂.u8n:u8*, ∂.u2s:u2*) : u8
ForEach_2(Arr<obj>, u8, u2):u8
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,u8>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,u8>):Seq<u8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<u8>):Seq<u8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<u8>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8n:u8*, u2s:u2*) to u8
Type: u8, Value: 0
*** Ctx ping count: 0
###
> Sum(a: u4n, b: u2s, a * b)
Sum(a : u4n, b : u2s, a * b) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(u4n), [map:2] Global(u2s), Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))):i8*)):i8))
// (<ctx>, ∂.u4n:u4*, ∂.u2s:u2*) : i8
ForEach_2(Arr<obj>, u4, u2):i8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,i8>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,i8>):Seq<i8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<i8>):Seq<i8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4n:u4*, u2s:u2*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> Sum(a: bin, b: i2s, a * b)
Sum(a : bin, b : i2s, a * b) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(bin), [map:2] Global(i2s), Mul(Scope(1), Num<i>(Scope(2)))):i*)):i))
// (<ctx>, ∂.bin:i*, ∂.i2s:i2*) : i
ForEach_2(Arr<obj>, ia, i2):ia
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,ia>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,ia>):Seq<ia>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<ia>):Seq<ia>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bin:i*, i2s:i2*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> Mean(a: r8n, b: i2s, a * b)
Mean(a : r8n, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(r8n), [map:2] Global(i2s), Mul(Scope(1), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r8n:r8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):r8
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8n:r8*, i2s:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: r4n, b: i2s, a * b)
Mean(a : r4n, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(r4n), [map:2] Global(i2s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r4n:r4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4n:r4*, i2s:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: i8n, b: i2s, a * b)
Mean(a : i8n, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(i8n), [map:2] Global(i2s), Num<r8>(Mul(Scope(1), Num<i8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.i8n:i8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, i8, i2):r8
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8n:i8*, i2s:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: i4n, b: i2s, a * b)
Mean(a : i4n, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(i4n), [map:2] Global(i2s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.i4n:i4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, i4, i2):r8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4n:i4*, i2s:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: u8n, b: u2s, a * b)
Mean(a : u8n, b : u2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(u8n), [map:2] Global(u2s), Num<r8>(Mul(Scope(1), Num<u8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.u8n:u8*, ∂.u2s:u2*) : r8
ForEach_2(Arr<obj>, u8, u2):r8
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,r8>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8n:u8*, u2s:u2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: u4n, b: u2s, a * b)
Mean(a : u4n, b : u2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(u4n), [map:2] Global(u2s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.u4n:u4*, ∂.u2s:u2*) : r8
ForEach_2(Arr<obj>, u4, u2):r8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,r8>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4n:u4*, u2s:u2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: bin, b: i2s, a * b)
Mean(a : bin, b : i2s, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(bin), [map:2] Global(i2s), Num<r8>(Mul(Scope(1), Num<i>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.bin:i*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, ia, i2):r8
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      1) ret
  Total Size: 18

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,r8>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bin:i*, i2s:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Sum(a: r8s, b: i2n, a * b)
Sum(a : r8s, b : i2n, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2n), Mul(Scope(1), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r8s:r8*, ∂.i2n:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):r8
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8s:r8*, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Sum(a: r4s, b: i2n, a * b)
Sum(a : r4s, b : i2n, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2n), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r4s:r4*, ∂.i2n:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4s:r4*, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Sum(a: i8s, b: i2n, a * b)
Sum(a : i8s, b : i2n, a * b) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2n), Mul(Scope(1), Num<i8>(Scope(2)))):i8*)):i8))
// (<ctx>, ∂.i8s:i8*, ∂.i2n:i2*) : i8
ForEach_2(Arr<obj>, i8, i2):i8
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,i8>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,i8>):Seq<i8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<i8>):Seq<i8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8s:i8*, i2n:i2*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> Sum(a: i4s, b: i2n, a * b)
Sum(a : i4s, b : i2n, a * b) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2n), Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))):i8*)):i8))
// (<ctx>, ∂.i4s:i4*, ∂.i2n:i2*) : i8
ForEach_2(Arr<obj>, i4, i2):i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,i8>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,i8>):Seq<i8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<i8>):Seq<i8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4s:i4*, i2n:i2*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> Sum(a: u8s, b: u2n, a * b)
Sum(a : u8s, b : u2n, a * b) : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2n), Mul(Scope(1), Num<u8>(Scope(2)))):u8*)):u8))
// (<ctx>, ∂.u8s:u8*, ∂.u2n:u2*) : u8
ForEach_2(Arr<obj>, u8, u2):u8
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,u8>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,u8>):Seq<u8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<u8>):Seq<u8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<u8>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8s:u8*, u2n:u2*) to u8
Type: u8, Value: 0
*** Ctx ping count: 0
###
> Sum(a: u4s, b: u2n, a * b)
Sum(a : u4s, b : u2n, a * b) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2n), Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))):i8*)):i8))
// (<ctx>, ∂.u4s:u4*, ∂.u2n:u2*) : i8
ForEach_2(Arr<obj>, u4, u2):i8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,i8>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,i8>):Seq<i8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<i8>):Seq<i8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4s:u4*, u2n:u2*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> Sum(a: bis, b: i2n, a * b)
Sum(a : bis, b : i2n, a * b) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2n), Mul(Scope(1), Num<i>(Scope(2)))):i*)):i))
// (<ctx>, ∂.bis:i*, ∂.i2n:i2*) : i
ForEach_2(Arr<obj>, ia, i2):ia
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,ia>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,ia>):Seq<ia>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<ia>):Seq<ia>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bis:i*, i2n:i2*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> Mean(a: r8s, b: i2n, a * b)
Mean(a : r8s, b : i2n, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2n), Mul(Scope(1), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r8s:r8*, ∂.i2n:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):r8
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8s:r8*, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: r4s, b: i2n, a * b)
Mean(a : r4s, b : i2n, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2n), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2)))):r8*)):r8))
// (<ctx>, ∂.r4s:r4*, ∂.i2n:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4s:r4*, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: i8s, b: i2n, a * b)
Mean(a : i8s, b : i2n, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2n), Num<r8>(Mul(Scope(1), Num<i8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.i8s:i8*, ∂.i2n:i2*) : r8
ForEach_2(Arr<obj>, i8, i2):r8
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8s:i8*, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: i4s, b: i2n, a * b)
Mean(a : i4s, b : i2n, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2n), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.i4s:i4*, ∂.i2n:i2*) : r8
ForEach_2(Arr<obj>, i4, i2):r8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4s:i4*, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: u8s, b: u2n, a * b)
Mean(a : u8s, b : u2n, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2n), Num<r8>(Mul(Scope(1), Num<u8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.u8s:u8*, ∂.u2n:u2*) : r8
ForEach_2(Arr<obj>, u8, u2):r8
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,r8>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8s:u8*, u2n:u2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: u4s, b: u2n, a * b)
Mean(a : u4s, b : u2n, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2n), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.u4s:u4*, ∂.u2n:u2*) : r8
ForEach_2(Arr<obj>, u4, u2):r8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,r8>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4s:u4*, u2n:u2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: bis, b: i2n, a * b)
Mean(a : bis, b : i2n, a * b) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2n), Num<r8>(Mul(Scope(1), Num<i>(Scope(2))))):r8*)):r8))
// (<ctx>, ∂.bis:i*, ∂.i2n:i2*) : r8
ForEach_2(Arr<obj>, ia, i2):r8
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      1) ret
  Total Size: 18

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,r8>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bis:i*, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qr8n->Sum()
qr8n->Sum() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Global(qr8n)):r8))
// (<ctx>, ∂.qr8n:r8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr8n:r8?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qr4n->Sum()
qr4n->Sum() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Global(qr4n)):r8))
// (<ctx>, ∂.qr4n:r4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr4n:r4?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qi8n->Sum()
qi8n->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qi8n)):i8))
// (<ctx>, ∂.qi8n:i8?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi8n:i8?*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> qi4n->Sum()
qi4n->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qi4n)):i8))
// (<ctx>, ∂.qi4n:i4?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<i4>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi4n:i4?*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> qi2n->Sum()
qi2n->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qi2n)):i8))
// (<ctx>, ∂.qi2n:i2?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<i2>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi2n:i2?*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> qi1n->Sum()
qi1n->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qi1n)):i8))
// (<ctx>, ∂.qi1n:i1?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<i1>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi1n:i1?*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> qu8n->Sum()
qu8n->Sum() : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum(Global(qu8n)):u8))
// (<ctx>, ∂.qu8n:u8?*) : u8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<u8>>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu8n:u8?*) to u8
Type: u8, Value: 0
*** Ctx ping count: 0
###
> qu4n->Sum()
qu4n->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qu4n)):i8))
// (<ctx>, ∂.qu4n:u4?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<u4>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu4n:u4?*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> qu2n->Sum()
qu2n->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qu2n)):i8))
// (<ctx>, ∂.qu2n:u2?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<u2>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu2n:u2?*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> qu1n->Sum()
qu1n->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qu1n)):i8))
// (<ctx>, ∂.qu1n:u1?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<u1>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu1n:u1?*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> qbn->Sum()
qbn->Sum() : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Global(qbn)):i8))
// (<ctx>, ∂.qbn:b?*) : i8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<bool>>
      1) stloc.1 [Seq<Opt<bool>>]
      1) ldloc.1 [Seq<Opt<bool>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<bool>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qbn:b?*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> qbin->Sum()
qbin->Sum() : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum(Global(qbin)):i))
// (<ctx>, ∂.qbin:i?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qbin:i?*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> qr8n->SumBig()
qr8n->SumBig() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig(Global(qr8n)):r8))
// (<ctx>, ∂.qr8n:r8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr8n:r8?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qr4n->SumBig()
qr4n->SumBig() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumBig(Global(qr4n)):r8))
// (<ctx>, ∂.qr4n:r4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecSum(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr4n:r4?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qi8n->SumBig()
qi8n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qi8n)):i))
// (<ctx>, ∂.qi8n:i8?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<i8>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi8n:i8?*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> qi4n->SumBig()
qi4n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qi4n)):i))
// (<ctx>, ∂.qi4n:i4?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<i4>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi4n:i4?*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> qi2n->SumBig()
qi2n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qi2n)):i))
// (<ctx>, ∂.qi2n:i2?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<i2>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi2n:i2?*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> qi1n->SumBig()
qi1n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qi1n)):i))
// (<ctx>, ∂.qi1n:i1?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<i1>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi1n:i1?*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> qu8n->SumBig()
qu8n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qu8n)):i))
// (<ctx>, ∂.qu8n:u8?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<u8>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu8n:u8?*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> qu4n->SumBig()
qu4n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qu4n)):i))
// (<ctx>, ∂.qu4n:u4?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<u4>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu4n:u4?*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> qu2n->SumBig()
qu2n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qu2n)):i))
// (<ctx>, ∂.qu2n:u2?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<u2>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu2n:u2?*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> qu1n->SumBig()
qu1n->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qu1n)):i))
// (<ctx>, ∂.qu1n:u1?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<u1>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu1n:u1?*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> qbn->SumBig()
qbn->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qbn)):i))
// (<ctx>, ∂.qbn:b?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<bool>>
      1) stloc.1 [Seq<Opt<bool>>]
      1) ldloc.1 [Seq<Opt<bool>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecBig(Seq<Opt<bool>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qbn:b?*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> qbin->SumBig()
qbin->SumBig() : i
BndKind:Call, Type:i, Bnd:(Call(∂.SumBig(Global(qbin)):i))
// (<ctx>, ∂.qbin:i?*) : i
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecS(Seq<Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qbin:i?*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> qr8n->SumK()
qr8n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qr8n)):r8))
// (<ctx>, ∂.qr8n:r8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr8n:r8?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qr4n->SumK()
qr4n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qr4n)):r8))
// (<ctx>, ∂.qr4n:r4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr4n:r4?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qi8n->SumK()
qi8n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qi8n)):r8))
// (<ctx>, ∂.qi8n:i8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<i8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi8n:i8?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qi4n->SumK()
qi4n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qi4n)):r8))
// (<ctx>, ∂.qi4n:i4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<i4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi4n:i4?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qi2n->SumK()
qi2n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qi2n)):r8))
// (<ctx>, ∂.qi2n:i2?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<i2>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi2n:i2?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qi1n->SumK()
qi1n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qi1n)):r8))
// (<ctx>, ∂.qi1n:i1?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<i1>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi1n:i1?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qu8n->SumK()
qu8n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qu8n)):r8))
// (<ctx>, ∂.qu8n:u8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<u8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu8n:u8?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qu4n->SumK()
qu4n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qu4n)):r8))
// (<ctx>, ∂.qu4n:u4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<u4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu4n:u4?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qu2n->SumK()
qu2n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qu2n)):r8))
// (<ctx>, ∂.qu2n:u2?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<u2>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu2n:u2?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qu1n->SumK()
qu1n->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qu1n)):r8))
// (<ctx>, ∂.qu1n:u1?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<u1>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu1n:u1?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qbin->SumK()
qbin->SumK() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.SumK(Global(qbin)):r8))
// (<ctx>, ∂.qbin:i?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecK(Seq<Opt<ia>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qbin:i?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qr8n->Mean()
qr8n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qr8n)):r8))
// (<ctx>, ∂.qr8n:r8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr8n:r8?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qr4n->Mean()
qr4n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qr4n)):r8))
// (<ctx>, ∂.qr4n:r4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qr4n:r4?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qi8n->Mean()
qi8n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qi8n)):r8))
// (<ctx>, ∂.qi8n:i8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<i8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi8n:i8?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qi4n->Mean()
qi4n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qi4n)):r8))
// (<ctx>, ∂.qi4n:i4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<i4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi4n:i4?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qi2n->Mean()
qi2n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qi2n)):r8))
// (<ctx>, ∂.qi2n:i2?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<i2>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi2n:i2?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qi1n->Mean()
qi1n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qi1n)):r8))
// (<ctx>, ∂.qi1n:i1?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<i1>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qi1n:i1?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qu8n->Mean()
qu8n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qu8n)):r8))
// (<ctx>, ∂.qu8n:u8?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<u8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu8n:u8?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qu4n->Mean()
qu4n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qu4n)):r8))
// (<ctx>, ∂.qu4n:u4?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<u4>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu4n:u4?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qu2n->Mean()
qu2n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qu2n)):r8))
// (<ctx>, ∂.qu2n:u2?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<u2>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu2n:u2?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qu1n->Mean()
qu1n->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qu1n)):r8))
// (<ctx>, ∂.qu1n:u1?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<u1>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qu1n:u1?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qbn->Mean()
qbn->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qbn)):r8))
// (<ctx>, ∂.qbn:b?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<bool>>
      1) stloc.1 [Seq<Opt<bool>>]
      1) ldloc.1 [Seq<Opt<bool>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<bool>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qbn:b?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> qbin->Mean()
qbin->Mean() : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Global(qbin)):r8))
// (<ctx>, ∂.qbin:i?*) : r8
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<ia>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 34

Func sig: (<ctx>:x, qbin:i?*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> r8n->Sum (Opt(it * it))
r8n->Sum(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum([map:1] Global(r8n), Opt<r8?>(Mul(Scope(1), Scope(1)))):r8))
// (<ctx>, ∂.r8n:r8*) : r8
Sum_1(Arr<obj>, r8):Opt<r8>
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<r8>, Func<r8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8n:r8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> r4n->Sum (Opt(it * it))
r4n->Sum(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum([map:1] Global(r4n), Opt<r8?>(Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1))))):r8))
// (<ctx>, ∂.r4n:r4*) : r8
Sum_1(Arr<obj>, r4):Opt<r8>
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<r4>, Func<r4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4n:r4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i8n->Sum (Opt(it * it))
i8n->Sum(Opt(it * it)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(i8n), Opt<i8?>(Mul(Scope(1), Scope(1)))):i8))
// (<ctx>, ∂.i8n:i8*) : i8
Sum_1(Arr<obj>, i8):Opt<i8>
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<i8>, Func<i8,Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8n:i8*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> i4n->Sum (Opt(it * it))
i4n->Sum(Opt(it * it)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(i4n), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1))))):i8))
// (<ctx>, ∂.i4n:i4*) : i8
Sum_1(Arr<obj>, i4):Opt<i8>
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<i4>, Func<i4,Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4n:i4*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> u8n->Sum (Opt(it * it))
u8n->Sum(Opt(it * it)) : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum([map:1] Global(u8n), Opt<u8?>(Mul(Scope(1), Scope(1)))):u8))
// (<ctx>, ∂.u8n:u8*) : u8
Sum_1(Arr<obj>, u8):Opt<u8>
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      5) newobj Opt<u8>(u8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<u8>, Func<u8,Opt<u8>>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8n:u8*) to u8
Type: u8, Value: 0
*** Ctx ping count: 0
###
> u4n->Sum (Opt(it * it))
u4n->Sum(Opt(it * it)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum([map:1] Global(u4n), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1))))):i8))
// (<ctx>, ∂.u4n:u4*) : i8
Sum_1(Arr<obj>, u4):Opt<i8>
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<u4>, Func<u4,Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4n:u4*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> bin->Sum (Opt(it * it))
bin->Sum(Opt(it * it)) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum([map:1] Global(bin), Opt<i?>(Mul(Scope(1), Scope(1)))):i))
// (<ctx>, ∂.bin:i*) : i
Sum_1(Arr<obj>, ia):Opt<ia>
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      5) newobj Opt<ia>(ia)
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::Exec(Seq<ia>, Func<ia,Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bin:i*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> r8n->Mean(Opt(it * it))
r8n->Mean(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(r8n), Opt<r8?>(Mul(Scope(1), Scope(1)))):r8))
// (<ctx>, ∂.r8n:r8*) : r8
Mean_1(Arr<obj>, r8):Opt<r8>
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<r8>, Func<r8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r8n:r8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> r4n->Mean(Opt(it * it))
r4n->Mean(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(r4n), Opt<r8?>(Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1))))):r8))
// (<ctx>, ∂.r4n:r4*) : r8
Mean_1(Arr<obj>, r4):Opt<r8>
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<r4>, Func<r4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, r4n:r4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i8n->Mean(Opt(it * it))
i8n->Mean(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(i8n), Opt<r8?>(Num<r8>(Mul(Scope(1), Scope(1))))):r8))
// (<ctx>, ∂.i8n:i8*) : r8
Mean_1(Arr<obj>, i8):Opt<r8>
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i8>, Func<i8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i8n:i8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> i4n->Mean(Opt(it * it))
i4n->Mean(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(i4n), Opt<r8?>(Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))))):r8))
// (<ctx>, ∂.i4n:i4*) : r8
Mean_1(Arr<obj>, i4):Opt<r8>
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 12

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<i4>, Func<i4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, i4n:i4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> u8n->Mean(Opt(it * it))
u8n->Mean(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(u8n), Opt<r8?>(Num<r8>(Mul(Scope(1), Scope(1))))):r8))
// (<ctx>, ∂.u8n:u8*) : r8
Mean_1(Arr<obj>, u8):Opt<r8>
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 14

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u8>, Func<u8,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u8n:u8*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> u4n->Mean(Opt(it * it))
u4n->Mean(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(u4n), Opt<r8?>(Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))))):r8))
// (<ctx>, ∂.u4n:u4*) : r8
Mean_1(Arr<obj>, u4):Opt<r8>
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 12

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<u4>, Func<u4,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, u4n:u4*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> bin->Mean(Opt(it * it))
bin->Mean(Opt(it * it)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean([map:1] Global(bin), Opt<r8?>(Num<r8>(Mul(Scope(1), Scope(1))))):r8))
// (<ctx>, ∂.bin:i*) : r8
Mean_1(Arr<obj>, ia):Opt<r8>
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 18

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (2)]
      5) call static SumBaseGen::ExecMean(Seq<ia>, Func<ia,Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 41

Func sig: (<ctx>:x, bin:i*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Sum (a: r8n, b: i2s, Opt(a * b))
Sum(a : r8n, b : i2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(r8n), [map:2] Global(i2s), Opt<r8?>(Mul(Scope(1), Num<r8>(Scope(2))))):r8?*)):r8))
// (<ctx>, ∂.r8n:r8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):Opt<r8>
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8n:r8*, i2s:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Sum (a: r4n, b: i2s, Opt(a * b))
Sum(a : r4n, b : i2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(r4n), [map:2] Global(i2s), Opt<r8?>(Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2))))):r8?*)):r8))
// (<ctx>, ∂.r4n:r4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):Opt<r8>
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4n:r4*, i2s:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Sum (a: i8n, b: i2s, Opt(a * b))
Sum(a : i8n, b : i2s, Opt(a * b)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(i8n), [map:2] Global(i2s), Opt<i8?>(Mul(Scope(1), Num<i8>(Scope(2))))):i8?*)):i8))
// (<ctx>, ∂.i8n:i8*, ∂.i2s:i2*) : i8
ForEach_2(Arr<obj>, i8, i2):Opt<i8>
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,Opt<i8>>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,Opt<i8>>):Seq<Opt<i8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<i8>>):Seq<Opt<i8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8n:i8*, i2s:i2*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> Sum (a: i4n, b: i2s, Opt(a * b))
Sum(a : i4n, b : i2s, Opt(a * b)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(i4n), [map:2] Global(i2s), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):i8?*)):i8))
// (<ctx>, ∂.i4n:i4*, ∂.i2s:i2*) : i8
ForEach_2(Arr<obj>, i4, i2):Opt<i8>
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,Opt<i8>>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,Opt<i8>>):Seq<Opt<i8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<i8>>):Seq<Opt<i8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4n:i4*, i2s:i2*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> Sum (a: u8n, b: u2s, Opt(a * b))
Sum(a : u8n, b : u2s, Opt(a * b)) : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(u8n), [map:2] Global(u2s), Opt<u8?>(Mul(Scope(1), Num<u8>(Scope(2))))):u8?*)):u8))
// (<ctx>, ∂.u8n:u8*, ∂.u2s:u2*) : u8
ForEach_2(Arr<obj>, u8, u2):Opt<u8>
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) newobj Opt<u8>(u8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,Opt<u8>>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,Opt<u8>>):Seq<Opt<u8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<u8>>):Seq<Opt<u8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<u8>>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8n:u8*, u2s:u2*) to u8
Type: u8, Value: 0
*** Ctx ping count: 0
###
> Sum (a: u4n, b: u2s, Opt(a * b))
Sum(a : u4n, b : u2s, Opt(a * b)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(u4n), [map:2] Global(u2s), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):i8?*)):i8))
// (<ctx>, ∂.u4n:u4*, ∂.u2s:u2*) : i8
ForEach_2(Arr<obj>, u4, u2):Opt<i8>
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,Opt<i8>>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,Opt<i8>>):Seq<Opt<i8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<i8>>):Seq<Opt<i8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4n:u4*, u2s:u2*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> Sum (a: bin, b: i2s, Opt(a * b))
Sum(a : bin, b : i2s, Opt(a * b)) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(bin), [map:2] Global(i2s), Opt<i?>(Mul(Scope(1), Num<i>(Scope(2))))):i?*)):i))
// (<ctx>, ∂.bin:i*, ∂.i2s:i2*) : i
ForEach_2(Arr<obj>, ia, i2):Opt<ia>
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      5) newobj Opt<ia>(ia)
      1) ret
  Total Size: 18

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,Opt<ia>>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,Opt<ia>>):Seq<Opt<ia>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<ia>>):Seq<Opt<ia>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bin:i*, i2s:i2*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> Mean(a: r8n, b: i2s, Opt(a * b))
Mean(a : r8n, b : i2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(r8n), [map:2] Global(i2s), Opt<r8?>(Mul(Scope(1), Num<r8>(Scope(2))))):r8?*)):r8))
// (<ctx>, ∂.r8n:r8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):Opt<r8>
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8n:r8*, i2s:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: r4n, b: i2s, Opt(a * b))
Mean(a : r4n, b : i2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(r4n), [map:2] Global(i2s), Opt<r8?>(Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2))))):r8?*)):r8))
// (<ctx>, ∂.r4n:r4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):Opt<r8>
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4n:r4*, i2s:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: i8n, b: i2s, Opt(a * b))
Mean(a : i8n, b : i2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(i8n), [map:2] Global(i2s), Opt<r8?>(Num<r8>(Mul(Scope(1), Num<i8>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.i8n:i8*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, i8, i2):Opt<r8>
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8n:i8*, i2s:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: i4n, b: i2s, Opt(a * b))
Mean(a : i4n, b : i2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(i4n), [map:2] Global(i2s), Opt<r8?>(Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.i4n:i4*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, i4, i2):Opt<r8>
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 12

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4n:i4*, i2s:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: u8n, b: u2s, Opt(a * b))
Mean(a : u8n, b : u2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(u8n), [map:2] Global(u2s), Opt<r8?>(Num<r8>(Mul(Scope(1), Num<u8>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.u8n:u8*, ∂.u2s:u2*) : r8
ForEach_2(Arr<obj>, u8, u2):Opt<r8>
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 15

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8n:u8*, u2s:u2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: u4n, b: u2s, Opt(a * b))
Mean(a : u4n, b : u2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(u4n), [map:2] Global(u2s), Opt<r8?>(Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.u4n:u4*, ∂.u2s:u2*) : r8
ForEach_2(Arr<obj>, u4, u2):Opt<r8>
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 12

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4n:u4*, u2s:u2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: bin, b: i2s, Opt(a * b))
Mean(a : bin, b : i2s, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(bin), [map:2] Global(i2s), Opt<r8?>(Num<r8>(Mul(Scope(1), Num<i>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.bin:i*, ∂.i2s:i2*) : r8
ForEach_2(Arr<obj>, ia, i2):Opt<r8>
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 23

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bin:i*, i2s:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Sum (a: r8s, b: i2n, Opt(a * b))
Sum(a : r8s, b : i2n, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2n), Opt<r8?>(Mul(Scope(1), Num<r8>(Scope(2))))):r8?*)):r8))
// (<ctx>, ∂.r8s:r8*, ∂.i2n:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):Opt<r8>
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8s:r8*, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Sum (a: r4s, b: i2n, Opt(a * b))
Sum(a : r4s, b : i2n, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2n), Opt<r8?>(Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2))))):r8?*)):r8))
// (<ctx>, ∂.r4s:r4*, ∂.i2n:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):Opt<r8>
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4s:r4*, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Sum (a: i8s, b: i2n, Opt(a * b))
Sum(a : i8s, b : i2n, Opt(a * b)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2n), Opt<i8?>(Mul(Scope(1), Num<i8>(Scope(2))))):i8?*)):i8))
// (<ctx>, ∂.i8s:i8*, ∂.i2n:i2*) : i8
ForEach_2(Arr<obj>, i8, i2):Opt<i8>
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,Opt<i8>>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,Opt<i8>>):Seq<Opt<i8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<i8>>):Seq<Opt<i8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8s:i8*, i2n:i2*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> Sum (a: i4s, b: i2n, Opt(a * b))
Sum(a : i4s, b : i2n, Opt(a * b)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2n), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):i8?*)):i8))
// (<ctx>, ∂.i4s:i4*, ∂.i2n:i2*) : i8
ForEach_2(Arr<obj>, i4, i2):Opt<i8>
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,Opt<i8>>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,Opt<i8>>):Seq<Opt<i8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<i8>>):Seq<Opt<i8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4s:i4*, i2n:i2*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> Sum (a: u8s, b: u2n, Opt(a * b))
Sum(a : u8s, b : u2n, Opt(a * b)) : u8
BndKind:Call, Type:u8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2n), Opt<u8?>(Mul(Scope(1), Num<u8>(Scope(2))))):u8?*)):u8))
// (<ctx>, ∂.u8s:u8*, ∂.u2n:u2*) : u8
ForEach_2(Arr<obj>, u8, u2):Opt<u8>
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) newobj Opt<u8>(u8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,Opt<u8>>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,Opt<u8>>):Seq<Opt<u8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<u8>>):Seq<Opt<u8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<u8>>, ExecCtx, i4, out i8):u8
      5) box [u8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8s:u8*, u2n:u2*) to u8
Type: u8, Value: 0
*** Ctx ping count: 0
###
> Sum (a: u4s, b: u2n, Opt(a * b))
Sum(a : u4s, b : u2n, Opt(a * b)) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2n), Opt<i8?>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):i8?*)):i8))
// (<ctx>, ∂.u4s:u4*, ∂.u2n:u2*) : i8
ForEach_2(Arr<obj>, u4, u2):Opt<i8>
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) newobj Opt<i8>(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,Opt<i8>>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,Opt<i8>>):Seq<Opt<i8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<i8>>):Seq<Opt<i8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      5) box [i8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4s:u4*, u2n:u2*) to i8
Type: i8, Value: 0
*** Ctx ping count: 0
###
> Sum (a: bis, b: i2n, Opt(a * b))
Sum(a : bis, b : i2n, Opt(a * b)) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Sum(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2n), Opt<i?>(Mul(Scope(1), Num<i>(Scope(2))))):i?*)):i))
// (<ctx>, ∂.bis:i*, ∂.i2n:i2*) : i
ForEach_2(Arr<obj>, ia, i2):Opt<ia>
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      5) newobj Opt<ia>(ia)
      1) ret
  Total Size: 18

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,Opt<ia>>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,Opt<ia>>):Seq<Opt<ia>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<ia>>):Seq<Opt<ia>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecS(Seq<Opt<ia>>, ExecCtx, i4, out i8):ia
      5) box [ia]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bis:i*, i2n:i2*) to i
Type: ia, Value: 0
*** Ctx ping count: 0
###
> Mean(a: r8s, b: i2n, Opt(a * b))
Mean(a : r8s, b : i2n, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2n), Opt<r8?>(Mul(Scope(1), Num<r8>(Scope(2))))):r8?*)):r8))
// (<ctx>, ∂.r8s:r8*, ∂.i2n:i2*) : r8
ForEach_2(Arr<obj>, r8, i2):Opt<r8>
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r8s:r8*, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: r4s, b: i2n, Opt(a * b))
Mean(a : r4s, b : i2n, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2n), Opt<r8?>(Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2))))):r8?*)):r8))
// (<ctx>, ∂.r4s:r4*, ∂.i2n:i2*) : r8
ForEach_2(Arr<obj>, r4, i2):Opt<r8>
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, r4s:r4*, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: i8s, b: i2n, Opt(a * b))
Mean(a : i8s, b : i2n, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2n), Opt<r8?>(Num<r8>(Mul(Scope(1), Num<i8>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.i8s:i8*, ∂.i2n:i2*) : r8
ForEach_2(Arr<obj>, i8, i2):Opt<r8>
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i8s:i8*, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: i4s, b: i2n, Opt(a * b))
Mean(a : i4s, b : i2n, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2n), Opt<r8?>(Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.i4s:i4*, ∂.i2n:i2*) : r8
ForEach_2(Arr<obj>, i4, i2):Opt<r8>
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 12

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, i4s:i4*, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: u8s, b: u2n, Opt(a * b))
Mean(a : u8s, b : u2n, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2n), Opt<r8?>(Num<r8>(Mul(Scope(1), Num<u8>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.u8s:u8*, ∂.u2n:u2*) : r8
ForEach_2(Arr<obj>, u8, u2):Opt<r8>
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 15

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u8s:u8*, u2n:u2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: u4s, b: u2n, Opt(a * b))
Mean(a : u4s, b : u2n, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2n), Opt<r8?>(Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.u4s:u4*, ∂.u2n:u2*) : r8
ForEach_2(Arr<obj>, u4, u2):Opt<r8>
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) conv.r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 12

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, u4s:u4*, u2n:u2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> Mean(a: bis, b: i2n, Opt(a * b))
Mean(a : bis, b : i2n, Opt(a * b)) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Mean(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2n), Opt<r8?>(Num<r8>(Mul(Scope(1), Num<i>(Scope(2)))))):r8?*)):r8))
// (<ctx>, ∂.bis:i*, ∂.i2n:i2*) : r8
ForEach_2(Arr<obj>, ia, i2):Opt<r8>
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      5) newobj Opt<r8>(r8)
      1) ret
  Total Size: 23

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,Opt<r8>>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,Opt<r8>>):Seq<Opt<r8>>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<Opt<r8>>):Seq<Opt<r8>>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      2) ldloca.s [i8 (3)]
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      5) box [r8]
      1) ret
  Total Size: 61

Func sig: (<ctx>:x, bis:i*, i2n:i2*) to r8
Type: r8, Value: 0
*** Ctx ping count: 0
###
> r8s->SumC()
r8s->SumC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumC(Global(r8s))))
// (<ctx>, ∂.r8s:r8*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, r8s:r8*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumC(r8s)
###
> r4s->SumC()
r4s->SumC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumC(Global(r4s))))
// (<ctx>, ∂.r4s:r4*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<r4>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, r4s:r4*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumC(r4s)
###
> i8s->SumC()
i8s->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(i8s))))
// (<ctx>, ∂.i8s:i8*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i8s:i8*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumC(i8s)
###
> i4s->SumC()
i4s->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(i4s))))
// (<ctx>, ∂.i4s:i4*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<i4>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i4s:i4*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumC(i4s)
###
> i2s->SumC()
i2s->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(i2s))))
// (<ctx>, ∂.i2s:i2*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.1 [Seq<i2>]
      1) ldloc.1 [Seq<i2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<i2>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i2s:i2*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumC(i2s)
###
> i1s->SumC()
i1s->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(i1s))))
// (<ctx>, ∂.i1s:i1*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i1>
      1) stloc.1 [Seq<i1>]
      1) ldloc.1 [Seq<i1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<i1>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i1s:i1*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumC(i1s)
###
> u8s->SumC()
u8s->SumC() : {Count:i8, Sum:u8}
BndKind:Call, Type:{Count:i8, Sum:u8}, Bnd:(Call(∂.SumC(Global(u8s))))
// (<ctx>, ∂.u8s:u8*) : {Count:i8, Sum:u8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,u8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,u8}::_B0:u1
      1) stloc.2 [{i8,u8}]
      1) ldloc.2 [{i8,u8}]
      5) ldflda {i8,u8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<u8>, ExecCtx, i4, out i8):u8
      1) stloc.3 [u8]
      1) ldloc.2 [{i8,u8}]
      1) ldloc.3 [u8]
      5) stfld {i8,u8}::_F1:u8
      1) ldloc.2 [{i8,u8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u8s:u8*) to {Count:i8, Sum:u8}
Type: {i8,u8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumC(u8s)
###
> u4s->SumC()
u4s->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(u4s))))
// (<ctx>, ∂.u4s:u4*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<u4>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u4s:u4*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumC(u4s)
###
> u2s->SumC()
u2s->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(u2s))))
// (<ctx>, ∂.u2s:u2*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.1 [Seq<u2>]
      1) ldloc.1 [Seq<u2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<u2>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u2s:u2*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumC(u2s)
###
> u1s->SumC()
u1s->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(u1s))))
// (<ctx>, ∂.u1s:u1*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u1>
      1) stloc.1 [Seq<u1>]
      1) ldloc.1 [Seq<u1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<u1>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u1s:u1*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumC(u1s)
###
> bs->SumC()
bs->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(bs))))
// (<ctx>, ∂.bs:b*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<bool>
      1) stloc.1 [Seq<bool>]
      1) ldloc.1 [Seq<bool>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<bool>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, bs:b*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 10, Sum: 5 }
*** Ctx ping count: 11
    [0](11): SumC(bs)
###
> bis->SumC()
bis->SumC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumC(Global(bis))))
// (<ctx>, ∂.bis:i*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, bis:i*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumC(bis)
###
> r8s->SumBigC()
r8s->SumBigC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumBigC(Global(r8s))))
// (<ctx>, ∂.r8s:r8*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, r8s:r8*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumBigC(r8s)
###
> r4s->SumBigC()
r4s->SumBigC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumBigC(Global(r4s))))
// (<ctx>, ∂.r4s:r4*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<r4>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, r4s:r4*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumBigC(r4s)
###
> i8s->SumBigC()
i8s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(i8s))))
// (<ctx>, ∂.i8s:i8*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<i8>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i8s:i8*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumBigC(i8s)
###
> i4s->SumBigC()
i4s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(i4s))))
// (<ctx>, ∂.i4s:i4*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<i4>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i4s:i4*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumBigC(i4s)
###
> i2s->SumBigC()
i2s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(i2s))))
// (<ctx>, ∂.i2s:i2*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.1 [Seq<i2>]
      1) ldloc.1 [Seq<i2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<i2>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i2s:i2*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumBigC(i2s)
###
> i1s->SumBigC()
i1s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(i1s))))
// (<ctx>, ∂.i1s:i1*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i1>
      1) stloc.1 [Seq<i1>]
      1) ldloc.1 [Seq<i1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<i1>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i1s:i1*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumBigC(i1s)
###
> u8s->SumBigC()
u8s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(u8s))))
// (<ctx>, ∂.u8s:u8*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<u8>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u8s:u8*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumBigC(u8s)
###
> u4s->SumBigC()
u4s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(u4s))))
// (<ctx>, ∂.u4s:u4*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<u4>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u4s:u4*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumBigC(u4s)
###
> u2s->SumBigC()
u2s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(u2s))))
// (<ctx>, ∂.u2s:u2*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.1 [Seq<u2>]
      1) ldloc.1 [Seq<u2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<u2>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u2s:u2*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumBigC(u2s)
###
> u1s->SumBigC()
u1s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(u1s))))
// (<ctx>, ∂.u1s:u1*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u1>
      1) stloc.1 [Seq<u1>]
      1) ldloc.1 [Seq<u1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<u1>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u1s:u1*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumBigC(u1s)
###
> bs->SumBigC()
bs->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(bs))))
// (<ctx>, ∂.bs:b*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<bool>
      1) stloc.1 [Seq<bool>]
      1) ldloc.1 [Seq<bool>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<bool>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, bs:b*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 5 }
*** Ctx ping count: 11
    [0](11): SumBigC(bs)
###
> bis->SumBigC()
bis->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(bis))))
// (<ctx>, ∂.bis:i*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, bis:i*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumBigC(bis)
###
> r8s->SumKC()
r8s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(r8s))))
// (<ctx>, ∂.r8s:r8*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, r8s:r8*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumKC(r8s)
###
> r4s->SumKC()
r4s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(r4s))))
// (<ctx>, ∂.r4s:r4*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<r4>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, r4s:r4*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumKC(r4s)
###
> i8s->SumKC()
i8s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(i8s))))
// (<ctx>, ∂.i8s:i8*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<i8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i8s:i8*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumKC(i8s)
###
> i4s->SumKC()
i4s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(i4s))))
// (<ctx>, ∂.i4s:i4*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<i4>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i4s:i4*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumKC(i4s)
###
> i2s->SumKC()
i2s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(i2s))))
// (<ctx>, ∂.i2s:i2*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.1 [Seq<i2>]
      1) ldloc.1 [Seq<i2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<i2>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i2s:i2*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumKC(i2s)
###
> i1s->SumKC()
i1s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(i1s))))
// (<ctx>, ∂.i1s:i1*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i1>
      1) stloc.1 [Seq<i1>]
      1) ldloc.1 [Seq<i1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<i1>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i1s:i1*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumKC(i1s)
###
> u8s->SumKC()
u8s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(u8s))))
// (<ctx>, ∂.u8s:u8*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<u8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u8s:u8*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumKC(u8s)
###
> u4s->SumKC()
u4s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(u4s))))
// (<ctx>, ∂.u4s:u4*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<u4>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u4s:u4*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumKC(u4s)
###
> u2s->SumKC()
u2s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(u2s))))
// (<ctx>, ∂.u2s:u2*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.1 [Seq<u2>]
      1) ldloc.1 [Seq<u2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<u2>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u2s:u2*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumKC(u2s)
###
> u1s->SumKC()
u1s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(u1s))))
// (<ctx>, ∂.u1s:u1*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u1>
      1) stloc.1 [Seq<u1>]
      1) ldloc.1 [Seq<u1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<u1>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u1s:u1*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumKC(u1s)
###
> bs->SumKC()
bs->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(bs))))
// (<ctx>, ∂.bs:b*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<bool>
      1) stloc.1 [Seq<bool>]
      1) ldloc.1 [Seq<bool>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<bool>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, bs:b*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 5 }
*** Ctx ping count: 11
    [0](11): SumKC(bs)
###
> bis->SumKC()
bis->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(bis))))
// (<ctx>, ∂.bis:i*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<ia>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, bis:i*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 45 }
*** Ctx ping count: 11
    [0](11): SumKC(bis)
###
> r8s->MeanC()
r8s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(r8s))))
// (<ctx>, ∂.r8s:r8*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, r8s:r8*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 4.5 }
*** Ctx ping count: 11
    [0](11): MeanC(r8s)
###
> r4s->MeanC()
r4s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(r4s))))
// (<ctx>, ∂.r4s:r4*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<r4>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, r4s:r4*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 4.5 }
*** Ctx ping count: 11
    [0](11): MeanC(r4s)
###
> i8s->MeanC()
i8s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(i8s))))
// (<ctx>, ∂.i8s:i8*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<i8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i8s:i8*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 4.5 }
*** Ctx ping count: 11
    [0](11): MeanC(i8s)
###
> i4s->MeanC()
i4s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(i4s))))
// (<ctx>, ∂.i4s:i4*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<i4>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i4s:i4*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 4.5 }
*** Ctx ping count: 11
    [0](11): MeanC(i4s)
###
> i2s->MeanC()
i2s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(i2s))))
// (<ctx>, ∂.i2s:i2*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.1 [Seq<i2>]
      1) ldloc.1 [Seq<i2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<i2>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i2s:i2*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 4.5 }
*** Ctx ping count: 11
    [0](11): MeanC(i2s)
###
> i1s->MeanC()
i1s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(i1s))))
// (<ctx>, ∂.i1s:i1*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i1>
      1) stloc.1 [Seq<i1>]
      1) ldloc.1 [Seq<i1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<i1>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, i1s:i1*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 4.5 }
*** Ctx ping count: 11
    [0](11): MeanC(i1s)
###
> u8s->MeanC()
u8s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(u8s))))
// (<ctx>, ∂.u8s:u8*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<u8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u8s:u8*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 4.5 }
*** Ctx ping count: 11
    [0](11): MeanC(u8s)
###
> u4s->MeanC()
u4s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(u4s))))
// (<ctx>, ∂.u4s:u4*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<u4>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u4s:u4*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 4.5 }
*** Ctx ping count: 11
    [0](11): MeanC(u4s)
###
> u2s->MeanC()
u2s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(u2s))))
// (<ctx>, ∂.u2s:u2*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.1 [Seq<u2>]
      1) ldloc.1 [Seq<u2>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<u2>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u2s:u2*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 4.5 }
*** Ctx ping count: 11
    [0](11): MeanC(u2s)
###
> u1s->MeanC()
u1s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(u1s))))
// (<ctx>, ∂.u1s:u1*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u1>
      1) stloc.1 [Seq<u1>]
      1) ldloc.1 [Seq<u1>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<u1>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, u1s:u1*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 4.5 }
*** Ctx ping count: 11
    [0](11): MeanC(u1s)
###
> bs->MeanC()
bs->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(bs))))
// (<ctx>, ∂.bs:b*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<bool>
      1) stloc.1 [Seq<bool>]
      1) ldloc.1 [Seq<bool>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<bool>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, bs:b*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 0.5 }
*** Ctx ping count: 11
    [0](11): MeanC(bs)
###
> bis->MeanC()
bis->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(bis))))
// (<ctx>, ∂.bis:i*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<ia>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, bis:i*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 4.5 }
*** Ctx ping count: 11
    [0](11): MeanC(bis)
###
> r8s->SumC(it * it)
r8s->SumC(it * it) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumC([map:1] Global(r8s), Mul(Scope(1), Scope(1)))))
// (<ctx>, ∂.r8s:r8*) : {Count:i8, Sum:r8}
SumC_1(Arr<obj>, r8):r8
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::Exec(Seq<r8>, Func<r8,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, r8s:r8*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumC(*1: r8s, Mul(*1, *1))
###
> r4s->SumC(it * it)
r4s->SumC(it * it) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumC([map:1] Global(r4s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1))))))
// (<ctx>, ∂.r4s:r4*) : {Count:i8, Sum:r8}
SumC_1(Arr<obj>, r4):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::Exec(Seq<r4>, Func<r4,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, r4s:r4*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumC(*1: r4s, Mul(Num<r8>(*1), Num<r8>(*1)))
###
> i8s->SumC(it * it)
i8s->SumC(it * it) : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC([map:1] Global(i8s), Mul(Scope(1), Scope(1)))))
// (<ctx>, ∂.i8s:i8*) : {Count:i8, Sum:i8}
SumC_1(Arr<obj>, i8):i8
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::Exec(Seq<i8>, Func<i8,i8>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, i8s:i8*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumC(*1: i8s, Mul(*1, *1))
###
> i4s->SumC(it * it)
i4s->SumC(it * it) : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC([map:1] Global(i4s), Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1))))))
// (<ctx>, ∂.i4s:i4*) : {Count:i8, Sum:i8}
SumC_1(Arr<obj>, i4):i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::Exec(Seq<i4>, Func<i4,i8>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, i4s:i4*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumC(*1: i4s, Mul(Num<i8>(*1), Num<i8>(*1)))
###
> u8s->SumC(it * it)
u8s->SumC(it * it) : {Count:i8, Sum:u8}
BndKind:Call, Type:{Count:i8, Sum:u8}, Bnd:(Call(∂.SumC([map:1] Global(u8s), Mul(Scope(1), Scope(1)))))
// (<ctx>, ∂.u8s:u8*) : {Count:i8, Sum:u8}
SumC_1(Arr<obj>, u8):u8
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,u8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,u8}::_B0:u1
      1) stloc.2 [{i8,u8}]
      1) ldloc.2 [{i8,u8}]
      5) ldflda {i8,u8}::_F0:i8
      5) call static SumBaseGen::Exec(Seq<u8>, Func<u8,u8>, ExecCtx, i4, out i8):u8
      1) stloc.3 [u8]
      1) ldloc.2 [{i8,u8}]
      1) ldloc.3 [u8]
      5) stfld {i8,u8}::_F1:u8
      1) ldloc.2 [{i8,u8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, u8s:u8*) to {Count:i8, Sum:u8}
Type: {i8,u8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumC(*1: u8s, Mul(*1, *1))
###
> u4s->SumC(it * it)
u4s->SumC(it * it) : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC([map:1] Global(u4s), Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1))))))
// (<ctx>, ∂.u4s:u4*) : {Count:i8, Sum:i8}
SumC_1(Arr<obj>, u4):i8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,i8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::Exec(Seq<u4>, Func<u4,i8>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, u4s:u4*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumC(*1: u4s, Mul(Num<i8>(*1), Num<i8>(*1)))
###
> bis->SumC(it * it)
bis->SumC(it * it) : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumC([map:1] Global(bis), Mul(Scope(1), Scope(1)))))
// (<ctx>, ∂.bis:i*) : {Count:i8, Sum:i}
SumC_1(Arr<obj>, ia):ia
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      1) ret
  Total Size: 8

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::Exec(Seq<ia>, Func<ia,ia>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, bis:i*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumC(*1: bis, Mul(*1, *1))
###
> r8s->SumBigC(it * it)
r8s->SumBigC(it * it) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumBigC([map:1] Global(r8s), Mul(Scope(1), Scope(1)))))
// (<ctx>, ∂.r8s:r8*) : {Count:i8, Sum:r8}
SumBigC_1(Arr<obj>, r8):r8
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::Exec(Seq<r8>, Func<r8,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, r8s:r8*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumBigC(*1: r8s, Mul(*1, *1))
###
> r4s->SumBigC(it * it)
r4s->SumBigC(it * it) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumBigC([map:1] Global(r4s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1))))))
// (<ctx>, ∂.r4s:r4*) : {Count:i8, Sum:r8}
SumBigC_1(Arr<obj>, r4):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::Exec(Seq<r4>, Func<r4,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, r4s:r4*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumBigC(*1: r4s, Mul(Num<r8>(*1), Num<r8>(*1)))
###
> i8s->SumBigC(it * it)
i8s->SumBigC(it * it) : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC([map:1] Global(i8s), Num<i>(Mul(Scope(1), Scope(1))))))
// (<ctx>, ∂.i8s:i8*) : {Count:i8, Sum:i}
SumBigC_1(Arr<obj>, i8):ia
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::Exec(Seq<i8>, Func<i8,ia>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, i8s:i8*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumBigC(*1: i8s, Num<i>(Mul(*1, *1)))
###
> i4s->SumBigC(it * it)
i4s->SumBigC(it * it) : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC([map:1] Global(i4s), Num<i>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))))))
// (<ctx>, ∂.i4s:i4*) : {Count:i8, Sum:i}
SumBigC_1(Arr<obj>, i4):ia
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::Exec(Seq<i4>, Func<i4,ia>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, i4s:i4*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumBigC(*1: i4s, Num<i>(Mul(Num<i8>(*1), Num<i8>(*1))))
###
> u8s->SumBigC(it * it)
u8s->SumBigC(it * it) : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC([map:1] Global(u8s), Num<i>(Mul(Scope(1), Scope(1))))))
// (<ctx>, ∂.u8s:u8*) : {Count:i8, Sum:i}
SumBigC_1(Arr<obj>, u8):ia
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      5) newobj ia(u8)
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::Exec(Seq<u8>, Func<u8,ia>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, u8s:u8*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumBigC(*1: u8s, Num<i>(Mul(*1, *1)))
###
> u4s->SumBigC(it * it)
u4s->SumBigC(it * it) : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC([map:1] Global(u4s), Num<i>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))))))
// (<ctx>, ∂.u4s:u4*) : {Count:i8, Sum:i}
SumBigC_1(Arr<obj>, u4):ia
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::Exec(Seq<u4>, Func<u4,ia>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, u4s:u4*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumBigC(*1: u4s, Num<i>(Mul(Num<i8>(*1), Num<i8>(*1))))
###
> bis->SumBigC(it * it)
bis->SumBigC(it * it) : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC([map:1] Global(bis), Mul(Scope(1), Scope(1)))))
// (<ctx>, ∂.bis:i*) : {Count:i8, Sum:i}
SumBigC_1(Arr<obj>, ia):ia
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      1) ret
  Total Size: 8

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,ia>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::Exec(Seq<ia>, Func<ia,ia>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, bis:i*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumBigC(*1: bis, Mul(*1, *1))
###
> r8s->SumKC(it * it)
r8s->SumKC(it * it) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC([map:1] Global(r8s), Mul(Scope(1), Scope(1)))))
// (<ctx>, ∂.r8s:r8*) : {Count:i8, Sum:r8}
SumKC_1(Arr<obj>, r8):r8
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<r8>, Func<r8,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, r8s:r8*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumKC(*1: r8s, Mul(*1, *1))
###
> r4s->SumKC(it * it)
r4s->SumKC(it * it) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC([map:1] Global(r4s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1))))))
// (<ctx>, ∂.r4s:r4*) : {Count:i8, Sum:r8}
SumKC_1(Arr<obj>, r4):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<r4>, Func<r4,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, r4s:r4*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumKC(*1: r4s, Mul(Num<r8>(*1), Num<r8>(*1)))
###
> i8s->SumKC(it * it)
i8s->SumKC(it * it) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC([map:1] Global(i8s), Num<r8>(Mul(Scope(1), Scope(1))))))
// (<ctx>, ∂.i8s:i8*) : {Count:i8, Sum:r8}
SumKC_1(Arr<obj>, i8):r8
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<i8>, Func<i8,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, i8s:i8*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumKC(*1: i8s, Num<r8>(Mul(*1, *1)))
###
> i4s->SumKC(it * it)
i4s->SumKC(it * it) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC([map:1] Global(i4s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))))))
// (<ctx>, ∂.i4s:i4*) : {Count:i8, Sum:r8}
SumKC_1(Arr<obj>, i4):r8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<i4>, Func<i4,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, i4s:i4*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumKC(*1: i4s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*1))))
###
> u8s->SumKC(it * it)
u8s->SumKC(it * it) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC([map:1] Global(u8s), Num<r8>(Mul(Scope(1), Scope(1))))))
// (<ctx>, ∂.u8s:u8*) : {Count:i8, Sum:r8}
SumKC_1(Arr<obj>, u8):r8
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<u8>, Func<u8,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, u8s:u8*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumKC(*1: u8s, Num<r8>(Mul(*1, *1)))
###
> u4s->SumKC(it * it)
u4s->SumKC(it * it) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC([map:1] Global(u4s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))))))
// (<ctx>, ∂.u4s:u4*) : {Count:i8, Sum:r8}
SumKC_1(Arr<obj>, u4):r8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<u4>, Func<u4,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, u4s:u4*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumKC(*1: u4s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*1))))
###
> bis->SumKC(it * it)
bis->SumKC(it * it) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC([map:1] Global(bis), Num<r8>(Mul(Scope(1), Scope(1))))))
// (<ctx>, ∂.bis:i*) : {Count:i8, Sum:r8}
SumKC_1(Arr<obj>, ia):r8
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<ia>, Func<ia,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, bis:i*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumKC(*1: bis, Num<r8>(Mul(*1, *1)))
###
> r8s->MeanC(it * it)
r8s->MeanC(it * it) : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC([map:1] Global(r8s), Mul(Scope(1), Scope(1)))))
// (<ctx>, ∂.r8s:r8*) : {Count:i8, Mean:r8}
MeanC_1(Arr<obj>, r8):r8
      1) ldarg.1 [r8]
      1) ldarg.1 [r8]
      1) mul
      1) ret
  Total Size: 4

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldloc.1 [Seq<r8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<r8>, Func<r8,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, r8s:r8*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 28.5 }
*** Ctx ping count: 11
    [0](11): MeanC(*1: r8s, Mul(*1, *1))
###
> r4s->MeanC(it * it)
r4s->MeanC(it * it) : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC([map:1] Global(r4s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(1))))))
// (<ctx>, ∂.r4s:r4*) : {Count:i8, Mean:r8}
MeanC_1(Arr<obj>, r4):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldloc.1 [Seq<r4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<r4>, Func<r4,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, r4s:r4*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 28.5 }
*** Ctx ping count: 11
    [0](11): MeanC(*1: r4s, Mul(Num<r8>(*1), Num<r8>(*1)))
###
> i8s->MeanC(it * it)
i8s->MeanC(it * it) : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC([map:1] Global(i8s), Num<r8>(Mul(Scope(1), Scope(1))))))
// (<ctx>, ∂.i8s:i8*) : {Count:i8, Mean:r8}
MeanC_1(Arr<obj>, i8):r8
      1) ldarg.1 [i8]
      1) ldarg.1 [i8]
      1) mul
      1) conv.r8
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldloc.1 [Seq<i8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<i8>, Func<i8,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, i8s:i8*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 28.5 }
*** Ctx ping count: 11
    [0](11): MeanC(*1: i8s, Num<r8>(Mul(*1, *1)))
###
> i4s->MeanC(it * it)
i4s->MeanC(it * it) : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC([map:1] Global(i4s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))))))
// (<ctx>, ∂.i4s:i4*) : {Count:i8, Mean:r8}
MeanC_1(Arr<obj>, i4):r8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldloc.1 [Seq<i4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<i4>, Func<i4,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, i4s:i4*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 28.5 }
*** Ctx ping count: 11
    [0](11): MeanC(*1: i4s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*1))))
###
> u8s->MeanC(it * it)
u8s->MeanC(it * it) : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC([map:1] Global(u8s), Num<r8>(Mul(Scope(1), Scope(1))))))
// (<ctx>, ∂.u8s:u8*) : {Count:i8, Mean:r8}
MeanC_1(Arr<obj>, u8):r8
      1) ldarg.1 [u8]
      1) ldarg.1 [u8]
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      1) ret
  Total Size: 9

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldloc.1 [Seq<u8>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<u8>, Func<u8,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, u8s:u8*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 28.5 }
*** Ctx ping count: 11
    [0](11): MeanC(*1: u8s, Num<r8>(Mul(*1, *1)))
###
> u4s->MeanC(it * it)
u4s->MeanC(it * it) : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC([map:1] Global(u4s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(1)))))))
// (<ctx>, ∂.u4s:u4*) : {Count:i8, Mean:r8}
MeanC_1(Arr<obj>, u4):r8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.1 [u4]
      1) conv.u8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldloc.1 [Seq<u4>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<u4>, Func<u4,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, u4s:u4*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 28.5 }
*** Ctx ping count: 11
    [0](11): MeanC(*1: u4s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*1))))
###
> bis->MeanC(it * it)
bis->MeanC(it * it) : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC([map:1] Global(bis), Num<r8>(Mul(Scope(1), Scope(1))))))
// (<ctx>, ∂.bis:i*) : {Count:i8, Mean:r8}
MeanC_1(Arr<obj>, ia):r8
      1) ldarg.1 [ia]
      1) ldarg.1 [ia]
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldloc.1 [Seq<ia>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,r8>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<ia>, Func<ia,r8>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 75

Func sig: (<ctx>:x, bis:i*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 28.5 }
*** Ctx ping count: 11
    [0](11): MeanC(*1: bis, Num<r8>(Mul(*1, *1)))
###
> SumC(a: r8s, b: i2s, a * b)
SumC(a : r8s, b : i2s, a * b) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumC(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2s), Mul(Scope(1), Num<r8>(Scope(2)))):r8*))))
// (<ctx>, ∂.r8s:r8*, ∂.i2s:i2*) : {Count:i8, Sum:r8}
ForEach_2(Arr<obj>, r8, i2):r8
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, r8s:r8*, i2s:i2*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumC(ForEach(*1: r8s, *2: i2s, Mul(*1, Num<r8>(*2))))
###
> SumC(a: r4s, b: i2s, a * b)
SumC(a : r4s, b : i2s, a * b) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumC(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2)))):r8*))))
// (<ctx>, ∂.r4s:r4*, ∂.i2s:i2*) : {Count:i8, Sum:r8}
ForEach_2(Arr<obj>, r4, i2):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, r4s:r4*, i2s:i2*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumC(ForEach(*1: r4s, *2: i2s, Mul(Num<r8>(*1), Num<r8>(*2))))
###
> SumC(a: i8s, b: i2s, a * b)
SumC(a : i8s, b : i2s, a * b) : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2s), Mul(Scope(1), Num<i8>(Scope(2)))):i8*))))
// (<ctx>, ∂.i8s:i8*, ∂.i2s:i2*) : {Count:i8, Sum:i8}
ForEach_2(Arr<obj>, i8, i2):i8
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,i8>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,i8>):Seq<i8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<i8>):Seq<i8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.3 [{i8,i8}]
      1) ldloc.3 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      2) stloc.s [i8 (4)]
      1) ldloc.3 [{i8,i8}]
      2) ldloc.s [i8 (4)]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.3 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, i8s:i8*, i2s:i2*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumC(ForEach(*1: i8s, *2: i2s, Mul(*1, Num<i8>(*2))))
###
> SumC(a: i4s, b: i2s, a * b)
SumC(a : i4s, b : i2s, a * b) : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2s), Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))):i8*))))
// (<ctx>, ∂.i4s:i4*, ∂.i2s:i2*) : {Count:i8, Sum:i8}
ForEach_2(Arr<obj>, i4, i2):i8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,i8>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,i8>):Seq<i8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<i8>):Seq<i8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.3 [{i8,i8}]
      1) ldloc.3 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      2) stloc.s [i8 (4)]
      1) ldloc.3 [{i8,i8}]
      2) ldloc.s [i8 (4)]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.3 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, i4s:i4*, i2s:i2*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumC(ForEach(*1: i4s, *2: i2s, Mul(Num<i8>(*1), Num<i8>(*2))))
###
> SumC(a: u8s, b: u2s, a * b)
SumC(a : u8s, b : u2s, a * b) : {Count:i8, Sum:u8}
BndKind:Call, Type:{Count:i8, Sum:u8}, Bnd:(Call(∂.SumC(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2s), Mul(Scope(1), Num<u8>(Scope(2)))):u8*))))
// (<ctx>, ∂.u8s:u8*, ∂.u2s:u2*) : {Count:i8, Sum:u8}
ForEach_2(Arr<obj>, u8, u2):u8
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,u8>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,u8>):Seq<u8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<u8>):Seq<u8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,u8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,u8}::_B0:u1
      1) stloc.3 [{i8,u8}]
      1) ldloc.3 [{i8,u8}]
      5) ldflda {i8,u8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<u8>, ExecCtx, i4, out i8):u8
      2) stloc.s [u8 (4)]
      1) ldloc.3 [{i8,u8}]
      2) ldloc.s [u8 (4)]
      5) stfld {i8,u8}::_F1:u8
      1) ldloc.3 [{i8,u8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, u8s:u8*, u2s:u2*) to {Count:i8, Sum:u8}
Type: {i8,u8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumC(ForEach(*1: u8s, *2: u2s, Mul(*1, Num<u8>(*2))))
###
> SumC(a: u4s, b: u2s, a * b)
SumC(a : u4s, b : u2s, a * b) : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2s), Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2)))):i8*))))
// (<ctx>, ∂.u4s:u4*, ∂.u2s:u2*) : {Count:i8, Sum:i8}
ForEach_2(Arr<obj>, u4, u2):i8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,i8>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,i8>):Seq<i8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<i8>):Seq<i8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.3 [{i8,i8}]
      1) ldloc.3 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<i8>, ExecCtx, i4, out i8):i8
      2) stloc.s [i8 (4)]
      1) ldloc.3 [{i8,i8}]
      2) ldloc.s [i8 (4)]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.3 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, u4s:u4*, u2s:u2*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumC(ForEach(*1: u4s, *2: u2s, Mul(Num<i8>(*1), Num<i8>(*2))))
###
> SumC(a: bis, b: i2s, a * b)
SumC(a : bis, b : i2s, a * b) : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumC(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2s), Mul(Scope(1), Num<i>(Scope(2)))):i*))))
// (<ctx>, ∂.bis:i*, ∂.i2s:i2*) : {Count:i8, Sum:i}
ForEach_2(Arr<obj>, ia, i2):ia
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,ia>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,ia>):Seq<ia>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<ia>):Seq<ia>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.3 [{i8,ia}]
      1) ldloc.3 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      2) stloc.s [ia (4)]
      1) ldloc.3 [{i8,ia}]
      2) ldloc.s [ia (4)]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.3 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, bis:i*, i2s:i2*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumC(ForEach(*1: bis, *2: i2s, Mul(*1, Num<i>(*2))))
###
> SumBigC(a: r8s, b: i2s, a * b)
SumBigC(a : r8s, b : i2s, a * b) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumBigC(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2s), Mul(Scope(1), Num<r8>(Scope(2)))):r8*))))
// (<ctx>, ∂.r8s:r8*, ∂.i2s:i2*) : {Count:i8, Sum:r8}
ForEach_2(Arr<obj>, r8, i2):r8
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, r8s:r8*, i2s:i2*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumBigC(ForEach(*1: r8s, *2: i2s, Mul(*1, Num<r8>(*2))))
###
> SumBigC(a: r4s, b: i2s, a * b)
SumBigC(a : r4s, b : i2s, a * b) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumBigC(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2)))):r8*))))
// (<ctx>, ∂.r4s:r4*, ∂.i2s:i2*) : {Count:i8, Sum:r8}
ForEach_2(Arr<obj>, r4, i2):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, r4s:r4*, i2s:i2*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumBigC(ForEach(*1: r4s, *2: i2s, Mul(Num<r8>(*1), Num<r8>(*2))))
###
> SumBigC(a: i8s, b: i2s, a * b)
SumBigC(a : i8s, b : i2s, a * b) : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2s), Num<i>(Mul(Scope(1), Num<i8>(Scope(2))))):i*))))
// (<ctx>, ∂.i8s:i8*, ∂.i2s:i2*) : {Count:i8, Sum:i}
ForEach_2(Arr<obj>, i8, i2):ia
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,ia>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,ia>):Seq<ia>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<ia>):Seq<ia>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.3 [{i8,ia}]
      1) ldloc.3 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      2) stloc.s [ia (4)]
      1) ldloc.3 [{i8,ia}]
      2) ldloc.s [ia (4)]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.3 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, i8s:i8*, i2s:i2*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumBigC(ForEach(*1: i8s, *2: i2s, Num<i>(Mul(*1, Num<i8>(*2)))))
###
> SumBigC(a: i4s, b: i2s, a * b)
SumBigC(a : i4s, b : i2s, a * b) : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2s), Num<i>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):i*))))
// (<ctx>, ∂.i4s:i4*, ∂.i2s:i2*) : {Count:i8, Sum:i}
ForEach_2(Arr<obj>, i4, i2):ia
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,ia>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,ia>):Seq<ia>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<ia>):Seq<ia>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.3 [{i8,ia}]
      1) ldloc.3 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      2) stloc.s [ia (4)]
      1) ldloc.3 [{i8,ia}]
      2) ldloc.s [ia (4)]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.3 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, i4s:i4*, i2s:i2*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumBigC(ForEach(*1: i4s, *2: i2s, Num<i>(Mul(Num<i8>(*1), Num<i8>(*2)))))
###
> SumBigC(a: u8s, b: u2s, a * b)
SumBigC(a : u8s, b : u2s, a * b) : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2s), Num<i>(Mul(Scope(1), Num<u8>(Scope(2))))):i*))))
// (<ctx>, ∂.u8s:u8*, ∂.u2s:u2*) : {Count:i8, Sum:i}
ForEach_2(Arr<obj>, u8, u2):ia
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) newobj ia(u8)
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,ia>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,ia>):Seq<ia>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<ia>):Seq<ia>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.3 [{i8,ia}]
      1) ldloc.3 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      2) stloc.s [ia (4)]
      1) ldloc.3 [{i8,ia}]
      2) ldloc.s [ia (4)]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.3 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, u8s:u8*, u2s:u2*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumBigC(ForEach(*1: u8s, *2: u2s, Num<i>(Mul(*1, Num<u8>(*2)))))
###
> SumBigC(a: u4s, b: u2s, a * b)
SumBigC(a : u4s, b : u2s, a * b) : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2s), Num<i>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):i*))))
// (<ctx>, ∂.u4s:u4*, ∂.u2s:u2*) : {Count:i8, Sum:i}
ForEach_2(Arr<obj>, u4, u2):ia
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) newobj ia(i8)
      1) ret
  Total Size: 11

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,ia>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,ia>):Seq<ia>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<ia>):Seq<ia>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.3 [{i8,ia}]
      1) ldloc.3 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      2) stloc.s [ia (4)]
      1) ldloc.3 [{i8,ia}]
      2) ldloc.s [ia (4)]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.3 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, u4s:u4*, u2s:u2*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumBigC(ForEach(*1: u4s, *2: u2s, Num<i>(Mul(Num<i8>(*1), Num<i8>(*2)))))
###
> SumBigC(a: bis, b: i2s, a * b)
SumBigC(a : bis, b : i2s, a * b) : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2s), Mul(Scope(1), Num<i>(Scope(2)))):i*))))
// (<ctx>, ∂.bis:i*, ∂.i2s:i2*) : {Count:i8, Sum:i}
ForEach_2(Arr<obj>, ia, i2):ia
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      1) ret
  Total Size: 13

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,ia>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,ia>):Seq<ia>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<ia>):Seq<ia>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.3 [{i8,ia}]
      1) ldloc.3 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<ia>, ExecCtx, i4, out i8):ia
      2) stloc.s [ia (4)]
      1) ldloc.3 [{i8,ia}]
      2) ldloc.s [ia (4)]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.3 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, bis:i*, i2s:i2*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumBigC(ForEach(*1: bis, *2: i2s, Mul(*1, Num<i>(*2))))
###
> SumKC(a: r8s, b: i2s, a * b)
SumKC(a : r8s, b : i2s, a * b) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2s), Mul(Scope(1), Num<r8>(Scope(2)))):r8*))))
// (<ctx>, ∂.r8s:r8*, ∂.i2s:i2*) : {Count:i8, Sum:r8}
ForEach_2(Arr<obj>, r8, i2):r8
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, r8s:r8*, i2s:i2*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumKC(ForEach(*1: r8s, *2: i2s, Mul(*1, Num<r8>(*2))))
###
> SumKC(a: r4s, b: i2s, a * b)
SumKC(a : r4s, b : i2s, a * b) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2)))):r8*))))
// (<ctx>, ∂.r4s:r4*, ∂.i2s:i2*) : {Count:i8, Sum:r8}
ForEach_2(Arr<obj>, r4, i2):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, r4s:r4*, i2s:i2*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumKC(ForEach(*1: r4s, *2: i2s, Mul(Num<r8>(*1), Num<r8>(*2))))
###
> SumKC(a: i8s, b: i2s, a * b)
SumKC(a : i8s, b : i2s, a * b) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2s), Num<r8>(Mul(Scope(1), Num<i8>(Scope(2))))):r8*))))
// (<ctx>, ∂.i8s:i8*, ∂.i2s:i2*) : {Count:i8, Sum:r8}
ForEach_2(Arr<obj>, i8, i2):r8
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, i8s:i8*, i2s:i2*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumKC(ForEach(*1: i8s, *2: i2s, Num<r8>(Mul(*1, Num<i8>(*2)))))
###
> SumKC(a: i4s, b: i2s, a * b)
SumKC(a : i4s, b : i2s, a * b) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):r8*))))
// (<ctx>, ∂.i4s:i4*, ∂.i2s:i2*) : {Count:i8, Sum:r8}
ForEach_2(Arr<obj>, i4, i2):r8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, i4s:i4*, i2s:i2*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumKC(ForEach(*1: i4s, *2: i2s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*2)))))
###
> SumKC(a: u8s, b: u2s, a * b)
SumKC(a : u8s, b : u2s, a * b) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2s), Num<r8>(Mul(Scope(1), Num<u8>(Scope(2))))):r8*))))
// (<ctx>, ∂.u8s:u8*, ∂.u2s:u2*) : {Count:i8, Sum:r8}
ForEach_2(Arr<obj>, u8, u2):r8
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,r8>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, u8s:u8*, u2s:u2*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumKC(ForEach(*1: u8s, *2: u2s, Num<r8>(Mul(*1, Num<u8>(*2)))))
###
> SumKC(a: u4s, b: u2s, a * b)
SumKC(a : u4s, b : u2s, a * b) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):r8*))))
// (<ctx>, ∂.u4s:u4*, ∂.u2s:u2*) : {Count:i8, Sum:r8}
ForEach_2(Arr<obj>, u4, u2):r8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,r8>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, u4s:u4*, u2s:u2*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumKC(ForEach(*1: u4s, *2: u2s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*2)))))
###
> SumKC(a: bis, b: i2s, a * b)
SumKC(a : bis, b : i2s, a * b) : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2s), Num<r8>(Mul(Scope(1), Num<i>(Scope(2))))):r8*))))
// (<ctx>, ∂.bis:i*, ∂.i2s:i2*) : {Count:i8, Sum:r8}
ForEach_2(Arr<obj>, ia, i2):r8
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      1) ret
  Total Size: 18

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,r8>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, bis:i*, i2s:i2*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 10, Sum: 285 }
*** Ctx ping count: 11
    [0](11): SumKC(ForEach(*1: bis, *2: i2s, Num<r8>(Mul(*1, Num<i>(*2)))))
###
> MeanC(a: r8s, b: i2s, a * b)
MeanC(a : r8s, b : i2s, a * b) : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Call(∂.ForEach([map:1] Global(r8s), [map:2] Global(i2s), Mul(Scope(1), Num<r8>(Scope(2)))):r8*))))
// (<ctx>, ∂.r8s:r8*, ∂.i2s:i2*) : {Count:i8, Mean:r8}
ForEach_2(Arr<obj>, r8, i2):r8
      1) ldarg.1 [r8]
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 5

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r8>
      1) stloc.1 [Seq<r8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r8>, Seq<i2>, Func<r8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, r8s:r8*, i2s:i2*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 28.5 }
*** Ctx ping count: 11
    [0](11): MeanC(ForEach(*1: r8s, *2: i2s, Mul(*1, Num<r8>(*2))))
###
> MeanC(a: r4s, b: i2s, a * b)
MeanC(a : r4s, b : i2s, a * b) : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Call(∂.ForEach([map:1] Global(r4s), [map:2] Global(i2s), Mul(Num<r8>(Scope(1)), Num<r8>(Scope(2)))):r8*))))
// (<ctx>, ∂.r4s:r4*, ∂.i2s:i2*) : {Count:i8, Mean:r8}
ForEach_2(Arr<obj>, r4, i2):r8
      1) ldarg.1 [r4]
      1) conv.r8
      1) ldarg.2 [i2]
      1) conv.r8
      1) mul
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<r4>
      1) stloc.1 [Seq<r4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<r4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<r4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<r4>, Seq<i2>, Func<r4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, r4s:r4*, i2s:i2*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 28.5 }
*** Ctx ping count: 11
    [0](11): MeanC(ForEach(*1: r4s, *2: i2s, Mul(Num<r8>(*1), Num<r8>(*2))))
###
> MeanC(a: i8s, b: i2s, a * b)
MeanC(a : i8s, b : i2s, a * b) : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Call(∂.ForEach([map:1] Global(i8s), [map:2] Global(i2s), Num<r8>(Mul(Scope(1), Num<i8>(Scope(2))))):r8*))))
// (<ctx>, ∂.i8s:i8*, ∂.i2s:i2*) : {Count:i8, Mean:r8}
ForEach_2(Arr<obj>, i8, i2):r8
      1) ldarg.1 [i8]
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 6

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i8>
      1) stloc.1 [Seq<i8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i8>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i8,i2,r8>]
      5) call static ForEachGen::Exec(Seq<i8>, Seq<i2>, Func<i8,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, i8s:i8*, i2s:i2*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 28.5 }
*** Ctx ping count: 11
    [0](11): MeanC(ForEach(*1: i8s, *2: i2s, Num<r8>(Mul(*1, Num<i8>(*2)))))
###
> MeanC(a: i4s, b: i2s, a * b)
MeanC(a : i4s, b : i2s, a * b) : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Call(∂.ForEach([map:1] Global(i4s), [map:2] Global(i2s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):r8*))))
// (<ctx>, ∂.i4s:i4*, ∂.i2s:i2*) : {Count:i8, Mean:r8}
ForEach_2(Arr<obj>, i4, i2):r8
      1) ldarg.1 [i4]
      1) conv.i8
      1) ldarg.2 [i2]
      1) conv.i8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i4>
      1) stloc.1 [Seq<i4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<i4>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<i4,i2,r8>]
      5) call static ForEachGen::Exec(Seq<i4>, Seq<i2>, Func<i4,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, i4s:i4*, i2s:i2*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 28.5 }
*** Ctx ping count: 11
    [0](11): MeanC(ForEach(*1: i4s, *2: i2s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*2)))))
###
> MeanC(a: u8s, b: u2s, a * b)
MeanC(a : u8s, b : u2s, a * b) : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Call(∂.ForEach([map:1] Global(u8s), [map:2] Global(u2s), Num<r8>(Mul(Scope(1), Num<u8>(Scope(2))))):r8*))))
// (<ctx>, ∂.u8s:u8*, ∂.u2s:u2*) : {Count:i8, Mean:r8}
ForEach_2(Arr<obj>, u8, u2):r8
      1) ldarg.1 [u8]
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      5) call static NumUtil::ToR8(u8):r8
      1) ret
  Total Size: 10

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u8>
      1) stloc.1 [Seq<u8>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u8>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u8,u2,r8>]
      5) call static ForEachGen::Exec(Seq<u8>, Seq<u2>, Func<u8,u2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, u8s:u8*, u2s:u2*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 28.5 }
*** Ctx ping count: 11
    [0](11): MeanC(ForEach(*1: u8s, *2: u2s, Num<r8>(Mul(*1, Num<u8>(*2)))))
###
> MeanC(a: u4s, b: u2s, a * b)
MeanC(a : u4s, b : u2s, a * b) : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Call(∂.ForEach([map:1] Global(u4s), [map:2] Global(u2s), Num<r8>(Mul(Num<i8>(Scope(1)), Num<i8>(Scope(2))))):r8*))))
// (<ctx>, ∂.u4s:u4*, ∂.u2s:u2*) : {Count:i8, Mean:r8}
ForEach_2(Arr<obj>, u4, u2):r8
      1) ldarg.1 [u4]
      1) conv.u8
      1) ldarg.2 [u2]
      1) conv.u8
      1) mul
      1) conv.r8
      1) ret
  Total Size: 7

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u4>
      1) stloc.1 [Seq<u4>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<u2>
      1) stloc.2 [Seq<u2>]
      1) ldloc.1 [Seq<u4>]
      1) ldloc.2 [Seq<u2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<u4,u2,r8>]
      5) call static ForEachGen::Exec(Seq<u4>, Seq<u2>, Func<u4,u2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, u4s:u4*, u2s:u2*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 28.5 }
*** Ctx ping count: 11
    [0](11): MeanC(ForEach(*1: u4s, *2: u2s, Num<r8>(Mul(Num<i8>(*1), Num<i8>(*2)))))
###
> MeanC(a: bis, b: i2s, a * b)
MeanC(a : bis, b : i2s, a * b) : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Call(∂.ForEach([map:1] Global(bis), [map:2] Global(i2s), Num<r8>(Mul(Scope(1), Num<i>(Scope(2))))):r8*))))
// (<ctx>, ∂.bis:i*, ∂.i2s:i2*) : {Count:i8, Mean:r8}
ForEach_2(Arr<obj>, ia, i2):r8
      1) ldarg.1 [ia]
      1) ldarg.2 [i2]
      5) newobj ia(i4)
      5) call static ia::op_Multiply(ia, ia):ia
      5) call static NumUtil::ToR8(ia):r8
      1) ret
  Total Size: 18

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<ia>
      1) stloc.1 [Seq<ia>]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.2
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<i2>
      1) stloc.2 [Seq<i2>]
      1) ldloc.1 [Seq<ia>]
      1) ldloc.2 [Seq<i2>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<ia,i2,r8>]
      5) call static ForEachGen::Exec(Seq<ia>, Seq<i2>, Func<ia,i2,r8>):Seq<r8>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<r8>):Seq<r8>
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.3 [{i8,r8}]
      1) ldloc.3 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<r8>, ExecCtx, i4, out i8):r8
      2) stloc.s [r8 (4)]
      1) ldloc.3 [{i8,r8}]
      2) ldloc.s [r8 (4)]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.3 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 97

Func sig: (<ctx>:x, bis:i*, i2s:i2*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 10, Mean: 28.5 }
*** Ctx ping count: 11
    [0](11): MeanC(ForEach(*1: bis, *2: i2s, Num<r8>(Mul(*1, Num<i>(*2)))))
###
> or8s->SumC()
or8s->SumC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumC(Global(or8s))))
// (<ctx>, ∂.or8s:r8?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, or8s:r8?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumC(or8s)
###
> or4s->SumC()
or4s->SumC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumC(Global(or4s))))
// (<ctx>, ∂.or4s:r4?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, or4s:r4?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumC(or4s)
###
> oi8s->SumC()
oi8s->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(oi8s))))
// (<ctx>, ∂.oi8s:i8?*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<Opt<i8>>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi8s:i8?*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumC(oi8s)
###
> oi4s->SumC()
oi4s->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(oi4s))))
// (<ctx>, ∂.oi4s:i4?*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<Opt<i4>>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi4s:i4?*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumC(oi4s)
###
> oi2s->SumC()
oi2s->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(oi2s))))
// (<ctx>, ∂.oi2s:i2?*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<Opt<i2>>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi2s:i2?*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumC(oi2s)
###
> oi1s->SumC()
oi1s->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(oi1s))))
// (<ctx>, ∂.oi1s:i1?*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<Opt<i1>>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi1s:i1?*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumC(oi1s)
###
> ou8s->SumC()
ou8s->SumC() : {Count:i8, Sum:u8}
BndKind:Call, Type:{Count:i8, Sum:u8}, Bnd:(Call(∂.SumC(Global(ou8s))))
// (<ctx>, ∂.ou8s:u8?*) : {Count:i8, Sum:u8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,u8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,u8}::_B0:u1
      1) stloc.2 [{i8,u8}]
      1) ldloc.2 [{i8,u8}]
      5) ldflda {i8,u8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<Opt<u8>>, ExecCtx, i4, out i8):u8
      1) stloc.3 [u8]
      1) ldloc.2 [{i8,u8}]
      1) ldloc.3 [u8]
      5) stfld {i8,u8}::_F1:u8
      1) ldloc.2 [{i8,u8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou8s:u8?*) to {Count:i8, Sum:u8}
Type: {i8,u8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumC(ou8s)
###
> ou4s->SumC()
ou4s->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(ou4s))))
// (<ctx>, ∂.ou4s:u4?*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<Opt<u4>>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou4s:u4?*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumC(ou4s)
###
> ou2s->SumC()
ou2s->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(ou2s))))
// (<ctx>, ∂.ou2s:u2?*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<Opt<u2>>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou2s:u2?*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumC(ou2s)
###
> ou1s->SumC()
ou1s->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(ou1s))))
// (<ctx>, ∂.ou1s:u1?*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<Opt<u1>>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou1s:u1?*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumC(ou1s)
###
> obs->SumC()
obs->SumC() : {Count:i8, Sum:i8}
BndKind:Call, Type:{Count:i8, Sum:i8}, Bnd:(Call(∂.SumC(Global(obs))))
// (<ctx>, ∂.obs:b?*) : {Count:i8, Sum:i8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<bool>>
      1) stloc.1 [Seq<Opt<bool>>]
      1) ldloc.1 [Seq<Opt<bool>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.2 [{i8,i8}]
      1) ldloc.2 [{i8,i8}]
      5) ldflda {i8,i8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<Opt<bool>>, ExecCtx, i4, out i8):i8
      1) stloc.3 [i8]
      1) ldloc.2 [{i8,i8}]
      1) ldloc.3 [i8]
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.2 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, obs:b?*) to {Count:i8, Sum:i8}
Type: {i8,i8}, Value: { Count: 9, Sum: 5 }
*** Ctx ping count: 11
    [0](11): SumC(obs)
###
> obis->SumC()
obis->SumC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumC(Global(obis))))
// (<ctx>, ∂.obis:i?*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<Opt<ia>>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, obis:i?*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumC(obis)
###
> or8s->SumBigC()
or8s->SumBigC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumBigC(Global(or8s))))
// (<ctx>, ∂.or8s:r8?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, or8s:r8?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumBigC(or8s)
###
> or4s->SumBigC()
or4s->SumBigC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumBigC(Global(or4s))))
// (<ctx>, ∂.or4s:r4?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecSum(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, or4s:r4?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumBigC(or4s)
###
> oi8s->SumBigC()
oi8s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(oi8s))))
// (<ctx>, ∂.oi8s:i8?*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<Opt<i8>>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi8s:i8?*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumBigC(oi8s)
###
> oi4s->SumBigC()
oi4s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(oi4s))))
// (<ctx>, ∂.oi4s:i4?*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<Opt<i4>>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi4s:i4?*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumBigC(oi4s)
###
> oi2s->SumBigC()
oi2s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(oi2s))))
// (<ctx>, ∂.oi2s:i2?*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<Opt<i2>>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi2s:i2?*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumBigC(oi2s)
###
> oi1s->SumBigC()
oi1s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(oi1s))))
// (<ctx>, ∂.oi1s:i1?*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<Opt<i1>>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi1s:i1?*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumBigC(oi1s)
###
> ou8s->SumBigC()
ou8s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(ou8s))))
// (<ctx>, ∂.ou8s:u8?*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<Opt<u8>>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou8s:u8?*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumBigC(ou8s)
###
> ou4s->SumBigC()
ou4s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(ou4s))))
// (<ctx>, ∂.ou4s:u4?*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<Opt<u4>>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou4s:u4?*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumBigC(ou4s)
###
> ou2s->SumBigC()
ou2s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(ou2s))))
// (<ctx>, ∂.ou2s:u2?*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<Opt<u2>>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou2s:u2?*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumBigC(ou2s)
###
> ou1s->SumBigC()
ou1s->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(ou1s))))
// (<ctx>, ∂.ou1s:u1?*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<Opt<u1>>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou1s:u1?*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumBigC(ou1s)
###
> obs->SumBigC()
obs->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(obs))))
// (<ctx>, ∂.obs:b?*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<bool>>
      1) stloc.1 [Seq<Opt<bool>>]
      1) ldloc.1 [Seq<Opt<bool>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecBig(Seq<Opt<bool>>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, obs:b?*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 9, Sum: 5 }
*** Ctx ping count: 11
    [0](11): SumBigC(obs)
###
> obis->SumBigC()
obis->SumBigC() : {Count:i8, Sum:i}
BndKind:Call, Type:{Count:i8, Sum:i}, Bnd:(Call(∂.SumBigC(Global(obis))))
// (<ctx>, ∂.obis:i?*) : {Count:i8, Sum:i}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,ia}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,ia}::_B0:u1
      1) stloc.2 [{i8,ia}]
      1) ldloc.2 [{i8,ia}]
      5) ldflda {i8,ia}::_F0:i8
      5) call static SumBaseGen::ExecS(Seq<Opt<ia>>, ExecCtx, i4, out i8):ia
      1) stloc.3 [ia]
      1) ldloc.2 [{i8,ia}]
      1) ldloc.3 [ia]
      5) stfld {i8,ia}::_F1:ia
      1) ldloc.2 [{i8,ia}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, obis:i?*) to {Count:i8, Sum:i}
Type: {i8,ia}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumBigC(obis)
###
> or8s->SumKC()
or8s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(or8s))))
// (<ctx>, ∂.or8s:r8?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, or8s:r8?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumKC(or8s)
###
> or4s->SumKC()
or4s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(or4s))))
// (<ctx>, ∂.or4s:r4?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, or4s:r4?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumKC(or4s)
###
> oi8s->SumKC()
oi8s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(oi8s))))
// (<ctx>, ∂.oi8s:i8?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<Opt<i8>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi8s:i8?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumKC(oi8s)
###
> oi4s->SumKC()
oi4s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(oi4s))))
// (<ctx>, ∂.oi4s:i4?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<Opt<i4>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi4s:i4?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumKC(oi4s)
###
> oi2s->SumKC()
oi2s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(oi2s))))
// (<ctx>, ∂.oi2s:i2?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<Opt<i2>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi2s:i2?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumKC(oi2s)
###
> oi1s->SumKC()
oi1s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(oi1s))))
// (<ctx>, ∂.oi1s:i1?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<Opt<i1>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi1s:i1?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumKC(oi1s)
###
> ou8s->SumKC()
ou8s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(ou8s))))
// (<ctx>, ∂.ou8s:u8?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<Opt<u8>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou8s:u8?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumKC(ou8s)
###
> ou4s->SumKC()
ou4s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(ou4s))))
// (<ctx>, ∂.ou4s:u4?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<Opt<u4>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou4s:u4?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumKC(ou4s)
###
> ou2s->SumKC()
ou2s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(ou2s))))
// (<ctx>, ∂.ou2s:u2?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<Opt<u2>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou2s:u2?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumKC(ou2s)
###
> ou1s->SumKC()
ou1s->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(ou1s))))
// (<ctx>, ∂.ou1s:u1?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<Opt<u1>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou1s:u1?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumKC(ou1s)
###
> obs->SumKC()
obs->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(obs))))
// (<ctx>, ∂.obs:b?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<bool>>
      1) stloc.1 [Seq<Opt<bool>>]
      1) ldloc.1 [Seq<Opt<bool>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<Opt<bool>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, obs:b?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 5 }
*** Ctx ping count: 11
    [0](11): SumKC(obs)
###
> obis->SumKC()
obis->SumKC() : {Count:i8, Sum:r8}
BndKind:Call, Type:{Count:i8, Sum:r8}, Bnd:(Call(∂.SumKC(Global(obis))))
// (<ctx>, ∂.obis:i?*) : {Count:i8, Sum:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecK(Seq<Opt<ia>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, obis:i?*) to {Count:i8, Sum:r8}
Type: {i8,r8}, Value: { Count: 9, Sum: 40 }
*** Ctx ping count: 11
    [0](11): SumKC(obis)
###
> or8s->MeanC()
or8s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(or8s))))
// (<ctx>, ∂.or8s:r8?*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r8>>
      1) stloc.1 [Seq<Opt<r8>>]
      1) ldloc.1 [Seq<Opt<r8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<Opt<r8>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, or8s:r8?*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 9, Mean: 4.444444444444445 }
*** Ctx ping count: 11
    [0](11): MeanC(or8s)
###
> or4s->MeanC()
or4s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(or4s))))
// (<ctx>, ∂.or4s:r4?*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<r4>>
      1) stloc.1 [Seq<Opt<r4>>]
      1) ldloc.1 [Seq<Opt<r4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<Opt<r4>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, or4s:r4?*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 9, Mean: 4.444444444444445 }
*** Ctx ping count: 11
    [0](11): MeanC(or4s)
###
> oi8s->MeanC()
oi8s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(oi8s))))
// (<ctx>, ∂.oi8s:i8?*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i8>>
      1) stloc.1 [Seq<Opt<i8>>]
      1) ldloc.1 [Seq<Opt<i8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<Opt<i8>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi8s:i8?*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 9, Mean: 4.444444444444445 }
*** Ctx ping count: 11
    [0](11): MeanC(oi8s)
###
> oi4s->MeanC()
oi4s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(oi4s))))
// (<ctx>, ∂.oi4s:i4?*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i4>>
      1) stloc.1 [Seq<Opt<i4>>]
      1) ldloc.1 [Seq<Opt<i4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<Opt<i4>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi4s:i4?*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 9, Mean: 4.444444444444445 }
*** Ctx ping count: 11
    [0](11): MeanC(oi4s)
###
> oi2s->MeanC()
oi2s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(oi2s))))
// (<ctx>, ∂.oi2s:i2?*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i2>>
      1) stloc.1 [Seq<Opt<i2>>]
      1) ldloc.1 [Seq<Opt<i2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<Opt<i2>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi2s:i2?*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 9, Mean: 4.444444444444445 }
*** Ctx ping count: 11
    [0](11): MeanC(oi2s)
###
> oi1s->MeanC()
oi1s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(oi1s))))
// (<ctx>, ∂.oi1s:i1?*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<i1>>
      1) stloc.1 [Seq<Opt<i1>>]
      1) ldloc.1 [Seq<Opt<i1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<Opt<i1>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, oi1s:i1?*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 9, Mean: 4.444444444444445 }
*** Ctx ping count: 11
    [0](11): MeanC(oi1s)
###
> ou8s->MeanC()
ou8s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(ou8s))))
// (<ctx>, ∂.ou8s:u8?*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u8>>
      1) stloc.1 [Seq<Opt<u8>>]
      1) ldloc.1 [Seq<Opt<u8>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<Opt<u8>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou8s:u8?*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 9, Mean: 4.444444444444445 }
*** Ctx ping count: 11
    [0](11): MeanC(ou8s)
###
> ou4s->MeanC()
ou4s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(ou4s))))
// (<ctx>, ∂.ou4s:u4?*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u4>>
      1) stloc.1 [Seq<Opt<u4>>]
      1) ldloc.1 [Seq<Opt<u4>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<Opt<u4>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou4s:u4?*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 9, Mean: 4.444444444444445 }
*** Ctx ping count: 11
    [0](11): MeanC(ou4s)
###
> ou2s->MeanC()
ou2s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(ou2s))))
// (<ctx>, ∂.ou2s:u2?*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u2>>
      1) stloc.1 [Seq<Opt<u2>>]
      1) ldloc.1 [Seq<Opt<u2>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<Opt<u2>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou2s:u2?*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 9, Mean: 4.444444444444445 }
*** Ctx ping count: 11
    [0](11): MeanC(ou2s)
###
> ou1s->MeanC()
ou1s->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(ou1s))))
// (<ctx>, ∂.ou1s:u1?*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<u1>>
      1) stloc.1 [Seq<Opt<u1>>]
      1) ldloc.1 [Seq<Opt<u1>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<Opt<u1>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, ou1s:u1?*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 9, Mean: 4.444444444444445 }
*** Ctx ping count: 11
    [0](11): MeanC(ou1s)
###
> obs->MeanC()
obs->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(obs))))
// (<ctx>, ∂.obs:b?*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<bool>>
      1) stloc.1 [Seq<Opt<bool>>]
      1) ldloc.1 [Seq<Opt<bool>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<Opt<bool>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, obs:b?*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 9, Mean: 0.5555555555555556 }
*** Ctx ping count: 11
    [0](11): MeanC(obs)
###
> obis->MeanC()
obis->MeanC() : {Count:i8, Mean:r8}
BndKind:Call, Type:{Count:i8, Mean:r8}, Bnd:(Call(∂.MeanC(Global(obis))))
// (<ctx>, ∂.obis:i?*) : {Count:i8, Mean:r8}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):ExecCtx
      1) stloc.0 [ExecCtx]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<Opt<ia>>
      1) stloc.1 [Seq<Opt<ia>>]
      1) ldloc.1 [Seq<Opt<ia>>]
      1) ldloc.0 [ExecCtx]
      1) ldc.i4.0
      5) newobj {i8,r8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,r8}::_B0:u1
      1) stloc.2 [{i8,r8}]
      1) ldloc.2 [{i8,r8}]
      5) ldflda {i8,r8}::_F0:i8
      5) call static SumBaseGen::ExecMean(Seq<Opt<ia>>, ExecCtx, i4, out i8):r8
      1) stloc.3 [r8]
      1) ldloc.2 [{i8,r8}]
      1) ldloc.3 [r8]
      5) stfld {i8,r8}::_F1:r8
      1) ldloc.2 [{i8,r8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 68

Func sig: (<ctx>:x, obis:i?*) to {Count:i8, Mean:r8}
Type: {i8,r8}, Value: { Count: 9, Mean: 4.444444444444445 }
*** Ctx ping count: 11
    [0](11): MeanC(obis)
###
