docs: def extendSeed(self, seedKmer, endSeeds):
          '''
          This function is intended to be an interactive technique for constructing transcripts, probably to be released
          in a future version of msbwt
          @param bwtFN - the filename of the BWT to load
          @param seedKmer - the seed sequence to use for construction
          @param threshold - minimum number for a path to be considered a path
          @param direction - True is forward, False is backward
          @param logger - the logger
          @param 
          '''
          
          if self.foundKmers.has_key(seedKmer):
              return
          
          pathK = self.settingsDict.get('kmerSize', len(seedKmer))
          countK = self.settingsDict.get('countK', pathK)
          isMerged = self.settingsDict.get('isMerged', False)
          trackPairs = self.settingsDict.get('trackPairs', False)
          trackReads = self.settingsDict.get('trackReads', False)
          useMemmap = self.settingsDict.get('useMemmap', True)
          maxDistance = self.settingsDict.get('maxDistance', 0xFFFFFFFF)
          
          if len(seedKmer) != pathK:
              raise Exception('Seed k-mer incorrect length')
          
          numNodes = self.settingsDict['numNodes']
          validChars = ['$', 'A', 'C', 'G', 'N', 'T']
          
          if self.logger != None:
              self.logger.info('Loading '+self.bwtDir+'...')
          msbwt = MultiStringBWT.loadBWT(self.bwtDir, useMemmap, self.logger)
          if os.path.exists(self.bwtDir+'/origins.npy'):
              raise Exception("You haven\'t reimplemented the handling of origin files")
              origins = np.load(self.bwtDir+'/origins.npy', 'r')
          else:
              origins = None
          
          self.settingsDict['interleaveFN'] = self.bwtDir+'/inter0.npy'
          
          kmer = seedKmer
          
          firstID = len(self.nodes)
          self.nodes.append(PathNode(firstID, kmer, msbwt, 0, self.settingsDict))
          self.foundKmers[kmer] = firstID
          
          for i, endSeed in enumerate(endSeeds):
              if len(endSeed) != pathK:
                  raise Exception(endSeed+': NOT CORRECT LENGTH')
              else:
                  endID = len(self.nodes)
                  self.nodes.append(PathNode(endID, endSeed, msbwt, 0, self.settingsDict))
                  self.nodes[endID].termCondition = 'END_SEED_'+str(i)
                  self.foundKmers[endSeed] = endID
          
          if self.logger != None:
              self.logger.info('Beginning with seed \''+seedKmer+'\', pathK='+str(pathK)+', countK='+str(countK))
          
          unexploredPaths = [self.nodes[firstID]]
          
          #init the kmer dictionary
          execID = firstID
          
          while len(unexploredPaths) > 0:
              #uncomment to make this smallest first
              unexploredPaths.sort(key = lambda node: node.minDistToSeed)
              #print 'UP: '+'['+','.join([str((node.minDistToSeed, node.nodeID)) for node in unexploredPaths])+']'
              nextNode = unexploredPaths.pop(0)
              
              if nextNode.nodeID >= numNodes:
                  nextNode.termCondition = 'UNEXPLORED_NODE'
              elif nextNode.minDistToSeed >= maxDistance:
                  nextNode.termCondition = 'UNEXPLORED_DIST'
              else:
                  nextNode.execOrder = execID
                  execID += 1
                  
                  if self.logger != None:
                      self.logger.info('Exploring new node')
                  nextNode.firstTimeExtension(self.foundKmers, unexploredPaths, self.nodes, self.edges)
              
          if isMerged and trackReads:
              interleaveFN = self.bwtDir+'/inter0.npy'
              interleave = np.load(interleaveFN, 'r')
              
              #we only need to do this for newly processed nodes
              for node in self.nodes[firstID:]:
                  dIDs = node.readSet
                  for dID in dIDs:
                      sourceID = interleave[dID[0]]
                      node.sourceCounts[sourceID] = node.sourceCounts.get(sourceID, 0)+1
                  
          if trackPairs:
              abtFN = self.bwtDir+'/abt.npy'
              abt = np.load(abtFN, 'r')
                      
              #abtDict = {}
              
              #only need to process new nodes
              for node in self.nodes[firstID:]:
                  dIDs = node.readSet
                  
                  for dID, direction in dIDs:
                      (fID, rID) = abt[dID]
                      if fID % 2 == 0:
                          oFID = fID+1
                      else:
                          oFID = fID-1
                      
                      if self.abtDict.has_key((oFID, rID, 1-direction)):
                          otherNIDs = self.abtDict[(oFID, rID, 1-direction)][1]
                          for n in otherNIDs:
                              self.nodes[n].pairedNodes[node.nodeID] = self.nodes[n].pairedNodes.get(node.nodeID, 0)+1
                              node.pairedNodes[n] = node.pairedNodes.get(n, 0)+1
                      
                      if not self.abtDict.has_key((fID, rID, direction)):
                          self.abtDict[(fID, rID, direction)] = (dID, set([]))
                      self.abtDict[(fID, rID, direction)][1].add(node.nodeID)