anchor.diff:  //        
   
           let filled = Mod.init true
  -        let text = Mod.init "hi"
  -
  +        let text = Mod.init """font"""
  +
  +        let size = 0.15
           let sg =
               Rewrite.Sg.Text(test, text)
   //            char 
  
positive.code:             path.AddString(String(c, 1), font.FontFamily, int font.Style, size, PointF(0.0f, 0.0f), StringFormat.GenericDefault)
  
  
  
  
              // build the interior polygon and boundary triangles using the 
              // given GraphicsPath
              let types = path.PathTypes
              let points = path.PathPoints |> Array.map (fun p -> V2d(p.X, p.Y))
  
              let mutable start = V2d.NaN
              let currentPoints = List<V2d>()
              let segments = List<PathSegment>()
  
              for (p, t) in Array.zip points types do
                  let t = t |> int |> unbox<PathPointType>
  
                  let close = t &&& PathPointType.CloseSubpath <> PathPointType.Start
  
  
                  match t &&& PathPointType.PathTypeMask with
                      | PathPointType.Line ->
                          if currentPoints.Count > 0 then
                              let last = currentPoints.[currentPoints.Count - 1]
                              segments.Add(Line(last, p))
                              currentPoints.Clear()
                          currentPoints.Add p
                          
  
  
                      | PathPointType.Bezier ->
                          currentPoints.Add p
                          if currentPoints.Count >= 4 then
                              let p0 = currentPoints.[0]
                              let p1 = currentPoints.[1]
                              let p2 = currentPoints.[2]
                              let p3 = currentPoints.[3]
                              segments.Add(Bezier3(p0, p1, p2, p3))
                              currentPoints.Clear()
                              currentPoints.Add p3
  
                      | PathPointType.Start | _ ->
                          currentPoints.Add p
                          start <- p
                          ()
  
                  if close then
                      if not start.IsNaN && p <> start then
                          segments.Add(Line(p, start))
                      currentPoints.Clear()
                      start <- V2d.NaN
  
              //use f = new Font(font.FontFamily, 2000.0f, font.Style, GraphicsUnit.Point, font.GdiCharSet, font.GdiVerticalFont)
              use g = Graphics.FromHwnd(0n)
              g.PageUnit <- font.Unit
  
              let size = 
                  let sf = g.MeasureString(String(c, 1), font)
                  V2d(sf.Width, sf.Height)
              { outline = CSharpList.toArray segments; bounds = Box2d.FromMinAndSize(0.0, 0.0, size.X, size.Y) }
  
          let single (seg : PathSegment) =
              { outline = [| seg |]; bounds = Box2d.Invalid }
  
          let ofSeq (segments : seq<PathSegment>) =
              { outline = Seq.toArray segments; bounds = Box2d.Invalid }
  
          let ofList (segments : list<PathSegment>) =
              { outline = List.toArray segments; bounds = Box2d.Invalid }
  
          let ofArray (segments : PathSegment[]) =
              { outline = Array.copy segments; bounds = Box2d.Invalid }
  
          let toSeq (p : Path) =
              p.outline :> seq<_>
  
negative.code:                 | (true, v) -> v
                  | _ -> 0.0
  
          let getGlyphSizes (c : char) =
              sizesABC.GetOrAdd(c, fun c ->
                  let abc = FontInfo.getCharWidths graphics largeScaleFont c
                  abc
              )
  
          let getGlyph (c : char) =
  