anchor.diff:          { In : 'a SegmentedArray -> 'b SegmentedArray
             Out : (Output * 'b SegmentedArray) -> 'a SegmentedArray -> (Output * 'a SegmentedArray) }
   
  +    type In<'a, 'b when 'a : struct> =
  +        delegate of 'a byref * 'b byref -> unit
  +
  +    type Out<'a, 'b when 'a : struct> =
  +        delegate of 'b byref * 'a byref -> unit
  +
       [<RequireQualifiedAccess>]
       module Scope =
   
  
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:                         | (FlipH, false) -> FlipNone
                          | (FlipV, false) -> FlipV
                          | (FlipHV, false) -> FlipV
                      p.Flip <- flip))
          let flipV =
              Scope.fast
                  (new In<_, _> (fun p v ->
                      let flipV = match p.Flip with FlipNone -> false | FlipH -> false | FlipV -> true | FlipHV -> true
                      v <- struct (p.Life, flipV)))
                  (new Out<_, _> (fun v p ->
                      let flip =
                          match (p.Flip, snd' v) with
                          | (FlipNone, true) -> FlipV
                          | (FlipH, true) -> FlipHV
                          | (FlipV, true) -> FlipV
  