Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/androidx/collection/FloatList.java

@@ -0,0 +1,715 @@
+package androidx.collection;
+
+import androidx.annotation.IntRange;
+import com.ironsource.v8;
+import java.util.NoSuchElementException;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.functions.Function3;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.ranges.RangesKt___RangesKt;
+
+@SourceDebugExtension({"SMAP\nFloatList.kt\nKotlin\n*S Kotlin\n*F\n+ 1 FloatList.kt\nandroidx/collection/FloatList\n*L\n1#1,969:1\n253#1,6:970\n279#1,6:976\n253#1,6:982\n75#1:988\n253#1,6:989\n253#1,6:995\n253#1,6:1001\n266#1,6:1007\n279#1,6:1013\n293#1,6:1019\n70#1:1025\n70#1:1026\n266#1,6:1027\n266#1,6:1033\n293#1,6:1039\n70#1:1045\n279#1,6:1046\n293#1,6:1052\n266#1,6:1058\n266#1,6:1064\n253#1,6:1070\n75#1:1076\n467#1,10:1077\n266#1,4:1087\n477#1,9:1091\n271#1:1100\n486#1,2:1101\n467#1,10:1103\n266#1,4:1113\n477#1,9:1117\n271#1:1126\n486#1,2:1127\n467#1,10:1129\n266#1,4:1139\n477#1,9:1143\n271#1:1152\n486#1,2:1153\n467#1,10:1155\n266#1,4:1165\n477#1,9:1169\n271#1:1178\n486#1,2:1179\n467#1,10:1181\n266#1,4:1191\n477#1,9:1195\n271#1:1204\n486#1,2:1205\n*S KotlinDebug\n*F\n+ 1 FloatList.kt\nandroidx/collection/FloatList\n*L\n96#1:970,6\n110#1:976,6\n122#1:982,6\n135#1:988\n153#1:989,6\n175#1:995,6\n192#1:1001,6\n208#1:1007,6\n225#1:1013,6\n241#1:1019,6\n306#1:1025\n317#1:1026\n343#1:1027,6\n357#1:1033,6\n371#1:1039,6\n397#1:1045\n407#1:1046,6\n420#1:1052,6\n445#1:1058,6\n476#1:1064,6\n494#1:1070,6\n510#1:1076\n-1#1:1077,10\n-1#1:1087,4\n-1#1:1091,9\n-1#1:1100\n-1#1:1101,2\n-1#1:1103,10\n-1#1:1113,4\n-1#1:1117,9\n-1#1:1126\n-1#1:1127,2\n-1#1:1129,10\n-1#1:1139,4\n-1#1:1143,9\n-1#1:1152\n-1#1:1153,2\n-1#1:1155,10\n-1#1:1165,4\n-1#1:1169,9\n-1#1:1178\n-1#1:1179,2\n-1#1:1181,10\n-1#1:1191,4\n-1#1:1195,9\n-1#1:1204\n-1#1:1205,2\n*E\n"})
+/* loaded from: classes.dex */
+public abstract class FloatList {
+    public int _size;
+    public float[] content;
+
+    public /* synthetic */ FloatList(int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(i);
+    }
+
+    public static /* synthetic */ void getContent$annotations() {
+    }
+
+    public static /* synthetic */ void get_size$annotations() {
+    }
+
+    public final int count() {
+        return this._size;
+    }
+
+    @IntRange(from = -1)
+    public final int getLastIndex() {
+        return this._size - 1;
+    }
+
+    @IntRange(from = 0)
+    public final int getSize() {
+        return this._size;
+    }
+
+    public final boolean isEmpty() {
+        return this._size == 0;
+    }
+
+    public final boolean isNotEmpty() {
+        return this._size != 0;
+    }
+
+    public final String joinToString() {
+        return joinToString$default(this, null, null, null, 0, null, 31, null);
+    }
+
+    public final String joinToString(CharSequence separator) {
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        return joinToString$default(this, separator, null, null, 0, null, 30, null);
+    }
+
+    public final String joinToString(CharSequence separator, CharSequence prefix) {
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        return joinToString$default(this, separator, prefix, null, 0, null, 28, null);
+    }
+
+    public final String joinToString(CharSequence separator, CharSequence prefix, CharSequence postfix) {
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        Intrinsics.checkNotNullParameter(postfix, "postfix");
+        return joinToString$default(this, separator, prefix, postfix, 0, null, 24, null);
+    }
+
+    public final String joinToString(CharSequence separator, CharSequence prefix, CharSequence postfix, int i) {
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        Intrinsics.checkNotNullParameter(postfix, "postfix");
+        return joinToString$default(this, separator, prefix, postfix, i, null, 16, null);
+    }
+
+    private FloatList(int i) {
+        float[] fArr;
+        if (i == 0) {
+            fArr = FloatSetKt.getEmptyFloatArray();
+        } else {
+            fArr = new float[i];
+        }
+        this.content = fArr;
+    }
+
+    public final boolean containsAll(FloatList elements) {
+        kotlin.ranges.IntRange until;
+        Intrinsics.checkNotNullParameter(elements, "elements");
+        until = RangesKt___RangesKt.until(0, elements._size);
+        int first = until.getFirst();
+        int last = until.getLast();
+        if (first > last) {
+            return true;
+        }
+        while (contains(elements.get(first))) {
+            if (first == last) {
+                return true;
+            }
+            first++;
+        }
+        return false;
+    }
+
+    public final kotlin.ranges.IntRange getIndices() {
+        kotlin.ranges.IntRange until;
+        until = RangesKt___RangesKt.until(0, this._size);
+        return until;
+    }
+
+    public final boolean none() {
+        return isEmpty();
+    }
+
+    public final boolean any() {
+        return isNotEmpty();
+    }
+
+    public final float first() {
+        if (isEmpty()) {
+            throw new NoSuchElementException("FloatList is empty.");
+        }
+        return this.content[0];
+    }
+
+    public final boolean any(Function1 predicate) {
+        Intrinsics.checkNotNullParameter(predicate, "predicate");
+        float[] fArr = this.content;
+        int i = this._size;
+        for (int i2 = 0; i2 < i; i2++) {
+            if (((Boolean) predicate.invoke(Float.valueOf(fArr[i2]))).booleanValue()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public final boolean contains(float f) {
+        float[] fArr = this.content;
+        int i = this._size;
+        for (int i2 = 0; i2 < i; i2++) {
+            if (fArr[i2] == f) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public final int count(Function1 predicate) {
+        Intrinsics.checkNotNullParameter(predicate, "predicate");
+        float[] fArr = this.content;
+        int i = this._size;
+        int i2 = 0;
+        for (int i3 = 0; i3 < i; i3++) {
+            if (((Boolean) predicate.invoke(Float.valueOf(fArr[i3]))).booleanValue()) {
+                i2++;
+            }
+        }
+        return i2;
+    }
+
+    public final float first(Function1 predicate) {
+        Intrinsics.checkNotNullParameter(predicate, "predicate");
+        float[] fArr = this.content;
+        int i = this._size;
+        for (int i2 = 0; i2 < i; i2++) {
+            float f = fArr[i2];
+            if (((Boolean) predicate.invoke(Float.valueOf(f))).booleanValue()) {
+                return f;
+            }
+        }
+        throw new NoSuchElementException("FloatList contains no element matching the predicate.");
+    }
+
+    public final <R> R fold(R r, Function2 operation) {
+        Intrinsics.checkNotNullParameter(operation, "operation");
+        float[] fArr = this.content;
+        int i = this._size;
+        for (int i2 = 0; i2 < i; i2++) {
+            r = (R) operation.invoke(r, Float.valueOf(fArr[i2]));
+        }
+        return r;
+    }
+
+    public final void forEach(Function1 block) {
+        Intrinsics.checkNotNullParameter(block, "block");
+        float[] fArr = this.content;
+        int i = this._size;
+        for (int i2 = 0; i2 < i; i2++) {
+            block.invoke(Float.valueOf(fArr[i2]));
+        }
+    }
+
+    public int hashCode() {
+        float[] fArr = this.content;
+        int i = this._size;
+        int i2 = 0;
+        for (int i3 = 0; i3 < i; i3++) {
+            i2 += Float.hashCode(fArr[i3]) * 31;
+        }
+        return i2;
+    }
+
+    public final <R> R foldIndexed(R r, Function3 operation) {
+        Intrinsics.checkNotNullParameter(operation, "operation");
+        float[] fArr = this.content;
+        int i = this._size;
+        for (int i2 = 0; i2 < i; i2++) {
+            R r2 = r;
+            r = (R) operation.invoke(Integer.valueOf(i2), r2, Float.valueOf(fArr[i2]));
+        }
+        return r;
+    }
+
+    public final void forEachIndexed(Function2 block) {
+        Intrinsics.checkNotNullParameter(block, "block");
+        float[] fArr = this.content;
+        int i = this._size;
+        for (int i2 = 0; i2 < i; i2++) {
+            block.invoke(Integer.valueOf(i2), Float.valueOf(fArr[i2]));
+        }
+    }
+
+    public final int indexOf(float f) {
+        float[] fArr = this.content;
+        int i = this._size;
+        for (int i2 = 0; i2 < i; i2++) {
+            if (f == fArr[i2]) {
+                return i2;
+            }
+        }
+        return -1;
+    }
+
+    public final int indexOfFirst(Function1 predicate) {
+        Intrinsics.checkNotNullParameter(predicate, "predicate");
+        float[] fArr = this.content;
+        int i = this._size;
+        for (int i2 = 0; i2 < i; i2++) {
+            if (((Boolean) predicate.invoke(Float.valueOf(fArr[i2]))).booleanValue()) {
+                return i2;
+            }
+        }
+        return -1;
+    }
+
+    public final <R> R foldRight(R r, Function2 operation) {
+        Intrinsics.checkNotNullParameter(operation, "operation");
+        float[] fArr = this.content;
+        int i = this._size;
+        while (true) {
+            i--;
+            if (-1 >= i) {
+                return r;
+            }
+            r = (R) operation.invoke(Float.valueOf(fArr[i]), r);
+        }
+    }
+
+    public final void forEachReversed(Function1 block) {
+        Intrinsics.checkNotNullParameter(block, "block");
+        float[] fArr = this.content;
+        int i = this._size;
+        while (true) {
+            i--;
+            if (-1 >= i) {
+                return;
+            } else {
+                block.invoke(Float.valueOf(fArr[i]));
+            }
+        }
+    }
+
+    public final float last(Function1 predicate) {
+        float f;
+        Intrinsics.checkNotNullParameter(predicate, "predicate");
+        float[] fArr = this.content;
+        int i = this._size;
+        do {
+            i--;
+            if (-1 < i) {
+                f = fArr[i];
+            } else {
+                throw new NoSuchElementException("FloatList contains no element matching the predicate.");
+            }
+        } while (!((Boolean) predicate.invoke(Float.valueOf(f))).booleanValue());
+        return f;
+    }
+
+    public final boolean reversedAny(Function1 predicate) {
+        Intrinsics.checkNotNullParameter(predicate, "predicate");
+        float[] fArr = this.content;
+        for (int i = this._size - 1; -1 < i; i--) {
+            if (((Boolean) predicate.invoke(Float.valueOf(fArr[i]))).booleanValue()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public final <R> R foldRightIndexed(R r, Function3 operation) {
+        Intrinsics.checkNotNullParameter(operation, "operation");
+        float[] fArr = this.content;
+        int i = this._size;
+        while (true) {
+            i--;
+            if (-1 >= i) {
+                return r;
+            }
+            r = (R) operation.invoke(Integer.valueOf(i), Float.valueOf(fArr[i]), r);
+        }
+    }
+
+    public final void forEachReversedIndexed(Function2 block) {
+        Intrinsics.checkNotNullParameter(block, "block");
+        float[] fArr = this.content;
+        int i = this._size;
+        while (true) {
+            i--;
+            if (-1 >= i) {
+                return;
+            } else {
+                block.invoke(Integer.valueOf(i), Float.valueOf(fArr[i]));
+            }
+        }
+    }
+
+    public final int indexOfLast(Function1 predicate) {
+        Intrinsics.checkNotNullParameter(predicate, "predicate");
+        float[] fArr = this.content;
+        int i = this._size;
+        do {
+            i--;
+            if (-1 >= i) {
+                return -1;
+            }
+        } while (!((Boolean) predicate.invoke(Float.valueOf(fArr[i]))).booleanValue());
+        return i;
+    }
+
+    public final int lastIndexOf(float f) {
+        float[] fArr = this.content;
+        int i = this._size;
+        do {
+            i--;
+            if (-1 >= i) {
+                return -1;
+            }
+        } while (fArr[i] != f);
+        return i;
+    }
+
+    public final float get(@IntRange(from = 0) int i) {
+        if (i < 0 || i >= this._size) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Index ");
+            sb.append(i);
+            sb.append(" must be in 0..");
+            sb.append(this._size - 1);
+            throw new IndexOutOfBoundsException(sb.toString());
+        }
+        return this.content[i];
+    }
+
+    public final float elementAt(@IntRange(from = 0) int i) {
+        if (i < 0 || i >= this._size) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Index ");
+            sb.append(i);
+            sb.append(" must be in 0..");
+            sb.append(this._size - 1);
+            throw new IndexOutOfBoundsException(sb.toString());
+        }
+        return this.content[i];
+    }
+
+    public final float elementAtOrElse(@IntRange(from = 0) int i, Function1 defaultValue) {
+        Intrinsics.checkNotNullParameter(defaultValue, "defaultValue");
+        if (i < 0 || i >= this._size) {
+            return ((Number) defaultValue.invoke(Integer.valueOf(i))).floatValue();
+        }
+        return this.content[i];
+    }
+
+    public final float last() {
+        if (!isEmpty()) {
+            return this.content[this._size - 1];
+        }
+        throw new NoSuchElementException("FloatList is empty.");
+    }
+
+    public static /* synthetic */ String joinToString$default(FloatList floatList, CharSequence charSequence, CharSequence charSequence2, CharSequence charSequence3, int i, CharSequence charSequence4, int i2, Object obj) {
+        if (obj != null) {
+            throw new UnsupportedOperationException("Super calls with default arguments not supported in this target, function: joinToString");
+        }
+        if ((i2 & 1) != 0) {
+            charSequence = ", ";
+        }
+        CharSequence charSequence5 = (i2 & 2) != 0 ? "" : charSequence2;
+        CharSequence charSequence6 = (i2 & 4) == 0 ? charSequence3 : "";
+        if ((i2 & 8) != 0) {
+            i = -1;
+        }
+        int i3 = i;
+        if ((i2 & 16) != 0) {
+            charSequence4 = "...";
+        }
+        return floatList.joinToString(charSequence, charSequence5, charSequence6, i3, charSequence4);
+    }
+
+    public final String joinToString(CharSequence separator, CharSequence prefix, CharSequence postfix, int i, CharSequence truncated) {
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        Intrinsics.checkNotNullParameter(postfix, "postfix");
+        Intrinsics.checkNotNullParameter(truncated, "truncated");
+        StringBuilder sb = new StringBuilder();
+        sb.append(prefix);
+        float[] fArr = this.content;
+        int i2 = this._size;
+        int i3 = 0;
+        while (true) {
+            if (i3 < i2) {
+                float f = fArr[i3];
+                if (i3 == i) {
+                    sb.append(truncated);
+                    break;
+                }
+                if (i3 != 0) {
+                    sb.append(separator);
+                }
+                sb.append(f);
+                i3++;
+            } else {
+                sb.append(postfix);
+                break;
+            }
+        }
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "StringBuilder().apply(builderAction).toString()");
+        return sb2;
+    }
+
+    public static /* synthetic */ String joinToString$default(FloatList floatList, CharSequence separator, CharSequence prefix, CharSequence postfix, int i, CharSequence truncated, Function1 transform, int i2, Object obj) {
+        if (obj == null) {
+            if ((i2 & 1) != 0) {
+                separator = ", ";
+            }
+            if ((i2 & 2) != 0) {
+                prefix = "";
+            }
+            if ((i2 & 4) != 0) {
+                postfix = "";
+            }
+            if ((i2 & 8) != 0) {
+                i = -1;
+            }
+            if ((i2 & 16) != 0) {
+                truncated = "...";
+            }
+            Intrinsics.checkNotNullParameter(separator, "separator");
+            Intrinsics.checkNotNullParameter(prefix, "prefix");
+            Intrinsics.checkNotNullParameter(postfix, "postfix");
+            Intrinsics.checkNotNullParameter(truncated, "truncated");
+            Intrinsics.checkNotNullParameter(transform, "transform");
+            StringBuilder sb = new StringBuilder();
+            sb.append(prefix);
+            float[] fArr = floatList.content;
+            int i3 = floatList._size;
+            int i4 = 0;
+            while (true) {
+                if (i4 < i3) {
+                    float f = fArr[i4];
+                    if (i4 == i) {
+                        sb.append(truncated);
+                        break;
+                    }
+                    if (i4 != 0) {
+                        sb.append(separator);
+                    }
+                    sb.append((CharSequence) transform.invoke(Float.valueOf(f)));
+                    i4++;
+                } else {
+                    sb.append(postfix);
+                    break;
+                }
+            }
+            String sb2 = sb.toString();
+            Intrinsics.checkNotNullExpressionValue(sb2, "StringBuilder().apply(builderAction).toString()");
+            return sb2;
+        }
+        throw new UnsupportedOperationException("Super calls with default arguments not supported in this target, function: joinToString");
+    }
+
+    public final String joinToString(CharSequence separator, CharSequence prefix, CharSequence postfix, int i, CharSequence truncated, Function1 transform) {
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        Intrinsics.checkNotNullParameter(postfix, "postfix");
+        Intrinsics.checkNotNullParameter(truncated, "truncated");
+        Intrinsics.checkNotNullParameter(transform, "transform");
+        StringBuilder sb = new StringBuilder();
+        sb.append(prefix);
+        float[] fArr = this.content;
+        int i2 = this._size;
+        int i3 = 0;
+        while (true) {
+            if (i3 < i2) {
+                float f = fArr[i3];
+                if (i3 == i) {
+                    sb.append(truncated);
+                    break;
+                }
+                if (i3 != 0) {
+                    sb.append(separator);
+                }
+                sb.append((CharSequence) transform.invoke(Float.valueOf(f)));
+                i3++;
+            } else {
+                sb.append(postfix);
+                break;
+            }
+        }
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "StringBuilder().apply(builderAction).toString()");
+        return sb2;
+    }
+
+    public final String joinToString(CharSequence separator, CharSequence prefix, CharSequence postfix, int i, Function1 transform) {
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        Intrinsics.checkNotNullParameter(postfix, "postfix");
+        Intrinsics.checkNotNullParameter(transform, "transform");
+        StringBuilder sb = new StringBuilder();
+        sb.append(prefix);
+        float[] fArr = this.content;
+        int i2 = this._size;
+        int i3 = 0;
+        while (true) {
+            if (i3 < i2) {
+                float f = fArr[i3];
+                if (i3 == i) {
+                    sb.append((CharSequence) "...");
+                    break;
+                }
+                if (i3 != 0) {
+                    sb.append(separator);
+                }
+                sb.append((CharSequence) transform.invoke(Float.valueOf(f)));
+                i3++;
+            } else {
+                sb.append(postfix);
+                break;
+            }
+        }
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "StringBuilder().apply(builderAction).toString()");
+        return sb2;
+    }
+
+    public final String joinToString(CharSequence separator, CharSequence prefix, CharSequence postfix, Function1 transform) {
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        Intrinsics.checkNotNullParameter(postfix, "postfix");
+        Intrinsics.checkNotNullParameter(transform, "transform");
+        StringBuilder sb = new StringBuilder();
+        sb.append(prefix);
+        float[] fArr = this.content;
+        int i = this._size;
+        int i2 = 0;
+        while (true) {
+            if (i2 < i) {
+                float f = fArr[i2];
+                if (i2 == -1) {
+                    sb.append((CharSequence) "...");
+                    break;
+                }
+                if (i2 != 0) {
+                    sb.append(separator);
+                }
+                sb.append((CharSequence) transform.invoke(Float.valueOf(f)));
+                i2++;
+            } else {
+                sb.append(postfix);
+                break;
+            }
+        }
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "StringBuilder().apply(builderAction).toString()");
+        return sb2;
+    }
+
+    public final String joinToString(CharSequence separator, CharSequence prefix, Function1 transform) {
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        Intrinsics.checkNotNullParameter(prefix, "prefix");
+        Intrinsics.checkNotNullParameter(transform, "transform");
+        StringBuilder sb = new StringBuilder();
+        sb.append(prefix);
+        float[] fArr = this.content;
+        int i = this._size;
+        int i2 = 0;
+        while (true) {
+            if (i2 < i) {
+                float f = fArr[i2];
+                if (i2 == -1) {
+                    sb.append((CharSequence) "...");
+                    break;
+                }
+                if (i2 != 0) {
+                    sb.append(separator);
+                }
+                sb.append((CharSequence) transform.invoke(Float.valueOf(f)));
+                i2++;
+            } else {
+                sb.append((CharSequence) "");
+                break;
+            }
+        }
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "StringBuilder().apply(builderAction).toString()");
+        return sb2;
+    }
+
+    public final String joinToString(CharSequence separator, Function1 transform) {
+        Intrinsics.checkNotNullParameter(separator, "separator");
+        Intrinsics.checkNotNullParameter(transform, "transform");
+        StringBuilder sb = new StringBuilder();
+        sb.append((CharSequence) "");
+        float[] fArr = this.content;
+        int i = this._size;
+        int i2 = 0;
+        while (true) {
+            if (i2 < i) {
+                float f = fArr[i2];
+                if (i2 == -1) {
+                    sb.append((CharSequence) "...");
+                    break;
+                }
+                if (i2 != 0) {
+                    sb.append(separator);
+                }
+                sb.append((CharSequence) transform.invoke(Float.valueOf(f)));
+                i2++;
+            } else {
+                sb.append((CharSequence) "");
+                break;
+            }
+        }
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "StringBuilder().apply(builderAction).toString()");
+        return sb2;
+    }
+
+    public final String joinToString(Function1 transform) {
+        Intrinsics.checkNotNullParameter(transform, "transform");
+        StringBuilder sb = new StringBuilder();
+        sb.append((CharSequence) "");
+        float[] fArr = this.content;
+        int i = this._size;
+        int i2 = 0;
+        while (true) {
+            if (i2 < i) {
+                float f = fArr[i2];
+                if (i2 == -1) {
+                    sb.append((CharSequence) "...");
+                    break;
+                }
+                if (i2 != 0) {
+                    sb.append((CharSequence) ", ");
+                }
+                sb.append((CharSequence) transform.invoke(Float.valueOf(f)));
+                i2++;
+            } else {
+                sb.append((CharSequence) "");
+                break;
+            }
+        }
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "StringBuilder().apply(builderAction).toString()");
+        return sb2;
+    }
+
+    public boolean equals(Object obj) {
+        kotlin.ranges.IntRange until;
+        if (obj instanceof FloatList) {
+            FloatList floatList = (FloatList) obj;
+            int i = floatList._size;
+            int i2 = this._size;
+            if (i == i2) {
+                float[] fArr = this.content;
+                float[] fArr2 = floatList.content;
+                until = RangesKt___RangesKt.until(0, i2);
+                int first = until.getFirst();
+                int last = until.getLast();
+                if (first > last) {
+                    return true;
+                }
+                while (fArr[first] == fArr2[first]) {
+                    if (first == last) {
+                        return true;
+                    }
+                    first++;
+                }
+                return false;
+            }
+        }
+        return false;
+    }
+
+    public String toString() {
+        return joinToString$default(this, null, v8.i.d, v8.i.e, 0, null, 25, null);
+    }
+}