Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.
This commit is contained in:
@@ -0,0 +1,68 @@
|
||||
package kotlin.reflect.jvm.internal.impl.utils;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import kotlin.jvm.internal.Intrinsics;
|
||||
import kotlin.jvm.internal.SourceDebugExtension;
|
||||
|
||||
@SourceDebugExtension({"SMAP\ncollections.kt\nKotlin\n*S Kotlin\n*F\n+ 1 collections.kt\norg/jetbrains/kotlin/utils/CollectionsKt\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n+ 3 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,110:1\n1208#2,2:111\n1238#2,4:113\n1#3:117\n*S KotlinDebug\n*F\n+ 1 collections.kt\norg/jetbrains/kotlin/utils/CollectionsKt\n*L\n22#1:111,2\n22#1:113,4\n*E\n"})
|
||||
/* loaded from: classes3.dex */
|
||||
public final class CollectionsKt {
|
||||
public static final <T> void addIfNotNull(Collection<T> collection, T t2) {
|
||||
Intrinsics.checkNotNullParameter(collection, "<this>");
|
||||
if (t2 != null) {
|
||||
collection.add(t2);
|
||||
}
|
||||
}
|
||||
|
||||
private static final int capacity(int i) {
|
||||
if (i < 3) {
|
||||
return 3;
|
||||
}
|
||||
return (i / 3) + i + 1;
|
||||
}
|
||||
|
||||
public static final <T> List<T> compact(ArrayList<T> arrayList) {
|
||||
Intrinsics.checkNotNullParameter(arrayList, "<this>");
|
||||
int size = arrayList.size();
|
||||
if (size == 0) {
|
||||
return kotlin.collections.CollectionsKt.emptyList();
|
||||
}
|
||||
if (size == 1) {
|
||||
return kotlin.collections.CollectionsKt.listOf(kotlin.collections.CollectionsKt.first((List) arrayList));
|
||||
}
|
||||
arrayList.trimToSize();
|
||||
return arrayList;
|
||||
}
|
||||
|
||||
public static final <K> Map<K, Integer> mapToIndex(Iterable<? extends K> iterable) {
|
||||
Intrinsics.checkNotNullParameter(iterable, "<this>");
|
||||
LinkedHashMap linkedHashMap = new LinkedHashMap();
|
||||
Iterator<? extends K> it = iterable.iterator();
|
||||
int i = 0;
|
||||
while (it.hasNext()) {
|
||||
linkedHashMap.put(it.next(), Integer.valueOf(i));
|
||||
i++;
|
||||
}
|
||||
return linkedHashMap;
|
||||
}
|
||||
|
||||
public static final <K, V> HashMap<K, V> newHashMapWithExpectedSize(int i) {
|
||||
return new HashMap<>(capacity(i));
|
||||
}
|
||||
|
||||
public static final <E> HashSet<E> newHashSetWithExpectedSize(int i) {
|
||||
return new HashSet<>(capacity(i));
|
||||
}
|
||||
|
||||
public static final <E> LinkedHashSet<E> newLinkedHashSetWithExpectedSize(int i) {
|
||||
return new LinkedHashSet<>(capacity(i));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,280 @@
|
||||
package kotlin.reflect.jvm.internal.impl.utils;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.LinkedList;
|
||||
import java.util.Set;
|
||||
import kotlin.jvm.functions.Function1;
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public class DFS {
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public static abstract class AbstractNodeHandler<N, R> implements NodeHandler<N, R> {
|
||||
@Override // kotlin.reflect.jvm.internal.impl.utils.DFS.NodeHandler
|
||||
public void afterChildren(N n4) {
|
||||
}
|
||||
|
||||
@Override // kotlin.reflect.jvm.internal.impl.utils.DFS.NodeHandler
|
||||
public boolean beforeChildren(N n4) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public static abstract class CollectingNodeHandler<N, R, C extends Iterable<R>> extends AbstractNodeHandler<N, C> {
|
||||
protected final C result;
|
||||
|
||||
private static /* synthetic */ void $$$reportNull$$$0(int i) {
|
||||
String str = i != 1 ? "Argument for @NotNull parameter '%s' of %s.%s must not be null" : "@NotNull method %s.%s must not return null";
|
||||
Object[] objArr = new Object[i != 1 ? 3 : 2];
|
||||
if (i != 1) {
|
||||
objArr[0] = "result";
|
||||
} else {
|
||||
objArr[0] = "kotlin/reflect/jvm/internal/impl/utils/DFS$CollectingNodeHandler";
|
||||
}
|
||||
if (i != 1) {
|
||||
objArr[1] = "kotlin/reflect/jvm/internal/impl/utils/DFS$CollectingNodeHandler";
|
||||
} else {
|
||||
objArr[1] = "result";
|
||||
}
|
||||
if (i != 1) {
|
||||
objArr[2] = "<init>";
|
||||
}
|
||||
String format = String.format(str, objArr);
|
||||
if (i == 1) {
|
||||
throw new IllegalStateException(format);
|
||||
}
|
||||
}
|
||||
|
||||
public CollectingNodeHandler(C c4) {
|
||||
if (c4 == null) {
|
||||
$$$reportNull$$$0(0);
|
||||
}
|
||||
this.result = c4;
|
||||
}
|
||||
|
||||
@Override // kotlin.reflect.jvm.internal.impl.utils.DFS.NodeHandler
|
||||
public C result() {
|
||||
C c4 = this.result;
|
||||
if (c4 == null) {
|
||||
$$$reportNull$$$0(1);
|
||||
}
|
||||
return c4;
|
||||
}
|
||||
}
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public interface Neighbors<N> {
|
||||
Iterable<? extends N> getNeighbors(N n4);
|
||||
}
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public interface NodeHandler<N, R> {
|
||||
void afterChildren(N n4);
|
||||
|
||||
boolean beforeChildren(N n4);
|
||||
|
||||
R result();
|
||||
}
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public static abstract class NodeHandlerWithListResult<N, R> extends CollectingNodeHandler<N, R, LinkedList<R>> {
|
||||
public NodeHandlerWithListResult() {
|
||||
super(new LinkedList());
|
||||
}
|
||||
}
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public interface Visited<N> {
|
||||
boolean checkAndMarkVisited(N n4);
|
||||
}
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public static class VisitedWithSet<N> implements Visited<N> {
|
||||
private final Set<N> visited;
|
||||
|
||||
private static /* synthetic */ void $$$reportNull$$$0(int i) {
|
||||
throw new IllegalArgumentException("Argument for @NotNull parameter 'visited' of kotlin/reflect/jvm/internal/impl/utils/DFS$VisitedWithSet.<init> must not be null");
|
||||
}
|
||||
|
||||
public VisitedWithSet() {
|
||||
this(new HashSet());
|
||||
}
|
||||
|
||||
@Override // kotlin.reflect.jvm.internal.impl.utils.DFS.Visited
|
||||
public boolean checkAndMarkVisited(N n4) {
|
||||
return this.visited.add(n4);
|
||||
}
|
||||
|
||||
public VisitedWithSet(Set<N> set) {
|
||||
if (set == null) {
|
||||
$$$reportNull$$$0(0);
|
||||
}
|
||||
this.visited = set;
|
||||
}
|
||||
}
|
||||
|
||||
private static /* synthetic */ void $$$reportNull$$$0(int i) {
|
||||
Object[] objArr = new Object[3];
|
||||
switch (i) {
|
||||
case 1:
|
||||
case 5:
|
||||
case 8:
|
||||
case 11:
|
||||
case 15:
|
||||
case 18:
|
||||
case 21:
|
||||
case 23:
|
||||
objArr[0] = "neighbors";
|
||||
break;
|
||||
case 2:
|
||||
case 12:
|
||||
case 16:
|
||||
case 19:
|
||||
case 24:
|
||||
objArr[0] = "visited";
|
||||
break;
|
||||
case 3:
|
||||
case 6:
|
||||
case 13:
|
||||
case 25:
|
||||
objArr[0] = "handler";
|
||||
break;
|
||||
case 4:
|
||||
case 7:
|
||||
case 17:
|
||||
case 20:
|
||||
default:
|
||||
objArr[0] = "nodes";
|
||||
break;
|
||||
case 9:
|
||||
objArr[0] = "predicate";
|
||||
break;
|
||||
case 10:
|
||||
case 14:
|
||||
objArr[0] = "node";
|
||||
break;
|
||||
case 22:
|
||||
objArr[0] = "current";
|
||||
break;
|
||||
}
|
||||
objArr[1] = "kotlin/reflect/jvm/internal/impl/utils/DFS";
|
||||
switch (i) {
|
||||
case 7:
|
||||
case 8:
|
||||
case 9:
|
||||
objArr[2] = "ifAny";
|
||||
break;
|
||||
case 10:
|
||||
case 11:
|
||||
case 12:
|
||||
case 13:
|
||||
case 14:
|
||||
case 15:
|
||||
case 16:
|
||||
objArr[2] = "dfsFromNode";
|
||||
break;
|
||||
case 17:
|
||||
case 18:
|
||||
case 19:
|
||||
case 20:
|
||||
case 21:
|
||||
objArr[2] = "topologicalOrder";
|
||||
break;
|
||||
case 22:
|
||||
case 23:
|
||||
case 24:
|
||||
case 25:
|
||||
objArr[2] = "doDfs";
|
||||
break;
|
||||
default:
|
||||
objArr[2] = "dfs";
|
||||
break;
|
||||
}
|
||||
throw new IllegalArgumentException(String.format("Argument for @NotNull parameter '%s' of %s.%s must not be null", objArr));
|
||||
}
|
||||
|
||||
public static <N, R> R dfs(Collection<N> collection, Neighbors<N> neighbors, Visited<N> visited, NodeHandler<N, R> nodeHandler) {
|
||||
if (collection == null) {
|
||||
$$$reportNull$$$0(0);
|
||||
}
|
||||
if (neighbors == null) {
|
||||
$$$reportNull$$$0(1);
|
||||
}
|
||||
if (visited == null) {
|
||||
$$$reportNull$$$0(2);
|
||||
}
|
||||
if (nodeHandler == null) {
|
||||
$$$reportNull$$$0(3);
|
||||
}
|
||||
Iterator<N> it = collection.iterator();
|
||||
while (it.hasNext()) {
|
||||
doDfs(it.next(), neighbors, visited, nodeHandler);
|
||||
}
|
||||
return nodeHandler.result();
|
||||
}
|
||||
|
||||
public static <N> void doDfs(N n4, Neighbors<N> neighbors, Visited<N> visited, NodeHandler<N, ?> nodeHandler) {
|
||||
if (n4 == null) {
|
||||
$$$reportNull$$$0(22);
|
||||
}
|
||||
if (neighbors == null) {
|
||||
$$$reportNull$$$0(23);
|
||||
}
|
||||
if (visited == null) {
|
||||
$$$reportNull$$$0(24);
|
||||
}
|
||||
if (nodeHandler == null) {
|
||||
$$$reportNull$$$0(25);
|
||||
}
|
||||
if (visited.checkAndMarkVisited(n4) && nodeHandler.beforeChildren(n4)) {
|
||||
Iterator<? extends N> it = neighbors.getNeighbors(n4).iterator();
|
||||
while (it.hasNext()) {
|
||||
doDfs(it.next(), neighbors, visited, nodeHandler);
|
||||
}
|
||||
nodeHandler.afterChildren(n4);
|
||||
}
|
||||
}
|
||||
|
||||
public static <N> Boolean ifAny(Collection<N> collection, Neighbors<N> neighbors, final Function1<N, Boolean> function1) {
|
||||
if (collection == null) {
|
||||
$$$reportNull$$$0(7);
|
||||
}
|
||||
if (neighbors == null) {
|
||||
$$$reportNull$$$0(8);
|
||||
}
|
||||
if (function1 == null) {
|
||||
$$$reportNull$$$0(9);
|
||||
}
|
||||
final boolean[] zArr = new boolean[1];
|
||||
return (Boolean) dfs(collection, neighbors, new AbstractNodeHandler<N, Boolean>() { // from class: kotlin.reflect.jvm.internal.impl.utils.DFS.1
|
||||
@Override // kotlin.reflect.jvm.internal.impl.utils.DFS.AbstractNodeHandler, kotlin.reflect.jvm.internal.impl.utils.DFS.NodeHandler
|
||||
public boolean beforeChildren(N n4) {
|
||||
if (((Boolean) Function1.this.invoke(n4)).booleanValue()) {
|
||||
zArr[0] = true;
|
||||
}
|
||||
return !zArr[0];
|
||||
}
|
||||
|
||||
@Override // kotlin.reflect.jvm.internal.impl.utils.DFS.NodeHandler
|
||||
public Boolean result() {
|
||||
return Boolean.valueOf(zArr[0]);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public static <N, R> R dfs(Collection<N> collection, Neighbors<N> neighbors, NodeHandler<N, R> nodeHandler) {
|
||||
if (collection == null) {
|
||||
$$$reportNull$$$0(4);
|
||||
}
|
||||
if (neighbors == null) {
|
||||
$$$reportNull$$$0(5);
|
||||
}
|
||||
if (nodeHandler == null) {
|
||||
$$$reportNull$$$0(6);
|
||||
}
|
||||
return (R) dfs(collection, neighbors, new VisitedWithSet(), nodeHandler);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
package kotlin.reflect.jvm.internal.impl.utils;
|
||||
|
||||
import kotlin.jvm.internal.Intrinsics;
|
||||
import kotlin.reflect.jvm.internal.impl.metadata.deserialization.BinaryVersion;
|
||||
import kotlin.reflect.jvm.internal.impl.metadata.jvm.deserialization.JvmMetadataVersion;
|
||||
import kotlin.reflect.jvm.internal.impl.serialization.deserialization.DeserializationConfiguration;
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public final class DeserializationHelpersKt {
|
||||
public static final JvmMetadataVersion jvmMetadataVersionOrDefault(DeserializationConfiguration deserializationConfiguration) {
|
||||
Intrinsics.checkNotNullParameter(deserializationConfiguration, "<this>");
|
||||
BinaryVersion binaryVersion = deserializationConfiguration.getBinaryVersion();
|
||||
JvmMetadataVersion jvmMetadataVersion = binaryVersion instanceof JvmMetadataVersion ? (JvmMetadataVersion) binaryVersion : null;
|
||||
return jvmMetadataVersion == null ? JvmMetadataVersion.INSTANCE : jvmMetadataVersion;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
package kotlin.reflect.jvm.internal.impl.utils;
|
||||
|
||||
import kotlin.jvm.internal.Intrinsics;
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public final class ExceptionUtilsKt {
|
||||
public static final boolean isProcessCanceledException(Throwable th) {
|
||||
Intrinsics.checkNotNullParameter(th, "<this>");
|
||||
Class<?> cls = th.getClass();
|
||||
while (!Intrinsics.areEqual(cls.getCanonicalName(), "com.intellij.openapi.progress.ProcessCanceledException")) {
|
||||
cls = cls.getSuperclass();
|
||||
if (cls == null) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static final RuntimeException rethrow(Throwable e4) {
|
||||
Intrinsics.checkNotNullParameter(e4, "e");
|
||||
throw e4;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
package kotlin.reflect.jvm.internal.impl.utils;
|
||||
|
||||
import kotlin.Unit;
|
||||
import kotlin.jvm.functions.Function1;
|
||||
import kotlin.jvm.functions.Function2;
|
||||
import kotlin.jvm.functions.Function3;
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public final class FunctionsKt {
|
||||
private static final Function1<Object, Object> IDENTITY = new Function1<Object, Object>() { // from class: kotlin.reflect.jvm.internal.impl.utils.FunctionsKt$IDENTITY$1
|
||||
@Override // kotlin.jvm.functions.Function1
|
||||
public final Object invoke(Object obj) {
|
||||
return obj;
|
||||
}
|
||||
};
|
||||
private static final Function1<Object, Boolean> ALWAYS_TRUE = new Function1<Object, Boolean>() { // from class: kotlin.reflect.jvm.internal.impl.utils.FunctionsKt$ALWAYS_TRUE$1
|
||||
/* JADX WARN: Can't rename method to resolve collision */
|
||||
@Override // kotlin.jvm.functions.Function1
|
||||
public final Boolean invoke(Object obj) {
|
||||
return Boolean.TRUE;
|
||||
}
|
||||
};
|
||||
private static final Function1<Object, Object> ALWAYS_NULL = new Function1() { // from class: kotlin.reflect.jvm.internal.impl.utils.FunctionsKt$ALWAYS_NULL$1
|
||||
@Override // kotlin.jvm.functions.Function1
|
||||
public final Void invoke(Object obj) {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
private static final Function1<Object, Unit> DO_NOTHING = new Function1<Object, Unit>() { // from class: kotlin.reflect.jvm.internal.impl.utils.FunctionsKt$DO_NOTHING$1
|
||||
/* renamed from: invoke, reason: avoid collision after fix types in other method */
|
||||
public final void invoke2(Object obj) {
|
||||
}
|
||||
|
||||
@Override // kotlin.jvm.functions.Function1
|
||||
public /* bridge */ /* synthetic */ Unit invoke(Object obj) {
|
||||
invoke2(obj);
|
||||
return Unit.INSTANCE;
|
||||
}
|
||||
};
|
||||
private static final Function2<Object, Object, Unit> DO_NOTHING_2 = new Function2<Object, Object, Unit>() { // from class: kotlin.reflect.jvm.internal.impl.utils.FunctionsKt$DO_NOTHING_2$1
|
||||
/* renamed from: invoke, reason: avoid collision after fix types in other method */
|
||||
public final void invoke2(Object obj, Object obj2) {
|
||||
}
|
||||
|
||||
@Override // kotlin.jvm.functions.Function2
|
||||
public /* bridge */ /* synthetic */ Unit invoke(Object obj, Object obj2) {
|
||||
invoke2(obj, obj2);
|
||||
return Unit.INSTANCE;
|
||||
}
|
||||
};
|
||||
private static final Function3<Object, Object, Object, Unit> DO_NOTHING_3 = new Function3<Object, Object, Object, Unit>() { // from class: kotlin.reflect.jvm.internal.impl.utils.FunctionsKt$DO_NOTHING_3$1
|
||||
/* renamed from: invoke, reason: avoid collision after fix types in other method */
|
||||
public final void invoke2(Object obj, Object obj2, Object obj3) {
|
||||
}
|
||||
|
||||
@Override // kotlin.jvm.functions.Function3
|
||||
public /* bridge */ /* synthetic */ Unit invoke(Object obj, Object obj2, Object obj3) {
|
||||
invoke2(obj, obj2, obj3);
|
||||
return Unit.INSTANCE;
|
||||
}
|
||||
};
|
||||
|
||||
public static final <T> Function1<T, Boolean> alwaysTrue() {
|
||||
return (Function1<T, Boolean>) ALWAYS_TRUE;
|
||||
}
|
||||
|
||||
public static final Function3<Object, Object, Object, Unit> getDO_NOTHING_3() {
|
||||
return DO_NOTHING_3;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,338 @@
|
||||
package kotlin.reflect.jvm.internal.impl.utils;
|
||||
|
||||
import C.w;
|
||||
import java.lang.reflect.Array;
|
||||
import java.util.AbstractList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Comparator;
|
||||
import java.util.ConcurrentModificationException;
|
||||
import java.util.Iterator;
|
||||
import java.util.NoSuchElementException;
|
||||
import java.util.RandomAccess;
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public class SmartList<E> extends AbstractList<E> implements RandomAccess {
|
||||
private Object myElem;
|
||||
private int mySize;
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public static class EmptyIterator<T> implements Iterator<T> {
|
||||
private static final EmptyIterator INSTANCE = new EmptyIterator();
|
||||
|
||||
private EmptyIterator() {
|
||||
}
|
||||
|
||||
public static <T> EmptyIterator<T> getInstance() {
|
||||
return INSTANCE;
|
||||
}
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public boolean hasNext() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public T next() {
|
||||
throw new NoSuchElementException();
|
||||
}
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public void remove() {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
}
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public class SingletonIterator extends SingletonIteratorBase<E> {
|
||||
private final int myInitialModCount;
|
||||
|
||||
public SingletonIterator() {
|
||||
super();
|
||||
this.myInitialModCount = ((AbstractList) SmartList.this).modCount;
|
||||
}
|
||||
|
||||
@Override // kotlin.reflect.jvm.internal.impl.utils.SmartList.SingletonIteratorBase
|
||||
public void checkCoModification() {
|
||||
if (((AbstractList) SmartList.this).modCount == this.myInitialModCount) {
|
||||
return;
|
||||
}
|
||||
throw new ConcurrentModificationException("ModCount: " + ((AbstractList) SmartList.this).modCount + "; expected: " + this.myInitialModCount);
|
||||
}
|
||||
|
||||
@Override // kotlin.reflect.jvm.internal.impl.utils.SmartList.SingletonIteratorBase
|
||||
public E getElement() {
|
||||
return (E) SmartList.this.myElem;
|
||||
}
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public void remove() {
|
||||
checkCoModification();
|
||||
SmartList.this.clear();
|
||||
}
|
||||
}
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public static abstract class SingletonIteratorBase<T> implements Iterator<T> {
|
||||
private boolean myVisited;
|
||||
|
||||
private SingletonIteratorBase() {
|
||||
}
|
||||
|
||||
public abstract void checkCoModification();
|
||||
|
||||
public abstract T getElement();
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public final boolean hasNext() {
|
||||
return !this.myVisited;
|
||||
}
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public final T next() {
|
||||
if (this.myVisited) {
|
||||
throw new NoSuchElementException();
|
||||
}
|
||||
this.myVisited = true;
|
||||
checkCoModification();
|
||||
return getElement();
|
||||
}
|
||||
}
|
||||
|
||||
private static /* synthetic */ void $$$reportNull$$$0(int i) {
|
||||
String str = (i == 2 || i == 3 || i == 5 || i == 6 || i == 7) ? "@NotNull method %s.%s must not return null" : "Argument for @NotNull parameter '%s' of %s.%s must not be null";
|
||||
Object[] objArr = new Object[(i == 2 || i == 3 || i == 5 || i == 6 || i == 7) ? 2 : 3];
|
||||
switch (i) {
|
||||
case 2:
|
||||
case 3:
|
||||
case 5:
|
||||
case 6:
|
||||
case 7:
|
||||
objArr[0] = "kotlin/reflect/jvm/internal/impl/utils/SmartList";
|
||||
break;
|
||||
case 4:
|
||||
objArr[0] = "a";
|
||||
break;
|
||||
default:
|
||||
objArr[0] = "elements";
|
||||
break;
|
||||
}
|
||||
if (i == 2 || i == 3) {
|
||||
objArr[1] = "iterator";
|
||||
} else if (i == 5 || i == 6 || i == 7) {
|
||||
objArr[1] = "toArray";
|
||||
} else {
|
||||
objArr[1] = "kotlin/reflect/jvm/internal/impl/utils/SmartList";
|
||||
}
|
||||
switch (i) {
|
||||
case 2:
|
||||
case 3:
|
||||
case 5:
|
||||
case 6:
|
||||
case 7:
|
||||
break;
|
||||
case 4:
|
||||
objArr[2] = "toArray";
|
||||
break;
|
||||
default:
|
||||
objArr[2] = "<init>";
|
||||
break;
|
||||
}
|
||||
String format = String.format(str, objArr);
|
||||
if (i != 2 && i != 3 && i != 5 && i != 6 && i != 7) {
|
||||
throw new IllegalArgumentException(format);
|
||||
}
|
||||
throw new IllegalStateException(format);
|
||||
}
|
||||
|
||||
@Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
|
||||
public boolean add(E e4) {
|
||||
int i = this.mySize;
|
||||
if (i == 0) {
|
||||
this.myElem = e4;
|
||||
} else if (i == 1) {
|
||||
this.myElem = new Object[]{this.myElem, e4};
|
||||
} else {
|
||||
Object[] objArr = (Object[]) this.myElem;
|
||||
int length = objArr.length;
|
||||
if (i >= length) {
|
||||
int i4 = ((length * 3) / 2) + 1;
|
||||
int i5 = i + 1;
|
||||
if (i4 < i5) {
|
||||
i4 = i5;
|
||||
}
|
||||
Object[] objArr2 = new Object[i4];
|
||||
this.myElem = objArr2;
|
||||
System.arraycopy(objArr, 0, objArr2, 0, length);
|
||||
objArr = objArr2;
|
||||
}
|
||||
objArr[this.mySize] = e4;
|
||||
}
|
||||
this.mySize++;
|
||||
((AbstractList) this).modCount++;
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
|
||||
public void clear() {
|
||||
this.myElem = null;
|
||||
this.mySize = 0;
|
||||
((AbstractList) this).modCount++;
|
||||
}
|
||||
|
||||
@Override // java.util.AbstractList, java.util.List
|
||||
public E get(int i) {
|
||||
int i4;
|
||||
if (i >= 0 && i < (i4 = this.mySize)) {
|
||||
return i4 == 1 ? (E) this.myElem : (E) ((Object[]) this.myElem)[i];
|
||||
}
|
||||
StringBuilder t2 = w.t(i, "Index: ", ", Size: ");
|
||||
t2.append(this.mySize);
|
||||
throw new IndexOutOfBoundsException(t2.toString());
|
||||
}
|
||||
|
||||
@Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.List
|
||||
public Iterator<E> iterator() {
|
||||
int i = this.mySize;
|
||||
if (i == 0) {
|
||||
EmptyIterator emptyIterator = EmptyIterator.getInstance();
|
||||
if (emptyIterator == null) {
|
||||
$$$reportNull$$$0(2);
|
||||
}
|
||||
return emptyIterator;
|
||||
}
|
||||
if (i == 1) {
|
||||
return new SingletonIterator();
|
||||
}
|
||||
Iterator<E> it = super.iterator();
|
||||
if (it == null) {
|
||||
$$$reportNull$$$0(3);
|
||||
}
|
||||
return it;
|
||||
}
|
||||
|
||||
@Override // java.util.AbstractList, java.util.List
|
||||
public E remove(int i) {
|
||||
int i4;
|
||||
E e4;
|
||||
if (i < 0 || i >= (i4 = this.mySize)) {
|
||||
StringBuilder t2 = w.t(i, "Index: ", ", Size: ");
|
||||
t2.append(this.mySize);
|
||||
throw new IndexOutOfBoundsException(t2.toString());
|
||||
}
|
||||
if (i4 == 1) {
|
||||
e4 = (E) this.myElem;
|
||||
this.myElem = null;
|
||||
} else {
|
||||
Object[] objArr = (Object[]) this.myElem;
|
||||
Object obj = objArr[i];
|
||||
if (i4 == 2) {
|
||||
this.myElem = objArr[1 - i];
|
||||
} else {
|
||||
int i5 = (i4 - i) - 1;
|
||||
if (i5 > 0) {
|
||||
System.arraycopy(objArr, i + 1, objArr, i, i5);
|
||||
}
|
||||
objArr[this.mySize - 1] = null;
|
||||
}
|
||||
e4 = (E) obj;
|
||||
}
|
||||
this.mySize--;
|
||||
((AbstractList) this).modCount++;
|
||||
return e4;
|
||||
}
|
||||
|
||||
@Override // java.util.AbstractList, java.util.List
|
||||
public E set(int i, E e4) {
|
||||
int i4;
|
||||
if (i < 0 || i >= (i4 = this.mySize)) {
|
||||
StringBuilder t2 = w.t(i, "Index: ", ", Size: ");
|
||||
t2.append(this.mySize);
|
||||
throw new IndexOutOfBoundsException(t2.toString());
|
||||
}
|
||||
if (i4 == 1) {
|
||||
E e5 = (E) this.myElem;
|
||||
this.myElem = e4;
|
||||
return e5;
|
||||
}
|
||||
Object[] objArr = (Object[]) this.myElem;
|
||||
E e6 = (E) objArr[i];
|
||||
objArr[i] = e4;
|
||||
return e6;
|
||||
}
|
||||
|
||||
@Override // java.util.AbstractCollection, java.util.Collection, java.util.List
|
||||
public int size() {
|
||||
return this.mySize;
|
||||
}
|
||||
|
||||
@Override // java.util.List
|
||||
public void sort(Comparator<? super E> comparator) {
|
||||
int i = this.mySize;
|
||||
if (i >= 2) {
|
||||
Arrays.sort((Object[]) this.myElem, 0, i, comparator);
|
||||
}
|
||||
}
|
||||
|
||||
/* JADX WARN: Multi-variable type inference failed */
|
||||
@Override // java.util.AbstractCollection, java.util.Collection, java.util.List
|
||||
public <T> T[] toArray(T[] tArr) {
|
||||
if (tArr == 0) {
|
||||
$$$reportNull$$$0(4);
|
||||
}
|
||||
int length = tArr.length;
|
||||
int i = this.mySize;
|
||||
if (i == 1) {
|
||||
if (length == 0) {
|
||||
T[] tArr2 = (T[]) ((Object[]) Array.newInstance(tArr.getClass().getComponentType(), 1));
|
||||
tArr2[0] = this.myElem;
|
||||
return tArr2;
|
||||
}
|
||||
tArr[0] = this.myElem;
|
||||
} else {
|
||||
if (length < i) {
|
||||
T[] tArr3 = (T[]) Arrays.copyOf((Object[]) this.myElem, i, tArr.getClass());
|
||||
if (tArr3 == null) {
|
||||
$$$reportNull$$$0(6);
|
||||
}
|
||||
return tArr3;
|
||||
}
|
||||
if (i != 0) {
|
||||
System.arraycopy(this.myElem, 0, tArr, 0, i);
|
||||
}
|
||||
}
|
||||
int i4 = this.mySize;
|
||||
if (length > i4) {
|
||||
tArr[i4] = 0;
|
||||
}
|
||||
return tArr;
|
||||
}
|
||||
|
||||
@Override // java.util.AbstractList, java.util.List
|
||||
public void add(int i, E e4) {
|
||||
int i4;
|
||||
if (i >= 0 && i <= (i4 = this.mySize)) {
|
||||
if (i4 == 0) {
|
||||
this.myElem = e4;
|
||||
} else if (i4 == 1 && i == 0) {
|
||||
this.myElem = new Object[]{e4, this.myElem};
|
||||
} else {
|
||||
Object[] objArr = new Object[i4 + 1];
|
||||
if (i4 == 1) {
|
||||
objArr[0] = this.myElem;
|
||||
} else {
|
||||
Object[] objArr2 = (Object[]) this.myElem;
|
||||
System.arraycopy(objArr2, 0, objArr, 0, i);
|
||||
System.arraycopy(objArr2, i, objArr, i + 1, this.mySize - i);
|
||||
}
|
||||
objArr[i] = e4;
|
||||
this.myElem = objArr;
|
||||
}
|
||||
this.mySize++;
|
||||
((AbstractList) this).modCount++;
|
||||
return;
|
||||
}
|
||||
StringBuilder t2 = w.t(i, "Index: ", ", Size: ");
|
||||
t2.append(this.mySize);
|
||||
throw new IndexOutOfBoundsException(t2.toString());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,212 @@
|
||||
package kotlin.reflect.jvm.internal.impl.utils;
|
||||
|
||||
import java.util.AbstractSet;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.Iterator;
|
||||
import java.util.NoSuchElementException;
|
||||
import java.util.Set;
|
||||
import kotlin.collections.ArraysKt;
|
||||
import kotlin.collections.SetsKt;
|
||||
import kotlin.jvm.JvmStatic;
|
||||
import kotlin.jvm.internal.ArrayIteratorKt;
|
||||
import kotlin.jvm.internal.DefaultConstructorMarker;
|
||||
import kotlin.jvm.internal.Intrinsics;
|
||||
import kotlin.jvm.internal.SourceDebugExtension;
|
||||
import kotlin.jvm.internal.TypeIntrinsics;
|
||||
import kotlin.jvm.internal.markers.KMutableIterator;
|
||||
|
||||
@SourceDebugExtension({"SMAP\nSmartSet.kt\nKotlin\n*S Kotlin\n*F\n+ 1 SmartSet.kt\norg/jetbrains/kotlin/utils/SmartSet\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,110:1\n1#2:111\n*E\n"})
|
||||
/* loaded from: classes3.dex */
|
||||
public final class SmartSet<T> extends AbstractSet<T> {
|
||||
public static final Companion Companion = new Companion(null);
|
||||
private Object data;
|
||||
private int size;
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public static final class ArrayIterator<T> implements Iterator<T>, KMutableIterator {
|
||||
private final Iterator<T> arrayIterator;
|
||||
|
||||
public ArrayIterator(T[] array) {
|
||||
Intrinsics.checkNotNullParameter(array, "array");
|
||||
this.arrayIterator = ArrayIteratorKt.iterator(array);
|
||||
}
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public boolean hasNext() {
|
||||
return this.arrayIterator.hasNext();
|
||||
}
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public T next() {
|
||||
return this.arrayIterator.next();
|
||||
}
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public Void remove() {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
}
|
||||
|
||||
@SourceDebugExtension({"SMAP\nSmartSet.kt\nKotlin\n*S Kotlin\n*F\n+ 1 SmartSet.kt\norg/jetbrains/kotlin/utils/SmartSet$Companion\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,110:1\n1#2:111\n*E\n"})
|
||||
/* loaded from: classes3.dex */
|
||||
public static final class Companion {
|
||||
public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
|
||||
this();
|
||||
}
|
||||
|
||||
@JvmStatic
|
||||
public final <T> SmartSet<T> create() {
|
||||
return new SmartSet<>(null);
|
||||
}
|
||||
|
||||
private Companion() {
|
||||
}
|
||||
|
||||
@JvmStatic
|
||||
public final <T> SmartSet<T> create(Collection<? extends T> set) {
|
||||
Intrinsics.checkNotNullParameter(set, "set");
|
||||
SmartSet<T> smartSet = new SmartSet<>(null);
|
||||
smartSet.addAll(set);
|
||||
return smartSet;
|
||||
}
|
||||
}
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public static final class SingletonIterator<T> implements Iterator<T>, KMutableIterator {
|
||||
private final T element;
|
||||
private boolean hasNext = true;
|
||||
|
||||
public SingletonIterator(T t2) {
|
||||
this.element = t2;
|
||||
}
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public boolean hasNext() {
|
||||
return this.hasNext;
|
||||
}
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public T next() {
|
||||
if (!this.hasNext) {
|
||||
throw new NoSuchElementException();
|
||||
}
|
||||
this.hasNext = false;
|
||||
return this.element;
|
||||
}
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public Void remove() {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
}
|
||||
|
||||
public /* synthetic */ SmartSet(DefaultConstructorMarker defaultConstructorMarker) {
|
||||
this();
|
||||
}
|
||||
|
||||
@JvmStatic
|
||||
public static final <T> SmartSet<T> create() {
|
||||
return Companion.create();
|
||||
}
|
||||
|
||||
/* JADX WARN: Multi-variable type inference failed */
|
||||
/* JADX WARN: Type inference failed for: r0v10, types: [java.util.AbstractCollection, java.util.LinkedHashSet] */
|
||||
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
||||
public boolean add(T t2) {
|
||||
Object[] objArr;
|
||||
if (size() == 0) {
|
||||
this.data = t2;
|
||||
} else if (size() == 1) {
|
||||
if (Intrinsics.areEqual(this.data, t2)) {
|
||||
return false;
|
||||
}
|
||||
this.data = new Object[]{this.data, t2};
|
||||
} else if (size() < 5) {
|
||||
Object obj = this.data;
|
||||
Intrinsics.checkNotNull(obj, "null cannot be cast to non-null type kotlin.Array<T of org.jetbrains.kotlin.utils.SmartSet>");
|
||||
Object[] objArr2 = (Object[]) obj;
|
||||
if (ArraysKt.contains(objArr2, t2)) {
|
||||
return false;
|
||||
}
|
||||
if (size() == 4) {
|
||||
?? linkedSetOf = SetsKt.linkedSetOf(Arrays.copyOf(objArr2, objArr2.length));
|
||||
linkedSetOf.add(t2);
|
||||
objArr = linkedSetOf;
|
||||
} else {
|
||||
Object[] copyOf = Arrays.copyOf(objArr2, size() + 1);
|
||||
Intrinsics.checkNotNullExpressionValue(copyOf, "copyOf(...)");
|
||||
copyOf[copyOf.length - 1] = t2;
|
||||
objArr = copyOf;
|
||||
}
|
||||
this.data = objArr;
|
||||
} else {
|
||||
Object obj2 = this.data;
|
||||
Intrinsics.checkNotNull(obj2, "null cannot be cast to non-null type kotlin.collections.MutableSet<T of org.jetbrains.kotlin.utils.SmartSet>");
|
||||
if (!TypeIntrinsics.asMutableSet(obj2).add(t2)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
setSize(size() + 1);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
||||
public void clear() {
|
||||
this.data = null;
|
||||
setSize(0);
|
||||
}
|
||||
|
||||
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
||||
public boolean contains(Object obj) {
|
||||
if (size() == 0) {
|
||||
return false;
|
||||
}
|
||||
if (size() == 1) {
|
||||
return Intrinsics.areEqual(this.data, obj);
|
||||
}
|
||||
if (size() < 5) {
|
||||
Object obj2 = this.data;
|
||||
Intrinsics.checkNotNull(obj2, "null cannot be cast to non-null type kotlin.Array<T of org.jetbrains.kotlin.utils.SmartSet>");
|
||||
return ArraysKt.contains((Object[]) obj2, obj);
|
||||
}
|
||||
Object obj3 = this.data;
|
||||
Intrinsics.checkNotNull(obj3, "null cannot be cast to non-null type kotlin.collections.Set<T of org.jetbrains.kotlin.utils.SmartSet>");
|
||||
return ((Set) obj3).contains(obj);
|
||||
}
|
||||
|
||||
public int getSize() {
|
||||
return this.size;
|
||||
}
|
||||
|
||||
@Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.Set
|
||||
public Iterator<T> iterator() {
|
||||
if (size() == 0) {
|
||||
return Collections.EMPTY_SET.iterator();
|
||||
}
|
||||
if (size() == 1) {
|
||||
return new SingletonIterator(this.data);
|
||||
}
|
||||
if (size() < 5) {
|
||||
Object obj = this.data;
|
||||
Intrinsics.checkNotNull(obj, "null cannot be cast to non-null type kotlin.Array<T of org.jetbrains.kotlin.utils.SmartSet>");
|
||||
return new ArrayIterator((Object[]) obj);
|
||||
}
|
||||
Object obj2 = this.data;
|
||||
Intrinsics.checkNotNull(obj2, "null cannot be cast to non-null type kotlin.collections.MutableSet<T of org.jetbrains.kotlin.utils.SmartSet>");
|
||||
return TypeIntrinsics.asMutableSet(obj2).iterator();
|
||||
}
|
||||
|
||||
public void setSize(int i) {
|
||||
this.size = i;
|
||||
}
|
||||
|
||||
@Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
|
||||
public final /* bridge */ int size() {
|
||||
return getSize();
|
||||
}
|
||||
|
||||
private SmartSet() {
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,139 @@
|
||||
package kotlin.reflect.jvm.internal.impl.utils;
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public class WrappedValues {
|
||||
private static final Object NULL_VALUE = new Object() { // from class: kotlin.reflect.jvm.internal.impl.utils.WrappedValues.1
|
||||
public String toString() {
|
||||
return "NULL_VALUE";
|
||||
}
|
||||
};
|
||||
public static volatile boolean throwWrappedProcessCanceledException = false;
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public static final class ThrowableWrapper {
|
||||
private final Throwable throwable;
|
||||
|
||||
private static /* synthetic */ void $$$reportNull$$$0(int i) {
|
||||
String str = i != 1 ? "Argument for @NotNull parameter '%s' of %s.%s must not be null" : "@NotNull method %s.%s must not return null";
|
||||
Object[] objArr = new Object[i != 1 ? 3 : 2];
|
||||
if (i != 1) {
|
||||
objArr[0] = "throwable";
|
||||
} else {
|
||||
objArr[0] = "kotlin/reflect/jvm/internal/impl/utils/WrappedValues$ThrowableWrapper";
|
||||
}
|
||||
if (i != 1) {
|
||||
objArr[1] = "kotlin/reflect/jvm/internal/impl/utils/WrappedValues$ThrowableWrapper";
|
||||
} else {
|
||||
objArr[1] = "getThrowable";
|
||||
}
|
||||
if (i != 1) {
|
||||
objArr[2] = "<init>";
|
||||
}
|
||||
String format = String.format(str, objArr);
|
||||
if (i == 1) {
|
||||
throw new IllegalStateException(format);
|
||||
}
|
||||
}
|
||||
|
||||
public Throwable getThrowable() {
|
||||
Throwable th = this.throwable;
|
||||
if (th == null) {
|
||||
$$$reportNull$$$0(1);
|
||||
}
|
||||
return th;
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return this.throwable.toString();
|
||||
}
|
||||
|
||||
private ThrowableWrapper(Throwable th) {
|
||||
if (th == null) {
|
||||
$$$reportNull$$$0(0);
|
||||
}
|
||||
this.throwable = th;
|
||||
}
|
||||
}
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public static class WrappedProcessCanceledException extends RuntimeException {
|
||||
public WrappedProcessCanceledException(Throwable th) {
|
||||
super("Rethrow stored exception", th);
|
||||
}
|
||||
}
|
||||
|
||||
private static /* synthetic */ void $$$reportNull$$$0(int i) {
|
||||
String str = (i == 1 || i == 2) ? "@NotNull method %s.%s must not return null" : "Argument for @NotNull parameter '%s' of %s.%s must not be null";
|
||||
Object[] objArr = new Object[(i == 1 || i == 2) ? 2 : 3];
|
||||
if (i == 1 || i == 2) {
|
||||
objArr[0] = "kotlin/reflect/jvm/internal/impl/utils/WrappedValues";
|
||||
} else if (i != 3) {
|
||||
objArr[0] = "value";
|
||||
} else {
|
||||
objArr[0] = "throwable";
|
||||
}
|
||||
if (i == 1 || i == 2) {
|
||||
objArr[1] = "escapeNull";
|
||||
} else {
|
||||
objArr[1] = "kotlin/reflect/jvm/internal/impl/utils/WrappedValues";
|
||||
}
|
||||
if (i != 1 && i != 2) {
|
||||
if (i == 3) {
|
||||
objArr[2] = "escapeThrowable";
|
||||
} else if (i != 4) {
|
||||
objArr[2] = "unescapeNull";
|
||||
} else {
|
||||
objArr[2] = "unescapeExceptionOrNull";
|
||||
}
|
||||
}
|
||||
String format = String.format(str, objArr);
|
||||
if (i != 1 && i != 2) {
|
||||
throw new IllegalArgumentException(format);
|
||||
}
|
||||
throw new IllegalStateException(format);
|
||||
}
|
||||
|
||||
public static <V> Object escapeNull(V v3) {
|
||||
if (v3 == null && (v3 = (V) NULL_VALUE) == null) {
|
||||
$$$reportNull$$$0(1);
|
||||
}
|
||||
return v3;
|
||||
}
|
||||
|
||||
public static Object escapeThrowable(Throwable th) {
|
||||
if (th == null) {
|
||||
$$$reportNull$$$0(3);
|
||||
}
|
||||
return new ThrowableWrapper(th);
|
||||
}
|
||||
|
||||
public static <V> V unescapeExceptionOrNull(Object obj) {
|
||||
if (obj == null) {
|
||||
$$$reportNull$$$0(4);
|
||||
}
|
||||
return (V) unescapeNull(unescapeThrowable(obj));
|
||||
}
|
||||
|
||||
/* JADX WARN: Multi-variable type inference failed */
|
||||
public static <V> V unescapeNull(Object obj) {
|
||||
if (obj == 0) {
|
||||
$$$reportNull$$$0(0);
|
||||
}
|
||||
if (obj == NULL_VALUE) {
|
||||
return null;
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
/* JADX WARN: Multi-variable type inference failed */
|
||||
public static <V> V unescapeThrowable(Object obj) {
|
||||
if (!(obj instanceof ThrowableWrapper)) {
|
||||
return obj;
|
||||
}
|
||||
Throwable throwable = ((ThrowableWrapper) obj).getThrowable();
|
||||
if (throwWrappedProcessCanceledException && ExceptionUtilsKt.isProcessCanceledException(throwable)) {
|
||||
throw new WrappedProcessCanceledException(throwable);
|
||||
}
|
||||
throw ExceptionUtilsKt.rethrow(throwable);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
package kotlin.reflect.jvm.internal.impl.utils.addToStdlib;
|
||||
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import kotlin.jvm.functions.Function0;
|
||||
import kotlin.jvm.internal.Intrinsics;
|
||||
import kotlin.jvm.internal.SourceDebugExtension;
|
||||
|
||||
@SourceDebugExtension({"SMAP\naddToStdlib.kt\nKotlin\n*S Kotlin\n*F\n+ 1 addToStdlib.kt\norg/jetbrains/kotlin/utils/addToStdlib/AddToStdlibKt\n+ 2 _Arrays.kt\nkotlin/collections/ArraysKt___ArraysKt\n+ 3 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,352:1\n20#1,2:353\n289#1,16:359\n327#1,13:375\n3792#2:355\n4307#2,2:356\n1#3:358\n*S KotlinDebug\n*F\n+ 1 addToStdlib.kt\norg/jetbrains/kotlin/utils/addToStdlib/AddToStdlibKt\n*L\n66#1:353,2\n281#1:359,16\n343#1:375,13\n132#1:355\n132#1:356,2\n*E\n"})
|
||||
/* loaded from: classes3.dex */
|
||||
public final class AddToStdlibKt {
|
||||
private static final ConcurrentHashMap<Function0<?>, Object> constantMap = new ConcurrentHashMap<>();
|
||||
|
||||
public static final Void shouldNotBeCalled(String message) {
|
||||
Intrinsics.checkNotNullParameter(message, "message");
|
||||
throw new IllegalStateException(message.toString());
|
||||
}
|
||||
|
||||
public static /* synthetic */ Void shouldNotBeCalled$default(String str, int i, Object obj) {
|
||||
if ((i & 1) != 0) {
|
||||
str = "should not be called";
|
||||
}
|
||||
return shouldNotBeCalled(str);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user