anchor.diff:      /// The forces that may operate on a target.
       type Forces = single array
   
  +    [<RequireQualifiedAccess>]
  +    module Forces =
  +        
  +        let makeAttractor (position : Vector2) force =
  +            [|position.X; position.Y; force|]
  +
  +        let getAttractorPosition (forces : Forces) =
  +            v2 forces.[0] forces.[1]
  +
  +        let getAttractorForce (forces : Forces) =
  +            forces.[2]
  +
       /// Describes the life of an instance value.
       /// OPTIMIZATION: LifeTimeOpt uses 0L to represent infinite life.
       /// OPTIMIZATION: doesn't use Liveness type to avoid its constructor calls.
  
positive.code: 
          /// Run the behavior over a single target.
          static member run time (constrain : Constraint) (behavior : Behavior<'a, 'b>) (target : 'a) =
              let struct (progress, target2) = behavior.Scope.In time target
              let target3 = behavior.Transformer progress constrain target2
              let struct (target4, output) = behavior.Scope.Out target3 target
              (target4, output)
  
          /// Run the behavior over an array of targets.
          /// OPTIMIZATION: runs transformers in batches for better utilization of instruction cache.
          static member runMany time (constrain : Constraint) (behavior : Behavior<'a, 'b>) (targets : 'a array) =
              let targets2 = Array.map (behavior.Scope.In time) targets
              let targets3 = Array.map (fun struct (progress, field) -> behavior.Transformer progress constrain field) targets2
              let targets4 = Array.map2 behavior.Scope.Out targets3 targets
              let targets5 = Array.map fst' targets4
              let outputs = targets4 |> Array.filter (function struct (_, Outputs [||]) -> false | struct (_, _) -> true) |> Array.map snd'
              let output = match outputs with [||] -> Outputs outputs | [|output|] -> output | outputs -> Outputs outputs
              (targets5, output)
  
          interface Behavior with
              member this.Run time constrain targetObj =
  
negative.code: 
      /// Transforms a constrained value.
      type 'a Transformer =
          int64 -> Constraint -> 'a array -> ('a array * Output)
  
      [<AutoOpen>]
      module Transformer =
  
          /// Pipe two transformers.
          let pipe (transformer : 'a Transformer) (transformer2 : 'a Transformer) : 'a Transformer =
              fun time constrain targets ->
                  let (targets, output) = transformer time constrain targets
                  let (targets, output2) = transformer2 time constrain targets
                  (targets, output + output2)
  
          /// Pipe multiple transformers.
          let pipeMany transformers =
  