anchor.diff:                                      NamedReferenceFirstChar
                                       NamedReferenceLastChars
                                       (fun c s -> ReferenceNamed(us, c.ToString() + s) :> Reference)
  -
  +                         <!> "NamedReference"
       let StringReference = getUserState >>=
                               fun us ->
                                   between
  
positive.code:                                                 | None      -> ReferenceAddress(Env(us.Path, wbname, wsname), addr) :> Reference
                                              )
                                          )
      let AddressReferenceWorksheet = getUserState >>=
                                          fun us ->
                                              pipe2
                                                  (WorksheetName .>> pstring "!")
                                                  AnyAddr
                                                  (fun wsname addr -> ReferenceAddress(Env(us.Path, us.WorkbookName, wsname), addr) :> Reference)
      let AddressReferenceNoWorksheet = getUserState >>=
                                          fun us ->
                                              AnyAddr
                                              |>> (fun addr -> ReferenceAddress(us, addr) :> Reference)
      let AddressReference = (attempt AddressReferenceWorkbook)
                             <|> (attempt AddressReferenceWorksheet)
                             <|> AddressReferenceNoWorksheet
  
      let NamedReferenceFirstChar = satisfy (fun c -> c = '_' || isLetter(c))
      let NamedReferenceLastChars = manySatisfy (fun c -> c = '_' || isLetter(c) || isDigit(c))
  
negative.code:                             Addr1Abs
                              (fun col row ->
                                  Address.fromA1(row, col, us.WorksheetName, us.WorkbookName, us.Path)))
                      <!> "AddrA1"
      let AnyAddr = ((attempt AddrIndirect)
                    <|> (attempt AddrR1C1)
                    <|> AddrA1)
                    <!> "AnyAddr"
  
      // Ranges
      let RA1TO = (* RTO *)
                  (attempt (pstring ":" >>. AddrA1) <!> "RTO (first)")
                  <|> ((pstring ":" >>. AddrA1 .>> pstring ",") <!> "RTO (second)")
      let RA1TC = (* RTC *)
                  (attempt (pstring "," >>. AddrA1) <!> "RTC (first)")
                  <|> ((pstring "," >>. AddrA1 .>> pstring ",") <!> "RTC (second)")
      let RA1_1 = (* A RTC *) pipe2 AddrA1 RA1TC (fun a1 a2 -> Range(a1,a2)) <!> "A RTC"
      let RA1_2 = (* A RTO *) pipe2 AddrA1 RA1TO (fun a1 a2 -> Range(a1,a2)) <!> "A RTO"
      let RA1_3 = (* A RTO RTC *) pipe3 AddrA1 RA1TO RA1TC (fun a1 a2 a3 -> Range([(a1,a2);(a3,a3)])) <!> "A RTO RTC"
      let RA1_4 = (* A "," R *) pipe2 (AddrA1 .>> (pstring ",")) RangeA1 (fun a1 r1 -> Range(r1.Ranges() @ [(a1, a1)])) <!> """A "," R"""
      let RA1_5 = (* A RTO R *) pipe3 AddrA1 RA1TO RangeA1 (fun a1 a2 r2 -> Range ((a1,a2) :: r2.Ranges())) <!> "A RTO R"
      do RangeA1Impl :=   (attempt RA1_3)
                          <|> (attempt RA1_1)
                          <|> (attempt RA1_2)
                          <|> (attempt RA1_4)
                          <|> RA1_5
                          
      do RangeR1C1Impl := RangeA1
  
      let R = RangeA1 <!> "Range"
  //    let R = (attempt RangeR1C1) <|> RangeA1
  
      // Worksheet Names
  