anchor.diff:      let fs =
           FST.GetRecordFields(t, flags)
           |> Array.map (fun f ->
  -            (i.GetEncodedFieldName mt f.Name, decodeOptionalField dD i f f.PropertyType))
  +            (i.GetEncodedFieldName t f.Name, decodeOptionalField dD i f f.PropertyType))
       fun (x: Value) ->
           match x with
           | Object fields ->
  
positive.code:         /// Tag the given encoded value with its type.
          AddTag : System.Type -> Encoded -> Encoded
          /// Get the JSON-encoded name of the given F# record or class field.
          GetEncodedFieldName : Reflection.TypeDefinition -> string -> string
          /// Find the union case tag of the given JSON object
          /// (represented as a fieldname -> value function)
          GetUnionTag : System.Type -> (string -> option<Value>) -> option<int>
  
negative.code:     let format =
          {
              AddTag = fun _ -> id
              GetEncodedFieldName = fun t ->
                  let d = Dictionary()
                  let fields =
                      if FST.IsRecord t then
                          FST.GetRecordFields(t, flags)
                          |> Seq.cast<System.Reflection.MemberInfo>
                      else
                          getObjectFields t
                          |> Seq.cast<System.Reflection.MemberInfo>
                  for f in fields do
                      if not (d.ContainsKey f.Name) then
                          d.Add(f.Name, defaultArg (getNameAttr f) f.Name)
                  fun n ->
                      match d.TryGetValue n with
                      | true, n -> n
                      | false, _ -> n
              GetUnionTag = fun t ->
                  match getDiscriminatorName t with
                  | None -> defaultGetUnionTag t
  