anchor.diff:                                                  | None      -> ReferenceAddress(Env(us.Path, wbname, wsname), addr) :> Reference
                                               )
                                           )
  +                                    <!> "AddressReferenceWorkbook"
       let AddressReferenceWorksheet = getUserState >>=
                                           fun us ->
                                               pipe2
                                                   (WorksheetName .>> pstring "!")
                                                   AnyAddr
                                                   (fun wsname addr -> ReferenceAddress(Env(us.Path, us.WorkbookName, wsname), addr) :> Reference)
  +                                    <!> "AddressReferenceWorksheet"
       let AddressReferenceNoWorksheet = getUserState >>=
                                           fun us ->
                                               AnyAddr
                                               |>> (fun addr -> ReferenceAddress(us, addr) :> Reference)
  +                                      <!> "AddressReferenceNOWorksheet"
       let AddressReference = (attempt AddressReferenceWorkbook)
                              <|> (attempt AddressReferenceWorksheet)
                              <|> AddressReferenceNoWorksheet
  +                           <!> "AddressReference"
   
       let NamedReferenceFirstChar = satisfy (fun c -> c = '_' || isLetter(c))
       let NamedReferenceLastChars = manySatisfy (fun c -> c = '_' || isLetter(c) || isDigit(c))
  
positive.code:                                     (pstring "\"")
                                      (manySatisfy ((<>) '"'))
                                  |>> (fun s -> ReferenceString(us, s) :> Reference)
  
      let ConstantReference = getUserState >>= 
                                  fun us ->
                                      (attempt
                                          (pfloat .>> pstring "%"
                                          |>> fun r -> ReferenceConstant(us, r / 100.0) :> Reference))
                                      <|> (pfloat |>> (fun r -> ReferenceConstant(us, r) :> Reference))
  
      let Reference = (attempt RangeReference) <|> (attempt AddressReference) <|> (attempt ConstantReference) <|> (attempt StringReference) <|> NamedReference
  
      // Functions
      let FunctionName = (pstring "INDIRECT" >>. pzero) <|> many1Satisfy (fun c -> isLetter(c))
      let Function = getUserState >>=
                      fun us ->
                          pipe2
                              (FunctionName .>> pstring "(")
                              (ArgumentList .>> pstring ")")
                              (fun fname arglist -> ReferenceFunction(us, fname, arglist) :> Reference)
      do ArgumentListImpl := sepBy ExpressionDecl (spaces >>. pstring "," .>> spaces)
  
      // Binary arithmetic operators
      let BinOpChar = spaces >>. satisfy (fun c -> c = '+' || c = '-' || c = '/' || c = '*' || c = '<' || c = '>' || c = '=' || c = '^' || c = '&') .>> spaces
      let BinOp2Char = spaces >>. ((attempt (regex "<=")) <|> (attempt (regex ">=")) <|> regex "<>") .>> spaces
      let BinOpLong: P<string*Expression> = pipe2 BinOp2Char ExpressionDecl (fun op rhs -> (op, rhs))
      let BinOpShort: P<string*Expression> = pipe2 BinOpChar ExpressionDecl (fun op rhs -> (op.ToString(), rhs))
      let BinOp: P<string*Expression> = (attempt BinOpLong) <|> BinOpShort
  
      // Unary operators
      let UnaryOpChar = spaces >>. satisfy (fun c -> c = '+' || c = '-') .>> spaces
  
      // Expressions
      let ParensExpr: P<Expression> = (between (pstring "(") (pstring ")") ExpressionDecl) |>> ParensExpr
      let ExpressionAtom: P<Expression> = ((attempt Function) <|> Reference) |>> ReferenceExpr
      do ExpressionSimpleImpl := ExpressionAtom <|> ParensExpr
      let UnaryOpExpr: P<Expression> = pipe2 UnaryOpChar ExpressionDecl (fun op rhs -> UnaryOpExpr(op, rhs))
      let BinOpExpr: P<Expression> = pipe2 ExpressionSimple BinOp (fun lhs (op, rhs) -> BinOpExpr(op, lhs, rhs))
      do ExpressionDeclImpl := (attempt UnaryOpExpr) <|> (attempt BinOpExpr) <|> (attempt ExpressionSimple)
  
      // Formulas
      let Formula = pstring "=" .>> spaces >>. ExpressionDecl .>> eof
negative.code:                                     NamedReferenceFirstChar
                                      NamedReferenceLastChars
                                      (fun c s -> ReferenceNamed(us, c.ToString() + s) :> Reference)
                           <!> "NamedReference"
      let StringReference = getUserState >>=
                              fun us ->
                                  between
  