anchor.diff:  
   open Aardvark.Base.Incremental
   
  +#nowarn "9"
  +#nowarn "51"
   
   [<AutoOpen>]
   module SgFSharp =
  
positive.code: 
          module private Interleaved = 
              open System.Reflection
  
              type Converter() =
                  static let accessors =
                      Dict.ofList [
                          typeof<float32>, (1, (fun (v : float32) -> [|v|]) :> obj)
                          typeof<V2f>,     (2, (fun (v : V2f) -> [|v.X; v.Y|]) :> obj)
                          typeof<V3f>,     (3, (fun (v : V3f) -> [|v.X; v.Y; v.Z|]) :> obj)
                          typeof<V4f>,     (4, (fun (v : V4f) -> [|v.X; v.Y; v.Z; v.W|]) :> obj)
                      ]
  
                  static member ToFloatArray (arr : 'a[]) : float32[] =
  
negative.code: 
              Sg.TrafoApplicator(Mod.map transformBox bb, this) :> ISg
  
          let normalizeTo (box : Box3d) (this : ISg) =
  
              let getBoxScale (fromBox : Box3d) (toBox : Box3d) : float =
                  let fromSize = fromBox.Size
                  let toSize = toBox.Size
                  let factor = toSize / fromSize
  
                  let mutable smallest = factor.X
  
                  if factor.Y < smallest then
                      smallest <- factor.Y
                  if factor.Z < smallest then
                      smallest <- factor.Z
  
                  smallest
  
              let bb = this?GlobalBoundingBox() : IMod<Box3d>
  
              let transformBox (sbox : Box3d) = Trafo3d.Translation(-sbox.Center) * Trafo3d.Scale(getBoxScale sbox box) * Trafo3d.Translation(box.Center)
  
              Sg.TrafoApplicator(bb.GetValue() |> transformBox |> Mod.constant, this) :> ISg
  
          let normalizeAdaptive sg = sg |> normalizeToAdaptive ( Box3d( V3d(-1,-1,-1), V3d(1,1,1) ) ) 
          
          let normalize sg = sg |> normalizeTo ( Box3d( V3d(-1,-1,-1), V3d(1,1,1) ) ) 
  
          let loadAsync (sg : ISg) = Sg.AsyncLoadApplicator(Mod.constant sg) :> ISg
  
  