Unique hashcodes in parallel
@yegor256 @mximp Now the test passes succesfully with `threads = 100` but failes when `threads = 1000`:
```
    @Test
    public void phiUniqueHashesInDynamic() {
        final int threads = 1000;
        final Set<Integer> hashes = ConcurrentHashMap.newKeySet();
        new Threads<>(
            threads,
            Stream.generate(
                () -> (Scalar<Integer>) () -> (new EOmutex$EOacquire(Phi.Φ)).hashCode()
            ).limit(threads).collect(Collectors.toList())
        ).forEach(hashes::add);
        MatcherAssert.assertThat(
            hashes.size(),
            Matchers.equalTo(threads)
        );
    }
```
```
[ERROR] Failures: 
[ERROR]   EOmutexTest.phiUniqueHashesInDynamic:88 
Expected: <1000>
     but: was <988>
[ERROR] Tests run: 27, Failures: 1, Errors: 0, Skipped: 0
```

diff --git a/eo-runtime/src/main/java/org/eolang/Vertices.java b/eo-runtime/src/main/java/org/eolang/Vertices.java
index f8caa087f..1fba45eac 100644
--- a/eo-runtime/src/main/java/org/eolang/Vertices.java
+++ b/eo-runtime/src/main/java/org/eolang/Vertices.java
@@ -57,7 +57,7 @@ final class Vertices {
     public int next() {
         return this.seen.computeIfAbsent(
             String.format("next:%d", this.count.addAndGet(1)),
-            key -> this.seen.size() + 1
+            key -> this.count.addAndGet(1)
         );
     }
 
@@ -97,7 +97,7 @@ final class Vertices {
         );
         final String hash = new String(digest.digest());
         return this.seen.computeIfAbsent(
-            hash, key -> this.seen.size() + 1
+            hash, key -> this.count.addAndGet(1)
         );
     }
 
diff --git a/eo-runtime/src/test/java/org/eolang/VerticesTest.java b/eo-runtime/src/test/java/org/eolang/VerticesTest.java
index 5f3d7299f..0bee3bed8 100644
--- a/eo-runtime/src/test/java/org/eolang/VerticesTest.java
+++ b/eo-runtime/src/test/java/org/eolang/VerticesTest.java
@@ -23,6 +23,8 @@
  */
 package org.eolang;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Random;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -45,7 +47,7 @@ final class VerticesTest {
     void makesNext() {
         MatcherAssert.assertThat(
             new Vertices().next(),
-            Matchers.equalTo(1)
+            Matchers.greaterThan(0)
         );
     }
 
@@ -59,16 +61,30 @@ final class VerticesTest {
         );
     }
 
+    /**
+     * Test that {@link Vertices#best(Object)} and {@link Vertices#next()}
+     * works correctly in multithreaded environment, i.e. produces non-repeatable
+     * values.
+     */
     @Test
-    void vtxThreadTest() {
+    void vtxConcurrencyTest() {
         final Set<Integer> hashes = ConcurrentHashMap.newKeySet();
         final Vertices vtx = new Vertices();
-        final int threads = 8;
+        final int threads = 1000;
+        final List<Scalar<Integer>> tasks = new ArrayList<>(threads);
+        tasks.addAll(
+            Stream.generate(() -> (Scalar<Integer>) vtx::next)
+                .limit(threads / 2)
+                .collect(Collectors.toList())
+        );
+        tasks.addAll(
+            Stream.generate(() -> (Scalar<Integer>) () -> vtx.best(new Random().nextLong()))
+                .limit(threads / 2)
+                .collect(Collectors.toList())
+        );
         new Threads<>(
             threads,
-            Stream.generate(
-                () -> (Scalar<Integer>) () -> vtx.best(new Random().nextLong())
-            ).limit(threads).collect(Collectors.toList())
+            tasks
         ).forEach(hashes::add);
         MatcherAssert.assertThat(
             hashes.size(),
['eo-runtime/src/main/java/org/eolang/Vertices.java', 'eo-runtime/src/test/java/org/eolang/VerticesTest.java']