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/kotlin/time/ComparableTimeMark.java

@@ -0,0 +1,16 @@
+package kotlin.time;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public interface ComparableTimeMark extends TimeMark, Comparable {
+    /* renamed from: minus-UwyO8pc, reason: not valid java name */
+    long mo4070minusUwyO8pc(ComparableTimeMark comparableTimeMark);
+
+    public static final class DefaultImpls {
+        public static int compareTo(ComparableTimeMark comparableTimeMark, ComparableTimeMark other) {
+            Intrinsics.checkNotNullParameter(other, "other");
+            return Duration.m4074compareToLRDsOJo(comparableTimeMark.mo4070minusUwyO8pc(other), Duration.Companion.m4105getZEROUwyO8pc());
+        }
+    }
+}

decompiled/sources/kotlin/time/Duration.java

@@ -0,0 +1,422 @@
+package kotlin.time;
+
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.ranges.LongRange;
+import kotlin.ranges.RangesKt___RangesKt;
+import kotlin.text.StringsKt__StringsKt;
+
+/* loaded from: classes5.dex */
+public final class Duration implements Comparable {
+    public static final long INFINITE;
+    public static final long NEG_INFINITE;
+    public final long rawValue;
+    public static final Companion Companion = new Companion(null);
+    public static final long ZERO = m4075constructorimpl(0);
+
+    /* renamed from: box-impl, reason: not valid java name */
+    public static final /* synthetic */ Duration m4073boximpl(long j) {
+        return new Duration(j);
+    }
+
+    /* renamed from: equals-impl, reason: not valid java name */
+    public static boolean m4076equalsimpl(long j, Object obj) {
+        return (obj instanceof Duration) && j == ((Duration) obj).m4102unboximpl();
+    }
+
+    /* renamed from: getValue-impl, reason: not valid java name */
+    public static final long m4088getValueimpl(long j) {
+        return j >> 1;
+    }
+
+    /* renamed from: hashCode-impl, reason: not valid java name */
+    public static int m4089hashCodeimpl(long j) {
+        return Long.hashCode(j);
+    }
+
+    /* renamed from: isInMillis-impl, reason: not valid java name */
+    public static final boolean m4091isInMillisimpl(long j) {
+        return (((int) j) & 1) == 1;
+    }
+
+    /* renamed from: isInNanos-impl, reason: not valid java name */
+    public static final boolean m4092isInNanosimpl(long j) {
+        return (((int) j) & 1) == 0;
+    }
+
+    /* renamed from: isInfinite-impl, reason: not valid java name */
+    public static final boolean m4093isInfiniteimpl(long j) {
+        return j == INFINITE || j == NEG_INFINITE;
+    }
+
+    /* renamed from: isNegative-impl, reason: not valid java name */
+    public static final boolean m4094isNegativeimpl(long j) {
+        return j < 0;
+    }
+
+    /* renamed from: isPositive-impl, reason: not valid java name */
+    public static final boolean m4095isPositiveimpl(long j) {
+        return j > 0;
+    }
+
+    public boolean equals(Object obj) {
+        return m4076equalsimpl(this.rawValue, obj);
+    }
+
+    public int hashCode() {
+        return m4089hashCodeimpl(this.rawValue);
+    }
+
+    /* renamed from: unbox-impl, reason: not valid java name */
+    public final /* synthetic */ long m4102unboximpl() {
+        return this.rawValue;
+    }
+
+    @Override // java.lang.Comparable
+    public /* bridge */ /* synthetic */ int compareTo(Object obj) {
+        return m4101compareToLRDsOJo(((Duration) obj).m4102unboximpl());
+    }
+
+    public /* synthetic */ Duration(long j) {
+        this.rawValue = j;
+    }
+
+    /* renamed from: getStorageUnit-impl, reason: not valid java name */
+    public static final DurationUnit m4087getStorageUnitimpl(long j) {
+        return m4092isInNanosimpl(j) ? DurationUnit.NANOSECONDS : DurationUnit.MILLISECONDS;
+    }
+
+    /* renamed from: constructor-impl, reason: not valid java name */
+    public static long m4075constructorimpl(long j) {
+        if (DurationJvmKt.getDurationAssertionsEnabled()) {
+            if (m4092isInNanosimpl(j)) {
+                if (!new LongRange(-4611686018426999999L, 4611686018426999999L).contains(m4088getValueimpl(j))) {
+                    throw new AssertionError(m4088getValueimpl(j) + " ns is out of nanoseconds range");
+                }
+            } else {
+                if (!new LongRange(-4611686018427387903L, 4611686018427387903L).contains(m4088getValueimpl(j))) {
+                    throw new AssertionError(m4088getValueimpl(j) + " ms is out of milliseconds range");
+                }
+                if (new LongRange(-4611686018426L, 4611686018426L).contains(m4088getValueimpl(j))) {
+                    throw new AssertionError(m4088getValueimpl(j) + " ms is denormalized");
+                }
+            }
+        }
+        return j;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+
+        /* renamed from: getZERO-UwyO8pc, reason: not valid java name */
+        public final long m4105getZEROUwyO8pc() {
+            return Duration.ZERO;
+        }
+
+        /* renamed from: getINFINITE-UwyO8pc, reason: not valid java name */
+        public final long m4103getINFINITEUwyO8pc() {
+            return Duration.INFINITE;
+        }
+
+        /* renamed from: getNEG_INFINITE-UwyO8pc$kotlin_stdlib, reason: not valid java name */
+        public final long m4104getNEG_INFINITEUwyO8pc$kotlin_stdlib() {
+            return Duration.NEG_INFINITE;
+        }
+    }
+
+    static {
+        long durationOfMillis;
+        long durationOfMillis2;
+        durationOfMillis = DurationKt.durationOfMillis(4611686018427387903L);
+        INFINITE = durationOfMillis;
+        durationOfMillis2 = DurationKt.durationOfMillis(-4611686018427387903L);
+        NEG_INFINITE = durationOfMillis2;
+    }
+
+    /* renamed from: unaryMinus-UwyO8pc, reason: not valid java name */
+    public static final long m4100unaryMinusUwyO8pc(long j) {
+        long durationOf;
+        durationOf = DurationKt.durationOf(-m4088getValueimpl(j), ((int) j) & 1);
+        return durationOf;
+    }
+
+    /* renamed from: plus-LRDsOJo, reason: not valid java name */
+    public static final long m4096plusLRDsOJo(long j, long j2) {
+        long durationOfMillisNormalized;
+        long durationOfNanosNormalized;
+        if (m4093isInfiniteimpl(j)) {
+            if (m4090isFiniteimpl(j2) || (j2 ^ j) >= 0) {
+                return j;
+            }
+            throw new IllegalArgumentException("Summing infinite durations of different signs yields an undefined result.");
+        }
+        if (m4093isInfiniteimpl(j2)) {
+            return j2;
+        }
+        if ((((int) j) & 1) == (((int) j2) & 1)) {
+            long m4088getValueimpl = m4088getValueimpl(j) + m4088getValueimpl(j2);
+            if (m4092isInNanosimpl(j)) {
+                durationOfNanosNormalized = DurationKt.durationOfNanosNormalized(m4088getValueimpl);
+                return durationOfNanosNormalized;
+            }
+            durationOfMillisNormalized = DurationKt.durationOfMillisNormalized(m4088getValueimpl);
+            return durationOfMillisNormalized;
+        }
+        if (m4091isInMillisimpl(j)) {
+            return m4071addValuesMixedRangesUwyO8pc(j, m4088getValueimpl(j), m4088getValueimpl(j2));
+        }
+        return m4071addValuesMixedRangesUwyO8pc(j, m4088getValueimpl(j2), m4088getValueimpl(j));
+    }
+
+    /* renamed from: addValuesMixedRanges-UwyO8pc, reason: not valid java name */
+    public static final long m4071addValuesMixedRangesUwyO8pc(long j, long j2, long j3) {
+        long nanosToMillis;
+        long coerceIn;
+        long durationOfMillis;
+        long millisToNanos;
+        long millisToNanos2;
+        long durationOfNanos;
+        nanosToMillis = DurationKt.nanosToMillis(j3);
+        long j4 = j2 + nanosToMillis;
+        if (new LongRange(-4611686018426L, 4611686018426L).contains(j4)) {
+            millisToNanos = DurationKt.millisToNanos(nanosToMillis);
+            long j5 = j3 - millisToNanos;
+            millisToNanos2 = DurationKt.millisToNanos(j4);
+            durationOfNanos = DurationKt.durationOfNanos(millisToNanos2 + j5);
+            return durationOfNanos;
+        }
+        coerceIn = RangesKt___RangesKt.coerceIn(j4, -4611686018427387903L, 4611686018427387903L);
+        durationOfMillis = DurationKt.durationOfMillis(coerceIn);
+        return durationOfMillis;
+    }
+
+    /* renamed from: isFinite-impl, reason: not valid java name */
+    public static final boolean m4090isFiniteimpl(long j) {
+        return !m4093isInfiniteimpl(j);
+    }
+
+    /* renamed from: getAbsoluteValue-UwyO8pc, reason: not valid java name */
+    public static final long m4077getAbsoluteValueUwyO8pc(long j) {
+        return m4094isNegativeimpl(j) ? m4100unaryMinusUwyO8pc(j) : j;
+    }
+
+    /* renamed from: compareTo-LRDsOJo, reason: not valid java name */
+    public int m4101compareToLRDsOJo(long j) {
+        return m4074compareToLRDsOJo(this.rawValue, j);
+    }
+
+    /* renamed from: compareTo-LRDsOJo, reason: not valid java name */
+    public static int m4074compareToLRDsOJo(long j, long j2) {
+        long j3 = j ^ j2;
+        if (j3 < 0 || (((int) j3) & 1) == 0) {
+            return Intrinsics.compare(j, j2);
+        }
+        int i = (((int) j) & 1) - (((int) j2) & 1);
+        return m4094isNegativeimpl(j) ? -i : i;
+    }
+
+    /* renamed from: getHoursComponent-impl, reason: not valid java name */
+    public static final int m4078getHoursComponentimpl(long j) {
+        if (m4093isInfiniteimpl(j)) {
+            return 0;
+        }
+        return (int) (m4080getInWholeHoursimpl(j) % 24);
+    }
+
+    /* renamed from: getMinutesComponent-impl, reason: not valid java name */
+    public static final int m4084getMinutesComponentimpl(long j) {
+        if (m4093isInfiniteimpl(j)) {
+            return 0;
+        }
+        return (int) (m4082getInWholeMinutesimpl(j) % 60);
+    }
+
+    /* renamed from: getSecondsComponent-impl, reason: not valid java name */
+    public static final int m4086getSecondsComponentimpl(long j) {
+        if (m4093isInfiniteimpl(j)) {
+            return 0;
+        }
+        return (int) (m4083getInWholeSecondsimpl(j) % 60);
+    }
+
+    /* renamed from: getNanosecondsComponent-impl, reason: not valid java name */
+    public static final int m4085getNanosecondsComponentimpl(long j) {
+        long m4088getValueimpl;
+        if (m4093isInfiniteimpl(j)) {
+            return 0;
+        }
+        if (m4091isInMillisimpl(j)) {
+            m4088getValueimpl = DurationKt.millisToNanos(m4088getValueimpl(j) % 1000);
+        } else {
+            m4088getValueimpl = m4088getValueimpl(j) % 1000000000;
+        }
+        return (int) m4088getValueimpl;
+    }
+
+    /* renamed from: toDouble-impl, reason: not valid java name */
+    public static final double m4097toDoubleimpl(long j, DurationUnit unit) {
+        Intrinsics.checkNotNullParameter(unit, "unit");
+        if (j == INFINITE) {
+            return Double.POSITIVE_INFINITY;
+        }
+        if (j == NEG_INFINITE) {
+            return Double.NEGATIVE_INFINITY;
+        }
+        return DurationUnitKt__DurationUnitJvmKt.convertDurationUnit(m4088getValueimpl(j), m4087getStorageUnitimpl(j), unit);
+    }
+
+    /* renamed from: toLong-impl, reason: not valid java name */
+    public static final long m4098toLongimpl(long j, DurationUnit unit) {
+        Intrinsics.checkNotNullParameter(unit, "unit");
+        if (j == INFINITE) {
+            return Long.MAX_VALUE;
+        }
+        if (j == NEG_INFINITE) {
+            return Long.MIN_VALUE;
+        }
+        return DurationUnitKt__DurationUnitJvmKt.convertDurationUnit(m4088getValueimpl(j), m4087getStorageUnitimpl(j), unit);
+    }
+
+    /* renamed from: getInWholeDays-impl, reason: not valid java name */
+    public static final long m4079getInWholeDaysimpl(long j) {
+        return m4098toLongimpl(j, DurationUnit.DAYS);
+    }
+
+    /* renamed from: getInWholeHours-impl, reason: not valid java name */
+    public static final long m4080getInWholeHoursimpl(long j) {
+        return m4098toLongimpl(j, DurationUnit.HOURS);
+    }
+
+    /* renamed from: getInWholeMinutes-impl, reason: not valid java name */
+    public static final long m4082getInWholeMinutesimpl(long j) {
+        return m4098toLongimpl(j, DurationUnit.MINUTES);
+    }
+
+    /* renamed from: getInWholeSeconds-impl, reason: not valid java name */
+    public static final long m4083getInWholeSecondsimpl(long j) {
+        return m4098toLongimpl(j, DurationUnit.SECONDS);
+    }
+
+    /* renamed from: getInWholeMilliseconds-impl, reason: not valid java name */
+    public static final long m4081getInWholeMillisecondsimpl(long j) {
+        return (m4091isInMillisimpl(j) && m4090isFiniteimpl(j)) ? m4088getValueimpl(j) : m4098toLongimpl(j, DurationUnit.MILLISECONDS);
+    }
+
+    public String toString() {
+        return m4099toStringimpl(this.rawValue);
+    }
+
+    /* renamed from: toString-impl, reason: not valid java name */
+    public static String m4099toStringimpl(long j) {
+        if (j == 0) {
+            return "0s";
+        }
+        if (j == INFINITE) {
+            return "Infinity";
+        }
+        if (j == NEG_INFINITE) {
+            return "-Infinity";
+        }
+        boolean m4094isNegativeimpl = m4094isNegativeimpl(j);
+        StringBuilder sb = new StringBuilder();
+        if (m4094isNegativeimpl) {
+            sb.append('-');
+        }
+        long m4077getAbsoluteValueUwyO8pc = m4077getAbsoluteValueUwyO8pc(j);
+        long m4079getInWholeDaysimpl = m4079getInWholeDaysimpl(m4077getAbsoluteValueUwyO8pc);
+        int m4078getHoursComponentimpl = m4078getHoursComponentimpl(m4077getAbsoluteValueUwyO8pc);
+        int m4084getMinutesComponentimpl = m4084getMinutesComponentimpl(m4077getAbsoluteValueUwyO8pc);
+        int m4086getSecondsComponentimpl = m4086getSecondsComponentimpl(m4077getAbsoluteValueUwyO8pc);
+        int m4085getNanosecondsComponentimpl = m4085getNanosecondsComponentimpl(m4077getAbsoluteValueUwyO8pc);
+        int i = 0;
+        boolean z = m4079getInWholeDaysimpl != 0;
+        boolean z2 = m4078getHoursComponentimpl != 0;
+        boolean z3 = m4084getMinutesComponentimpl != 0;
+        boolean z4 = (m4086getSecondsComponentimpl == 0 && m4085getNanosecondsComponentimpl == 0) ? false : true;
+        if (z) {
+            sb.append(m4079getInWholeDaysimpl);
+            sb.append('d');
+            i = 1;
+        }
+        if (z2 || (z && (z3 || z4))) {
+            int i2 = i + 1;
+            if (i > 0) {
+                sb.append(' ');
+            }
+            sb.append(m4078getHoursComponentimpl);
+            sb.append('h');
+            i = i2;
+        }
+        if (z3 || (z4 && (z2 || z))) {
+            int i3 = i + 1;
+            if (i > 0) {
+                sb.append(' ');
+            }
+            sb.append(m4084getMinutesComponentimpl);
+            sb.append('m');
+            i = i3;
+        }
+        if (z4) {
+            int i4 = i + 1;
+            if (i > 0) {
+                sb.append(' ');
+            }
+            if (m4086getSecondsComponentimpl != 0 || z || z2 || z3) {
+                m4072appendFractionalimpl(j, sb, m4086getSecondsComponentimpl, m4085getNanosecondsComponentimpl, 9, "s", false);
+            } else if (m4085getNanosecondsComponentimpl >= 1000000) {
+                m4072appendFractionalimpl(j, sb, m4085getNanosecondsComponentimpl / 1000000, m4085getNanosecondsComponentimpl % 1000000, 6, "ms", false);
+            } else if (m4085getNanosecondsComponentimpl >= 1000) {
+                m4072appendFractionalimpl(j, sb, m4085getNanosecondsComponentimpl / 1000, m4085getNanosecondsComponentimpl % 1000, 3, "us", false);
+            } else {
+                sb.append(m4085getNanosecondsComponentimpl);
+                sb.append("ns");
+            }
+            i = i4;
+        }
+        if (m4094isNegativeimpl && i > 1) {
+            sb.insert(1, '(').append(')');
+        }
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "toString(...)");
+        return sb2;
+    }
+
+    /* renamed from: appendFractional-impl, reason: not valid java name */
+    public static final void m4072appendFractionalimpl(long j, StringBuilder sb, int i, int i2, int i3, String str, boolean z) {
+        String padStart;
+        sb.append(i);
+        if (i2 != 0) {
+            sb.append('.');
+            padStart = StringsKt__StringsKt.padStart(String.valueOf(i2), i3, '0');
+            int i4 = -1;
+            int length = padStart.length() - 1;
+            if (length >= 0) {
+                while (true) {
+                    int i5 = length - 1;
+                    if (padStart.charAt(length) != '0') {
+                        i4 = length;
+                        break;
+                    } else if (i5 < 0) {
+                        break;
+                    } else {
+                        length = i5;
+                    }
+                }
+            }
+            int i6 = i4 + 1;
+            if (!z && i6 < 3) {
+                sb.append((CharSequence) padStart, 0, i6);
+                Intrinsics.checkNotNullExpressionValue(sb, "append(...)");
+            } else {
+                sb.append((CharSequence) padStart, 0, ((i4 + 3) / 3) * 3);
+                Intrinsics.checkNotNullExpressionValue(sb, "append(...)");
+            }
+        }
+        sb.append(str);
+    }
+}

decompiled/sources/kotlin/time/DurationJvmKt.java

@@ -0,0 +1,19 @@
+package kotlin.time;
+
+/* loaded from: classes5.dex */
+public abstract class DurationJvmKt {
+    public static final boolean durationAssertionsEnabled = false;
+    public static final ThreadLocal[] precisionFormats;
+
+    public static final boolean getDurationAssertionsEnabled() {
+        return durationAssertionsEnabled;
+    }
+
+    static {
+        ThreadLocal[] threadLocalArr = new ThreadLocal[4];
+        for (int i = 0; i < 4; i++) {
+            threadLocalArr[i] = new ThreadLocal();
+        }
+        precisionFormats = threadLocalArr;
+    }
+}

decompiled/sources/kotlin/time/DurationKt.java

@@ -0,0 +1,64 @@
+package kotlin.time;
+
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.ranges.LongRange;
+import kotlin.ranges.RangesKt___RangesKt;
+
+/* loaded from: classes5.dex */
+public abstract class DurationKt {
+    public static final long millisToNanos(long j) {
+        return j * 1000000;
+    }
+
+    public static final long toDuration(int i, DurationUnit unit) {
+        Intrinsics.checkNotNullParameter(unit, "unit");
+        if (unit.compareTo(DurationUnit.SECONDS) <= 0) {
+            return durationOfNanos(DurationUnitKt__DurationUnitJvmKt.convertDurationUnitOverflow(i, unit, DurationUnit.NANOSECONDS));
+        }
+        return toDuration(i, unit);
+    }
+
+    public static final long toDuration(long j, DurationUnit unit) {
+        long coerceIn;
+        Intrinsics.checkNotNullParameter(unit, "unit");
+        DurationUnit durationUnit = DurationUnit.NANOSECONDS;
+        long convertDurationUnitOverflow = DurationUnitKt__DurationUnitJvmKt.convertDurationUnitOverflow(4611686018426999999L, durationUnit, unit);
+        if (new LongRange(-convertDurationUnitOverflow, convertDurationUnitOverflow).contains(j)) {
+            return durationOfNanos(DurationUnitKt__DurationUnitJvmKt.convertDurationUnitOverflow(j, unit, durationUnit));
+        }
+        coerceIn = RangesKt___RangesKt.coerceIn(DurationUnitKt__DurationUnitJvmKt.convertDurationUnit(j, unit, DurationUnit.MILLISECONDS), -4611686018427387903L, 4611686018427387903L);
+        return durationOfMillis(coerceIn);
+    }
+
+    public static final long nanosToMillis(long j) {
+        return j / 1000000;
+    }
+
+    public static final long durationOfNanos(long j) {
+        return Duration.m4075constructorimpl(j << 1);
+    }
+
+    public static final long durationOfMillis(long j) {
+        return Duration.m4075constructorimpl((j << 1) + 1);
+    }
+
+    public static final long durationOf(long j, int i) {
+        return Duration.m4075constructorimpl((j << 1) + i);
+    }
+
+    public static final long durationOfNanosNormalized(long j) {
+        if (new LongRange(-4611686018426999999L, 4611686018426999999L).contains(j)) {
+            return durationOfNanos(j);
+        }
+        return durationOfMillis(nanosToMillis(j));
+    }
+
+    public static final long durationOfMillisNormalized(long j) {
+        long coerceIn;
+        if (new LongRange(-4611686018426L, 4611686018426L).contains(j)) {
+            return durationOfNanos(millisToNanos(j));
+        }
+        coerceIn = RangesKt___RangesKt.coerceIn(j, -4611686018427387903L, 4611686018427387903L);
+        return durationOfMillis(coerceIn);
+    }
+}

decompiled/sources/kotlin/time/DurationUnit.java

@@ -0,0 +1,51 @@
+package kotlin.time;
+
+import java.util.concurrent.TimeUnit;
+import kotlin.enums.EnumEntries;
+import kotlin.enums.EnumEntriesKt;
+
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* JADX WARN: Unknown enum class pattern. Please report as an issue! */
+/* loaded from: classes5.dex */
+public final class DurationUnit {
+    private static final /* synthetic */ EnumEntries $ENTRIES;
+    private static final /* synthetic */ DurationUnit[] $VALUES;
+    private final TimeUnit timeUnit;
+    public static final DurationUnit NANOSECONDS = new DurationUnit("NANOSECONDS", 0, TimeUnit.NANOSECONDS);
+    public static final DurationUnit MICROSECONDS = new DurationUnit("MICROSECONDS", 1, TimeUnit.MICROSECONDS);
+    public static final DurationUnit MILLISECONDS = new DurationUnit("MILLISECONDS", 2, TimeUnit.MILLISECONDS);
+    public static final DurationUnit SECONDS = new DurationUnit("SECONDS", 3, TimeUnit.SECONDS);
+    public static final DurationUnit MINUTES = new DurationUnit("MINUTES", 4, TimeUnit.MINUTES);
+    public static final DurationUnit HOURS = new DurationUnit("HOURS", 5, TimeUnit.HOURS);
+    public static final DurationUnit DAYS = new DurationUnit("DAYS", 6, TimeUnit.DAYS);
+
+    private static final /* synthetic */ DurationUnit[] $values() {
+        return new DurationUnit[]{NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS};
+    }
+
+    public static EnumEntries getEntries() {
+        return $ENTRIES;
+    }
+
+    public static DurationUnit valueOf(String str) {
+        return (DurationUnit) Enum.valueOf(DurationUnit.class, str);
+    }
+
+    public static DurationUnit[] values() {
+        return (DurationUnit[]) $VALUES.clone();
+    }
+
+    public final TimeUnit getTimeUnit$kotlin_stdlib() {
+        return this.timeUnit;
+    }
+
+    private DurationUnit(String str, int i, TimeUnit timeUnit) {
+        this.timeUnit = timeUnit;
+    }
+
+    static {
+        DurationUnit[] $values = $values();
+        $VALUES = $values;
+        $ENTRIES = EnumEntriesKt.enumEntries($values);
+    }
+}

decompiled/sources/kotlin/time/DurationUnitKt__DurationUnitJvmKt.java

@@ -0,0 +1,25 @@
+package kotlin.time;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes5.dex */
+public abstract class DurationUnitKt__DurationUnitJvmKt {
+    public static final double convertDurationUnit(double d, DurationUnit sourceUnit, DurationUnit targetUnit) {
+        Intrinsics.checkNotNullParameter(sourceUnit, "sourceUnit");
+        Intrinsics.checkNotNullParameter(targetUnit, "targetUnit");
+        long convert = targetUnit.getTimeUnit$kotlin_stdlib().convert(1L, sourceUnit.getTimeUnit$kotlin_stdlib());
+        return convert > 0 ? d * convert : d / sourceUnit.getTimeUnit$kotlin_stdlib().convert(1L, targetUnit.getTimeUnit$kotlin_stdlib());
+    }
+
+    public static final long convertDurationUnitOverflow(long j, DurationUnit sourceUnit, DurationUnit targetUnit) {
+        Intrinsics.checkNotNullParameter(sourceUnit, "sourceUnit");
+        Intrinsics.checkNotNullParameter(targetUnit, "targetUnit");
+        return targetUnit.getTimeUnit$kotlin_stdlib().convert(j, sourceUnit.getTimeUnit$kotlin_stdlib());
+    }
+
+    public static final long convertDurationUnit(long j, DurationUnit sourceUnit, DurationUnit targetUnit) {
+        Intrinsics.checkNotNullParameter(sourceUnit, "sourceUnit");
+        Intrinsics.checkNotNullParameter(targetUnit, "targetUnit");
+        return targetUnit.getTimeUnit$kotlin_stdlib().convert(j, sourceUnit.getTimeUnit$kotlin_stdlib());
+    }
+}

decompiled/sources/kotlin/time/LongSaturatedMathKt.java

@@ -0,0 +1,49 @@
+package kotlin.time;
+
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.time.Duration;
+
+/* loaded from: classes5.dex */
+public abstract class LongSaturatedMathKt {
+    public static final long infinityOfSign(long j) {
+        return j < 0 ? Duration.Companion.m4104getNEG_INFINITEUwyO8pc$kotlin_stdlib() : Duration.Companion.m4103getINFINITEUwyO8pc();
+    }
+
+    public static final long saturatingDiff(long j, long j2, DurationUnit unit) {
+        Intrinsics.checkNotNullParameter(unit, "unit");
+        if ((1 | (j2 - 1)) == Long.MAX_VALUE) {
+            return Duration.m4100unaryMinusUwyO8pc(infinityOfSign(j2));
+        }
+        return saturatingFiniteDiff(j, j2, unit);
+    }
+
+    public static final long saturatingOriginsDiff(long j, long j2, DurationUnit unit) {
+        Intrinsics.checkNotNullParameter(unit, "unit");
+        if (((j2 - 1) | 1) == Long.MAX_VALUE) {
+            if (j == j2) {
+                return Duration.Companion.m4105getZEROUwyO8pc();
+            }
+            return Duration.m4100unaryMinusUwyO8pc(infinityOfSign(j2));
+        }
+        if ((1 | (j - 1)) == Long.MAX_VALUE) {
+            return infinityOfSign(j);
+        }
+        return saturatingFiniteDiff(j, j2, unit);
+    }
+
+    public static final long saturatingFiniteDiff(long j, long j2, DurationUnit durationUnit) {
+        long j3 = j - j2;
+        if (((j3 ^ j) & (~(j3 ^ j2))) < 0) {
+            DurationUnit durationUnit2 = DurationUnit.MILLISECONDS;
+            if (durationUnit.compareTo(durationUnit2) < 0) {
+                long convertDurationUnit = DurationUnitKt__DurationUnitJvmKt.convertDurationUnit(1L, durationUnit2, durationUnit);
+                long j4 = (j / convertDurationUnit) - (j2 / convertDurationUnit);
+                long j5 = (j % convertDurationUnit) - (j2 % convertDurationUnit);
+                Duration.Companion companion = Duration.Companion;
+                return Duration.m4096plusLRDsOJo(DurationKt.toDuration(j4, durationUnit2), DurationKt.toDuration(j5, durationUnit));
+            }
+            return Duration.m4100unaryMinusUwyO8pc(infinityOfSign(j3));
+        }
+        return DurationKt.toDuration(j3, durationUnit);
+    }
+}

decompiled/sources/kotlin/time/MonotonicTimeSource.java

@@ -0,0 +1,32 @@
+package kotlin.time;
+
+import kotlin.time.TimeSource$Monotonic;
+
+/* loaded from: classes5.dex */
+public final class MonotonicTimeSource {
+    public static final MonotonicTimeSource INSTANCE = new MonotonicTimeSource();
+    public static final long zero = System.nanoTime();
+
+    public String toString() {
+        return "TimeSource(System.nanoTime())";
+    }
+
+    public final long read() {
+        return System.nanoTime() - zero;
+    }
+
+    /* renamed from: markNow-z9LOYto, reason: not valid java name */
+    public long m4108markNowz9LOYto() {
+        return TimeSource$Monotonic.ValueTimeMark.m4112constructorimpl(read());
+    }
+
+    /* renamed from: elapsedFrom-6eNON_k, reason: not valid java name */
+    public final long m4107elapsedFrom6eNON_k(long j) {
+        return LongSaturatedMathKt.saturatingDiff(read(), j, DurationUnit.NANOSECONDS);
+    }
+
+    /* renamed from: differenceBetween-fRLX17w, reason: not valid java name */
+    public final long m4106differenceBetweenfRLX17w(long j, long j2) {
+        return LongSaturatedMathKt.saturatingOriginsDiff(j, j2, DurationUnit.NANOSECONDS);
+    }
+}

decompiled/sources/kotlin/time/TimeMark.java

@@ -0,0 +1,7 @@
+package kotlin.time;
+
+/* loaded from: classes5.dex */
+public interface TimeMark {
+    /* renamed from: elapsedNow-UwyO8pc, reason: not valid java name */
+    long mo4109elapsedNowUwyO8pc();
+}

decompiled/sources/kotlin/time/TimeSource$Monotonic.java

@@ -0,0 +1,105 @@
+package kotlin.time;
+
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.time.ComparableTimeMark;
+
+/* loaded from: classes5.dex */
+public final class TimeSource$Monotonic {
+    public static final TimeSource$Monotonic INSTANCE = new TimeSource$Monotonic();
+
+    /* renamed from: markNow-z9LOYto, reason: not valid java name */
+    public long m4110markNowz9LOYto() {
+        return MonotonicTimeSource.INSTANCE.m4108markNowz9LOYto();
+    }
+
+    public String toString() {
+        return MonotonicTimeSource.INSTANCE.toString();
+    }
+
+    public static final class ValueTimeMark implements ComparableTimeMark {
+        public final long reading;
+
+        /* renamed from: box-impl, reason: not valid java name */
+        public static final /* synthetic */ ValueTimeMark m4111boximpl(long j) {
+            return new ValueTimeMark(j);
+        }
+
+        /* renamed from: constructor-impl, reason: not valid java name */
+        public static long m4112constructorimpl(long j) {
+            return j;
+        }
+
+        /* renamed from: equals-impl, reason: not valid java name */
+        public static boolean m4114equalsimpl(long j, Object obj) {
+            return (obj instanceof ValueTimeMark) && j == ((ValueTimeMark) obj).m4119unboximpl();
+        }
+
+        /* renamed from: hashCode-impl, reason: not valid java name */
+        public static int m4115hashCodeimpl(long j) {
+            return Long.hashCode(j);
+        }
+
+        /* renamed from: toString-impl, reason: not valid java name */
+        public static String m4118toStringimpl(long j) {
+            return "ValueTimeMark(reading=" + j + ')';
+        }
+
+        public boolean equals(Object obj) {
+            return m4114equalsimpl(this.reading, obj);
+        }
+
+        public int hashCode() {
+            return m4115hashCodeimpl(this.reading);
+        }
+
+        public String toString() {
+            return m4118toStringimpl(this.reading);
+        }
+
+        /* renamed from: unbox-impl, reason: not valid java name */
+        public final /* synthetic */ long m4119unboximpl() {
+            return this.reading;
+        }
+
+        @Override // java.lang.Comparable
+        public int compareTo(ComparableTimeMark comparableTimeMark) {
+            return ComparableTimeMark.DefaultImpls.compareTo(this, comparableTimeMark);
+        }
+
+        public /* synthetic */ ValueTimeMark(long j) {
+            this.reading = j;
+        }
+
+        /* renamed from: elapsedNow-UwyO8pc, reason: not valid java name */
+        public static long m4113elapsedNowUwyO8pc(long j) {
+            return MonotonicTimeSource.INSTANCE.m4107elapsedFrom6eNON_k(j);
+        }
+
+        @Override // kotlin.time.TimeMark
+        /* renamed from: elapsedNow-UwyO8pc */
+        public long mo4109elapsedNowUwyO8pc() {
+            return m4113elapsedNowUwyO8pc(this.reading);
+        }
+
+        @Override // kotlin.time.ComparableTimeMark
+        /* renamed from: minus-UwyO8pc */
+        public long mo4070minusUwyO8pc(ComparableTimeMark other) {
+            Intrinsics.checkNotNullParameter(other, "other");
+            return m4117minusUwyO8pc(this.reading, other);
+        }
+
+        /* renamed from: minus-UwyO8pc, reason: not valid java name */
+        public static long m4117minusUwyO8pc(long j, ComparableTimeMark other) {
+            Intrinsics.checkNotNullParameter(other, "other");
+            if (!(other instanceof ValueTimeMark)) {
+                throw new IllegalArgumentException("Subtracting or comparing time marks from different time sources is not possible: " + ((Object) m4118toStringimpl(j)) + " and " + other);
+            }
+            return m4116minus6eNON_k(j, ((ValueTimeMark) other).m4119unboximpl());
+        }
+
+        /* renamed from: minus-6eNON_k, reason: not valid java name */
+        public static final long m4116minus6eNON_k(long j, long j2) {
+            return MonotonicTimeSource.INSTANCE.m4106differenceBetweenfRLX17w(j, j2);
+        }
+    }
+}