anchor.diff:                              let pullForce = pull * force
                               body.LinearVelocity <- body.LinearVelocity + pullForce * normal
                           i <- inc i
  -                    (Output.empty, bodies)
  +                    Output.empty
                   | Drag (linearDrag, angularDrag) ->
  -                    let bodies =
  -                        SegmentedArray.transform (fun (body : Body) ->
  -                            let linearDrag = body.LinearVelocity * linearDrag
  -                            let angularDrag = body.AngularVelocity * angularDrag
  -                            { body with
  -                                LinearVelocity = body.LinearVelocity - linearDrag
  -                                AngularVelocity = body.AngularVelocity - angularDrag })
  -                            bodies
  -                    (Output.empty, bodies)
  +                    let mutable i = 0
  +                    while i < dec bodies.Length do
  +                        let body = &bodies.[i]
  +                        let linearDrag = body.LinearVelocity * linearDrag
  +                        let angularDrag = body.AngularVelocity * angularDrag
  +                        body.LinearVelocity <- body.LinearVelocity - linearDrag
  +                        body.AngularVelocity <- body.AngularVelocity - angularDrag
  +                        i <- inc i
  +                    Output.empty
                   | Velocity c2 ->
                       let c3 = c + c2
  -                    let bodies = constrain c3 bodies
  -                    let bodies = accelerate bodies
  -                    (Output.empty, bodies)
  +                    constrain c3 bodies
  +                    accelerate bodies
  +                    Output.empty
   
           /// Make a logic transformer.
           let logic logic : struct (Life * bool) Transformer =
               match logic.LogicType with
               | Or value ->
                   fun _ _ targets ->
  -                    let targets = SegmentedArray.transform (fun struct (targetLife, targetValue) -> struct (targetLife, targetValue || value)) targets
  -                    (Output.empty, targets)
  +                    let mutable i = 0
  +                    while i < dec targets.Length do
  +                        let v = &targets.[i]
  +                        let struct (targetLife, targetValue) = v
  +                        targets.[i] <- struct (targetLife, targetValue || value)
  +                        i <- inc i
  +                    Output.empty
               | Nor value ->
                   fun _ _ targets ->
  -                    let targets = SegmentedArray.transform (fun struct (targetLife, targetValue) -> struct (targetLife, not targetValue && not value)) targets
  -                    (Output.empty, targets)
  +                    let mutable i = 0
  +                    while i < dec targets.Length do
  +                        let v = &targets.[i]
  +                        let struct (targetLife, targetValue) = v
  +                        targets.[i] <- struct (targetLife, not targetValue && not value)
  +                        i <- inc i
  +                    Output.empty
               | Xor value ->
                   fun _ _ targets ->
  -                    let targets = SegmentedArray.transform (fun struct (targetLife, targetValue) -> struct (targetLife, targetValue <> value)) targets
  -                    (Output.empty, targets)
  +                    let mutable i = 0
  +                    while i < dec targets.Length do
  +                        let v = &targets.[i]
  +                        let struct (targetLife, targetValue) = v
  +                        targets.[i] <- struct (targetLife, targetValue <> value)
  +                        i <- inc i
  +                    Output.empty
               | And value ->
                   fun _ _ targets ->
  -                    let targets = SegmentedArray.transform (fun struct (targetLife, targetValue) -> struct (targetLife, targetValue && value)) targets
  -                    (Output.empty, targets)
  +                    let mutable i = 0
  +                    while i < dec targets.Length do
  +                        let v = &targets.[i]
  +                        let struct (targetLife, targetValue) = v
  +                        targets.[i] <- struct (targetLife, targetValue && value)
  +                        i <- inc i
  +                    Output.empty
               | Nand value ->
                   fun _ _ targets ->
  -                    let targets = SegmentedArray.transform (fun struct (targetLife, targetValue) -> struct (targetLife, not (targetValue && value))) targets
  -                    (Output.empty, targets)
  +                    let mutable i = 0
  +                    while i < dec targets.Length do
  +                        let v = &targets.[i]
  +                        let struct (targetLife, targetValue) = v
  +                        targets.[i] <- struct (targetLife, not (targetValue && value))
  +                        i <- inc i
  +                    Output.empty
               | Equal value ->
                   fun _ _ targets ->
  -                    let targets = SegmentedArray.transform (fun struct (targetLife, _) -> struct (targetLife, value)) targets
  -                    (Output.empty, targets)
  +                    let mutable i = 0
  +                    while i < dec targets.Length do
  +                        let v = &targets.[i]
  +                        let struct (targetLife, _) = v
  +                        targets.[i] <- struct (targetLife, value)
  +                        i <- inc i
  +                    Output.empty
   
           /// Make a generic range transformer.
           let inline rangeSrtp mul div (scale : (^a * single) -> ^a) time (range : ^a Range) : struct (Life * ^a) Transformer =
  
positive.code:                 body.Position <- body.Position + body.LinearVelocity
                  body.Angles <- body.Angles + body.AngularVelocity
                  i <- inc i
              bodies
  
          /// Constrain bodies.
          let rec constrain c (bodies : Body SegmentedArray) =
  
negative.code:                 let (outputs, target) = Behavior<'a, 'b>.run time constrain this (targetObj :?> 'a)
                  (outputs, target :> obj)
              member this.RunMany time constrain targetsObj =
                  Behavior<'a, 'b>.runMany time constrain this (targetsObj :?> 'a SegmentedArray)
  
      /// A composition of behaviors.
      type [<NoEquality; NoComparison>] Behaviors =
  