anchor.diff:      state
   
   //
  +[<CompiledName("FoldIndexed")>]
  +let foldi (folder : int -> 'State -> 'T -> 'State) state (resizeArray : ResizeArray<'T>) =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    let folder = FSharpFunc<_,_,_,_>.Adapt folder
  +
  +    let mutable state = state
  +    let count = resizeArray.Count
  +    for i = 0 to count - 1 do
  +        state <- folder.Invoke (i, state, resizeArray.[i])
  +    state
  +
  +//
  +[<CompiledName("Fold2")>]
  +let fold2 folder (state : 'State)
  +    (resizeArray1 : ResizeArray<'T1>) (resizeArray2 : ResizeArray<'T2>) : 'State =
  +    // Preconditions
  +    checkNonNull "resizeArray1" resizeArray1
  +    checkNonNull "resizeArray2" resizeArray2
  +
  +    let len = length resizeArray1
  +    if len <> length resizeArray2 then
  +        invalidArg "resizeArray2" "The arrays have different lengths."
  +
  +    let folder = FSharpFunc<_,_,_,_>.Adapt folder
  +    let mutable state = state
  +    for i = 0 to len - 1 do
  +        state <- folder.Invoke (state, resizeArray1.[i], resizeArray2.[i])
  +    state
  +
  +//
  +[<CompiledName("FoldBack")>]
  +let foldBack (folder : 'T -> 'State -> 'State) (resizeArray : ResizeArray<'T>) state =
  +    // Preconditions
  +    checkNonNull "resizeArray" resizeArray
  +
  +    let folder = FSharpFunc<_,_,_>.Adapt folder
  +
  +    let mutable state = state
  +    for i = resizeArray.Count - 1 downto 0 do
  +        state <- folder.Invoke (resizeArray.[i], state)
  +    state
  +
  +//
   [<CompiledName("FoldBackSub")>]
   let foldBackSub folder (resizeArray : ResizeArray<'T>) startIndex endIndex (state : 'State) : 'State =
       // Preconditions
  
positive.code:     results1, results2
  
  //
  [<CompiledName("Partition")>]
  let partition predicate (resizeArray : ResizeArray<'T>) : ResizeArray<'T> * ResizeArray<'T> =
      // Preconditions
      checkNonNull "resizeArray" resizeArray
  
      let trueResults = ResizeArray ()
      let falseResults = ResizeArray ()
  
      let len = length resizeArray
      for i = 0 to len - 1 do
          let el = resizeArray.[i]
          if predicate el then
              trueResults.Add el
          else
              falseResults.Add el
  
      trueResults, falseResults
  
  //
  [<CompiledName("Fold2")>]
  let fold2 folder (state : 'State)
      (resizeArray1 : ResizeArray<'T1>) (resizeArray2 : ResizeArray<'T2>) : 'State =
      // Preconditions
      checkNonNull "resizeArray1" resizeArray1
      checkNonNull "resizeArray2" resizeArray2
  
      let len = length resizeArray1
      if len <> length resizeArray2 then
          invalidArg "resizeArray2" "The arrays have different lengths."
  
      let folder = FSharpFunc<_,_,_,_>.Adapt folder
      let mutable state = state
      for i = 0 to len - 1 do
          state <- folder.Invoke (state, resizeArray1.[i], resizeArray2.[i])
      state
  
  //
  [<CompiledName("FoldBack2")>]
  let foldBack2 folder (resizeArray1 : ResizeArray<'T1>)
      (resizeArray2 : ResizeArray<'T2>) (state : 'State) : 'State =
      // Preconditions
      checkNonNull "resizeArray1" resizeArray1
      checkNonNull "resizeArray2" resizeArray2
  
      let len = length resizeArray1
      if len <> length resizeArray2 then
          invalidArg "resizeArray2" "The arrays have different lengths."
  
      let folder = FSharpFunc<_,_,_,_>.Adapt folder
      let mutable state = state
      for i = len - 1 downto 0 do
          state <- folder.Invoke (resizeArray1.[i], resizeArray2.[i], state)
      state
  
  //
  
negative.code:     state
  
  //
  [<CompiledName("FoldBackIndexed")>]
  let foldiBack (folder : int -> 'T -> 'State -> 'State) (resizeArray : ResizeArray<'T>) state =
      // Preconditions
      checkNonNull "resizeArray" resizeArray
  
      let folder = FSharpFunc<_,_,_,_>.Adapt folder
  
      let mutable state = state
      for i = resizeArray.Count - 1 downto 0 do
          state <- folder.Invoke (i, resizeArray.[i], state)
      state
  
  //
  [<CompiledName("FoldBack2")>]
  let foldBack2 folder (resizeArray1 : ResizeArray<'T1>)
      (resizeArray2 : ResizeArray<'T2>) (state : 'State) : 'State =
      // Preconditions
      checkNonNull "resizeArray1" resizeArray1
      checkNonNull "resizeArray2" resizeArray2
  
      let len = length resizeArray1
      if len <> length resizeArray2 then
          invalidArg "resizeArray2" "The arrays have different lengths."
  
      let folder = FSharpFunc<_,_,_,_>.Adapt folder
      let mutable state = state
      for i = len - 1 downto 0 do
          state <- folder.Invoke (resizeArray1.[i], resizeArray2.[i], state)
      state
  
  //
  [<CompiledName("Reduce")>]
  let reduce (reduction : 'T -> 'T -> 'T) (resizeArray : ResizeArray<'T>) =
      // Preconditions
      checkNonNull "resizeArray" resizeArray
      if isEmpty resizeArray then
          invalidArg "resizeArray" "The ResizeArray is empty."
  
      let reduction = FSharpFunc<_,_,_>.Adapt reduction
  
      let mutable state = resizeArray.[0]
      let count = resizeArray.Count
      for i = 1 to count - 1 do
          state <- reduction.Invoke (state, resizeArray.[i])
      state
  
  //
  [<CompiledName("ReduceBack")>]
  let reduceBack (reduction : 'T -> 'T -> 'T) (resizeArray : ResizeArray<'T>) : 'T =
      // Preconditions
      checkNonNull "resizeArray" resizeArray
      if isEmpty resizeArray then
          invalidArg "resizeArray" "The ResizeArray is empty."
  
      let reduction = FSharpFunc<_,_,_>.Adapt reduction
  
      let count = resizeArray.Count
      let mutable state = resizeArray.[count - 1]
  
      for i = count - 2 downto 0 do
          state <- reduction.Invoke (resizeArray.[i], state)
      state
  
  //
  [<CompiledName("ScanSub")>]
  let scanSub folder (state : 'State) (resizeArray : ResizeArray<'T>) startIndex endIndex : ResizeArray<'State> =
      // Preconditions
  