anchor.diff: +#I @"..\..\..\bin\Release"
  +#I @"..\..\..\Packages\Rx-Core\lib\net45"
  +#I @"..\..\..\Packages\Rx-Interfaces\lib\net45"
  +#I @"..\..\..\Packages\Rx-Linq\lib\net45"
  +#r "Aardvark.Base.dll"
  +#r "Aardvark.Base.Essentials.dll"
  +#r "Aardvark.Base.TypeProviders.dll"
  +#r "Aardvark.Base.FSharp.dll"
  +#r "Aardvark.Base.Incremental.dll"
  +#r "System.Reactive.Core.dll"
  +#r "System.Reactive.Interfaces.dll"
  +#r "System.Reactive.Linq.dll"
  +
  +
  +
   open System
   open System.Runtime.CompilerServices
   open System.Collections
   open System.Collections.Generic
  -
  +open Aardvark.Base
  +open Aardvark.Base.Incremental
   
   type Measure<'a, 'm> = { f : 'a -> 'm; add : 'm -> 'm -> 'm; zero : 'm}
   
  
positive.code:     let toArray (s : SortedList<'a>) =
          s.tree.ViewLeft |> Seq.toArray
  
      let split (v : 'a) (s : SortedList<'a>) =
          match FingerTree.split (fun vi -> vi >= Some v) s.tree with
              | Split(l,x,r) ->
                  let c = compare x v
                  if c > 0 then ({ tree = l }, { tree = FingerTree.prepend x r})
                  elif c < 0 then ({ tree = FingerTree.append x l }, { tree = r })
                  else ({ tree = FingerTree.append x l }, { tree = r })
              | NoSplit ->
                  (s, empty)
  
      let min (s : SortedList<'a>) =
          s.tree.ViewLeft |> Seq.head
  
      let max (s : SortedList<'a>) =
          s.tree.ViewRight |> Seq.head
  
      let isEmpty (s : SortedList<'a>) =
          match FingerTree.total s.tree with
              | Some _ -> false
              | None -> true
  
      let union (l : SortedList<'a>) (r : SortedList<'a>) =
          let lt = FingerTree.total l.tree
  
negative.code:             | Some _, None -> l
              | None, Some _ -> r
              | Some lv, Some rv ->
                  let rightMin = min r
                  let leftMin = min l
                  if lv < rightMin then
                      { tree = FingerTree.concat l.tree r.tree }
                  elif rv < leftMin then
                      { tree = FingerTree.concat r.tree l.tree }
                  else
                      let mutable res = l
                      for e in r.tree.ViewLeft do
                          res <- add e res
                      res
  
      let unsafeConcatWithMiddle (l : SortedList<'a>) (m : list<'a>) (r : SortedList<'a>) =
          { tree = FingerTree.concatWithMiddle l.tree m r.tree }
     
      let unsafeAppendRange (l : SortedList<'a>) (r : list<'a>) =
          { tree = FingerTree.concatWithMiddle l.tree r (FingerTree.custom m) }
      
      let unsafePrependRange (l : list<'a>) (r : SortedList<'a>) =
          { tree = FingerTree.concatWithMiddle (FingerTree.custom m) l r.tree }
  
  
      let viewl (l : SortedList<'a>) =
          match FingerTree.viewl l.tree with
              | Some(v,rest) -> Some(v, { tree = rest })
  