diff --git a/CHANGES.md b/CHANGES.md
index 60a8a7d..0b5ec49 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,3 +1,7 @@
+### 2.0.2
+
+* Bug fixes and improvements.
+
 ### 2.0.1
 
 * Bug fixes and improvements.
diff --git a/README.md b/README.md
index facf474..b33cd64 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 # abacus-extra 
  
 [![Maven Central](https://img.shields.io/maven-central/v/com.landawn/abacus-extra.svg)](https://maven-badges.herokuapp.com/maven-central/com.landawn/abacus-extra/)
-[![Javadocs](https://img.shields.io/badge/javadoc-2.0.1-brightgreen.svg)](https://www.javadoc.io/doc/com.landawn/abacus-extra/2.0.1/index.html)
+[![Javadocs](https://img.shields.io/badge/javadoc-2.0.2-brightgreen.svg)](https://www.javadoc.io/doc/com.landawn/abacus-extra/2.0.2/index.html)
 
 
 * Matrixes: 
@@ -32,7 +32,7 @@
 * Gradle:
 ```gradle
 // JDK 1.8 or above:
-compile 'com.landawn:abacus-extra:2.0.1'
+compile 'com.landawn:abacus-extra:2.0.2'
 ```
 
 
diff --git a/maven/0.0.1-SNAPSHOT/abacus-extra-0.0.1-SNAPSHOT.pom b/maven/0.0.1-SNAPSHOT/abacus-extra-0.0.1-SNAPSHOT.pom
index badb529..89d7184 100644
--- a/maven/0.0.1-SNAPSHOT/abacus-extra-0.0.1-SNAPSHOT.pom
+++ b/maven/0.0.1-SNAPSHOT/abacus-extra-0.0.1-SNAPSHOT.pom
@@ -78,7 +78,7 @@
 		<dependency>
 			<groupId>com.landawn</groupId>
 			<artifactId>abacus-common</artifactId>
-			<version>5.6.9</version>
+			<version>5.6.10</version>
 		</dependency>
 	</dependencies>
 
diff --git a/pom.xml b/pom.xml
index 39778c9..3d4b9b5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -5,7 +5,7 @@
 
 	<groupId>com.landawn</groupId>
 	<artifactId>abacus-extra</artifactId>
-	<version>2.0.2</version>
+	<version>2.1.0</version>
 	<packaging>jar</packaging>
 
 	<name>abacus-extra</name>
@@ -25,7 +25,7 @@
 		<dependency>
 			<groupId>com.landawn</groupId>
 			<artifactId>abacus-common</artifactId>
-			<version>5.6.9</version>
+			<version>5.6.10</version>
 			<scope>provided</scope>
 		</dependency>
 
diff --git a/src/main/java/com/landawn/abacus/util/Arrays.java b/src/main/java/com/landawn/abacus/util/Arrays.java
index 6cb2141..ca5f74f 100644
--- a/src/main/java/com/landawn/abacus/util/Arrays.java
+++ b/src/main/java/com/landawn/abacus/util/Arrays.java
@@ -6313,6 +6313,486 @@ public static <E extends Exception> byte[][][] zip(final byte[][][] a, final byt
         return result;
     }
 
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param a
+    //     * @param b
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    public static <R, E extends Exception> R[] zip(final byte[] a, final byte[] b, final Throwables.ByteBiFunction<? extends R, E> zipFunction,
+    //            final Class<? extends R> targetElementType) throws E {
+    //        final int lenA = N.len(a);
+    //        final int lenB = N.len(b);
+    //
+    //        final R[] result = Array.newInstance(targetElementType, N.min(lenA, lenB));
+    //
+    //        for (int i = 0, len = result.length; i < len; i++) {
+    //            result[i] = zipFunction.apply(a[i], b[i]);
+    //        }
+    //
+    //        return result;
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param a
+    //     * @param b
+    //     * @param valueForNoneA
+    //     * @param valueForNoneB
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    public static <R, E extends Exception> R[] zip(final byte[] a, final byte[] b, final byte valueForNoneA, final byte valueForNoneB,
+    //            final Throwables.ByteBiFunction<? extends R, E> zipFunction, final Class<? extends R> targetElementType) throws E {
+    //        final int lenA = N.len(a);
+    //        final int lenB = N.len(b);
+    //
+    //        return zip(N.max(lenA, lenB), a, b, valueForNoneA, valueForNoneB, zipFunction, targetElementType);
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param len
+    //     * @param a
+    //     * @param b
+    //     * @param valueForNoneA
+    //     * @param valueForNoneB
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    private static <R, E extends Exception> R[] zip(final int len, final byte[] a, final byte[] b, final byte valueForNoneA, final byte valueForNoneB,
+    //            final Throwables.ByteBiFunction<? extends R, E> zipFunction, final Class<? extends R> targetElementType) throws E {
+    //        final int lenA = N.len(a);
+    //        final int lenB = N.len(b);
+    //
+    //        final R[] result = Array.newInstance(targetElementType, len);
+    //
+    //        for (int i = 0, min = N.min(lenA, lenB, len); i < min; i++) {
+    //            result[i] = zipFunction.apply(a[i], b[i]);
+    //        }
+    //
+    //        if (lenA < lenB && lenA < len) {
+    //            for (int i = lenA, min = N.min(lenB, len); i < min; i++) {
+    //                result[i] = zipFunction.apply(valueForNoneA, b[i]);
+    //            }
+    //        } else if (lenB < lenA && lenB < len) {
+    //            for (int i = lenB, min = N.min(lenA, len); i < min; i++) {
+    //                result[i] = zipFunction.apply(a[i], valueForNoneB);
+    //            }
+    //        }
+    //
+    //        if (N.max(lenA, lenB) < len) {
+    //            for (int i = N.max(lenA, lenB); i < len; i++) {
+    //                result[i] = zipFunction.apply(valueForNoneA, valueForNoneB);
+    //            }
+    //        }
+    //
+    //        return result;
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param a
+    //     * @param b
+    //     * @param c
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    public static <R, E extends Exception> R[] zip(final byte[] a, final byte[] b, final byte[] c, final Throwables.ByteTriFunction<? extends R, E> zipFunction,
+    //            final Class<? extends R> targetElementType) throws E {
+    //        final int lenA = N.len(a);
+    //        final int lenB = N.len(b);
+    //        final int lenC = N.len(c);
+    //
+    //        final R[] result = Array.newInstance(targetElementType, N.min(lenA, lenB, lenC));
+    //
+    //        for (int i = 0, len = result.length; i < len; i++) {
+    //            result[i] = zipFunction.apply(a[i], b[i], c[i]);
+    //        }
+    //
+    //        return result;
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param a
+    //     * @param b
+    //     * @param c
+    //     * @param valueForNoneA
+    //     * @param valueForNoneB
+    //     * @param valueForNoneC
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    public static <R, E extends Exception> R[] zip(final byte[] a, final byte[] b, final byte[] c, final byte valueForNoneA, final byte valueForNoneB,
+    //            final byte valueForNoneC, final Throwables.ByteTriFunction<? extends R, E> zipFunction, final Class<? extends R> targetElementType) throws E {
+    //        final int lenA = N.len(a);
+    //        final int lenB = N.len(b);
+    //        final int lenC = N.len(c);
+    //
+    //        return zip(N.max(lenA, lenB, lenC), a, b, c, valueForNoneA, valueForNoneB, valueForNoneC, zipFunction, targetElementType);
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param len
+    //     * @param a
+    //     * @param b
+    //     * @param c
+    //     * @param valueForNoneA
+    //     * @param valueForNoneB
+    //     * @param valueForNoneC
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    private static <R, E extends Exception> R[] zip(final int len, final byte[] a, final byte[] b, final byte[] c, final byte valueForNoneA,
+    //            final byte valueForNoneB, final byte valueForNoneC, final Throwables.ByteTriFunction<? extends R, E> zipFunction,
+    //            final Class<? extends R> targetElementType) throws E {
+    //        final int lenA = N.len(a);
+    //        final int lenB = N.len(b);
+    //        final int lenC = N.len(c);
+    //
+    //        final R[] result = Array.newInstance(targetElementType, len);
+    //
+    //        for (int i = 0, min = N.min(lenA, lenB, lenC, len); i < min; i++) {
+    //            result[i] = zipFunction.apply(a[i], b[i], c[i]);
+    //        }
+    //
+    //        if (N.min(lenA, lenB, lenC) < len) {
+    //            for (int i = N.min(lenA, lenB, lenC); i < len; i++) {
+    //                result[i] = zipFunction.apply(i < lenA ? a[i] : valueForNoneA, i < lenB ? b[i] : valueForNoneB, i < lenC ? c[i] : valueForNoneC);
+    //            }
+    //        }
+    //
+    //        return result;
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param a
+    //     * @param b
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    public static <R, E extends Exception> R[][] zip(final byte[][] a, final byte[][] b, final Throwables.ByteBiFunction<? extends R, E> zipFunction,
+    //            final Class<? extends R> targetElementType) throws E {
+    //        final int lenA = N.len(a);
+    //        final int lenB = N.len(b);
+    //
+    //        final R[][] result = Array.newInstance(targetElementType, N.min(lenA, lenB), 0);
+    //
+    //        for (int i = 0, len = result.length; i < len; i++) {
+    //            result[i] = zip(a[i], b[i], zipFunction, targetElementType);
+    //        }
+    //
+    //        return result;
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param a
+    //     * @param b
+    //     * @param valueForNoneA
+    //     * @param valueForNoneB
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    public static <R, E extends Exception> R[][] zip(final byte[][] a, final byte[][] b, final byte valueForNoneA, final byte valueForNoneB,
+    //            final Throwables.ByteBiFunction<? extends R, E> zipFunction, final Class<? extends R> targetElementType) throws E {
+    //        return zip(N.max(N.len(a), N.len(b)), N.max(maxSubArrayLen(a), maxSubArrayLen(b)), a, b, valueForNoneA, valueForNoneB, zipFunction, targetElementType);
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param len
+    //     * @param rowLen
+    //     * @param a
+    //     * @param b
+    //     * @param valueForNoneA
+    //     * @param valueForNoneB
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    private static <R, E extends Exception> R[][] zip(final int len, final int rowLen, final byte[][] a, final byte[][] b, final byte valueForNoneA,
+    //            final byte valueForNoneB, final Throwables.ByteBiFunction<? extends R, E> zipFunction, final Class<? extends R> targetElementType) throws E {
+    //        final int lenA = N.len(a);
+    //        final int lenB = N.len(b);
+    //
+    //        final R[][] result = Array.newInstance(targetElementType, len, 0);
+    //
+    //        for (int i = 0, min = N.min(lenA, lenB, len); i < min; i++) {
+    //            result[i] = zip(rowLen, a[i], b[i], valueForNoneA, valueForNoneB, zipFunction, targetElementType);
+    //        }
+    //
+    //        if (lenA < lenB && lenA < len) {
+    //            for (int i = lenA, min = N.min(lenB, len); i < min; i++) {
+    //                result[i] = zip(rowLen, null, b[i], valueForNoneA, valueForNoneB, zipFunction, targetElementType);
+    //            }
+    //        } else if (lenB < lenA && lenB < len) {
+    //            for (int i = lenB, min = N.min(lenA, len); i < min; i++) {
+    //                result[i] = zip(rowLen, a[i], null, valueForNoneA, valueForNoneB, zipFunction, targetElementType);
+    //            }
+    //        }
+    //
+    //        if (N.max(lenA, lenB) < len) {
+    //            for (int i = N.max(lenA, lenB); i < len; i++) {
+    //                result[i] = zip(rowLen, null, null, valueForNoneA, valueForNoneB, zipFunction, targetElementType);
+    //            }
+    //        }
+    //
+    //        return result;
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param a
+    //     * @param b
+    //     * @param c
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    public static <R, E extends Exception> R[][] zip(final byte[][] a, final byte[][] b, final byte[][] c,
+    //            final Throwables.ByteTriFunction<? extends R, E> zipFunction, final Class<? extends R> targetElementType) throws E {
+    //        final int lenA = N.len(a);
+    //        final int lenB = N.len(b);
+    //        final int lenC = N.len(c);
+    //
+    //        final R[][] result = Array.newInstance(targetElementType, N.min(lenA, lenB, lenC), 0);
+    //
+    //        for (int i = 0, len = result.length; i < len; i++) {
+    //            result[i] = zip(a[i], b[i], c[i], zipFunction, targetElementType);
+    //        }
+    //
+    //        return result;
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param a
+    //     * @param b
+    //     * @param c
+    //     * @param valueForNoneA
+    //     * @param valueForNoneB
+    //     * @param valueForNoneC
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    public static <R, E extends Exception> R[][] zip(final byte[][] a, final byte[][] b, final byte[][] c, final byte valueForNoneA, final byte valueForNoneB,
+    //            final byte valueForNoneC, final Throwables.ByteTriFunction<? extends R, E> zipFunction, final Class<? extends R> targetElementType) throws E {
+    //        return zip(N.max(N.len(a), N.len(b), N.len(c)), N.max(maxSubArrayLen(a), maxSubArrayLen(b), maxSubArrayLen(c)), a, b, c, valueForNoneA, valueForNoneB,
+    //                valueForNoneC, zipFunction, targetElementType);
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param len
+    //     * @param rowLen
+    //     * @param a
+    //     * @param b
+    //     * @param c
+    //     * @param valueForNoneA
+    //     * @param valueForNoneB
+    //     * @param valueForNoneC
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    private static <R, E extends Exception> R[][] zip(final int len, final int rowLen, final byte[][] a, final byte[][] b, final byte[][] c,
+    //            final byte valueForNoneA, final byte valueForNoneB, final byte valueForNoneC, final Throwables.ByteTriFunction<? extends R, E> zipFunction,
+    //            final Class<? extends R> targetElementType) throws E {
+    //        final int lenA = N.len(a);
+    //        final int lenB = N.len(b);
+    //        final int lenC = N.len(c);
+    //
+    //        final R[][] result = Array.newInstance(targetElementType, len, 0);
+    //
+    //        for (int i = 0, min = N.min(lenA, lenB, lenC, len); i < min; i++) {
+    //            result[i] = zip(rowLen, a[i], b[i], c[i], valueForNoneA, valueForNoneB, valueForNoneC, zipFunction, targetElementType);
+    //        }
+    //
+    //        if (N.min(lenA, lenB, lenC) < len) {
+    //            for (int i = N.min(lenA, lenB, lenC); i < len; i++) {
+    //                result[i] = zip(rowLen, i < lenA ? a[i] : null, i < lenB ? b[i] : null, i < lenC ? c[i] : null, valueForNoneA, valueForNoneB, valueForNoneC,
+    //                        zipFunction, targetElementType);
+    //            }
+    //        }
+    //
+    //        return result;
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param a
+    //     * @param b
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    public static <R, E extends Exception> R[][][] zip(final byte[][][] a, final byte[][][] b, final Throwables.ByteBiFunction<? extends R, E> zipFunction,
+    //            final Class<? extends R> targetElementType) throws E {
+    //        final int lenA = N.len(a);
+    //        final int lenB = N.len(b);
+    //
+    //        final R[][][] result = Array.newInstance(targetElementType, N.min(lenA, lenB), 0, 0);
+    //
+    //        for (int i = 0, len = result.length; i < len; i++) {
+    //            result[i] = zip(a[i], b[i], zipFunction, targetElementType);
+    //        }
+    //
+    //        return result;
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param a
+    //     * @param b
+    //     * @param valueForNoneA
+    //     * @param valueForNoneB
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    public static <R, E extends Exception> R[][][] zip(final byte[][][] a, final byte[][][] b, final byte valueForNoneA, final byte valueForNoneB,
+    //            final Throwables.ByteBiFunction<? extends R, E> zipFunction, final Class<? extends R> targetElementType) throws E {
+    //        final int lenA = N.len(a);
+    //        final int lenB = N.len(b);
+    //
+    //        final R[][][] result = Array.newInstance(targetElementType, N.max(lenA, lenB), 0, 0);
+    //
+    //        for (int i = 0, min = N.min(lenA, lenB); i < min; i++) {
+    //            result[i] = zip(a[i], b[i], valueForNoneA, valueForNoneB, zipFunction, targetElementType);
+    //        }
+    //
+    //        if (lenA < lenB) {
+    //            for (int i = lenA; i < lenB; i++) {
+    //                result[i] = zip(null, b[i], valueForNoneA, valueForNoneB, zipFunction, targetElementType);
+    //            }
+    //        } else if (lenB < lenA) {
+    //            for (int i = lenB; i < lenA; i++) {
+    //                result[i] = zip(a[i], null, valueForNoneA, valueForNoneB, zipFunction, targetElementType);
+    //            }
+    //        }
+    //
+    //        return result;
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param a
+    //     * @param b
+    //     * @param c
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    public static <R, E extends Exception> R[][][] zip(final byte[][][] a, final byte[][][] b, final byte[][][] c,
+    //            final Throwables.ByteTriFunction<? extends R, E> zipFunction, final Class<? extends R> targetElementType) throws E {
+    //        final int lenA = N.len(a);
+    //        final int lenB = N.len(b);
+    //        final int lenC = N.len(c);
+    //
+    //        final R[][][] result = Array.newInstance(targetElementType, N.min(lenA, lenB, lenC), 0, 0);
+    //
+    //        for (int i = 0, len = result.length; i < len; i++) {
+    //            result[i] = zip(a[i], b[i], c[i], zipFunction, targetElementType);
+    //        }
+    //
+    //        return result;
+    //    }
+    //
+    //    /**
+    //     *
+    //     * @param <R>
+    //     * @param <E>
+    //     * @param a
+    //     * @param b
+    //     * @param c
+    //     * @param valueForNoneA
+    //     * @param valueForNoneB
+    //     * @param valueForNoneC
+    //     * @param zipFunction
+    //     * @param targetElementType
+    //     * @return
+    //     * @throws E the e
+    //     */
+    //    public static <R, E extends Exception> R[][][] zip(final byte[][][] a, final byte[][][] b, final byte[][][] c, final byte valueForNoneA,
+    //            final byte valueForNoneB, final byte valueForNoneC, final Throwables.ByteTriFunction<? extends R, E> zipFunction,
+    //            final Class<? extends R> targetElementType) throws E {
+    //        final int lenA = N.len(a);
+    //        final int lenB = N.len(b);
+    //        final int lenC = N.len(c);
+    //
+    //        final R[][][] result = Array.newInstance(targetElementType, N.max(lenA, lenB, lenC), 0, 0);
+    //
+    //        for (int i = 0, min = N.min(lenA, lenB, lenC); i < min; i++) {
+    //            result[i] = zip(a[i], b[i], c[i], valueForNoneA, valueForNoneB, valueForNoneC, zipFunction, targetElementType);
+    //        }
+    //
+    //        for (int i = N.min(lenA, lenB, lenC), len = result.length; i < len; i++) {
+    //            result[i] = zip(i < lenA ? a[i] : null, i < lenB ? b[i] : null, i < lenC ? c[i] : null, valueForNoneA, valueForNoneB, valueForNoneC, zipFunction,
+    //                    targetElementType);
+    //        }
+    //
+    //        return result;
+    //    }
+
     public static long totalCountOfElements(final byte[][] a) {
         long count = 0;
 
diff --git a/src/test/java/com/landawn/abacus/util/ArraysTest.java b/src/test/java/com/landawn/abacus/util/ArraysTest.java
index f6ca794..6a0a1a7 100644
--- a/src/test/java/com/landawn/abacus/util/ArraysTest.java
+++ b/src/test/java/com/landawn/abacus/util/ArraysTest.java
@@ -22,9 +22,15 @@ class ArraysTest {
     @Test
     public void test_minSubArrayLen() {
         final String[][] a = { { "a", "b" }, { "c", "d", "d" } };
+        final String[][][] b = { { { "a", "b" } }, { { "1", "2" }, { "3", "4" } } };
+        final int[][][] c = Arrays.reshape(Array.rangeClosed(1, 9), 2, 3);
 
         assertEquals(2, Arrays.ff.minSubArrayLen(a));
         assertEquals(3, Arrays.ff.maxSubArrayLen(a));
+        assertEquals(1, Arrays.ff.minSubArrayLen(b));
+        assertEquals(2, Arrays.ff.maxSubArrayLen(b));
+        assertEquals(1, Arrays.ff.minSubArrayLen(c));
+        assertEquals(2, Arrays.ff.maxSubArrayLen(c));
 
     }