indri::lang::Node* after( indri::lang::RawScorerNode* oldNode, indri::lang::RawScorerNode* newNode ) {
        indri::lang::Node* result = 0;

        if( _lastTerm && !_disqualifiers.size() && !_disqualifiedTree && oldNode->getContext() == NULL ) {
          indri::lang::TermFrequencyScorerNode* scorerNode;
          // there's a term to score, and nothing to disqualify us from doing frequency scoring
          scorerNode = new indri::lang::TermFrequencyScorerNode( _lastTerm->getText(),
                                                                 _lastTerm->getStemmed() );

          scorerNode->setNodeName( oldNode->nodeName() );
          scorerNode->setSmoothing( oldNode->getSmoothing() );
          scorerNode->setStatistics( oldNode->getOccurrences(), oldNode->getContextSize() );

          delete newNode;
          result = defaultAfter( oldNode, scorerNode );
        } else if( !_disqualifiers.size() ) {
          ListCache::CachedList* list = 0; 

          if( _listCache )
            list = _listCache->find( newNode->getRawExtent(), newNode->getContext() );
      
          if( list ) {
            indri::lang::CachedFrequencyScorerNode* cachedNode;
            cachedNode = new indri::lang::CachedFrequencyScorerNode( newNode->getRawExtent(), newNode->getContext() );
            cachedNode->setNodeName( newNode->nodeName() );
            cachedNode->setSmoothing( newNode->getSmoothing() );
            cachedNode->setList( list );

            delete newNode;
            result = defaultAfter( oldNode, cachedNode );
          } else {
            result = defaultAfter( oldNode, newNode );
          }
        } else {
          result = defaultAfter( oldNode, newNode );
        }

        _disqualifiedTree = false;
        return result; 
      }

 void Walker::after( class WeightedExtentOr* n ) { defaultAfter( n ); }