anchor.diff:      open System
       open System.Threading
       open System.Threading.Tasks
  -
  -    /// <summary>
  -    /// 
  -    /// </summary>
  -    /// <param name="length"></param>
  -    /// <param name="generator"></param>
  -    /// <returns></returns>
  -    [<CompiledName("Initialize2")>]
  -    let init2 length (generator : int -> 'T1 * 'T2) : 'T1[] * 'T2[] =
  -        // Preconditions
  -        if length < 0 then
  -            invalidArg "length" "The length of the array to initialize cannot be negative."
  -
  -        let array1 = Array.zeroCreate length
  -        let array2 = Array.zeroCreate length
  -
  -        // Create each of the array elements using the generator function.
  -        // TODO : Instead of ignoring the result, keep it and check the IsCompleted property to
  -        //        ensure the loop completed as expected; if it didn't, raise an exception instead
  -        //        of returning a partially-initialized result.
  -        Parallel.For (0, length, fun i ->
  -            let x, y = generator i
  -            array1.[i] <- x
  -            array2.[i] <- y)
  -        |> ignore
  -
  -        // Return the initialized arrays.
  -        array1, array2
  -
  -    /// <summary></summary>
  -    /// <param name="mapping"></param>
  -    /// <param name="array"></param>
  -    /// <returns></returns>
  -    [<CompiledName("MapInPlace")>]
  -    let mapInPlace (mapping : 'T -> 'T) (array : 'T[]) : unit =
  -        // Preconditions
  -        checkNonNull "array" array
  -
  -        Parallel.For (0, array.Length, fun i ->
  -            array.[i] <- mapping array.[i])
  -        |> ignore
  -
  -    /// <summary></summary>
  -    /// <param name="mapping"></param>
  -    /// <param name="array"></param>
  -    /// <returns></returns>
  -    [<CompiledName("MapIndexedInPlace")>]
  -    let mapiInPlace (mapping : int -> 'T -> 'T) (array : 'T[]) : unit =
  -        // Preconditions
  -        checkNonNull "array" array
  -
  -        let mapping = FSharpFunc<_,_,_>.Adapt mapping
  -
  -        Parallel.For (0, array.Length, fun i ->
  -            array.[i] <- mapping.Invoke (i, array.[i]))
  -        |> ignore
  -
  -    /// <summary></summary>
  -    /// <param name="predicate"></param>
  -    /// <param name="array"></param>
  -    /// <returns></returns>
  -    [<CompiledName("CountWith")>]
  -    let countWith (predicate : 'T -> bool) (array : 'T[]) : int =
  -        // Preconditions
  -        checkNonNull "array" array
  -
  -        let matchCount = ref 0
  -
  -        Parallel.For (0, array.Length,
  -            System.Func<_> (fun _ -> 0),
  -            System.Func<_,_,_,_> (fun idx loopState localMatchCount ->
  -                if predicate array.[idx] then
  -                    localMatchCount + 1
  -                else localMatchCount),
  -            System.Action<_> (fun localMatchCount ->
  -                Interlocked.Add (matchCount, localMatchCount)
  -                |> ignore)
  -            ) |> ignore
  -
  -        // Return the number of matching elements.
  -        !matchCount
   
       /// Sorts key-value pairs with integer keys according to the value of the key.
       [<Sealed>]
  
positive.code:         // Return the results array.
          results
  
      /// <summary>
      /// 
      /// </summary>
      [<CompiledName("ChooseIndexed")>]
      let choosei (chooser : int -> 'T -> 'U option) (array: 'T[]) : 'U[] =
          checkNonNull "array" array
  
          // If the input array is empty, immediately return an empty output array.
  
negative.code:                     // determine how the lists compare to each other.
                      ElementIndexComparer.Instance.Compare (x.[count_x - 1], y.[count_y - 1])
  
      /// <summary>
      /// Combines the results of individual workers (e.g., threads, tasks), according to the ordering
      /// of elements in the original input array.
      /// </summary>
      /// <param name="workerResults"></param>
      /// <returns></returns>
      let internal combineWorkerResults (workerResults : ResizeArray<ResizeArray<KeyValuePair<int, 'T>>>) : 'T[] =
          /// The total number of chosen values (i.e., the length of the results array).
          let chosenValueCount =
  