anchor.diff:      let FunctionNamesForArity i: P<string> = arityNNameArr.[i]
       let FunctionNamesForAtLeastArity i: P<string> = arityAtLeastNNameArr.[i-1]
   
  +    // from http://stackoverflow.com/a/22252504/480764
  +    let rec pmap f xs =
  +        match xs with
  +        | x :: xs -> parse { let! y = f x
  +                             let! ys = pmap f xs
  +                             return y :: ys }
  +        | [] -> parse { return [] }
  +
  +    let Argument R = fun (i: int) -> (((ExpressionDecl R) .>> pstring ",") <!> ("argument #" + i.ToString()))
  +
       let ArgumentsN R n =
           (pipe2
  -            (parray (n-1) ((ExpressionDecl R) .>> pstring ",") )
  +            (pmap (Argument R) [0..n-1])
               (ExpressionDecl R)
  -            (fun exprArr expr -> Array.toList exprArr @ [expr] ) <!> ("Arguments" + n.ToString())
  +            (fun exprs expr -> exprs @ [expr] ) <!> ("Arguments" + n.ToString())
           )
   
       let ArgumentsAtLeastN R n =
  
positive.code:                   <!> "AnyAddr"
  
      // Ranges
      let RA1TO_1 = pstring ":" >>. AddrA1 .>> pstring "," <!> "RTO1"
      let RA1TO_2 = pstring ":" >>. AddrA1 <!> "RTO2"
      let RTO = (attempt RA1TO_1) <|> RA1TO_2
  
      let RA1TC_1 = pstring "," >>. AddrA1 .>> pstring "," <!> "RTC1"
      let RA1TC_2 = pstring "," >>. AddrA1 <!> "RTC2"
      let RTC = (attempt RA1TC_1) <|> RA1TC_2
  
      let RA1_1 = (* AddrA1 RTC (1)*) pipe2 AddrA1 RTC (fun a1 a2 -> Range([(a2,a2); (a1,a1)])) <!> "AddrA1 RTC ==(1)=="
      let RA1_2 = (* AddrA1 RTO (2)*) pipe2 AddrA1 RTO (fun a1 a2 -> Range(a1,a2)) <!> "AddrA1 RTO ==(2)=="
  
      let rat_fun = fun a1 a2 a3 -> Range([(a1,a2);(a3,a3)])
      let RA1_3a = pipe3 AddrA1 RA1TO_1 RA1TC_1 rat_fun <!> "AddrA1 RTO1 RTC1 ===(3a)==="
      let RA1_3b = pipe3 AddrA1 RA1TO_1 RA1TC_2 rat_fun <!> "AddrA1 RTO1 RTC2 ===(3b)==="
      let RA1_3c = pipe3 AddrA1 RA1TO_2 RA1TC_1 rat_fun <!> "AddrA1 RTO2 RTC1 ===(3c)==="
      let RA1_3d = pipe3 AddrA1 RA1TO_2 RA1TC_2 rat_fun <!> "AddrA1 RTO2 RTC2 ===(3d)==="
      let RA1_3 = (* AddrA1 RTO RTC (3)*) 
                  (attempt RA1_3a) <|> (attempt RA1_3b) <|> (attempt RA1_3c) <|> RA1_3d <!> "AddrA1 RTO RTC ==(3)=="
  
      let RA1_4_UNION = (* AddrA1 "," R (4)*) pipe2 (AddrA1 .>> (pstring ",")) RangeA1Union (fun a1 r1 -> Range(r1.Ranges() @ [(a1, a1)])) <!> """AddrA1 "," R ==(4)=="""
      let RA1_5_UNION = (* AddrA1 RTO R (5)*) pipe3 AddrA1 RTO RangeA1Union (fun a1 a2 r2 -> Range ((a1,a2) :: r2.Ranges())) <!> "AddrA1 RTO R ==(5)=="
      do RangeA1UnionImpl :=   (attempt RA1_5_UNION)
                          <|> (attempt RA1_4_UNION)
                          <|> (attempt RA1_3)
  
negative.code: "ODDFPRICE"; "ODDFYIELD"; "ODDLPRICE"; "ODDLYIELD"; "OR";
  "PRODUCT"; 
  "RTD"; 
  "STDEV"; "STDEV.P"; "STDEV.S"; "STDEVA"; "STDEVP"; "STDEVPA"; "SUBTOTAL"; "SUMPRODUCT"; "SUMSQ"; "SWITCH";
  "TEXTJOIN"; 
  "VAR"; "VAR.P"; "VAR.S"; "VARA"; "VARP"; "VARPA";
  "XOR"]
  