anchor.diff:  
           // One X and Four Y values
           let internal mergeDataAndLabelsForXY4 (data:seq<#key * #value * #value * #value * #value>) labels = 
  +            let xTypeOpt = getChartValueTypeStatic (Seq.map (fun (a, _, _, _, _) -> a) data)
               let data = convertKeys1of5 (NotifySeq.notifyOrOnce data)
  -            let xType = getChartValueType (Seq.map (fun (a, _, _, _, _) -> a) data)
  +            let xType = getChartValueTypeDynamic xTypeOpt (Seq.map (fun (a, _, _, _, _) -> a) data)
               match labels with 
               | None -> 
                   let dataAndLabels = data |> NotifySeq.map (fun (x,y1,y2,y3,y4) -> FourXYDataPoint(X= string (box x),Y1=y1,Label=null,Y2=y2,Y3=y3,Y4=y4))
  
positive.code: 
          open System.Collections.Specialized
          
          // ----------------------------------------------------------------------------------
          // Single Y value
  
          let private convertKeys (selector:_ -> key) (transform:(key -> key) -> _) data = 
            let hasConvertor = ref None
            let convertor = ref None
  
negative.code:     type key = System.IComparable
  
      module internal KeyConversions = 
          // Mapping from known runtime types to 'ChartValueType' that is used for the X axis
          // (we try to infer the axis type so that it is displayed nicely)
          let knownTypes = 
            dict [ typeof<int>, ChartValueType.Int32; typeof<int64>, ChartValueType.Int64
                   typeof<uint32>, ChartValueType.UInt32; typeof<uint64>, ChartValueType.UInt64
                   typeof<float>, ChartValueType.Double; typeof<float32>, ChartValueType.Single
                   typeof<string>, ChartValueType.String ]
  
          let private registeredConvertors = System.Collections.Generic.Dictionary<_, key -> key>()
          let tryGetCovnertor (typ:System.Type) =
            match registeredConvertors.TryGetValue(typ) with 
            | true, conv -> Some conv
            | _ -> None
          let registerConvertor<'T when 'T :> key> (f:'T -> key) =
            if knownTypes.ContainsKey(typeof<'T>) then 
              invalidOp "Registering convertors for known primitive types (int, string, DateTime, ...) is not allowed."
            registeredConvertors.Add(typeof<'T>, fun arg -> f (arg :?> 'T))
          
          do registerConvertor (fun (dto:DateTimeOffset) -> dto.DateTime :> key)
  