anchor.diff:          member x.Get(v) = match lookupLocals locals  v with // match locals.TryFind(v) with 
                               | None -> ve.Get(v) 
                               | Some(s) -> s
  +    /// Match either a  Bool const or variable that's a bool
  +    let (|BConstOrVar|_|) (vf:VarFetcher) = function
  +        | BCONST(c) -> Some(c)
  +        | VARIABLE(v) ->
  +            match vf.Get(v) with
  +                | BCONST(e) ->
  +                    Some(e)
  +                | _ as x -> failwithf "ERROR: '%A' not a boolean expression" (x.ToString())
  +        | _ -> None
   
       /// Main template rendering class.  Instantiated usings
       /// string as a constructor and optionally a function to fetch sub templates  
  
positive.code:     and (|ComparisonExpr|_|) = function // series of or statements
          | ComparisonFactor(e1, Ws(t)) ->
              let rec aux e1 = function
                | 'o'::'r'::Ws(Expr(e2, t)) -> aux (OR(e1,e2)) t
                | _ as t -> Some(e1,t)
              aux e1 t
          | _ -> None
      and (|ComparisonFactor|_|) = function
          | Expr(e1,Ws(t)) ->
              let rec aux e = function
                  | 'a'::'n'::'d'::Ws(ComparisonFactor(e2,t)) -> aux (AND(e1,e2)) t
                  | t -> Some(e,t)
              aux e1 t
          | _ -> None
  
      and (|Expr|_|) = function
          | Factor(e1, Ws(t)) ->
              let rec aux e1 = function
                | 'o'::'r'::Ws(Expr(e2, t)) -> aux (OR(e1,e2)) t
                | '!'::'='::Ws(Factor(e2,t)) -> aux(NOTEQUAL(e1,e2)) t
                | '='::'='::Ws(Factor(e2,t)) -> aux (EQUALS(e1,e2)) t
                | '+'::Ws(Factor(e2, t)) -> aux (ADD(e1,e2)) t
                | '-'::Ws(Factor(e2, t)) -> aux (SUB(e1,e2)) t
                | '<'::Ws(Expr(e2,t)) -> aux(LESSTHAN(e1,e2)) t
                | '>'::Ws(Expr(e2,t)) -> aux(GREATERTHAN(e1,e2)) t
                | t -> Some(e1, t)
              aux e1 t
          | _ -> None
        and (|Factor|_|) = function
  
negative.code:                             | x when x.StartsWith("if") -> 
                                          match (List.ofSeq x.[3..]) with
                                                      //| Comparison(c,[]) -> IFSTART(c)
                                                      | BoolExpr(c,[]) -> IFSTART(c) // boolean expression like if x
                                                      | _ as x -> failwithf "ERROR: parsing if expression, unparseable expression encountered %A" x
                                          //IFSTART(c)
                              | _ as x -> UNKNOWNLOGIC(x)
  