RhodeCode

    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);

              }

              popLeft(pd);

              deleteNode(jd);

              jd = pd;

            } else {

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

              popLeft(nodes[jd].next);

              pushRight(jd, ld);

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

              }

              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);

              }

              popRight(pd);

              deleteNode(jd);

              jd = pd;

            } else {

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

              popRight(nodes[jd].prev);

              pushLeft(jd, ld);

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

              }

              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);

    }

    bool equal(int id, int jd) const {

      return !less(id, jd) && !less(jd, id);

    }

  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;

    }

          classes[classes[l].next].prev = classes[l].prev;

        }

        classes[classes[l].prev].next = classes[l].next;

        classes[l].prev = -1;

        classes[l].next = -1;

        classes[l].depth = leftNode(l);

        classes[l].parent = class_id;

      }

      { // merging of heap

        int l = class_id;

        for (int ci = 1; ci < int(cs.size()); ++ci) {

          int r = cs[ci];

          int rln = leftNode(r);

          if (classes[l].depth > classes[r].depth) {

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

            for (int i = classes[r].depth + 1; i < classes[l].depth; ++i) {

              id = nodes[id].right;

            }

            while (id >= 0 && nodes[id].size == cmax) {

              int new_id = newNode();

              int right_id = nodes[id].right;

              popRight(id);

              if (nodes[id].item == nodes[right_id].item) {

                setPrio(id);

              }

              push(new_id, right_id);

              pushRight(new_id, ~(classes[r].parent));

              id = nodes[id].parent;

              classes[r].parent = ~new_id;

            }

            if (id < 0) {

              int new_parent = newNode();

              nodes[new_parent].next = -1;

              nodes[new_parent].prev = -1;

              nodes[new_parent].parent = ~l;

              push(new_parent, ~(classes[l].parent));

              pushRight(new_parent, ~(classes[r].parent));

              setPrio(new_parent);

              classes[l].parent = ~new_parent;

              classes[l].depth += 1;

            } else {

              pushRight(id, ~(classes[r].parent));

              while (id >= 0 && less(~(classes[r].parent), id)) {

                nodes[id].prio = nodes[~(classes[r].parent)].prio;

                nodes[id].item = nodes[~(classes[r].parent)].item;

                id = nodes[id].parent;

              }

            }

          } else if (classes[r].depth > classes[l].depth) {

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

            for (int i = classes[l].depth + 1; i < classes[r].depth; ++i) {

              id = nodes[id].left;

            }

            while (id >= 0 && nodes[id].size == cmax) {

              int new_id = newNode();

              int left_id = nodes[id].left;

              popLeft(id);

              if (nodes[id].prio == nodes[left_id].prio) {

                setPrio(id);

              }

              push(new_id, left_id);

              pushLeft(new_id, ~(classes[l].parent));

              id = nodes[id].parent;

              classes[l].parent = ~new_id;

            }

            if (id < 0) {

              int new_parent = newNode();

              nodes[new_parent].next = -1;

              nodes[new_parent].prev = -1;

              nodes[new_parent].parent = ~l;

              push(new_parent, ~(classes[r].parent));

              pushLeft(new_parent, ~(classes[l].parent));

              setPrio(new_parent);

              classes[r].parent = ~new_parent;

              classes[r].depth += 1;

            } else {

              pushLeft(id, ~(classes[l].parent));

              while (id >= 0 && less(~(classes[l].parent), id)) {

                nodes[id].prio = nodes[~(classes[l].parent)].prio;

                nodes[id].item = nodes[~(classes[l].parent)].item;

                id = nodes[id].parent;

              }

            }

            nodes[~(classes[r].parent)].parent = ~l;

            classes[l].parent = classes[r].parent;

            classes[l].depth = classes[r].depth;

          } else {

            if (classes[l].depth != 0 &&

                nodes[~(classes[l].parent)].size +

                nodes[~(classes[r].parent)].size <= cmax) {