anchor.diff:          | true, Kind.Other when isRegisteredParentType t ->  
               let inheritedTypes = inheritedConverterTypes.[t.FullName]
   
  -            let findType typeName =
  -                Seq.find (fun (tp: Type) ->
  -                    tp.FullName = typeName
  -                ) inheritedTypes
  -            
  -            match reader.TokenType with
  -            | JsonToken.String ->
  -                let value = serializer.Deserialize(reader, typeof<string>) :?> string
  -                let inheritedType = findType value 
  -                Activator.CreateInstance(inheritedType)
  -            | JsonToken.StartObject ->
  -                let jObject = JObject.Load(reader)
  -                let inheritedType =
  -                    let typeName = jObject.["TypeName"].ToString()
  -                    findType typeName
  -
  -                jObject.Remove("TypeName") |> ignore  
  -                let json = jObject.ToString()
  -                JsonConvert.DeserializeObject(json, inheritedType, deserializeInheritedTypeJsonConverters)
  -                
  -            | _ -> failwith "invalid token"
  +            let findType (jsonFields: seq<string>) =
  +                inheritedTypes |> Seq.maxBy (fun tp ->
  +                    let fields = tp.GetFields() |> Seq.map (fun fd -> fd.Name)
  +                    jsonFields |> Seq.filter(fun jsonField ->
  +                        Seq.contains jsonField fields
  +                    )
  +                    |> Seq.length
  +                )            
  +
  +            let jObject = JObject.Load(reader)
  +            let jsonFields = jObject.Properties() |> Seq.map (fun prop -> prop.Name) |> List.ofSeq
  +            let inheritedType = findType jsonFields
  +            printfn "found inherited type %s with jsonFields %A" inheritedType.FullName jsonFields
  +            jObject.ToObject(inheritedType,serializer)
  +
           | true, _ ->
               serializer.Deserialize(reader, t)
   
  
positive.code:     let inheritedConverterTypes = ConcurrentDictionary<string,HashSet<Type>>()
  
  open Cache
  type DeserializeInheritedTypeJsonConverter() =
      inherit FSharpJsonConverter()
      override x.CanConvert(t) =
          base.CanConvert(t) && (base.IsRegisteredInherientedType t |> not)
  
  /// Converts F# options, tuples and unions to a format understandable
  /// A derivative of Fable's JsonConverter. Code adapted from Lev Gorodinski's original.
  /// See https://goo.gl/F6YiQk
  and FSharpJsonConverter() =
      inherit Newtonsoft.Json.JsonConverter()
      let advance(reader: JsonReader) =
          reader.Read() |> ignore
  
negative.code:                 let mapSerializer = typedefof<MapSerializer<_,_>>.MakeGenericType mapTypes
                  let mapSerializeMethod = mapSerializer.GetMethod("Serialize")
                  mapSerializeMethod.Invoke(null, [| value; writer; serializer |]) |> ignore
              | true, _ ->                
                  serializer.Serialize(writer, value)
  
  