<T extends @Nullable Object> Scenario<?> mutate(Scenario<T> scenario) {
        List<Iterable<T>> words = new ArrayList<>();
        words.add(Collections.<T>emptyList());
        for (T t : scenario.strictlyOrderedList) {
          words.add(asList(t));
          for (T s : scenario.strictlyOrderedList) {
            words.add(asList(t, s));
          }
        }
        return new Scenario<Iterable<T>>(

      <T extends @Nullable Object> Scenario<?> mutate(Scenario<T> scenario) {
        List<Iterable<T>> words = new ArrayList<>();
        words.add(Collections.<T>emptyList());
        for (T t : scenario.strictlyOrderedList) {
          words.add(asList(t));
          for (T s : scenario.strictlyOrderedList) {
            words.add(asList(t, s));
          }
        }
        return new Scenario<Iterable<T>>(

```

Result (French):

```
"Hello world"
“Hello Universe”
"He said: 'Hello'"
"The module is `__main__`"
```

### Ellipsis

- Make sure there is a space between an ellipsis and a word following or preceding the ellipsis.

Examples:

Source (English):

```
...as we intended.
...this would work:
...etc.
others...
More to come...
```

Result (French):

```

    }

    @Test
    public void test_longQuery() throws Exception {
        StringBuilder longQuery = new StringBuilder();
        for (int i = 0; i < 100; i++) {
            longQuery.append("word").append(i).append(" ");
        }
        String query = longQuery.toString().trim();

        QueryLog queryLog = new QueryLog(query, null);

        assertEquals(query, queryLog.getQueryString());
    }

    private static final int CHUNK_SIZE = 8;

    // The number of compression rounds.
    private final int c;
    // The number of finalization rounds.
    private final int d;

    // Four 64-bit words of internal state.
    // The initial state corresponds to the ASCII string "somepseudorandomlygeneratedbytes",
    // big-endian encoded. There is nothing special about this value; the only requirement

  protected class StandardKeySet extends Maps.SortedKeySet<K, V> {
    /** Constructor for use by subclasses. */
    public StandardKeySet() {
      super(ForwardingSortedMap.this);
    }
  }

  // unsafe, but worst case is a CCE or NPE is thrown, which callers will be expecting
  @SuppressWarnings({"unchecked", "nullness"})
  static int unsafeCompare(
      @Nullable Comparator<?> comparator, @Nullable Object o1, @Nullable Object o2) {

   * Stream.of("foo", "quux", "banana", "elephant").collect(least(2, comparingInt(String::length)))
   * // returns {"foo", "quux"}
   * }
   *
   * <p>This {@code Collector} uses O(k) memory and takes expected time O(n) (worst-case O(n log
   * k)), as opposed to e.g. {@code Stream.sorted(comparator).limit(k)}, which currently takes O(n
   * log n) time and O(n) space.
   *
   * @throws IllegalArgumentException if {@code k < 0}

     */
    public static CrawlingInfoHelper getCrawlingInfoHelper() {
        return getComponent(CRAWLING_INFO_HELPER);
    }

    /**
     * Gets the popular word helper component.
     * @return The popular word helper.
     */
    public static PopularWordHelper getPopularWordHelper() {
        return getComponent(POPULAR_WORD_HELPER);
    }

    /**

file: org.apache.spark.rdd.RDD[String] = s3a://testbucket/testdata MapPartitionsRDD[1] at textFile at <console>:24

scala> val counts = file.flatMap(line => line.split(" ")).map(word => (word, 1)).reduceByKey(_ + _)
counts: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[4] at reduceByKey at <console>:25

scala> counts.saveAsTextFile("s3a://testbucket/wordcount")
```

		the end of the term you are searching.
		<pre>Fess^100</pre>
	</dd>
	<dt>Fuzzy</dt>
	<dd>
		To do a fuzzy search use the "~" symbol at the end of a single word
		term. For example to search for a term similar in spelling to "Fess"
		use the fuzzy search:
		<pre>Fess~0.5</pre>
	</dd>