anchor.diff:  open System.Collections.Generic
   open System.Reflection
   open System.Reflection.Emit
  +open System.Runtime.CompilerServices
   open Microsoft.FSharp.Reflection
   open Microsoft.FSharp.Quotations
   open Microsoft.FSharp.Quotations.Patterns
  
positive.code:             let sw = System.Diagnostics.Stopwatch()
              sw.Start()
              for i in 1 .. iter do
  //                let s = Scope.Root.ChildScope test
  //                s.Set(1, 0)
  //                s.Set(2, 0)
                  test.Sum (SumScope(null, test)) |> ignore
              sw.Stop()
              Log.line "virt: %A" (sw.MicroTime / iter)
  
              let sw = System.Diagnostics.Stopwatch()
              let disp = Globals.synDispatchers.[Globals.getAttributeIndex "Sum"]// |> unbox<WrappedDispatcher<int, int>>
              let mutable res = null
              sw.Start()
              for i in 1 .. iter do
                  sum test |> ignore
                  //disp.TryInvoke(test, Scope.Root.ChildScope test, &res) |> ignore
              sw.Stop()
              Log.line "ag:   %A" (sw.MicroTime / iter)
  
  
negative.code: open QuotationCompiler.Simple
  open Aardvark.Base.Incremental
  
  module Ag =
      [<AutoOpen>]
      module Frontend =
          type AttributeKind =
              | None          = 0x00
              | Inherited     = 0x01
              | Synthesized   = 0x02
              | Mixed         = 0x03
  
          [<AttributeUsage(AttributeTargets.Class, AllowMultiple = false)>]
          type SemanticAttribute() = 
              inherit Attribute()
  
          [<AttributeUsage(AttributeTargets.Property ||| AttributeTargets.Method, AllowMultiple = false); AllowNullLiteral>]
          type AttributeAttribute(name : string, kind : AttributeKind) =
              inherit Attribute()
  
              member x.Name = name
              member x.Kind = kind
  
              new(kind : AttributeKind) = AttributeAttribute(null, kind)
  
          type Root<'a> = class end
          
          type Inh private() =
              static let instance = Inh()
              static member Instance = instance
  
          let inh = Inh.Instance
  
          [<MethodImpl(MethodImplOptions.NoInlining)>]
          let (?) (o : 'a) (name : string) : 'b = failwith ""
              
          [<MethodImpl(MethodImplOptions.NoInlining)>]
          let (<<=) (m : Inh) (value : 'a) = ()
  
      module Implementation = 
          [<AutoOpen>]
          module Patterns =
              let private isUnitFunction (t : Type) =
                  if t.Name.StartsWith "FSharpFunc" then
                      let (d,_) = FSharpType.GetFunctionElements t
                      d = typeof<unit>
                  else
                      false
              let private attributeLookupCache = System.Collections.Concurrent.ConcurrentDictionary<MethodInfo, Option<string * AttributeKind>>()
              let private rx = System.Text.RegularExpressions.Regex @"(get_)?(?<name>[a-zA-Z_0-9]+$)"
  
              let (|AttributeLookup|_|) (mi : MethodInfo) =
                  attributeLookupCache.GetOrAdd (mi, fun mi ->
                      let att = mi.GetCustomAttribute<AttributeAttribute>()
  