anchor.diff:      inherit EntityReaderColumnGenerator(builder, column)
       let output = column.Blueprint.Value.Output
       let mutable colValue = null
  -    let mutable colIndex = null
  +    let mutable colInfo = null
       let mutable found = null
       override __.DefineConstructor() =
           found <- builder.DefineField("_p_f_" + column.Name, typeof<bool>, FieldAttributes.Private)
  -        colIndex <- builder.DefineField("_p_i_" + column.Name, typeof<int>, FieldAttributes.Private)
  +        colInfo <- builder.DefineField("_p_i_" + column.Name, typeof<ColumnInfo>, FieldAttributes.Private)
           colValue <- builder.DefineField("_p_" + column.Name, output, FieldAttributes.Private)
           zero
       override __.DefineProcessColumns() =
  
positive.code:             yield ldarg 1 // column map
              yield ldstr column.Name
              yield call2 ColumnMap.ColumnMethod
              yield stfld colIndex
          }
      override __.DefineImpartKnowledgeToNext() =
          cil {
              yield ldarg 1
              yield castclass builder
              yield ldarg 0
              yield ldfld colIndex
              yield stfld colIndex
          }
      override __.DefineRead(skipOnes) =
          cil {
  
negative.code:             yield ldarg 0
              yield ldfld entReader
              yield callvirt1 (entReaderType.GetMethod("ToEntity"))
          }
  
  type private ManyColumnGenerator
      ( builder
      , column
      , element : ElementBlueprint
      , elementId : Column
      , conversion : ConversionMethod
      ) =
      inherit EntityReaderColumnGenerator(builder, column)
      let elemTy = element.Output
      let staticTemplate = typedefof<_ StaticEntityReaderTemplate>.MakeGenericType(elemTy)
      let entTemplate = typedefof<_ EntityReaderTemplate>.MakeGenericType(elemTy)
      let elemReaderTy = typedefof<_ EntityReader>.MakeGenericType(elemTy)
      let dictTy = typedefof<Dictionary<_, _>>.MakeGenericType(elementId.Blueprint.Value.Output, elemReaderTy)
      let idTy = elementId.Blueprint.Value.Output
      let idConverter =
          match elementId.Blueprint.Value.Cardinality with
          | One { Shape = Primitive prim } ->
              prim.Converter
          | One _ -> failwith "Composite keys are not supported"
          | Many _ -> failwith "Collections as keys are not supported"
      let mutable entDict = null
      let mutable refReader = null
      let mutable idInfo = null
      override __.DefineConstructor() =
          idInfo <- builder.DefineField("_m_i_" + column.Name, typeof<ColumnInfo>, FieldAttributes.Private)
          entDict <- builder.DefineField("_m_d_" + column.Name, dictTy, FieldAttributes.Private)
          refReader <- builder.DefineField("_m_r_" + column.Name, elemReaderTy, FieldAttributes.Private)
          zero // don't initialize dictionary yet
      override __.DefineProcessColumns() =
          cil {
              yield ldarg 1 // column map
              yield ldstr column.Name
              yield call2 ColumnMap.SubMapMethod
              let! sub = deflocal typeof<ColumnMap>
              yield stloc sub
              yield ldarg 0 // this
              yield ldloc sub
              yield ldstr elementId.Name
              yield call2 ColumnMap.ColumnMethod
              yield stfld idInfo
              yield ldloc sub
              let! skip = deflabel
              yield brfalse's skip
              yield cil {
                  yield ldarg 0
                  yield call0 (staticTemplate.GetMethod("Template"))
                  yield call1 (entTemplate.GetMethod("CreateReader"))
                  yield dup
                  yield ldloc sub
                  yield callvirt2'void (elemReaderTy.GetMethod("ProcessColumns"))
                  yield stfld refReader
              }
              yield mark skip
          }
      override __.DefineImpartKnowledgeToNext() =
          cil {
              yield ldarg 1
              yield castclass builder
              yield ldarg 0
              yield ldfld idInfo
              yield stfld idInfo
  
              let! nread = deflabel
              let! exit = deflabel
              yield dup
              yield ldfld refReader
              yield brfalse's nread
              yield cil {
                  yield ldarg 1
                  yield ldarg 0
                  yield ldfld refReader
                  yield castclass builder
                  yield call0 (staticTemplate.GetMethod("Template"))
                  yield call1 (entTemplate.GetMethod("CreateReader"))
                  let! loc = deflocal elemReaderTy
                  yield dup
                  yield stloc loc
                  // that, oldReader, newReader
                  yield callvirt2'void (elemReaderTy.GetMethod("ImpartKnowledgeToNext"))
                  // that
                  yield ldloc loc
                  yield stfld refReader
                  yield br's exit
              }
              yield mark nread
              yield cil {
                  yield ldarg 1
                  yield ldnull
                  yield stfld refReader
              }
              yield mark exit
          }
      override __.DefineRead(_) =
          cil {
              let! skip = deflabel
              yield dup
              yield ldfld refReader
              yield brfalse skip
              yield cil {
                  yield ldarg 1 // row
                  yield ldarg 0 // row, this
                  yield ldfld idInfo // row, colinfo
                  yield ldfld (typeof<ColumnInfo>.GetField("Index")) // row, index
                  yield callvirt2 (typeof<Row>.GetMethod("IsNull")) // isnull
                  yield brtrue skip
                  
                  yield ldarg 1 // row
                  yield ldarg 0 // row, this
                  yield ldfld idInfo // row, colinfo
                  yield generalize2 idConverter // id
                  
                  let! id = deflocal idTy
                  yield stloc id
                  let! entReader = deflocal elemReaderTy
                  yield dup
                  yield ldfld entDict
                  yield ldloc id
                  yield ldloca entReader
                  yield call3 (dictTy.GetMethod("TryGetValue"))
                  let! readRow = deflabel
                  yield brtrue's readRow
                  
                  yield dup
                  yield ldfld entDict
                  yield ldloc id
                  yield call0 (staticTemplate.GetMethod("Template"))
                  yield call1 (entTemplate.GetMethod("CreateReader"))
                  yield dup
                  yield stloc entReader
                  yield call3'void (dictTy.GetMethod("Add", [| idTy; elemReaderTy |]))
                  yield dup
                  yield ldfld refReader
                  yield ldloc entReader
                  yield callvirt2'void (elemReaderTy.GetMethod("ImpartKnowledgeToNext"))
  
                  yield mark readRow
                  yield ldloc entReader
                  yield ldarg 1 // row
                  yield callvirt2'void (elemReaderTy.GetMethod("Read"))
              }
              yield mark skip
          }
      override __.DefinePush() =
          cil {
              yield ldarg 0
              yield ldfld entDict
              yield call1 (dictTy.GetProperty("Values").GetGetMethod())
              yield generalize conversion
          }
  