docs: @Override
      public Sequence<T> next() {
          int[] visitedHops = new int[walkLength];
          Arrays.fill(visitedHops, -1);
  
          Sequence<T> sequence = new Sequence<>();
  
          int startPosition = position.getAndIncrement();
          int lastId = -1;
          int startPoint = order[startPosition];
          //System.out.println("");
  
  
          startPosition = startPoint;
  
          //if (startPosition == 0 || startPoint % 1000 == 0)
          //   System.out.println("ATZ Walk: ");
  
          for (int i = 0; i < walkLength; i++) {
              Vertex<T> vertex = sourceGraph.getVertex(startPosition);
  
              int currentPosition = startPosition;
  
              sequence.addElement(vertex.getValue());
              visitedHops[i] = vertex.vertexID();
              //if (startPoint == 0 || startPoint % 1000 == 0)
              // System.out.print("" + vertex.vertexID() + " -> ");
  
  
              if (alpha > 0 && lastId != startPoint && lastId != -1 && alpha > rng.nextDouble()) {
                  startPosition = startPoint;
                  continue;
              }
  
  
              // get next vertex
              switch (walkDirection) {
                  case RANDOM: {
                      int[] nextHops = sourceGraph.getConnectedVertexIndices(currentPosition);
                      startPosition = nextHops[rng.nextInt(nextHops.length)];
                  }
                      break;
                  case FORWARD_ONLY: {
                      // here we remove only last hop
                      int[] nextHops = ArrayUtils.removeElements(sourceGraph.getConnectedVertexIndices(currentPosition),
                                      lastId);
                      if (nextHops.length > 0) {
                          startPosition = nextHops[rng.nextInt(nextHops.length)];
                      } else {
                          switch (noEdgeHandling) {
                              case CUTOFF_ON_DISCONNECTED: {
                                  i += walkLength;
                              }
                                  break;
                              case EXCEPTION_ON_DISCONNECTED: {
                                  throw new NoEdgesException("No more edges at vertex [" + currentPosition + "]");
                              }
                              case SELF_LOOP_ON_DISCONNECTED: {
                                  startPosition = currentPosition;
                              }
                                  break;
                              case PADDING_ON_DISCONNECTED: {
                                  throw new UnsupportedOperationException("PADDING not implemented yet");
                              }
                              case RESTART_ON_DISCONNECTED: {
                                  startPosition = startPoint;
                              }
                                  break;
                              default:
                                  throw new UnsupportedOperationException(
                                                  "NoEdgeHandling mode [" + noEdgeHandling + "] not implemented yet.");
                          }
                      }
                  }
                      break;
                  case FORWARD_UNIQUE: {
                      // here we remove all previously visited hops, and we don't get  back to them ever
                      int[] nextHops = ArrayUtils.removeElements(sourceGraph.getConnectedVertexIndices(currentPosition),
                                      visitedHops);
                      if (nextHops.length > 0) {
                          startPosition = nextHops[rng.nextInt(nextHops.length)];
                      } else {
                          // if we don't have any more unique hops within this path - break out.
                          switch (noEdgeHandling) {
                              case CUTOFF_ON_DISCONNECTED: {
                                  i += walkLength;
                              }
                                  break;
                              case EXCEPTION_ON_DISCONNECTED: {
                                  throw new NoEdgesException("No more edges at vertex [" + currentPosition + "]");
                              }
                              case SELF_LOOP_ON_DISCONNECTED: {
                                  startPosition = currentPosition;
                              }
                                  break;
                              case PADDING_ON_DISCONNECTED: {
                                  throw new UnsupportedOperationException("PADDING not implemented yet");
                              }
                              case RESTART_ON_DISCONNECTED: {
                                  startPosition = startPoint;
                              }
                                  break;
                              default:
                                  throw new UnsupportedOperationException(
                                                  "NoEdgeHandling mode [" + noEdgeHandling + "] not implemented yet.");
                          }
                      }
                  }
                      break;
                  case FORWARD_PREFERRED: {
                      // here we remove all previously visited hops, and if there's no next unique hop available - we fallback to anything, but the last one
                      int[] nextHops = ArrayUtils.removeElements(sourceGraph.getConnectedVertexIndices(currentPosition),
                                      visitedHops);
                      if (nextHops.length == 0) {
                          nextHops = ArrayUtils.removeElements(sourceGraph.getConnectedVertexIndices(currentPosition),
                                          lastId);
                          if (nextHops.length == 0) {
                              switch (noEdgeHandling) {
                                  case CUTOFF_ON_DISCONNECTED: {
                                      i += walkLength;
                                  }
                                      break;
                                  case EXCEPTION_ON_DISCONNECTED: {
                                      throw new NoEdgesException("No more edges at vertex [" + currentPosition + "]");
                                  }
                                  case SELF_LOOP_ON_DISCONNECTED: {
                                      startPosition = currentPosition;
                                  }
                                      break;
                                  case PADDING_ON_DISCONNECTED: {
                                      throw new UnsupportedOperationException("PADDING not implemented yet");
                                  }
                                  case RESTART_ON_DISCONNECTED: {
                                      startPosition = startPoint;
                                  }
                                      break;
                                  default:
                                      throw new UnsupportedOperationException("NoEdgeHandling mode [" + noEdgeHandling
                                                      + "] not implemented yet.");
                              }
                          } else
                              startPosition = nextHops[rng.nextInt(nextHops.length)];
                      }
                  }
                      break;
                  default:
                      throw new UnsupportedOperationException("Unknown WalkDirection [" + walkDirection + "]");
              }
  
              lastId = vertex.vertexID();
          }
  
          //if (startPoint == 0 || startPoint % 1000 == 0)
          //System.out.println("");
          return sequence;
      }