docs: def bwtPartialInsertPoolCall(tup):
      '''
      This is a function typically called by a multiprocess pool to do the partial insertions
      @param tup - the tuple of inputs, see below for breakdown
      '''
      #load these values from the tuple
      (procLabel, seqFNPrefix, offsetFN, finalOutFN, prevIterFN, columnStart, fmIndex, insertionFNs, cOffset, areUniform) = tup
      
      #mark the start time
      sTime = time.time()
      debug = False
      
      #TODO: param is hardcoded, bad?
      vcLen = 6
      
      #load the sequences and the offsets
      if areUniform:
          #figure out the length of uniformity
          offsets = np.load(offsetFN, 'r')
          uniformLength = int(offsets[0])
          
          mmapSeqs = np.load(seqFNPrefix+'.'+str(columnStart % uniformLength)+'.npy')
      else:
          offsetData = np.load(offsetFN, 'r')
          mmapSeqs = np.load(seqFNPrefix+'.npy', 'r')
      fnToLoad = prevIterFN
      
      #if there's nothing to insert, we can just rename the file
      if len(insertionFNs) == 0:
          #TODO: is this screwing up our save points? note that we're renaming so we'd lose the old before guaranteed safe
          #nothing to do in this iteration
          oldFN = fnToLoad
          newFN = finalOutFN+'.'+procLabel+'.'+str(columnStart)+'.npy'
          os.rename(oldFN, newFN)
          
          #vcLen*vcLen matrix for fmDeltas
          fmDeltas = [[0]*vcLen]*vcLen
          nextInsertFNs = [None]*vcLen
          
          #return None as last to let it know not to update
          return (fmDeltas, nextInsertFNs, None)
          
      debugDump('Running.', procLabel, sTime, debug)
      
      #load the previous iteration and mark the column we're in
      column = columnStart
      prevIter = np.load(fnToLoad, 'r')
      
      #reset everything
      nextInserts = [None]*vcLen
      insertionArrays = []
      
      #this is a normal task
      #but first, clear the dump task
      newInsertSize = 0
      insertCounts = [0]*vcLen
      debugDump('Loading inserts...', procLabel, sTime, debug)
      for i, fn in enumerate(insertionFNs):
          #fully load these into memory for fastest results
          insertionArrays.append(np.load(fn))
          newInsertSize += insertionArrays[i].shape[0]
          insertCounts = np.add(insertCounts, np.bincount(insertionArrays[i]['f1'], minlength=vcLen))
          try:
              os.remove(fn)
          except:
              pass
          
      debugDump('Loaded inserts.', procLabel, sTime, debug)
      
      #create the file for the next iteration by pre-allocating for the new insertion size
      nextIter = np.zeros(shape=(prevIter.shape[0]+newInsertSize,), dtype='<u1')
      nextIter[:] = vcLen
      
      #mark the counts
      fmDeltas = [None]*vcLen
      nextInsertFNs = [None]*vcLen
      
      #insert everything that needs inserting
      for arr in insertionArrays:
          nextIter[arr['f0']-cOffset] = arr['f1'][:]
      
      #copy the other
      if prevIter.shape[0] > 0:
          nextIter[nextIter == vcLen] = prevIter[:]
      
      #save the next iteration
      debugDump('Saving...', procLabel, sTime, debug)
      np.save(finalOutFN+'.'+procLabel+'.'+str(column)+'.npy', nextIter)
      debugDump('Finished saving.', procLabel, sTime, debug)
      
      #no longer need this
      del prevIter
      try:
          os.remove(prevIterFN)
      except:
          pass
          
      for c in xrange(0, vcLen):
          #create this array
          nextInserts[c] = np.zeros(shape=(insertCounts[c],), dtype='<u8,<u1,<u4')
          
          #clear the fmDeltas
          fmDeltas[c] = [0]*vcLen
          
      bc = np.array(fmIndex)
      newInsertFilePos = [0]*vcLen
      p = 0
      for arr in insertionArrays:
          nz = np.nonzero(arr['f1'])[0]
          seqIds = arr['f2'][nz]
          
          if areUniform:
              nextC = mmapSeqs[seqIds]
          else:
              indices = np.subtract(offsetData[seqIds+1], (column+1))
              if seqIds.shape[0] > 0 and seqIds[0] == 0 and offsetData[1] < (column+1):
                  indices[0] = offsetData[1]-1
              nextC = mmapSeqs[indices]
          
          pos = np.zeros(dtype='<u8', shape=(seqIds.shape[0], ))
          
          for i in xrange(0, seqIds.shape[0]):
              e = arr['f0'][nz[i]]-cOffset
              if p == e:
                  pass
              else:
                  bc = np.add(bc, np.bincount(nextIter[p:e], minlength=vcLen))
              pos[i] = bc[arr['f1'][nz[i]]]
              p = e
          
          for c in xrange(1, vcLen):
              counters = np.where(arr['f1'][nz] == c)[0]
              nextInserts[c]['f0'][newInsertFilePos[c]:newInsertFilePos[c]+counters.shape[0]] = pos[counters]
              nextInserts[c]['f1'][newInsertFilePos[c]:newInsertFilePos[c]+counters.shape[0]] = nextC[counters]
              nextInserts[c]['f2'][newInsertFilePos[c]:newInsertFilePos[c]+counters.shape[0]] = seqIds[counters]
              newInsertFilePos[c] += counters.shape[0]
              
              if counters.shape[0] == 0:
                  pass
              else:
                  fmDeltas[c] = np.add(fmDeltas[c], np.bincount(nextC[counters], minlength=6))
      
      nextShape = nextIter.shape[0]
      
      nextInsertFNs = [None]*vcLen
      for c in xrange(1, vcLen):
          if insertCounts[c] > 0:
              nextInsertFN = finalOutFN+'.'+str(c)+procLabel+'.'+str(column)+'.temp.npy'
              nextInsertFNs[c] = nextInsertFN
              np.save(nextInsertFN, nextInserts[c])
              
      #cleanup 
      del nz
      del seqIds
      if not areUniform:
          del indices
      del nextC
      del counters
      del pos
      del nextIter
      del insertionArrays
      del nextInserts
      gc.collect()
      
      debugDump('Finished.', procLabel, sTime, debug)
      
      return (fmDeltas, nextInsertFNs, nextShape)