3222 lines
116 KiB
Java
3222 lines
116 KiB
Java
package b.i.a.f.e.o;
|
|
|
|
import android.annotation.TargetApi;
|
|
import android.app.AppOpsManager;
|
|
import android.content.Context;
|
|
import android.content.pm.PackageInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.res.Resources;
|
|
import android.database.Cursor;
|
|
import android.database.sqlite.SQLiteDatabase;
|
|
import android.database.sqlite.SQLiteException;
|
|
import android.graphics.Rect;
|
|
import android.graphics.RectF;
|
|
import android.hardware.Camera;
|
|
import android.opengl.EGL14;
|
|
import android.opengl.EGLConfig;
|
|
import android.opengl.EGLContext;
|
|
import android.opengl.EGLDisplay;
|
|
import android.opengl.EGLSurface;
|
|
import android.opengl.GLES20;
|
|
import android.os.Binder;
|
|
import android.os.Build;
|
|
import android.os.Bundle;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
import android.util.TypedValue;
|
|
import android.view.Display;
|
|
import android.view.WindowManager;
|
|
import androidx.annotation.DimenRes;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.annotation.RecentlyNonNull;
|
|
import androidx.annotation.WorkerThread;
|
|
import androidx.media.AudioAttributesCompat;
|
|
import androidx.recyclerview.widget.RecyclerView;
|
|
import b.i.a.f.h.l.a3;
|
|
import b.i.a.f.h.l.b5;
|
|
import b.i.a.f.h.l.b7;
|
|
import b.i.a.f.h.l.c3;
|
|
import b.i.a.f.h.l.c6;
|
|
import b.i.a.f.h.l.c7;
|
|
import b.i.a.f.h.l.d2;
|
|
import b.i.a.f.h.l.e6;
|
|
import b.i.a.f.h.l.k7;
|
|
import b.i.a.f.h.l.q6;
|
|
import b.i.a.f.h.l.s3;
|
|
import b.i.a.f.h.l.t3;
|
|
import b.i.a.f.h.l.u4;
|
|
import b.i.a.f.h.l.w4;
|
|
import b.i.a.f.h.l.x4;
|
|
import b.i.a.f.h.l.z2;
|
|
import b.i.a.f.h.l.z3;
|
|
import b.i.a.f.i.b.ga;
|
|
import b.i.a.f.i.b.q3;
|
|
import b.i.a.f.n.b0;
|
|
import b.i.a.f.n.d0;
|
|
import b.i.a.f.n.h;
|
|
import b.i.b.b.h;
|
|
import b.i.b.b.n0;
|
|
import b.i.c.l.d;
|
|
import b.i.c.m.d.k.s0;
|
|
import b.i.c.m.d.k.t0;
|
|
import b.o.a.x.i;
|
|
import b.o.a.x.j;
|
|
import com.discord.models.domain.ModelAuditLogEntry;
|
|
import com.discord.widgets.chat.input.MentionUtilsKt;
|
|
import com.google.android.gms.common.R;
|
|
import com.google.android.gms.common.api.Status;
|
|
import com.google.android.gms.internal.measurement.zzij;
|
|
import com.google.android.gms.tasks.Task;
|
|
import com.google.errorprone.annotations.CanIgnoreReturnValue;
|
|
import com.google.firebase.appindexing.FirebaseAppIndexingException;
|
|
import com.google.firebase.appindexing.FirebaseAppIndexingInvalidArgumentException;
|
|
import com.google.firebase.appindexing.FirebaseAppIndexingTooManyArgumentsException;
|
|
import com.google.firebase.appindexing.zza;
|
|
import com.google.firebase.appindexing.zzb;
|
|
import com.google.firebase.appindexing.zzc;
|
|
import com.google.firebase.appindexing.zzd;
|
|
import com.google.firebase.appindexing.zze;
|
|
import com.google.firebase.appindexing.zzf;
|
|
import com.google.firebase.appindexing.zzg;
|
|
import com.google.firebase.appindexing.zzh;
|
|
import com.google.gson.JsonElement;
|
|
import com.google.gson.JsonParseException;
|
|
import com.google.gson.internal.bind.TypeAdapters;
|
|
import com.google.gson.stream.JsonReader;
|
|
import com.google.gson.stream.MalformedJsonException;
|
|
import com.lytefast.flexinput.viewmodel.FlexInputViewModel;
|
|
import d0.g0.t;
|
|
import d0.k;
|
|
import d0.w.d;
|
|
import d0.w.i.a.g;
|
|
import d0.z.d.e0;
|
|
import d0.z.d.m;
|
|
import f0.e0.f.d;
|
|
import g0.n;
|
|
import g0.p;
|
|
import g0.u;
|
|
import g0.x;
|
|
import java.io.EOFException;
|
|
import java.io.File;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.io.Serializable;
|
|
import java.lang.reflect.Method;
|
|
import java.lang.reflect.Modifier;
|
|
import java.net.IDN;
|
|
import java.net.InetAddress;
|
|
import java.net.Socket;
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.ByteOrder;
|
|
import java.nio.FloatBuffer;
|
|
import java.text.DateFormat;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Calendar;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
import java.util.Set;
|
|
import java.util.TreeSet;
|
|
import java.util.concurrent.Callable;
|
|
import java.util.concurrent.CancellationException;
|
|
import java.util.concurrent.ExecutionException;
|
|
import java.util.concurrent.Executor;
|
|
import java.util.concurrent.ExecutorService;
|
|
import java.util.concurrent.Executors;
|
|
import java.util.concurrent.LinkedBlockingQueue;
|
|
import java.util.concurrent.ThreadPoolExecutor;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.concurrent.TimeoutException;
|
|
import java.util.concurrent.atomic.AtomicLong;
|
|
import java.util.concurrent.atomic.AtomicReference;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
import java.util.zip.GZIPOutputStream;
|
|
import kotlin.TypeCastException;
|
|
import kotlin.Unit;
|
|
import kotlin.coroutines.Continuation;
|
|
import kotlin.coroutines.CoroutineContext;
|
|
import kotlin.jvm.functions.Function1;
|
|
import kotlin.jvm.functions.Function2;
|
|
import kotlinx.coroutines.CoroutineExceptionHandler;
|
|
import kotlinx.coroutines.CoroutineScope;
|
|
import kotlinx.coroutines.CoroutineStart;
|
|
import kotlinx.coroutines.Job;
|
|
import kotlinx.coroutines.internal.UndeliveredElementException;
|
|
import org.checkerframework.checker.nullness.compatqual.NullableDecl;
|
|
import s.a.a.r;
|
|
import s.a.b2.f;
|
|
import s.a.b2.o;
|
|
import s.a.b2.q;
|
|
import s.a.b2.s;
|
|
import s.a.b2.v;
|
|
import s.a.d;
|
|
import s.a.f0;
|
|
import s.a.f1;
|
|
import s.a.g0;
|
|
import s.a.h0;
|
|
import s.a.i0;
|
|
import s.a.i1;
|
|
import s.a.j0;
|
|
import s.a.j1;
|
|
import s.a.k1;
|
|
import s.a.l;
|
|
import s.a.m0;
|
|
import s.a.s1;
|
|
import s.a.t1;
|
|
import s.a.w;
|
|
import s.a.y1;
|
|
import s.a.z;
|
|
/* compiled from: com.google.android.gms:play-services-basement@@17.4.0 */
|
|
public final class f {
|
|
public static Boolean a;
|
|
|
|
/* renamed from: b reason: collision with root package name */
|
|
public static Context f1382b;
|
|
@Nullable
|
|
public static Boolean c;
|
|
public static ga d;
|
|
|
|
/* compiled from: SizeSelectors */
|
|
public static class a implements j {
|
|
public final /* synthetic */ int a;
|
|
|
|
public a(int i) {
|
|
this.a = i;
|
|
}
|
|
|
|
@Override // b.o.a.x.j
|
|
public boolean a(@NonNull b.o.a.x.b bVar) {
|
|
return bVar.j <= this.a;
|
|
}
|
|
}
|
|
|
|
/* compiled from: SizeSelectors */
|
|
public static class b implements j {
|
|
public final /* synthetic */ int a;
|
|
|
|
public b(int i) {
|
|
this.a = i;
|
|
}
|
|
|
|
@Override // b.o.a.x.j
|
|
public boolean a(@NonNull b.o.a.x.b bVar) {
|
|
return bVar.j >= this.a;
|
|
}
|
|
}
|
|
|
|
/* compiled from: SizeSelectors */
|
|
public static class c implements j {
|
|
public final /* synthetic */ int a;
|
|
|
|
public c(int i) {
|
|
this.a = i;
|
|
}
|
|
|
|
@Override // b.o.a.x.j
|
|
public boolean a(@NonNull b.o.a.x.b bVar) {
|
|
return bVar.k <= this.a;
|
|
}
|
|
}
|
|
|
|
/* compiled from: SizeSelectors */
|
|
public static class d implements j {
|
|
public final /* synthetic */ int a;
|
|
|
|
public d(int i) {
|
|
this.a = i;
|
|
}
|
|
|
|
@Override // b.o.a.x.j
|
|
public boolean a(@NonNull b.o.a.x.b bVar) {
|
|
return bVar.k >= this.a;
|
|
}
|
|
}
|
|
|
|
/* compiled from: Await.kt */
|
|
@d0.w.i.a.e(c = "kotlinx.coroutines.AwaitKt", f = "Await.kt", l = {26}, m = "awaitAll")
|
|
public static final class e extends d0.w.i.a.d {
|
|
public Object L$0;
|
|
public int label;
|
|
public /* synthetic */ Object result;
|
|
|
|
public e(Continuation continuation) {
|
|
super(continuation);
|
|
}
|
|
|
|
@Override // d0.w.i.a.a
|
|
public final Object invokeSuspend(Object obj) {
|
|
this.result = obj;
|
|
this.label |= Integer.MIN_VALUE;
|
|
return f.k(null, this);
|
|
}
|
|
}
|
|
|
|
/* compiled from: Channels.kt */
|
|
@d0.w.i.a.e(c = "kotlinx.coroutines.flow.FlowKt__ChannelsKt", f = "Channels.kt", l = {50, 61}, m = "emitAllImpl$FlowKt__ChannelsKt")
|
|
/* renamed from: b.i.a.f.e.o.f$f reason: collision with other inner class name */
|
|
public static final class C0108f extends d0.w.i.a.d {
|
|
public Object L$0;
|
|
public Object L$1;
|
|
public Object L$2;
|
|
public Object L$3;
|
|
public boolean Z$0;
|
|
public int label;
|
|
public /* synthetic */ Object result;
|
|
|
|
public C0108f(Continuation continuation) {
|
|
super(continuation);
|
|
}
|
|
|
|
@Override // d0.w.i.a.a
|
|
public final Object invokeSuspend(Object obj) {
|
|
this.result = obj;
|
|
this.label |= Integer.MIN_VALUE;
|
|
return f.T(null, null, false, this);
|
|
}
|
|
}
|
|
|
|
public static final void A(long j, long j2, long j3) {
|
|
if ((j2 | j3) < 0 || j2 > j || j - j2 < j3) {
|
|
throw new ArrayIndexOutOfBoundsException("size=" + j + " offset=" + j2 + " byteCount=" + j3);
|
|
}
|
|
}
|
|
|
|
public static boolean A0(Camera camera) {
|
|
List<String> supportedFlashModes;
|
|
if (camera != null) {
|
|
Camera.Parameters parameters = camera.getParameters();
|
|
if (parameters.getFlashMode() != null && (supportedFlashModes = parameters.getSupportedFlashModes()) != null && !supportedFlashModes.isEmpty() && (supportedFlashModes.size() != 1 || !supportedFlashModes.get(0).equals("off"))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static int A1(int i, byte[] bArr, int i2, s3 s3Var) {
|
|
int i3 = i & 127;
|
|
int i4 = i2 + 1;
|
|
byte b2 = bArr[i2];
|
|
if (b2 >= 0) {
|
|
s3Var.a = i3 | (b2 << 7);
|
|
return i4;
|
|
}
|
|
int i5 = i3 | ((b2 & Byte.MAX_VALUE) << 7);
|
|
int i6 = i4 + 1;
|
|
byte b3 = bArr[i4];
|
|
if (b3 >= 0) {
|
|
s3Var.a = i5 | (b3 << 14);
|
|
return i6;
|
|
}
|
|
int i7 = i5 | ((b3 & Byte.MAX_VALUE) << 14);
|
|
int i8 = i6 + 1;
|
|
byte b4 = bArr[i6];
|
|
if (b4 >= 0) {
|
|
s3Var.a = i7 | (b4 << 21);
|
|
return i8;
|
|
}
|
|
int i9 = i7 | ((b4 & Byte.MAX_VALUE) << 21);
|
|
int i10 = i8 + 1;
|
|
byte b5 = bArr[i8];
|
|
if (b5 >= 0) {
|
|
s3Var.a = i9 | (b5 << 28);
|
|
return i10;
|
|
}
|
|
int i11 = i9 | ((b5 & Byte.MAX_VALUE) << 28);
|
|
while (true) {
|
|
int i12 = i10 + 1;
|
|
if (bArr[i10] >= 0) {
|
|
s3Var.a = i11;
|
|
return i12;
|
|
}
|
|
i10 = i12;
|
|
}
|
|
}
|
|
|
|
@CanIgnoreReturnValue
|
|
public static int B(int i, int i2) {
|
|
if (i >= 0 && i <= i2) {
|
|
return i;
|
|
}
|
|
throw new IndexOutOfBoundsException(l(i, i2, "index"));
|
|
}
|
|
|
|
@RecentlyNonNull
|
|
public static boolean B0(@RecentlyNonNull Context context, @RecentlyNonNull int i) {
|
|
if (!r1(context, i, "com.google.android.gms")) {
|
|
return false;
|
|
}
|
|
try {
|
|
PackageInfo packageInfo = context.getPackageManager().getPackageInfo("com.google.android.gms", 64);
|
|
b.i.a.f.e.f a2 = b.i.a.f.e.f.a(context);
|
|
Objects.requireNonNull(a2);
|
|
if (packageInfo == null) {
|
|
return false;
|
|
}
|
|
if (!b.i.a.f.e.f.d(packageInfo, false)) {
|
|
if (!b.i.a.f.e.f.d(packageInfo, true)) {
|
|
return false;
|
|
}
|
|
if (!b.i.a.f.e.e.a(a2.f1334b)) {
|
|
Log.w("GoogleSignatureVerifier", "Test-keys aren't accepted on this build.");
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
} catch (PackageManager.NameNotFoundException unused) {
|
|
if (Log.isLoggable("UidVerifier", 3)) {
|
|
Log.d("UidVerifier", "Package manager can't find google play services package, defaulting to false");
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static int B1(q6<?> q6Var, int i, byte[] bArr, int i2, int i3, b5<?> b5Var, s3 s3Var) throws IOException {
|
|
int D1 = D1(q6Var, bArr, i2, i3, s3Var);
|
|
b5Var.add(s3Var.c);
|
|
while (D1 < i3) {
|
|
int F1 = F1(bArr, D1, s3Var);
|
|
if (i != s3Var.a) {
|
|
break;
|
|
}
|
|
D1 = D1(q6Var, bArr, F1, i3, s3Var);
|
|
b5Var.add(s3Var.c);
|
|
}
|
|
return D1;
|
|
}
|
|
|
|
public static void C(int i, int i2, int i3) {
|
|
if (i < 0 || i2 < i || i2 > i3) {
|
|
throw new IndexOutOfBoundsException((i < 0 || i > i3) ? l(i, i3, "start index") : (i2 < 0 || i2 > i3) ? l(i2, i3, "end index") : G0("end index (%s) must not be less than start index (%s)", Integer.valueOf(i2), Integer.valueOf(i)));
|
|
}
|
|
}
|
|
|
|
@RecentlyNonNull
|
|
public static synchronized boolean C0(@RecentlyNonNull Context context) {
|
|
Boolean bool;
|
|
synchronized (f.class) {
|
|
Context applicationContext = context.getApplicationContext();
|
|
Context context2 = f1382b;
|
|
if (context2 != null && (bool = c) != null && context2 == applicationContext) {
|
|
return bool.booleanValue();
|
|
}
|
|
c = null;
|
|
if (y0()) {
|
|
c = Boolean.valueOf(applicationContext.getPackageManager().isInstantApp());
|
|
} else {
|
|
try {
|
|
context.getClassLoader().loadClass("com.google.android.instantapps.supervisor.InstantAppsRuntime");
|
|
c = Boolean.TRUE;
|
|
} catch (ClassNotFoundException unused) {
|
|
c = Boolean.FALSE;
|
|
}
|
|
}
|
|
f1382b = applicationContext;
|
|
return c.booleanValue();
|
|
}
|
|
}
|
|
|
|
public static int C1(q6 q6Var, byte[] bArr, int i, int i2, int i3, s3 s3Var) throws IOException {
|
|
e6 e6Var = (e6) q6Var;
|
|
Object b2 = e6Var.m.b(e6Var.g);
|
|
int m = e6Var.m(b2, bArr, i, i2, i3, s3Var);
|
|
e6Var.d(b2);
|
|
s3Var.c = b2;
|
|
return m;
|
|
}
|
|
|
|
public static void D(boolean z2) {
|
|
if (!z2) {
|
|
throw new IllegalStateException("no calls to next() since the last call to remove()");
|
|
}
|
|
}
|
|
|
|
public static final boolean D0(g0.e eVar) {
|
|
m.checkParameterIsNotNull(eVar, "$this$isProbablyUtf8");
|
|
try {
|
|
g0.e eVar2 = new g0.e();
|
|
eVar.n(eVar2, 0, d0.d0.f.coerceAtMost(eVar.k, 64));
|
|
for (int i = 0; i < 16; i++) {
|
|
if (eVar2.w()) {
|
|
return true;
|
|
}
|
|
int I = eVar2.I();
|
|
if (Character.isISOControl(I) && !Character.isWhitespace(I)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
} catch (EOFException unused) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static int D1(q6 q6Var, byte[] bArr, int i, int i2, s3 s3Var) throws IOException {
|
|
int i3 = i + 1;
|
|
byte b2 = bArr[i];
|
|
byte b3 = b2;
|
|
if (b2 < 0) {
|
|
i3 = A1(b2, bArr, i3, s3Var);
|
|
b3 = s3Var.a;
|
|
}
|
|
if (b3 < 0 || b3 > i2 - i3) {
|
|
throw zzij.a();
|
|
}
|
|
Object a2 = q6Var.a();
|
|
int i4 = (b3 == 1 ? 1 : 0) + i3;
|
|
q6Var.h(a2, bArr, i3, i4, s3Var);
|
|
q6Var.d(a2);
|
|
s3Var.c = a2;
|
|
return i4;
|
|
}
|
|
|
|
public static void E(boolean z2, @NullableDecl String str, int i) {
|
|
if (!z2) {
|
|
throw new IllegalStateException(G0(str, Integer.valueOf(i)));
|
|
}
|
|
}
|
|
|
|
public static final Job E0(CoroutineScope coroutineScope, CoroutineContext coroutineContext, CoroutineStart coroutineStart, Function2<? super CoroutineScope, ? super Continuation<? super Unit>, ? extends Object> function2) {
|
|
CoroutineContext a2 = z.a(coroutineScope, coroutineContext);
|
|
Objects.requireNonNull(coroutineStart);
|
|
s.a.b k1Var = coroutineStart == CoroutineStart.LAZY ? new k1(a2, function2) : new s1(a2, true);
|
|
k1Var.j0(coroutineStart, k1Var, function2);
|
|
return k1Var;
|
|
}
|
|
|
|
public static int E1(byte[] bArr, int i) {
|
|
return ((bArr[i + 3] & 255) << 24) | (bArr[i] & 255) | ((bArr[i + 1] & 255) << 8) | ((bArr[i + 2] & 255) << 16);
|
|
}
|
|
|
|
public static void F(boolean z2, @NullableDecl String str, @NullableDecl Object obj) {
|
|
if (!z2) {
|
|
throw new IllegalStateException(G0(str, obj));
|
|
}
|
|
}
|
|
|
|
public static /* synthetic */ Job F0(CoroutineScope coroutineScope, CoroutineContext coroutineContext, CoroutineStart coroutineStart, Function2 function2, int i, Object obj) {
|
|
if ((i & 1) != 0) {
|
|
coroutineContext = d0.w.f.j;
|
|
}
|
|
return E0(coroutineScope, coroutineContext, (i & 2) != 0 ? CoroutineStart.DEFAULT : null, function2);
|
|
}
|
|
|
|
public static int F1(byte[] bArr, int i, s3 s3Var) {
|
|
int i2 = i + 1;
|
|
byte b2 = bArr[i];
|
|
if (b2 < 0) {
|
|
return A1(b2, bArr, i2, s3Var);
|
|
}
|
|
s3Var.a = b2;
|
|
return i2;
|
|
}
|
|
|
|
public static int G(long j) {
|
|
int i = (int) j;
|
|
if (((long) i) == j) {
|
|
return i;
|
|
}
|
|
throw new IllegalArgumentException(G0("Out of range: %s", Long.valueOf(j)));
|
|
}
|
|
|
|
public static String G0(@NullableDecl String str, @NullableDecl Object... objArr) {
|
|
int indexOf;
|
|
String str2;
|
|
String valueOf = String.valueOf(str);
|
|
int i = 0;
|
|
for (int i2 = 0; i2 < objArr.length; i2++) {
|
|
Object obj = objArr[i2];
|
|
try {
|
|
str2 = String.valueOf(obj);
|
|
} catch (Exception e2) {
|
|
String str3 = obj.getClass().getName() + MentionUtilsKt.MENTIONS_CHAR + Integer.toHexString(System.identityHashCode(obj));
|
|
Logger.getLogger("com.google.common.base.Strings").log(Level.WARNING, "Exception during lenientFormat for " + str3, (Throwable) e2);
|
|
str2 = "<" + str3 + " threw " + e2.getClass().getName() + ">";
|
|
}
|
|
objArr[i2] = str2;
|
|
}
|
|
StringBuilder sb = new StringBuilder((objArr.length * 16) + valueOf.length());
|
|
int i3 = 0;
|
|
while (i < objArr.length && (indexOf = valueOf.indexOf("%s", i3)) != -1) {
|
|
sb.append((CharSequence) valueOf, i3, indexOf);
|
|
sb.append(objArr[i]);
|
|
i3 = indexOf + 2;
|
|
i++;
|
|
}
|
|
sb.append((CharSequence) valueOf, i3, valueOf.length());
|
|
if (i < objArr.length) {
|
|
sb.append(" [");
|
|
sb.append(objArr[i]);
|
|
for (int i4 = i + 1; i4 < objArr.length; i4++) {
|
|
sb.append(", ");
|
|
sb.append(objArr[i4]);
|
|
}
|
|
sb.append(']');
|
|
}
|
|
return sb.toString();
|
|
}
|
|
|
|
public static int G1(byte[] bArr, int i, b5<?> b5Var, s3 s3Var) throws IOException {
|
|
x4 x4Var = (x4) b5Var;
|
|
int F1 = F1(bArr, i, s3Var);
|
|
int i2 = s3Var.a + F1;
|
|
while (F1 < i2) {
|
|
F1 = F1(bArr, F1, s3Var);
|
|
x4Var.g(s3Var.a);
|
|
}
|
|
if (F1 == i2) {
|
|
return F1;
|
|
}
|
|
throw zzij.a();
|
|
}
|
|
|
|
public static /* synthetic */ boolean H(s sVar, Throwable th, int i, Object obj) {
|
|
int i2 = i & 1;
|
|
return sVar.j(null);
|
|
}
|
|
|
|
public static final float[] H0(float[] fArr) {
|
|
m.checkNotNullParameter(fArr, "matrix");
|
|
return (float[]) fArr.clone();
|
|
}
|
|
|
|
public static <T> z2<T> H1(z2<T> z2Var) {
|
|
return ((z2Var instanceof c3) || (z2Var instanceof a3)) ? z2Var : z2Var instanceof Serializable ? new a3(z2Var) : new c3(z2Var);
|
|
}
|
|
|
|
public static int I(int i, int i2) {
|
|
int i3 = i - i2;
|
|
if (i3 > i2) {
|
|
i3 = i2;
|
|
i2 = i3;
|
|
}
|
|
int i4 = 1;
|
|
int i5 = 1;
|
|
while (i > i2) {
|
|
i4 *= i;
|
|
if (i5 <= i3) {
|
|
i4 /= i5;
|
|
i5++;
|
|
}
|
|
i--;
|
|
}
|
|
while (i5 <= i3) {
|
|
i4 /= i5;
|
|
i5++;
|
|
}
|
|
return i4;
|
|
}
|
|
|
|
@NonNull
|
|
public static b.o.a.x.c I0(int i) {
|
|
return u1(new c(i));
|
|
}
|
|
|
|
public static FirebaseAppIndexingException I1(@NonNull Status status, String str) {
|
|
String str2 = status.q;
|
|
if (str2 != null && !str2.isEmpty()) {
|
|
str = str2;
|
|
}
|
|
int i = status.p;
|
|
if (i == 17510) {
|
|
return new FirebaseAppIndexingInvalidArgumentException(str);
|
|
}
|
|
if (i == 17511) {
|
|
return new FirebaseAppIndexingTooManyArgumentsException(str);
|
|
}
|
|
if (i == 17602) {
|
|
return new zzh(str);
|
|
}
|
|
switch (i) {
|
|
case 17513:
|
|
return new zzb(str);
|
|
case 17514:
|
|
return new zza(str);
|
|
case 17515:
|
|
return new zzg(str);
|
|
case 17516:
|
|
return new zze(str);
|
|
case 17517:
|
|
return new zzf(str);
|
|
case 17518:
|
|
return new zzd(str);
|
|
case 17519:
|
|
return new zzc(str);
|
|
default:
|
|
return new FirebaseAppIndexingException(str);
|
|
}
|
|
}
|
|
|
|
public static final byte[] J(String str) {
|
|
int i;
|
|
int i2;
|
|
char charAt;
|
|
m.checkParameterIsNotNull(str, "$this$commonAsUtf8ToByteArray");
|
|
byte[] bArr = new byte[(str.length() * 4)];
|
|
int length = str.length();
|
|
int i3 = 0;
|
|
while (i3 < length) {
|
|
char charAt2 = str.charAt(i3);
|
|
if (charAt2 >= 128) {
|
|
int length2 = str.length();
|
|
int i4 = i3;
|
|
while (i3 < length2) {
|
|
char charAt3 = str.charAt(i3);
|
|
if (charAt3 < 128) {
|
|
int i5 = i4 + 1;
|
|
bArr[i4] = (byte) charAt3;
|
|
i3++;
|
|
while (i3 < length2 && str.charAt(i3) < 128) {
|
|
bArr[i5] = (byte) str.charAt(i3);
|
|
i3++;
|
|
i5++;
|
|
}
|
|
i4 = i5;
|
|
} else {
|
|
if (charAt3 < 2048) {
|
|
int i6 = i4 + 1;
|
|
bArr[i4] = (byte) ((charAt3 >> 6) | 192);
|
|
i = i6 + 1;
|
|
bArr[i6] = (byte) ((charAt3 & '?') | 128);
|
|
} else if (55296 > charAt3 || 57343 < charAt3) {
|
|
int i7 = i4 + 1;
|
|
bArr[i4] = (byte) ((charAt3 >> '\f') | 224);
|
|
int i8 = i7 + 1;
|
|
bArr[i7] = (byte) (((charAt3 >> 6) & 63) | 128);
|
|
i = i8 + 1;
|
|
bArr[i8] = (byte) ((charAt3 & '?') | 128);
|
|
} else if (charAt3 > 56319 || length2 <= (i2 = i3 + 1) || 56320 > (charAt = str.charAt(i2)) || 57343 < charAt) {
|
|
i = i4 + 1;
|
|
bArr[i4] = 63;
|
|
} else {
|
|
int charAt4 = (str.charAt(i2) + (charAt3 << '\n')) - 56613888;
|
|
int i9 = i4 + 1;
|
|
bArr[i4] = (byte) ((charAt4 >> 18) | 240);
|
|
int i10 = i9 + 1;
|
|
bArr[i9] = (byte) (((charAt4 >> 12) & 63) | 128);
|
|
int i11 = i10 + 1;
|
|
bArr[i10] = (byte) (((charAt4 >> 6) & 63) | 128);
|
|
i = i11 + 1;
|
|
bArr[i11] = (byte) ((charAt4 & 63) | 128);
|
|
i3 += 2;
|
|
i4 = i;
|
|
}
|
|
i3++;
|
|
i4 = i;
|
|
}
|
|
}
|
|
byte[] copyOf = Arrays.copyOf(bArr, i4);
|
|
m.checkExpressionValueIsNotNull(copyOf, "java.util.Arrays.copyOf(this, newSize)");
|
|
return copyOf;
|
|
}
|
|
bArr[i3] = (byte) charAt2;
|
|
i3++;
|
|
}
|
|
byte[] copyOf2 = Arrays.copyOf(bArr, str.length());
|
|
m.checkExpressionValueIsNotNull(copyOf2, "java.util.Arrays.copyOf(this, newSize)");
|
|
return copyOf2;
|
|
}
|
|
|
|
@NonNull
|
|
public static b.o.a.x.c J0(int i) {
|
|
return u1(new a(i));
|
|
}
|
|
|
|
public static <T> T J1(@NonNull Bundle bundle, String str, Class<T> cls, T t) {
|
|
T t2 = (T) bundle.get(str);
|
|
if (t2 == null) {
|
|
return t;
|
|
}
|
|
if (cls.isAssignableFrom(t2.getClass())) {
|
|
return t2;
|
|
}
|
|
throw new IllegalStateException(String.format("Invalid conditional user property field type. '%s' expected [%s] but was [%s]", str, cls.getCanonicalName(), t2.getClass().getCanonicalName()));
|
|
}
|
|
|
|
@NonNull
|
|
public static Rect K(@NonNull b.o.a.x.b bVar, @NonNull b.o.a.x.a aVar) {
|
|
int i;
|
|
int i2 = bVar.j;
|
|
int i3 = bVar.k;
|
|
int i4 = 0;
|
|
if (Math.abs(aVar.i() - b.o.a.x.a.f(bVar.j, bVar.k).i()) <= 5.0E-4f) {
|
|
return new Rect(0, 0, i2, i3);
|
|
}
|
|
if (b.o.a.x.a.f(i2, i3).i() > aVar.i()) {
|
|
int round = Math.round(aVar.i() * ((float) i3));
|
|
i2 = round;
|
|
i4 = Math.round(((float) (i2 - round)) / 2.0f);
|
|
i = 0;
|
|
} else {
|
|
int round2 = Math.round(((float) i2) / aVar.i());
|
|
i = Math.round(((float) (i3 - round2)) / 2.0f);
|
|
i3 = round2;
|
|
}
|
|
return new Rect(i4, i, i2 + i4, i3 + i);
|
|
}
|
|
|
|
@NonNull
|
|
public static b.o.a.x.c K0(int i) {
|
|
return u1(new d(i));
|
|
}
|
|
|
|
public static <V> V K1(d2<V> d2Var) {
|
|
long clearCallingIdentity;
|
|
try {
|
|
return d2Var.a();
|
|
} catch (SecurityException unused) {
|
|
clearCallingIdentity = Binder.clearCallingIdentity();
|
|
V a2 = d2Var.a();
|
|
Binder.restoreCallingIdentity(clearCallingIdentity);
|
|
return a2;
|
|
} catch (Throwable th) {
|
|
Binder.restoreCallingIdentity(clearCallingIdentity);
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
public static final <R> Object L(Function2<? super CoroutineScope, ? super Continuation<? super R>, ? extends Object> function2, Continuation<? super R> continuation) {
|
|
r rVar = new r(continuation.getContext(), continuation);
|
|
Object c1 = c1(rVar, rVar, function2);
|
|
if (c1 == d0.w.h.c.getCOROUTINE_SUSPENDED()) {
|
|
g.probeCoroutineSuspended(continuation);
|
|
}
|
|
return c1;
|
|
}
|
|
|
|
@NonNull
|
|
public static b.o.a.x.c L0(int i) {
|
|
return u1(new b(i));
|
|
}
|
|
|
|
public static <TResult> TResult L1(@NonNull Task<TResult> task) throws ExecutionException {
|
|
if (task.p()) {
|
|
return task.l();
|
|
}
|
|
if (task.n()) {
|
|
throw new CancellationException("Task is already canceled");
|
|
}
|
|
throw new ExecutionException(task.k());
|
|
}
|
|
|
|
public static b.i.c.l.d<?> M(String str, String str2) {
|
|
b.i.c.x.a aVar = new b.i.c.x.a(str, str2);
|
|
d.b a2 = b.i.c.l.d.a(b.i.c.x.e.class);
|
|
a2.d = 1;
|
|
a2.c(new b.i.c.l.c(aVar));
|
|
return a2.b();
|
|
}
|
|
|
|
public static /* synthetic */ void M0(FlexInputViewModel flexInputViewModel, boolean z2, int i, Object obj) {
|
|
if ((i & 1) != 0) {
|
|
z2 = true;
|
|
}
|
|
flexInputViewModel.onContentDialogDismissed(z2);
|
|
}
|
|
|
|
public static String M1(Context context, String str) {
|
|
try {
|
|
Objects.requireNonNull(context, "null reference");
|
|
Resources resources = context.getResources();
|
|
int identifier = resources.getIdentifier(str, "string", resources.getResourcePackageName(R.a.common_google_play_services_unknown_issue));
|
|
if (identifier == 0) {
|
|
return null;
|
|
}
|
|
return resources.getString(identifier);
|
|
} catch (Resources.NotFoundException unused) {
|
|
}
|
|
}
|
|
|
|
/* JADX WARNING: Code restructure failed: missing block: B:40:0x00a0, code lost:
|
|
if ((r2 - r15) != 0) goto L_0x00a3;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:61:0x00ea, code lost:
|
|
return null;
|
|
*/
|
|
public static final InetAddress N(String str, int i, int i2) {
|
|
boolean z2;
|
|
int i3;
|
|
int i4;
|
|
byte[] bArr = new byte[16];
|
|
int i5 = i;
|
|
int i6 = 0;
|
|
int i7 = -1;
|
|
int i8 = -1;
|
|
while (true) {
|
|
if (i5 >= i2) {
|
|
break;
|
|
} else if (i6 == 16) {
|
|
return null;
|
|
} else {
|
|
int i9 = i5 + 2;
|
|
if (i9 > i2 || !t.startsWith$default(str, "::", i5, false, 4, null)) {
|
|
if (i6 != 0) {
|
|
if (t.startsWith$default(str, ":", i5, false, 4, null)) {
|
|
i5++;
|
|
} else if (!t.startsWith$default(str, ".", i5, false, 4, null)) {
|
|
return null;
|
|
} else {
|
|
int i10 = i6 - 2;
|
|
int i11 = i10;
|
|
loop1:
|
|
while (true) {
|
|
if (i8 < i2) {
|
|
if (i11 == 16) {
|
|
break;
|
|
}
|
|
if (i11 != i10) {
|
|
if (str.charAt(i8) != '.') {
|
|
break;
|
|
}
|
|
i8++;
|
|
}
|
|
i3 = i8;
|
|
i4 = 0;
|
|
while (true) {
|
|
if (i3 < i2) {
|
|
char charAt = str.charAt(i3);
|
|
if (charAt >= '0' && charAt <= '9') {
|
|
if ((i4 == 0 && i8 != i3) || (i4 = ((i4 * 10) + charAt) - 48) > 255) {
|
|
break loop1;
|
|
}
|
|
i3++;
|
|
} else {
|
|
break;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
} else if (i11 == i10 + 4) {
|
|
z2 = true;
|
|
}
|
|
bArr[i11] = (byte) i4;
|
|
i8 = i3;
|
|
i11++;
|
|
}
|
|
z2 = false;
|
|
if (!z2) {
|
|
return null;
|
|
}
|
|
i6 += 2;
|
|
}
|
|
}
|
|
i8 = i5;
|
|
} else if (i7 != -1) {
|
|
return null;
|
|
} else {
|
|
i6 += 2;
|
|
if (i9 == i2) {
|
|
i7 = i6;
|
|
break;
|
|
}
|
|
i8 = i9;
|
|
i7 = i6;
|
|
}
|
|
i5 = i8;
|
|
int i12 = 0;
|
|
while (i5 < i2) {
|
|
int r = f0.e0.c.r(str.charAt(i5));
|
|
if (r == -1) {
|
|
break;
|
|
}
|
|
i12 = (i12 << 4) + r;
|
|
i5++;
|
|
}
|
|
int i13 = i5 - i8;
|
|
if (i13 == 0 || i13 > 4) {
|
|
break;
|
|
}
|
|
int i14 = i6 + 1;
|
|
bArr[i6] = (byte) ((i12 >>> 8) & 255);
|
|
i6 = i14 + 1;
|
|
bArr[i14] = (byte) (i12 & 255);
|
|
}
|
|
}
|
|
if (i6 != 16) {
|
|
if (i7 == -1) {
|
|
return null;
|
|
}
|
|
int i15 = i6 - i7;
|
|
System.arraycopy(bArr, i7, bArr, 16 - i15, i15);
|
|
Arrays.fill(bArr, i7, (16 - i6) + i7, (byte) 0);
|
|
}
|
|
return InetAddress.getByAddress(bArr);
|
|
}
|
|
|
|
public static /* synthetic */ void N0(FlexInputViewModel flexInputViewModel, String str, Boolean bool, int i, Object obj) {
|
|
int i2 = i & 2;
|
|
flexInputViewModel.onInputTextChanged(str, null);
|
|
}
|
|
|
|
public static String N1(t3 t3Var) {
|
|
b7 b7Var = new b7(t3Var);
|
|
StringBuilder sb = new StringBuilder(t3Var.d());
|
|
for (int i = 0; i < b7Var.a.d(); i++) {
|
|
byte c2 = b7Var.a.c(i);
|
|
if (c2 == 34) {
|
|
sb.append("\\\"");
|
|
} else if (c2 == 39) {
|
|
sb.append("\\'");
|
|
} else if (c2 != 92) {
|
|
switch (c2) {
|
|
case 7:
|
|
sb.append("\\a");
|
|
continue;
|
|
case 8:
|
|
sb.append("\\b");
|
|
continue;
|
|
case 9:
|
|
sb.append("\\t");
|
|
continue;
|
|
case 10:
|
|
sb.append("\\n");
|
|
continue;
|
|
case 11:
|
|
sb.append("\\v");
|
|
continue;
|
|
case 12:
|
|
sb.append("\\f");
|
|
continue;
|
|
case 13:
|
|
sb.append("\\r");
|
|
continue;
|
|
default:
|
|
if (c2 < 32 || c2 > 126) {
|
|
sb.append('\\');
|
|
sb.append((char) (((c2 >>> 6) & 3) + 48));
|
|
sb.append((char) (((c2 >>> 3) & 7) + 48));
|
|
sb.append((char) ((c2 & 7) + 48));
|
|
break;
|
|
} else {
|
|
sb.append((char) c2);
|
|
continue;
|
|
}
|
|
}
|
|
} else {
|
|
sb.append("\\\\");
|
|
}
|
|
}
|
|
return sb.toString();
|
|
}
|
|
|
|
public static final Object O(long j, Continuation<? super Unit> continuation) {
|
|
if (j <= 0) {
|
|
return Unit.a;
|
|
}
|
|
l lVar = new l(d0.w.h.b.intercepted(continuation), 1);
|
|
lVar.A();
|
|
if (j < RecyclerView.FOREVER_NS) {
|
|
g0(lVar.o).c(j, lVar);
|
|
}
|
|
Object u = lVar.u();
|
|
if (u == d0.w.h.c.getCOROUTINE_SUSPENDED()) {
|
|
g.probeCoroutineSuspended(continuation);
|
|
}
|
|
return u;
|
|
}
|
|
|
|
@NonNull
|
|
public static b.o.a.x.c O0(b.o.a.x.c... cVarArr) {
|
|
return new b.o.a.x.l(cVarArr, null);
|
|
}
|
|
|
|
public static final String O1(String str) {
|
|
StringBuilder sb = new StringBuilder();
|
|
for (int i = 0; i < str.length(); i++) {
|
|
char charAt = str.charAt(i);
|
|
if (Character.isUpperCase(charAt)) {
|
|
sb.append("_");
|
|
}
|
|
sb.append(Character.toLowerCase(charAt));
|
|
}
|
|
return sb.toString();
|
|
}
|
|
|
|
public static float P(float f, float f2, float f3, float f4) {
|
|
float f5 = f - f3;
|
|
float f6 = f2 - f4;
|
|
return (float) Math.sqrt((double) ((f6 * f6) + (f5 * f5)));
|
|
}
|
|
|
|
public static int P0(int i) {
|
|
if (i >= 200 && i <= 299) {
|
|
return 0;
|
|
}
|
|
if (i >= 300 && i <= 399) {
|
|
return 1;
|
|
}
|
|
if (i >= 400 && i <= 499) {
|
|
return 0;
|
|
}
|
|
if (i >= 500) {
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
@Nullable
|
|
public static String P1(String str, String[] strArr, String[] strArr2) {
|
|
int min = Math.min(strArr.length, strArr2.length);
|
|
for (int i = 0; i < min; i++) {
|
|
String str2 = strArr[i];
|
|
if ((str == null && str2 == null) ? true : str == null ? false : str.equals(str2)) {
|
|
return strArr2[i];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static float Q(int i, int i2, int i3, int i4) {
|
|
int i5 = i - i3;
|
|
int i6 = i2 - i4;
|
|
return (float) Math.sqrt((double) ((i6 * i6) + (i5 * i5)));
|
|
}
|
|
|
|
/* JADX WARNING: Code restructure failed: missing block: B:10:0x0016, code lost:
|
|
r2 = move-exception;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:12:0x001c, code lost:
|
|
throw new com.google.gson.JsonIOException(r2);
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:13:0x001d, code lost:
|
|
r2 = move-exception;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:15:0x0023, code lost:
|
|
throw new com.google.gson.JsonSyntaxException(r2);
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:20:0x002a, code lost:
|
|
return b.i.d.j.a;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:22:0x0030, code lost:
|
|
throw new com.google.gson.JsonSyntaxException(r2);
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:6:0x000d, code lost:
|
|
r2 = e;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:7:0x000f, code lost:
|
|
r2 = move-exception;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:9:0x0015, code lost:
|
|
throw new com.google.gson.JsonSyntaxException(r2);
|
|
*/
|
|
/* JADX WARNING: Failed to process nested try/catch */
|
|
/* JADX WARNING: Removed duplicated region for block: B:10:0x0016 A[ExcHandler: IOException (r2v5 'e' java.io.IOException A[CUSTOM_DECLARE]), Splitter:B:0:0x0000] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:13:0x001d A[ExcHandler: MalformedJsonException (r2v4 'e' com.google.gson.stream.MalformedJsonException A[CUSTOM_DECLARE]), Splitter:B:0:0x0000] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:19:0x0028 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:21:0x002b */
|
|
/* JADX WARNING: Removed duplicated region for block: B:7:0x000f A[ExcHandler: NumberFormatException (r2v6 'e' java.lang.NumberFormatException A[CUSTOM_DECLARE]), Splitter:B:0:0x0000] */
|
|
public static JsonElement Q0(JsonReader jsonReader) throws JsonParseException {
|
|
boolean z2;
|
|
try {
|
|
jsonReader.N();
|
|
z2 = false;
|
|
return TypeAdapters.X.read(jsonReader);
|
|
} catch (EOFException e2) {
|
|
EOFException e3 = e2;
|
|
z2 = true;
|
|
if (!z2) {
|
|
}
|
|
} catch (MalformedJsonException e4) {
|
|
} catch (IOException e5) {
|
|
} catch (NumberFormatException e6) {
|
|
}
|
|
}
|
|
|
|
@WorkerThread
|
|
public static Set<String> Q1(SQLiteDatabase sQLiteDatabase, String str) {
|
|
HashSet hashSet = new HashSet();
|
|
Cursor rawQuery = sQLiteDatabase.rawQuery(b.d.b.a.a.j(b.d.b.a.a.b(str, 22), "SELECT * FROM ", str, " LIMIT 0"), null);
|
|
try {
|
|
Collections.addAll(hashSet, rawQuery.getColumnNames());
|
|
return hashSet;
|
|
} finally {
|
|
rawQuery.close();
|
|
}
|
|
}
|
|
|
|
public static int R(Context context, float f) {
|
|
float applyDimension = TypedValue.applyDimension(1, f, context.getResources().getDisplayMetrics());
|
|
int i = (int) (((double) applyDimension) + 0.5d);
|
|
if (i != 0 || applyDimension <= 0.0f) {
|
|
return i;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
public static final Object R0(Object obj, E e2) {
|
|
if (obj == null) {
|
|
return e2;
|
|
}
|
|
if (obj instanceof ArrayList) {
|
|
((ArrayList) obj).add(e2);
|
|
return obj;
|
|
}
|
|
ArrayList arrayList = new ArrayList(4);
|
|
arrayList.add(obj);
|
|
arrayList.add(e2);
|
|
return arrayList;
|
|
}
|
|
|
|
public static void R1(byte b2, byte b3, byte b4, byte b5, char[] cArr, int i) throws zzij {
|
|
if (!m2(b3)) {
|
|
if ((((b3 + 112) + (b2 << 28)) >> 30) == 0 && !m2(b4) && !m2(b5)) {
|
|
int i2 = ((b2 & 7) << 18) | ((b3 & 63) << 12) | ((b4 & 63) << 6) | (b5 & 63);
|
|
cArr[i] = (char) ((i2 >>> 10) + 55232);
|
|
cArr[i + 1] = (char) ((i2 & AudioAttributesCompat.FLAG_ALL) + 56320);
|
|
return;
|
|
}
|
|
}
|
|
throw zzij.e();
|
|
}
|
|
|
|
public static float S(float f, float f2, float f3, float f4) {
|
|
float f5 = f / (f4 / 2.0f);
|
|
float f6 = f3 / 2.0f;
|
|
if (f5 < 1.0f) {
|
|
return (f6 * f5 * f5 * f5) + f2;
|
|
}
|
|
float f7 = f5 - 2.0f;
|
|
return (((f7 * f7 * f7) + 2.0f) * f6) + f2;
|
|
}
|
|
|
|
/* JADX ERROR: JadxRuntimeException in pass: RegionMakerVisitor
|
|
jadx.core.utils.exceptions.JadxRuntimeException: Failed to find switch 'out' block
|
|
at jadx.core.dex.visitors.regions.RegionMaker.processSwitch(RegionMaker.java:821)
|
|
at jadx.core.dex.visitors.regions.RegionMaker.traverse(RegionMaker.java:157)
|
|
at jadx.core.dex.visitors.regions.RegionMaker.makeRegion(RegionMaker.java:94)
|
|
at jadx.core.dex.visitors.regions.RegionMaker.processSwitch(RegionMaker.java:860)
|
|
at jadx.core.dex.visitors.regions.RegionMaker.traverse(RegionMaker.java:157)
|
|
at jadx.core.dex.visitors.regions.RegionMaker.makeRegion(RegionMaker.java:94)
|
|
at jadx.core.dex.visitors.regions.RegionMaker.processIf(RegionMaker.java:731)
|
|
at jadx.core.dex.visitors.regions.RegionMaker.traverse(RegionMaker.java:152)
|
|
at jadx.core.dex.visitors.regions.RegionMaker.makeRegion(RegionMaker.java:94)
|
|
at jadx.core.dex.visitors.regions.RegionMakerVisitor.visit(RegionMakerVisitor.java:50)
|
|
*/
|
|
public static void S0(int r2, h0.a.a.c r3) {
|
|
/*
|
|
int r0 = r2 >>> 24
|
|
if (r0 == 0) goto L_0x0025
|
|
r1 = 1
|
|
if (r0 == r1) goto L_0x0025
|
|
switch(r0) {
|
|
case 16: goto L_0x001b;
|
|
case 17: goto L_0x001b;
|
|
case 18: goto L_0x001b;
|
|
case 19: goto L_0x0013;
|
|
case 20: goto L_0x0013;
|
|
case 21: goto L_0x0013;
|
|
case 22: goto L_0x0025;
|
|
case 23: goto L_0x001b;
|
|
default: goto L_0x000a;
|
|
}
|
|
L_0x000a:
|
|
switch(r0) {
|
|
case 66: goto L_0x001b;
|
|
case 67: goto L_0x001b;
|
|
case 68: goto L_0x001b;
|
|
case 69: goto L_0x001b;
|
|
case 70: goto L_0x001b;
|
|
case 71: goto L_0x0017;
|
|
case 72: goto L_0x0017;
|
|
case 73: goto L_0x0017;
|
|
case 74: goto L_0x0017;
|
|
case 75: goto L_0x0017;
|
|
default: goto L_0x000d;
|
|
}
|
|
L_0x000d:
|
|
java.lang.IllegalArgumentException r2 = new java.lang.IllegalArgumentException
|
|
r2.<init>()
|
|
throw r2
|
|
L_0x0013:
|
|
r3.g(r0)
|
|
goto L_0x002a
|
|
L_0x0017:
|
|
r3.i(r2)
|
|
goto L_0x002a
|
|
L_0x001b:
|
|
r1 = 16776960(0xffff00, float:2.3509528E-38)
|
|
r2 = r2 & r1
|
|
int r2 = r2 >> 8
|
|
r3.e(r0, r2)
|
|
goto L_0x002a
|
|
L_0x0025:
|
|
int r2 = r2 >>> 16
|
|
r3.j(r2)
|
|
L_0x002a:
|
|
return
|
|
switch-data {16->0x001b, 17->0x001b, 18->0x001b, 19->0x0013, 20->0x0013, 21->0x0013, 22->0x0025, 23->0x001b, }
|
|
switch-data {66->0x001b, 67->0x001b, 68->0x001b, 69->0x001b, 70->0x001b, 71->0x0017, 72->0x0017, 73->0x0017, 74->0x0017, 75->0x0017, }
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: b.i.a.f.e.o.f.S0(int, h0.a.a.c):void");
|
|
}
|
|
|
|
public static void S1(byte b2, byte b3, byte b4, char[] cArr, int i) throws zzij {
|
|
if (m2(b3) || ((b2 == -32 && b3 < -96) || ((b2 == -19 && b3 >= -96) || m2(b4)))) {
|
|
throw zzij.e();
|
|
}
|
|
cArr[i] = (char) (((b2 & 15) << 12) | ((b3 & 63) << 6) | (b4 & 63));
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:18:0x0060 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:23:0x0077 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:28:0x0086 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:35:0x0095 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:37:0x00a1 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:8:0x0024 */
|
|
public static final <T> Object T(s.a.c2.e<? super T> eVar, o<? extends T> oVar, boolean z2, Continuation<? super Unit> continuation) {
|
|
C0108f fVar;
|
|
Object coroutine_suspended;
|
|
int i;
|
|
o<? extends T> oVar2;
|
|
boolean z3;
|
|
Throwable th;
|
|
Throwable th2;
|
|
s.a.c2.e eVar2;
|
|
Throwable th3;
|
|
Object m;
|
|
s.a.c2.e<? super T> eVar3;
|
|
if (continuation instanceof C0108f) {
|
|
fVar = (C0108f) continuation;
|
|
int i2 = fVar.label;
|
|
if ((i2 & Integer.MIN_VALUE) != 0) {
|
|
fVar.label = i2 - Integer.MIN_VALUE;
|
|
Object obj = fVar.result;
|
|
coroutine_suspended = d0.w.h.c.getCOROUTINE_SUSPENDED();
|
|
i = fVar.label;
|
|
if (i != 0) {
|
|
d0.l.throwOnFailure(obj);
|
|
th3 = null;
|
|
fVar.L$0 = eVar;
|
|
fVar.L$1 = oVar;
|
|
fVar.Z$0 = z2;
|
|
fVar.L$2 = th3;
|
|
fVar.L$3 = eVar;
|
|
fVar.label = 1;
|
|
m = oVar.m(fVar);
|
|
if (m != coroutine_suspended) {
|
|
eVar2 = eVar;
|
|
th2 = th3;
|
|
obj = m;
|
|
oVar2 = oVar;
|
|
z3 = z2;
|
|
if (!(obj instanceof v.a)) {
|
|
}
|
|
if (!(obj instanceof v.a)) {
|
|
}
|
|
}
|
|
return coroutine_suspended;
|
|
} else if (i == 1) {
|
|
s.a.c2.e eVar4 = (s.a.c2.e) fVar.L$3;
|
|
th2 = (Throwable) fVar.L$2;
|
|
z3 = fVar.Z$0;
|
|
oVar2 = (o) fVar.L$1;
|
|
d0.l.throwOnFailure(obj);
|
|
eVar2 = (s.a.c2.e) fVar.L$0;
|
|
if (!(obj instanceof v.a)) {
|
|
if (!(obj instanceof v.a)) {
|
|
fVar.L$0 = eVar2;
|
|
fVar.L$1 = oVar2;
|
|
fVar.Z$0 = z3;
|
|
fVar.L$2 = th2;
|
|
fVar.L$3 = obj;
|
|
fVar.label = 2;
|
|
Object emit = eVar2.emit(obj, fVar);
|
|
eVar3 = eVar2;
|
|
if (emit == coroutine_suspended) {
|
|
return coroutine_suspended;
|
|
}
|
|
}
|
|
throw new IllegalStateException("Channel was closed".toString());
|
|
}
|
|
if (!(obj instanceof v.a)) {
|
|
Throwable th4 = ((v.a) obj).a;
|
|
if (th4 == null) {
|
|
if (z3) {
|
|
t(oVar2, th2);
|
|
}
|
|
return Unit.a;
|
|
}
|
|
throw th4;
|
|
}
|
|
throw new IllegalStateException("Channel was not closed".toString());
|
|
} else if (i == 2) {
|
|
th2 = (Throwable) fVar.L$2;
|
|
z3 = fVar.Z$0;
|
|
oVar2 = (o) fVar.L$1;
|
|
s.a.c2.e<? super T> eVar5 = (s.a.c2.e) fVar.L$0;
|
|
try {
|
|
d0.l.throwOnFailure(obj);
|
|
eVar3 = eVar5;
|
|
} catch (Throwable th5) {
|
|
th = th5;
|
|
try {
|
|
throw th;
|
|
} catch (Throwable th6) {
|
|
if (z3) {
|
|
t(oVar2, th);
|
|
}
|
|
throw th6;
|
|
}
|
|
}
|
|
} else {
|
|
throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
|
|
}
|
|
th3 = th2;
|
|
eVar = eVar3;
|
|
z2 = z3;
|
|
oVar = oVar2;
|
|
fVar.L$0 = eVar;
|
|
fVar.L$1 = oVar;
|
|
fVar.Z$0 = z2;
|
|
fVar.L$2 = th3;
|
|
fVar.L$3 = eVar;
|
|
fVar.label = 1;
|
|
m = oVar.m(fVar);
|
|
if (m != coroutine_suspended) {
|
|
}
|
|
return coroutine_suspended;
|
|
}
|
|
}
|
|
fVar = new C0108f(continuation);
|
|
Object obj = fVar.result;
|
|
coroutine_suspended = d0.w.h.c.getCOROUTINE_SUSPENDED();
|
|
i = fVar.label;
|
|
if (i != 0) {
|
|
}
|
|
th3 = th2;
|
|
eVar = eVar3;
|
|
z2 = z3;
|
|
oVar = oVar2;
|
|
try {
|
|
fVar.L$0 = eVar;
|
|
fVar.L$1 = oVar;
|
|
fVar.Z$0 = z2;
|
|
fVar.L$2 = th3;
|
|
fVar.L$3 = eVar;
|
|
fVar.label = 1;
|
|
m = oVar.m(fVar);
|
|
if (m != coroutine_suspended) {
|
|
}
|
|
return coroutine_suspended;
|
|
} catch (Throwable th7) {
|
|
th = th7;
|
|
oVar2 = oVar;
|
|
z3 = z2;
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
public static final <T> Object T0(Object obj, Continuation<? super T> continuation) {
|
|
if (obj instanceof w) {
|
|
k.a aVar = k.j;
|
|
return k.m72constructorimpl(d0.l.createFailure(((w) obj).f3804b));
|
|
}
|
|
k.a aVar2 = k.j;
|
|
return k.m72constructorimpl(obj);
|
|
}
|
|
|
|
public static void T1(byte b2, byte b3, char[] cArr, int i) throws zzij {
|
|
if (b2 < -62 || m2(b3)) {
|
|
throw zzij.e();
|
|
}
|
|
cArr[i] = (char) (((b2 & 31) << 6) | (b3 & 63));
|
|
}
|
|
|
|
public static boolean U(@NullableDecl Object obj, @NullableDecl Object obj2) {
|
|
return obj == obj2 || (obj != null && obj.equals(obj2));
|
|
}
|
|
|
|
public static final <T> void U0(j0<? super T> j0Var, Continuation<? super T> continuation, boolean z2) {
|
|
Object obj;
|
|
Object m = j0Var.m();
|
|
Throwable e2 = j0Var.e(m);
|
|
if (e2 != null) {
|
|
k.a aVar = k.j;
|
|
obj = d0.l.createFailure(e2);
|
|
} else {
|
|
k.a aVar2 = k.j;
|
|
obj = j0Var.j(m);
|
|
}
|
|
Object r2 = k.m72constructorimpl(obj);
|
|
if (z2) {
|
|
Objects.requireNonNull(continuation, "null cannot be cast to non-null type kotlinx.coroutines.internal.DispatchedContinuation<T>");
|
|
s.a.a.g gVar = (s.a.a.g) continuation;
|
|
CoroutineContext context = gVar.getContext();
|
|
Object b2 = s.a.a.a.b(context, gVar.p);
|
|
try {
|
|
gVar.r.resumeWith(r2);
|
|
} finally {
|
|
s.a.a.a.a(context, b2);
|
|
}
|
|
} else {
|
|
continuation.resumeWith(r2);
|
|
}
|
|
}
|
|
|
|
public static void U1(@NonNull Bundle bundle, @NonNull Object obj) {
|
|
if (obj instanceof Double) {
|
|
bundle.putDouble("value", ((Double) obj).doubleValue());
|
|
} else if (obj instanceof Long) {
|
|
bundle.putLong("value", ((Long) obj).longValue());
|
|
} else {
|
|
bundle.putString("value", obj.toString());
|
|
}
|
|
}
|
|
|
|
public static <T> T V(@NullableDecl T t, @NullableDecl T t2) {
|
|
if (t != null) {
|
|
return t;
|
|
}
|
|
Objects.requireNonNull(t2, "Both parameters are null");
|
|
return t2;
|
|
}
|
|
|
|
public static int V0(float f) {
|
|
return (int) (f + (f < 0.0f ? -0.5f : 0.5f));
|
|
}
|
|
|
|
/* JADX WARNING: Code restructure failed: missing block: B:81:0x01e5, code lost:
|
|
if (((java.lang.Boolean) r4).booleanValue() == false) goto L_0x024a;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:85:0x01f3, code lost:
|
|
if (((java.lang.Integer) r4).intValue() == 0) goto L_0x024a;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:89:0x0204, code lost:
|
|
if (((java.lang.Float) r4).floatValue() == 0.0f) goto L_0x024a;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:93:0x0216, code lost:
|
|
if (((java.lang.Double) r4).doubleValue() == com.google.android.material.shadow.ShadowDrawableWrapper.COS_45) goto L_0x024a;
|
|
*/
|
|
/* JADX WARNING: Removed duplicated region for block: B:111:0x0250 */
|
|
public static void V1(c6 c6Var, StringBuilder sb, int i) {
|
|
boolean z2;
|
|
HashMap hashMap = new HashMap();
|
|
HashMap hashMap2 = new HashMap();
|
|
TreeSet treeSet = new TreeSet();
|
|
Method[] declaredMethods = c6Var.getClass().getDeclaredMethods();
|
|
for (Method method : declaredMethods) {
|
|
hashMap2.put(method.getName(), method);
|
|
if (method.getParameterTypes().length == 0) {
|
|
hashMap.put(method.getName(), method);
|
|
if (method.getName().startsWith("get")) {
|
|
treeSet.add(method.getName());
|
|
}
|
|
}
|
|
}
|
|
Iterator it = treeSet.iterator();
|
|
while (it.hasNext()) {
|
|
String str = (String) it.next();
|
|
String substring = str.startsWith("get") ? str.substring(3) : str;
|
|
boolean z3 = true;
|
|
if (substring.endsWith("List") && !substring.endsWith("OrBuilderList") && !substring.equals("List")) {
|
|
String valueOf = String.valueOf(substring.substring(0, 1).toLowerCase());
|
|
String valueOf2 = String.valueOf(substring.substring(1, substring.length() - 4));
|
|
String concat = valueOf2.length() != 0 ? valueOf.concat(valueOf2) : new String(valueOf);
|
|
Method method2 = (Method) hashMap.get(str);
|
|
if (method2 != null && method2.getReturnType().equals(List.class)) {
|
|
Z1(sb, i, O1(concat), u4.q(method2, c6Var, new Object[0]));
|
|
}
|
|
}
|
|
if (substring.endsWith("Map") && !substring.equals("Map")) {
|
|
String valueOf3 = String.valueOf(substring.substring(0, 1).toLowerCase());
|
|
String valueOf4 = String.valueOf(substring.substring(1, substring.length() - 3));
|
|
String concat2 = valueOf4.length() != 0 ? valueOf3.concat(valueOf4) : new String(valueOf3);
|
|
Method method3 = (Method) hashMap.get(str);
|
|
if (method3 != null && method3.getReturnType().equals(Map.class) && !method3.isAnnotationPresent(Deprecated.class) && Modifier.isPublic(method3.getModifiers())) {
|
|
Z1(sb, i, O1(concat2), u4.q(method3, c6Var, new Object[0]));
|
|
}
|
|
}
|
|
if (((Method) hashMap2.get(substring.length() != 0 ? "set".concat(substring) : new String("set"))) != null) {
|
|
if (substring.endsWith("Bytes")) {
|
|
String valueOf5 = String.valueOf(substring.substring(0, substring.length() - 5));
|
|
if (!hashMap.containsKey(valueOf5.length() != 0 ? "get".concat(valueOf5) : new String("get"))) {
|
|
}
|
|
}
|
|
String valueOf6 = String.valueOf(substring.substring(0, 1).toLowerCase());
|
|
String valueOf7 = String.valueOf(substring.substring(1));
|
|
String concat3 = valueOf7.length() != 0 ? valueOf6.concat(valueOf7) : new String(valueOf6);
|
|
Method method4 = (Method) hashMap.get(substring.length() != 0 ? "get".concat(substring) : new String("get"));
|
|
Method method5 = (Method) hashMap.get(substring.length() != 0 ? "has".concat(substring) : new String("has"));
|
|
if (method4 != null) {
|
|
Object q = u4.q(method4, c6Var, new Object[0]);
|
|
if (method5 == null) {
|
|
if (!(q instanceof Boolean)) {
|
|
if (!(q instanceof Integer)) {
|
|
if (!(q instanceof Float)) {
|
|
if (!(q instanceof Double)) {
|
|
if (q instanceof String) {
|
|
z2 = q.equals("");
|
|
} else if (q instanceof t3) {
|
|
z2 = q.equals(t3.j);
|
|
} else {
|
|
z2 = !(q instanceof c6) ? false : false;
|
|
}
|
|
if (z2) {
|
|
z3 = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
z2 = true;
|
|
if (z2) {
|
|
}
|
|
} else {
|
|
z3 = ((Boolean) u4.q(method5, c6Var, new Object[0])).booleanValue();
|
|
}
|
|
if (z3) {
|
|
Z1(sb, i, O1(concat3), q);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (c6Var instanceof u4.d) {
|
|
Iterator<Map.Entry<u4.c, Object>> l = ((u4.d) c6Var).zzc.l();
|
|
if (l.hasNext()) {
|
|
l.next().getKey();
|
|
throw new NoSuchMethodError();
|
|
}
|
|
}
|
|
c7 c7Var = ((u4) c6Var).zzb;
|
|
if (c7Var != null) {
|
|
for (int i2 = 0; i2 < c7Var.f1423b; i2++) {
|
|
Z1(sb, i, String.valueOf(c7Var.c[i2] >>> 3), c7Var.d[i2]);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static final FloatBuffer W(int i) {
|
|
ByteBuffer order = ByteBuffer.allocateDirect(i * 4 * 1).order(ByteOrder.nativeOrder());
|
|
order.limit(order.capacity());
|
|
m.checkNotNullExpressionValue(order, "ByteBuffer\n .allo…it.limit(it.capacity()) }");
|
|
FloatBuffer asFloatBuffer = order.asFloatBuffer();
|
|
m.checkNotNullExpressionValue(asFloatBuffer, "byteBuffer(size * Egloo.…OF_FLOAT).asFloatBuffer()");
|
|
return asFloatBuffer;
|
|
}
|
|
|
|
public static final int W0(u uVar, int i) {
|
|
int i2;
|
|
m.checkParameterIsNotNull(uVar, "$this$segment");
|
|
int[] iArr = uVar.o;
|
|
int i3 = i + 1;
|
|
int length = uVar.n.length;
|
|
m.checkParameterIsNotNull(iArr, "$this$binarySearch");
|
|
int i4 = length - 1;
|
|
int i5 = 0;
|
|
while (true) {
|
|
if (i5 <= i4) {
|
|
i2 = (i5 + i4) >>> 1;
|
|
int i6 = iArr[i2];
|
|
if (i6 >= i3) {
|
|
if (i6 <= i3) {
|
|
break;
|
|
}
|
|
i4 = i2 - 1;
|
|
} else {
|
|
i5 = i2 + 1;
|
|
}
|
|
} else {
|
|
i2 = (-i5) - 1;
|
|
break;
|
|
}
|
|
}
|
|
return i2 >= 0 ? i2 : ~i2;
|
|
}
|
|
|
|
public static void W1(q3 q3Var, SQLiteDatabase sQLiteDatabase) {
|
|
if (q3Var != null) {
|
|
File file = new File(sQLiteDatabase.getPath());
|
|
if (!file.setReadable(false, false)) {
|
|
q3Var.i.a("Failed to turn off database read permission");
|
|
}
|
|
if (!file.setWritable(false, false)) {
|
|
q3Var.i.a("Failed to turn off database write permission");
|
|
}
|
|
if (!file.setReadable(true, true)) {
|
|
q3Var.i.a("Failed to turn on database read permission for owner");
|
|
}
|
|
if (!file.setWritable(true, true)) {
|
|
q3Var.i.a("Failed to turn on database write permission for owner");
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
throw new IllegalArgumentException("Monitor must not be null");
|
|
}
|
|
|
|
@NonNull
|
|
public static <TResult> Task<TResult> X(@NonNull Exception exc) {
|
|
b0 b0Var = new b0();
|
|
b0Var.s(exc);
|
|
return b0Var;
|
|
}
|
|
|
|
public static final g0.v X0(Socket socket) throws IOException {
|
|
m.checkParameterIsNotNull(socket, "$this$sink");
|
|
g0.w wVar = new g0.w(socket);
|
|
OutputStream outputStream = socket.getOutputStream();
|
|
m.checkExpressionValueIsNotNull(outputStream, "getOutputStream()");
|
|
p pVar = new p(outputStream, wVar);
|
|
m.checkParameterIsNotNull(pVar, "sink");
|
|
return new g0.c(wVar, pVar);
|
|
}
|
|
|
|
@WorkerThread
|
|
public static void X1(q3 q3Var, SQLiteDatabase sQLiteDatabase, String str, String str2, String str3, String[] strArr) throws SQLiteException {
|
|
boolean z2;
|
|
if (q3Var != null) {
|
|
Cursor cursor = null;
|
|
try {
|
|
cursor = sQLiteDatabase.query("SQLITE_MASTER", new String[]{ModelAuditLogEntry.CHANGE_KEY_NAME}, "name=?", new String[]{str}, null, null, null);
|
|
z2 = cursor.moveToFirst();
|
|
cursor.close();
|
|
} catch (SQLiteException e2) {
|
|
q3Var.i.c("Error querying for table", str, e2);
|
|
if (cursor != null) {
|
|
cursor.close();
|
|
}
|
|
z2 = false;
|
|
} catch (Throwable th) {
|
|
if (cursor != null) {
|
|
cursor.close();
|
|
}
|
|
throw th;
|
|
}
|
|
if (!z2) {
|
|
sQLiteDatabase.execSQL(str2);
|
|
}
|
|
try {
|
|
Set<String> Q1 = Q1(sQLiteDatabase, str);
|
|
String[] split = str3.split(",");
|
|
for (String str4 : split) {
|
|
if (!((HashSet) Q1).remove(str4)) {
|
|
StringBuilder sb = new StringBuilder(str.length() + 35 + String.valueOf(str4).length());
|
|
sb.append("Table ");
|
|
sb.append(str);
|
|
sb.append(" is missing required column: ");
|
|
sb.append(str4);
|
|
throw new SQLiteException(sb.toString());
|
|
}
|
|
}
|
|
if (strArr != null) {
|
|
for (int i = 0; i < strArr.length; i += 2) {
|
|
if (!((HashSet) Q1).remove(strArr[i])) {
|
|
sQLiteDatabase.execSQL(strArr[i + 1]);
|
|
}
|
|
}
|
|
}
|
|
if (!((HashSet) Q1).isEmpty()) {
|
|
q3Var.i.c("Table has extra columns. table, columns", str, TextUtils.join(", ", Q1));
|
|
}
|
|
} catch (SQLiteException e3) {
|
|
q3Var.f.b("Failed to verify columns on table that was just created", str);
|
|
throw e3;
|
|
}
|
|
} else {
|
|
throw new IllegalArgumentException("Monitor must not be null");
|
|
}
|
|
}
|
|
|
|
@NonNull
|
|
public static <TResult> Task<TResult> Y(TResult tresult) {
|
|
b0 b0Var = new b0();
|
|
b0Var.t(tresult);
|
|
return b0Var;
|
|
}
|
|
|
|
public static int Y0(int i) {
|
|
return (int) (((long) Integer.rotateLeft((int) (((long) i) * -862048943), 15)) * 461845907);
|
|
}
|
|
|
|
public static <T> void Y1(Task<T> task, h<? super T> hVar) {
|
|
Executor executor = b.i.a.f.n.g.f1578b;
|
|
task.g(executor, hVar);
|
|
task.e(executor, hVar);
|
|
task.a(executor, hVar);
|
|
}
|
|
|
|
public static final String Z(long j) {
|
|
String str;
|
|
if (j <= ((long) -999500000)) {
|
|
str = ((j - ((long) 500000000)) / ((long) 1000000000)) + " s ";
|
|
} else if (j <= ((long) -999500)) {
|
|
str = ((j - ((long) 500000)) / ((long) 1000000)) + " ms";
|
|
} else if (j <= 0) {
|
|
str = ((j - ((long) 500)) / ((long) 1000)) + " µs";
|
|
} else if (j < ((long) 999500)) {
|
|
str = ((j + ((long) 500)) / ((long) 1000)) + " µs";
|
|
} else if (j < ((long) 999500000)) {
|
|
str = ((j + ((long) 500000)) / ((long) 1000000)) + " ms";
|
|
} else {
|
|
str = ((j + ((long) 500000000)) / ((long) 1000000000)) + " s ";
|
|
}
|
|
String format = String.format("%6s", Arrays.copyOf(new Object[]{str}, 1));
|
|
m.checkExpressionValueIsNotNull(format, "java.lang.String.format(format, *args)");
|
|
return format;
|
|
}
|
|
|
|
public static final x Z0(Socket socket) throws IOException {
|
|
m.checkParameterIsNotNull(socket, "$this$source");
|
|
g0.w wVar = new g0.w(socket);
|
|
InputStream inputStream = socket.getInputStream();
|
|
m.checkExpressionValueIsNotNull(inputStream, "getInputStream()");
|
|
n nVar = new n(inputStream, wVar);
|
|
m.checkParameterIsNotNull(nVar, "source");
|
|
return new g0.d(wVar, nVar);
|
|
}
|
|
|
|
public static final void Z1(StringBuilder sb, int i, String str, Object obj) {
|
|
if (obj instanceof List) {
|
|
for (Object obj2 : (List) obj) {
|
|
Z1(sb, i, str, obj2);
|
|
}
|
|
} else if (obj instanceof Map) {
|
|
for (Map.Entry entry : ((Map) obj).entrySet()) {
|
|
Z1(sb, i, str, entry);
|
|
}
|
|
} else {
|
|
sb.append('\n');
|
|
int i2 = 0;
|
|
for (int i3 = 0; i3 < i; i3++) {
|
|
sb.append(' ');
|
|
}
|
|
sb.append(str);
|
|
if (obj instanceof String) {
|
|
sb.append(": \"");
|
|
t3 t3Var = t3.j;
|
|
sb.append(N1(new z3(((String) obj).getBytes(w4.a))));
|
|
sb.append('\"');
|
|
} else if (obj instanceof t3) {
|
|
sb.append(": \"");
|
|
sb.append(N1((t3) obj));
|
|
sb.append('\"');
|
|
} else if (obj instanceof u4) {
|
|
sb.append(" {");
|
|
V1((u4) obj, sb, i + 2);
|
|
sb.append("\n");
|
|
while (i2 < i) {
|
|
sb.append(' ');
|
|
i2++;
|
|
}
|
|
sb.append("}");
|
|
} else if (obj instanceof Map.Entry) {
|
|
sb.append(" {");
|
|
Map.Entry entry2 = (Map.Entry) obj;
|
|
int i4 = i + 2;
|
|
Z1(sb, i4, "key", entry2.getKey());
|
|
Z1(sb, i4, "value", entry2.getValue());
|
|
sb.append("\n");
|
|
while (i2 < i) {
|
|
sb.append(' ');
|
|
i2++;
|
|
}
|
|
sb.append("}");
|
|
} else {
|
|
sb.append(": ");
|
|
sb.append(obj.toString());
|
|
}
|
|
}
|
|
}
|
|
|
|
public static final CancellationException a(String str, Throwable th) {
|
|
CancellationException cancellationException = new CancellationException(str);
|
|
cancellationException.initCause(th);
|
|
return cancellationException;
|
|
}
|
|
|
|
public static b.i.c.l.d<?> a0(String str, b.i.c.x.g<Context> gVar) {
|
|
d.b a2 = b.i.c.l.d.a(b.i.c.x.e.class);
|
|
a2.d = 1;
|
|
a2.a(new b.i.c.l.o(Context.class, 1, 0));
|
|
a2.c(new b.i.c.x.f(str, gVar));
|
|
return a2.b();
|
|
}
|
|
|
|
public static final void a1(Continuation<? super Unit> continuation, Continuation<?> continuation2) {
|
|
try {
|
|
Continuation intercepted = d0.w.h.b.intercepted(continuation);
|
|
k.a aVar = k.j;
|
|
s.a.a.h.b(intercepted, k.m72constructorimpl(Unit.a), null, 2);
|
|
} catch (Throwable th) {
|
|
k.a aVar2 = k.j;
|
|
((s.a.b) continuation2).resumeWith(k.m72constructorimpl(d0.l.createFailure(th)));
|
|
}
|
|
}
|
|
|
|
public static boolean a2(byte b2) {
|
|
return b2 >= 0;
|
|
}
|
|
|
|
public static s.a.b2.f b(int i, s.a.b2.e eVar, Function1 function1, int i2) {
|
|
s.a.b2.e eVar2 = s.a.b2.e.SUSPEND;
|
|
boolean z2 = false;
|
|
if ((i2 & 1) != 0) {
|
|
i = 0;
|
|
}
|
|
if ((i2 & 2) != 0) {
|
|
eVar = eVar2;
|
|
}
|
|
int i3 = i2 & 4;
|
|
int i4 = 1;
|
|
if (i == -2) {
|
|
if (eVar == eVar2) {
|
|
Objects.requireNonNull(s.a.b2.f.i);
|
|
i4 = f.a.a;
|
|
}
|
|
return new s.a.b2.d(i4, eVar, null);
|
|
} else if (i != -1) {
|
|
return i != 0 ? i != Integer.MAX_VALUE ? (i == 1 && eVar == s.a.b2.e.DROP_OLDEST) ? new s.a.b2.j(null) : new s.a.b2.d(i, eVar, null) : new s.a.b2.k(null) : eVar == eVar2 ? new q(null) : new s.a.b2.d(1, eVar, null);
|
|
} else {
|
|
if (eVar == eVar2) {
|
|
z2 = true;
|
|
}
|
|
if (z2) {
|
|
return new s.a.b2.j(null);
|
|
}
|
|
throw new IllegalArgumentException("CONFLATED capacity cannot be used with non-default onBufferOverflow".toString());
|
|
}
|
|
}
|
|
|
|
public static float[] b0(RectF rectF) {
|
|
return new float[]{rectF.centerX(), rectF.centerY()};
|
|
}
|
|
|
|
public static void b1(Function2 function2, Object obj, Continuation continuation, Function1 function1, int i) {
|
|
int i2 = i & 4;
|
|
try {
|
|
Continuation intercepted = d0.w.h.b.intercepted(d0.w.h.b.createCoroutineUnintercepted(function2, obj, continuation));
|
|
k.a aVar = k.j;
|
|
s.a.a.h.a(intercepted, k.m72constructorimpl(Unit.a), null);
|
|
} catch (Throwable th) {
|
|
k.a aVar2 = k.j;
|
|
continuation.resumeWith(k.m72constructorimpl(d0.l.createFailure(th)));
|
|
}
|
|
}
|
|
|
|
public static boolean b2(@NullableDecl Object obj, @NullableDecl Object obj2) {
|
|
if (obj != obj2) {
|
|
return obj != null && obj.equals(obj2);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static final CoroutineScope c(CoroutineContext coroutineContext) {
|
|
if (coroutineContext.get(Job.h) == null) {
|
|
coroutineContext = coroutineContext.plus(new f1(null));
|
|
}
|
|
return new s.a.a.f(coroutineContext);
|
|
}
|
|
|
|
public static final String c0(Object obj) {
|
|
return obj.getClass().getSimpleName();
|
|
}
|
|
|
|
public static final <T, R> Object c1(r<? super T> rVar, R r, Function2<? super R, ? super Continuation<? super T>, ? extends Object> function2) {
|
|
Object obj;
|
|
rVar.f0();
|
|
if (function2 != null) {
|
|
try {
|
|
obj = ((Function2) e0.beforeCheckcastToFunctionOfArity(function2, 2)).invoke(r, rVar);
|
|
} catch (Throwable th) {
|
|
obj = new w(th, false, 2);
|
|
}
|
|
if (obj == d0.w.h.c.getCOROUTINE_SUSPENDED()) {
|
|
return d0.w.h.c.getCOROUTINE_SUSPENDED();
|
|
}
|
|
Object R = rVar.R(obj);
|
|
if (R == i1.f3798b) {
|
|
return d0.w.h.c.getCOROUTINE_SUSPENDED();
|
|
}
|
|
if (!(R instanceof w)) {
|
|
return i1.a(R);
|
|
}
|
|
throw ((w) R).f3804b;
|
|
}
|
|
throw new NullPointerException("null cannot be cast to non-null type (R, kotlin.coroutines.Continuation<T>) -> kotlin.Any?");
|
|
}
|
|
|
|
public static String c2(String str, Object... objArr) {
|
|
int length;
|
|
int length2;
|
|
int indexOf;
|
|
String str2;
|
|
int i = 0;
|
|
int i2 = 0;
|
|
while (true) {
|
|
length = objArr.length;
|
|
if (i2 >= length) {
|
|
break;
|
|
}
|
|
Object obj = objArr[i2];
|
|
if (obj == null) {
|
|
str2 = "null";
|
|
} else {
|
|
try {
|
|
str2 = obj.toString();
|
|
} catch (Exception e2) {
|
|
String name = obj.getClass().getName();
|
|
String hexString = Integer.toHexString(System.identityHashCode(obj));
|
|
StringBuilder sb = new StringBuilder(name.length() + 1 + String.valueOf(hexString).length());
|
|
sb.append(name);
|
|
sb.append(MentionUtilsKt.MENTIONS_CHAR);
|
|
sb.append(hexString);
|
|
String sb2 = sb.toString();
|
|
Logger logger = Logger.getLogger("com.google.common.base.Strings");
|
|
Level level = Level.WARNING;
|
|
String valueOf = String.valueOf(sb2);
|
|
logger.logp(level, "com.google.common.base.Strings", "lenientToString", valueOf.length() != 0 ? "Exception during lenientFormat for ".concat(valueOf) : new String("Exception during lenientFormat for "), (Throwable) e2);
|
|
String name2 = e2.getClass().getName();
|
|
StringBuilder sb3 = new StringBuilder(String.valueOf(sb2).length() + 9 + name2.length());
|
|
b.d.b.a.a.q0(sb3, "<", sb2, " threw ", name2);
|
|
sb3.append(">");
|
|
str2 = sb3.toString();
|
|
}
|
|
}
|
|
objArr[i2] = str2;
|
|
i2++;
|
|
}
|
|
StringBuilder sb4 = new StringBuilder((length * 16) + str.length());
|
|
int i3 = 0;
|
|
while (true) {
|
|
length2 = objArr.length;
|
|
if (i >= length2 || (indexOf = str.indexOf("%s", i3)) == -1) {
|
|
break;
|
|
}
|
|
sb4.append((CharSequence) str, i3, indexOf);
|
|
sb4.append(objArr[i]);
|
|
i3 = indexOf + 2;
|
|
i++;
|
|
}
|
|
sb4.append((CharSequence) str, i3, str.length());
|
|
if (i < length2) {
|
|
sb4.append(" [");
|
|
sb4.append(objArr[i]);
|
|
for (int i4 = i + 1; i4 < objArr.length; i4++) {
|
|
sb4.append(", ");
|
|
sb4.append(objArr[i4]);
|
|
}
|
|
sb4.append(']');
|
|
}
|
|
return sb4.toString();
|
|
}
|
|
|
|
public static s.a.u d(Job job, int i) {
|
|
int i2 = i & 1;
|
|
return new t1(null);
|
|
}
|
|
|
|
public static float[] d0(RectF rectF) {
|
|
float f = rectF.left;
|
|
float f2 = rectF.top;
|
|
float f3 = rectF.right;
|
|
float f4 = rectF.bottom;
|
|
return new float[]{f, f2, f3, f2, f3, f4, f, f4};
|
|
}
|
|
|
|
public static int d1(int[] iArr) {
|
|
int i = 0;
|
|
for (int i2 : iArr) {
|
|
i += i2;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
public static boolean d2(Object obj, Object obj2) {
|
|
return obj == obj2 || (obj != null && obj.equals(obj2));
|
|
}
|
|
|
|
public static final void e(f0.e0.f.a aVar, f0.e0.f.c cVar, String str) {
|
|
d.b bVar = f0.e0.f.d.c;
|
|
Logger logger = f0.e0.f.d.f3570b;
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append(cVar.f);
|
|
sb.append(' ');
|
|
String format = String.format("%-22s", Arrays.copyOf(new Object[]{str}, 1));
|
|
m.checkExpressionValueIsNotNull(format, "java.lang.String.format(format, *args)");
|
|
sb.append(format);
|
|
sb.append(": ");
|
|
sb.append(aVar.c);
|
|
logger.fine(sb.toString());
|
|
}
|
|
|
|
public static String e0(long j) {
|
|
return f0(j, null);
|
|
}
|
|
|
|
public static final long e1(String str, long j, long j2, long j3) {
|
|
String f1 = f1(str);
|
|
if (f1 == null) {
|
|
return j;
|
|
}
|
|
Long longOrNull = d0.g0.s.toLongOrNull(f1);
|
|
if (longOrNull != null) {
|
|
long longValue = longOrNull.longValue();
|
|
if (j2 <= longValue && j3 >= longValue) {
|
|
return longValue;
|
|
}
|
|
throw new IllegalStateException(("System property '" + str + "' should be in range " + j2 + ".." + j3 + ", but is '" + longValue + '\'').toString());
|
|
}
|
|
throw new IllegalStateException(("System property '" + str + "' has unrecognized value '" + f1 + '\'').toString());
|
|
}
|
|
|
|
public static int e2(byte[] bArr, int i, s3 s3Var) {
|
|
int i2 = i + 1;
|
|
long j = (long) bArr[i];
|
|
if (j >= 0) {
|
|
s3Var.f1478b = j;
|
|
return i2;
|
|
}
|
|
int i3 = i2 + 1;
|
|
byte b2 = bArr[i2];
|
|
long j2 = (j & 127) | (((long) (b2 & Byte.MAX_VALUE)) << 7);
|
|
int i4 = 7;
|
|
while (b2 < 0) {
|
|
int i5 = i3 + 1;
|
|
byte b3 = bArr[i3];
|
|
i4 += 7;
|
|
j2 |= ((long) (b3 & Byte.MAX_VALUE)) << i4;
|
|
b2 = b3;
|
|
i3 = i5;
|
|
}
|
|
s3Var.f1478b = j2;
|
|
return i3;
|
|
}
|
|
|
|
@NonNull
|
|
public static b.o.a.x.c f(b.o.a.x.c... cVarArr) {
|
|
return new i(cVarArr, null);
|
|
}
|
|
|
|
public static String f0(long j, @Nullable SimpleDateFormat simpleDateFormat) {
|
|
Calendar h = b.i.a.g.d.l.h();
|
|
Calendar i = b.i.a.g.d.l.i();
|
|
i.setTimeInMillis(j);
|
|
return simpleDateFormat != null ? simpleDateFormat.format(new Date(j)) : h.get(1) == i.get(1) ? l0(j, Locale.getDefault()) : q0(j, Locale.getDefault());
|
|
}
|
|
|
|
public static final String f1(String str) {
|
|
int i = s.a.a.u.a;
|
|
try {
|
|
return System.getProperty(str);
|
|
} catch (SecurityException unused) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static long f2(byte[] bArr, int i) {
|
|
return ((((long) bArr[i + 7]) & 255) << 56) | (((long) bArr[i]) & 255) | ((((long) bArr[i + 1]) & 255) << 8) | ((((long) bArr[i + 2]) & 255) << 16) | ((((long) bArr[i + 3]) & 255) << 24) | ((((long) bArr[i + 4]) & 255) << 32) | ((((long) bArr[i + 5]) & 255) << 40) | ((((long) bArr[i + 6]) & 255) << 48);
|
|
}
|
|
|
|
public static final boolean g(byte[] bArr, int i, byte[] bArr2, int i2, int i3) {
|
|
m.checkParameterIsNotNull(bArr, "a");
|
|
m.checkParameterIsNotNull(bArr2, "b");
|
|
for (int i4 = 0; i4 < i3; i4++) {
|
|
if (bArr[i4 + i] != bArr2[i4 + i2]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static final h0 g0(CoroutineContext coroutineContext) {
|
|
int i = d0.w.d.e;
|
|
CoroutineContext.Element element = coroutineContext.get(d.b.a);
|
|
if (!(element instanceof h0)) {
|
|
element = null;
|
|
}
|
|
h0 h0Var = (h0) element;
|
|
return h0Var != null ? h0Var : s.a.e0.a;
|
|
}
|
|
|
|
public static int g1(String str, int i, int i2, int i3, int i4, Object obj) {
|
|
if ((i4 & 4) != 0) {
|
|
i2 = 1;
|
|
}
|
|
if ((i4 & 8) != 0) {
|
|
i3 = Integer.MAX_VALUE;
|
|
}
|
|
return (int) e1(str, (long) i, (long) i2, (long) i3);
|
|
}
|
|
|
|
public static void g2(boolean z2, @NullableDecl Object obj) {
|
|
if (!z2) {
|
|
throw new IllegalStateException(String.valueOf(obj));
|
|
}
|
|
}
|
|
|
|
public static f0 h(CoroutineScope coroutineScope, CoroutineContext coroutineContext, CoroutineStart coroutineStart, Function2 function2, int i, Object obj) {
|
|
CoroutineStart coroutineStart2 = null;
|
|
d0.w.f fVar = (i & 1) != 0 ? d0.w.f.j : null;
|
|
if ((i & 2) != 0) {
|
|
coroutineStart2 = CoroutineStart.DEFAULT;
|
|
}
|
|
CoroutineContext a2 = z.a(coroutineScope, fVar);
|
|
Objects.requireNonNull(coroutineStart2);
|
|
g0 j1Var = coroutineStart2 == CoroutineStart.LAZY ? new j1(a2, function2) : new g0(a2, true);
|
|
j1Var.j0(coroutineStart2, j1Var, function2);
|
|
return j1Var;
|
|
}
|
|
|
|
public static final int h0(b.p.a.b bVar, @DimenRes int i) {
|
|
m.checkNotNullParameter(bVar, "$this$getDimenPixelSize");
|
|
return bVar.getResources().getDimensionPixelSize(i);
|
|
}
|
|
|
|
public static /* synthetic */ long h1(String str, long j, long j2, long j3, int i, Object obj) {
|
|
if ((i & 4) != 0) {
|
|
j2 = 1;
|
|
}
|
|
if ((i & 8) != 0) {
|
|
j3 = RecyclerView.FOREVER_NS;
|
|
}
|
|
return e1(str, j, j2, j3);
|
|
}
|
|
|
|
public static int h2(byte[] bArr, int i, s3 s3Var) throws zzij {
|
|
int F1 = F1(bArr, i, s3Var);
|
|
int i2 = s3Var.a;
|
|
if (i2 < 0) {
|
|
throw zzij.b();
|
|
} else if (i2 == 0) {
|
|
s3Var.c = "";
|
|
return F1;
|
|
} else {
|
|
s3Var.c = new String(bArr, F1, i2, w4.a);
|
|
return F1 + i2;
|
|
}
|
|
}
|
|
|
|
public static <TResult> TResult i(@NonNull Task<TResult> task) throws ExecutionException, InterruptedException {
|
|
b.c.a.a0.d.x("Must not be called on the main application thread");
|
|
b.c.a.a0.d.z(task, "Task must not be null");
|
|
if (task.o()) {
|
|
return (TResult) L1(task);
|
|
}
|
|
b.i.a.f.n.i iVar = new b.i.a.f.n.i(null);
|
|
Y1(task, iVar);
|
|
iVar.a.await();
|
|
return (TResult) L1(task);
|
|
}
|
|
|
|
@NullableDecl
|
|
public static <T> T i0(Iterable<? extends T> iterable, @NullableDecl T t) {
|
|
n0 n0Var = new n0((h.a) iterable);
|
|
return n0Var.hasNext() ? (T) n0Var.next() : t;
|
|
}
|
|
|
|
public static int[] i1(Collection<? extends Number> collection) {
|
|
if (collection instanceof b.i.b.c.a) {
|
|
b.i.b.c.a aVar = (b.i.b.c.a) collection;
|
|
return Arrays.copyOfRange(aVar.array, aVar.start, aVar.end);
|
|
}
|
|
Object[] array = collection.toArray();
|
|
int length = array.length;
|
|
int[] iArr = new int[length];
|
|
for (int i = 0; i < length; i++) {
|
|
Object obj = array[i];
|
|
Objects.requireNonNull(obj);
|
|
iArr[i] = ((Number) obj).intValue();
|
|
}
|
|
return iArr;
|
|
}
|
|
|
|
public static void i2(int i, int i2, int i3) {
|
|
if (i < 0 || i2 < i || i2 > i3) {
|
|
throw new IndexOutOfBoundsException((i < 0 || i > i3) ? k2(i, i3, "start index") : (i2 < 0 || i2 > i3) ? k2(i2, i3, "end index") : c2("end index (%s) must not be less than start index (%s)", Integer.valueOf(i2), Integer.valueOf(i)));
|
|
}
|
|
}
|
|
|
|
public static <TResult> TResult j(@NonNull Task<TResult> task, long j, @NonNull TimeUnit timeUnit) throws ExecutionException, InterruptedException, TimeoutException {
|
|
b.c.a.a0.d.x("Must not be called on the main application thread");
|
|
b.c.a.a0.d.z(task, "Task must not be null");
|
|
b.c.a.a0.d.z(timeUnit, "TimeUnit must not be null");
|
|
if (task.o()) {
|
|
return (TResult) L1(task);
|
|
}
|
|
b.i.a.f.n.i iVar = new b.i.a.f.n.i(null);
|
|
Y1(task, iVar);
|
|
if (iVar.a.await(j, timeUnit)) {
|
|
return (TResult) L1(task);
|
|
}
|
|
throw new TimeoutException("Timed out waiting for Task");
|
|
}
|
|
|
|
public static final String j0(Object obj) {
|
|
return Integer.toHexString(System.identityHashCode(obj));
|
|
}
|
|
|
|
/* JADX WARNING: Code restructure failed: missing block: B:66:0x010b, code lost:
|
|
r1 = 1;
|
|
*/
|
|
public static final String j1(String str) {
|
|
m.checkParameterIsNotNull(str, "$this$toCanonicalHost");
|
|
int i = 0;
|
|
int i2 = -1;
|
|
if (d0.g0.w.contains$default((CharSequence) str, (CharSequence) ":", false, 2, (Object) null)) {
|
|
InetAddress N = (!t.startsWith$default(str, "[", false, 2, null) || !t.endsWith$default(str, "]", false, 2, null)) ? N(str, 0, str.length()) : N(str, 1, str.length() - 1);
|
|
if (N == null) {
|
|
return null;
|
|
}
|
|
byte[] address = N.getAddress();
|
|
if (address.length == 16) {
|
|
m.checkExpressionValueIsNotNull(address, "address");
|
|
int i3 = 0;
|
|
int i4 = 0;
|
|
while (i3 < address.length) {
|
|
int i5 = i3;
|
|
while (i5 < 16 && address[i5] == 0 && address[i5 + 1] == 0) {
|
|
i5 += 2;
|
|
}
|
|
int i6 = i5 - i3;
|
|
if (i6 > i4 && i6 >= 4) {
|
|
i2 = i3;
|
|
i4 = i6;
|
|
}
|
|
i3 = i5 + 2;
|
|
}
|
|
g0.e eVar = new g0.e();
|
|
while (i < address.length) {
|
|
if (i == i2) {
|
|
eVar.T(58);
|
|
i += i4;
|
|
if (i == 16) {
|
|
eVar.T(58);
|
|
}
|
|
} else {
|
|
if (i > 0) {
|
|
eVar.T(58);
|
|
}
|
|
byte b2 = address[i];
|
|
byte[] bArr = f0.e0.c.a;
|
|
eVar.Q((long) (((b2 & 255) << 8) | (address[i + 1] & 255)));
|
|
i += 2;
|
|
}
|
|
}
|
|
return eVar.D();
|
|
} else if (address.length == 4) {
|
|
return N.getHostAddress();
|
|
} else {
|
|
throw new AssertionError("Invalid IPv6 address: '" + str + '\'');
|
|
}
|
|
} else {
|
|
try {
|
|
String ascii = IDN.toASCII(str);
|
|
m.checkExpressionValueIsNotNull(ascii, "IDN.toASCII(host)");
|
|
Locale locale = Locale.US;
|
|
m.checkExpressionValueIsNotNull(locale, "Locale.US");
|
|
if (ascii != null) {
|
|
String lowerCase = ascii.toLowerCase(locale);
|
|
m.checkExpressionValueIsNotNull(lowerCase, "(this as java.lang.String).toLowerCase(locale)");
|
|
if (lowerCase.length() == 0) {
|
|
return null;
|
|
}
|
|
int length = lowerCase.length();
|
|
int i7 = 0;
|
|
while (true) {
|
|
if (i7 >= length) {
|
|
break;
|
|
}
|
|
char charAt = lowerCase.charAt(i7);
|
|
if (charAt <= 31) {
|
|
break;
|
|
} else if (charAt >= 127) {
|
|
break;
|
|
} else if (d0.g0.w.indexOf$default((CharSequence) " #%/:?@[\\]", charAt, 0, false, 6, (Object) null) != -1) {
|
|
break;
|
|
} else {
|
|
i7++;
|
|
}
|
|
}
|
|
if (i != 0) {
|
|
return null;
|
|
}
|
|
return lowerCase;
|
|
}
|
|
throw new TypeCastException("null cannot be cast to non-null type java.lang.String");
|
|
} catch (IllegalArgumentException unused) {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static int j2(byte[] bArr, int i, s3 s3Var) throws zzij {
|
|
int F1 = F1(bArr, i, s3Var);
|
|
int i2 = s3Var.a;
|
|
if (i2 < 0) {
|
|
throw zzij.b();
|
|
} else if (i2 == 0) {
|
|
s3Var.c = "";
|
|
return F1;
|
|
} else {
|
|
s3Var.c = k7.a.c(bArr, F1, i2);
|
|
return F1 + i2;
|
|
}
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:12:0x0036 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:8:0x0023 */
|
|
public static final <T> Object k(f0<? extends T>[] f0VarArr, Continuation<? super List<? extends T>> continuation) {
|
|
e eVar;
|
|
int i;
|
|
if (continuation instanceof e) {
|
|
eVar = (e) continuation;
|
|
int i2 = eVar.label;
|
|
if ((i2 & Integer.MIN_VALUE) != 0) {
|
|
eVar.label = i2 - Integer.MIN_VALUE;
|
|
Object obj = eVar.result;
|
|
Object coroutine_suspended = d0.w.h.c.getCOROUTINE_SUSPENDED();
|
|
i = eVar.label;
|
|
if (i != 0) {
|
|
d0.l.throwOnFailure(obj);
|
|
if (f0VarArr.length == 0) {
|
|
return d0.t.n.emptyList();
|
|
}
|
|
s.a.d dVar = new s.a.d(f0VarArr);
|
|
eVar.L$0 = f0VarArr;
|
|
eVar.label = 1;
|
|
l lVar = new l(d0.w.h.b.intercepted(eVar), 1);
|
|
lVar.A();
|
|
int length = f0VarArr.length;
|
|
d.a[] aVarArr = new d.a[length];
|
|
for (int i3 = 0; i3 < length; i3++) {
|
|
f0<T> f0Var = dVar.f3794b[d0.w.i.a.b.boxInt(i3).intValue()];
|
|
f0Var.start();
|
|
d.a aVar = new d.a(lVar, f0Var);
|
|
aVar.n = f0Var.u(aVar);
|
|
aVarArr[i3] = aVar;
|
|
}
|
|
d.b bVar = new d.b(dVar, aVarArr);
|
|
for (int i4 = 0; i4 < length; i4++) {
|
|
aVarArr[i4]._disposer = bVar;
|
|
}
|
|
if (lVar.v()) {
|
|
bVar.b();
|
|
} else {
|
|
lVar.f(bVar);
|
|
}
|
|
obj = lVar.u();
|
|
if (obj == d0.w.h.c.getCOROUTINE_SUSPENDED()) {
|
|
g.probeCoroutineSuspended(eVar);
|
|
}
|
|
if (obj == coroutine_suspended) {
|
|
return coroutine_suspended;
|
|
}
|
|
} else if (i == 1) {
|
|
f0[] f0VarArr2 = (f0[]) eVar.L$0;
|
|
d0.l.throwOnFailure(obj);
|
|
} else {
|
|
throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
|
|
}
|
|
return (List) obj;
|
|
}
|
|
}
|
|
eVar = new e(continuation);
|
|
Object obj = eVar.result;
|
|
Object coroutine_suspended = d0.w.h.c.getCOROUTINE_SUSPENDED();
|
|
i = eVar.label;
|
|
if (i != 0) {
|
|
}
|
|
return (List) obj;
|
|
}
|
|
|
|
@TargetApi(17)
|
|
public static int k0() {
|
|
EGLDisplay eglGetDisplay = EGL14.eglGetDisplay(0);
|
|
int[] iArr = new int[2];
|
|
EGL14.eglInitialize(eglGetDisplay, iArr, 0, iArr, 1);
|
|
EGLConfig[] eGLConfigArr = new EGLConfig[1];
|
|
int[] iArr2 = new int[1];
|
|
EGL14.eglChooseConfig(eglGetDisplay, new int[]{12351, 12430, 12329, 0, 12352, 4, 12339, 1, 12344}, 0, eGLConfigArr, 0, 1, iArr2, 0);
|
|
if (iArr2[0] == 0) {
|
|
return 0;
|
|
}
|
|
EGLConfig eGLConfig = eGLConfigArr[0];
|
|
EGLSurface eglCreatePbufferSurface = EGL14.eglCreatePbufferSurface(eglGetDisplay, eGLConfig, new int[]{12375, 64, 12374, 64, 12344}, 0);
|
|
EGLContext eglCreateContext = EGL14.eglCreateContext(eglGetDisplay, eGLConfig, EGL14.EGL_NO_CONTEXT, new int[]{12440, 2, 12344}, 0);
|
|
EGL14.eglMakeCurrent(eglGetDisplay, eglCreatePbufferSurface, eglCreatePbufferSurface, eglCreateContext);
|
|
int[] iArr3 = new int[1];
|
|
GLES20.glGetIntegerv(3379, iArr3, 0);
|
|
EGLSurface eGLSurface = EGL14.EGL_NO_SURFACE;
|
|
EGL14.eglMakeCurrent(eglGetDisplay, eGLSurface, eGLSurface, EGL14.EGL_NO_CONTEXT);
|
|
EGL14.eglDestroySurface(eglGetDisplay, eglCreatePbufferSurface);
|
|
EGL14.eglDestroyContext(eglGetDisplay, eglCreateContext);
|
|
EGL14.eglTerminate(eglGetDisplay);
|
|
return iArr3[0];
|
|
}
|
|
|
|
public static final String k1(Continuation<?> continuation) {
|
|
Object obj;
|
|
if (continuation instanceof s.a.a.g) {
|
|
return continuation.toString();
|
|
}
|
|
try {
|
|
k.a aVar = k.j;
|
|
obj = k.m72constructorimpl(continuation + MentionUtilsKt.MENTIONS_CHAR + j0(continuation));
|
|
} catch (Throwable th) {
|
|
k.a aVar2 = k.j;
|
|
obj = k.m72constructorimpl(d0.l.createFailure(th));
|
|
}
|
|
if (k.m74exceptionOrNullimpl(obj) != null) {
|
|
obj = continuation.getClass().getName() + MentionUtilsKt.MENTIONS_CHAR + j0(continuation);
|
|
}
|
|
return (String) obj;
|
|
}
|
|
|
|
public static String k2(int i, int i2, @NullableDecl String str) {
|
|
if (i < 0) {
|
|
return c2("%s (%s) must not be negative", str, Integer.valueOf(i));
|
|
}
|
|
if (i2 >= 0) {
|
|
return c2("%s (%s) must not be greater than size (%s)", str, Integer.valueOf(i), Integer.valueOf(i2));
|
|
}
|
|
throw new IllegalArgumentException(b.d.b.a.a.f(26, "negative size: ", i2));
|
|
}
|
|
|
|
public static String l(int i, int i2, @NullableDecl String str) {
|
|
if (i < 0) {
|
|
return G0("%s (%s) must not be negative", str, Integer.valueOf(i));
|
|
}
|
|
if (i2 >= 0) {
|
|
return G0("%s (%s) must not be greater than size (%s)", str, Integer.valueOf(i), Integer.valueOf(i2));
|
|
}
|
|
throw new IllegalArgumentException(b.d.b.a.a.p("negative size: ", i2));
|
|
}
|
|
|
|
public static String l0(long j, Locale locale) {
|
|
if (Build.VERSION.SDK_INT >= 24) {
|
|
return b.i.a.g.d.l.c("MMMd", locale).format(new Date(j));
|
|
}
|
|
AtomicReference<b.i.a.g.d.k> atomicReference = b.i.a.g.d.l.a;
|
|
DateFormat dateInstance = DateFormat.getDateInstance(2, locale);
|
|
dateInstance.setTimeZone(b.i.a.g.d.l.g());
|
|
SimpleDateFormat simpleDateFormat = (SimpleDateFormat) dateInstance;
|
|
String pattern = simpleDateFormat.toPattern();
|
|
int b2 = b.i.a.g.d.l.b(pattern, "yY", 1, 0);
|
|
if (b2 < pattern.length()) {
|
|
String str = "EMd";
|
|
int b3 = b.i.a.g.d.l.b(pattern, str, 1, b2);
|
|
if (b3 < pattern.length()) {
|
|
str = "EMd,";
|
|
}
|
|
pattern = pattern.replace(pattern.substring(b.i.a.g.d.l.b(pattern, str, -1, b2) + 1, b3), " ").trim();
|
|
}
|
|
simpleDateFormat.applyPattern(pattern);
|
|
return simpleDateFormat.format(new Date(j));
|
|
}
|
|
|
|
public static final String l1(byte b2) {
|
|
char[] cArr = g0.z.b.a;
|
|
return new String(new char[]{cArr[(b2 >> 4) & 15], cArr[b2 & 15]});
|
|
}
|
|
|
|
public static int l2(byte[] bArr, int i, s3 s3Var) throws zzij {
|
|
int F1 = F1(bArr, i, s3Var);
|
|
int i2 = s3Var.a;
|
|
if (i2 < 0) {
|
|
throw zzij.b();
|
|
} else if (i2 > bArr.length - F1) {
|
|
throw zzij.a();
|
|
} else if (i2 == 0) {
|
|
s3Var.c = t3.j;
|
|
return F1;
|
|
} else {
|
|
s3Var.c = t3.h(bArr, F1, i2);
|
|
return F1 + i2;
|
|
}
|
|
}
|
|
|
|
public static ExecutorService m(String str) {
|
|
ExecutorService unconfigurableExecutorService = Executors.unconfigurableExecutorService(new ThreadPoolExecutor(1, 1, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), new s0(str, new AtomicLong(1)), new ThreadPoolExecutor.DiscardPolicy()));
|
|
Runtime.getRuntime().addShutdownHook(new Thread(new t0(str, unconfigurableExecutorService, 2, TimeUnit.SECONDS), b.d.b.a.a.v("Crashlytics Shutdown Hook for ", str)));
|
|
return unconfigurableExecutorService;
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r4v2, resolved type: java.util.concurrent.atomic.AtomicReferenceFieldUpdater */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public static final <T> l<T> m0(Continuation<? super T> continuation) {
|
|
l<T> lVar;
|
|
l<T> lVar2;
|
|
if (!(continuation instanceof s.a.a.g)) {
|
|
return new l<>(continuation, 2);
|
|
}
|
|
s.a.a.g gVar = (s.a.a.g) continuation;
|
|
while (true) {
|
|
Object obj = gVar._reusableCancellableContinuation;
|
|
lVar = null;
|
|
if (obj == null) {
|
|
gVar._reusableCancellableContinuation = s.a.a.h.f3784b;
|
|
lVar2 = null;
|
|
break;
|
|
} else if (obj instanceof l) {
|
|
if (s.a.a.g.m.compareAndSet(gVar, obj, s.a.a.h.f3784b)) {
|
|
lVar2 = (l) obj;
|
|
break;
|
|
}
|
|
} else {
|
|
throw new IllegalStateException(b.d.b.a.a.u("Inconsistent state ", obj).toString());
|
|
}
|
|
}
|
|
if (lVar2 != null) {
|
|
Object obj2 = lVar2._state;
|
|
boolean z2 = false;
|
|
if (!(obj2 instanceof s.a.v) || ((s.a.v) obj2).d == null) {
|
|
lVar2._decision = 0;
|
|
lVar2._state = s.a.c.j;
|
|
z2 = true;
|
|
} else {
|
|
lVar2.q();
|
|
}
|
|
if (z2) {
|
|
lVar = lVar2;
|
|
}
|
|
if (lVar != null) {
|
|
return lVar;
|
|
}
|
|
}
|
|
return new l<>(continuation, 2);
|
|
}
|
|
|
|
public static String m1(String str) {
|
|
int length = str.length();
|
|
int i = 0;
|
|
while (i < length) {
|
|
char charAt = str.charAt(i);
|
|
if (charAt >= 'A' && charAt <= 'Z') {
|
|
char[] charArray = str.toCharArray();
|
|
while (i < length) {
|
|
char c2 = charArray[i];
|
|
if (c2 >= 'A' && c2 <= 'Z') {
|
|
charArray[i] = (char) (c2 ^ ' ');
|
|
}
|
|
i++;
|
|
}
|
|
return String.valueOf(charArray);
|
|
}
|
|
i++;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
public static boolean m2(byte b2) {
|
|
return b2 > -65;
|
|
}
|
|
|
|
@NonNull
|
|
@Deprecated
|
|
public static <TResult> Task<TResult> n(@NonNull Executor executor, @NonNull Callable<TResult> callable) {
|
|
b.c.a.a0.d.z(executor, "Executor must not be null");
|
|
b.c.a.a0.d.z(callable, "Callback must not be null");
|
|
b0 b0Var = new b0();
|
|
executor.execute(new d0(b0Var, callable));
|
|
return b0Var;
|
|
}
|
|
|
|
public static int n0(int[] iArr, int i, boolean z2) {
|
|
int[] iArr2 = iArr;
|
|
int i2 = 0;
|
|
for (int i3 : iArr2) {
|
|
i2 += i3;
|
|
}
|
|
int length = iArr2.length;
|
|
int i4 = 0;
|
|
int i5 = 0;
|
|
int i6 = 0;
|
|
while (true) {
|
|
int i7 = length - 1;
|
|
if (i4 >= i7) {
|
|
return i5;
|
|
}
|
|
int i8 = 1 << i4;
|
|
i6 |= i8;
|
|
int i9 = 1;
|
|
while (i9 < iArr2[i4]) {
|
|
int i10 = i2 - i9;
|
|
int i11 = length - i4;
|
|
int i12 = i11 - 2;
|
|
int I = I(i10 - 1, i12);
|
|
if (z2 && i6 == 0) {
|
|
int i13 = i11 - 1;
|
|
if (i10 - i13 >= i13) {
|
|
I -= I(i10 - i11, i12);
|
|
}
|
|
}
|
|
if (i11 - 1 > 1) {
|
|
int i14 = 0;
|
|
for (int i15 = i10 - i12; i15 > i; i15--) {
|
|
i14 += I((i10 - i15) - 1, i11 - 3);
|
|
}
|
|
I -= (i7 - i4) * i14;
|
|
} else if (i10 > i) {
|
|
I--;
|
|
}
|
|
i5 += I;
|
|
i9++;
|
|
i6 &= ~i8;
|
|
iArr2 = iArr;
|
|
}
|
|
i2 -= i9;
|
|
i4++;
|
|
iArr2 = iArr;
|
|
}
|
|
}
|
|
|
|
public static final <T> Object n1(Object obj, Function1<? super Throwable, Unit> function1) {
|
|
Throwable r0 = k.m74exceptionOrNullimpl(obj);
|
|
return r0 == null ? function1 != null ? new s.a.x(obj, function1) : obj : new w(r0, false, 2);
|
|
}
|
|
|
|
public static int n2(String str) {
|
|
if (Log.isLoggable("FirebaseAppIndex", 3) ? true : Log.isLoggable("FirebaseAppIndex", 3)) {
|
|
return Log.d("FirebaseAppIndex", str);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static final <E> UndeliveredElementException o(Function1<? super E, Unit> function1, E e2, UndeliveredElementException undeliveredElementException) {
|
|
try {
|
|
function1.invoke(e2);
|
|
} catch (Throwable th) {
|
|
if (undeliveredElementException == null || undeliveredElementException.getCause() == th) {
|
|
return new UndeliveredElementException(b.d.b.a.a.u("Exception in undelivered element handler for ", e2), th);
|
|
}
|
|
d0.b.addSuppressed(undeliveredElementException, th);
|
|
}
|
|
return undeliveredElementException;
|
|
}
|
|
|
|
public static int o0(Context context) {
|
|
Display defaultDisplay = ((WindowManager) context.getSystemService("window")).getDefaultDisplay();
|
|
if (defaultDisplay.getWidth() == defaultDisplay.getHeight()) {
|
|
return 3;
|
|
}
|
|
return defaultDisplay.getWidth() < defaultDisplay.getHeight() ? 1 : 2;
|
|
}
|
|
|
|
public static String o1(String str) {
|
|
int length = str.length();
|
|
int i = 0;
|
|
while (i < length) {
|
|
char charAt = str.charAt(i);
|
|
if (charAt >= 'a' && charAt <= 'z') {
|
|
char[] charArray = str.toCharArray();
|
|
while (i < length) {
|
|
char c2 = charArray[i];
|
|
if (c2 >= 'a' && c2 <= 'z') {
|
|
charArray[i] = (char) (c2 ^ ' ');
|
|
}
|
|
i++;
|
|
}
|
|
return String.valueOf(charArray);
|
|
}
|
|
i++;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
public static /* synthetic */ UndeliveredElementException p(Function1 function1, Object obj, UndeliveredElementException undeliveredElementException, int i) {
|
|
int i2 = i & 2;
|
|
return o(function1, obj, null);
|
|
}
|
|
|
|
public static DateFormat p0(int i, int i2) {
|
|
String str;
|
|
String str2;
|
|
StringBuilder sb = new StringBuilder();
|
|
if (i == 0) {
|
|
str = "EEEE, MMMM d, yyyy";
|
|
} else if (i == 1) {
|
|
str = "MMMM d, yyyy";
|
|
} else if (i == 2) {
|
|
str = "MMM d, yyyy";
|
|
} else if (i == 3) {
|
|
str = "M/d/yy";
|
|
} else {
|
|
throw new IllegalArgumentException(b.d.b.a.a.p("Unknown DateFormat style: ", i));
|
|
}
|
|
sb.append(str);
|
|
sb.append(" ");
|
|
if (i2 == 0 || i2 == 1) {
|
|
str2 = "h:mm:ss a z";
|
|
} else if (i2 == 2) {
|
|
str2 = "h:mm:ss a";
|
|
} else if (i2 == 3) {
|
|
str2 = "h:mm a";
|
|
} else {
|
|
throw new IllegalArgumentException(b.d.b.a.a.p("Unknown DateFormat style: ", i2));
|
|
}
|
|
sb.append(str2);
|
|
return new SimpleDateFormat(sb.toString(), Locale.US);
|
|
}
|
|
|
|
@NonNull
|
|
public static b.o.a.n.o.e p1(@NonNull b.o.a.n.o.e... eVarArr) {
|
|
return new b.o.a.n.o.j(Arrays.asList(eVarArr));
|
|
}
|
|
|
|
public static final void q(CoroutineScope coroutineScope, CancellationException cancellationException) {
|
|
Job job = (Job) coroutineScope.getCoroutineContext().get(Job.h);
|
|
if (job != null) {
|
|
job.b(cancellationException);
|
|
return;
|
|
}
|
|
throw new IllegalStateException(("Scope cannot be cancelled because it does not have a job: " + coroutineScope).toString());
|
|
}
|
|
|
|
public static String q0(long j, Locale locale) {
|
|
if (Build.VERSION.SDK_INT >= 24) {
|
|
return b.i.a.g.d.l.c("yMMMd", locale).format(new Date(j));
|
|
}
|
|
AtomicReference<b.i.a.g.d.k> atomicReference = b.i.a.g.d.l.a;
|
|
DateFormat dateInstance = DateFormat.getDateInstance(2, locale);
|
|
dateInstance.setTimeZone(b.i.a.g.d.l.g());
|
|
return dateInstance.format(new Date(j));
|
|
}
|
|
|
|
public static RectF q1(float[] fArr) {
|
|
RectF rectF = new RectF(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY);
|
|
for (int i = 1; i < fArr.length; i += 2) {
|
|
float round = ((float) Math.round(fArr[i - 1] * 10.0f)) / 10.0f;
|
|
float round2 = ((float) Math.round(fArr[i] * 10.0f)) / 10.0f;
|
|
float f = rectF.left;
|
|
if (round < f) {
|
|
f = round;
|
|
}
|
|
rectF.left = f;
|
|
float f2 = rectF.top;
|
|
if (round2 < f2) {
|
|
f2 = round2;
|
|
}
|
|
rectF.top = f2;
|
|
float f3 = rectF.right;
|
|
if (round <= f3) {
|
|
round = f3;
|
|
}
|
|
rectF.right = round;
|
|
float f4 = rectF.bottom;
|
|
if (round2 <= f4) {
|
|
round2 = f4;
|
|
}
|
|
rectF.bottom = round2;
|
|
}
|
|
rectF.sort();
|
|
return rectF;
|
|
}
|
|
|
|
public static void r(CoroutineContext coroutineContext, CancellationException cancellationException, int i, Object obj) {
|
|
int i2 = i & 1;
|
|
Job job = (Job) coroutineContext.get(Job.h);
|
|
if (job != null) {
|
|
job.b(null);
|
|
}
|
|
}
|
|
|
|
public static void r0(@Nullable InputStream inputStream, @NonNull File file) throws IOException {
|
|
Throwable th;
|
|
byte[] bArr = new byte[8192];
|
|
GZIPOutputStream gZIPOutputStream = null;
|
|
try {
|
|
GZIPOutputStream gZIPOutputStream2 = new GZIPOutputStream(new FileOutputStream(file));
|
|
while (true) {
|
|
try {
|
|
int read = inputStream.read(bArr);
|
|
if (read > 0) {
|
|
gZIPOutputStream2.write(bArr, 0, read);
|
|
} else {
|
|
gZIPOutputStream2.finish();
|
|
b.i.c.m.d.k.h.d(gZIPOutputStream2);
|
|
return;
|
|
}
|
|
} catch (Throwable th2) {
|
|
th = th2;
|
|
gZIPOutputStream = gZIPOutputStream2;
|
|
b.i.c.m.d.k.h.d(gZIPOutputStream);
|
|
throw th;
|
|
}
|
|
}
|
|
} catch (Throwable th3) {
|
|
th = th3;
|
|
b.i.c.m.d.k.h.d(gZIPOutputStream);
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
@RecentlyNonNull
|
|
@TargetApi(19)
|
|
public static boolean r1(@RecentlyNonNull Context context, @RecentlyNonNull int i, @RecentlyNonNull String str) {
|
|
b.i.a.f.e.p.a a2 = b.i.a.f.e.p.b.a(context);
|
|
Objects.requireNonNull(a2);
|
|
try {
|
|
AppOpsManager appOpsManager = (AppOpsManager) a2.a.getSystemService("appops");
|
|
if (appOpsManager != null) {
|
|
appOpsManager.checkPackage(i, str);
|
|
return true;
|
|
}
|
|
throw new NullPointerException("context.getSystemService(Context.APP_OPS_SERVICE) is null");
|
|
} catch (SecurityException unused) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static /* synthetic */ void s(Job job, CancellationException cancellationException, int i, Object obj) {
|
|
int i2 = i & 1;
|
|
job.b(null);
|
|
}
|
|
|
|
public static final void s0(CoroutineContext coroutineContext, Throwable th) {
|
|
try {
|
|
int i = CoroutineExceptionHandler.g;
|
|
CoroutineExceptionHandler coroutineExceptionHandler = (CoroutineExceptionHandler) coroutineContext.get(CoroutineExceptionHandler.a.a);
|
|
if (coroutineExceptionHandler != null) {
|
|
coroutineExceptionHandler.handleException(coroutineContext, th);
|
|
} else {
|
|
s.a.b0.a(coroutineContext, th);
|
|
}
|
|
} catch (Throwable th2) {
|
|
if (th != th2) {
|
|
RuntimeException runtimeException = new RuntimeException("Exception while trying to handle coroutine exception", th2);
|
|
d0.b.addSuppressed(runtimeException, th);
|
|
th = runtimeException;
|
|
}
|
|
s.a.b0.a(coroutineContext, th);
|
|
}
|
|
}
|
|
|
|
@NonNull
|
|
public static Task<Void> s1(@Nullable Collection<? extends Task<?>> collection) {
|
|
if (collection == null || collection.isEmpty()) {
|
|
return Y(null);
|
|
}
|
|
Iterator<? extends Task<?>> it = collection.iterator();
|
|
while (it.hasNext()) {
|
|
Objects.requireNonNull((Task) it.next(), "null tasks are not accepted");
|
|
}
|
|
b0 b0Var = new b0();
|
|
b.i.a.f.n.j jVar = new b.i.a.f.n.j(collection.size(), b0Var);
|
|
Iterator<? extends Task<?>> it2 = collection.iterator();
|
|
while (it2.hasNext()) {
|
|
Y1((Task) it2.next(), jVar);
|
|
}
|
|
return b0Var;
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r0v6, resolved type: java.util.concurrent.CancellationException */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public static final void t(o<?> oVar, Throwable th) {
|
|
CancellationException cancellationException = null;
|
|
if (th != null) {
|
|
if (th instanceof CancellationException) {
|
|
cancellationException = th;
|
|
}
|
|
cancellationException = cancellationException;
|
|
if (cancellationException == null) {
|
|
cancellationException = a("Channel was consumed, consumer had failed", th);
|
|
}
|
|
}
|
|
oVar.b(cancellationException);
|
|
}
|
|
|
|
public static int t0(long j) {
|
|
return (int) (j ^ (j >>> 32));
|
|
}
|
|
|
|
/* JADX INFO: finally extract failed */
|
|
/* JADX DEBUG: Multi-variable search result rejected for r3v11, resolved type: java.util.concurrent.atomic.AtomicIntegerFieldUpdater */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public static final <T> Object t1(CoroutineContext coroutineContext, Function2<? super CoroutineScope, ? super Continuation<? super T>, ? extends Object> function2, Continuation<? super T> continuation) {
|
|
Object obj;
|
|
boolean z2;
|
|
CoroutineContext context = continuation.getContext();
|
|
CoroutineContext plus = context.plus(coroutineContext);
|
|
Job job = (Job) plus.get(Job.h);
|
|
if (job == null || job.a()) {
|
|
if (plus == context) {
|
|
r rVar = new r(plus, continuation);
|
|
obj = c1(rVar, rVar, function2);
|
|
} else {
|
|
int i = d0.w.d.e;
|
|
d.b bVar = d.b.a;
|
|
if (m.areEqual((d0.w.d) plus.get(bVar), (d0.w.d) context.get(bVar))) {
|
|
y1 y1Var = new y1(plus, continuation);
|
|
Object b2 = s.a.a.a.b(plus, null);
|
|
try {
|
|
Object c1 = c1(y1Var, y1Var, function2);
|
|
s.a.a.a.a(plus, b2);
|
|
obj = c1;
|
|
} catch (Throwable th) {
|
|
s.a.a.a.a(plus, b2);
|
|
throw th;
|
|
}
|
|
} else {
|
|
i0 i0Var = new i0(plus, continuation);
|
|
i0Var.f0();
|
|
b1(function2, i0Var, i0Var, null, 4);
|
|
while (true) {
|
|
int i2 = i0Var._decision;
|
|
z2 = false;
|
|
if (i2 == 0) {
|
|
if (i0.n.compareAndSet(i0Var, 0, 1)) {
|
|
z2 = true;
|
|
break;
|
|
}
|
|
} else if (i2 != 2) {
|
|
throw new IllegalStateException("Already suspended".toString());
|
|
}
|
|
}
|
|
if (z2) {
|
|
obj = d0.w.h.c.getCOROUTINE_SUSPENDED();
|
|
} else {
|
|
obj = i1.a(i0Var.M());
|
|
if (obj instanceof w) {
|
|
throw ((w) obj).f3804b;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (obj == d0.w.h.c.getCOROUTINE_SUSPENDED()) {
|
|
g.probeCoroutineSuspended(continuation);
|
|
}
|
|
return obj;
|
|
}
|
|
throw job.q();
|
|
}
|
|
|
|
public static void u(boolean z2) {
|
|
if (!z2) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
}
|
|
|
|
public static /* synthetic */ m0 u0(Job job, boolean z2, boolean z3, Function1 function1, int i, Object obj) {
|
|
if ((i & 1) != 0) {
|
|
z2 = false;
|
|
}
|
|
if ((i & 2) != 0) {
|
|
z3 = true;
|
|
}
|
|
return job.n(z2, z3, function1);
|
|
}
|
|
|
|
@NonNull
|
|
public static b.o.a.x.c u1(@NonNull j jVar) {
|
|
return new b.o.a.x.k(jVar, null);
|
|
}
|
|
|
|
public static void v(boolean z2) {
|
|
if (!z2) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
}
|
|
|
|
public static m0 v0(long j, Runnable runnable, CoroutineContext coroutineContext) {
|
|
return s.a.e0.a.x(j, runnable, coroutineContext);
|
|
}
|
|
|
|
public static <T> Class<T> v1(Class<T> cls) {
|
|
return cls == Integer.TYPE ? Integer.class : cls == Float.TYPE ? Float.class : cls == Byte.TYPE ? Byte.class : cls == Double.TYPE ? Double.class : cls == Long.TYPE ? Long.class : cls == Character.TYPE ? Character.class : cls == Boolean.TYPE ? Boolean.class : cls == Short.TYPE ? Short.class : cls == Void.TYPE ? Void.class : cls;
|
|
}
|
|
|
|
@CanIgnoreReturnValue
|
|
public static int w(int i, int i2) {
|
|
String str;
|
|
if (i >= 0 && i < i2) {
|
|
return i;
|
|
}
|
|
if (i < 0) {
|
|
str = G0("%s (%s) must not be negative", "index", Integer.valueOf(i));
|
|
} else if (i2 >= 0) {
|
|
str = G0("%s (%s) must be less than size (%s)", "index", Integer.valueOf(i), Integer.valueOf(i2));
|
|
} else {
|
|
throw new IllegalArgumentException(b.d.b.a.a.p("negative size: ", i2));
|
|
}
|
|
throw new IndexOutOfBoundsException(str);
|
|
}
|
|
|
|
public static final boolean w0(CoroutineScope coroutineScope) {
|
|
Job job = (Job) coroutineScope.getCoroutineContext().get(Job.h);
|
|
if (job != null) {
|
|
return job.a();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static int w1(int i, int i2, @NullableDecl String str) {
|
|
String str2;
|
|
if (i >= 0 && i < i2) {
|
|
return i;
|
|
}
|
|
if (i < 0) {
|
|
str2 = c2("%s (%s) must not be negative", "index", Integer.valueOf(i));
|
|
} else if (i2 < 0) {
|
|
throw new IllegalArgumentException(b.d.b.a.a.f(26, "negative size: ", i2));
|
|
} else {
|
|
str2 = c2("%s (%s) must be less than size (%s)", "index", Integer.valueOf(i), Integer.valueOf(i2));
|
|
}
|
|
throw new IndexOutOfBoundsException(str2);
|
|
}
|
|
|
|
@CanIgnoreReturnValue
|
|
public static Object x(Object obj, int i) {
|
|
if (obj != null) {
|
|
return obj;
|
|
}
|
|
throw new NullPointerException(b.d.b.a.a.p("at index ", i));
|
|
}
|
|
|
|
public static final boolean x0(AssertionError assertionError) {
|
|
m.checkParameterIsNotNull(assertionError, "$this$isAndroidGetsocknameError");
|
|
if (assertionError.getCause() == null) {
|
|
return false;
|
|
}
|
|
String message = assertionError.getMessage();
|
|
return message != null ? d0.g0.w.contains$default(message, "getsockname failed", false, 2, null) : false;
|
|
}
|
|
|
|
public static int x1(int i, byte[] bArr, int i2, int i3, s3 s3Var) throws zzij {
|
|
if ((i >>> 3) != 0) {
|
|
int i4 = i & 7;
|
|
if (i4 == 0) {
|
|
return e2(bArr, i2, s3Var);
|
|
}
|
|
if (i4 == 1) {
|
|
return i2 + 8;
|
|
}
|
|
if (i4 == 2) {
|
|
return F1(bArr, i2, s3Var) + s3Var.a;
|
|
}
|
|
if (i4 == 3) {
|
|
int i5 = (i & -8) | 4;
|
|
int i6 = 0;
|
|
while (i2 < i3) {
|
|
i2 = F1(bArr, i2, s3Var);
|
|
i6 = s3Var.a;
|
|
if (i6 == i5) {
|
|
break;
|
|
}
|
|
i2 = x1(i6, bArr, i2, i3, s3Var);
|
|
}
|
|
if (i2 <= i3 && i6 == i5) {
|
|
return i2;
|
|
}
|
|
throw zzij.d();
|
|
} else if (i4 == 5) {
|
|
return i2 + 4;
|
|
} else {
|
|
throw zzij.c();
|
|
}
|
|
} else {
|
|
throw zzij.c();
|
|
}
|
|
}
|
|
|
|
public static void y(Object obj, Object obj2) {
|
|
if (obj == null) {
|
|
throw new NullPointerException(b.d.b.a.a.u("null key in entry: null=", obj2));
|
|
} else if (obj2 == null) {
|
|
throw new NullPointerException("null value in entry: " + obj + "=null");
|
|
}
|
|
}
|
|
|
|
@RecentlyNonNull
|
|
public static boolean y0() {
|
|
return Build.VERSION.SDK_INT >= 26;
|
|
}
|
|
|
|
public static int y1(int i, byte[] bArr, int i2, int i3, b5<?> b5Var, s3 s3Var) {
|
|
x4 x4Var = (x4) b5Var;
|
|
int F1 = F1(bArr, i2, s3Var);
|
|
x4Var.g(s3Var.a);
|
|
while (F1 < i3) {
|
|
int F12 = F1(bArr, F1, s3Var);
|
|
if (i != s3Var.a) {
|
|
break;
|
|
}
|
|
F1 = F1(bArr, F12, s3Var);
|
|
x4Var.g(s3Var.a);
|
|
}
|
|
return F1;
|
|
}
|
|
|
|
@CanIgnoreReturnValue
|
|
public static int z(int i, String str) {
|
|
if (i >= 0) {
|
|
return i;
|
|
}
|
|
throw new IllegalArgumentException(str + " cannot be negative but was: " + i);
|
|
}
|
|
|
|
public static final boolean z0(int i) {
|
|
return i == 1 || i == 2;
|
|
}
|
|
|
|
public static int z1(int i, byte[] bArr, int i2, int i3, c7 c7Var, s3 s3Var) throws zzij {
|
|
if ((i >>> 3) != 0) {
|
|
int i4 = i & 7;
|
|
if (i4 == 0) {
|
|
int e2 = e2(bArr, i2, s3Var);
|
|
c7Var.a(i, Long.valueOf(s3Var.f1478b));
|
|
return e2;
|
|
} else if (i4 == 1) {
|
|
c7Var.a(i, Long.valueOf(f2(bArr, i2)));
|
|
return i2 + 8;
|
|
} else if (i4 == 2) {
|
|
int F1 = F1(bArr, i2, s3Var);
|
|
int i5 = s3Var.a;
|
|
if (i5 < 0) {
|
|
throw zzij.b();
|
|
} else if (i5 <= bArr.length - F1) {
|
|
if (i5 == 0) {
|
|
c7Var.a(i, t3.j);
|
|
} else {
|
|
c7Var.a(i, t3.h(bArr, F1, i5));
|
|
}
|
|
return F1 + i5;
|
|
} else {
|
|
throw zzij.a();
|
|
}
|
|
} else if (i4 == 3) {
|
|
c7 c2 = c7.c();
|
|
int i6 = (i & -8) | 4;
|
|
int i7 = 0;
|
|
while (true) {
|
|
if (i2 >= i3) {
|
|
break;
|
|
}
|
|
int F12 = F1(bArr, i2, s3Var);
|
|
int i8 = s3Var.a;
|
|
if (i8 == i6) {
|
|
i7 = i8;
|
|
i2 = F12;
|
|
break;
|
|
}
|
|
i7 = i8;
|
|
i2 = z1(i8, bArr, F12, i3, c2, s3Var);
|
|
}
|
|
if (i2 > i3 || i7 != i6) {
|
|
throw zzij.d();
|
|
}
|
|
c7Var.a(i, c2);
|
|
return i2;
|
|
} else if (i4 == 5) {
|
|
c7Var.a(i, Integer.valueOf(E1(bArr, i2)));
|
|
return i2 + 4;
|
|
} else {
|
|
throw zzij.c();
|
|
}
|
|
} else {
|
|
throw zzij.c();
|
|
}
|
|
}
|
|
}
|