merge

 public void threaded_merge_sort(int[] getallen, int p, int r, int depthRemaining)
{
    if (p < r)
    {
                int q = (p + r) / 2;

                if (depthRemaining > 0)
                {
                    Parallel.Invoke(
                        () => threaded_merge_sort(getallen, p, q, depthRemaining-1)/*,
                        () => threaded_merge_sort(getallen, q + 1, r, depthRemaining-1)*/);
                    threaded_merge_sort(getallen, q + 1, r, 0);
                }
                else
                {
                    threaded_merge_sort(getallen, p, q, 0);
                    threaded_merge_sort(getallen, q+1, r, 0);
                }

                merge(getallen, p, q, r);
    }
}

public void merge(int[] getallen, int p, int q, int r)
{
            int n1 = q - p + 1;
            int n2 = r - q;
            int[] left = new int[n1];
            int[] right = new int[n2];

            for (int i = 0; i < n1; i++)
                left[i] = getallen[p + i];
            for (int i = 0; i < n2; i++)
                right[i] = getallen[q + 1 + i];

            int leftCounter = 0;
            int rightCounter = 0;

            for (int k = p; k <= r; k++)
            {
                if (left.Length > leftCounter && right.Length > rightCounter)
                {
                    if (left[leftCounter] <= right[rightCounter])
                        getallen[k] = left[leftCounter++];
                    else
                        getallen[k] = right[rightCounter++];
                }

                else if (left.Length > leftCounter)
                    getallen[k] = left[leftCounter++];
                else if (right.Length > rightCounter)
                    getallen[k] = right[rightCounter++];
            }
        }