CAndRyan
diff --git a/‎xml/System.Collections.Generic/List`1.xml
Lines changed: 4 additions & 4 deletions b/‎xml/System.Collections.Generic/List`1.xml
Lines changed: 4 additions & 4 deletions
diff --git a/‎xml/System/Array.xml
Lines changed: 17 additions & 17 deletions b/‎xml/System/Array.xml
Lines changed: 17 additions & 17 deletions
@@ -3671,7 +3671,7 @@ Public Function StartsWith(e As Employee) As Boolean
   
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
   
- On average, this method is an O(*n* log *n*) operation, where *n* is <xref:System.Collections.Generic.List%601.Count%2A>; in the worst case it is an O(*n*<sup>2</sup>) operation.  
+ This method is an O(*n* log *n*) operation, where *n* is <xref:System.Collections.Generic.List%601.Count%2A>.  
   
    
   
@@ -3756,7 +3756,7 @@ Public Function StartsWith(e As Employee) As Boolean
   
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
   
- On average, this method is an O(*n* log *n*) operation, where *n* is <xref:System.Collections.Generic.List%601.Count%2A>; in the worst case it is an O(*n*<sup>2</sup>) operation.  
+ This method is an O(*n* log *n*) operation, where *n* is <xref:System.Collections.Generic.List%601.Count%2A>.  
   
    
   
@@ -3836,7 +3836,7 @@ Public Function StartsWith(e As Employee) As Boolean
   
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
   
- On average, this method is an O(*n* log *n*) operation, where *n* is <xref:System.Collections.Generic.List%601.Count%2A>; in the worst case it is an O(*n*<sup>2</sup>) operation.  
+ This method is an O(*n* log *n*) operation, where *n* is <xref:System.Collections.Generic.List%601.Count%2A>.  
   
    
   
@@ -3924,7 +3924,7 @@ Public Function StartsWith(e As Employee) As Boolean
   
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
   
- On average, this method is an O(*n* log *n*) operation, where *n* is <xref:System.Collections.Generic.List%601.Count%2A>; in the worst case it is an O(*n*<sup>2</sup>) operation.  
+ This method is an O(*n* log *n*) operation, where *n* is <xref:System.Collections.Generic.List%601.Count%2A>.  
   
    
   
 
@@ -7405,7 +7405,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `array`.  
+ This method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `array`.  
 
 
 
@@ -7499,7 +7499,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `keys`.  
+ This method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `keys`.  
 
 
 
@@ -7597,7 +7597,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `array`.  
+ This method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `array`.  
 
  The .NET Framework includes predefined <xref:System.Collections.IComparer> implementations listed in the following table.  
 
@@ -7725,7 +7725,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `keys`.  
+ This method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `keys`.  
 
 
 
@@ -7829,7 +7829,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is `length`.  
+ This method is an O(`n` log `n`) operation, where `n` is `length`.  
 
 
 
@@ -7935,7 +7935,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is `length`.  
+ This method is an O(`n` log `n`) operation, where `n` is `length`.  
 
 
 
@@ -8061,7 +8061,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is `length`.  
+ This method is an O(`n` log `n`) operation, where `n` is `length`.  
 
 
 
@@ -8196,7 +8196,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is `length`.  
+ This method is an O(`n` log `n`) operation, where `n` is `length`.  
 
 
 
@@ -8317,7 +8317,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `array`.  
+ This method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `array`.  
 
 
 
@@ -8413,7 +8413,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `array`.  
+ This method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `array`.  
 
 
 
@@ -8510,7 +8510,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `array`.  
+ This method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `array`.  
 
 
 
@@ -8612,7 +8612,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is `length`.  
+ This method is an O(`n` log `n`) operation, where `n` is `length`.  
 
 
 
@@ -8723,7 +8723,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is `length`.  
+ This method is an O(`n` log `n`) operation, where `n` is `length`.  
 
 
 
@@ -8840,7 +8840,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `array`.  
+ This method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `array`.  
 
 
 
@@ -8957,7 +8957,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `array`.  
+ This method is an O(`n` log `n`) operation, where `n` is the <xref:System.Array.Length%2A> of `array`.  
 
 
 
@@ -9084,7 +9084,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is `length`.  
+ This method is an O(`n` log `n`) operation, where `n` is `length`.  
 
 
 
@@ -9221,7 +9221,7 @@ int[,,] TDArray = new int[1,1,1];
 
  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.  
 
- For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(`n` log `n`) operation, where `n` is `length`.  
+ This method is an O(`n` log `n`) operation, where `n` is `length`.