anchor.diff:  
           static member (+) (constrain, constrain2) =
               match (constrain, constrain2) with
  -            | (Unconstrained, Unconstrained) -> Unconstrained
  +            | (Unconstrained, Unconstrained) -> constrain // OPTIMIZATION: elide Constraint ctor
               | (_, Unconstrained) -> constrain
               | (Unconstrained, _) -> constrain2
               | (_, _) -> Constraints [|constrain; constrain2|]
  
positive.code: 
      /// The default particle emitter.
      type [<NoEquality; NoComparison>] Emitter<'a when 'a :> Particle and 'a : struct> =
          { Life : Life
            Body : Body
            mutable ParticleIndex : int // operates as a ring-buffer
            Particles : 'a array // operates as a ring-buffer
            Initializer : int64 -> Constraint -> 'a Emitter -> 'a
            Behaviors : Behaviors
            Constraint : Constraint
            Rate : single
            Id : Guid }
  
          static member private computeLiveness time emitter =
              let length = emitter.Particles.Length
              let mutable index = 0
              let mutable result = Dead
              while (match result with Live -> false | Dead -> true) && index < length do
                  let particle = &emitter.Particles.[index]
                  match Life.getLiveness time particle.Life with
                  | Live -> result <- Live
                  | Dead -> index <- inc index
              result
  
          static member private emit time constrain emitter =
              let particleIndex = if emitter.ParticleIndex >= emitter.Particles.Length then 0 else inc emitter.ParticleIndex
  
negative.code:             particle.Life <- { LifeTime = particle.Life.LifeTime; StartTime = time }
              particle <- emitter.Initializer time constrain emitter
  
          static member private getEmitting time emitter =
              match emitter.LifeTimeOpt with
              | Some lifeTime ->
                  let life = { StartTime = emitter.StartTime; LifeTime = lifeTime }
                  Life.getLiveness time life
              | None -> true
  
          /// Determine emitter's liveness.
          static member getLiveness time emitter =
              match emitter.LifeTimeOpt with
              | Some lifeTime ->
                  let life = { StartTime = emitter.StartTime; LifeTime = lifeTime + emitter.ParticleLifeTimeMax }
                  if Life.getLiveness time life then Live else Dead
              | None -> Live
  
          /// Run the emitter.
          static member run time (constrain : Constraint) (emitter : 'a Emitter) =
  
              // determine local time
              let localTime = time - emitter.StartTime
  
              // combine constraints
              let constrain = constrain + emitter.Constraint
  
              // emit new particles if live
              if Emitter<'a>.getEmitting time emitter then
                  let emitCountLastFrame = single (dec localTime) * emitter.Rate
                  let emitCountThisFrame = single localTime * emitter.Rate
                  let emitCount = int emitCountThisFrame - int emitCountLastFrame
                  for _ in 0 .. dec emitCount do Emitter<'a>.emit time constrain emitter
  
              // update existing particles
              let (particles, output) = Behaviors.run time emitter.Behaviors emitter.Particles
              let emitter = { emitter with Particles = particles }
              (emitter, output)
  
          interface Emitter with
              member this.GetLiveness time =
                  Emitter<'a>.getLiveness time this
              member this.Run time constrain =
                  let (emitter, output) = Emitter<'a>.run time constrain this
                  (emitter :> Emitter, output)
              end
  
      /// A particle system.
  