**** New definitions: T, type: {X:i8, Y:i8}?*

> T->&{ X }
T+>{ X } : {X:i8, Y:i8}?*
BndKind:Global, Type:{X:i8, Y:i8}?*, Bnd:(Global(T))
// (∂.T:{X:i8, Y:i8}?*) : {X:i8, Y: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):Seq<{i8,i8}>
      1) stloc.0 [Seq<{i8,i8}>]
      1) ldloc.0 [Seq<{i8,i8}>]
      1) ret
  Total Size: 11

Func sig: (T:{X:i8, Y:i8}?*) to {X:i8, Y:i8}?*
Sequence: Seq<{i8,i8}>
 0) { X: 0, Y: 3 }
 1) { X: 1, Y: 4 }
 2) <null>
 3) { X: 3, Y: 12 }
 4) { X: 4, Y: 19 }
 5) <null>
 6) { X: 6, Y: 39 }
 7) { X: 7, Y: 52 }
 8) <null>
 9) { X: 9, Y: 84 }
###
> T->&{ X: null }
T+>{ X : null } : {Y:i8}?*
BndKind:Call, Type:{Y:i8}?*, Bnd:(Call(∂.ForEach([map:1] Global(T), Call(∂.Guard([guard:2] Scope(1), SetFields(Scope(2)))))))
// (∂.T:{X:i8, Y:i8}?*) : {Y:i8}?*
ForEach_1(Arr<obj>, {i8,i8}):{i8}
      1) ldarg.1 [{i8,i8}]
      5) brfalse [0]
      5) newobj {i8}()
      1) dup
      1) ldc.i4.1
      5) stfld {i8}::_B0:u1
      1) stloc.0 [{i8}]
      1) ldloc.0 [{i8}]
      1) ldarg.1 [{i8,i8}]
      5) ldfld {i8,i8}::_F1:i8
      5) stfld {i8}::_F0:i8
      1) ldloc.0 [{i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      5) br [1]
  Label [0]:
      1) ldnull
  Label [1]:
      1) ret
  Total Size: 52

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<{i8,i8}>
      1) stloc.0 [Seq<{i8,i8}>]
      1) ldloc.0 [Seq<{i8,i8}>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<{i8,i8},{i8}>]
      5) call static ForEachGen::Exec(Seq<{i8,i8}>, Func<{i8,i8},{i8}>):Seq<{i8}>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<{i8}>):Seq<{i8}>
      1) ret
  Total Size: 28

Func sig: (T:{X:i8, Y:i8}?*) to {Y:i8}?*
Sequence: Seq<{i8}>
 0) { Y: 3 }
 1) { Y: 4 }
 2) <null>
 3) { Y: 12 }
 4) { Y: 19 }
 5) <null>
 6) { Y: 39 }
 7) { Y: 52 }
 8) <null>
 9) { Y: 84 }
###
> T->&{ X: null, Z: X + 17 }
T+>{ X : null, Z : X + 17 } : {Y:i8, Z:i8}?*
BndKind:Call, Type:{Y:i8, Z:i8}?*, Bnd:(Call(∂.ForEach([map:1] Global(T), Call(∂.Guard([guard:2] Scope(1), SetFields([with:3] Scope(2), Z : Add(GetField(Scope(3), X), 17:i8)))))))
// (∂.T:{X:i8, Y:i8}?*) : {Y:i8, Z:i8}?*
ForEach_1(Arr<obj>, {i8,i8}):{i8,i8}
      1) ldarg.1 [{i8,i8}]
      5) brfalse [0]
      5) newobj {i8,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,i8}::_B0:u1
      1) stloc.0 [{i8,i8}]
      1) ldloc.0 [{i8,i8}]
      1) ldarg.1 [{i8,i8}]
      5) ldfld {i8,i8}::_F0:i8
      2) ldc.i4.s [17]
      1) conv.i8
      1) add
      5) stfld {i8,i8}::_F1:i8
      1) ldloc.0 [{i8,i8}]
      1) ldarg.1 [{i8,i8}]
      5) ldfld {i8,i8}::_F1:i8
      5) stfld {i8,i8}::_F0:i8
      1) ldloc.0 [{i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      5) br [1]
  Label [0]:
      1) ldnull
  Label [1]:
      1) ret
  Total Size: 68

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<{i8,i8}>
      1) stloc.0 [Seq<{i8,i8}>]
      1) ldloc.0 [Seq<{i8,i8}>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<{i8,i8},{i8,i8}>]
      5) call static ForEachGen::Exec(Seq<{i8,i8}>, Func<{i8,i8},{i8,i8}>):Seq<{i8,i8}>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<{i8,i8}>):Seq<{i8,i8}>
      1) ret
  Total Size: 28

Func sig: (T:{X:i8, Y:i8}?*) to {Y:i8, Z:i8}?*
Sequence: Seq<{i8,i8}>
 0) { Y: 3, Z: 17 }
 1) { Y: 4, Z: 18 }
 2) <null>
 3) { Y: 12, Z: 20 }
 4) { Y: 19, Z: 21 }
 5) <null>
 6) { Y: 39, Z: 23 }
 7) { Y: 52, Z: 24 }
 8) <null>
 9) { Y: 84, Z: 26 }
###
> T ++ [ { X:1.5, Z:-17 } ]
T ++ [{ X : 1.5, Z : -17 }] : {X:r8, Y:i8?, Z:i8?}?*
BndKind:VariadicOp, Type:{X:r8, Y:i8?, Z:i8?}?*, Bnd:(SeqConcat(Call(∂.ForEach([map:1] Global(T), Call(∂.Guard([guard:2] Scope(1), {X:Num<r8>(GetField(Scope(2), X)), Y:Opt<i8?>(GetField(Scope(2), Y)), Z:null:i8?})))), [Ref<{X:r8, Y:i8?, Z:i8?}?>({X:1.5:r8, Z:Opt<i8?>(-17:i8)[, Y:null:i8?]})]:{X:r8, Y:i8?, Z:i8?}?*))
// (∂.T:{X:i8, Y:i8}?*) : {X:r8, Y:i8?, Z:i8?}?*
ForEach_1(Arr<obj>, {i8,i8}):{r8,i8,i8}
      1) ldarg.1 [{i8,i8}]
      5) brfalse [0]
      5) newobj {r8,i8,i8}()
      1) dup
      1) ldc.i4.1
      5) stfld {r8,i8,i8}::_B0:u1
      1) stloc.0 [{r8,i8,i8}]
      1) ldloc.0 [{r8,i8,i8}]
      1) ldarg.1 [{i8,i8}]
      5) ldfld {i8,i8}::_F0:i8
      1) conv.r8
      5) stfld {r8,i8,i8}::_F0:r8
      1) ldloc.0 [{r8,i8,i8}]
      1) ldarg.1 [{i8,i8}]
      5) ldfld {i8,i8}::_F1:i8
      5) stfld {r8,i8,i8}::_F1:i8
      1) ldloc.0 [{r8,i8,i8}]
      1) dup
      5) ldfld {r8,i8,i8}::_B0:u1
      1) ldc.i4.2
      1) or
      5) stfld {r8,i8,i8}::_B0:u1
      1) ldloc.0 [{r8,i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      5) br [1]
  Label [0]:
      1) ldnull
  Label [1]:
      1) ret
  Total Size: 79

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<{i8,i8}>
      1) stloc.0 [Seq<{i8,i8}>]
      1) ldloc.0 [Seq<{i8,i8}>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<{i8,i8},{r8,i8,i8}>]
      5) call static ForEachGen::Exec(Seq<{i8,i8}>, Func<{i8,i8},{r8,i8,i8}>):Seq<{r8,i8,i8}>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<{r8,i8,i8}>):Seq<{r8,i8,i8}>
      1) ldc.i4.1
      5) newarr [{r8,i8,i8}]
      1) dup
      1) ldc.i4.0
      5) newobj {r8,i8,i8}()
      1) dup
      1) ldc.i4.1
      5) stfld {r8,i8,i8}::_B0:u1
      1) stloc.1 [{r8,i8,i8}]
      1) ldloc.1 [{r8,i8,i8}]
      9) ldc.r8 [1.5]
      5) stfld {r8,i8,i8}::_F0:r8
      1) ldloc.1 [{r8,i8,i8}]
      2) ldc.i4.s [-17]
      1) conv.i8
      5) stfld {r8,i8,i8}::_F2:i8
      1) ldloc.1 [{r8,i8,i8}]
      1) dup
      5) ldfld {r8,i8,i8}::_B0:u1
      1) ldc.i4.4
      1) or
      5) stfld {r8,i8,i8}::_B0:u1
      1) ldloc.1 [{r8,i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      5) stelem [{r8,i8,i8}]
      5) call static CodeGenUtil::SeqConcat(Seq<{r8,i8,i8}>, Seq<{r8,i8,i8}>):Seq<{r8,i8,i8}>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<{r8,i8,i8}>):Seq<{r8,i8,i8}>
      1) ret
  Total Size: 116

Func sig: (T:{X:i8, Y:i8}?*) to {X:r8, Y:i8?, Z:i8?}?*
Sequence: Seq<{r8,i8,i8}>
 0) { X: 0, Y: 3, Z: <null> }
 1) { X: 1, Y: 4, Z: <null> }
 2) <null>
 3) { X: 3, Y: 12, Z: <null> }
 4) { X: 4, Y: 19, Z: <null> }
 5) <null>
 6) { X: 6, Y: 39, Z: <null> }
 7) { X: 7, Y: 52, Z: <null> }
 8) <null>
 9) { X: 9, Y: 84, Z: <null> }
10) { X: 1.5, Y: <null>, Z: -17 }
###
> [{A:3, B:true}, {A:2.5}]
[{ A : 3, B : true }, { A : 2.5 }] : {A:r8, B:b?}*
BndKind:Sequence, Type:{A:r8, B:b?}*, Bnd:([{A:3:r8, B:Opt<b?>(true:b)}, {A:2.5:r8[, B:null:b?]}]:{A:r8, B:b?}*)
// () : {A:r8, B:b?}*
top(Arr<obj>, Arr<obj>):obj
      1) ldc.i4.2
      5) newarr [{r8,bool}]
      1) dup
      1) ldc.i4.0
      5) newobj {r8,bool}()
      1) dup
      1) ldc.i4.1
      5) stfld {r8,bool}::_B0:u1
      1) stloc.0 [{r8,bool}]
      1) ldloc.0 [{r8,bool}]
      9) ldc.r8 [3]
      5) stfld {r8,bool}::_F0:r8
      1) ldloc.0 [{r8,bool}]
      1) ldc.i4.1
      5) stfld {r8,bool}::_F1:bool
      1) ldloc.0 [{r8,bool}]
      1) dup
      5) ldfld {r8,bool}::_B0:u1
      1) ldc.i4.2
      1) or
      5) stfld {r8,bool}::_B0:u1
      1) ldloc.0 [{r8,bool}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      5) stelem [{r8,bool}]
      1) dup
      1) ldc.i4.1
      5) newobj {r8,bool}()
      1) dup
      1) ldc.i4.1
      5) stfld {r8,bool}::_B0:u1
      1) stloc.0 [{r8,bool}]
      1) ldloc.0 [{r8,bool}]
      9) ldc.r8 [2.5]
      5) stfld {r8,bool}::_F0:r8
      1) ldloc.0 [{r8,bool}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      5) stelem [{r8,bool}]
      1) ret
  Total Size: 126

Func sig: () to {A:r8, B:b?}*
Sequence: Seq<{r8,bool}>
 0) { A: 3, B: true  }
 1) { A: 2.5, B: <null> }
###
> [{A:3, B:true}, {A:2.5}] & { B: "hi" }
[{ A : 3, B : true }, { A : 2.5 }] & { B : "hi" } : {A:r8, B:s}*
BndKind:Call, Type:{A:r8, B:s}*, Bnd:(Call(∂.With([with:1] {B:str(hi)}, Call(∂.ForEach([map:2] [{A:3:r8, B:Opt<b?>(true:b)}, {A:2.5:r8[, B:null:b?]}]:{A:r8, B:b?}*, RecordConcat(Scope(2), Scope(1)))))))
// () : {A:r8, B:s}*
ForEach_1(Arr<obj>, {r8,bool}):{r8,str}
      5) newobj {r8,str}()
      1) dup
      1) ldc.i4.3
      5) stfld {r8,str}::_B0:u1
      1) stloc.0 [{r8,str}]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.3
      5) ldelem [({str})]
      5) ldfld ({str})::_F0:{str}
      1) stloc.1 [{str}]
      1) ldloc.0 [{r8,str}]
      1) ldloc.1 [{str}]
      5) ldfld {str}::_F0:str
      5) stfld {r8,str}::_F1:str
      1) ldloc.0 [{r8,str}]
      1) ldarg.1 [{r8,bool}]
      5) ldfld {r8,bool}::_F0:r8
      5) stfld {r8,str}::_F0:r8
      1) ldloc.0 [{r8,str}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 71

top(Arr<obj>, Arr<obj>):obj
      5) newobj {str}()
      1) dup
      1) ldc.i4.1
      5) stfld {str}::_B0:u1
      1) stloc.0 [{str}]
      1) ldloc.0 [{str}]
      5) ldstr [hi]
      5) stfld {str}::_F0:str
      1) ldloc.0 [{str}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) stloc.0 [{str}]
      1) ldc.i4.2
      5) newarr [{r8,bool}]
      1) dup
      1) ldc.i4.0
      5) newobj {r8,bool}()
      1) dup
      1) ldc.i4.1
      5) stfld {r8,bool}::_B0:u1
      1) stloc.1 [{r8,bool}]
      1) ldloc.1 [{r8,bool}]
      9) ldc.r8 [3]
      5) stfld {r8,bool}::_F0:r8
      1) ldloc.1 [{r8,bool}]
      1) ldc.i4.1
      5) stfld {r8,bool}::_F1:bool
      1) ldloc.1 [{r8,bool}]
      1) dup
      5) ldfld {r8,bool}::_B0:u1
      1) ldc.i4.2
      1) or
      5) stfld {r8,bool}::_B0:u1
      1) ldloc.1 [{r8,bool}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      5) stelem [{r8,bool}]
      1) dup
      1) ldc.i4.1
      5) newobj {r8,bool}()
      1) dup
      1) ldc.i4.1
      5) stfld {r8,bool}::_B0:u1
      1) stloc.1 [{r8,bool}]
      1) ldloc.1 [{r8,bool}]
      9) ldc.r8 [2.5]
      5) stfld {r8,bool}::_F0:r8
      1) ldloc.1 [{r8,bool}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      5) stelem [{r8,bool}]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.2
      5) ldelem [MethodInfo]
      5) ldtoken [Func<{r8,bool},{r8,str}>]
      5) call static Type::GetTypeFromHandle(RuntimeTypeHandle):Type
      1) ldc.i4.4
      5) newarr [obj]
      1) dup
      1) ldc.i4.0
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.3
      5) ldelem [Arr<obj>]
      5) stelem [Arr<obj>]
      1) dup
      1) ldc.i4.3
      5) newobj ({str})()
      1) dup
      1) ldloc.0 [{str}]
      5) stfld ({str})::_F0:{str}
      5) stelem [({str})]
      5) callvirt DynamicMethod::CreateDelegate(Type, obj):Delegate
      5) call static ForEachGen::Exec(Seq<{r8,bool}>, Func<{r8,bool},{r8,str}>):Seq<{r8,str}>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<{r8,str}>):Seq<{r8,str}>
      1) ret
  Total Size: 236

Func sig: () to {A:r8, B:s}*
Sequence: Seq<{r8,str}>
 0) { A: 3, B: hi }
 1) { A: 2.5, B: hi }
###
> T & { A: "stuff" }
T & { A : "stuff" } : {A:s, X:i8, Y:i8}?*
BndKind:Call, Type:{A:s, X:i8, Y:i8}?*, Bnd:(Call(∂.With([with:1] {A:str(stuff)}, Call(∂.ForEach([map:2] Global(T), Call(∂.Guard([guard:3] Scope(2), RecordConcat(Scope(3), Scope(1)))))))))
// (∂.T:{X:i8, Y:i8}?*) : {A:s, X:i8, Y:i8}?*
ForEach_1(Arr<obj>, {i8,i8}):{str,i8,i8}
      1) ldarg.1 [{i8,i8}]
      5) brfalse [0]
      5) newobj {str,i8,i8}()
      1) dup
      1) ldc.i4.7
      5) stfld {str,i8,i8}::_B0:u1
      1) stloc.0 [{str,i8,i8}]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.3
      5) ldelem [({str})]
      5) ldfld ({str})::_F0:{str}
      1) stloc.1 [{str}]
      1) ldloc.0 [{str,i8,i8}]
      1) ldloc.1 [{str}]
      5) ldfld {str}::_F0:str
      5) stfld {str,i8,i8}::_F0:str
      1) ldloc.0 [{str,i8,i8}]
      1) ldarg.1 [{i8,i8}]
      5) ldfld {i8,i8}::_F0:i8
      5) stfld {str,i8,i8}::_F1:i8
      1) ldloc.0 [{str,i8,i8}]
      1) ldarg.1 [{i8,i8}]
      5) ldfld {i8,i8}::_F1:i8
      5) stfld {str,i8,i8}::_F2:i8
      1) ldloc.0 [{str,i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      5) br [1]
  Label [0]:
      1) ldnull
  Label [1]:
      1) ret
  Total Size: 95

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<{i8,i8}>
      1) stloc.0 [Seq<{i8,i8}>]
      5) newobj {str}()
      1) dup
      1) ldc.i4.1
      5) stfld {str}::_B0:u1
      1) stloc.1 [{str}]
      1) ldloc.1 [{str}]
      5) ldstr [stuff]
      5) stfld {str}::_F0:str
      1) ldloc.1 [{str}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) stloc.1 [{str}]
      1) ldloc.0 [Seq<{i8,i8}>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [MethodInfo]
      5) ldtoken [Func<{i8,i8},{str,i8,i8}>]
      5) call static Type::GetTypeFromHandle(RuntimeTypeHandle):Type
      1) ldc.i4.4
      5) newarr [obj]
      1) dup
      1) ldc.i4.0
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.2
      5) ldelem [Arr<obj>]
      5) stelem [Arr<obj>]
      1) dup
      1) ldc.i4.3
      5) newobj ({str})()
      1) dup
      1) ldloc.1 [{str}]
      5) stfld ({str})::_F0:{str}
      5) stelem [({str})]
      5) callvirt DynamicMethod::CreateDelegate(Type, obj):Delegate
      5) call static ForEachGen::Exec(Seq<{i8,i8}>, Func<{i8,i8},{str,i8,i8}>):Seq<{str,i8,i8}>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<{str,i8,i8}>):Seq<{str,i8,i8}>
      1) ret
  Total Size: 121

Func sig: (T:{X:i8, Y:i8}?*) to {A:s, X:i8, Y:i8}?*
Sequence: Seq<{str,i8,i8}>
 0) { A: stuff, X: 0, Y: 3 }
 1) { A: stuff, X: 1, Y: 4 }
 2) <null>
 3) { A: stuff, X: 3, Y: 12 }
 4) { A: stuff, X: 4, Y: 19 }
 5) <null>
 6) { A: stuff, X: 6, Y: 39 }
 7) { A: stuff, X: 7, Y: 52 }
 8) <null>
 9) { A: stuff, X: 9, Y: 84 }
###
> { A: "stuff" } & T
{ A : "stuff" } & T : {A:s, X:i8, Y:i8}?*
BndKind:Call, Type:{A:s, X:i8, Y:i8}?*, Bnd:(Call(∂.With([with:1] {A:str(stuff)}, Call(∂.ForEach([map:2] Global(T), Call(∂.Guard([guard:3] Scope(2), RecordConcat(Scope(1), Scope(3)))))))))
// (∂.T:{X:i8, Y:i8}?*) : {A:s, X:i8, Y:i8}?*
ForEach_1(Arr<obj>, {i8,i8}):{str,i8,i8}
      1) ldarg.1 [{i8,i8}]
      5) brfalse [0]
      5) newobj {str,i8,i8}()
      1) dup
      1) ldc.i4.7
      5) stfld {str,i8,i8}::_B0:u1
      1) stloc.0 [{str,i8,i8}]
      1) ldloc.0 [{str,i8,i8}]
      1) ldarg.1 [{i8,i8}]
      5) ldfld {i8,i8}::_F0:i8
      5) stfld {str,i8,i8}::_F1:i8
      1) ldloc.0 [{str,i8,i8}]
      1) ldarg.1 [{i8,i8}]
      5) ldfld {i8,i8}::_F1:i8
      5) stfld {str,i8,i8}::_F2:i8
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.3
      5) ldelem [({str})]
      5) ldfld ({str})::_F0:{str}
      1) stloc.1 [{str}]
      1) ldloc.0 [{str,i8,i8}]
      1) ldloc.1 [{str}]
      5) ldfld {str}::_F0:str
      5) stfld {str,i8,i8}::_F0:str
      1) ldloc.0 [{str,i8,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      5) br [1]
  Label [0]:
      1) ldnull
  Label [1]:
      1) ret
  Total Size: 95

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<{i8,i8}>
      1) stloc.0 [Seq<{i8,i8}>]
      5) newobj {str}()
      1) dup
      1) ldc.i4.1
      5) stfld {str}::_B0:u1
      1) stloc.1 [{str}]
      1) ldloc.1 [{str}]
      5) ldstr [stuff]
      5) stfld {str}::_F0:str
      1) ldloc.1 [{str}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) stloc.1 [{str}]
      1) ldloc.0 [Seq<{i8,i8}>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [MethodInfo]
      5) ldtoken [Func<{i8,i8},{str,i8,i8}>]
      5) call static Type::GetTypeFromHandle(RuntimeTypeHandle):Type
      1) ldc.i4.4
      5) newarr [obj]
      1) dup
      1) ldc.i4.0
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.2
      5) ldelem [Arr<obj>]
      5) stelem [Arr<obj>]
      1) dup
      1) ldc.i4.3
      5) newobj ({str})()
      1) dup
      1) ldloc.1 [{str}]
      5) stfld ({str})::_F0:{str}
      5) stelem [({str})]
      5) callvirt DynamicMethod::CreateDelegate(Type, obj):Delegate
      5) call static ForEachGen::Exec(Seq<{i8,i8}>, Func<{i8,i8},{str,i8,i8}>):Seq<{str,i8,i8}>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<{str,i8,i8}>):Seq<{str,i8,i8}>
      1) ret
  Total Size: 121

Func sig: (T:{X:i8, Y:i8}?*) to {A:s, X:i8, Y:i8}?*
Sequence: Seq<{str,i8,i8}>
 0) { A: stuff, X: 0, Y: 3 }
 1) { A: stuff, X: 1, Y: 4 }
 2) <null>
 3) { A: stuff, X: 3, Y: 12 }
 4) { A: stuff, X: 4, Y: 19 }
 5) <null>
 6) { A: stuff, X: 6, Y: 39 }
 7) { A: stuff, X: 7, Y: 52 }
 8) <null>
 9) { A: stuff, X: 9, Y: 84 }
###
> T & { X: "stuff" }
T & { X : "stuff" } : {X:s, Y:i8}?*
BndKind:Call, Type:{X:s, Y:i8}?*, Bnd:(Call(∂.With([with:1] {X:str(stuff)}, Call(∂.ForEach([map:2] Global(T), Call(∂.Guard([guard:3] Scope(2), RecordConcat(Scope(3), Scope(1)))))))))
// (∂.T:{X:i8, Y:i8}?*) : {X:s, Y:i8}?*
ForEach_1(Arr<obj>, {i8,i8}):{str,i8}
      1) ldarg.1 [{i8,i8}]
      5) brfalse [0]
      5) newobj {str,i8}()
      1) dup
      1) ldc.i4.3
      5) stfld {str,i8}::_B0:u1
      1) stloc.0 [{str,i8}]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.3
      5) ldelem [({str})]
      5) ldfld ({str})::_F0:{str}
      1) stloc.1 [{str}]
      1) ldloc.0 [{str,i8}]
      1) ldloc.1 [{str}]
      5) ldfld {str}::_F0:str
      5) stfld {str,i8}::_F0:str
      1) ldloc.0 [{str,i8}]
      1) ldarg.1 [{i8,i8}]
      5) ldfld {i8,i8}::_F1:i8
      5) stfld {str,i8}::_F1:i8
      1) ldloc.0 [{str,i8}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      5) br [1]
  Label [0]:
      1) ldnull
  Label [1]:
      1) ret
  Total Size: 83

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<{i8,i8}>
      1) stloc.0 [Seq<{i8,i8}>]
      5) newobj {str}()
      1) dup
      1) ldc.i4.1
      5) stfld {str}::_B0:u1
      1) stloc.1 [{str}]
      1) ldloc.1 [{str}]
      5) ldstr [stuff]
      5) stfld {str}::_F0:str
      1) ldloc.1 [{str}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) stloc.1 [{str}]
      1) ldloc.0 [Seq<{i8,i8}>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [MethodInfo]
      5) ldtoken [Func<{i8,i8},{str,i8}>]
      5) call static Type::GetTypeFromHandle(RuntimeTypeHandle):Type
      1) ldc.i4.4
      5) newarr [obj]
      1) dup
      1) ldc.i4.0
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.2
      5) ldelem [Arr<obj>]
      5) stelem [Arr<obj>]
      1) dup
      1) ldc.i4.3
      5) newobj ({str})()
      1) dup
      1) ldloc.1 [{str}]
      5) stfld ({str})::_F0:{str}
      5) stelem [({str})]
      5) callvirt DynamicMethod::CreateDelegate(Type, obj):Delegate
      5) call static ForEachGen::Exec(Seq<{i8,i8}>, Func<{i8,i8},{str,i8}>):Seq<{str,i8}>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<{str,i8}>):Seq<{str,i8}>
      1) ret
  Total Size: 121

Func sig: (T:{X:i8, Y:i8}?*) to {X:s, Y:i8}?*
Sequence: Seq<{str,i8}>
 0) { X: stuff, Y: 3 }
 1) { X: stuff, Y: 4 }
 2) <null>
 3) { X: stuff, Y: 12 }
 4) { X: stuff, Y: 19 }
 5) <null>
 6) { X: stuff, Y: 39 }
 7) { X: stuff, Y: 52 }
 8) <null>
 9) { X: stuff, Y: 84 }
###
> { X: "stuff" } & T
{ X : "stuff" } & T : {X:i8, Y:i8}?*
BndKind:Global, Type:{X:i8, Y:i8}?*, Bnd:(Global(T))
// (∂.T:{X:i8, Y:i8}?*) : {X:i8, Y: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):Seq<{i8,i8}>
      1) stloc.0 [Seq<{i8,i8}>]
      1) ldloc.0 [Seq<{i8,i8}>]
      1) ret
  Total Size: 11

Func sig: (T:{X:i8, Y:i8}?*) to {X:i8, Y:i8}?*
Sequence: Seq<{i8,i8}>
 0) { X: 0, Y: 3 }
 1) { X: 1, Y: 4 }
 2) <null>
 3) { X: 3, Y: 12 }
 4) { X: 4, Y: 19 }
 5) <null>
 6) { X: 6, Y: 39 }
 7) { X: 7, Y: 52 }
 8) <null>
 9) { X: 9, Y: 84 }
###
> T & { Y: "stuff" }
T & { Y : "stuff" } : {X:i8, Y:s}?*
BndKind:Call, Type:{X:i8, Y:s}?*, Bnd:(Call(∂.With([with:1] {Y:str(stuff)}, Call(∂.ForEach([map:2] Global(T), Call(∂.Guard([guard:3] Scope(2), RecordConcat(Scope(3), Scope(1)))))))))
// (∂.T:{X:i8, Y:i8}?*) : {X:i8, Y:s}?*
ForEach_1(Arr<obj>, {i8,i8}):{i8,str}
      1) ldarg.1 [{i8,i8}]
      5) brfalse [0]
      5) newobj {i8,str}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,str}::_B0:u1
      1) stloc.0 [{i8,str}]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.3
      5) ldelem [({str})]
      5) ldfld ({str})::_F0:{str}
      1) stloc.1 [{str}]
      1) ldloc.0 [{i8,str}]
      1) ldloc.1 [{str}]
      5) ldfld {str}::_F0:str
      5) stfld {i8,str}::_F1:str
      1) ldloc.0 [{i8,str}]
      1) ldarg.1 [{i8,i8}]
      5) ldfld {i8,i8}::_F0:i8
      5) stfld {i8,str}::_F0:i8
      1) ldloc.0 [{i8,str}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      5) br [1]
  Label [0]:
      1) ldnull
  Label [1]:
      1) ret
  Total Size: 83

top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):Seq<{i8,i8}>
      1) stloc.0 [Seq<{i8,i8}>]
      5) newobj {str}()
      1) dup
      1) ldc.i4.1
      5) stfld {str}::_B0:u1
      1) stloc.1 [{str}]
      1) ldloc.1 [{str}]
      5) ldstr [stuff]
      5) stfld {str}::_F0:str
      1) ldloc.1 [{str}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) stloc.1 [{str}]
      1) ldloc.0 [Seq<{i8,i8}>]
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.1
      5) ldelem [MethodInfo]
      5) ldtoken [Func<{i8,i8},{i8,str}>]
      5) call static Type::GetTypeFromHandle(RuntimeTypeHandle):Type
      1) ldc.i4.4
      5) newarr [obj]
      1) dup
      1) ldc.i4.0
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.2
      5) ldelem [Arr<obj>]
      5) stelem [Arr<obj>]
      1) dup
      1) ldc.i4.3
      5) newobj ({str})()
      1) dup
      1) ldloc.1 [{str}]
      5) stfld ({str})::_F0:{str}
      5) stelem [({str})]
      5) callvirt DynamicMethod::CreateDelegate(Type, obj):Delegate
      5) call static ForEachGen::Exec(Seq<{i8,i8}>, Func<{i8,i8},{i8,str}>):Seq<{i8,str}>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<{i8,str}>):Seq<{i8,str}>
      1) ret
  Total Size: 121

Func sig: (T:{X:i8, Y:i8}?*) to {X:i8, Y:s}?*
Sequence: Seq<{i8,str}>
 0) { X: 0, Y: stuff }
 1) { X: 1, Y: stuff }
 2) <null>
 3) { X: 3, Y: stuff }
 4) { X: 4, Y: stuff }
 5) <null>
 6) { X: 6, Y: stuff }
 7) { X: 7, Y: stuff }
 8) <null>
 9) { X: 9, Y: stuff }
###
> { Y: "stuff" } & T
{ Y : "stuff" } & T : {X:i8, Y:i8}?*
BndKind:Global, Type:{X:i8, Y:i8}?*, Bnd:(Global(T))
// (∂.T:{X:i8, Y:i8}?*) : {X:i8, Y: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):Seq<{i8,i8}>
      1) stloc.0 [Seq<{i8,i8}>]
      1) ldloc.0 [Seq<{i8,i8}>]
      1) ret
  Total Size: 11

Func sig: (T:{X:i8, Y:i8}?*) to {X:i8, Y:i8}?*
Sequence: Seq<{i8,i8}>
 0) { X: 0, Y: 3 }
 1) { X: 1, Y: 4 }
 2) <null>
 3) { X: 3, Y: 12 }
 4) { X: 4, Y: 19 }
 5) <null>
 6) { X: 6, Y: 39 }
 7) { X: 7, Y: 52 }
 8) <null>
 9) { X: 9, Y: 84 }
###
> Wrap([])->{X:it}
Wrap([])->{ X : it } : {X:v}*
BndKind:Call, Type:{X:v}*, Bnd:(Call(∂.ForEach([map:1] Call(∂.Test.Wrap(null:v*):v*), {X:Scope(1)})))
// () : {X:v}*
ForEach_1(Arr<obj>, obj):{obj}
      5) newobj {obj}()
      1) stloc.0 [{obj}]
      1) ldloc.0 [{obj}]
      1) ldarg.1 [obj]
      5) stfld {obj}::_F0:obj
      1) ldloc.0 [{obj}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 28

top(Arr<obj>, Arr<obj>):obj
      1) ldnull
      5) call static WrapFuncGen::Exec(Seq<obj>):Seq<obj>
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [Func<obj,{obj}>]
      5) call static ForEachGen::Exec(Seq<obj>, Func<obj,{obj}>):Seq<{obj}>
      5) call static CodeGenUtil::EnumerableToCaching(Seq<{obj}>):Seq<{obj}>
      1) ret
  Total Size: 24

Func sig: () to {X:v}*
Type: <null>, Value: <null>
###

**** New definitions: R1, type: {A:i8, B:b}
**** New definitions: R2, type: {A:r8}
**** New definitions: R3, type: {B:s}

> R1 & R3
R1 & R3 : {A:i8, B:s}
BndKind:VariadicOp, Type:{A:i8, B:s}, Bnd:(RecordConcat(Global(R1), Global(R3)))
// (∂.R1:{A:i8, B:b}, ∂.R3:{B:s}) : {A:i8, B:s}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):{i8,bool}
      1) stloc.0 [{i8,bool}]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):{str}
      1) stloc.1 [{str}]
      5) newobj {i8,str}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,str}::_B0:u1
      1) stloc.2 [{i8,str}]
      1) ldloc.2 [{i8,str}]
      1) ldloc.1 [{str}]
      5) ldfld {str}::_F0:str
      5) stfld {i8,str}::_F1:str
      1) ldloc.2 [{i8,str}]
      1) ldloc.0 [{i8,bool}]
      5) ldfld {i8,bool}::_F0:i8
      5) stfld {i8,str}::_F0:i8
      1) ldloc.2 [{i8,str}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 70

Func sig: (R1:{A:i8, B:b}, R3:{B:s}) to {A:i8, B:s}
Type: {i8,str}, Value: { A: 3, B: hi }
###
> R2 & R3
R2 & R3 : {A:r8, B:s}
BndKind:VariadicOp, Type:{A:r8, B:s}, Bnd:(RecordConcat(Global(R2), Global(R3)))
// (∂.R2:{A:r8}, ∂.R3:{B:s}) : {A:r8, B:s}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):{r8}
      1) stloc.0 [{r8}]
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.1
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):{str}
      1) stloc.1 [{str}]
      5) newobj {r8,str}()
      1) dup
      1) ldc.i4.3
      5) stfld {r8,str}::_B0:u1
      1) stloc.2 [{r8,str}]
      1) ldloc.2 [{r8,str}]
      1) ldloc.1 [{str}]
      5) ldfld {str}::_F0:str
      5) stfld {r8,str}::_F1:str
      1) ldloc.2 [{r8,str}]
      1) ldloc.0 [{r8}]
      5) ldfld {r8}::_F0:r8
      5) stfld {r8,str}::_F0:r8
      1) ldloc.2 [{r8,str}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 70

Func sig: (R2:{A:r8}, R3:{B:s}) to {A:r8, B:s}
Type: {r8,str}, Value: { A: 2.5, B: hi }
###
> R1 & { B: "hi" }
R1 & { B : "hi" } : {A:i8, B:s}
BndKind:VariadicOp, Type:{A:i8, B:s}, Bnd:(RecordConcat(Global(R1), {B:str(hi)}))
// (∂.R1:{A:i8, B:b}) : {A:i8, B:s}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):{i8,bool}
      1) stloc.0 [{i8,bool}]
      5) newobj {i8,str}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,str}::_B0:u1
      1) stloc.1 [{i8,str}]
      1) ldloc.1 [{i8,str}]
      5) ldstr [hi]
      5) stfld {i8,str}::_F1:str
      1) ldloc.1 [{i8,str}]
      1) ldloc.0 [{i8,bool}]
      5) ldfld {i8,bool}::_F0:i8
      5) stfld {i8,str}::_F0:i8
      1) ldloc.1 [{i8,str}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 60

Func sig: (R1:{A:i8, B:b}) to {A:i8, B:s}
Type: {i8,str}, Value: { A: 3, B: hi }
###
> { A:3, B:true } & R3
{ A : 3, B : true } & R3 : {A:i8, B:s}
BndKind:VariadicOp, Type:{A:i8, B:s}, Bnd:(RecordConcat({A:3:i8}, Global(R3)))
// (∂.R3:{B:s}) : {A:i8, B:s}
top(Arr<obj>, Arr<obj>):obj
      1) ldarg.1 [Arr<obj>]
      1) ldc.i4.0
      1) ldelem.ref
      5) call static CodeGenUtil::ToRef(obj):{str}
      1) stloc.0 [{str}]
      5) newobj {i8,str}()
      1) dup
      1) ldc.i4.3
      5) stfld {i8,str}::_B0:u1
      1) stloc.1 [{i8,str}]
      1) ldloc.1 [{i8,str}]
      1) ldloc.0 [{str}]
      5) ldfld {str}::_F0:str
      5) stfld {i8,str}::_F1:str
      1) ldloc.1 [{i8,str}]
      1) ldc.i4.3
      1) conv.i8
      5) stfld {i8,str}::_F0:i8
      1) ldloc.1 [{i8,str}]
      1) dup
      1) ldarg.0 [Arr<obj>]
      1) ldc.i4.0
      5) ldelem [RecordRuntimeTypeInfo]
      5) stfld {}::_rrti:RecordRuntimeTypeInfo
      1) ret
  Total Size: 57

Func sig: (R3:{B:s}) to {A:i8, B:s}
Type: {i8,str}, Value: { A: 3, B: hi }
###
