anchor.diff:  
           // X and Y values 
           let internal mergeDataAndLabelsForXY6 (data:seq<#key * #value * #value * #value * #value * #value * #value>) labels = 
  +            let xTypeOpt = getChartValueTypeStatic (Seq.map (fun (a, _, _, _, _, _, _) -> a) data)
               let data = convertKeys1of7 (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,y5,y6) -> SixXYDataPoint(X=string (box x),Y1=y1,Label=null,Y2=y2,Y3=y3,Y4=y4,Y5=y5,Y6=y6))
  
positive.code:     type key = System.IComparable
  
      module internal KeyConversions = 
          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) =
            registeredConvertors.Add(typeof<'T>, fun arg -> f (arg :?> 'T))
          
          do registerConvertor (fun (dto:DateTimeOffset) -> dto.DateTime :> key)
  
negative.code:           data |> NotifySeq.map (fun (k, v1, v2, v3, v4, v5, v6) -> k :> key, v1, v2, v3, v4, v5, v6)          
                 |> convertKeys (fun (k, _, _, _, _, _, _) -> k) (fun kf (k, v1, v2, v3, v4, v5, v6) -> kf k, v1, v2, v3, v4, v5, v6) 
  
          // In most cases, we can use static type - if it is primitive type and it is not
          // mapped to something else
          let getChartValueTypeStatic<'K when 'K :> key>(witness:seq<'K>) =
            ignore(witness)
            match KeyConversions.knownTypes.TryGetValue(typeof<'K>) with
            | true, typ -> Some typ
            | _ -> None
  
          let getChartValueTypeDynamic xTypeOpt values = 
            // Only look at the values if we did not find the type using static type
            match xTypeOpt with
            | Some xType -> xType
            | _ ->
              try 
                let v = Seq.head values 
                // For date time, we need to decide if it represents dates or actual time
                // If they all represent the same day, then it is probably time; If they 
                // all represent 12:00am, then it is probably a date...
                let typ = v.GetType() 
                if typ = typeof<DateTime> then                 
                  let dates = Seq.map (unbox<DateTime>) values
                  let firstDate = ((box v) :?> DateTime).Date
                  if dates |> Seq.forall (fun dt -> dt.Date = firstDate) then ChartValueType.Time
                  elif dates |> Seq.forall (fun dt -> dt.TimeOfDay = TimeSpan.Zero) then ChartValueType.Date
                  else ChartValueType.DateTime
                else 
                  // For all other types, we use the 'knownTypes' lookup table
                  match KeyConversions.knownTypes.TryGetValue(typ) with
                  | true, t -> t
                  | _ -> ChartValueType.Auto
              with _ -> ChartValueType.Auto
  
          // ----------------------------------------------------------------------------------
          // Single Y value
            
          let internal mergeDataAndLabelsForXY (data:seq<#key * #value>) (labels: #seq<string> option) = 
              let xTypeOpt = getChartValueTypeStatic (Seq.map fst data)
              let data = convertKeys1of2 (NotifySeq.notifyOrOnce data)
              let xType = getChartValueTypeDynamic xTypeOpt (Seq.map fst data)
              match labels with 
              | None -> ChartData.Values(NotifySeq.ignoreReset data, xType, "Item1", "Item2", "") 
              | Some labels -> 
  