code: int nextSequenceShuffleIndex() throws Exception {
  		RTObject popEvaluationStack = state.popEvaluationStack();
  
  		IntValue numElementsIntVal = popEvaluationStack instanceof IntValue ? (IntValue) popEvaluationStack : null;
  
  		if (numElementsIntVal == null) {
  			error("expected number of elements in sequence for shuffle index");
  			return 0;
  		}
  
  		Container seqContainer = state.getCurrentPointer().container;
  
  		int numElements = numElementsIntVal.value;
  
  		IntValue seqCountVal = (IntValue) state.popEvaluationStack();
  		int seqCount = seqCountVal.value;
  		int loopIndex = seqCount / numElements;
  		int iterationIndex = seqCount % numElements;
  
  		// Generate the same shuffle based on:
  		// - The hash of this container, to make sure it's consistent
  		// each time the runtime returns to the sequence
  		// - How many times the runtime has looped around this full shuffle
  		String seqPathStr = seqContainer.getPath().toString();
  		int sequenceHash = 0;
  		for (char c : seqPathStr.toCharArray()) {
  			sequenceHash += c;
  		}
  
  		int randomSeed = sequenceHash + loopIndex + state.getStorySeed();
  
  		Random random = new Random(randomSeed);
  
  		ArrayList<Integer> unpickedIndices = new ArrayList<Integer>();
  		for (int i = 0; i < numElements; ++i) {
  			unpickedIndices.add(i);
  		}
  
  		for (int i = 0; i <= iterationIndex; ++i) {
  			int chosen = random.nextInt(Integer.MAX_VALUE) % unpickedIndices.size();
  			int chosenIndex = unpickedIndices.get(chosen);
  			unpickedIndices.remove(chosen);
  
  			if (i == iterationIndex) {
  				return chosenIndex;
  			}
  		}
  
  		throw new Exception("Should never reach here");
  	}
docs: TODO: Is this the best algorithm it can be?