anchor.diff:                  v|> Seq.toList, s
               }
   
  +    [<AutoOpen>]
  +    module Patterns =
  +        let (|ExpressionStatement|_|) (n : AstNode) =
  +            match n with
  +                | :? ExpressionStatement as s ->
  +                    Some (ExpressionStatement(s.Expression))
  +                | _ ->
  +                    None
  +
  +        let (|Assignment|_|) (n : Expression) =
  +            match n with
  +                | :? AssignmentExpression as ass ->
  +                    Some (Assignment(ass.Left, ass.Right))
  +                | _ ->
  +                    None
  +
  +        let (|Identifier|_|) (n : Expression) =
  +            match n with
  +                | :? IdentifierExpression as id ->
  +                    Some (Identifier(id.Identifier))
  +                | _ -> None
  +
  +        let (|Expression|_|) (n : AstNode) =
  +            match n with
  +                | :? Expression as e ->
  +                    Some (Expression(e))
  +                | _ ->
  +                    None
  +
  +        let (|BinaryOperator|_|) (n : Expression) =
  +            match n with
  +                | :? BinaryOperatorExpression as bin ->
  +                    Some (BinaryOperator(bin.Operator, bin.Left, bin.Right))
  +                | _ ->
  +                    None
  +        
  +        let (|Constant|_|) (n : Expression) =
  +            match n with
  +                | :? PrimitiveExpression as p ->
  +                    Some (Constant(p.Value))
  +                | _ ->
  +                    None
  +
  +        let (|VariableDeclaration|_|) (n : AstNode) =
  +            match n with
  +                | :? VariableDeclarationStatement as decl ->
  +                    Some (VariableDeclaration(decl.Variables |> Seq.toList))
  +                | _ ->
  +                    None
  +
  +        let (|Init|) (i : VariableInitializer) =
  +            Init (i.Name, i.Initializer)
  +
  +
  +        let (|PostIncrement|PostDecrement|PreIncrement|PreDecrement|NoIncrement|) (n : Expression) = 
  +            match n with
  +                | :? UnaryOperatorExpression as op ->
  +                    if op.Operator = UnaryOperatorType.PostIncrement then 
  +                        (PostIncrement(op.Children |> Seq.head))
  +                    elif op.Operator = UnaryOperatorType.PostDecrement then 
  +                        (PostDecrement(op.Children |> Seq.head))
  +                    elif op.Operator = UnaryOperatorType.Increment then 
  +                        (PreIncrement(op.Children |> Seq.head))
  +                    elif op.Operator = UnaryOperatorType.Decrement then 
  +                        (PreDecrement(op.Children |> Seq.head))
  +                    else
  +                        NoIncrement
  +                | _ ->
  +                    NoIncrement
  +
  +        let subtractOne (e : Expr) =
  +            match e with
  +                | Call(None, add, [v;Value((:? int as c), _)]) | Call(None, add, [Value((:? int as c), _); v]) when add.Name = "op_Addition" && c = 1 ->
  +                    v
  +                | Call(None, add, [v;Value((:? int as c), _)]) | Call(None, add, [Value((:? int as c), _); v]) when add.Name = "op_Addition" ->
  +                    let c1 = c - 1
  +                    if c1 = 0 then
  +                        v
  +                    else
  +                        <@@ %%v + c1 @@>
  +                | _ ->
  +                    <@@ %%e - 1 @@>
  +
   type QuotationVisitor(mi : MethodInfo, m : MethodDefinition) as this =
   
       let resolve (t : TypeReference) =
  
positive.code:         | None ->
              failwithf "could not get module: %A" mi.Module
  
  [<EntryPoint>]
  let main args =
      let mi = typeof<Test>.GetMethod "Do"
  
      let m = getCecilMethod mi
  //
  //    let builder = ICSharpCode.Decompiler.ILAst.ILAstBuilder()
      let ctx = DecompilerContext(m.Module)
  //    let res = builder.Build(m, true, ctx)
  //
  //    let b = ILBlock(res)
  //    let ctrl = SimpleControlFlow(ctx, b)
  
  
      let b1 = AstBuilder(ctx)
      
      b1.AddType(m.DeclaringType)
      b1.RunTransformations(fun t -> printfn "%A" t; true)
  
      let ex = b1.SyntaxTree.AcceptVisitor(QuotationVisitor(mi, m))
  
  
      let resolve (t : TypeReference) =
          Type.GetType(t.FullName)
  
  
negative.code:     let argsMap = args |> List.map (fun a -> a.Name, a) |> Map.ofList
  
  
      let exd, s = ex.run { arguments = argsMap; locals = Map.empty; declared = Map.empty }
  
      let ex = exd []
      let ex2 = ex |> FSharp.removeImperativeReturn |> FSharp.removeRetFunctions
  
      printfn "%A" ex2
  //
  //    printfn "%A" b
  //
  