  bool getDivisor(const Term* term) const {
    if (empty())
      return false;

    _walker->goToRoot();
    _walker->stepDown();

    while (true) {
      while (_walker->getNode()->getExponent() <=
	      _handler->getExponent(term, _position + _walker->getLevel() - 1)) {
	if (!_walker->canStepDown())
	  return true;
	_walker->stepDown();
      }
      
      while (!_walker->canStepRight()) {
	_walker->stepUp();
	if (_walker->atRoot())
	  return false;
      
      }
      _walker->stepRight();
    }
  }


  // mergeSubtree assumes the sub-trees are of equal height and
  // non-empty. TODO: adjust for _threshold.
  bool mergeSubtree(TreeWalker& toWalker, TreeWalker& fromWalker) {
    if (!fromWalker.canStepDown())
      return false;

    bool changed = false;
    int rootLevel = fromWalker.getLevel();
    
    // The goto's in this method are unfortunate, but I have not found
    // a good way to get rid of them.
  stepDown:
    fromWalker.stepDown();
    
    if (toWalker.getNode()->getChild()->getExponent() >
	fromWalker.getNode()->getExponent()) {
      toWalker.insertUnder(fromWalker.getNode()->getExponent());
      toWalker.stepDown();
      copySubtree(toWalker, fromWalker);
      changed = true;
      
      goto moveOn;
    }

    toWalker.stepDown();

    while (true) {
      // Now toWalker's exponent <= fromWalker's exponent. Then we
      // step toWalker right as long as this property is preserved.
     
      while (toWalker.canStepRight() &&
	     toWalker.getNode()->getNext()->getExponent() <=
	     fromWalker.getNode()->getExponent())
	toWalker.stepRight();

      // If the exponents are equal then we need to merge the subtrees
      // of the current positions.
      if (toWalker.getNode()->getExponent() ==
	  fromWalker.getNode()->getExponent()) {
	if (fromWalker.canStepDown())
	  goto stepDown;
      } else {

	ASSERT(toWalker.getNode()->getExponent() <
	       fromWalker.getNode()->getExponent());

	// Due to the previous right-stepping of toWalker, we know that
	// the correct place to insert the new subtree is immediately to
	// the right of toWalker.
	toWalker.insertRightOf(fromWalker.getNode()->getExponent());
	toWalker.stepRight();
	copySubtree(toWalker, fromWalker);
	changed = true;
      }

    moveOn:
      while (!fromWalker.canStepRight()) {
	fromWalker.stepUp();
	toWalker.stepUp();
	
	if (fromWalker.getLevel() == rootLevel)
	  return changed;
      }
      fromWalker.stepRight();
    }
  }

  void copySubtree(TreeWalker& toWalker, TreeWalker& fromWalker) {
    if (!fromWalker.canStepDown())
      return;

    int rootLevel = fromWalker.getLevel();

    while (true) {
      while (fromWalker.canStepDown()) {
	fromWalker.stepDown();
	
	toWalker.insertUnder(fromWalker.getNode()->getExponent());
	toWalker.stepDown();
      }

      while (!fromWalker.canStepRight()) {
	fromWalker.stepUp();
	toWalker.stepUp();

	if (fromWalker.getLevel() == rootLevel)
	  return;
      }

      fromWalker.stepRight();

      toWalker.insertRightOf(fromWalker.getNode()->getExponent());
      toWalker.stepRight();
    }
  }
  
  bool insertProjectionOf(const TermTree& tree, Exponent from, Exponent to) {
    if (tree.empty())
      return false;

    ExternalTerm term(*_handler);

    TreeWalker* toWalker = _walker;//(*this);
    TreeWalker* fromWalker = tree._walker;//((TermTree&)tree);
    toWalker->goToRoot();
    fromWalker->goToRoot();

    fromWalker->stepDown();

    bool changed = false;
    
    while (true) {
      if (to < fromWalker->getNode()->getExponent())
	break;
      if (from <= fromWalker->getNode()->getExponent()) {
	if (empty()) {
	  copySubtree(*toWalker, *fromWalker);
	  changed = true;
	} else
	  changed |= mergeSubtree(*toWalker, *fromWalker);
      }

      if (!fromWalker->canStepRight())
	break;
      fromWalker->stepRight();
    }

    return changed;
  }
