* enqueued, enqueuing the commit in a list of pending commits, in latest
  * commit date first order.
  *
- * The algorithm then preceeds to visit each commit in the pending queue.
+ * The algorithm then proceeds to visit each commit in the pending queue.
  * Upon each visit, the pending mass is added to the mass already seen for that
  * commit and then divided into N equal portions, where N is the number of
  * parents of the commit being visited. The divided portions are then injected
 
                                if (!parent_node) {
                                        parent_node = new_mass_counter(parent, &distribution);
-                                       insert_by_date(&pending, parent);
+                                       insert_by_date(parent, &pending);
                                        commit_list_insert(parent, &cleaner);
                                } else {
                                        if (!compare(&parent_node->pending, get_zero()))
-                                               insert_by_date(&pending, parent);
+                                               insert_by_date(parent, &pending);
                                        add(&parent_node->pending, &parent_node->pending, &distribution);
                                }
                        }
                if (*stack || include_last) {
                        if (!*stack) 
                                next->object.flags |= BOUNDARY;
-                       action = (*emitter) (next);
+                       action = emitter(next);
                }
        }
 
                                if (next->object.flags & UNINTERESTING) {
                                        action = STOP;
                                } else {
-                                       action = (*emitter) (next);
+                                       action = emitter(next);
                                }
                                if (action != STOP) {
                                        next = next->parents->item;
        }
 
        if (next && (action != STOP) && !ret) {
-               (*emitter) (next);
+               emitter(next);
        }
 
        return ret;
        int action = CONTINUE;
        struct commit_list *reversed = NULL;
 
-       for (; list; list = list->next) {
-               struct commit *next = list->item;
-
-               if (!(next->object.flags & DUPCHECK)) {
-                       next->object.flags |= DUPCHECK;
-                       commit_list_insert(list->item, &reversed);
-               }
-       }
+       for (; list; list = list->next)
+               commit_list_insert(list->item, &reversed);
 
        if (!reversed)
                return ret;
                while (reversed) {
                        struct commit * next = pop_commit(&reversed);
 
-                       if (!(next->object.flags & VISITED)) {
+                       if (!(next->object.flags & VISITED) && next!=base) {
                                sort_first_epoch(next, &stack);
                                if (reversed) {
                                        /*