anchor.diff:              else None
           go ipos x
   
  +        /// Multiple Edge designs possible, for now use simple dictionary over sorted array w/ binary search
   
           // let rec go l r = 
           //     if l > r then 
  
positive.code: open FSharp.Core.Printf
  open System.Collections.Generic
  
  
  let stringParse2 (path:string) ipos fpos = path.Substring(ipos,fpos - ipos)
  
  let intParse2 (path:string) ipos fpos =
      let mutable result = 0
      for pos in ipos .. fpos do 
          let charDiff = int path.[pos] //- '0'
          if -1 < charDiff && charDiff < 10 then
              result <- (result * 10) + charDiff
      result
  
  let floatParse2 (path:string) ipos fpos =
      let mutable result = 0.
      let mutable decPlaces = 0.
      let negNumber = path.[ipos] = '-'
      for pos in ipos .. fpos do
          if path.[pos] = '.' then
              decPlaces <- 1.
          else
              let charDiff = float path.[pos] // - '0'
              if -1. < charDiff && charDiff < 10. then
                  if decPlaces = 0. then 
                      result <- (result * 10.) + float charDiff
                  else
                      result <- result + ((float charDiff) / (10. * decPlaces))
      if negNumber then result * -1. else result
  
  let formatStringMap =
      dict [
      // Char    Regex                    Parser
      // ----------------------------------------------------------
          'b', (bool.Parse >> box)  // bool
          'c', (char       >> box)  // char
          's', (              box)  // string
          'i', (int32      >> box)  // int
          'd', (int64      >> box)  // int64
          'f', (float      >> box)  // float
      ]
  
  type Node(iRouteFn:RouteCont<'T>) = 
      let edges = Dictionary<char,Node>()
  
negative.code: 
          let pathLen = path.Length
  
  
          let findClosure (path:string) ipos (inode:Node) =
              let pathLen = path.Length
  