anchor.diff:  and RouteCont<'T> =
   | EmptyMap
   | HandlerMap of HttpHandler
  -| MatchMap of ( char list * (Node option) * ('T -> HttpHandler))
  -
  +| MatchMap of ( (char list) * (Node option) * ('T -> HttpHandler) )
  +
  +// test construction of Node Trie using node mapping functions
  +////////////////////////////////////////////////////
  +
  +// Simple route that iterates down nodes and if function found, execute as normal
   let tRoute (path:string) (fn:HttpHandler) (root:Node)=
  -    let fin = path.Length - 1 
  +    let last = path.Length - 1 
       let rec go i (node:Node) =
  -        if i = fin then
  +        if i = last then
               node.Add path.[i] (HandlerMap fn)
           else
               let nextNode = node.Add path.[i] EmptyMap
               go (i + 1) nextNode
       go 0 root
   
  +// parsing route that iterates down nodes, parses, and then continues down further notes if needed
   let tRoutef (path : StringFormat<_,'U>) (fn:'U -> HttpHandler) (root:Node)=
       let fin = path.Value.Length - 1 
       let rec go i (node:Node) (fMap:char list) =
           if i = fin then
               node.Add path.Value.[i] (MatchMap( fMap , None ))
           else
  -            if path.Value.[i] = '%' then
  -                let fmtChar = path.Value.[i + 1] ///HACK fix out of bounds gap
  +            if path.Value.[i] = '%' && i + 1 < fin then
  +                let fmtChar = path.Value.[i + 1]
                   if formatStringMap.ContainsKey fmtChar then
                       let nMatchMap = fmtChar :: fMap
  -                    let newNodeBranch = Node(EmptyMap)
  +                    let newNodeBranch = Node(EmptyMap) //doublr check logic & relation to i + 1 = 2
                       node.RouteFn <- MatchMap( nMatchMap , Some newNodeBranch )
                       go (i + 2) newNodeBranch nMatchMap
                   else
  
positive.code:             else None
          go ipos x
  
  
          // let rec go l r = 
          //     if l > r then 
  
negative.code:                 go (i + 1) nextNode fMap
      go 0 root []
  
  // choose root will apply its root node to all route mapping functions to generate Trie at compile time, function produced will take routeState (path) and execute appropriate function
  let chooseRoute (routeState:RouteState) (fns:(Node->Node) list)  =
      let root = Node(EmptyMap)
      let rec go ls =
          match ls with
          | [] -> ()
          | h :: t ->
              h root |> ignore
              go t
      go fns
      // process path fn that returns httpHandler
  
  
  let processPath (path:string) (ipos:int) (inode:Node) : HttpHandler =
      fun succ fail ctx -> 
  
          let pathLen = path.Length
  
  
          let findClosure (path:string) ipos (inode:Node) =
              let pathLen = path.Length
  