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 d3240bfd..2e5a87c5 100644
--- a/cffu-core/src/main/java/io/foldright/cffu/CffuFactory.java
+++ b/cffu-core/src/main/java/io/foldright/cffu/CffuFactory.java
@@ -14,6 +14,7 @@
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 import java.util.function.Supplier;
 
 import static java.util.Objects.requireNonNull;
@@ -546,6 +547,271 @@ public <T1, T2, T3, T4, T5> Cffu<Tuple5<T1, T2, T3, T4, T5>> mostTupleOfSuccess(
         return create(CompletableFutureUtils.mostTupleOfSuccess(defaultExecutor, timeout, unit, cf1, cf2, cf3, cf4, cf5));
     }
 
+    /**
+     * Returns a new Cffu that is successful when the given three stages success.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so
+     * *without* waiting other incomplete given stages, with a CompletionException holding this exception as its cause.
+     * <p>
+     * This method is the same as {@link #allTupleOfMSupplyAsync(Supplier, Supplier)}
+     * except for the fast-fail behavior.
+     *
+     * @return a new Cffu that is successful when the given three stages success
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOfFastFail(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T1, T2> Cffu<Tuple2<T1, T2>> allTupleOfMSupplyFastFailAsync(
+            Supplier<? extends T1> supplier1, Supplier<? extends T2> supplier2) {
+        return create(CompletableFutureUtils.allTupleOfMSupplyFastFailAsync(supplier1, supplier2));
+    }
+
+    /**
+     * Returns a new Cffu that is completed when the given three stages complete.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so,
+     * with a CompletionException holding this exception as its cause.
+     *
+     * @return a new Cffu that is completed when the given three stages complete
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOf(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T1, T2> Cffu<Tuple2<T1, T2>> allTupleOfMSupplyAsync(
+            Supplier<? extends T1> supplier1, Supplier<? extends T2> supplier2) {
+        return create(CompletableFutureUtils.allTupleOfMSupplyAsync(supplier1, supplier2));
+    }
+
+    /**
+     * Returns a new Cffu that is successful when the given three stages success.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so
+     * *without* waiting other incomplete given stages, with a CompletionException holding this exception as its cause.
+     * <p>
+     * This method is the same as {@link #allTupleOfMSupplyAsync(Supplier, Supplier, Supplier)}
+     * except for the fast-fail behavior.
+     *
+     * @return a new Cffu that is successful when the given three stages success
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOfFastFail(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T1, T2,T3> Cffu<Tuple3<T1, T2,T3>> allTupleOfMSupplyFastFailAsync(
+            Supplier<? extends T1> supplier1, Supplier<? extends T2> supplier2, Supplier<? extends T3> supplier3) {
+        return create(CompletableFutureUtils.allTupleOfMSupplyFastFailAsync(supplier1, supplier2,supplier3));
+    }
+
+    /**
+     * Returns a new Cffu that is completed when the given three stages complete.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so,
+     * with a CompletionException holding this exception as its cause.
+     *
+     * @return a new Cffu that is completed when the given three stages complete
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOf(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T1, T2,T3> Cffu<Tuple3<T1,T2,T3>> allTupleOfMSupplyAsync(
+            Supplier<? extends T1> supplier1, Supplier<? extends T2> supplier2, Supplier<? extends T3> supplier3) {
+        return create(CompletableFutureUtils.allTupleOfMSupplyAsync(supplier1, supplier2,supplier3));
+    }
+
+    /**
+     * Returns a new Cffu that is successful when the given three stages success.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so
+     * *without* waiting other incomplete given stages, with a CompletionException holding this exception as its cause.
+     * <p>
+     * This method is the same as {@link #allTupleOfMSupplyAsync(Supplier, Supplier, Supplier, Supplier)}
+     * except for the fast-fail behavior.
+     *
+     * @return a new Cffu that is successful when the given three stages success
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOfFastFail(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T1, T2,T3,T4> Cffu<Tuple4<T1, T2,T3,T4>> allTupleOfMSupplyFastFailAsync(
+            Supplier<? extends T1> supplier1, Supplier<? extends T2> supplier2, Supplier<? extends T3> supplier3, Supplier<? extends T4> supplier4) {
+        return create(CompletableFutureUtils.allTupleOfMSupplyFastFailAsync(supplier1, supplier2,supplier3,supplier4));
+    }
+
+    /**
+     * Returns a new Cffu that is completed when the given three stages complete.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so,
+     * with a CompletionException holding this exception as its cause.
+     *
+     * @return a new Cffu that is completed when the given three stages complete
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOf(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T1, T2,T3,T4> Cffu<Tuple4<T1,T2,T3,T4>> allTupleOfMSupplyAsync(
+            Supplier<? extends T1> supplier1, Supplier<? extends T2> supplier2, Supplier<? extends T3> supplier3, Supplier<? extends T4> supplier4) {
+        return create(CompletableFutureUtils.allTupleOfMSupplyAsync(supplier1,supplier2,supplier3,supplier4));
+    }
+
+
+    /**
+     * Returns a new Cffu that is successful when the given three stages success.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so
+     * *without* waiting other incomplete given stages, with a CompletionException holding this exception as its cause.
+     * <p>
+     * This method is the same as {@link #allTupleOfMSupplyAsync(Supplier, Supplier, Supplier, Supplier, Supplier)}
+     * except for the fast-fail behavior.
+     *
+     * @return a new Cffu that is successful when the given three stages success
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOfFastFail(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T1, T2,T3,T4,T5> Cffu<Tuple5<T1, T2,T3,T4,T5>> allTupleOfMSupplyFastFailAsync(
+            Supplier<? extends T1> supplier1, Supplier<? extends T2> supplier2, Supplier<? extends T3> supplier3, Supplier<? extends T4> supplier4, Supplier<? extends T5> supplier5) {
+        return create(CompletableFutureUtils.allTupleOfMSupplyFastFailAsync(supplier1, supplier2,supplier3,supplier4,supplier5));
+    }
+
+    /**
+     * Returns a new Cffu that is completed when the given three stages complete.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so,
+     * with a CompletionException holding this exception as its cause.
+     *
+     * @return a new Cffu that is completed when the given three stages complete
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOf(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T1, T2,T3,T4,T5> Cffu<Tuple5<T1,T2,T3,T4,T5>> allTupleOfMSupplyAsync(
+            Supplier<? extends T1> supplier1, Supplier<? extends T2> supplier2, Supplier<? extends T3> supplier3, Supplier<? extends T4> supplier4, Supplier<? extends T5> supplier5) {
+        return create(CompletableFutureUtils.allTupleOfMSupplyAsync(supplier1,supplier2,supplier3,supplier4,supplier5));
+    }
+
+
+    /**
+     * Returns a new Cffu that is successful when the given three stages success.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so
+     * *without* waiting other incomplete given stages, with a CompletionException holding this exception as its cause.
+     * <p>
+     * This method is the same as {@link #allTupleOfThenMApplyAsync(CompletionStage,Function, Function)}
+     * except for the fast-fail behavior.
+     *
+     * @return a new Cffu that is successful when the given three stages success
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOfFastFail(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T,U1,U2> Cffu<Tuple2<U1, U2>> allTupleOfThenMApplyFastFailAsync(
+            CompletionStage<? extends T> cf, Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2) {
+        return create(CompletableFutureUtils.allTupleOfThenMApplyFastFailAsync(cf,function1, function2));
+    }
+    /**
+     * Returns a new Cffu that is successful when the given three stages success.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so
+     * *without* waiting other incomplete given stages, with a CompletionException holding this exception as its cause.
+     * <p>
+     * This method is the same as {@link #allTupleOfThenMApplyAsync(CompletionStage,Function, Function,Function)}
+     * except for the fast-fail behavior.
+     *
+     * @return a new Cffu that is successful when the given three stages success
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOfFastFail(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T,U1,U2,U3> Cffu<Tuple3<U1,U2,U3>> allTupleOfThenMApplyFastFailAsync(
+            CompletionStage<? extends T> cf, Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3) {
+        return create(CompletableFutureUtils.allTupleOfThenMApplyFastFailAsync(cf,function1, function2,function3));
+    }
+
+    /**
+     * Returns a new Cffu that is successful when the given three stages success.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so
+     * *without* waiting other incomplete given stages, with a CompletionException holding this exception as its cause.
+     * <p>
+     * This method is the same as {@link #allTupleOfThenMApplyAsync(CompletionStage,Function, Function,Function,Function)}
+     * except for the fast-fail behavior.
+     *
+     * @return a new Cffu that is successful when the given three stages success
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOfFastFail(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T,U1,U2,U3,U4> Cffu<Tuple4<U1,U2,U3,U4>> allTupleOfThenMApplyFastFailAsync(
+            CompletionStage<? extends T> cf, Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3,Function<? super T, ? extends U4> function4) {
+        return create(CompletableFutureUtils.allTupleOfThenMApplyFastFailAsync(cf,function1, function2,function3,function4));
+    }
+
+    /**
+     * Returns a new Cffu that is successful when the given three stages success.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so
+     * *without* waiting other incomplete given stages, with a CompletionException holding this exception as its cause.
+     * <p>
+     * This method is the same as {@link #allTupleOfThenMApplyAsync(CompletionStage,Function, Function,Function, Function,Function)}
+     * except for the fast-fail behavior.
+     *
+     * @return a new Cffu that is successful when the given three stages success
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOfFastFail(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T,U1,U2,U3,U4,U5> Cffu<Tuple5<U1,U2,U3,U4,U5>> allTupleOfThenMApplyFastFailAsync(
+            CompletionStage<? extends T> cf, Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3,Function<? super T, ? extends U4> function4,Function<? super T, ? extends U5> function5) {
+        return create(CompletableFutureUtils.allTupleOfThenMApplyFastFailAsync(cf,function1, function2,function3,function4,function5));
+    }
+
+    /**
+     * Returns a new Cffu that is completed when the given three stages complete.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so,
+     * with a CompletionException holding this exception as its cause.
+     *
+     * @return a new Cffu that is completed when the given three stages complete
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOf(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T,U1,U2> Cffu<Tuple2<U1, U2>> allTupleOfThenMApplyAsync(
+            CompletionStage<? extends T> cf,Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2) {
+        return create(CompletableFutureUtils.allTupleOfThenMApplyAsync(cf,function1, function2));
+    }
+
+    /**
+     * Returns a new Cffu that is completed when the given three stages complete.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so,
+     * with a CompletionException holding this exception as its cause.
+     *
+     * @return a new Cffu that is completed when the given three stages complete
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOf(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T,U1,U2,U3> Cffu<Tuple3<U1,U2,U3>> allTupleOfThenMApplyAsync(
+            CompletionStage<? extends T> cf,Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3) {
+        return create(CompletableFutureUtils.allTupleOfThenMApplyAsync(cf,function1, function2,function3));
+    }
+    /**
+     * Returns a new Cffu that is completed when the given three stages complete.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so,
+     * with a CompletionException holding this exception as its cause.
+     *
+     * @return a new Cffu that is completed when the given three stages complete
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOf(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T,U1,U2,U3,U4> Cffu<Tuple4<U1,U2,U3,U4>> allTupleOfThenMApplyAsync(
+            CompletionStage<? extends T> cf,Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3,Function<? super T, ? extends U4> function4) {
+        return create(CompletableFutureUtils.allTupleOfThenMApplyAsync(cf,function1, function2,function3,function4));
+    }
+
+    /**
+     * Returns a new Cffu that is completed when the given three stages complete.
+     * If any of the given stages complete exceptionally, then the returned Cffu also does so,
+     * with a CompletionException holding this exception as its cause.
+     *
+     * @return a new Cffu that is completed when the given three stages complete
+     * @throws NullPointerException if any of the given stages are {@code null}
+     * @see #allResultsOf(CompletionStage[])
+     */
+    @Contract(pure = true)
+    public <T,U1,U2,U3,U4,U5> Cffu<Tuple5<U1,U2,U3,U4,U5>> allTupleOfThenMApplyAsync(
+            CompletionStage<? extends T> cf,Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3,Function<? super T, ? extends U4> function4,Function<? super T, ? extends U5> function5) {
+        return create(CompletableFutureUtils.allTupleOfThenMApplyAsync(cf,function1, function2,function3,function4,function5));
+    }
+
+
     // endregion
     ////////////////////////////////////////////////////////////////////////////////
     // region## Immediate Value Argument Factory Methods
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 1fe4cb25..5a3b0d5c 100644
--- a/cffu-core/src/main/java/io/foldright/cffu/CompletableFutureUtils.java
+++ b/cffu-core/src/main/java/io/foldright/cffu/CompletableFutureUtils.java
@@ -77,6 +77,183 @@ public static <T> CompletableFuture<List<T>> mSupplyFastFailAsync(
         return allResultsOfFastFail(wrapSuppliers(executor, suppliers));
     }
 
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the CompletableFuture's default asynchronous execution facility
+     * with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     * <p>
+     * This method is the same as {@link #mSupplyAsync(Supplier[])} except for the fast-fail behavior.
+     *
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @return the new CompletableFuture
+     * @see #allResultsOfFastFail(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier)
+     */
+    @Contract(pure = true)
+    public static <T1,T2> CompletableFuture<Tuple2<T1,T2>> allTupleOfMSupplyFastFailAsync(Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2) {
+        return allTupleOfMSupplyFastFailAsync(AsyncPoolHolder.ASYNC_POOL,supplier1,supplier2);
+    }
+
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the given Executor with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     * <p>
+     * This method is the same as {@link #mSupplyAsync(Executor, Supplier[])} except for the fast-fail behavior.
+     *
+     * @param executor  the executor to use for asynchronous execution
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @return the new CompletableFuture
+     * @see #allResultsOfFastFail(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier, Executor)
+     */
+    @Contract(pure = true)
+    public static <T1,T2> CompletableFuture<Tuple2<T1,T2>> allTupleOfMSupplyFastFailAsync(
+            Executor executor, Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2) {
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("supplier", supplier1,supplier2);
+        return allTupleOf0(wrapSuppliers(executor,supplier1,supplier2), true);
+    }
+
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the CompletableFuture's default asynchronous execution facility
+     * with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     * <p>
+     * This method is the same as {@link #mSupplyAsync(Supplier[])} except for the fast-fail behavior.
+     *
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier3 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @return the new CompletableFuture
+     * @see #allResultsOfFastFail(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier)
+     */
+    @Contract(pure = true)
+    public static <T1,T2,T3> CompletableFuture<Tuple3<T1,T2,T3>> allTupleOfMSupplyFastFailAsync(Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2,Supplier<? extends T3> supplier3) {
+        return allTupleOfMSupplyFastFailAsync(AsyncPoolHolder.ASYNC_POOL,supplier1,supplier2,supplier3);
+    }
+
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the given Executor with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     * <p>
+     * This method is the same as {@link #mSupplyAsync(Executor, Supplier[])} except for the fast-fail behavior.
+     *
+     * @param executor  the executor to use for asynchronous execution
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier3 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @return the new CompletableFuture
+     * @see #allResultsOfFastFail(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier, Executor)
+     */
+    @Contract(pure = true)
+    public static <T1,T2,T3> CompletableFuture<Tuple3<T1,T2,T3>> allTupleOfMSupplyFastFailAsync(
+            Executor executor, Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2,Supplier<? extends T3> supplier3) {
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("supplier", supplier1,supplier2,supplier3);
+        return allTupleOf0(wrapSuppliers(executor,supplier1,supplier2,supplier3), true);
+    }
+
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the CompletableFuture's default asynchronous execution facility
+     * with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     * <p>
+     * This method is the same as {@link #mSupplyAsync(Supplier[])} except for the fast-fail behavior.
+     *
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier3 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier4 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @return the new CompletableFuture
+     * @see #allResultsOfFastFail(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier)
+     */
+    @Contract(pure = true)
+    public static <T1,T2,T3,T4> CompletableFuture<Tuple4<T1,T2,T3,T4>> allTupleOfMSupplyFastFailAsync(Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2,Supplier<? extends T3> supplier3,Supplier<? extends T4> supplier4) {
+        return allTupleOfMSupplyFastFailAsync(AsyncPoolHolder.ASYNC_POOL,supplier1,supplier2,supplier3,supplier4);
+    }
+
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the given Executor with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     * <p>
+     * This method is the same as {@link #mSupplyAsync(Executor, Supplier[])} except for the fast-fail behavior.
+     *
+     * @param executor  the executor to use for asynchronous execution
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier3 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier4 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @return the new CompletableFuture
+     * @see #allResultsOfFastFail(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier, Executor)
+     */
+    @Contract(pure = true)
+    public static <T1,T2,T3,T4> CompletableFuture<Tuple4<T1,T2,T3,T4>> allTupleOfMSupplyFastFailAsync(
+            Executor executor, Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2,Supplier<? extends T3> supplier3,Supplier<? extends T4> supplier4) {
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("supplier", supplier1,supplier2,supplier3,supplier4);
+        return allTupleOf0(wrapSuppliers(executor,supplier1,supplier2,supplier3,supplier4), true);
+    }
+
+
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the CompletableFuture's default asynchronous execution facility
+     * with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     * <p>
+     * This method is the same as {@link #mSupplyAsync(Supplier[])} except for the fast-fail behavior.
+     *
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier3 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier4 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier5 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @return the new CompletableFuture
+     * @see #allResultsOfFastFail(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier)
+     */
+    @Contract(pure = true)
+    public static <T1,T2,T3,T4,T5> CompletableFuture<Tuple5<T1,T2,T3,T4,T5>> allTupleOfMSupplyFastFailAsync(Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2,Supplier<? extends T3> supplier3,Supplier<? extends T4> supplier4,Supplier<? extends T5> supplier5) {
+        return allTupleOfMSupplyFastFailAsync(AsyncPoolHolder.ASYNC_POOL,supplier1,supplier2,supplier3,supplier4,supplier5);
+    }
+
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the given Executor with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     * <p>
+     * This method is the same as {@link #mSupplyAsync(Executor, Supplier[])} except for the fast-fail behavior.
+     *
+     * @param executor  the executor to use for asynchronous execution
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier3 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier4 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier5 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @return the new CompletableFuture
+     * @see #allResultsOfFastFail(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier, Executor)
+     */
+    @Contract(pure = true)
+    public static <T1,T2,T3,T4,T5> CompletableFuture<Tuple5<T1,T2,T3,T4,T5>> allTupleOfMSupplyFastFailAsync(
+            Executor executor, Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2,Supplier<? extends T3> supplier3,Supplier<? extends T4> supplier4,Supplier<? extends T5> supplier5) {
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("supplier", supplier1,supplier2,supplier3,supplier4,supplier5);
+        return allTupleOf0(wrapSuppliers(executor,supplier1,supplier2,supplier3,supplier4,supplier5), true);
+    }
+
     /**
      * Returns a new CompletableFuture that is asynchronously completed
      * by tasks running in the CompletableFuture's default asynchronous execution facility
@@ -169,6 +346,166 @@ public static <T> CompletableFuture<List<T>> mSupplyAsync(Executor executor, Sup
         return allResultsOf(wrapSuppliers(executor, suppliers));
     }
 
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the CompletableFuture's default asynchronous execution facility
+     * with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     *
+     * @param <T>       the suppliers' return type
+     * @return the new CompletableFuture
+     * @see #allResultsOf(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier)
+     */
+    @Contract(pure = true)
+    public static <T1,T2> CompletableFuture<Tuple2<T1,T2>> allTupleOfMSupplyAsync(Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2) {
+        return allTupleOfMSupplyAsync(AsyncPoolHolder.ASYNC_POOL,supplier1,supplier2);
+    }
+
+
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the CompletableFuture's default asynchronous execution facility
+     * with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     *
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @return the new CompletableFuture
+     * @see #allResultsOf(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier)
+     */
+    @Contract(pure = true)
+    public static <T1,T2> CompletableFuture<Tuple2<T1,T2>> allTupleOfMSupplyAsync(Executor executor,
+                                                                       Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2) {
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("supplier", supplier1,supplier2);
+        return allTupleOf0(wrapSuppliers(executor,supplier1,supplier2), false);
+    }
+
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the CompletableFuture's default asynchronous execution facility
+     * with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     *
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier3 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @return the new CompletableFuture
+     * @see #allResultsOf(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier)
+     */
+    @Contract(pure = true)
+    public static <T1,T2,T3> CompletableFuture<Tuple3<T1,T2,T3>> allTupleOfMSupplyAsync(Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2,Supplier<? extends T3> supplier3) {
+        return allTupleOfMSupplyAsync(AsyncPoolHolder.ASYNC_POOL,supplier1,supplier2,supplier3);
+    }
+
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the CompletableFuture's default asynchronous execution facility
+     * with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     *
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier3 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param <T>       the suppliers' return type
+     * @return the new CompletableFuture
+     * @see #allResultsOf(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier)
+     */
+    @Contract(pure = true)
+    public static <T1,T2,T3> CompletableFuture<Tuple3<T1,T2,T3>> allTupleOfMSupplyAsync(Executor executor,Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2,Supplier<? extends T3> supplier3) {
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("supplier", supplier1,supplier2,supplier3);
+        return allTupleOf0(wrapSuppliers(executor,supplier1,supplier2,supplier3), false);
+    }
+
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the CompletableFuture's default asynchronous execution facility
+     * with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     *
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier3 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier4 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @return the new CompletableFuture
+     * @see #allResultsOf(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier)
+     */
+    @Contract(pure = true)
+    public static <T1,T2,T3,T4> CompletableFuture<Tuple4<T1,T2,T3,T4>> allTupleOfMSupplyAsync(Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2,Supplier<? extends T3> supplier3,Supplier<? extends T4> supplier4) {
+        return allTupleOfMSupplyAsync(AsyncPoolHolder.ASYNC_POOL,supplier1,supplier2,supplier3,supplier4);
+    }
+
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the CompletableFuture's default asynchronous execution facility
+     * with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     *
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier3 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier4 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param <T>       the suppliers' return type
+     * @return the new CompletableFuture
+     * @see #allResultsOf(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier)
+     */
+    @Contract(pure = true)
+    public static <T1,T2,T3,T4> CompletableFuture<Tuple4<T1,T2,T3,T4>> allTupleOfMSupplyAsync(Executor executor,Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2,Supplier<? extends T3> supplier3,Supplier<? extends T4> supplier4) {
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("supplier", supplier1,supplier2,supplier3,supplier4);
+        return allTupleOf0(wrapSuppliers(executor,supplier1,supplier2,supplier3,supplier4), false);
+    }
+
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the CompletableFuture's default asynchronous execution facility
+     * with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     *
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier3 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier4 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier5 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @return the new CompletableFuture
+     * @see #allResultsOf(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier)
+     */
+    @Contract(pure = true)
+    public static <T1,T2,T3,T4,T5> CompletableFuture<Tuple5<T1,T2,T3,T4,T5>> allTupleOfMSupplyAsync(Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2,Supplier<? extends T3> supplier3,Supplier<? extends T4> supplier4,Supplier<? extends T5> supplier5) {
+        return allTupleOfMSupplyAsync(AsyncPoolHolder.ASYNC_POOL,supplier1,supplier2,supplier3,supplier4,supplier5);
+    }
+
+    /**
+     * Returns a new CompletableFuture that is asynchronously completed
+     * by tasks running in the CompletableFuture's default asynchronous execution facility
+     * with the values obtained by calling the given Suppliers
+     * in the <strong>same order</strong> of the given Suppliers arguments.
+     *
+     * @param supplier1 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier2 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier3 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier4 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param supplier5 the suppliers returning the value to be used to complete the returned CompletableFuture
+     * @param <T>       the suppliers' return type
+     * @return the new CompletableFuture
+     * @see #allResultsOf(CompletionStage[])
+     * @see CompletableFuture#supplyAsync(Supplier)
+     */
+    @Contract(pure = true)
+    public static <T1,T2,T3,T4,T5> CompletableFuture<Tuple5<T1,T2,T3,T4,T5>> allTupleOfMSupplyAsync(Executor executor,Supplier<? extends T1> supplier1,Supplier<? extends T2> supplier2,Supplier<? extends T3> supplier3,Supplier<? extends T4> supplier4,Supplier<? extends T5> supplier5) {
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("supplier", supplier1,supplier2,supplier3,supplier4,supplier5);
+        return allTupleOf0(wrapSuppliers(executor,supplier1,supplier2,supplier3,supplier4,supplier5), false);
+    }
+
     @SafeVarargs
     private static <T> T[] requireArrayAndEleNonNull(String varName, T... array) {
         requireNonNull(array, varName + "s is null");
@@ -179,7 +516,7 @@ private static <T> T[] requireArrayAndEleNonNull(String varName, T... array) {
     }
 
     private static <T> CompletableFuture<? extends T>[] wrapSuppliers(
-            Executor executor, Supplier<? extends T>[] suppliers) {
+            Executor executor, Supplier<? extends T>... suppliers) {
         @SuppressWarnings("unchecked")
         CompletableFuture<? extends T>[] cfs = new CompletableFuture[suppliers.length];
         for (int i = 0; i < suppliers.length; i++) {
@@ -1281,8 +1618,387 @@ public static <T, U> CompletableFuture<List<U>> thenMApplyAsync(
         return toNonMinCf(cf).thenCompose(v -> allResultsOf(wrapFunctions(executor, v, fns)));
     }
 
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the CompletableFuture's default asynchronous execution facility,
+     * with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param <U> the functions' return type
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T,U1,U2> CompletableFuture<Tuple2<U1,U2>> allTupleOfThenMApplyAsync(
+            CompletionStage<? extends T> cf,Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2) {
+        return allTupleOfThenMApplyAsync(cf, AsyncPoolHolder.ASYNC_POOL, function1,function2);
+    }
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the given Executor, with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param <U> the functions' return type
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T,U1,U2> CompletableFuture<Tuple2<U1,U2>> allTupleOfThenMApplyAsync(
+            CompletionStage<? extends T> cf, Executor executor, Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2) {
+        requireNonNull(cf, "cf is null");
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("fn", function1,function2);
+        CompletableFuture<T>  cf1= toNonMinCf(cf);
+        CompletableFuture<U1>  completableFuture1 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function1.apply(v), executor));
+        CompletableFuture<U2>  completableFuture2 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function2.apply(v), executor));
+        CompletionStage<?>[] css = {completableFuture1,completableFuture2};
+        return allTupleOf0(css,false);
+    }
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the CompletableFuture's default asynchronous execution facility,
+     * with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param function3 the functions to use to compute the values of the returned CompletableFuture
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T,U1,U2,U3> CompletableFuture<Tuple3<U1,U2,U3>> allTupleOfThenMApplyAsync(
+            CompletionStage<? extends T> cf,Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3) {
+        return allTupleOfThenMApplyAsync(cf, AsyncPoolHolder.ASYNC_POOL, function1,function2,function3);
+    }
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the given Executor, with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param function3 the functions to use to compute the values of the returned CompletableFuture
+     * @param <U> the functions' return type
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T,U1,U2,U3> CompletableFuture<Tuple3<U1,U2,U3>> allTupleOfThenMApplyAsync(
+            CompletionStage<? extends T> cf, Executor executor, Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3) {
+        requireNonNull(cf, "cf is null");
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("fn", function1,function2,function3);
+
+        CompletableFuture<T>  cf1= toNonMinCf(cf);
+        CompletableFuture<U1>  completableFuture1 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function1.apply(v), executor));
+        CompletableFuture<U2>  completableFuture2 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function2.apply(v), executor));
+        CompletableFuture<U3>  completableFuture3 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function3.apply(v), executor));
+        CompletionStage<?>[] css = {completableFuture1,completableFuture2,completableFuture3};
+        return allTupleOf0(css,false);
+    }
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the CompletableFuture's default asynchronous execution facility,
+     * with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param function3 the functions to use to compute the values of the returned CompletableFuture
+     * @param function4 the functions to use to compute the values of the returned CompletableFuture
+     * @param <U> the functions' return type
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T,U1,U2,U3,U4> CompletableFuture<Tuple4<U1,U2,U3,U4>> allTupleOfThenMApplyAsync(
+            CompletionStage<? extends T> cf,Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3,Function<? super T, ? extends U4> function4) {
+        return allTupleOfThenMApplyAsync(cf, AsyncPoolHolder.ASYNC_POOL, function1,function2,function3,function4);
+    }
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the given Executor, with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param function3 the functions to use to compute the values of the returned CompletableFuture
+     * @param function4 the functions to use to compute the values of the returned CompletableFuture
+     * @param <U> the functions' return type
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T,U1,U2,U3,U4> CompletableFuture<Tuple4<U1,U2,U3,U4>> allTupleOfThenMApplyAsync(
+            CompletionStage<? extends T> cf, Executor executor, Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3,Function<? super T, ? extends U4> function4) {
+        requireNonNull(cf, "cf is null");
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("fn", function1,function2,function3,function4);
+
+        CompletableFuture<T>  cf1= toNonMinCf(cf);
+        CompletableFuture<U1>  completableFuture1 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function1.apply(v), executor));
+        CompletableFuture<U2>  completableFuture2 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function2.apply(v), executor));
+        CompletableFuture<U3>  completableFuture3 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function3.apply(v), executor));
+        CompletableFuture<U4>  completableFuture4 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function4.apply(v), executor));
+        CompletionStage<?>[] css = {completableFuture1,completableFuture2,completableFuture3,completableFuture4};
+        return allTupleOf0(css,false);
+    }
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the CompletableFuture's default asynchronous execution facility,
+     * with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param function3 the functions to use to compute the values of the returned CompletableFuture
+     * @param function4 the functions to use to compute the values of the returned CompletableFuture
+     * @param function5 the functions to use to compute the values of the returned CompletableFuture
+     * @param <U> the functions' return type
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T,U1,U2,U3,U4,U5> CompletableFuture<Tuple5<U1,U2,U3,U4,U5>> allTupleOfThenMApplyAsync(
+            CompletionStage<? extends T> cf,Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3,Function<? super T, ? extends U4> function4,Function<? super T, ? extends U5> function5) {
+        return allTupleOfThenMApplyAsync(cf, AsyncPoolHolder.ASYNC_POOL, function1,function2,function3,function4,function5);
+    }
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the given Executor, with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param function3 the functions to use to compute the values of the returned CompletableFuture
+     * @param function4 the functions to use to compute the values of the returned CompletableFuture
+     * @param function5 the functions to use to compute the values of the returned CompletableFuture
+     * @param <U> the functions' return type
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T,U1,U2,U3,U4,U5> CompletableFuture<Tuple5<U1,U2,U3,U4,U5>> allTupleOfThenMApplyAsync(
+            CompletionStage<? extends T> cf, Executor executor, Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3,Function<? super T, ? extends U4> function4,Function<? super T, ? extends U5> function5) {
+        requireNonNull(cf, "cf is null");
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("fn", function1,function2,function3,function4,function5);
+
+        CompletableFuture<T>  cf1= toNonMinCf(cf);
+        CompletableFuture<U1>  completableFuture1 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function1.apply(v), executor));
+        CompletableFuture<U2>  completableFuture2 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function2.apply(v), executor));
+        CompletableFuture<U3>  completableFuture3 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function3.apply(v), executor));
+        CompletableFuture<U4>  completableFuture4 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function4.apply(v), executor));
+        CompletableFuture<U5>  completableFuture5 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function5.apply(v), executor));
+        CompletionStage<?>[] css = {completableFuture1,completableFuture2,completableFuture3,completableFuture4,completableFuture5};
+        return allTupleOf0(css,false);
+    }
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the CompletableFuture's default asynchronous execution facility,
+     * with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T,U1,U2> CompletableFuture<Tuple2<U1,U2>> allTupleOfThenMApplyFastFailAsync(
+            CompletionStage<? extends T> cf,Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2) {
+        return allTupleOfThenMApplyFastFailAsync(cf, AsyncPoolHolder.ASYNC_POOL, function1,function2);
+    }
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the given Executor, with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param <U> the functions' return type
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T,U1,U2> CompletableFuture<Tuple2<U1,U2>> allTupleOfThenMApplyFastFailAsync(
+            CompletionStage<? extends T> cf, Executor executor, Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2) {
+        requireNonNull(cf, "cf is null");
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("fn", function1,function2);
+        CompletableFuture<T>  cf1= toNonMinCf(cf);
+        CompletableFuture<U1>  completableFuture1 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function1.apply(v), executor));
+        CompletableFuture<U2>  completableFuture2 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function2.apply(v), executor));
+        CompletionStage<?>[] css = {completableFuture1,completableFuture2};
+        return allTupleOf0(css,true);
+    }
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the CompletableFuture's default asynchronous execution facility,
+     * with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param function3 the functions to use to compute the values of the returned CompletableFuture
+     * @param <U> the functions' return type
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T,U1,U2,U3> CompletableFuture<Tuple3<U1,U2,U3>> allTupleOfThenMApplyFastFailAsync(
+            CompletionStage<? extends T> cf,Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3) {
+        return allTupleOfThenMApplyFastFailAsync(cf, AsyncPoolHolder.ASYNC_POOL, function1,function2,function3);
+    }
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the given Executor, with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param function3 the functions to use to compute the values of the returned CompletableFuture
+     * @param <U> the functions' return type
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T,U1,U2,U3> CompletableFuture<Tuple3<U1,U2,U3>> allTupleOfThenMApplyFastFailAsync(
+            CompletionStage<? extends T> cf, Executor executor, Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3) {
+        requireNonNull(cf, "cf is null");
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("fn", function1,function2,function3);
+
+        CompletableFuture<T>  cf1= toNonMinCf(cf);
+        CompletableFuture<U1>  completableFuture1 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function1.apply(v), executor));
+        CompletableFuture<U2>  completableFuture2 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function2.apply(v), executor));
+        CompletableFuture<U3>  completableFuture3 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function3.apply(v), executor));
+        CompletionStage<?>[] css = {completableFuture1,completableFuture2,completableFuture3};
+        return allTupleOf0(css,true);
+    }
+
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the CompletableFuture's default asynchronous execution facility,
+     * with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param function3 the functions to use to compute the values of the returned CompletableFuture
+     * @param function4 the functions to use to compute the values of the returned CompletableFuture
+     * @param <U> the functions' return type
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T, U1,U2,U3,U4> CompletableFuture<Tuple4<U1,U2,U3,U4>> allTupleOfThenMApplyFastFailAsync(
+            CompletionStage<? extends T> cf,Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3,Function<? super T, ? extends U4> function4) {
+        return allTupleOfThenMApplyFastFailAsync(cf, AsyncPoolHolder.ASYNC_POOL, function1,function2,function3,function4);
+    }
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the given Executor, with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param function3 the functions to use to compute the values of the returned CompletableFuture
+     * @param function4 the functions to use to compute the values of the returned CompletableFuture
+     * @param <U> the functions' return type
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T,U1,U2,U3,U4> CompletableFuture<Tuple4<U1,U2,U3,U4>> allTupleOfThenMApplyFastFailAsync(
+            CompletionStage<? extends T> cf, Executor executor, Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3,Function<? super T, ? extends U4> function4) {
+        requireNonNull(cf, "cf is null");
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("fn", function1,function2,function3,function4);
+
+        CompletableFuture<T>  cf1= toNonMinCf(cf);
+        CompletableFuture<U1>  completableFuture1 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function1.apply(v), executor));
+        CompletableFuture<U2>  completableFuture2 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function2.apply(v), executor));
+        CompletableFuture<U3>  completableFuture3 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function3.apply(v), executor));
+        CompletableFuture<U4>  completableFuture4 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function4.apply(v), executor));
+        CompletionStage<?>[] css = {completableFuture1,completableFuture2,completableFuture3,completableFuture4};
+        return allTupleOf0(css,true);
+    }
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the CompletableFuture's default asynchronous execution facility,
+     * with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param function3 the functions to use to compute the values of the returned CompletableFuture
+     * @param function4 the functions to use to compute the values of the returned CompletableFuture
+     * @param function5 the functions to use to compute the values of the returned CompletableFuture
+     * @param <U> the functions' return type
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T, U1,U2,U3,U4,U5> CompletableFuture<Tuple5<U1,U2,U3,U4,U5>> allTupleOfThenMApplyFastFailAsync(
+            CompletionStage<? extends T> cf,Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3,Function<? super T, ? extends U4> function4,Function<? super T, ? extends U5> function5) {
+        return allTupleOfThenMApplyFastFailAsync(cf, AsyncPoolHolder.ASYNC_POOL, function1,function2,function3,function4,function5);
+    }
+
+    /**
+     * Returns a new CompletableFuture that, when the given stage completes normally,
+     * is executed using the given Executor, with the values obtained by calling the given Functions
+     * (with the given stage's result as the argument to the given functions)
+     * in the <strong>same order</strong> of the given Functions arguments.
+     *
+     * @param function1 the functions to use to compute the values of the returned CompletableFuture
+     * @param function2 the functions to use to compute the values of the returned CompletableFuture
+     * @param function3 the functions to use to compute the values of the returned CompletableFuture
+     * @param function4 the functions to use to compute the values of the returned CompletableFuture
+     * @param function5 the functions to use to compute the values of the returned CompletableFuture
+     * @param <U> the functions' return type
+     * @return the new CompletableFuture
+     */
+    @Contract(pure = true)
+    public static <T, U1,U2,U3,U4,U5> CompletableFuture<Tuple5<U1,U2,U3,U4,U5>> allTupleOfThenMApplyFastFailAsync(
+            CompletionStage<? extends T> cf, Executor executor, Function<? super T, ? extends U1> function1,Function<? super T, ? extends U2> function2,Function<? super T, ? extends U3> function3,Function<? super T, ? extends U4> function4,Function<? super T, ? extends U5> function5) {
+        requireNonNull(cf, "cf is null");
+        requireNonNull(executor, "executor is null");
+        requireArrayAndEleNonNull("fn", function1,function2,function3,function4,function5);
+
+        CompletableFuture<T>  cf1= toNonMinCf(cf);
+        CompletableFuture<U1>  completableFuture1 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function1.apply(v), executor));
+        CompletableFuture<U2>  completableFuture2 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function2.apply(v), executor));
+        CompletableFuture<U3>  completableFuture3 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function3.apply(v), executor));
+        CompletableFuture<U4>  completableFuture4 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function4.apply(v), executor));
+        CompletableFuture<U5>  completableFuture5 = cf1.thenCompose(v->CompletableFuture.supplyAsync(() -> function5.apply(v), executor));
+        CompletionStage<?>[] css = {completableFuture1,completableFuture2,completableFuture3,completableFuture4,completableFuture5};
+        return allTupleOf0(css,true);
+
+    }
+
+
     private static <T, U> CompletableFuture<U>[] wrapFunctions(
-            Executor executor, T v, Function<? super T, ? extends U>[] fns) {
+            Executor executor, T v, Function<? super T, ? extends U>... fns) {
         @SuppressWarnings("unchecked")
         CompletableFuture<U>[] cfs = new CompletableFuture[fns.length];
         for (int i = 0; i < fns.length; i++) {
@@ -1292,6 +2008,7 @@ private static <T, U> CompletableFuture<U>[] wrapFunctions(
         return cfs;
     }
 
+
     /**
      * Returns a new CompletableFuture that, when the given stage completes normally,
      * is executed using the CompletableFuture's default asynchronous execution facility,
diff --git a/cffu-core/src/test/java/io/foldright/cffu/CffuFactoryTest.java b/cffu-core/src/test/java/io/foldright/cffu/CffuFactoryTest.java
index 46bfbd4e..245714fc 100644
--- a/cffu-core/src/test/java/io/foldright/cffu/CffuFactoryTest.java
+++ b/cffu-core/src/test/java/io/foldright/cffu/CffuFactoryTest.java
@@ -14,6 +14,8 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.concurrent.*;
+import java.util.function.Function;
+import java.util.function.Supplier;
 
 import static io.foldright.cffu.CompletableFutureUtils.failedFuture;
 import static io.foldright.cffu.CompletableFutureUtils.toCompletableFutureArray;
@@ -624,6 +626,80 @@ void test_mostTupleOfSuccess() throws Exception {
         ).get());
     }
 
+    @Test
+    void test_allTupleOfMSupplyAsync() throws Exception {
+        final Supplier<Integer> supplier_n = () -> {
+            sleep(100);
+            return n;
+        };
+        final Supplier<String> supplier_s = () -> {
+            sleep(100);
+            return s;
+        };
+
+        final Supplier<Double> supplier_d = () -> {
+            sleep(100);
+            return d;
+        };
+        final Supplier<Integer> supplier_an = () -> {
+            sleep(100);
+            return anotherN;
+        };
+        final Supplier<Integer> supplier_nn = () -> {
+            sleep(100);
+            return n+n;
+        };
+        assertEquals(Tuple2.of(n, s), cffuFactory.allTupleOfMSupplyAsync(supplier_n, supplier_s).get());
+        assertEquals(Tuple2.of(n, s),  cffuFactory.allTupleOfMSupplyFastFailAsync(supplier_n, supplier_s).get());
+
+        assertEquals(Tuple3.of(n, s, d),  cffuFactory.allTupleOfMSupplyAsync(supplier_n, supplier_s, supplier_d).get());
+        assertEquals(Tuple3.of(n, s, d),  cffuFactory.allTupleOfMSupplyFastFailAsync(supplier_n, supplier_s, supplier_d).get());
+
+        assertEquals(Tuple4.of(n, s, d, anotherN),  cffuFactory.allTupleOfMSupplyAsync(supplier_n, supplier_s, supplier_d, supplier_an).get());
+        assertEquals(Tuple4.of(n, s, d, anotherN),  cffuFactory.allTupleOfMSupplyFastFailAsync(supplier_n, supplier_s, supplier_d, supplier_an).get());
+
+        assertEquals(Tuple5.of(n, s, d, anotherN, n + n),  cffuFactory.allTupleOfMSupplyAsync(supplier_n, supplier_s, supplier_d, supplier_an, supplier_nn).get());
+        assertEquals(Tuple5.of(n, s, d, anotherN, n + n),  cffuFactory.allTupleOfMSupplyFastFailAsync(supplier_n, supplier_s, supplier_d, supplier_an, supplier_nn).get());
+    }
+
+    @Test
+    void test_allTupleOfThenMApplyAsync() throws Exception {
+        final CompletableFuture<Integer> completed = completedFuture(n);
+        final Function<Integer,Integer> function_n = (x) -> {
+            sleep(100);
+            return n;
+        };
+
+        final Function<Integer,String> function_s = (x) -> {
+            sleep(100);
+            return s;
+        };
+
+        final Function<Integer,Double> function_d = (x) -> {
+            sleep(100);
+            return d;
+        };
+        final Function<Integer,Integer> function_an = (x) -> {
+            sleep(100);
+            return anotherN;
+        };
+        final Function<Integer,Integer> function_nn = (x) -> {
+            sleep(100);
+            return n+n;
+        };
+        assertEquals(Tuple2.of(n, s), cffuFactory.allTupleOfThenMApplyAsync(completed,function_n, function_s).get());
+        assertEquals(Tuple2.of(n, s),  cffuFactory.allTupleOfThenMApplyFastFailAsync(completed,function_n, function_s).get());
+
+        assertEquals(Tuple3.of(n, s, d),  cffuFactory.allTupleOfThenMApplyAsync(completed,function_n, function_s, function_d).get());
+        assertEquals(Tuple3.of(n, s, d),  cffuFactory.allTupleOfThenMApplyFastFailAsync(completed,function_n, function_s, function_d).get());
+
+        assertEquals(Tuple4.of(n, s, d, anotherN),  cffuFactory.allTupleOfThenMApplyAsync(completed,function_n, function_s, function_d, function_an).get());
+        assertEquals(Tuple4.of(n, s, d, anotherN),  cffuFactory.allTupleOfThenMApplyFastFailAsync(completed,function_n, function_s, function_d, function_an).get());
+
+        assertEquals(Tuple5.of(n, s, d, anotherN, n + n),  cffuFactory.allTupleOfThenMApplyAsync(completed,function_n, function_s, function_d, function_an, function_nn).get());
+        assertEquals(Tuple5.of(n, s, d, anotherN, n + n),  cffuFactory.allTupleOfThenMApplyFastFailAsync(completed,function_n, function_s, function_d, function_an, function_nn).get());
+    }
+
     ////////////////////////////////////////////////////////////////////////////////
     //# Conversion (Static) Methods
     //
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 2da0b91b..92848b85 100644
--- a/cffu-core/src/test/java/io/foldright/cffu/CompletableFutureUtilsTest.java
+++ b/cffu-core/src/test/java/io/foldright/cffu/CompletableFutureUtilsTest.java
@@ -749,6 +749,82 @@ void test_allTupleOf_NotFastFail() throws Exception {
         );
     }
 
+
+    @Test
+    void test_allTupleOfMSupplyAsync() throws Exception {
+        final Supplier<Integer> supplier_n = () -> {
+            sleep(100);
+            return n;
+        };
+        final Supplier<String> supplier_s = () -> {
+            sleep(100);
+            return s;
+        };
+
+        final Supplier<Double> supplier_d = () -> {
+            sleep(100);
+            return d;
+        };
+        final Supplier<Integer> supplier_an = () -> {
+            sleep(100);
+            return anotherN;
+        };
+        final Supplier<Integer> supplier_nn = () -> {
+            sleep(100);
+            return n+n;
+        };
+        assertEquals(Tuple2.of(n, s), allTupleOfMSupplyAsync(supplier_n, supplier_s).get());
+        assertEquals(Tuple2.of(n, s), allTupleOfMSupplyFastFailAsync(supplier_n, supplier_s).get());
+
+        assertEquals(Tuple3.of(n, s, d), allTupleOfMSupplyAsync(supplier_n, supplier_s, supplier_d).get());
+        assertEquals(Tuple3.of(n, s, d), allTupleOfMSupplyFastFailAsync(supplier_n, supplier_s, supplier_d).get());
+
+        assertEquals(Tuple4.of(n, s, d, anotherN), allTupleOfMSupplyAsync(supplier_n, supplier_s, supplier_d, supplier_an).get());
+        assertEquals(Tuple4.of(n, s, d, anotherN), allTupleOfMSupplyFastFailAsync(supplier_n, supplier_s, supplier_d, supplier_an).get());
+
+        assertEquals(Tuple5.of(n, s, d, anotherN, n + n), allTupleOfMSupplyAsync(supplier_n, supplier_s, supplier_d, supplier_an, supplier_nn).get());
+        assertEquals(Tuple5.of(n, s, d, anotherN, n + n), allTupleOfMSupplyFastFailAsync(supplier_n, supplier_s, supplier_d, supplier_an, supplier_nn).get());
+    }
+
+
+    @Test
+    void test_allTupleOfThenMApplyAsync() throws Exception {
+        final CompletableFuture<Integer> completed = completedFuture(n);
+        final Function<Integer,Integer> function_n = (x) -> {
+            sleep(100);
+            return n;
+        };
+
+        final Function<Integer,String> function_s = (x) -> {
+            sleep(100);
+            return s;
+        };
+
+        final Function<Integer,Double> function_d = (x) -> {
+            sleep(100);
+            return d;
+        };
+        final Function<Integer,Integer> function_an = (x) -> {
+            sleep(100);
+            return anotherN;
+        };
+        final Function<Integer,Integer> function_nn = (x) -> {
+            sleep(100);
+            return n+n;
+        };
+        assertEquals(Tuple2.of(n, s), allTupleOfThenMApplyAsync(completed,function_n, function_s).get());
+        assertEquals(Tuple2.of(n, s), allTupleOfThenMApplyFastFailAsync(completed,function_n, function_s).get());
+
+        assertEquals(Tuple3.of(n, s, d), allTupleOfThenMApplyAsync(completed,function_n, function_s, function_d).get());
+        assertEquals(Tuple3.of(n, s, d), allTupleOfThenMApplyFastFailAsync(completed,function_n, function_s, function_d).get());
+
+        assertEquals(Tuple4.of(n, s, d, anotherN), allTupleOfThenMApplyAsync(completed,function_n, function_s, function_d, function_an).get());
+        assertEquals(Tuple4.of(n, s, d, anotherN), allTupleOfThenMApplyFastFailAsync(completed,function_n, function_s, function_d, function_an).get());
+
+        assertEquals(Tuple5.of(n, s, d, anotherN, n + n), allTupleOfThenMApplyAsync(completed,function_n, function_s, function_d, function_an, function_nn).get());
+        assertEquals(Tuple5.of(n, s, d, anotherN, n + n), allTupleOfThenMApplyFastFailAsync(completed,function_n, function_s, function_d, function_an, function_nn).get());
+    }
+
     @Test
     void test_mostTupleOfSuccess() throws Exception {
         final CompletableFuture<Integer> completed = completedFuture(n);