anchor.diff:                          let body = &bodies.[i]
                           body.LinearVelocity <- body.LinearVelocity + gravity
                           i <- inc i
  -                    (Output.empty, bodies)
  +                    Output.empty
                   | Attractor (position, radius, force) ->
                       let mutable i = 0
                       while i < dec bodies.Length do
  
positive.code:     [<RequireQualifiedAccess>]
      module Scope =
  
          /// Make a scope with pure in and out lambdas.
          let inline byCopy<'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 in-place in and out delegates.
          let inline byRef<'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
  
negative.code: 
          /// Run the behaviors over targets.
          static member runMany time behaviors constrain (targets : 'a SegmentedArray) =
              let outputs =
                  FStack.fold (fun output (behavior : Behavior) ->
                      output + behavior.RunMany time constrain targets)
                      Output.empty
                      behaviors.Behaviors
              outputs
  
      /// Describes an emitter.
      and [<NoEquality; NoComparison>] EmitterDescriptor<'a when 'a :> Particle and 'a : struct> =
  