\section{Daikon Invariants Frequency Tables}
\begin{table}[ht]
\centering
\scriptsize
\caption{Invariants for avl\_tree, 11 public methods.}
\label{avl_tree_daikon}
\begin{tabular}{|l|c|}
\hline
Invariant & Count \\
\hline
this->root has only one value & 4 \\
this->root.\_M\_t has only one value & 4 \\
this->root.\_M\_t.\_\_uniq\_ptr\_impl<AvlTree::Node, std::default\_delete<AvlTree::Node> >.\_M\_t has only one value & 4 \\
this[0] has only one value & 3 \\
this->n one of \{ 3, 4 \} & 3 \\
this[0] != null & 2 \\
this->root != null & 2 \\
this->root.\_M\_t != null & 2 \\
this->root.\_M\_t.\_\_uniq\_ptr\_impl<AvlTree::Node, std::default\_delete<AvlTree::Node> >.\_M\_t != null & 2 \\
this->n one of \{ 1, 2, 3 \} & 1 \\
this->n one of \{ 0, 3 \} & 1 \\
this->n >= 1 & 1 \\
this->n == 3 & 1 \\
t.root has only one value & 1 \\
t.root.\_M\_t has only one value & 1 \\
t.root.\_M\_t.\_\_uniq\_ptr\_impl<AvlTree::Node, std::default\_delete<AvlTree::Node> >.\_M\_t has only one value & 1 \\
t.n == 3 & 1 \\
this->n == return & 1 \\
\hline
\end{tabular}
\end{table}

\begin{table}[ht]
\centering
\scriptsize
\caption{Invariants for red\_black\_tree, 11 public methods.}
\label{red_black_tree_daikon}
\begin{tabular}{|l|c|}
\hline
Invariant & Count \\
\hline
this[0] != null & 3 \\
this->root != null & 3 \\
this->root.\_M\_t != null & 3 \\
this->root.\_M\_t.\_\_uniq\_ptr\_impl<RedBlackTree::Node, std::default\_delete<RedBlackTree::Node> >.\_M\_t != null & 3 \\
this->n one of \{ 3, 4, 6 \} & 3 \\
this->root has only one value & 3 \\
this->root.\_M\_t has only one value & 3 \\
this->root.\_M\_t.\_\_uniq\_ptr\_impl<RedBlackTree::Node, std::default\_delete<RedBlackTree::Node> >.\_M\_t has only one value & 3 \\
this[0] has only one value & 2 \\
this->n >= 0 & 1 \\
(No intersection exists) & 1 \\
t.root has only one value & 1 \\
t.root.\_M\_t has only one value & 1 \\
t.root.\_M\_t.\_\_uniq\_ptr\_impl<RedBlackTree::Node, std::default\_delete<RedBlackTree::Node> >.\_M\_t has only one value & 1 \\
t.n == 3 & 1 \\
No intersection & 1 \\
\hline
\end{tabular}
\end{table}

\begin{table}[ht]
\centering
\scriptsize
\caption{Invariants for linked\_list, 8 public methods.}
\label{linked_list_daikon}
\begin{tabular}{|l|c|}
\hline
Invariant & Count \\
\hline
this[0] has only one value & 5 \\
this->head has only one value & 5 \\
this->head.\_M\_t has only one value & 5 \\
this->head.\_M\_t.\_\_uniq\_ptr\_impl<LinkedList::Node, std::default\_delete<LinkedList::Node> >.\_M\_t has only one value & 5 \\
this[0] != null & 4 \\
this->head != null & 4 \\
this->head.\_M\_t != null & 4 \\
this->head.\_M\_t.\_\_uniq\_ptr\_impl<LinkedList::Node, std::default\_delete<LinkedList::Node> >.\_M\_t != null & 4 \\
this->tail[] elements != null & 2 \\
this->tail[].next elements != null & 2 \\
this->tail[].next.\_M\_t elements != null & 2 \\
this->n >= 0 & 2 \\
this->n == 0 & 1 \\
this->tail[].data elements one of \{ 1 \} & 1 \\
this->tail[].data one of \{ [1] \} & 1 \\
this->n one of \{ 1 \} & 1 \\
this->n one of \{ 1, 2 \} & 1 \\
this->tail[].data elements >= 1 & 1 \\
this->tail[].data elements <= this->n & 1 \\
this->tail[].data elements one of \{ 1, 2, 4 \} & 1 \\
this->tail[].data one of \{ [1], [2], [4] \} & 1 \\
this->n one of \{ 2, 3 \} & 1 \\
this->tail[].data == [3] & 1 \\
this->tail[].data elements == 3 & 1 \\
\hline
\end{tabular}
\end{table}

\begin{table}[ht]
\centering
\scriptsize
\caption{Invariants for binary\_search\_tree, 11 public methods.}
\label{binary_search_tree_daikon}
\begin{tabular}{|l|c|}
\hline
Invariant & Count \\
\hline
this->root has only one value & 4 \\
this->root.\_M\_t has only one value & 4 \\
this->root.\_M\_t.\_\_uniq\_ptr\_impl<BinarySearchTree::Node, std::default\_delete<BinarySearchTree::Node> >.\_M\_t has only one value & 4 \\
this->n one of \{ 0, 2, 3 \} & 3 \\
this->n one of \{ 0, 3 \} & 3 \\
this[0] has only one value & 3 \\
this[0] != null & 2 \\
this->root != null & 2 \\
this->root.\_M\_t != null & 2 \\
this->root.\_M\_t.\_\_uniq\_ptr\_impl<BinarySearchTree::Node, std::default\_delete<BinarySearchTree::Node> >.\_M\_t != null & 2 \\
t.root has only one value & 1 \\
t.root.\_M\_t has only one value & 1 \\
t.root.\_M\_t.\_\_uniq\_ptr\_impl<BinarySearchTree::Node, std::default\_delete<BinarySearchTree::Node> >.\_M\_t has only one value & 1 \\
t.n == 3 & 1 \\
(this->n == return) == (return == orig(this->n)) & 1 \\
\hline
\end{tabular}
\end{table}

\begin{table}[ht]
\centering
\scriptsize
\caption{Invariants for heap, 7 public methods.}
\label{heap_daikon}
\begin{tabular}{|l|c|}
\hline
Invariant & Count \\
\hline
this->comp.\_M\_invoker has only one value & 7 \\
this->comp.\_Function\_base.\_M\_manager has only one value & 7 \\
this[0] has only one value & 6 \\
this->data has only one value & 6 \\
this->data.\_Vector\_base<int, std::allocator<int> >.\_M\_impl has only one value & 6 \\
this->comp has only one value & 6 \\
this->comp.\_Function\_base.\_M\_functor has only one value & 6 \\
this->comp.\_Function\_base.\_M\_functor.\_M\_unused has only one value & 6 \\
this[0] != null & 3 \\
this->data != null & 3 \\
this->data.\_Vector\_base<int, std::allocator<int> >.\_M\_impl != null & 3 \\
this->comp != null & 3 \\
this->comp.\_M\_invoker != null & 3 \\
this->comp.\_Function\_base.\_M\_functor != null & 3 \\
this->comp.\_Function\_base.\_M\_functor.\_M\_unused != null & 3 \\
this->comp.\_Function\_base.\_M\_manager != null & 3 \\
this->data.\_Vector\_base<int, std::allocator<int> >.\_M\_impl.\_Vector\_impl\_data.\_M\_start[] elements >= 1 & 2 \\
this->data.\_Vector\_base<int, std::allocator<int> >.\_M\_impl.\_Vector\_impl\_data.\_M\_start != null & 1 \\
this->data.\_Vector\_base<int, std::allocator<int> >.\_M\_impl.\_Vector\_impl\_data.\_M\_finish != null & 1 \\
this->data.\_Vector\_base<int, std::allocator<int> >.\_M\_impl.\_Vector\_impl\_data.\_M\_end\_of\_storage != null & 1 \\
\hline
\end{tabular}
\end{table}

\begin{table}[ht]
\centering
\scriptsize
\caption{Invariants for hash\_table, 7 public methods.}
\label{hash_table_daikon}
\begin{tabular}{|l|c|}
\hline
Invariant & Count \\
\hline
::\_\_digits == "000102...6979899" & 3 \\
::\_\_tag == "" & 3 \\
this[0] has only one value & 3 \\
this->hash\_function has only one value & 3 \\
this->hash\_function.\_Function\_base.\_M\_functor has only one value & 3 \\
this->hash\_function.\_Function\_base.\_M\_functor.\_M\_unused has only one value & 3 \\
this->hash\_function.\_Function\_base.\_M\_functor.\_M\_pod\_data == "" & 3 \\
this->load\_factor == 0.75 & 3 \\
this->table has only one value & 3 \\
this->table.\_Vector\_base<... >.\_M\_impl has only one value & 2 \\
this->table.\_Vector\_base<... >.\_M\_impl has only one value & 1 \\
this->\_num\_elements one of \{ 0, 1 \} & 1 \\
this->\_size == 10 & 1 \\
this->table.\_Vector\_base<... > > > > >.\_M\_impl.\_Vector\_impl\_data.\_M\_end\_of\_storage & 1 \\
key.\_M\_dataplus has only one value & 1 \\
key.\_M\_dataplus.\_M\_p one of \{ "key1", "key2" \} & 1 \\
key.\_M\_string\_length == 4 & 1 \\
this->\_num\_elements >= 0 & 1 \\
this->\_size >= 0 & 1 \\
this->\_num\_elements <= this->\_size & 1 \\
\hline
\end{tabular}
\end{table}

\begin{table}[ht]
\centering
\scriptsize
\caption{Invariants for vector, 11 public methods. }
\label{vector_daikon}
\begin{tabular}{|l|c|}
\hline
Invariant & Count \\
\hline
this[0] has only one value & 9 \\
this->capacity == 5 & 7 \\
this->data has only one value & 5 \\
this->data[] elements one of \{ 1, 2 \} & 5 \\
this->n == 2 & 4 \\
this->data[] == [1, 2] & 4 \\
this->n in this->data[] & 4 \\
this->data[] == [1] & 3 \\
this->n == 0 & 2 \\
this->n one of \{ 1 \} & 2 \\
this->n in return[] & 1 \\
return[] == [1, 2] & 1 \\
return[] elements one of \{ 1, 2 \} & 1 \\
this->capacity == 0 & 1 \\
this->data == null & 1 \\
this->n == 1 & 1 \\
this->n == v.n & 1 \\
this->capacity == v.capacity & 1 \\
v.data has only one value & 1 \\
v one of \{ 1, 2 \} & 1 \\
this->capacity one of \{ 5 \} & 1 \\
this->data[] sorted by < & 1 \\
this->n <= this->capacity & 1 \\
this->n < this->capacity & 1 \\
this->n one of \{ 2, 5 \} & 1 \\
this->data[] elements == 1 & 1 \\
this->data[] one of \{ [1], [1, 2] \} & 1 \\
return one of \{ 1, 2 \} & 1 \\
\hline
\end{tabular}
\end{table}

\begin{table}[ht]
\centering
\scriptsize
\caption{Invariants for queue, 7 public methods.}
\label{queue_daikon}
\begin{tabular}{|l|c|}
\hline
Invariant & Count \\
\hline
this->data has only one value & 5 \\
this->maxSize == 10 & 5 \\
this[0] has only one value & 4 \\
this->data[] == [10, 20, 30] & 2 \\
this->data[] elements one of \{ 10, 20, 30 \} & 2 \\
this->head one of \{ 0, 1 \} & 2 \\
this->tail == 3 & 2 \\
this->n one of \{ 2, 3 \} & 2 \\
this->maxSize in this->data[] & 2 \\
this[0] != null & 2 \\
this->data != null & 2 \\
this->data[] elements >= 0 & 2 \\
this->data[] sorted by < & 2 \\
this->head < this->maxSize & 2 \\
this->tail < this->maxSize & 2 \\
this->data[] elements one of \{ 1, 2 \} & 2 \\
this->data[] one of \{ [1], [1, 2] \} & 2 \\
this->tail one of \{ 0, 1, 2 \} & 2 \\
this->tail in this->data[] & 2 \\
this->head - this->tail + this->n == 0 & 1 \\
this->tail one of \{ 2, 3, 100 \} & 1 \\
this->maxSize one of \{ 10, 160 \} & 1 \\
this->n < this->maxSize & 1 \\
this->head one of \{ 0, 50 \} & 1 \\
this->tail >= 0 & 1 \\
this->n <= this->maxSize & 1 \\
this->head <= this->tail & 1 \\
this->head one of \{ 0, 2 \} & 1 \\
this->n one of \{ 0, 1 \} & 1 \\
this->head == other.head & 1 \\
this->maxSize == other.maxSize & 1 \\
this->data[] == [7, 14] & 1 \\
this->data[] elements one of \{ 7, 14 \} & 1 \\
this->head == 0 & 1 \\
other.data has only one value & 1 \\
other.tail == 2 & 1 \\
this->head one of \{ 0, 1, 2 \} & 1 \\
this->head - this->tail + return == 0 & 1 \\
return one of \{ 0, 1, 2 \} & 1 \\
\hline
\end{tabular}
\end{table}

\begin{table}[ht]
\centering
\scriptsize
\caption{Invariants for stack, 6 public methods.}
\label{stack_daikon}
\begin{tabular}{|l|c|}
\hline
Invariant & Count \\
\hline
this->maxSize one of \{ 10, 160, 1280 \} & 4 \\
this->data[] sorted by < & 4 \\
this->data[] elements < this->maxSize & 4 \\
this->n < this->maxSize & 3 \\
this[0] != null & 3 \\
this->data != null & 3 \\
this[0] has only one value & 2 \\
this->data[] elements >= 0 & 2 \\
this->n one of \{ 0, 1, 2 \} & 1 \\
this->maxSize == other.maxSize & 1 \\
this has only one value & 1 \\
this->data has only one value & 1 \\
this->n == 2 & 1 \\
this->maxSize == 10 & 1 \\
other.data has only one value & 1 \\
other.data[] == [1, 2] & 1 \\
other.data[] elements one of \{ 1, 2 \} & 1 \\
this->n <= this->maxSize & 1 \\
\hline
\end{tabular}
\end{table}

