diff --git a/GA3/ga3.pdf b/GA3/ga3.pdf
index a186554..e094ee2 100644
Binary files a/GA3/ga3.pdf and b/GA3/ga3.pdf differ
diff --git a/GA3/ga3.tex b/GA3/ga3.tex
index 2fa6e30..b97aa20 100644
--- a/GA3/ga3.tex
+++ b/GA3/ga3.tex
@@ -222,7 +222,8 @@ Delete 12:
 \end{verbatim}
 }
 
-The following printout was obtained by running the following BST implementation.with the following command:
+The following printout was obtained by running the following BST implementation.
+with the following command:
 
 \begin{verbatim}
 ./tree.py 12 6 1 7 4 11 15 9 5 13 8 14 3 10 2 \| 6 2 12
@@ -613,9 +614,9 @@ if __name__ == "__main__":
 \end{lstlisting}
 \subsection{Point B}
 
-A red-black tree of n distinct elements has an height between $\log(n)$ 
-and $2\log(n)$ (as professor Carzaniga said in class) thanks to the red-black 
-tree invariant. The worst-case insertion complexity is $\log(n)$ since 
+A red-black tree of n distinct elements has an height between $\log(n)$
+and $2\log(n)$ (as professor Carzaniga said in class) thanks to the red-black
+tree invariant. The worst-case insertion complexity is $\log(n)$ since
 finding the right place to insert is as complex as
 a regular tree (i.e. logarithmic) and the ``fixup'' operation is logarithmic as
 well (the tree traversal is logarithmic while operations in each iteration are constant).
@@ -628,15 +629,15 @@ since it is a constant factor (since the maximum height is $2\log(n)$ and the mi
 FUNCTION JOIN-INTERVALS(X)
   if X.length == 0:
     return
- 
+
   for i from 1 to X.length:
     if i % 2 == 1:
       X[i] $\gets$ (X[i], 1)
     else:
       X[i] $\gets$ (X[i], -1)
-  
+
   $\textit{sort X in place by 1st tuple element in O(n log(n))}$
-  
+
   c $\gets$ 1
   n $\gets$ 0
   start $\gets$ X[1][1]
@@ -648,17 +649,23 @@ FUNCTION JOIN-INTERVALS(X)
       if i < X.length:
         start $\gets$ X[i+1][1]
       n $\gets$ n + 1
-  X.length $\gets$ 2 * n    
+  X.length $\gets$ 2 * n
 \end{lstlisting}
 %
-The complexity of this algorithm is $O(n\log(n))$ since the sorting is in $\Theta(n\log(n))$ and the
-union operation afterwards is $\Theta(n)$.
+The complexity of this algorithm is $O(n\log(n))$ since the sorting is in
+$\Theta(n\log(n))$ and the union operation afterwards is $\Theta(n)$.
 
 \section{Bonus}
 
-The number of possible trees with $n$ nodes can be defined recursively. The number of trees with 0 or 1 node is clearly 1, since there is no freedom in arranging any remaining elements as children. For $n$ nodes, this number can be defined as the the sum, for each $x, y \in N_0$ s.t. $x + y = n - 1$, of the number of trees with $x$ nodes times the number of trees with $y$ nodes. We consider only $n - 1$ nodes since one node must be the root of the tree. 
-Using math notation, the number $T_n$ of trees with $n$ nodes can be expressed as:
+The number of possible trees with $n$ nodes can be defined recursively. The
+number of trees with 0 or 1 node is clearly 1, since there is no freedom in
+arranging any remaining elements as children. For $n$ nodes, this number can be
+defined as the the sum, for each $x, y \in N_0$ s.t. $x + y = n - 1$, of the
+number of trees with $x$ nodes times the number of trees with $y$ nodes. We
+consider only $n - 1$ nodes since one node must be the root of the tree.
+Using math notation, the number $T_n$ of trees with $n$ nodes can be expressed
+as:
 
 $$T_n = 1 \hspace{1cm} n = 0 \lor n = 1$$
-$$T_n = \sum_{i = 0}^{n-1} C_i C_{n-1-i} \hspace{1cm} n \geq 2$$
-\end{document}
\ No newline at end of file
+$$T_n = \sum_{i = 0}^{n-1} T_i T_{n-1-i} \hspace{1cm} n \geq 2$$
+\end{document}