anchor.diff:          let private convertKeys1of2 data = 
             data |> NotifySeq.map (fun (k, v) -> k :> key, v)          
                  |> convertKeys fst (fun kf (k, v) -> kf k, v) 
  -        let private convertKeys1of2of2 data = 
  -          data |> NotifySeq.map (fun ((k, v), l) -> (k :> key, v), l)
  -               |> convertKeys (fst >> fst) (fun kf ((k, v), l) -> (kf k, v), l)
           let private convertKeys1of3 data = 
             data |> NotifySeq.map (fun (k, v1, v2) -> k :> key, v1, v2)          
                  |> convertKeys (fun (k, _, _) -> k) (fun kf (k, v1, v2) -> kf k, v1, v2) 
  -        let private convertKeys1of3of2 data = 
  -          data |> NotifySeq.map (fun ((k, v1, v2), l) -> (k :> key, v1, v2), l)
  -               |> convertKeys (fun ((k, _, _), _) -> k) (fun kf ((k, v1, v2), l) -> (kf k, v1, v2), l)
           let private convertKeys1of4 data = 
             data |> NotifySeq.map (fun (k, v1, v2, v3) -> k :> key, v1, v2, v3)          
                  |> convertKeys (fun (k, _, _, _) -> k) (fun kf (k, v1, v2, v3) -> kf k, v1, v2, v3) 
  -        let private convertKeys1of4of2 data = 
  -          data |> NotifySeq.map (fun ((k, v1, v2, v3), l) -> (k :> key, v1, v2, v3), l)
  -               |> convertKeys (fun ((k, _, _, _), _) -> k) (fun kf ((k, v1, v2, v3), l) -> (kf k, v1, v2, v3), l)
           let private convertKeys1of5 data = 
             data |> NotifySeq.map (fun (k, v1, v2, v3, v4) -> k :> key, v1, v2, v3, v4)          
                  |> convertKeys (fun (k, _, _, _, _) -> k) (fun kf (k, v1, v2, v3, v4) -> kf k, v1, v2, v3, v4) 
  -        let private convertKeys1of5of2 data = 
  -          data |> NotifySeq.map (fun ((k, v1, v2, v3, v4), l) -> (k :> key, v1, v2, v3, v4), l)
  -               |> convertKeys (fun ((k, _, _, _, _), _) -> k) (fun kf ((k, v1, v2, v3, v4), l) -> (kf k, v1, v2, v3, v4), l)
  +        let private convertKeys1of7 data = 
  +          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) 
   
           let knownTypes = 
             dict [ typeof<int>, ChartValueType.Int32; typeof<int64>, ChartValueType.Int64
  
positive.code: 
          // Two Y values
          let internal mergeDataAndLabelsForXY2 data labels = 
              let xType = getChartValueType (Seq.map (fun (a, _, _) -> a) data)
              let data = NotifySeq.notifyOrOnce data // evaluate only once and cache
              match labels with 
              | None -> 
                  let dataAndLabels = data |> convertKeys1of3 |> NotifySeq.map (fun (x,y1,y2) -> TwoXYDataPoint(X=x,Y1=y1,Label=null,Y2=y2))
                  ChartData.Values(NotifySeq.ignoreReset dataAndLabels, xType, "X", "Y1,Y2", "")
              | Some labels ->  
                  let labels = NotifySeq.notifyOrOnce labels
                  let dataAndLabels = NotifySeq.zip data labels |> convertKeys1of3of2 |> NotifySeq.map (fun ((x,y1,y2),label) -> TwoXYDataPoint(X=x,Y1=y1,Y2=y2,Label=label))
                  ChartData.Values(NotifySeq.ignoreReset dataAndLabels, xType, "X", "Y1,Y2", "Label=Label")
  
          let internal mergeDataAndLabelsForY2 data (labels: #seq<string> option) = 
  
negative.code: 
          // Three Y values
          let internal mergeDataAndLabelsForXY3 data labels = 
              let data = convertKeys1of4 (NotifySeq.notifyOrOnce data)
              let xType = getChartValueType (Seq.map (fun (a, _, _, _) -> a) data)
              match labels with 
              | None -> 
                  let dataAndLabels = data |> NotifySeq.map (fun (x,y1,y2,y3) -> ThreeXYDataPoint(X=x,Y1=y1,Label=null,Y2=y2,Y3=y3))
                  ChartData.Values(NotifySeq.ignoreReset dataAndLabels, xType, "X", "Y1,Y2,Y3", "")
              | Some labels ->  
                  let labels = NotifySeq.notifyOrOnce labels
                  let dataAndLabels = NotifySeq.zip data labels |> NotifySeq.map (fun ((x,y1,y2,y3),label) -> ThreeXYDataPoint(X=x,Y1=y1,Y2=y2,Y3=y3,Label=label))
                  ChartData.Values(NotifySeq.ignoreReset dataAndLabels, xType, "X", "Y1,Y2,Y3", "Label=Label")
  
  
          // One X and Four Y values
          let internal mergeDataAndLabelsForXY4 (data:seq<#key * #value * #value * #value * #value>) labels = 
              let data = convertKeys1of5 (NotifySeq.notifyOrOnce data)
              let xType = getChartValueType (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))
                  ChartData.Values(NotifySeq.ignoreReset dataAndLabels, xType, "X", "Y1,Y2,Y3,Y4", "")
              | Some labels ->  
                  let labels = NotifySeq.notifyOrOnce labels
                  let dataAndLabels = NotifySeq.zip data labels |> NotifySeq.map (fun ((x,y1,y2,y3,y4),label) -> FourXYDataPoint(X= string (box x),Y1=y1,Y2=y2,Y3=y3,Y4=y4,Label=label))
                  ChartData.Values(NotifySeq.ignoreReset dataAndLabels, xType, "X", "Y1,Y2,Y3,Y4", "Label=Label")
  
          // Four Y values
  