diff --git a/cffu-core/src/main/java/io/foldright/cffu/CffuFactory.java b/cffu-core/src/main/java/io/foldright/cffu/CffuFactory.java
index 2f30491c..eaf69610 100644
--- a/cffu-core/src/main/java/io/foldright/cffu/CffuFactory.java
+++ b/cffu-core/src/main/java/io/foldright/cffu/CffuFactory.java
@@ -301,7 +301,7 @@ public final <T> Cffu<T>[] toCffuArray(CompletionStage<T>... stages) {
     //
     //  - allOf / allOfFastFail
     //  - allResultsOf / allResultsOfFastFail
-    //  - allResultsOf / allResultsOfFastFail
+    //  - mostResultsOfSuccess
     ////////////////////////////////////////////////////////////////////////////////
 
     /**
@@ -423,7 +423,6 @@ public final <T> Cffu<List<T>> allResultsOfFastFail(CompletionStage<? extends T>
      * the given stages in the given time({@code timeout}), aka as many results as possible in the given time.
      * <p>
      * If the given stage is successful, its result is the completed value; Otherwise the given valueIfNotSuccess.
-     * (aka the result extraction logic is {@link Cffu#getSuccessNow(Object)}).
      *
      * @param timeout           how long to wait in units of {@code unit}
      * @param unit              a {@code TimeUnit} determining how to interpret the {@code timeout} parameter
@@ -431,7 +430,6 @@ public final <T> Cffu<List<T>> allResultsOfFastFail(CompletionStage<? extends T>
      * @param cfs               the stages
      * @see Cffu#getSuccessNow(Object)
      */
-    // TODO * @see CompletableFutureUtils#MGetSuccessNow(Object, CompletionStage[])
     @Contract(pure = true)
     @SafeVarargs
     public final <T> Cffu<List<T>> mostResultsOfSuccess(
@@ -495,6 +493,7 @@ public final <T> Cffu<T> anyOfSuccess(CompletionStage<? extends T>... cfs) {
     //
     //  - allTupleOf
     //  - allTupleOfFastFail
+    //  - mostTupleOfSuccess
     ////////////////////////////////////////////////////////////////////////////////
 
     /**
@@ -633,6 +632,83 @@ public <T1, T2, T3, T4, T5> Cffu<Tuple5<T1, T2, T3, T4, T5>> allTupleOfFastFail(
         return new0(CompletableFutureUtils.allTupleOfFastFail(cf1, cf2, cf3, cf4, cf5));
     }
 
+    /**
+     * Returns a new Cffu with the most results in the <strong>same order</strong> of
+     * the given two stages in the given time({@code timeout}), aka as many results as possible in the given time.
+     * <p>
+     * If the given stage is successful, its result is the completed value; Otherwise the value {@code null}.
+     *
+     * @param timeout how long to wait in units of {@code unit}
+     * @param unit    a {@code TimeUnit} determining how to interpret the {@code timeout} parameter
+     * @return a new Cffu that is completed when the given two stages complete
+     * @see #mostResultsOfSuccess(long, TimeUnit, Object, CompletionStage[])
+     * @see Cffu#getSuccessNow(Object)
+     */
+    @Contract(pure = true)
+    public <T1, T2> Cffu<Tuple2<T1, T2>> mostTupleOfSuccess(
+            long timeout, TimeUnit unit, CompletionStage<? extends T1> cf1, CompletionStage<? extends T2> cf2) {
+        return new0(CompletableFutureUtils.mostTupleOfSuccess(timeout, unit, cf1, cf2));
+    }
+
+    /**
+     * Returns a new Cffu with the most results in the <strong>same order</strong> of
+     * the given three stages in the given time({@code timeout}), aka as many results as possible in the given time.
+     * <p>
+     * If the given stage is successful, its result is the completed value; Otherwise the value {@code null}.
+     *
+     * @param timeout how long to wait in units of {@code unit}
+     * @param unit    a {@code TimeUnit} determining how to interpret the {@code timeout} parameter
+     * @return a new Cffu that is completed when the given three stages complete
+     * @see #mostResultsOfSuccess(long, TimeUnit, Object, CompletionStage[])
+     * @see Cffu#getSuccessNow(Object)
+     */
+    @Contract(pure = true)
+    public <T1, T2, T3> Cffu<Tuple3<T1, T2, T3>> mostTupleOfSuccess(
+            long timeout, TimeUnit unit,
+            CompletionStage<? extends T1> cf1, CompletionStage<? extends T2> cf2, CompletionStage<? extends T3> cf3) {
+        return new0(CompletableFutureUtils.mostTupleOfSuccess(timeout, unit, cf1, cf2, cf3));
+    }
+
+    /**
+     * Returns a new Cffu with the most results in the <strong>same order</strong> of
+     * the given four stages in the given time({@code timeout}), aka as many results as possible in the given time.
+     * <p>
+     * If the given stage is successful, its result is the completed value; Otherwise the value {@code null}.
+     *
+     * @param timeout how long to wait in units of {@code unit}
+     * @param unit    a {@code TimeUnit} determining how to interpret the {@code timeout} parameter
+     * @return a new Cffu that is completed when the given four stages complete
+     * @see #mostResultsOfSuccess(long, TimeUnit, Object, CompletionStage[])
+     * @see Cffu#getSuccessNow(Object)
+     */
+    @Contract(pure = true)
+    public <T1, T2, T3, T4> Cffu<Tuple4<T1, T2, T3, T4>> mostTupleOfSuccess(
+            long timeout, TimeUnit unit,
+            CompletionStage<? extends T1> cf1, CompletionStage<? extends T2> cf2,
+            CompletionStage<? extends T3> cf3, CompletionStage<? extends T4> cf4) {
+        return new0(CompletableFutureUtils.mostTupleOfSuccess(timeout, unit, cf1, cf2, cf3, cf4));
+    }
+
+    /**
+     * Returns a new Cffu with the most results in the <strong>same order</strong> of
+     * the given five stages in the given time({@code timeout}), aka as many results as possible in the given time.
+     * <p>
+     * If the given stage is successful, its result is the completed value; Otherwise the value {@code null}.
+     *
+     * @param timeout how long to wait in units of {@code unit}
+     * @param unit    a {@code TimeUnit} determining how to interpret the {@code timeout} parameter
+     * @return a new Cffu that is completed when the given five stages complete
+     * @see #mostResultsOfSuccess(long, TimeUnit, Object, CompletionStage[])
+     * @see Cffu#getSuccessNow(Object)
+     */
+    @Contract(pure = true)
+    public <T1, T2, T3, T4, T5> Cffu<Tuple5<T1, T2, T3, T4, T5>> mostTupleOfSuccess(
+            long timeout, TimeUnit unit,
+            CompletionStage<? extends T1> cf1, CompletionStage<? extends T2> cf2, CompletionStage<? extends T3> cf3,
+            CompletionStage<? extends T4> cf4, CompletionStage<? extends T5> cf5) {
+        return new0(CompletableFutureUtils.mostTupleOfSuccess(timeout, unit, cf1, cf2, cf3, cf4, cf5));
+    }
+
     ////////////////////////////////////////////////////////////////////////////////
     //# Delay Execution, equivalent to same name static methods of CompletableFuture
     //
diff --git a/cffu-core/src/main/java/io/foldright/cffu/CompletableFutureUtils.java b/cffu-core/src/main/java/io/foldright/cffu/CompletableFutureUtils.java
index 66885aaa..fc4ee004 100644
--- a/cffu-core/src/main/java/io/foldright/cffu/CompletableFutureUtils.java
+++ b/cffu-core/src/main/java/io/foldright/cffu/CompletableFutureUtils.java
@@ -190,7 +190,6 @@ public static <T> CompletableFuture<List<T>> allResultsOfFastFail(CompletionStag
      * the given stages in the given time({@code timeout}), aka as many results as possible in the given time.
      * <p>
      * If the given stage is successful, its result is the completed value; Otherwise the given valueIfNotSuccess.
-     * (aka the result extraction logic is {@link #getSuccessNow(CompletableFuture, Object)}).
      *
      * @param timeout           how long to wait in units of {@code unit}
      * @param unit              a {@code TimeUnit} determining how to interpret the {@code timeout} parameter
@@ -198,7 +197,6 @@ public static <T> CompletableFuture<List<T>> allResultsOfFastFail(CompletionStag
      * @param cfs               the stages
      * @see #getSuccessNow(CompletableFuture, Object)
      */
-    // * @see #MGetSuccessNow(Object, CompletionStage[])
     @Contract(pure = true)
     @SafeVarargs
     public static <T> CompletableFuture<List<T>> mostResultsOfSuccess(
@@ -208,14 +206,34 @@ public static <T> CompletableFuture<List<T>> mostResultsOfSuccess(
 
         if (cfs.length == 0) return CompletableFuture.completedFuture(arrayList());
         if (cfs.length == 1) {
+            // defensive copy input cf in order to
+            // avoid writing it by `completeOnTimeout` and read its result(`getSuccessNow`)
             final CompletableFuture<T> f = toCfCopy(cfs[0]);
-            return orTimeout(f, timeout, unit).handle((unused, ex) -> arrayList(getSuccessNow(f, valueIfNotSuccess)));
+            return orTimeout(f, timeout, unit)
+                    .handle((unused, ex) -> arrayList(getSuccessNow(f, valueIfNotSuccess)));
         }
 
-        // MUST be Non-Minimal CF instances in order to read results, otherwise UnsupportedOperationException
+        // MUST be *Non-Minimal* CF instances in order to read results(`getSuccessNow`),
+        // otherwise UnsupportedOperationException
         final CompletableFuture<T>[] cfArray = f_toNonMinCfArray(cfs);
         return orTimeout(CompletableFuture.allOf(cfArray), timeout, unit)
-                .handle((unused, ex) -> MGetSuccessNow(valueIfNotSuccess, cfArray));
+                .handle((unused, ex) -> arrayList(MGetSuccessNow0(valueIfNotSuccess, cfArray)));
+    }
+
+    /**
+     * Multi-Gets(MGet) the results in the <strong>same order</strong> of the given cfs,
+     * use the result value if the given stage is completed successfully, else use the given valueIfNotSuccess
+     *
+     * @param cfs MUST be *Non-Minimal* CF instances in order to read results(`getSuccessNow`),
+     *            otherwise UnsupportedOperationException
+     */
+    @SuppressWarnings("unchecked")
+    private static <T> T[] MGetSuccessNow0(@Nullable Object valueIfNotSuccess, CompletableFuture<?>... cfs) {
+        Object[] ret = new Object[cfs.length];
+        for (int i = 0; i < cfs.length; i++) {
+            ret[i] = getSuccessNow(cfs[i], valueIfNotSuccess);
+        }
+        return (T[]) ret;
     }
 
     @SafeVarargs
@@ -396,6 +414,7 @@ public static <T> CompletableFuture<T> anyOfSuccess(CompletionStage<? extends T>
         requireCfsAndEleNonNull(cfs);
         final int size = cfs.length;
         if (size == 0) return failedFuture(new NoCfsProvidedException());
+        // defensive copy input cf to avoid writing it unexpectedly it by caller code
         if (size == 1) return toCfCopy(cfs[0]);
 
         // NOTE: fill ONE MORE element of successOrBeIncompleteCfs LATER
@@ -412,7 +431,7 @@ public static <T> CompletableFuture<T> anyOfSuccess(CompletionStage<? extends T>
     }
 
     ////////////////////////////////////////////////////////////////////////////////
-    //# allTupleOf* methods
+    //# allTupleOf*/mostTupleOfSuccess methods
     ////////////////////////////////////////////////////////////////////////////////
 
     /**
@@ -552,16 +571,14 @@ public static <T1, T2, T3, T4, T5> CompletableFuture<Tuple5<T1, T2, T3, T4, T5>>
     }
 
     private static <T> CompletableFuture<T> allTupleOf0(CompletionStage<?>[] css, boolean fastFail) {
-        final int length = css.length;
-        final Object[] result = new Object[length];
+        final Object[] result = new Object[css.length];
         final CompletableFuture<Void>[] resultSetterCfs = createResultSetterCfs(css, result);
 
         final CompletableFuture<Void> resultSetter;
         if (fastFail) resultSetter = allOfFastFail(resultSetterCfs);
         else resultSetter = CompletableFuture.allOf(resultSetterCfs);
 
-        final CompletableFuture<Object> ret = resultSetter.thenApply(unused -> tupleOf0(result));
-        return f_cast(ret);
+        return resultSetter.thenApply(unused -> tupleOf0(result));
     }
 
     @SuppressWarnings("unchecked")
@@ -575,6 +592,93 @@ private static <T> T tupleOf0(Object... elements) {
         return (T) ret;
     }
 
+    /**
+     * Returns a new CompletableFuture with the most results in the <strong>same order</strong> of
+     * the given two stages in the given time({@code timeout}), aka as many results as possible in the given time.
+     * <p>
+     * If the given stage is successful, its result is the completed value; Otherwise the value {@code null}.
+     *
+     * @param timeout how long to wait in units of {@code unit}
+     * @param unit    a {@code TimeUnit} determining how to interpret the {@code timeout} parameter
+     * @return a new CompletableFuture that is completed when the given two stages complete
+     * @see #mostResultsOfSuccess(long, TimeUnit, Object, CompletionStage[])
+     * @see #getSuccessNow(CompletableFuture, Object)
+     */
+    @Contract(pure = true)
+    public static <T1, T2> CompletableFuture<Tuple2<T1, T2>> mostTupleOfSuccess(
+            long timeout, TimeUnit unit, CompletionStage<? extends T1> cf1, CompletionStage<? extends T2> cf2) {
+        return mostTupleOfSuccess0(timeout, unit, requireCfsAndEleNonNull(cf1, cf2));
+    }
+
+    /**
+     * Returns a new CompletableFuture with the most results in the <strong>same order</strong> of
+     * the given three stages in the given time({@code timeout}), aka as many results as possible in the given time.
+     * <p>
+     * If the given stage is successful, its result is the completed value; Otherwise the value {@code null}.
+     *
+     * @param timeout how long to wait in units of {@code unit}
+     * @param unit    a {@code TimeUnit} determining how to interpret the {@code timeout} parameter
+     * @return a new CompletableFuture that is completed when the given three stages complete
+     * @see #mostResultsOfSuccess(long, TimeUnit, Object, CompletionStage[])
+     * @see #getSuccessNow(CompletableFuture, Object)
+     */
+    @Contract(pure = true)
+    public static <T1, T2, T3> CompletableFuture<Tuple3<T1, T2, T3>> mostTupleOfSuccess(
+            long timeout, TimeUnit unit,
+            CompletionStage<? extends T1> cf1, CompletionStage<? extends T2> cf2, CompletionStage<? extends T3> cf3) {
+        return mostTupleOfSuccess0(timeout, unit, requireCfsAndEleNonNull(cf1, cf2, cf3));
+    }
+
+    /**
+     * Returns a new CompletableFuture with the most results in the <strong>same order</strong> of
+     * the given four stages in the given time({@code timeout}), aka as many results as possible in the given time.
+     * <p>
+     * If the given stage is successful, its result is the completed value; Otherwise the value {@code null}.
+     *
+     * @param timeout how long to wait in units of {@code unit}
+     * @param unit    a {@code TimeUnit} determining how to interpret the {@code timeout} parameter
+     * @return a new CompletableFuture that is completed when the given four stages complete
+     * @see #mostResultsOfSuccess(long, TimeUnit, Object, CompletionStage[])
+     * @see #getSuccessNow(CompletableFuture, Object)
+     */
+    @Contract(pure = true)
+    public static <T1, T2, T3, T4> CompletableFuture<Tuple4<T1, T2, T3, T4>> mostTupleOfSuccess(
+            long timeout, TimeUnit unit,
+            CompletionStage<? extends T1> cf1, CompletionStage<? extends T2> cf2,
+            CompletionStage<? extends T3> cf3, CompletionStage<? extends T4> cf4) {
+        return mostTupleOfSuccess0(timeout, unit, requireCfsAndEleNonNull(cf1, cf2, cf3, cf4));
+    }
+
+    /**
+     * Returns a new CompletableFuture with the most results in the <strong>same order</strong> of
+     * the given five stages in the given time({@code timeout}), aka as many results as possible in the given time.
+     * <p>
+     * If the given stage is successful, its result is the completed value; Otherwise the value {@code null}.
+     *
+     * @param timeout how long to wait in units of {@code unit}
+     * @param unit    a {@code TimeUnit} determining how to interpret the {@code timeout} parameter
+     * @return a new CompletableFuture that is completed when the given five stages complete
+     * @see #mostResultsOfSuccess(long, TimeUnit, Object, CompletionStage[])
+     * @see #getSuccessNow(CompletableFuture, Object)
+     */
+    @Contract(pure = true)
+    public static <T1, T2, T3, T4, T5> CompletableFuture<Tuple5<T1, T2, T3, T4, T5>> mostTupleOfSuccess(
+            long timeout, TimeUnit unit,
+            CompletionStage<? extends T1> cf1, CompletionStage<? extends T2> cf2, CompletionStage<? extends T3> cf3,
+            CompletionStage<? extends T4> cf4, CompletionStage<? extends T5> cf5) {
+        return mostTupleOfSuccess0(timeout, unit, requireCfsAndEleNonNull(cf1, cf2, cf3, cf4, cf5));
+    }
+
+    private static <T> CompletableFuture<T> mostTupleOfSuccess0(
+            long timeout, TimeUnit unit, CompletionStage<?>[] css) {
+        requireNonNull(unit, "unit is null");
+        // MUST be *Non-Minimal* CF instances in order to read results(`getSuccessNow`),
+        // otherwise UnsupportedOperationException
+        final CompletableFuture<Object>[] cfArray = f_toNonMinCfArray(css);
+        return orTimeout(CompletableFuture.allOf(cfArray), timeout, unit)
+                .handle((unused, ex) -> tupleOf0(MGetSuccessNow0(null, cfArray)));
+    }
+
     ////////////////////////////////////////////////////////////////////////////////
     //# `then both(binary input)` methods with fast-fail support:
     //
@@ -1375,6 +1479,7 @@ C exceptionallyComposeAsync(C cf, Function<Throwable, ? extends CompletionStage<
     @Nullable
     public static <T> T join(CompletableFuture<T> cf, long timeout, TimeUnit unit) {
         if (cf.isDone()) return cf.join();
+        // defensive copy input cf to avoid writing it by `orTimeout`
         return orTimeout(copy(cf), timeout, unit).join();
     }
 
@@ -1387,7 +1492,6 @@ public static <T> T join(CompletableFuture<T> cf, long timeout, TimeUnit unit) {
      * @param valueIfNotSuccess the value to return if not completed successfully
      * @return the result value, if completed successfully, else the given valueIfNotSuccess
      */
-    // * @see #MGetSuccessNow(Object, CompletionStage[])
     @Contract(pure = true)
     @Nullable
     public static <T> T getSuccessNow(CompletableFuture<? extends T> cf, @Nullable T valueIfNotSuccess) {
@@ -1511,82 +1615,6 @@ public static CffuState state(CompletableFuture<?> cf) {
         }
     }
 
-    //# New enhanced multi-read(explicitly) methods
-
-    /**
-     * Multi-Gets(MGet) the results in the <strong>same order</strong> of the given cfs,
-     * use the result value if the given stage is completed successfully, else use the given valueIfNotSuccess
-     * (aka the result extraction logic is {@link #getSuccessNow(CompletableFuture, Object)}).
-     *
-     * @param cfs the stages
-     * @see #mostResultsOfSuccess(long, TimeUnit, Object, CompletionStage[])
-     * @see #getSuccessNow(CompletableFuture, Object)
-     */
-    @Contract(pure = true)
-    @SafeVarargs
-    static <T> List<T> MGetSuccessNow(@Nullable T valueIfNotSuccess, CompletionStage<? extends T>... cfs) {
-        return arrayList(MGet0(cf -> getSuccessNow(cf, valueIfNotSuccess), cfs));
-    }
-
-    @SafeVarargs
-    @SuppressWarnings("unchecked")
-    private static <T> T[] MGet0(Function<CompletableFuture<T>, ? extends T> resultGetter,
-                                 CompletionStage<? extends T>... cfs) {
-        final CompletableFuture<T>[] cfArray = f_toCfArray(cfs);
-        Object[] ret = new Object[cfs.length];
-        for (int i = 0; i < cfArray.length; i++) {
-            CompletableFuture<T> cf = cfArray[i];
-            ret[i] = resultGetter.apply(cf);
-        }
-        return (T[]) ret;
-    }
-
-    /**
-     * Multi-Gets(MGet) the result value in the <strong>same order</strong> of the given cfs,
-     * use the result value if the cf is completed successfully, else use the value {@code null}
-     * (aka the result extraction logic is {@code getSuccessNow(cf, null)}).
-     */
-    static <T1, T2> Tuple2<T1, T2> tupleGetSuccessNow(
-            CompletionStage<? extends T1> cf1, CompletionStage<? extends T2> cf2) {
-        return tupleGet0(requireCfsAndEleNonNull(cf1, cf2));
-    }
-
-    /**
-     * Multi-Gets(MGet) the result value in the <strong>same order</strong> of the given cfs,
-     * use the result value if the cf is completed successfully, else use the value {@code null}
-     * (aka the result extraction logic is {@code getSuccessNow(cf, null)}).
-     */
-    static <T1, T2, T3> Tuple3<T1, T2, T3> tupleGetSuccessNow(
-            CompletionStage<? extends T1> cf1, CompletionStage<? extends T2> cf2, CompletionStage<? extends T3> cf3) {
-        return tupleGet0(requireCfsAndEleNonNull(cf1, cf2, cf3));
-    }
-
-    /**
-     * Multi-Gets(MGet) the result value in the <strong>same order</strong> of the given cfs,
-     * use the result value if the cf is completed successfully, else use the value {@code null}
-     * (aka the result extraction logic is {@code getSuccessNow(cf, null)}).
-     */
-    static <T1, T2, T3, T4> Tuple4<T1, T2, T3, T4> tupleGetSuccessNow(
-            CompletionStage<? extends T1> cf1, CompletionStage<? extends T2> cf2,
-            CompletionStage<? extends T3> cf3, CompletionStage<? extends T4> cf4) {
-        return tupleGet0(requireCfsAndEleNonNull(cf1, cf2, cf3, cf4));
-    }
-
-    /**
-     * Multi-Gets(MGet) the result value in the <strong>same order</strong> of the given cfs,
-     * use the result value if the cf is completed successfully, else the value {@code null}
-     * (aka the result extraction logic is {@code getSuccessNow(cf, null)}).
-     */
-    static <T1, T2, T3, T4, T5> Tuple5<T1, T2, T3, T4, T5> tupleGetSuccessNow(
-            CompletionStage<? extends T1> cf1, CompletionStage<? extends T2> cf2, CompletionStage<? extends T3> cf3,
-            CompletionStage<? extends T4> cf4, CompletionStage<? extends T5> cf5) {
-        return tupleGet0(requireCfsAndEleNonNull(cf1, cf2, cf3, cf4, cf5));
-    }
-
-    private static <T> T tupleGet0(CompletionStage<?>... css) {
-        return tupleOf0(MGet0(cf -> getSuccessNow(cf, null), css));
-    }
-
     //# Write methods of CompletableFuture
 
     /**
diff --git a/cffu-core/src/test/java/io/foldright/cffu/CompletableFutureUtilsTest.java b/cffu-core/src/test/java/io/foldright/cffu/CompletableFutureUtilsTest.java
index 5f884be3..67cd2b77 100644
--- a/cffu-core/src/test/java/io/foldright/cffu/CompletableFutureUtilsTest.java
+++ b/cffu-core/src/test/java/io/foldright/cffu/CompletableFutureUtilsTest.java
@@ -323,11 +323,23 @@ void test_mostOf() throws Exception {
         final CompletableFuture<Integer> cancelled = createCancelledFuture();
         final CompletableFuture<Integer> incomplete = createIncompleteFuture();
 
+        // 0 input cf
         assertEquals(0, mostResultsOfSuccess(10, TimeUnit.MILLISECONDS, null).get().size());
 
+        // 1 input cf
         assertEquals(Collections.singletonList(n), mostResultsOfSuccess(
                 10, TimeUnit.MILLISECONDS, null, completed).get());
+        assertEquals(Collections.singletonList(n), mostResultsOfSuccess(
+                10, TimeUnit.MILLISECONDS, anotherN, completed).get());
+
+        assertEquals(Collections.singletonList(anotherN), mostResultsOfSuccess(
+                10, TimeUnit.MILLISECONDS, anotherN, failed).get());
+        assertEquals(Collections.singletonList(anotherN), mostResultsOfSuccess(
+                10, TimeUnit.MILLISECONDS, anotherN, cancelled).get());
+        assertEquals(Collections.singletonList(anotherN), mostResultsOfSuccess(
+                10, TimeUnit.MILLISECONDS, anotherN, incomplete).get());
 
+        // more input cf
         assertEquals(Arrays.asList(n, null, null, null), mostResultsOfSuccess(
                 10, TimeUnit.MILLISECONDS, null, completed, failed, cancelled, incomplete
         ).get());
@@ -689,6 +701,40 @@ void test_allTupleOf_NotFastFail() throws Exception {
         }
     }
 
+    @Test
+    void test_mostTupleOfSuccess() throws Exception {
+        final CompletableFuture<Integer> completed = completedFuture(n);
+        final CompletableFuture<String> anotherCompleted = completedFuture(s);
+        final CompletableFuture<Integer> failed = failedFuture(rte);
+        final CompletableFuture<Integer> cancelled = createCancelledFuture();
+        final CompletableFuture<Integer> incomplete = createIncompleteFuture();
+
+        assertEquals(Tuple2.of(n, s), mostTupleOfSuccess(
+                10, TimeUnit.MILLISECONDS, completed, anotherCompleted
+        ).get());
+        assertEquals(Tuple2.of(n, null), mostTupleOfSuccess(
+                10, TimeUnit.MILLISECONDS, completed, failed
+        ).get());
+
+        assertEquals(Tuple3.of(n, s, null), mostTupleOfSuccess(
+                10, TimeUnit.MILLISECONDS, completed, anotherCompleted, cancelled
+        ).get());
+        assertEquals(Tuple3.of(null, null, s), mostTupleOfSuccess(
+                10, TimeUnit.MILLISECONDS, incomplete, failed, anotherCompleted
+        ).get());
+
+        assertEquals(Tuple4.of(n, s, null, null), mostTupleOfSuccess(
+                10, TimeUnit.MILLISECONDS, completed, anotherCompleted, cancelled, incomplete
+        ).get());
+        assertEquals(Tuple4.of(null, null, null, null), mostTupleOfSuccess(
+                10, TimeUnit.MILLISECONDS, incomplete, failed, cancelled, incomplete
+        ).get());
+
+        assertEquals(Tuple5.of(null, n, s, null, null), mostTupleOfSuccess(
+                10, TimeUnit.MILLISECONDS, cancelled, completed, anotherCompleted, incomplete, failed
+        ).get());
+    }
+
     ////////////////////////////////////////////////////////////////////////////////
     //# both methods
     ////////////////////////////////////////////////////////////////////////////////
@@ -1012,24 +1058,6 @@ void test_read() {
         assertEquals(n, join(later, 3, TimeUnit.SECONDS));
     }
 
-    @Test
-    void test_gets() {
-        final CompletableFuture<Integer> completed = completedFuture(n);
-        final CompletableFuture<Integer> failed = failedFuture(rte);
-        final CompletableFuture<Integer> cancelled = createCancelledFuture();
-        final CompletableFuture<Integer> incomplete = createIncompleteFuture();
-
-        assertEquals(Arrays.asList(n, anotherN, anotherN, anotherN),
-                MGetSuccessNow(anotherN, completed, incomplete, cancelled, failed));
-
-        assertEquals(Tuple2.of(n, null), tupleGetSuccessNow(completed, failed));
-        assertEquals(Tuple3.of(null, n, null), tupleGetSuccessNow(failed, completed, cancelled));
-        assertEquals(Tuple4.of(null, n, null, anotherN),
-                tupleGetSuccessNow(failed, completed, cancelled, completedFuture(anotherN)));
-        assertEquals(Tuple5.of(null, n, null, anotherN, null),
-                tupleGetSuccessNow(failed, completed, cancelled, completedFuture(anotherN), failed));
-    }
-
     @Test
     void test_write() throws Exception {
         assertEquals(n, completeAsync(createIncompleteFuture(), () -> n).get());
diff --git a/cffu-kotlin/src/main/java/io/foldright/cffu/kotlin/CffuExtensions.kt b/cffu-kotlin/src/main/java/io/foldright/cffu/kotlin/CffuExtensions.kt
index 12aa52fb..71dc93d6 100644
--- a/cffu-kotlin/src/main/java/io/foldright/cffu/kotlin/CffuExtensions.kt
+++ b/cffu-kotlin/src/main/java/io/foldright/cffu/kotlin/CffuExtensions.kt
@@ -395,16 +395,14 @@ fun Array<out CompletionStage<*>>.allOfFastFailCffu(cffuFactory: CffuFactory): C
  * the given Cffus in the given time(`timeout`), aka as many results as possible in the given time.
  *
  * If the given Cffu is successful, its result is the completed value; Otherwise the given valueIfNotSuccess.
- * (aka the result extraction logic is [Cffu.getSuccessNow]).
- *
- * The result extraction logic can be customized using another overloaded [mostResultsOfSuccessCffu] method.
  *
  * @param timeout       how long to wait in units of `unit`
  * @param unit          a `TimeUnit` determining how to interpret the `timeout` parameter
  * @param valueIfNotSuccess the value to return if not completed successfully
+ * @see CffuFactory.mostResultsOfSuccess
+ * @see CffuFactory.mostTupleOfSuccess
  * @see Cffu.getSuccessNow
  */
-// * @see CompletableFutureUtils.MGetSuccessNow
 fun <T> Collection<Cffu<out T>>.mostResultsOfSuccessCffu(
     timeout: Long, unit: TimeUnit, valueIfNotSuccess: T, cffuFactory: CffuFactory = ABSENT
 ): Cffu<List<T>> {
@@ -418,19 +416,19 @@ fun <T> Collection<Cffu<out T>>.mostResultsOfSuccessCffu(
  * the given Cffus in the given time(`timeout`), aka as many results as possible in the given time.
  *
  * If the given Cffu is successful, its result is the completed value; Otherwise the given valueIfNotSuccess.
- * (aka the result extraction logic is [Cffu.getSuccessNow]).
  *
  * @param timeout       how long to wait in units of `unit`
  * @param unit          a `TimeUnit` determining how to interpret the `timeout` parameter
  * @param valueIfNotSuccess the value to return if not completed successfully
+ * @see CffuFactory.mostResultsOfSuccess
+ * @see CffuFactory.mostTupleOfSuccess
  * @see Cffu.getSuccessNow
  */
-// * @see CompletableFutureUtils.MGetSuccessNow
 fun <T> Array<out Cffu<out T>>.mostResultsOfSuccessCffu(
     timeout: Long, unit: TimeUnit, valueIfNotSuccess: T, cffuFactory: CffuFactory = ABSENT
 ): Cffu<List<T>> {
     val factory: CffuFactory = if (cffuFactory !== ABSENT) cffuFactory
-    else firstOrNull()?.cffuFactory() ?: throw IllegalArgumentException(ERROR_MSG_FOR_COLL)
+    else firstOrNull()?.cffuFactory() ?: throw IllegalArgumentException(ERROR_MSG_FOR_ARRAY)
     return factory.mostResultsOfSuccess(timeout, unit, valueIfNotSuccess, *this)
 }
 
@@ -439,16 +437,14 @@ fun <T> Array<out Cffu<out T>>.mostResultsOfSuccessCffu(
  * the given stages in the given time(`timeout`), aka as many results as possible in the given time.
  *
  * If the given stage is successful, its result is the completed value; Otherwise the given valueIfNotSuccess.
- * (aka the result extraction logic is [Cffu.getSuccessNow]).
- *
- * The result extraction logic can be customized using another overloaded [mostResultsOfSuccessCffu] method.
  *
  * @param timeout       how long to wait in units of `unit`
  * @param unit          a `TimeUnit` determining how to interpret the `timeout` parameter
  * @param valueIfNotSuccess the value to return if not completed successfully
+ * @see CffuFactory.mostResultsOfSuccess
+ * @see CffuFactory.mostTupleOfSuccess
  * @see Cffu.getSuccessNow
  */
-// * @see CompletableFutureUtils.MGetSuccessNow
 @JvmName("mostResultsOfSuccessCffuCs")
 fun <T> Collection<CompletionStage<out T>>.mostResultsOfSuccessCffu(
     timeout: Long, unit: TimeUnit, valueIfNotSuccess: T, cffuFactory: CffuFactory
@@ -465,9 +461,10 @@ fun <T> Collection<CompletionStage<out T>>.mostResultsOfSuccessCffu(
  * @param timeout       how long to wait in units of `unit`
  * @param unit          a `TimeUnit` determining how to interpret the `timeout` parameter
  * @param valueIfNotSuccess the value to return if not completed successfully
+ * @see CffuFactory.mostResultsOfSuccess
+ * @see CffuFactory.mostTupleOfSuccess
  * @see Cffu.getSuccessNow
  */
-// * @see CompletableFutureUtils.MGetSuccessNow
 fun <T> Array<out CompletionStage<out T>>.mostResultsOfSuccessCffu(
     timeout: Long, unit: TimeUnit, valueIfNotSuccess: T, cffuFactory: CffuFactory
 ): Cffu<List<T>> =
diff --git a/cffu-kotlin/src/main/java/io/foldright/cffu/kotlin/CompletableFutureExtensions.kt b/cffu-kotlin/src/main/java/io/foldright/cffu/kotlin/CompletableFutureExtensions.kt
index f4b33ef6..70ab2c13 100644
--- a/cffu-kotlin/src/main/java/io/foldright/cffu/kotlin/CompletableFutureExtensions.kt
+++ b/cffu-kotlin/src/main/java/io/foldright/cffu/kotlin/CompletableFutureExtensions.kt
@@ -212,14 +212,14 @@ fun <T> Array<out CompletionStage<out T>>.allResultsOfFastFailCompletableFuture(
  * the given stages in the given time(`timeout`), aka as many results as possible in the given time.
  *
  * If the given stage is successful, its result is the completed value; Otherwise the given valueIfNotSuccess.
- * (aka the result extraction logic is [getSuccessNow]).
  *
  * @param timeout       how long to wait in units of `unit`
  * @param unit          a `TimeUnit` determining how to interpret the `timeout` parameter
  * @param valueIfNotSuccess the value to return if not completed successfully
+ * @see CompletableFutureUtils.mostResultsOfSuccess
+ * @see CompletableFutureUtils.mostTupleOfSuccess
  * @see getSuccessNow
  */
-// * @see CompletableFutureUtils.MGetSuccessNow
 fun <T> Collection<CompletionStage<out T>>.mostResultsOfSuccessCompletableFuture(
     timeout: Long, unit: TimeUnit, valueIfNotSuccess: T
 ): CompletableFuture<List<T>> =
@@ -230,14 +230,14 @@ fun <T> Collection<CompletionStage<out T>>.mostResultsOfSuccessCompletableFuture
  * the given stages in the given time(`timeout`), aka as many results as possible in the given time.
  *
  * If the given stage is successful, its result is the completed value; Otherwise the given valueIfNotSuccess.
- * (aka the result extraction logic is [getSuccessNow]).
  *
  * @param timeout       how long to wait in units of `unit`
  * @param unit          a `TimeUnit` determining how to interpret the `timeout` parameter
  * @param valueIfNotSuccess the value to return if not completed successfully
+ * @see CompletableFutureUtils.mostResultsOfSuccess
+ * @see CompletableFutureUtils.mostTupleOfSuccess
  * @see getSuccessNow
  */
-// * @see CompletableFutureUtils.MGetSuccessNow
 fun <T> Array<out CompletionStage<out T>>.mostResultsOfSuccessCompletableFuture(
     timeout: Long, unit: TimeUnit, valueIfNotSuccess: T
 ): CompletableFuture<List<T>> =
@@ -486,6 +486,7 @@ fun <T, U, V> CompletionStage<out T>.thenCombineFastFailAsync(
 //
 //  - allTupleOf
 //  - allTupleOfFastFail
+//  - mostTupleOfSuccess
 ////////////////////////////////////////
 
 /**
@@ -618,6 +619,79 @@ fun <T1, T2, T3, T4, T5> CompletionStage<out T1>.allTupleOfFastFail(
 ): CompletableFuture<Tuple5<T1, T2, T3, T4, T5>> =
     CompletableFutureUtils.allTupleOfFastFail(this, cf2, cf3, cf4, cf5)
 
+/**
+ * Returns a new CompletableFuture with the most results in the **same order** of
+ * the given two stages in the given time(`timeout`), aka as many results as possible in the given time.
+ *
+ * If the given stage is successful, its result is the completed value; Otherwise the value `null`.
+ *
+ * @param timeout how long to wait in units of `unit`
+ * @param unit    a `TimeUnit` determining how to interpret the `timeout` parameter
+ * @return a new CompletableFuture that is completed when the given two stages complete
+ * @see mostResultsOfSuccessCompletableFuture
+ * @see getSuccessNow
+ */
+fun <T1, T2> mostTupleOfSuccess(
+    timeout: Long, unit: TimeUnit, cf1: CompletionStage<out T1>, cf2: CompletionStage<out T2>
+): CompletableFuture<Tuple2<T1?, T2?>> =
+    CompletableFutureUtils.mostTupleOfSuccess(timeout, unit, cf1, cf2)
+
+/**
+ * Returns a new CompletableFuture with the most results in the **same order** of
+ * the given three stages in the given time(`timeout`), aka as many results as possible in the given time.
+ *
+ * If the given stage is successful, its result is the completed value; Otherwise the value `null`.
+ *
+ * @param timeout how long to wait in units of `unit`
+ * @param unit    a `TimeUnit` determining how to interpret the `timeout` parameter
+ * @return a new CompletableFuture that is completed when the given three stages complete
+ * @see mostResultsOfSuccessCompletableFuture
+ * @see getSuccessNow
+ */
+fun <T1, T2, T3> mostTupleOfSuccess(
+    timeout: Long, unit: TimeUnit,
+    cf1: CompletionStage<out T1>, cf2: CompletionStage<out T2>, cf3: CompletionStage<out T3>
+): CompletableFuture<Tuple3<T1?, T2?, T3?>> =
+    CompletableFutureUtils.mostTupleOfSuccess(timeout, unit, cf1, cf2, cf3)
+
+/**
+ * Returns a new CompletableFuture with the most results in the **same order** of
+ * the given four stages in the given time(`timeout`), aka as many results as possible in the given time.
+ *
+ * If the given stage is successful, its result is the completed value; Otherwise the value `null`.
+ *
+ * @param timeout how long to wait in units of `unit`
+ * @param unit    a `TimeUnit` determining how to interpret the `timeout` parameter
+ * @return a new CompletableFuture that is completed when the given four stages complete
+ * @see mostResultsOfSuccessCompletableFuture
+ * @see getSuccessNow
+ */
+fun <T1, T2, T3, T4> mostTupleOfSuccess(
+    timeout: Long, unit: TimeUnit,
+    cf1: CompletionStage<out T1>, cf2: CompletionStage<out T2>,
+    cf3: CompletionStage<out T3>, cf4: CompletionStage<out T4>
+): CompletableFuture<Tuple4<T1?, T2?, T3?, T4?>> =
+    CompletableFutureUtils.mostTupleOfSuccess(timeout, unit, cf1, cf2, cf3, cf4)
+
+/**
+ * Returns a new CompletableFuture with the most results in the **same order** of
+ * the given five stages in the given time(`timeout`), aka as many results as possible in the given time.
+ *
+ * If the given stage is successful, its result is the completed value; Otherwise the value `null`.
+ *
+ * @param timeout how long to wait in units of `unit`
+ * @param unit    a `TimeUnit` determining how to interpret the `timeout` parameter
+ * @return a new CompletableFuture that is completed when the given five stages complete
+ * @see mostResultsOfSuccessCompletableFuture
+ * @see getSuccessNow
+ */
+fun <T1, T2, T3, T4, T5> mostTupleOfSuccess(
+    timeout: Long, unit: TimeUnit,
+    cf1: CompletionStage<out T1>, cf2: CompletionStage<out T2>, cf3: CompletionStage<out T3>,
+    cf4: CompletionStage<out T4>, cf5: CompletionStage<out T5>
+): CompletableFuture<Tuple5<T1?, T2?, T3?, T4?, T5?>> =
+    CompletableFutureUtils.mostTupleOfSuccess(timeout, unit, cf1, cf2, cf3, cf4, cf5)
+
 ////////////////////////////////////////////////////////////////////////////////
 //# `then either(binary input)` methods with either(any)-success support:
 //