class StatisticsMsmStrategy : public DecoratorMsmStrategy {
public:
  StatisticsMsmStrategy(MsmStrategy* strategy):
    DecoratorMsmStrategy(strategy),
    _level(0),
    _consumeCount(0),
    _independenceSplitCount(0) {
  }

  ~StatisticsMsmStrategy() {
    fputs("**** Statistics\n", stderr);
    size_t sum = 0;
    size_t baseSum = 0;
	size_t emptySum = 0;
    for (size_t l = 0; l < _calls.size(); ++l) {
      sum += _calls[l];
      baseSum += _baseCases[l];
	  emptySum += _empty[l];
      if (false) {
		fprintf(stderr,
				"Level %lu had %lu calls of which %lu were base cases.\n",
				(unsigned long)l + 1,
				(unsigned long)_calls[l],
				(unsigned long)_baseCases[l]);
      }
    }

    fprintf(stderr,
			"* recursive levels:    %lu\n"
			"* decom size:          %lu\n" 
			"* empty slices:        %lu\n"
			"* base case slices:    %lu\n"
			"* independence splits: %lu\n"
			"* (numbers not corrected for independence splits)\n"
			"****\n",
			(unsigned long)_calls.size(),
			(unsigned long)_consumeCount,
			(unsigned long)emptySum,
			(unsigned long)baseSum,
			(unsigned long)_independenceSplitCount);
  }

  virtual void doingIndependenceSplit(const MsmSlice& slice,
									  Ideal* mixedProjectionSubtract) {
    ++_independenceSplitCount;
    DecoratorMsmStrategy::doingIndependenceSplit(slice,
												   mixedProjectionSubtract);
  }

  void consume(const Term& term) {
	for (size_t level = _level; level > 0; --level) {
	  if (!_isEmpty[level - 1])
		break; // The remaining entries are already false
	  _isEmpty[level - 1] = false;
	}
    ++_consumeCount;

    DecoratorMsmStrategy::consume(term);
  }

private:
  size_t _level;
  vector<size_t> _calls;
  vector<size_t> _baseCases;
  vector<size_t> _isBaseCase;
  vector<size_t> _empty;
  vector<size_t> _isEmpty;
  size_t _consumeCount;
  size_t _independenceSplitCount;
};
