anchor.diff:                          | (FlipH, false) -> FlipNone
                           | (FlipV, false) -> FlipV
                           | (FlipHV, false) -> FlipV
  -                    { p with Flip = flip })
  +                    p.Flip <- flip))
           let flipV =
  -            Scope.make
  -                (fun p ->
  +            Scope.fast
  +                (new In<_, _> (fun p v ->
                       let flipV = match p.Flip with FlipNone -> false | FlipH -> false | FlipV -> true | FlipHV -> true
  -                    struct (p.Life, flipV))
  -                (fun struct (_, v) p ->
  +                    v <- struct (p.Life, flipV)))
  +                (new Out<_, _> (fun v p ->
                       let flip =
  -                        match (p.Flip, v) with
  +                        match (p.Flip, snd' v) with
                           | (FlipNone, true) -> FlipV
                           | (FlipH, true) -> FlipHV
                           | (FlipV, true) -> FlipV
  
positive.code: 
      [<RequireQualifiedAccess>]
      module BasicParticle =
          let body = Scope.make (fun p -> p.Body) (fun v p -> { p with Body = v })
          let position = Scope.make (fun p -> struct (p.Life, p.Body.Position)) (fun struct (_, v) p -> { p with Body = { p.Body with Position = v }})
          let scale = Scope.make (fun p -> struct (p.Life, p.Body.Scale)) (fun struct (_, v) p -> { p with Body = { p.Body with Scale = v }})
          let angles = Scope.make (fun p -> struct (p.Life, p.Body.Angles)) (fun struct (_, v) p -> { p with Body = { p.Body with Angles = v }})
          let offset = Scope.make (fun p -> struct (p.Life, p.Offset)) (fun struct (_, v) p -> { p with Offset = v })
          let size = Scope.make (fun p -> struct (p.Life, p.Size)) (fun struct (_, v) p -> { p with Size = v })
          let inset = Scope.make (fun p -> struct (p.Life, p.Inset)) (fun struct (_, v) p -> { p with Inset = v })
          let color = Scope.make (fun p -> struct (p.Life, p.Color)) (fun struct (_, v) p -> { p with Color = v })
          let glow = Scope.make (fun p -> struct (p.Life, p.Glow)) (fun struct (_, v) p -> { p with Glow = v })
          let flipH =
              Scope.make
                  (fun p ->
                      let flipH = match p.Flip with FlipNone -> false | FlipH -> true | FlipV -> false | FlipHV -> true
                      struct (p.Life, flipH))
                  (fun struct (_, v) p ->
                      let flip =
                          match (p.Flip, v) with
                          | (FlipNone, true) -> FlipH
                          | (FlipH, true) -> FlipH
                          | (FlipV, true) -> FlipHV
  
negative.code:         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 =
  