anchor.diff:          // Return the results array.
           results
   
  +#if DEBUG
  +    /// Debugging function to check that a parallel loop completed successfully.
  +    let private checkParallelLoopResult (loopResult : ParallelLoopResult) : unit =
  +        let msg =
  +            let msgBase = "The parallel-for loop did not complete successfully."
  +            let breakIteration = loopResult.LowestBreakIteration
  +            if breakIteration.HasValue then
  +                msgBase + sprintf " The loop was broken at index %i." breakIteration.Value
  +            else msgBase
  +        System.Diagnostics.Debug.Assert (loopResult.IsCompleted, msg)
  +#endif
  +
       /// <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)
  +#if DEBUG
  +        |> tap checkParallelLoopResult
  +#endif
  +        |> 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])
  +#if DEBUG
  +        |> tap checkParallelLoopResult
  +#endif
  +        |> 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]))
  +#if DEBUG
  +        |> tap checkParallelLoopResult
  +#endif
  +        |> 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 _ localMatchCount ->
  +                if predicate array.[idx] then
  +                    localMatchCount + 1
  +                else localMatchCount),
  +            System.Action<_> (fun localMatchCount ->
  +                Interlocked.Add (matchCount, localMatchCount)
  +                |> ignore)
  +            )
  +#if DEBUG
  +        |> tap checkParallelLoopResult
  +#endif
  +        |> ignore
  +
  +        // Return the number of matching elements.
  +        !matchCount
  +
  +    /// <summary>
  +    /// 
  +    /// </summary>
  +    /// <param name="chooser"></param>
  +    /// <param name="array"></param>
  +    /// <returns></returns>
       [<CompiledName("ChooseIndexed")>]
       let choosei (chooser : int -> 'T -> 'U option) (array: 'T[]) : 'U[] =
  +        // Preconditions
           checkNonNull "array" array
   
           // If the input array is empty, immediately return an empty output array.
  
positive.code:                     // determine how the lists compare to each other.
                      ElementIndexComparer.Instance.Compare (x.[count_x - 1], y.[count_y - 1])
  
      //
      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 =
  
negative.code:     open System
      open System.Threading
      open System.Threading.Tasks
  
      /// Sorts key-value pairs with integer keys according to the value of the key.
      [<Sealed>]
  