anchor.diff:      let Equal(l : Expr, r : Expr) = BinaryExpression(Equal, l, r) :> Expr
       let NotEqual(l : Expr, r : Expr) = BinaryExpression(NotEqual, l, r) :> Expr
   
  +    let And(l : Expr, r : Expr) = BinaryExpression(And, l, r) :> Expr
  +    let Or(l : Expr, r : Expr) = BinaryExpression(Or, l, r) :> Expr
  +    
  +    let BitAnd(l : Expr, r : Expr) = BinaryExpression(BitAnd, l, r) :> Expr
  +    let BitOr(l : Expr, r : Expr) = BinaryExpression(BitOr, l, r) :> Expr
  +    let BitXor(l : Expr, r : Expr) = BinaryExpression(BitXor, l, r) :> Expr
  +
  +    let LeftShift(l : Expr, r : Expr) = BinaryExpression(LeftShift, l, r) :> Expr
  +    let RightShiftLogic(l : Expr, r : Expr) = BinaryExpression(RightShiftLogic, l, r) :> Expr
  +    let RightShiftArithmetic(l : Expr, r : Expr) = BinaryExpression(RightShiftArithmetic, l, r) :> Expr
  +
  +
   
       let NewObject(t : Type, args : list<Expr>) = NewObjectExpression(t, args) :> Expr
       let Unit = UnitExpression.Instance :> Expr
  
positive.code:                     | Add | Sub -> additionType l r
                      | Mul  -> multiplicationType l r
                      | Div | Mod -> divisionType l r
                      | _ -> Some Type.Bool
  
              match res with
                  | Some res -> res
                  | None -> failwithf "could not determine type for %A(%A, %A)" op l r
  
          [<AbstractClass>]
          type AbstractExpression(kind : ExpressionType, t : Type) =
  
negative.code: [<AutoOpen>]
  module SpirVBuilders =
      
      let (|ExitInstruction|_|) (i : Instruction) =
          match i with
              | OpReturn -> Some()
              | OpReturnValue _ -> Some()
              | OpBranch _ -> Some()
              | OpBranchConditional _ -> Some()
              | OpKill -> Some ()
              | OpUnreachable -> Some ()
              | OpSwitch(_,_,_) -> Some ()
              | _ -> None
  
  
      type RevList<'a> =
          | Snoc of RevList<'a> * 'a
          | Nil
  