anchor.diff:          writer.WriteEndObject()
   
   module private Cache =
  +
       let jsonConverterTypes = ConcurrentDictionary<Type,Kind>()
       let serializationBinderTypes = ConcurrentDictionary<string,Type>()
       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
  -type FSharpJsonConverter() =
  +and FSharpJsonConverter() =
       inherit Newtonsoft.Json.JsonConverter()
       let advance(reader: JsonReader) =
           reader.Read() |> ignore
  
positive.code:                 let inheritedType =
                      let typeName = jObject.["TypeName"].ToString()
                      findType typeName
                      
                  jObject.Remove("TypeName") |> ignore                   
  
                  let itemTypes = inheritedType.GetFields() |> Array.map (fun pi -> pi.FieldType)
                  if itemTypes.Length > 1
                  then
                      let propertyValues = jObject.PropertyValues()
                      let values = 
                          propertyValues |> Seq.mapi (fun i (v: JToken) ->
                              let reader = new JTokenReader(v)
                              serializer.Deserialize(reader, itemTypes.[i])
                          ) |> Array.ofSeq
                      Activator.CreateInstance(inheritedType,values)             
                  else
                      let reader = new JTokenReader(jObject)
                      advance reader
                      advance reader        
                      advance reader
                      let value = serializer.Deserialize(reader, itemTypes.[0])
                      Activator.CreateInstance(inheritedType,[|value|])        
              | _ -> failwith "invalid token"
          | true, _ ->
              serializer.Deserialize(reader, t)
  
negative.code:                 else Kind.Other)
          
          match kind with 
          | Kind.Other -> x.IsRegisteredInherientedType t || isRegisteredParentType t
          | _ -> true       
  
      override x.WriteJson(writer, value, serializer) =
  