anchor.diff:          let inline make<'a, 'b when 'a : struct> (getField : 'a -> 'b) (setField : 'b -> 'a -> 'a) : Scope<'a, 'b> =
               { In = SegmentedArray.map getField
                 Out = fun (output, fields) (targets : 'a SegmentedArray) -> (output, SegmentedArray.map2 setField fields targets) }
  +
  +        /// Make a scope with optimized in and out delegates.
  +        let inline fast<'a, 'b when 'a : struct> (getField : In<'a, 'b>) (setField : Out<'a, 'b>) : Scope<'a, 'b> =
  +            { In =
  +                fun (targets : 'a SegmentedArray) ->
  +                    let fields = SegmentedArray.zeroCreate targets.Length
  +                    let mutable i = 0
  +                    while i < dec targets.Length do
  +                        getField.Invoke (&targets.[i], &fields.[i])
  +                        i <- inc i
  +                    fields
  +              Out = fun (output, fields) (targets : 'a SegmentedArray) ->
  +                let mutable i = 0
  +                while i < dec targets.Length do
  +                    setField.Invoke (&fields.[i], &targets.[i])
  +                    i <- inc i
  +                (output, targets) }
   
       /// The base behavior type.
       type Behavior =
  
positive.code:                         | (FlipH, false) -> FlipH
                          | (FlipV, false) -> FlipNone
                          | (FlipHV, false) -> FlipH
                      { p with Flip = flip })
  
      /// Describes a basic emitter.
      type BasicEmitterDescriptor =
  
negative.code:                         | (FlipH, false) -> FlipNone
                          | (FlipV, false) -> FlipV
                          | (FlipHV, false) -> FlipV
                      p.Flip <- flip))
          let flipV =
              Scope.fast
                  (new In<_, _> (fun p v ->
                      let flipV = match p.Flip with FlipNone -> false | FlipH -> false | FlipV -> true | FlipHV -> true
                      v <- struct (p.Life, flipV)))
                  (new Out<_, _> (fun v p ->
                      let flip =
                          match (p.Flip, snd' v) with
                          | (FlipNone, true) -> FlipV
                          | (FlipH, true) -> FlipHV
                          | (FlipV, true) -> FlipV
  