RhodeCode

      nodes[id].right = nodes[jd].prev;

    }

    void splice(int id, int jd) {

      nodes[id].size += nodes[jd].size;

      nodes[nodes[id].right].next = nodes[jd].left;

      nodes[nodes[jd].left].prev = nodes[id].right;

      int kd = nodes[jd].left;

      while (kd != -1) {

        nodes[kd].parent = id;

        kd = nodes[kd].next;

      }

      nodes[id].right = nodes[jd].right;

    }

    void split(int id, int jd) {

      int kd = nodes[id].parent;

      nodes[kd].right = nodes[id].prev;

      nodes[nodes[id].prev].next = -1;

      nodes[jd].left = id;

      nodes[id].prev = -1;

      int num = 0;

      while (id != -1) {

        nodes[id].parent = jd;

        nodes[jd].right = id;

        id = nodes[id].next;

        ++num;

      }

      nodes[kd].size -= num;

      nodes[jd].size = num;

    }

    void pushLeft(int id, int jd) {

      nodes[id].size += 1;

      nodes[jd].next = nodes[id].left;

      nodes[jd].prev = -1;

      nodes[nodes[id].left].prev = jd;

      nodes[id].left = jd;

      nodes[jd].parent = id;

    }

    void popLeft(int id) {

      nodes[id].size -= 1;

      int jd = nodes[id].left;

      nodes[nodes[jd].next].prev = -1;

      nodes[id].left = nodes[jd].next;

    }

    void repairLeft(int id) {

      int jd = ~(classes[id].parent);

      while (nodes[jd].left != -1) {

        int kd = nodes[jd].left;

        if (nodes[jd].size == 1) {

          if (nodes[jd].parent < 0) {

            classes[id].parent = ~kd;

            classes[id].depth -= 1;

            nodes[kd].parent = ~id;

            deleteNode(jd);

            jd = kd;

          } else {

            int pd = nodes[jd].parent;

            if (nodes[nodes[jd].next].size < cmax) {

              pushLeft(nodes[jd].next, nodes[jd].left);

                nodes[nodes[jd].next].prio = nodes[jd].prio;

                nodes[nodes[jd].next].item = nodes[jd].item;

              }

              popLeft(pd);

              deleteNode(jd);

              jd = pd;

            } else {

              int ld = nodes[nodes[jd].next].left;

              popLeft(nodes[jd].next);

              pushRight(jd, ld);

              if (less(ld, nodes[jd].left) || 

                  nodes[ld].item == nodes[pd].item) {

                nodes[jd].item = nodes[ld].item;

                nodes[jd].prio = nodes[ld].prio;

              }

              if (nodes[nodes[jd].next].item == nodes[ld].item) {

                setPrio(nodes[jd].next);

              }

              jd = nodes[jd].left;

            }

          }

        } else {

          jd = nodes[jd].left;

        }

      }

    }

    void repairRight(int id) {

      int jd = ~(classes[id].parent);

      while (nodes[jd].right != -1) {

        int kd = nodes[jd].right;

        if (nodes[jd].size == 1) {

          if (nodes[jd].parent < 0) {

            classes[id].parent = ~kd;

            classes[id].depth -= 1;

            nodes[kd].parent = ~id;

            deleteNode(jd);

            jd = kd;

          } else {

            int pd = nodes[jd].parent;

            if (nodes[nodes[jd].prev].size < cmax) {

              pushRight(nodes[jd].prev, nodes[jd].right);

                nodes[nodes[jd].prev].prio = nodes[jd].prio;

                nodes[nodes[jd].prev].item = nodes[jd].item;

              }

              popRight(pd);

              deleteNode(jd);

              jd = pd;

            } else {

              int ld = nodes[nodes[jd].prev].right;

              popRight(nodes[jd].prev);

              pushLeft(jd, ld);

              if (less(ld, nodes[jd].right) ||

                  nodes[ld].item == nodes[pd].item) {

                nodes[jd].item = nodes[ld].item;

                nodes[jd].prio = nodes[ld].prio;

              }

              if (nodes[nodes[jd].prev].item == nodes[ld].item) {

                setPrio(nodes[jd].prev);

              }

              jd = nodes[jd].right;

            }

          }

        } else {

          jd = nodes[jd].right;

        }

      }

    }

    bool less(int id, int jd) const {

      return comp(nodes[id].prio, nodes[jd].prio);

    }

  public:

    /// \brief Returns true when the given class is alive.

    ///

    /// Returns true when the given class is alive, ie. the class is

    /// not nested into other class.

    bool alive(int cls) const {

      return classes[cls].parent < 0;

    }

    /// \brief Returns true when the given class is trivial.

    ///

    /// Returns true when the given class is trivial, ie. the class

    /// contains just one item directly.

    bool trivial(int cls) const {

      return classes[cls].left == -1;

    }

    /// \brief Constructs the union-find.

    ///

    /// Constructs the union-find.

    /// \brief _index The index map of the union-find. The data

    /// structure uses internally for store references.

    HeapUnionFind(ItemIntMap& _index)

      : index(_index), first_class(-1),

        first_free_class(-1), first_free_node(-1) {}

    /// \brief Insert a new node into a new component.

    ///

    /// Insert a new node into a new component.

    /// \param item The item of the new node.

    /// \param prio The priority of the new node.

    /// \return The class id of the one-item-heap.

    int insert(const Item& item, const Value& prio) {

      int id = newNode();

      nodes[id].item = item;

      nodes[id].prio = prio;

      nodes[id].size = 0;

      nodes[id].prev = -1;

      nodes[id].next = -1;

      nodes[id].left = -1;

      nodes[id].right = -1;

      nodes[id].item = item;

      index[item] = id;

      int class_id = newClass();

      classes[class_id].parent = ~id;

      classes[class_id].depth = 0;

      classes[class_id].left = -1;

      classes[class_id].right = -1;

      if (first_class != -1) {

        classes[first_class].prev = class_id;

      }

      classes[class_id].next = first_class;

      classes[class_id].prev = -1;

      first_class = class_id;

      nodes[id].parent = ~class_id;