diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
index ee74961f1e..d602bfe00d 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/max.kt
@@ -13,6 +13,7 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -35,25 +36,25 @@ public fun <T : Comparable<T>> DataColumn<T?>.max(skipNaN: Boolean = skipNaNDefa
 public fun <T : Comparable<T>> DataColumn<T?>.maxOrNull(skipNaN: Boolean = skipNaNDefault): T? =
     Aggregators.max<T>(skipNaN).aggregateSingleColumn(this)
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T & Any = maxByOrNull(skipNaN, selector).suggestIfNull("maxBy")
+): T = maxByOrNull(skipNaN, selector).suggestIfNull("maxBy")
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxByOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.max<R>(skipNaN).aggregateByOrNull(this, selector)
+): T? = Aggregators.max.invoke(skipNaN).cast<R>().aggregateByOrNull(this, selector)
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R & Any = maxOfOrNull(skipNaN, selector).suggestIfNull("maxOf")
+): R = maxOfOrNull(skipNaN, selector).suggestIfNull("maxOf")
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R? = Aggregators.max<R>(skipNaN).aggregateOf(this, selector)
+): R? = Aggregators.max.invoke(skipNaN).cast<R>().aggregateOf(this, selector)
 
 // endregion
 
@@ -103,61 +104,61 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxFor(skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C & Any = maxOrNull(skipNaN, columns).suggestIfNull("max")
+): C = maxOrNull(skipNaN, columns).suggestIfNull("max")
 
 public fun <T> DataFrame<T>.max(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any> =
     maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C & Any = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
+): C = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C & Any = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
+): C = maxOrNull(*columns, skipNaN = skipNaN).suggestIfNull("max")
 
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C? = Aggregators.max<C>(skipNaN).aggregateAll(this, columns)
+): C? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.maxOrNull(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any>? =
     maxOrNull(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = maxOrNull(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = maxOrNull(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOf(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C & Any = maxOfOrNull(skipNaN, expression).suggestIfNull("maxOf")
+): C = maxOfOrNull(skipNaN, expression).suggestIfNull("maxOf")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOfOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C? = Aggregators.max<C>(skipNaN).aggregateOf(this, expression)
+): C? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = maxByOrNull(skipNaN, expression).suggestIfNull("maxBy")
@@ -167,36 +168,36 @@ public fun <T> DataFrame<T>.maxBy(column: String, skipNaN: Boolean = skipNaNDefa
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxByOrNull(column, skipNaN).suggestIfNull("maxBy")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxByOrNull(column, skipNaN).suggestIfNull("maxBy")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.max<C>(skipNaN).aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.maxByOrNull(column: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>? =
     maxByOrNull(column.toColumnOf<Comparable<Any>?>(), skipNaN)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.max<C>(skipNaN).aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.max.invoke(skipNaN).cast<C>().aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T>? = maxByOrNull(column.toColumnAccessor(), skipNaN)
@@ -236,11 +237,11 @@ public fun <T, C : Comparable<*>?> Grouped<T>.maxFor(
 
 @Refine
 @Interpretable("GroupByMax0")
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+public fun <T, C : Comparable<*>?> Grouped<T>.max(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C?>,
-): DataFrame<T> = Aggregators.max<C>(skipNaN).aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.max.invoke(skipNaN).cast<C>().aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.max(
     vararg columns: String,
@@ -250,7 +251,7 @@ public fun <T> Grouped<T>.max(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+public fun <T, C : Comparable<*>?> Grouped<T>.max(
     vararg columns: ColumnReference<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -258,7 +259,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+public fun <T, C : Comparable<*>?> Grouped<T>.max(
     vararg columns: KProperty<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -266,21 +267,21 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
 
 @Refine
 @Interpretable("GroupByMaxOf")
-public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.maxOf(
+public inline fun <T, reified C : Comparable<*>?> Grouped<T>.maxOf(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataFrame<T> = Aggregators.max<C>(skipNaN).aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.max.invoke(skipNaN).cast<C>().aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression")
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = reduce { maxByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = reduce { maxByOrNull(column, skipNaN) }
@@ -290,7 +291,7 @@ public fun <T, G> GroupBy<T, G>.maxBy(column: String, skipNaN: Boolean = skipNaN
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = maxBy(column.toColumnAccessor(), skipNaN)
@@ -330,41 +331,43 @@ public fun <T, R : Comparable<*>?> Pivot<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = maxFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(
+public fun <T, R : Comparable<*>?> Pivot<T>.max(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
-): DataRow<T> = delegate { max(skipNaN, columns) }
+): DataRow<T> = delegate { maxFor(separate = false, skipNaN, columns) }
 
-public fun <T> Pivot<T>.max(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataRow<T> =
-    max(skipNaN) { columns.toComparableColumns() }
+public fun <T, R : Comparable<*>?> Pivot<T>.max(
+    vararg columns: String,
+    skipNaN: Boolean = skipNaNDefault,
+): DataRow<T> = max(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(
+public fun <T, R : Comparable<*>?> Pivot<T>.max(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = max(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(
+public fun <T, R : Comparable<*>?> Pivot<T>.max(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = max(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = delegate { maxOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = reduce { maxByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = reduce { maxByOrNull(column, skipNaN) }
@@ -374,7 +377,7 @@ public fun <T> Pivot<T>.maxBy(column: String, skipNaN: Boolean = skipNaNDefault)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = maxBy(column.toColumnAccessor(), skipNaN)
@@ -414,39 +417,39 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = maxFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
-): DataFrame<T> = Aggregators.max<R>(skipNaN).aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.max.invoke(skipNaN).cast<R>().aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.max(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     max(skipNaN) { columns.toComparableColumns() }
 
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = max(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = max(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = aggregate { maxOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = reduce { maxByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = reduce { maxByOrNull(column, skipNaN) }
@@ -456,7 +459,7 @@ public fun <T> PivotGroupBy<T>.maxBy(column: String, skipNaN: Boolean = skipNaND
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = maxBy(column.toColumnAccessor(), skipNaN)
@@ -473,26 +476,26 @@ public fun <T : Comparable<T>> DataColumn<T?>.max(): T = max(skipNaN = skipNaNDe
 public fun <T : Comparable<T>> DataColumn<T?>.maxOrNull(): T? = maxOrNull(skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxBy(noinline selector: (T) -> R): T & Any =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxBy(noinline selector: (T) -> R): T =
     maxBy(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxByOrNull(noinline selector: (T) -> R): T? =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxByOrNull(noinline selector: (T) -> R): T? =
     maxByOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOf(crossinline selector: (T) -> R): R & Any =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOf(crossinline selector: (T) -> R): R =
     maxOf(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.maxOfOrNull(crossinline selector: (T) -> R): R? =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.maxOfOrNull(crossinline selector: (T) -> R): R? =
     maxOfOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public inline fun <reified T : Comparable<T>> AnyRow.rowMaxOfOrNull(): T? = rowMaxOfOrNull<T>(skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <reified T : Comparable<T & Any>?> AnyRow.rowMaxOf(): T & Any = rowMaxOf(skipNaN = skipNaNDefault)
+public inline fun <reified T : Comparable<T>> AnyRow.rowMaxOf(): T = rowMaxOf(skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> DataFrame<T>.max(): DataRow<T> = max(skipNaN = skipNaNDefault)
@@ -516,7 +519,7 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.maxFor(vararg columns: KProperty
     maxFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(columns: ColumnsSelector<T, C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(columns: ColumnsSelector<T, C>): C =
     max(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -525,16 +528,16 @@ public fun <T> DataFrame<T>.max(vararg columns: String): Comparable<Any> =
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(vararg columns: ColumnReference<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(vararg columns: ColumnReference<C>): C =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.max(vararg columns: KProperty<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.max(vararg columns: KProperty<C>): C =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(columns: ColumnsSelector<T, C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(columns: ColumnsSelector<T, C>): C? =
     maxOrNull(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -543,26 +546,25 @@ public fun <T> DataFrame<T>.maxOrNull(vararg columns: String): Comparable<Any>?
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(vararg columns: ColumnReference<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(vararg columns: ColumnReference<C>): C? =
     maxOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.maxOrNull(vararg columns: KProperty<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.maxOrNull(vararg columns: KProperty<C>): C? =
     maxOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOf(
-    crossinline expression: RowExpression<T, C>,
-): C & Any = maxOf(skipNaN = skipNaNDefault, expression = expression)
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOf(crossinline expression: RowExpression<T, C>): C =
+    maxOf(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxOfOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxOfOrNull(
     crossinline expression: RowExpression<T, C>,
 ): C? = maxOfOrNull(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = maxBy(skipNaN = skipNaNDefault, expression = expression)
 
@@ -571,16 +573,16 @@ public fun <T> DataFrame<T>.maxBy(column: String): DataRow<T> = maxBy(column, sk
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(column: ColumnReference<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(column: ColumnReference<C>): DataRow<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxBy(column: KProperty<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxBy(column: KProperty<C>): DataRow<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T>? = maxByOrNull(skipNaN = skipNaNDefault, expression = expression)
 
@@ -589,13 +591,12 @@ public fun <T> DataFrame<T>.maxByOrNull(column: String): DataRow<T>? = maxByOrNu
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(
-    column: ColumnReference<C>,
-): DataRow<T>? = maxByOrNull(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(column: ColumnReference<C>): DataRow<T>? =
+    maxByOrNull(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.maxByOrNull(column: KProperty<C>): DataRow<T>? =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.maxByOrNull(column: KProperty<C>): DataRow<T>? =
     maxByOrNull(column, skipNaN = skipNaNDefault)
 
 @Refine
@@ -626,7 +627,7 @@ public fun <T, C : Comparable<*>?> Grouped<T>.maxFor(vararg columns: KProperty<C
 @Refine
 @Interpretable("GroupByMax0")
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+public fun <T, C : Comparable<*>?> Grouped<T>.max(
     name: String? = null,
     columns: ColumnsSelector<T, C?>,
 ): DataFrame<T> = max(name, skipNaN = skipNaNDefault, columns = columns)
@@ -637,35 +638,33 @@ public fun <T> Grouped<T>.max(vararg columns: String, name: String? = null): Dat
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
+public fun <T, C : Comparable<*>?> Grouped<T>.max(
     vararg columns: ColumnReference<C>,
     name: String? = null,
 ): DataFrame<T> = max(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.max(
-    vararg columns: KProperty<C>,
-    name: String? = null,
-): DataFrame<T> = max(columns = columns, name = name, skipNaN = skipNaNDefault)
+public fun <T, C : Comparable<*>?> Grouped<T>.max(vararg columns: KProperty<C>, name: String? = null): DataFrame<T> =
+    max(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @Refine
 @Interpretable("GroupByMaxOf")
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.maxOf(
+public inline fun <T, reified C : Comparable<*>?> Grouped<T>.maxOf(
     name: String? = null,
     crossinline expression: RowExpression<T, C>,
 ): DataFrame<T> = maxOf(name, skipNaN = skipNaNDefault, expression = expression)
 
 @Interpretable("GroupByReduceExpression")
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.maxBy(
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = maxBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(
     column: ColumnReference<C>,
 ): ReducedGroupBy<T, G> = maxBy(column, skipNaN = skipNaNDefault)
 
@@ -674,9 +673,8 @@ public fun <T, G> GroupBy<T, G>.maxBy(column: String): ReducedGroupBy<T, G> = ma
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.maxBy(
-    column: KProperty<C>,
-): ReducedGroupBy<T, G> = maxBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.maxBy(column: KProperty<C>): ReducedGroupBy<T, G> =
+    maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> Pivot<T>.max(separate: Boolean = false): DataRow<T> = max(separate, skipNaN = skipNaNDefault)
@@ -706,32 +704,32 @@ public fun <T, R : Comparable<*>?> Pivot<T>.maxFor(
 ): DataRow<T> = maxFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(columns: ColumnsSelector<T, R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.max(columns: ColumnsSelector<T, R>): DataRow<T> =
     max(skipNaN = skipNaNDefault, columns = columns)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(vararg columns: ColumnReference<R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.max(vararg columns: ColumnReference<R>): DataRow<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.max(vararg columns: KProperty<R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.max(vararg columns: KProperty<R>): DataRow<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = maxOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.maxBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = maxBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(column: ColumnReference<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(column: ColumnReference<C>): ReducedPivot<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -739,7 +737,7 @@ public fun <T> Pivot<T>.maxBy(column: String): ReducedPivot<T> = maxBy(column, s
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.maxBy(column: KProperty<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.maxBy(column: KProperty<C>): ReducedPivot<T> =
     maxBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -770,7 +768,7 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.maxFor(
 ): DataFrame<T> = maxFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(columns: ColumnsSelector<T, R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(columns: ColumnsSelector<T, R>): DataFrame<T> =
     max(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -778,27 +776,27 @@ public fun <T> PivotGroupBy<T>.max(vararg columns: String): DataFrame<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(vararg columns: ColumnReference<R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(vararg columns: ColumnReference<R>): DataFrame<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.max(vararg columns: KProperty<R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.max(vararg columns: KProperty<R>): DataFrame<T> =
     max(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = maxOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.maxBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = maxBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(
     column: ColumnReference<C>,
 ): ReducedPivotGroupBy<T> = maxBy(column, skipNaN = skipNaNDefault)
 
@@ -807,8 +805,7 @@ public fun <T> PivotGroupBy<T>.maxBy(column: String): ReducedPivotGroupBy<T> = m
 
 @AccessApiOverload
 @Deprecated(MAX_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.maxBy(
-    column: KProperty<C>,
-): ReducedPivotGroupBy<T> = maxBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.maxBy(column: KProperty<C>): ReducedPivotGroupBy<T> =
+    maxBy(column, skipNaN = skipNaNDefault)
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
index 6a1b29daff..20e302c8e7 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/median.kt
@@ -15,6 +15,8 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast2
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -45,61 +47,58 @@ import kotlin.reflect.KProperty
 
 // region DataColumn
 
-public fun <T : Comparable<T & Any>?> DataColumn<T>.median(): T & Any = medianOrNull().suggestIfNull("median")
+public fun <T : Comparable<*>?> DataColumn<T>.median(): T = medianOrNull().suggestIfNull("median")
 
-public fun <T : Comparable<T & Any>?> DataColumn<T>.medianOrNull(): T? =
-    Aggregators.medianComparables<T>().aggregateSingleColumn(this)
+public fun <T : Comparable<*>?> DataColumn<T>.medianOrNull(): T? =
+    Aggregators.median(skipNaNDefault).cast<T>().aggregateSingleColumn(this)
 
 public fun <T> DataColumn<T>.median(
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where T : Comparable<T & Any>?, T : Number? = medianOrNull(skipNaN = skipNaN).suggestIfNull("median")
+    where T : Comparable<*>?, T : Number? = medianOrNull(skipNaN = skipNaN).suggestIfNull("median")
 
 public fun <T> DataColumn<T>.medianOrNull(
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where T : Comparable<T & Any>?, T : Number? =
-    Aggregators.medianNumbers<T>(skipNaN).aggregateSingleColumn(this)
+    where T : Comparable<*>?, T : Number? =
+    Aggregators.median(skipNaN).cast2<T & Any, Double?>().aggregateSingleColumn(this)
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianBy(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T & Any = medianByOrNull(skipNaN, selector).suggestIfNull("medianBy")
+): T = medianByOrNull(skipNaN, selector).suggestIfNull("medianBy")
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianByOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.medianCommon<R>(skipNaN).aggregateByOrNull(this, selector)
+): T? = Aggregators.median(skipNaN).cast<R>().aggregateByOrNull(this, selector)
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianOf(
-    crossinline expression: (T) -> R,
-): R & Any = medianOfOrNull(expression).suggestIfNull("medianOf")
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianOf(crossinline expression: (T) -> R): R =
+    medianOfOrNull(expression).suggestIfNull("medianOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.medianOfOrNull(
-    crossinline expression: (T) -> R,
-): R? = Aggregators.medianComparables<R>().aggregateOf(this, expression)
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.medianOfOrNull(crossinline expression: (T) -> R): R? =
+    Aggregators.median(skipNaNDefault).cast<R>().aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataColumn<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double
-    where R : Comparable<R & Any>?, R : Number? =
-    medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
+    where R : Comparable<*>?, R : Number? = medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataColumn<T>.medianOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double?
-    where R : Comparable<R & Any>?, R : Number? =
-    Aggregators.medianNumbers<R>(skipNaN).aggregateOf(this, expression)
+    where R : Comparable<*>?, R : Number? =
+    Aggregators.median(skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
 
 // endregion
 
@@ -162,21 +161,21 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.medianFor(
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.median(columns: ColumnsSelector<T, C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.median(columns: ColumnsSelector<T, C>): C =
     medianOrNull(columns).suggestIfNull("median")
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
 @Suppress("UNCHECKED_CAST")
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianOrNull(columns: ColumnsSelector<T, C>): C? =
-    Aggregators.medianComparables<C>().aggregateAll(this, columns)
+public fun <T, C : Comparable<*>?> DataFrame<T>.medianOrNull(columns: ColumnsSelector<T, C>): C? =
+    Aggregators.median(skipNaNDefault).cast<C>().aggregateAll(this, columns)
 
 @OverloadResolutionByLambdaReturnType
 public fun <T, C> DataFrame<T>.median(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double
-    where C : Number?, C : Comparable<C & Any>? = medianOrNull(skipNaN, columns).suggestIfNull("median")
+    where C : Number?, C : Comparable<*>? = medianOrNull(skipNaN, columns).suggestIfNull("median")
 
 @OverloadResolutionByLambdaReturnType
 @Suppress("UNCHECKED_CAST")
@@ -184,8 +183,8 @@ public fun <T, C> DataFrame<T>.medianOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? =
-    Aggregators.medianNumbers<C>(skipNaN).aggregateAll(this, columns)
+    where C : Comparable<*>?, C : Number? =
+    Aggregators.median(skipNaN).cast2<C & Any, Double?>().aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.median(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Any =
     medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
@@ -195,12 +194,12 @@ public fun <T> DataFrame<T>.medianOrNull(vararg columns: String, skipNaN: Boolea
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.median(vararg columns: ColumnReference<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.median(vararg columns: ColumnReference<C>): C =
     medianOrNull(*columns).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianOrNull(vararg columns: ColumnReference<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.medianOrNull(vararg columns: ColumnReference<C>): C? =
     medianOrNull<T, C> { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -209,8 +208,7 @@ public fun <T, C> DataFrame<T>.median(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<C & Any>?, C : Number? =
-    medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
+    where C : Comparable<*>?, C : Number? = medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
@@ -218,16 +216,16 @@ public fun <T, C> DataFrame<T>.medianOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
+    where C : Comparable<*>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.median(vararg columns: KProperty<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.median(vararg columns: KProperty<C>): C =
     medianOrNull(*columns).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.medianOrNull(vararg columns: KProperty<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.medianOrNull(vararg columns: KProperty<C>): C? =
     medianOrNull<T, C> { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -236,8 +234,7 @@ public fun <T, C> DataFrame<T>.median(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<C & Any>?, C : Number? =
-    medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
+    where C : Comparable<*>?, C : Number? = medianOrNull(*columns, skipNaN = skipNaN).suggestIfNull("median")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
@@ -245,37 +242,36 @@ public fun <T, C> DataFrame<T>.medianOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
+    where C : Comparable<*>?, C : Number? = medianOrNull(skipNaN) { columns.toColumnSet() }
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.medianOf(
+public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.medianOf(
     crossinline expression: RowExpression<T, R>,
-): R & Any = medianOfOrNull(expression).suggestIfNull("medianOf")
+): R = medianOfOrNull(expression).suggestIfNull("medianOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.medianOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.medianOfOrNull(
     crossinline expression: RowExpression<T, R>,
-): R? = Aggregators.medianComparables<R>().aggregateOf(this, expression)
+): R? = Aggregators.median(skipNaNDefault).cast<R>().aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataFrame<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double
-    where R : Comparable<R & Any>?, R : Number? =
-    medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
+    where R : Comparable<*>?, R : Number? = medianOfOrNull(skipNaN, expression).suggestIfNull("medianOf")
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataFrame<T>.medianOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double?
-    where R : Comparable<R & Any>?, R : Number? =
-    Aggregators.medianNumbers<R>(skipNaN).aggregateOf(this, expression)
+    where R : Comparable<*>?, R : Number? =
+    Aggregators.median(skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = medianByOrNull(skipNaN, expression).suggestIfNull("medianBy")
@@ -285,36 +281,36 @@ public fun <T> DataFrame<T>.medianBy(column: String, skipNaN: Boolean = skipNaND
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = medianByOrNull(column, skipNaN).suggestIfNull("medianBy")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = medianByOrNull(column, skipNaN).suggestIfNull("medianBy")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.medianCommon<C>(skipNaN).aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.median(skipNaN).cast<C>().aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.medianByOrNull(column: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>? =
     medianByOrNull(column.toColumnOf<Comparable<Any>?>(), skipNaN)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianByOrNull(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.medianCommon<C>(skipNaN).aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.median(skipNaN).cast<C>().aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.medianByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.medianByOrNull(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T>? = medianByOrNull(column.toColumnAccessor(), skipNaN)
@@ -352,11 +348,11 @@ public fun <T, C : Comparable<*>?> Grouped<T>.medianFor(
 
 @Refine
 @Interpretable("GroupByMedian0")
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
+public fun <T, C : Comparable<*>?> Grouped<T>.median(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.medianCommon<C>(skipNaN).aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.median(skipNaN).cast<C>().aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.median(
     vararg columns: String,
@@ -366,7 +362,7 @@ public fun <T> Grouped<T>.median(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
+public fun <T, C : Comparable<*>?> Grouped<T>.median(
     vararg columns: ColumnReference<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -374,7 +370,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
+public fun <T, C : Comparable<*>?> Grouped<T>.median(
     vararg columns: KProperty<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -382,21 +378,21 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.median(
 
 @Refine
 @Interpretable("GroupByMedianOf")
-public inline fun <T, reified R : Comparable<R & Any>?> Grouped<T>.medianOf(
+public inline fun <T, reified R : Comparable<*>?> Grouped<T>.medianOf(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.medianCommon<R>(skipNaN).aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.median(skipNaN).cast<R>().aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression") // TODO?
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.medianBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = reduce { medianByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.medianBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = reduce { medianByOrNull(column, skipNaN) }
@@ -406,7 +402,7 @@ public fun <T, G> GroupBy<T, G>.medianBy(column: String, skipNaN: Boolean = skip
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.medianBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = medianBy(column.toColumnAccessor(), skipNaN)
@@ -446,7 +442,7 @@ public fun <T, C : Comparable<*>?> Pivot<T>.medianFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = medianFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.median(
+public fun <T, C : Comparable<*>?> Pivot<T>.median(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): DataRow<T> = delegate { median(skipNaN, columns) }
@@ -456,31 +452,31 @@ public fun <T> Pivot<T>.median(vararg columns: String, skipNaN: Boolean = skipNa
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.median(
+public fun <T, C : Comparable<*>?> Pivot<T>.median(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = median(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.median(
+public fun <T, C : Comparable<*>?> Pivot<T>.median(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = median(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.medianOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): DataRow<T> = delegate { medianOf(skipNaN, expression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.medianBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = reduce { medianByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = reduce { medianByOrNull(column, skipNaN) }
@@ -490,7 +486,7 @@ public fun <T> Pivot<T>.medianBy(column: String, skipNaN: Boolean = skipNaNDefau
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = medianBy(column.toColumnAccessor(), skipNaN)
@@ -529,41 +525,41 @@ public fun <T, C : Comparable<*>?> PivotGroupBy<T>.medianFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = medianFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.median(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.median(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.medianCommon<C>(skipNaN).aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.median(skipNaN).cast<C>().aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.median(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     median(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.median(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.median(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = median(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.median(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.median(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = median(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.medianOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.medianOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.medianCommon<R>(skipNaN).aggregateOf(this, expression)
+): DataFrame<T> = Aggregators.median(skipNaN).cast<R>().aggregateOf(this, expression)
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.medianBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.medianBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = reduce { medianByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.medianBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = reduce { medianByOrNull(column, skipNaN) }
@@ -573,7 +569,7 @@ public fun <T> PivotGroupBy<T>.medianBy(column: String, skipNaN: Boolean = skipN
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.medianBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.medianBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = medianBy(column.toColumnAccessor(), skipNaN)
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
index a0c8603a7a..c70862a648 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/min.kt
@@ -13,6 +13,7 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -35,25 +36,25 @@ public fun <T : Comparable<T>> DataColumn<T?>.min(skipNaN: Boolean = skipNaNDefa
 public fun <T : Comparable<T>> DataColumn<T?>.minOrNull(skipNaN: Boolean = skipNaNDefault): T? =
     Aggregators.min<T>(skipNaN).aggregateSingleColumn(this)
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T & Any = minByOrNull(skipNaN, selector).suggestIfNull("minBy")
+): T = minByOrNull(skipNaN, selector).suggestIfNull("minBy")
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minByOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.min<R>(skipNaN).aggregateByOrNull(this, selector)
+): T? = Aggregators.min.invoke(skipNaN).cast<R>().aggregateByOrNull(this, selector)
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R & Any = minOfOrNull(skipNaN, selector).suggestIfNull("minOf")
+): R = minOfOrNull(skipNaN, selector).suggestIfNull("minOf")
 
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): R? = Aggregators.min<R>(skipNaN).aggregateOf(this, selector)
+): R? = Aggregators.min.invoke(skipNaN).cast<R>().aggregateOf(this, selector)
 
 // endregion
 
@@ -103,61 +104,61 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minFor(skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C & Any = minOrNull(skipNaN, columns).suggestIfNull("min")
+): C = minOrNull(skipNaN, columns).suggestIfNull("min")
 
 public fun <T> DataFrame<T>.min(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any> =
     minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C & Any = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
+): C = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
-): C & Any = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
+): C = minOrNull(*columns, skipNaN = skipNaN).suggestIfNull("min")
 
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): C? = Aggregators.min<C>(skipNaN).aggregateAll(this, columns)
+): C? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.minOrNull(vararg columns: String, skipNaN: Boolean = skipNaNDefault): Comparable<Any>? =
     minOrNull(skipNaN) { columns.toComparableColumns() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = minOrNull(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): C? = minOrNull(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOf(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C & Any = minOfOrNull(skipNaN, expression).suggestIfNull("minOf")
+): C = minOfOrNull(skipNaN, expression).suggestIfNull("minOf")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOfOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): C? = Aggregators.min<C>(skipNaN).aggregateOf(this, expression)
+): C? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = minByOrNull(skipNaN, expression).suggestIfNull("minBy")
@@ -167,36 +168,36 @@ public fun <T> DataFrame<T>.minBy(column: String, skipNaN: Boolean = skipNaNDefa
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minByOrNull(column, skipNaN).suggestIfNull("minBy")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minByOrNull(column, skipNaN).suggestIfNull("minBy")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.min<C>(skipNaN).aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.minByOrNull(column: String, skipNaN: Boolean = skipNaNDefault): DataRow<T>? =
     minByOrNull(column.toColumnOf<Comparable<Any>?>(), skipNaN)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.min<C>(skipNaN).aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.min.invoke(skipNaN).cast<C>().aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T>? = minByOrNull(column.toColumnAccessor(), skipNaN)
@@ -236,11 +237,11 @@ public fun <T, C : Comparable<*>?> Grouped<T>.minFor(
 
 @Refine
 @Interpretable("GroupByMin0")
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+public fun <T, C : Comparable<*>?> Grouped<T>.min(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C?>,
-): DataFrame<T> = Aggregators.min<C>(skipNaN).aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.min.invoke(skipNaN).cast<C>().aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.min(
     vararg columns: String,
@@ -250,7 +251,7 @@ public fun <T> Grouped<T>.min(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+public fun <T, C : Comparable<*>?> Grouped<T>.min(
     vararg columns: ColumnReference<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -258,7 +259,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+public fun <T, C : Comparable<*>?> Grouped<T>.min(
     vararg columns: KProperty<C>,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
@@ -266,21 +267,21 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
 
 @Refine
 @Interpretable("GroupByMinOf")
-public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.minOf(
+public inline fun <T, reified C : Comparable<*>?> Grouped<T>.minOf(
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataFrame<T> = Aggregators.min<C>(skipNaN).aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.min.invoke(skipNaN).cast<C>().aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression")
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = reduce { minByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = reduce { minByOrNull(column, skipNaN) }
@@ -290,7 +291,7 @@ public fun <T, G> GroupBy<T, G>.minBy(column: String, skipNaN: Boolean = skipNaN
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedGroupBy<T, G> = minBy(column.toColumnAccessor(), skipNaN)
@@ -330,7 +331,7 @@ public fun <T, R : Comparable<*>?> Pivot<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = minFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(
+public fun <T, R : Comparable<*>?> Pivot<T>.min(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
 ): DataRow<T> = delegate { min(skipNaN, columns) }
@@ -340,31 +341,31 @@ public fun <T> Pivot<T>.min(vararg columns: String, skipNaN: Boolean = skipNaNDe
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(
+public fun <T, R : Comparable<*>?> Pivot<T>.min(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = min(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(
+public fun <T, R : Comparable<*>?> Pivot<T>.min(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = min(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = delegate { minOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = reduce { minByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = reduce { minByOrNull(column, skipNaN) }
@@ -374,7 +375,7 @@ public fun <T> Pivot<T>.minBy(column: String, skipNaN: Boolean = skipNaNDefault)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivot<T> = minBy(column.toColumnAccessor(), skipNaN)
@@ -414,39 +415,39 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = minFor(separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, R>,
-): DataFrame<T> = Aggregators.min<R>(skipNaN).aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.min.invoke(skipNaN).cast<R>().aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.min(vararg columns: String, skipNaN: Boolean = skipNaNDefault): DataFrame<T> =
     min(skipNaN) { columns.toComparableColumns() }
 
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(
     vararg columns: ColumnReference<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = min(skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(
     vararg columns: KProperty<R>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = min(skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = aggregate { minOf(skipNaN, rowExpression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minBy(
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = reduce { minByOrNull(skipNaN, rowExpression) }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = reduce { minByOrNull(column, skipNaN) }
@@ -456,7 +457,7 @@ public fun <T> PivotGroupBy<T>.minBy(column: String, skipNaN: Boolean = skipNaND
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): ReducedPivotGroupBy<T> = minBy(column.toColumnAccessor(), skipNaN)
@@ -473,26 +474,26 @@ public fun <T : Comparable<T>> DataColumn<T?>.min(): T = min(skipNaN = skipNaNDe
 public fun <T : Comparable<T>> DataColumn<T?>.minOrNull(): T? = minOrNull(skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minBy(noinline selector: (T) -> R): T & Any =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minBy(noinline selector: (T) -> R): T =
     minBy(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minByOrNull(noinline selector: (T) -> R): T? =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minByOrNull(noinline selector: (T) -> R): T? =
     minByOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOf(crossinline selector: (T) -> R): R & Any =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOf(crossinline selector: (T) -> R): R =
     minOf(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.minOfOrNull(crossinline selector: (T) -> R): R? =
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.minOfOrNull(crossinline selector: (T) -> R): R? =
     minOfOrNull(skipNaN = skipNaNDefault, selector = selector)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public inline fun <reified T : Comparable<T>> AnyRow.rowMinOfOrNull(): T? = rowMinOfOrNull<T>(skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <reified T : Comparable<T & Any>?> AnyRow.rowMinOf(): T & Any = rowMinOf(skipNaN = skipNaNDefault)
+public inline fun <reified T : Comparable<T>> AnyRow.rowMinOf(): T = rowMinOf(skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> DataFrame<T>.min(): DataRow<T> = min(skipNaN = skipNaNDefault)
@@ -516,7 +517,7 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.minFor(vararg columns: KProperty
     minFor(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(columns: ColumnsSelector<T, C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(columns: ColumnsSelector<T, C>): C =
     min(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -525,16 +526,16 @@ public fun <T> DataFrame<T>.min(vararg columns: String): Comparable<Any> =
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(vararg columns: ColumnReference<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(vararg columns: ColumnReference<C>): C =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.min(vararg columns: KProperty<C>): C & Any =
+public fun <T, C : Comparable<*>?> DataFrame<T>.min(vararg columns: KProperty<C>): C =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(columns: ColumnsSelector<T, C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(columns: ColumnsSelector<T, C>): C? =
     minOrNull(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -543,26 +544,25 @@ public fun <T> DataFrame<T>.minOrNull(vararg columns: String): Comparable<Any>?
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(vararg columns: ColumnReference<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(vararg columns: ColumnReference<C>): C? =
     minOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.minOrNull(vararg columns: KProperty<C>): C? =
+public fun <T, C : Comparable<*>?> DataFrame<T>.minOrNull(vararg columns: KProperty<C>): C? =
     minOrNull(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOf(
-    crossinline expression: RowExpression<T, C>,
-): C & Any = minOf(skipNaN = skipNaNDefault, expression = expression)
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOf(crossinline expression: RowExpression<T, C>): C =
+    minOf(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minOfOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minOfOrNull(
     crossinline expression: RowExpression<T, C>,
 ): C? = minOfOrNull(skipNaN = skipNaNDefault, expression = expression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T> = minBy(skipNaN = skipNaNDefault, expression = expression)
 
@@ -571,16 +571,16 @@ public fun <T> DataFrame<T>.minBy(column: String): DataRow<T> = minBy(column, sk
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(column: ColumnReference<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(column: ColumnReference<C>): DataRow<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minBy(column: KProperty<C>): DataRow<T> =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minBy(column: KProperty<C>): DataRow<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(
     crossinline expression: RowExpression<T, C>,
 ): DataRow<T>? = minByOrNull(skipNaN = skipNaNDefault, expression = expression)
 
@@ -589,13 +589,12 @@ public fun <T> DataFrame<T>.minByOrNull(column: String): DataRow<T>? = minByOrNu
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(
-    column: ColumnReference<C>,
-): DataRow<T>? = minByOrNull(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(column: ColumnReference<C>): DataRow<T>? =
+    minByOrNull(column, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.minByOrNull(column: KProperty<C>): DataRow<T>? =
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.minByOrNull(column: KProperty<C>): DataRow<T>? =
     minByOrNull(column, skipNaN = skipNaNDefault)
 
 @Refine
@@ -626,7 +625,7 @@ public fun <T, C : Comparable<*>?> Grouped<T>.minFor(vararg columns: KProperty<C
 @Refine
 @Interpretable("GroupByMin0")
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+public fun <T, C : Comparable<*>?> Grouped<T>.min(
     name: String? = null,
     columns: ColumnsSelector<T, C?>,
 ): DataFrame<T> = min(name, skipNaN = skipNaNDefault, columns = columns)
@@ -637,35 +636,33 @@ public fun <T> Grouped<T>.min(vararg columns: String, name: String? = null): Dat
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
+public fun <T, C : Comparable<*>?> Grouped<T>.min(
     vararg columns: ColumnReference<C>,
     name: String? = null,
 ): DataFrame<T> = min(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.min(
-    vararg columns: KProperty<C>,
-    name: String? = null,
-): DataFrame<T> = min(columns = columns, name = name, skipNaN = skipNaNDefault)
+public fun <T, C : Comparable<*>?> Grouped<T>.min(vararg columns: KProperty<C>, name: String? = null): DataFrame<T> =
+    min(columns = columns, name = name, skipNaN = skipNaNDefault)
 
 @Refine
 @Interpretable("GroupByMinOf")
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Grouped<T>.minOf(
+public inline fun <T, reified C : Comparable<*>?> Grouped<T>.minOf(
     name: String? = null,
     crossinline expression: RowExpression<T, C>,
 ): DataFrame<T> = minOf(name, skipNaN = skipNaNDefault, expression = expression)
 
 @Interpretable("GroupByReduceExpression")
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.minBy(
     crossinline rowExpression: RowExpression<G, R>,
 ): ReducedGroupBy<T, G> = minBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(
     column: ColumnReference<C>,
 ): ReducedGroupBy<T, G> = minBy(column, skipNaN = skipNaNDefault)
 
@@ -674,9 +671,8 @@ public fun <T, G> GroupBy<T, G>.minBy(column: String): ReducedGroupBy<T, G> = mi
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.minBy(
-    column: KProperty<C>,
-): ReducedGroupBy<T, G> = minBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.minBy(column: KProperty<C>): ReducedGroupBy<T, G> =
+    minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
 public fun <T> Pivot<T>.min(separate: Boolean = false): DataRow<T> = min(separate, skipNaN = skipNaNDefault)
@@ -706,32 +702,32 @@ public fun <T, R : Comparable<*>?> Pivot<T>.minFor(
 ): DataRow<T> = minFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(columns: ColumnsSelector<T, R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.min(columns: ColumnsSelector<T, R>): DataRow<T> =
     min(skipNaN = skipNaNDefault, columns = columns)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(vararg columns: ColumnReference<R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.min(vararg columns: ColumnReference<R>): DataRow<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> Pivot<T>.min(vararg columns: KProperty<R>): DataRow<T> =
+public fun <T, R : Comparable<*>?> Pivot<T>.min(vararg columns: KProperty<R>): DataRow<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataRow<T> = minOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.minBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivot<T> = minBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(column: ColumnReference<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(column: ColumnReference<C>): ReducedPivot<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -739,7 +735,7 @@ public fun <T> Pivot<T>.minBy(column: String): ReducedPivot<T> = minBy(column, s
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.minBy(column: KProperty<C>): ReducedPivot<T> =
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.minBy(column: KProperty<C>): ReducedPivot<T> =
     minBy(column, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -770,7 +766,7 @@ public fun <T, R : Comparable<*>?> PivotGroupBy<T>.minFor(
 ): DataFrame<T> = minFor(columns = columns, separate = separate, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(columns: ColumnsSelector<T, R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(columns: ColumnsSelector<T, R>): DataFrame<T> =
     min(skipNaN = skipNaNDefault, columns = columns)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
@@ -778,27 +774,27 @@ public fun <T> PivotGroupBy<T>.min(vararg columns: String): DataFrame<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(vararg columns: ColumnReference<R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(vararg columns: ColumnReference<R>): DataFrame<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public fun <T, R : Comparable<R & Any>?> PivotGroupBy<T>.min(vararg columns: KProperty<R>): DataFrame<T> =
+public fun <T, R : Comparable<*>?> PivotGroupBy<T>.min(vararg columns: KProperty<R>): DataFrame<T> =
     min(columns = columns, skipNaN = skipNaNDefault)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minOf(
     crossinline rowExpression: RowExpression<T, R>,
 ): DataFrame<T> = minOf(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.minBy(
     crossinline rowExpression: RowExpression<T, R>,
 ): ReducedPivotGroupBy<T> = minBy(skipNaN = skipNaNDefault, rowExpression = rowExpression)
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(
     column: ColumnReference<C>,
 ): ReducedPivotGroupBy<T> = minBy(column, skipNaN = skipNaNDefault)
 
@@ -807,8 +803,7 @@ public fun <T> PivotGroupBy<T>.minBy(column: String): ReducedPivotGroupBy<T> = m
 
 @AccessApiOverload
 @Deprecated(MIN_NO_SKIPNAN, level = DeprecationLevel.HIDDEN)
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.minBy(
-    column: KProperty<C>,
-): ReducedPivotGroupBy<T> = minBy(column, skipNaN = skipNaNDefault)
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.minBy(column: KProperty<C>): ReducedPivotGroupBy<T> =
+    minBy(column, skipNaN = skipNaNDefault)
 
 // endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt
index b57bf16a3d..d768c67c22 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/percentile.kt
@@ -15,6 +15,8 @@ import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.Aggregators
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.aggregators.cast2
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.intraComparableColumns
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateAll
 import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateByOrNull
@@ -46,53 +48,53 @@ import kotlin.reflect.KProperty
 
 // region DataColumn
 
-public fun <T : Comparable<T & Any>?> DataColumn<T>.percentile(percentile: Double): T & Any =
+public fun <T : Comparable<*>?> DataColumn<T>.percentile(percentile: Double): T =
     percentileOrNull(percentile).suggestIfNull("percentile")
 
-public fun <T : Comparable<T & Any>?> DataColumn<T>.percentileOrNull(percentile: Double): T? =
-    Aggregators.percentileComparables<T>(percentile).aggregateSingleColumn(this)
+public fun <T : Comparable<*>?> DataColumn<T>.percentileOrNull(percentile: Double): T? =
+    Aggregators.percentile(percentile, skipNaNDefault).cast<T>().aggregateSingleColumn(this)
 
 public fun <T> DataColumn<T>.percentile(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where T : Comparable<T & Any>?, T : Number? =
+    where T : Comparable<*>?, T : Number? =
     percentileOrNull(percentile = percentile, skipNaN = skipNaN).suggestIfNull("percentile")
 
 public fun <T> DataColumn<T>.percentileOrNull(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where T : Comparable<T & Any>?, T : Number? =
-    Aggregators.percentileNumbers<T>(percentile, skipNaN).aggregateSingleColumn(this)
+    where T : Comparable<*>?, T : Number? =
+    Aggregators.percentile(percentile, skipNaN).cast2<T & Any, Double?>().aggregateSingleColumn(this)
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileBy(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T & Any = percentileByOrNull(percentile, skipNaN, selector).suggestIfNull("percentileBy")
+): T = percentileByOrNull(percentile, skipNaN, selector).suggestIfNull("percentileBy")
 
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileByOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileByOrNull(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline selector: (T) -> R,
-): T? = Aggregators.percentileCommon<R>(percentile, skipNaN).aggregateByOrNull(this, selector)
+): T? = Aggregators.percentile(percentile, skipNaN).cast<R>().aggregateByOrNull(this, selector)
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileOf(
     percentile: Double,
     crossinline expression: (T) -> R,
-): R & Any = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
+): R = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataColumn<T>.percentileOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataColumn<T>.percentileOfOrNull(
     percentile: Double,
     crossinline expression: (T) -> R,
-): R? = Aggregators.percentileComparables<R>(percentile).aggregateOf(this, expression)
+): R? = Aggregators.percentile(percentile, skipNaNDefault).cast<R>().aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataColumn<T>.percentileOf(
@@ -100,7 +102,7 @@ public inline fun <T, reified R> DataColumn<T>.percentileOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double
-    where R : Comparable<R & Any>?, R : Number? =
+    where R : Comparable<*>?, R : Number? =
     percentileOfOrNull(percentile, skipNaN, expression).suggestIfNull("percentileOf")
 
 @OverloadResolutionByLambdaReturnType
@@ -109,8 +111,8 @@ public inline fun <T, reified R> DataColumn<T>.percentileOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: (T) -> R,
 ): Double?
-    where R : Comparable<R & Any>?, R : Number? =
-    Aggregators.percentileNumbers<R>(percentile, skipNaN).aggregateOf(this, expression)
+    where R : Comparable<*>?, R : Number? =
+    Aggregators.percentile(percentile, skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
 
 // endregion
 
@@ -182,18 +184,16 @@ public fun <T, C : Comparable<*>?> DataFrame<T>.percentileFor(
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentile(
-    percentile: Double,
-    columns: ColumnsSelector<T, C>,
-): C & Any = percentileOrNull(percentile, columns).suggestIfNull("percentile")
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentile(percentile: Double, columns: ColumnsSelector<T, C>): C =
+    percentileOrNull(percentile, columns).suggestIfNull("percentile")
 
 // TODO, requires explicit type C due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
 @Suppress("UNCHECKED_CAST")
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentileOrNull(
     percentile: Double,
     columns: ColumnsSelector<T, C>,
-): C? = Aggregators.percentileComparables<C>(percentile).aggregateAll(this, columns)
+): C? = Aggregators.percentile(percentile, skipNaNDefault).cast<C>().aggregateAll(this, columns)
 
 @OverloadResolutionByLambdaReturnType
 public fun <T, C> DataFrame<T>.percentile(
@@ -201,7 +201,7 @@ public fun <T, C> DataFrame<T>.percentile(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double
-    where C : Number?, C : Comparable<C & Any>? =
+    where C : Number?, C : Comparable<*>? =
     percentileOrNull(percentile, skipNaN, columns).suggestIfNull("percentile")
 
 @OverloadResolutionByLambdaReturnType
@@ -211,8 +211,8 @@ public fun <T, C> DataFrame<T>.percentileOrNull(
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? =
-    Aggregators.percentileNumbers<C>(percentile, skipNaN).aggregateAll(this, columns)
+    where C : Comparable<*>?, C : Number? =
+    Aggregators.percentile(percentile, skipNaN).cast2<C & Any, Double?>().aggregateAll(this, columns)
 
 public fun <T> DataFrame<T>.percentile(
     percentile: Double,
@@ -229,14 +229,12 @@ public fun <T> DataFrame<T>.percentileOrNull(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentile(
-    percentile: Double,
-    vararg columns: ColumnReference<C>,
-): C & Any = percentileOrNull(percentile, *columns).suggestIfNull("percentile")
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentile(percentile: Double, vararg columns: ColumnReference<C>): C =
+    percentileOrNull(percentile, *columns).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentileOrNull(
     percentile: Double,
     vararg columns: ColumnReference<C>,
 ): C? = percentileOrNull<T, C>(percentile) { columns.toColumnSet() }
@@ -248,7 +246,7 @@ public fun <T, C> DataFrame<T>.percentile(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<C & Any>?, C : Number? =
+    where C : Comparable<*>?, C : Number? =
     percentileOrNull(percentile, *columns, skipNaN = skipNaN).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -258,19 +256,16 @@ public fun <T, C> DataFrame<T>.percentileOrNull(
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? =
-    percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
+    where C : Comparable<*>?, C : Number? = percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentile(
-    percentile: Double,
-    vararg columns: KProperty<C>,
-): C & Any = percentileOrNull(percentile, *columns).suggestIfNull("percentile")
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentile(percentile: Double, vararg columns: KProperty<C>): C =
+    percentileOrNull(percentile, *columns).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> DataFrame<T>.percentileOrNull(
+public fun <T, C : Comparable<*>?> DataFrame<T>.percentileOrNull(
     percentile: Double,
     vararg columns: KProperty<C>,
 ): C? = percentileOrNull<T, C>(percentile) { columns.toColumnSet() }
@@ -282,7 +277,7 @@ public fun <T, C> DataFrame<T>.percentile(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double
-    where C : Comparable<C & Any>?, C : Number? =
+    where C : Comparable<*>?, C : Number? =
     percentileOrNull(percentile, *columns, skipNaN = skipNaN).suggestIfNull("percentile")
 
 @Deprecated(DEPRECATED_ACCESS_API)
@@ -292,22 +287,21 @@ public fun <T, C> DataFrame<T>.percentileOrNull(
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): Double?
-    where C : Comparable<C & Any>?, C : Number? =
-    percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
+    where C : Comparable<*>?, C : Number? = percentileOrNull(percentile, skipNaN) { columns.toColumnSet() }
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.percentileOf(
     percentile: Double,
     crossinline expression: RowExpression<T, R>,
-): R & Any = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
+): R = percentileOfOrNull(percentile, expression).suggestIfNull("percentileOf")
 
 // TODO, requires explicit type R due to https://youtrack.jetbrains.com/issue/KT-76683
 @OverloadResolutionByLambdaReturnType
-public inline fun <T, reified R : Comparable<R & Any>?> DataFrame<T>.percentileOfOrNull(
+public inline fun <T, reified R : Comparable<*>?> DataFrame<T>.percentileOfOrNull(
     percentile: Double,
     crossinline expression: RowExpression<T, R>,
-): R? = Aggregators.percentileComparables<R>(percentile).aggregateOf(this, expression)
+): R? = Aggregators.percentile(percentile, skipNaNDefault).cast<R>().aggregateOf(this, expression)
 
 @OverloadResolutionByLambdaReturnType
 public inline fun <T, reified R> DataFrame<T>.percentileOf(
@@ -315,7 +309,7 @@ public inline fun <T, reified R> DataFrame<T>.percentileOf(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double
-    where R : Comparable<R & Any>?, R : Number? =
+    where R : Comparable<*>?, R : Number? =
     percentileOfOrNull(percentile, skipNaN, expression).suggestIfNull("percentileOf")
 
 @OverloadResolutionByLambdaReturnType
@@ -324,10 +318,10 @@ public inline fun <T, reified R> DataFrame<T>.percentileOfOrNull(
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): Double?
-    where R : Comparable<R & Any>?, R : Number? =
-    Aggregators.percentileNumbers<R>(percentile, skipNaN).aggregateOf(this, expression)
+    where R : Comparable<*>?, R : Number? =
+    Aggregators.percentile(percentile, skipNaN).cast2<R & Any, Double?>().aggregateOf(this, expression)
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
@@ -341,7 +335,7 @@ public fun <T> DataFrame<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -349,17 +343,17 @@ public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileB
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = percentileByOrNull(percentile, column, skipNaN).suggestIfNull("percentileBy")
 
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileByOrNull(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, C>,
-): DataRow<T>? = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateByOrNull(this, expression)
+): DataRow<T>? = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateByOrNull(this, expression)
 
 public fun <T> DataFrame<T>.percentileByOrNull(
     percentile: Double,
@@ -369,15 +363,15 @@ public fun <T> DataFrame<T>.percentileByOrNull(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileByOrNull(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
-): DataRow<T>? = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateByOrNull(this, column)
+): DataRow<T>? = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateByOrNull(this, column)
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> DataFrame<T>.percentileByOrNull(
+public inline fun <T, reified C : Comparable<*>?> DataFrame<T>.percentileByOrNull(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -420,12 +414,12 @@ public fun <T, C : Comparable<*>?> Grouped<T>.percentileFor(
 
 @Refine
 @Interpretable("GroupByPercentile0")
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
+public fun <T, C : Comparable<*>?> Grouped<T>.percentile(
     percentile: Double,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateAll(this, name, columns)
+): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateAll(this, name, columns)
 
 public fun <T> Grouped<T>.percentile(
     percentile: Double,
@@ -436,7 +430,7 @@ public fun <T> Grouped<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
+public fun <T, C : Comparable<*>?> Grouped<T>.percentile(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     name: String? = null,
@@ -445,7 +439,7 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
+public fun <T, C : Comparable<*>?> Grouped<T>.percentile(
     percentile: Double,
     vararg columns: KProperty<C>,
     name: String? = null,
@@ -454,15 +448,15 @@ public fun <T, C : Comparable<C & Any>?> Grouped<T>.percentile(
 
 @Refine
 @Interpretable("GroupByPercentileOf")
-public inline fun <T, reified R : Comparable<R & Any>?> Grouped<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> Grouped<T>.percentileOf(
     percentile: Double,
     name: String? = null,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.percentileCommon<R>(percentile, skipNaN).aggregateOf(this, name, expression)
+): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<R>().aggregateOf(this, name, expression)
 
 @Interpretable("GroupByReduceExpression") // TODO?
-public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.percentileBy(
+public inline fun <T, G, reified R : Comparable<*>?> GroupBy<T, G>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<G, R>,
@@ -470,7 +464,7 @@ public inline fun <T, G, reified R : Comparable<R & Any>?> GroupBy<T, G>.percent
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.percentileBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -484,7 +478,7 @@ public fun <T, G> GroupBy<T, G>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, G, reified C : Comparable<C & Any>?> GroupBy<T, G>.percentileBy(
+public inline fun <T, G, reified C : Comparable<*>?> GroupBy<T, G>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -532,7 +526,7 @@ public fun <T, C : Comparable<*>?> Pivot<T>.percentileFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = percentileFor(percentile, separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
+public fun <T, C : Comparable<*>?> Pivot<T>.percentile(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
@@ -546,7 +540,7 @@ public fun <T> Pivot<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
+public fun <T, C : Comparable<*>?> Pivot<T>.percentile(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -554,19 +548,19 @@ public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> Pivot<T>.percentile(
+public fun <T, C : Comparable<*>?> Pivot<T>.percentile(
     percentile: Double,
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataRow<T> = percentile(percentile, skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.percentileOf(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
 ): DataRow<T> = delegate { percentileOf(percentile, skipNaN, expression) }
 
-public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.percentileBy(
+public inline fun <T, reified R : Comparable<*>?> Pivot<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
@@ -574,7 +568,7 @@ public inline fun <T, reified R : Comparable<R & Any>?> Pivot<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -588,7 +582,7 @@ public fun <T> Pivot<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> Pivot<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> Pivot<T>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -635,11 +629,11 @@ public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentileFor(
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = percentileFor(percentile, separate, skipNaN) { columns.toColumnSet() }
 
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentile(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     columns: ColumnsSelector<T, C>,
-): DataFrame<T> = Aggregators.percentileCommon<C>(percentile, skipNaN).aggregateAll(this, columns)
+): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<C>().aggregateAll(this, columns)
 
 public fun <T> PivotGroupBy<T>.percentile(
     percentile: Double,
@@ -649,7 +643,7 @@ public fun <T> PivotGroupBy<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentile(
     percentile: Double,
     vararg columns: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -657,19 +651,19 @@ public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public fun <T, C : Comparable<C & Any>?> PivotGroupBy<T>.percentile(
+public fun <T, C : Comparable<*>?> PivotGroupBy<T>.percentile(
     percentile: Double,
     vararg columns: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,
 ): DataFrame<T> = percentile(percentile, skipNaN) { columns.toColumnSet() }
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.percentileOf(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.percentileOf(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline expression: RowExpression<T, R>,
-): DataFrame<T> = Aggregators.percentileCommon<R>(percentile, skipNaN).aggregateOf(this, expression)
+): DataFrame<T> = Aggregators.percentile(percentile, skipNaN).cast<R>().aggregateOf(this, expression)
 
-public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.percentileBy(
+public inline fun <T, reified R : Comparable<*>?> PivotGroupBy<T>.percentileBy(
     percentile: Double,
     skipNaN: Boolean = skipNaNDefault,
     crossinline rowExpression: RowExpression<T, R>,
@@ -677,7 +671,7 @@ public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.percenti
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.percentileBy(
     percentile: Double,
     column: ColumnReference<C>,
     skipNaN: Boolean = skipNaNDefault,
@@ -691,7 +685,7 @@ public fun <T> PivotGroupBy<T>.percentileBy(
 
 @Deprecated(DEPRECATED_ACCESS_API)
 @AccessApiOverload
-public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.percentileBy(
+public inline fun <T, reified C : Comparable<*>?> PivotGroupBy<T>.percentileBy(
     percentile: Double,
     column: KProperty<C>,
     skipNaN: Boolean = skipNaNDefault,