anchor.diff:  open ICSharpCode.Decompiler.ILAst
   open ICSharpCode.Decompiler.Ast
   open ICSharpCode.NRefactory.CSharp
  +open ICSharpCode.NRefactory.TypeSystem
   open Microsoft.FSharp.Quotations
   
  -type ExprState = { arguments : Map<string, Var>; locals : Map<string, Var> }
  +type ExprState = { arguments : Map<string, Var>; locals : Map<string, Var>; declared : Map<string, Var> }
   type ExprResult<'a> = { run : ExprState -> 'a * ExprState}
  -
  -
   
   [<AutoOpen>]
   module Builder =
       open Quotations.Patterns
   
       type ExprBuilder() =
  -        member x.Bind(m : ExprResult<'a>, f : 'a -> ExprResult<'b>) =
  +//        member x.Bind(m : ExprResult<'a>, f : 'a -> ExprResult<'b>) =
  +//            { run = fun s ->
  +//                let v, s = m.run s    
  +//                (f v).run s
  +//            }
  +
  +        member x.Bind(m : ExprResult<list<Expr> -> 'a>, f : 'a -> ExprResult<'b>) =
               { run = fun s ->
                   let v, s = m.run s    
  -                (f v).run s
  +                (f (v [])).run s
               }
   
           member x.Return(v) =
               { run = fun s ->
  +                (fun (e : list<Expr>) -> 
  +                    let rec build (e : list<Expr>) =
  +                        match e with
  +                            | [e] -> e
  +                            | [] -> Expr.Value(())
  +                            | e::es ->
  +                                Expr.Sequential(e, build es)
  +                    match e with
  +                        | [] -> v
  +                        | e ->
  +                            let e = build e
  +                            Expr.Sequential(v, e)
  +
  +
  +                ), s
  +            }
  +
  +        member x.ReturnFrom(v : list<Expr> -> Expr) =
  +            { run = fun s ->
                   v, s
               }
   
  
positive.code:                 v|> Seq.toList, s
              }
  
  type QuotationVisitor(mi : MethodInfo, m : MethodDefinition) as this =
  
      let resolve (t : TypeReference) =
  
negative.code:                         match Map.tryFind name s.arguments with
                              | Some a -> a
                              | None -> failwithf "unknown identifier: %A" name
              (fun (cont : list<Expr>) -> v), s
          }
  
      let seq (l : seq<Expr>) =
          let l = l |> Seq.toList
          let rec build (a : list<Expr>) =
              match a with
                  | [] -> Expr.Value(())
                  | [e] -> e
                  | e::es -> Expr.Sequential(e, build es)
          build l
  
  
      module Seq =
          let mapM (f : 'a -> ExprResult<list<Expr> -> Expr>) (l : seq<'a>) =
              { run = fun s ->
                  let l = l |> Seq.toList
  
                  let rec run (l : list<'a>) (s : ExprState) =
                      match l with
                          | [] -> (fun (cont : list<Expr>) -> seq cont), s
                          | [e] -> 
                              let v, s = (f e).run s
                              v, s
                          | e::es ->
                              let v1, s = (f e).run s
                              let v, s = run es s
  
                              (fun cont -> v1 [v cont]), s 
  
                  run l s
  //
  //                let mutable c = s
  //                let res = System.Collections.Generic.List()
  //                for e in l do
  //                    let v, s = (f e).run c
  //                    res.Add(v [])
  //                    c <- s
  //                (fun (cont : list<Expr>) -> res.AddRange cont; res :> seq<_>), c
                  
              }
          let toListM (m : ExprResult<seq<'a>>) =
  