Step Record v1.1.5版本的 MD5 值为：5797275f89198878d2f00ee92d534382
以下内容为反编译后的 HzSKSKHH.java 源代码，内容仅作参考
package com.chartboost.heliumsdk.impl;
import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Color;
import android.graphics.drawable.Drawable;
import android.util.Log;
import android.util.TypedValue;
import android.view.View;
import androidx.annotation.AttrRes;
import androidx.annotation.ColorInt;
import androidx.annotation.DrawableRes;
import androidx.annotation.FloatRange;
import androidx.annotation.IntRange;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.anythink.expressad.e.a.b;
import com.anythink.expressad.foundation.d.g;
import com.chartboost.heliumsdk.impl.H1KztzKH;
import com.chartboost.heliumsdk.impl.Ktz11zS1;
import com.chartboost.heliumsdk.impl.tS1S1HSzt;
import com.chartboost.heliumsdk.impl.ttSztK;
import com.chartboost.heliumsdk.impl.tzzKSz;
import com.chartboost.heliumsdk.impl.ztS;
import com.google.android.gms.tasks.Continuation;
import com.google.android.gms.tasks.SuccessContinuation;
import com.google.android.gms.tasks.Task;
import com.google.android.gms.tasks.Tasks;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import javax.annotation.CheckForNull;
import kotlin.Pair;
import kotlin.Unit;
import kotlin.coroutines.CoroutineContext;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.functions.Function3;
import kotlin.time.Duration;
import kotlinx.coroutines.SKHKzK;
import org.json.JSONException;
import org.json.JSONObject;
@SuppressLint({"RestrictedAPI"})
public class HzSKSKHH implements SuccessContinuation, Continuation, z11K, KSK1 {
public static final HzSKSKHH tz = new HzSKSKHH();
public static final Object HKzHtzz(ArrayList arrayList, kotlin.coroutines.Continuation continuation) {
if (arrayList.isEmpty()) {
return ztKKzKz.tz;
}
Object[] array = arrayList.toArray(new KSH1zzHSH[0]);
if (array != null) {
KSH1zzHSH[] kSH1zzHSHArr = (KSH1zzHSH[]) array;
kotlinx.coroutines.SKHKzK sKHKzK = new kotlinx.coroutines.SKHKzK(kSH1zzHSHArr);
SHH1111Ht sHH1111Ht = new SHH1111Ht(1, t11z1.tHSKtzz(continuation));
sHH1111Ht.zzKKKtKHK();
int length = kSH1zzHSHArr.length;
SKHKzK.C0453SKHKzK[] c0453SKHKzKArr = new SKHKzK.C0453SKHKzK[length];
for (int i = 0; i < length; i++) {
KSH1zzHSH kSH1zzHSH = kSH1zzHSHArr[i];
kSH1zzHSH.start();
SKHKzK.C0453SKHKzK c0453SKHKzK = new SKHKzK.C0453SKHKzK(sHH1111Ht);
c0453SKHKzK.Ht = kSH1zzHSH.KztSK1(c0453SKHKzK);
Unit unit = Unit.SKHKzK;
c0453SKHKzKArr[i] = c0453SKHKzK;
}
SKHKzK.t1H1KH1K t1h1kh1k = new SKHKzK.t1H1KH1K(c0453SKHKzKArr);
for (int i2 = 0; i2 < length; i2++) {
c0453SKHKzKArr[i2].KSz1H1t(t1h1kh1k);
}
if (sHH1111Ht.zH()) {
t1h1kh1k.t1H1KH1K();
} else {
sHH1111Ht.tz(t1h1kh1k);
}
return sHH1111Ht.tSHz11();
}
throw new NullPointerException("null cannot be cast to non-null type kotlin.Array<T of kotlin.collections.ArraysKt__ArraysJVMKt.toTypedArray>");
}
public static final Hz1tzHK1H HKzt(KHSSzzKK1 kHSSzzKK1, Stzzt1 stzzt1) {
boolean z;
ttHtzKt.tzttS1SS1(kHSSzzKK1, "<this>");
ttHtzKt.tzttS1SS1(stzzt1, "typeTable");
int i = kHSSzzKK1.HKzHtzz;
boolean z2 = true;
if ((i & 8) == 8) {
z = true;
} else {
z = false;
}
if (z) {
Hz1tzHK1H hz1tzHK1H = kHSSzzKK1.HzHtt1;
ttHtzKt.tz(hz1tzHK1H, "returnType");
return hz1tzHK1H;
}
if ((i & 16) != 16) {
z2 = false;
}
if (z2) {
return stzzt1.SKHKzK(kHSSzzKK1.SKzzSKS);
}
throw new IllegalStateException("No returnType in ProtoBuf.Function".toString());
}
public static int HS(int i) {
return (int) (Integer.rotateLeft((int) (i * (-862048943)), 15) * 461845907);
}
public static final H1H1z HSK(ztHHt zthht) {
ttHtzKt.tzttS1SS1(zthht, "<this>");
K1zKSHztK H1SzHH1K = zthht.H1SzHH1K();
if (H1SzHH1K instanceof SSzztz) {
return ((SSzztz) H1SzHH1K).KtH1t1;
}
if (H1SzHH1K instanceof H1H1z) {
return (H1H1z) H1SzHH1K;
}
throw new SKS();
}
public static final boolean HSK11S(ztHHt zthht) {
ttHtzKt.tzttS1SS1(zthht, "<this>");
return zthht.H1SzHH1K() instanceof StHH;
}
@ColorInt
public static int Ht(@ColorInt int i, @IntRange(from = 0, to = 255) int i2) {
return zHzzzzKHt.HtSH(i, (Color.alpha(i) * i2) / 255);
}
public static final int Hz1HtH(int i, int i2, int i3) {
if (i3 > 0) {
if (i < i2) {
int i4 = i2 % i3;
if (i4 < 0) {
i4 += i3;
}
int i5 = i % i3;
if (i5 < 0) {
i5 += i3;
}
int i6 = (i4 - i5) % i3;
if (i6 < 0) {
i6 += i3;
}
return i2 - i6;
}
return i2;
}
if (i3 < 0) {
if (i > i2) {
int i7 = -i3;
int i8 = i % i7;
if (i8 < 0) {
i8 += i7;
}
int i9 = i2 % i7;
if (i9 < 0) {
i9 += i7;
}
int i10 = (i8 - i9) % i7;
if (i10 < 0) {
i10 += i7;
}
return i2 + i10;
}
return i2;
}
throw new IllegalArgumentException("Step is zero.");
}
public static final String HzHtt1(Kz1SK kz1SK, KSK1 ksk1) {
Kz1SK kz1SK2;
ttHtzKt.tzttS1SS1(kz1SK, "klass");
ttHtzKt.tzttS1SS1(ksk1, "typeMappingConfiguration");
ksk1.t1H1KH1K(kz1SK);
KHHH t1H1KH1K = kz1SK.t1H1KH1K();
ttHtzKt.tz(t1H1KH1K, "klass.containingDeclaration");
HHtz name = kz1SK.getName();
if (name != null) {
HHtz hHtz = SztKz.SKHKzK;
}
name = SztKz.HtSH;
String t1S1zKHK = name.t1S1zKHK();
ttHtzKt.tz(t1S1zKHK, "safeIdentifier(klass.name).identifier");
if (t1H1KH1K instanceof ttSt1SH) {
S1KHHS tz2 = ((ttSt1SH) t1H1KH1K).tz();
if (!tz2.t1S1zKHK()) {
return S1t1HtH.SHHtSSzS(tz2.t1H1KH1K(), '.', '/') + '/' + t1S1zKHK;
}
return t1S1zKHK;
}
if (t1H1KH1K instanceof Kz1SK) {
kz1SK2 = (Kz1SK) t1H1KH1K;
} else {
kz1SK2 = null;
}
if (kz1SK2 != null) {
ksk1.HtSH(kz1SK2);
return HzHtt1(kz1SK2, ksk1) + '$' + t1S1zKHK;
}
throw new IllegalArgumentException("Unexpected container: " + t1H1KH1K + " for " + kz1SK);
}
public static String K1Ht(String str) {
boolean z;
boolean z2;
int length = str.length();
int i = 0;
while (i < length) {
char charAt = str.charAt(i);
if (charAt >= 'A' && charAt <= 'Z') {
z = true;
} else {
z = false;
}
if (z) {
char[] charArray = str.toCharArray();
while (i < length) {
char c = charArray[i];
if (c >= 'A' && c <= 'Z') {
z2 = true;
} else {
z2 = false;
}
if (z2) {
charArray[i] = (char) (c ^ ' ');
}
i++;
}
return String.valueOf(charArray);
}
i++;
}
return str;
}
public static final long KHS(double d, KSzSHSHSK kSzSHSHSK) {
double HKS = t1KKztt.HKS(d, kSzSHSHSK, KSzSHSHSK.NANOSECONDS);
if (!Double.isNaN(HKS)) {
if (!Double.isNaN(HKS)) {
long round = Math.round(HKS);
if (new SH1tz(-4611686018426999999L, 4611686018426999999L).t1S1zKHK(round)) {
long j = round << 1;
Duration.Companion companion = Duration.KtH1t1;
int i = Sz1ztHStK.SKHKzK;
return j;
}
double HKS2 = t1KKztt.HKS(d, kSzSHSHSK, KSzSHSHSK.MILLISECONDS);
if (!Double.isNaN(HKS2)) {
return tSHz11(Math.round(HKS2));
}
throw new IllegalArgumentException("Cannot round NaN value.");
}
throw new IllegalArgumentException("Cannot round NaN value.");
}
throw new IllegalArgumentException("Duration value cannot be NaN.".toString());
}
public static final HzHHKKH KS1SK(int i, int i2) {
if (i2 <= Integer.MIN_VALUE) {
HzHHKKH hzHHKKH = HzHHKKH.zS;
return HzHHKKH.zS;
}
return new HzHHKKH(i, i2 - 1);
}
@ColorInt
public static int KSHtSK1H(@FloatRange(from = 0.0d, to = 1.0d) float f, @ColorInt int i, @ColorInt int i2) {
return zHzzzzKHt.t1H1KH1K(zHzzzzKHt.HtSH(i2, Math.round(Color.alpha(i2) * f)), i);
}
public static final String KSz1H1t(HzHtS hzHtS) {
StringBuilder sb = new StringBuilder();
zSSHzSHtz(sb, "type: " + hzHtS);
zSSHzSHtz(sb, "hashCode: " + hzHtS.hashCode());
zSSHzSHtz(sb, "javaClass: " + hzHtS.getClass().getCanonicalName());
for (KHHH t1S1zKHK = hzHtS.t1S1zKHK(); t1S1zKHK != null; t1S1zKHK = t1S1zKHK.t1H1KH1K()) {
zSSHzSHtz(sb, "fqName: ".concat(zzStHH.SKHKzK.zzzSztz(t1S1zKHK)));
zSSHzSHtz(sb, "javaClass: " + t1S1zKHK.getClass().getCanonicalName());
}
String sb2 = sb.toString();
ttHtzKt.tz(sb2, "StringBuilder().apply(builderAction).toString()");
return sb2;
}
public static int KSzzK(@CheckForNull Object obj) {
return HS(obj == null ? 0 : obj.hashCode());
}
public static final SSzztz KtH1t1(ztHHt zthht) {
ttHtzKt.tzttS1SS1(zthht, "<this>");
K1zKSHztK H1SzHH1K = zthht.H1SzHH1K();
ttHtzKt.t1S1zKHK(H1SzHH1K, "null cannot be cast to non-null type org.jetbrains.kotlin.types.FlexibleType");
return (SSzztz) H1SzHH1K;
}
public static final long Kz1(long j, KSzSHSHSK kSzSHSHSK) {
ttHtzKt.tzttS1SS1(kSzSHSHSK, "unit");
KSzSHSHSK kSzSHSHSK2 = KSzSHSHSK.NANOSECONDS;
ttHtzKt.tzttS1SS1(kSzSHSHSK2, "sourceUnit");
TimeUnit timeUnit = kSzSHSHSK2.tz;
TimeUnit timeUnit2 = kSzSHSHSK.tz;
long convert = timeUnit2.convert(4611686018426999999L, timeUnit);
if (new SH1tz(-convert, convert).t1S1zKHK(j)) {
long convert2 = kSzSHSHSK2.tz.convert(j, timeUnit2) << 1;
Duration.Companion companion = Duration.KtH1t1;
int i = Sz1ztHStK.SKHKzK;
return convert2;
}
KSzSHSHSK kSzSHSHSK3 = KSzSHSHSK.MILLISECONDS;
ttHtzKt.tzttS1SS1(kSzSHSHSK3, "targetUnit");
return tS1(zS(kSzSHSHSK3.tz.convert(j, timeUnit2)));
}
public static final long KztSK1(String str, long j, long j2, long j3) {
String str2;
boolean z;
int i = H11K1H.SKHKzK;
try {
str2 = System.getProperty(str);
} catch (SecurityException unused) {
str2 = null;
}
if (str2 != null) {
Long HKHSHSzzt = zzzz1zHKt.HKHSHSzzt(str2);
if (HKHSHSzzt != null) {
long longValue = HKHSHSzzt.longValue();
if (j2 <= longValue && longValue <= j3) {
z = true;
} else {
z = false;
}
if (z) {
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 '" + str2 + '\'').toString());
}
return j;
}
public static final int SH(int i) {
if (i < 0) {
return i;
}
if (i < 3) {
return i + 1;
}
if (i < 1073741824) {
return (int) ((i / 0.75f) + 1.0f);
}
return Integer.MAX_VALUE;
}
public static final Hz1tzHK1H SKHt1t1Kt(SKtHz1S sKtHz1S, Stzzt1 stzzt1) {
boolean z;
ttHtzKt.tzttS1SS1(sKtHz1S, "<this>");
ttHtzKt.tzttS1SS1(stzzt1, "typeTable");
int i = sKtHz1S.HKzHtzz;
boolean z2 = true;
if ((i & 8) == 8) {
z = true;
} else {
z = false;
}
if (z) {
Hz1tzHK1H hz1tzHK1H = sKtHz1S.HzHtt1;
ttHtzKt.tz(hz1tzHK1H, "returnType");
return hz1tzHK1H;
}
if ((i & 16) != 16) {
z2 = false;
}
if (z2) {
return stzzt1.SKHKzK(sKtHz1S.SKzzSKS);
}
throw new IllegalStateException("No returnType in ProtoBuf.Property".toString());
}
public static final void SKzzSKS(int i, int i2) {
if (i <= i2) {
} else {
throw new IndexOutOfBoundsException(KKzzzzH1.tz("toIndex (", i, ") is greater than size (", i2, ")."));
}
}
public static final Hz1tzHK1H StHz1StKS(KHSSzzKK1 kHSSzzKK1, Stzzt1 stzzt1) {
boolean z;
ttHtzKt.tzttS1SS1(kHSSzzKK1, "<this>");
ttHtzKt.tzttS1SS1(stzzt1, "typeTable");
int i = kHSSzzKK1.HKzHtzz;
boolean z2 = true;
if ((i & 32) == 32) {
z = true;
} else {
z = false;
}
if (z) {
return kHSSzzKK1.zSSHzSHtz;
}
if ((i & 64) != 64) {
z2 = false;
}
if (z2) {
return stzzt1.SKHKzK(kHSSzzKK1.tS1);
}
return null;
}
public static final Hz1tzHK1H Sz(ttSHSz ttshsz, Stzzt1 stzzt1) {
boolean z;
ttHtzKt.tzttS1SS1(stzzt1, "typeTable");
int i = ttshsz.HKzHtzz;
boolean z2 = true;
if ((i & 4) == 4) {
z = true;
} else {
z = false;
}
if (z) {
Hz1tzHK1H hz1tzHK1H = ttshsz.Ht;
ttHtzKt.tz(hz1tzHK1H, "type");
return hz1tzHK1H;
}
if ((i & 8) != 8) {
z2 = false;
}
if (z2) {
return stzzt1.SKHKzK(ttshsz.HzHtt1);
}
throw new IllegalStateException("No type in ProtoBuf.ValueParameter".toString());
}
public static final void Sz1tH(Throwable th, Throwable th2) {
ttHtzKt.tzttS1SS1(th, "<this>");
ttHtzKt.tzttS1SS1(th2, g.i);
if (th != th2) {
S11SKKtHK.SKHKzK.SKHKzK(th, th2);
}
}
@Nullable
public static Drawable SzS(@NonNull Context context, @DrawableRes int i) {
return Kz1t1zHH.HtSH().tz(context, i);
}
public static final Map SzSH(Pair pair) {
ttHtzKt.tzttS1SS1(pair, "pair");
Map singletonMap = Collections.singletonMap(pair.tz, pair.KtH1t1);
ttHtzKt.tz(singletonMap, "singletonMap(pair.first, pair.second)");
return singletonMap;
}
public static final KKHSt Szt(HzHHKKH hzHHKKH, int i) {
boolean z;
ttHtzKt.tzttS1SS1(hzHHKKH, "<this>");
if (i > 0) {
z = true;
} else {
z = false;
}
Integer valueOf = Integer.valueOf(i);
ttHtzKt.tzttS1SS1(valueOf, "step");
if (z) {
if (hzHHKKH.HKzHtzz <= 0) {
i = -i;
}
return new KKHSt(hzHHKKH.tz, hzHHKKH.KtH1t1, i);
}
throw new IllegalArgumentException("Step must be positive, was: " + valueOf + '.');
}
public static final S1KHHS t1S1zKHK(zzz zzzVar, String str) {
S1KHHS KtH1t1 = zzzVar.t1H1KH1K(HHtz.tzttS1SS1(str)).KtH1t1();
ttHtzKt.tz(KtH1t1, "child(Name.identifier(name)).toSafe()");
return KtH1t1;
}
@ColorInt
public static int tHH1Kt(@AttrRes int i, @NonNull View view) {
return SzSt.t1H1KH1K(view.getContext(), i, view.getClass().getCanonicalName());
}
public static final boolean tHKtz(ztHHt zthht) {
ttHtzKt.tzttS1SS1(zthht, "<this>");
return zthht.H1SzHH1K() instanceof SSzztz;
}
public static final Object tHSKtzz(ztHHt zthht, tHSSzK thsszk, Function3 function3) {
tS1S1HSzt.t1H1KH1K t1h1kh1k;
tS1S1HSzt.t1H1KH1K SzKSK;
ztHHt zthht2;
tHSSzK thsszk2;
Object tHSKtzz;
int ordinal;
boolean z;
boolean z2;
KzHt kzHt = KzHt.t1S1zKHK;
HzSKSKHH hzSKSKHH = tz;
ttHtzKt.tzttS1SS1(zthht, "kotlinType");
ttHtzKt.tzttS1SS1(function3, "writeGenericType");
if (t11z1.StHz1StKS(zthht)) {
zSKSSz1 zskssz1 = HtSKK.SKHKzK;
t11z1.StHz1StKS(zthht);
HS1S tSHz11 = t1KKztt.tSHz11(zthht);
HSz annotations = zthht.getAnnotations();
ztHHt HSK = t11z1.HSK(zthht);
List tSHz112 = t11z1.tSHz11(zthht);
List SzSH = t11z1.SzSH(zthht);
ArrayList arrayList = new ArrayList(tSHztSSSz.KztSK1(SzSH, 10));
Iterator it = SzSH.iterator();
while (it.hasNext()) {
arrayList.add(((ttHHHS1K) it.next()).getType());
}
Ktz11zS1.KtH1t1.getClass();
Ktz11zS1 ktz11zS1 = Ktz11zS1.HKzHtzz;
HzHtS zS = HtSKK.SKHKzK.zS();
t11z1.tt1KHS(zthht);
ztHHt type = ((ttHHHS1K) K1H.Kz(zthht.tHHHtH())).getType();
ttHtzKt.tz(type, "arguments.last().type");
ArrayList zH1KKKSS = K1H.zH1KKKSS(K11z.tzttS1SS1(ktz11zS1, zS, SHHHS1K.tHH1Kt(t1KKztt.Sz1tH(type)), false, null), arrayList);
H1H1z zSSHzSHtz = t1KKztt.tSHz11(zthht).zSSHzSHtz();
ttHtzKt.tz(zSSHzSHtz, "suspendFunType.builtIns.nullableAnyType");
return tHSKtzz(t11z1.HzHtt1(tSHz11, annotations, HSK, tSHz112, zH1KKKSS, zSSHzSHtz, false).SSzSzK1(zthht.tSKtHtK()), thsszk, function3);
}
zzzKzHS KHH = ztS.SKHKzK.KHH(KzHt.tzttS1SS1, zthht);
if (ztS.SKHKzK.tt1S1(KHH)) {
tKSSzz zH = ztS.SKHKzK.zH(KHH);
if (zH != null) {
tS1S1HSzt.HtSH tttS1SKKt = kzHt.tttS1SKKt(zH);
if (!ztS.SKHKzK.zzKzH1Stt(zthht)) {
S1KHHS s1khhs = H1S1S.zSSHzSHtz;
ttHtzKt.tz(s1khhs, "ENHANCED_NULLABILITY_ANNOTATION");
if (!ztS.SKHKzK.tHSKtzz(zthht, s1khhs)) {
z2 = false;
ttHtzKt.tzttS1SS1(tttS1SKKt, "possiblyPrimitiveType");
t1h1kh1k = tttS1SKKt;
if (z2) {
HzSSz hzSSz = tttS1SKKt.HKzHtzz;
t1h1kh1k = tttS1SKKt;
if (hzSSz != null) {
String tz2 = SK1zKSK1.HtSH(hzSSz.tzttS1SS1()).tz();
ttHtzKt.tz(tz2, "byFqNameWithoutInnerClas…apperFqName).internalName");
t1h1kh1k = new tS1S1HSzt.t1H1KH1K(tz2);
}
}
}
}
z2 = true;
ttHtzKt.tzttS1SS1(tttS1SKKt, "possiblyPrimitiveType");
t1h1kh1k = tttS1SKKt;
if (z2) {
}
} else {
tKSSzz tHH1Kt = ztS.SKHKzK.tHH1Kt(KHH);
if (tHH1Kt != null) {
StringBuilder sb = new StringBuilder("[");
HzSSz hzSSz2 = (HzSSz) HzSSz.zH.get(tHH1Kt);
if (hzSSz2 != null) {
sb.append(hzSSz2.t1S1zKHK());
t1h1kh1k = KzHt.zK1HKK(sb.toString());
} else {
HzSSz.t1H1KH1K(4);
throw null;
}
} else if (ztS.SKHKzK.Sz(KHH)) {
zzz tS1 = ztS.SKHKzK.tS1(KHH);
String str = H1KztzKH.SKHKzK;
KSKtt Sz1tH = H1KztzKH.Sz1tH(tS1);
if (Sz1tH != null) {
if (!thsszk.Sz1tH) {
List<H1KztzKH.SKHKzK> list = H1KztzKH.SKzzSKS;
if (!(list instanceof Collection) || !list.isEmpty()) {
Iterator it2 = list.iterator();
while (it2.hasNext()) {
if (ttHtzKt.SKHKzK(((H1KztzKH.SKHKzK) it2.next()).SKHKzK, Sz1tH)) {
z = true;
break;
}
}
}
z = false;
}
String tz3 = SK1zKSK1.t1H1KH1K(Sz1tH).tz();
ttHtzKt.tz(tz3, "byClassId(classId).internalName");
t1h1kh1k = kzHt.SzKSK(tz3);
}
}
}
if (t1h1kh1k == null) {
tS1S1HSzt.t1H1KH1K t1h1kh1k2 = t1h1kh1k;
if (thsszk.SKHKzK) {
boolean z3 = t1h1kh1k instanceof tS1S1HSzt.HtSH;
t1h1kh1k2 = t1h1kh1k;
if (z3) {
HzSSz hzSSz3 = ((tS1S1HSzt.HtSH) t1h1kh1k).HKzHtzz;
t1h1kh1k2 = t1h1kh1k;
if (hzSSz3 != null) {
String tz4 = SK1zKSK1.HtSH(hzSSz3.tzttS1SS1()).tz();
ttHtzKt.tz(tz4, "byFqNameWithoutInnerClas…apperFqName).internalName");
t1h1kh1k2 = new tS1S1HSzt.t1H1KH1K(tz4);
}
}
}
function3.invoke(zthht, t1h1kh1k2, thsszk);
return t1h1kh1k2;
}
HzHtS tHSzS = zthht.tHSzS();
if (tHSzS instanceof Sz1) {
Sz1 sz1 = (Sz1) tHSzS;
ztHHt zthht3 = sz1.SKHKzK;
if (zthht3 != null) {
return tHSKtzz(t1KKztt.HSK(zthht3), thsszk, function3);
}
hzSKSKHH.HKS(sz1.t1H1KH1K);
throw null;
}
tt1KSt t1S1zKHK = tHSzS.t1S1zKHK();
if (t1S1zKHK != null) {
if (z1Kt1.tzttS1SS1(t1S1zKHK)) {
return kzHt.SzKSK("error/NonExistentClass");
}
boolean z4 = t1S1zKHK instanceof Kz1SK;
boolean z5 = thsszk.HtSH;
if (z4 && HS1S.KSHtSK1H(zthht)) {
if (zthht.tHHHtH().size() == 1) {
ttHHHS1K tthhhs1k = zthht.tHHHtH().get(0);
ztHHt type2 = tthhhs1k.getType();
ttHtzKt.tz(type2, "memberProjection.type");
if (tthhhs1k.HtSH() == S1KHz1z1H.IN_VARIANCE) {
tHSKtzz = kzHt.SzKSK("java/lang/Object");
} else {
S1KHz1z1H HtSH = tthhhs1k.HtSH();
ttHtzKt.tz(HtSH, "memberProjection.projectionKind");
if (z5 || ((ordinal = HtSH.ordinal()) == 0 ? (thsszk2 = thsszk.HKzHtzz) == null : !(ordinal == 1 ? (thsszk2 = thsszk.KtH1t1) != null : (thsszk2 = thsszk.tzttS1SS1) != null))) {
thsszk2 = thsszk;
}
tHSKtzz = tHSKtzz(type2, thsszk2, function3);
}
return KzHt.zK1HKK("[" + kzHt.KSHzHtSKK(tHSKtzz));
}
throw new UnsupportedOperationException("arrays must have one type argument");
}
if (z4) {
if (KKHK.t1H1KH1K(t1S1zKHK) && !thsszk.t1H1KH1K && (zthht2 = (ztHHt) S1StH111.KtH1t1(zthht, new HashSet())) != null) {
return tHSKtzz(zthht2, new tHSSzK(thsszk.SKHKzK, true, thsszk.HtSH, thsszk.t1S1zKHK, thsszk.tz, thsszk.tzttS1SS1, thsszk.Sz1tH, thsszk.KtH1t1, thsszk.HKzHtzz, false, 512), function3);
}
if (z5 && HS1S.HtSH((Kz1SK) t1S1zKHK, tzzKSz.SKHKzK.zSztHHK)) {
SzKSK = kzHt.HSKSS();
} else {
Kz1SK kz1SK = (Kz1SK) t1S1zKHK;
ttHtzKt.tz(kz1SK.SKHKzK(), "descriptor.original");
if (kz1SK.HKzHtzz() == 4) {
KHHH t1H1KH1K = kz1SK.t1H1KH1K();
ttHtzKt.t1S1zKHK(t1H1KH1K, "null cannot be cast to non-null type org.jetbrains.kotlin.descriptors.ClassDescriptor");
kz1SK = (Kz1SK) t1H1KH1K;
}
Kz1SK SKHKzK = kz1SK.SKHKzK();
ttHtzKt.tz(SKHKzK, "enumClassIfEnumEntry.original");
SzKSK = kzHt.SzKSK(HzHtt1(SKHKzK, hzSKSKHH));
}
function3.invoke(zthht, SzKSK, thsszk);
return SzKSK;
}
if (t1S1zKHK instanceof SHtK) {
ztHHt tHH1Kt2 = t1KKztt.tHH1Kt((SHtK) t1S1zKHK);
if (zthht.tSKtHtK()) {
tHH1Kt2 = t1KKztt.HSK11S(tHH1Kt2);
}
return tHSKtzz(tHH1Kt2, thsszk, HtKH11SzS.t1H1KH1K);
}
if ((t1S1zKHK instanceof zzt1tHSH) && thsszk.zS) {
return tHSKtzz(((zzt1tHSH) t1S1zKHK).tt1S1(), thsszk, function3);
}
throw new UnsupportedOperationException("Unknown type " + zthht);
}
throw new UnsupportedOperationException("no descriptor for type constructor of " + zthht);
}
t1h1kh1k = null;
if (t1h1kh1k == null) {
}
}
public static final long tS1(long j) {
long j2 = (j << 1) + 1;
Duration.Companion companion = Duration.KtH1t1;
int i = Sz1ztHStK.SKHKzK;
return j2;
}
public static final long tSHz11(long j) {
if (new SH1tz(-4611686018426L, 4611686018426L).t1S1zKHK(j)) {
long j2 = (j * 1000000) << 1;
Duration.Companion companion = Duration.KtH1t1;
int i = Sz1ztHStK.SKHKzK;
return j2;
}
return tS1(zS(j));
}
public static KttKHt1t tSSzHtSHK(int i, boolean z, boolean z2, KzztK kzztK, int i2) {
boolean z3;
boolean z4;
Set set;
if ((i2 & 1) != 0) {
z3 = false;
} else {
z3 = z;
}
if ((i2 & 2) != 0) {
z4 = false;
} else {
z4 = z2;
}
if ((i2 & 4) != 0) {
kzztK = null;
}
KKzzzzH1.Ht(i, "<this>");
if (kzztK != null) {
set = K1SHz1H.tt1S1(kzztK);
} else {
set = null;
}
return new KttKHt1t(i, z4, z3, set, 34);
}
public static String tStt1z(String str) {
boolean z;
boolean z2;
int length = str.length();
int i = 0;
while (i < length) {
char charAt = str.charAt(i);
if (charAt >= 'a' && charAt <= 'z') {
z = true;
} else {
z = false;
}
if (z) {
char[] charArray = str.toCharArray();
while (i < length) {
char c = charArray[i];
if (c >= 'a' && c <= 'z') {
z2 = true;
} else {
z2 = false;
}
if (z2) {
charArray[i] = (char) (c ^ ' ');
}
i++;
}
return String.valueOf(charArray);
}
i++;
}
return str;
}
public static final Hz1tzHK1H tt1KHS(Hz1tzHK1H hz1tzHK1H, Stzzt1 stzzt1) {
boolean z;
ttHtzKt.tzttS1SS1(hz1tzHK1H, "<this>");
ttHtzKt.tzttS1SS1(stzzt1, "typeTable");
int i = hz1tzHK1H.HKzHtzz;
boolean z2 = true;
if ((i & 256) == 256) {
z = true;
} else {
z = false;
}
if (z) {
return hz1tzHK1H.zzKKKtKHK;
}
if ((i & 512) != 512) {
z2 = false;
}
if (z2) {
return stzzt1.SKHKzK(hz1tzHK1H.tHH1Kt);
}
return null;
}
public static final Ktz11zS1 tt1S1(Ktz11zS1 ktz11zS1, HSz hSz) {
Ktz11zS1 ktz11zS12;
ttHtzKt.tzttS1SS1(ktz11zS1, "<this>");
if (zz1.SKHKzK(ktz11zS1) == hSz) {
return ktz11zS1;
}
boolean z = true;
if (zz1.t1H1KH1K(ktz11zS1) != null) {
if (!ktz11zS1.isEmpty()) {
Iterable iterable = ktz11zS1.tz;
ArrayList arrayList = new ArrayList();
for (Object obj : iterable) {
if (!ttHtzKt.SKHKzK((Kz1tKKt1) obj, r0)) {
arrayList.add(obj);
}
}
if (arrayList.size() != ktz11zS1.tz.t1S1zKHK()) {
Ktz11zS1.KtH1t1.getClass();
ktz11zS12 = Ktz11zS1.SKHKzK.HtSH(arrayList);
if (ktz11zS12 != null) {
ktz11zS1 = ktz11zS12;
}
}
}
ktz11zS12 = ktz11zS1;
if (ktz11zS12 != null) {
}
}
if (!hSz.iterator().hasNext() && hSz.isEmpty()) {
return ktz11zS1;
}
HzSSK1 hzSSK1 = new HzSSK1(hSz);
if (ktz11zS1.tz.get(Ktz11zS1.KtH1t1.t1H1KH1K(hzSSK1.t1H1KH1K())) == null) {
z = false;
}
if (!z) {
if (ktz11zS1.isEmpty()) {
return new Ktz11zS1(SHHHS1K.tHH1Kt(hzSSK1));
}
return Ktz11zS1.SKHKzK.HtSH(K1H.zH1KKKSS(hzSSK1, K1H.HHzKH(ktz11zS1)));
}
return ktz11zS1;
}
public static final String tz(Method method) {
StringBuilder sb = new StringBuilder();
sb.append(method.getName());
Class<?>[] parameterTypes = method.getParameterTypes();
ttHtzKt.tz(parameterTypes, "parameterTypes");
sb.append(tzSKS11H.S11t1S1SS(parameterTypes, "", "(", ")", KKS1S.tz, 24));
Class<?> returnType = method.getReturnType();
ttHtzKt.tz(returnType, "returnType");
sb.append(HtKz1.t1H1KH1K(returnType));
return sb.toString();
}
public static final Map tzStSS1(Map map, Function1 function1) {
ttHtzKt.tzttS1SS1(map, "<this>");
ttHtzKt.tzttS1SS1(function1, "defaultValue");
if (map instanceof zt1zK) {
return tzStSS1(((zt1zK) map).SKHKzK(), function1);
}
return new zH1tSHK(map, function1);
}
public static final long tzttS1SS1(String str) {
int i;
boolean z;
boolean z2;
boolean z3;
KSzSHSHSK kSzSHSHSK;
boolean z4;
int length = str.length();
if (length != 0) {
Duration.KtH1t1.getClass();
char charAt = str.charAt(0);
if (charAt == '+' || charAt == '-') {
i = 1;
} else {
i = 0;
}
if (i > 0) {
z = true;
} else {
z = false;
}
if (z && tttt1SH.zK1HKK(str, '-')) {
z2 = true;
} else {
z2 = false;
}
if (length > i) {
if (str.charAt(i) == 'P') {
int i2 = i + 1;
if (i2 != length) {
KSzSHSHSK kSzSHSHSK2 = null;
long j = 0;
boolean z5 = false;
while (i2 < length) {
if (str.charAt(i2) == 'T') {
if (!z5 && (i2 = i2 + 1) != length) {
z5 = true;
} else {
throw new IllegalArgumentException();
}
} else {
int i3 = i2;
while (i3 < str.length()) {
char charAt2 = str.charAt(i3);
if (!new SzttzSz('0', '9').t1S1zKHK(charAt2) && !tttt1SH.KHKH1("+-.", charAt2)) {
z4 = false;
} else {
z4 = true;
}
if (!z4) {
break;
}
i3++;
}
String substring = str.substring(i2, i3);
ttHtzKt.tz(substring, "this as java.lang.String…ing(startIndex, endIndex)");
if (substring.length() == 0) {
z3 = true;
} else {
z3 = false;
}
if (!z3) {
int length2 = substring.length() + i2;
if (length2 >= 0 && length2 <= tttt1SH.S11t1S1SS(str)) {
char charAt3 = str.charAt(length2);
int i4 = length2 + 1;
if (!z5) {
if (charAt3 == 'D') {
kSzSHSHSK = KSzSHSHSK.DAYS;
} else {
throw new IllegalArgumentException("Invalid or unsupported duration ISO non-time unit: " + charAt3);
}
} else if (charAt3 == 'H') {
kSzSHSHSK = KSzSHSHSK.HOURS;
} else if (charAt3 == 'M') {
kSzSHSHSK = KSzSHSHSK.MINUTES;
} else if (charAt3 == 'S') {
kSzSHSHSK = KSzSHSHSK.SECONDS;
} else {
throw new IllegalArgumentException("Invalid duration ISO time unit: " + charAt3);
}
if (kSzSHSHSK2 != null && kSzSHSHSK2.compareTo(kSzSHSHSK) <= 0) {
throw new IllegalArgumentException("Unexpected order of duration components");
}
int KSt = tttt1SH.KSt(substring, '.', 0, false, 6);
if (kSzSHSHSK == KSzSHSHSK.SECONDS && KSt > 0) {
String substring2 = substring.substring(0, KSt);
ttHtzKt.tz(substring2, "this as java.lang.String…ing(startIndex, endIndex)");
long tzttS1SS1 = Duration.tzttS1SS1(j, Kz1(zzzSztz(substring2), kSzSHSHSK));
String substring3 = substring.substring(KSt);
ttHtzKt.tz(substring3, "this as java.lang.String).substring(startIndex)");
j = Duration.tzttS1SS1(tzttS1SS1, KHS(Double.parseDouble(substring3), kSzSHSHSK));
} else {
j = Duration.tzttS1SS1(j, Kz1(zzzSztz(substring), kSzSHSHSK));
}
kSzSHSHSK2 = kSzSHSHSK;
i2 = i4;
} else {
throw new IllegalArgumentException("Missing unit for value ".concat(substring));
}
} else {
throw new IllegalArgumentException();
}
}
}
if (z2) {
long j2 = ((-(j >> 1)) << 1) + (((int) j) & 1);
int i5 = Sz1ztHStK.SKHKzK;
return j2;
}
return j;
}
throw new IllegalArgumentException();
}
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("No components");
}
throw new IllegalArgumentException("The string is empty");
}
@ColorInt
public static int zH(@NonNull Context context, @AttrRes int i, @ColorInt int i2) {
TypedValue SKHKzK = SzSt.SKHKzK(context, i);
if (SKHKzK != null) {
return SKHKzK.data;
}
return i2;
}
public static final H1H1z zKSHtHz(ztHHt zthht) {
ttHtzKt.tzttS1SS1(zthht, "<this>");
K1zKSHztK H1SzHH1K = zthht.H1SzHH1K();
if (H1SzHH1K instanceof SSzztz) {
return ((SSzztz) H1SzHH1K).HKzHtzz;
}
if (H1SzHH1K instanceof H1H1z) {
return (H1H1z) H1SzHH1K;
}
throw new SKS();
}
public static final long zS(long j) {
if (j < -4611686018427387903L) {
return -4611686018427387903L;
}
if (j > 4611686018427387903L) {
return 4611686018427387903L;
}
return j;
}
public static final void zSSHzSHtz(StringBuilder sb, String str) {
ttHtzKt.tzttS1SS1(str, "<this>");
sb.append(str);
sb.append('\n');
}
public static final void zSz(Sztz sztz, kotlin.coroutines.Continuation continuation, boolean z) {
Object Sz1tH;
KzzK1<?> kzzK1;
boolean HKHSHSzzt;
Object HKS = sztz.HKS();
Throwable tzttS1SS1 = sztz.tzttS1SS1(HKS);
if (tzttS1SS1 != null) {
Sz1tH = SHHHS1K.SKzzSKS(tzttS1SS1);
} else {
Sz1tH = sztz.Sz1tH(HKS);
}
if (z) {
zH1tH zh1th = (zH1tH) continuation;
kotlin.coroutines.Continuation<T> continuation2 = zh1th.HKS;
CoroutineContext context = continuation2.getContext();
Object t1H1KH1K = ztKHSK.t1H1KH1K(context, zh1th.HzHtt1);
if (t1H1KH1K != ztKHSK.SKHKzK) {
kzzK1 = tHtHzS1KS.t1H1KH1K(continuation2, context, t1H1KH1K);
} else {
kzzK1 = null;
}
try {
zh1th.HKS.resumeWith(Sz1tH);
Unit unit = Unit.SKHKzK;
if (kzzK1 != null) {
if (!HKHSHSzzt) {
return;
}
}
return;
} finally {
if (kzzK1 == null || kzzK1.HKHSHSzzt()) {
ztKHSK.SKHKzK(context, t1H1KH1K);
}
}
}
continuation.resumeWith(Sz1tH);
}
public static int zSztHHK(String str, int i, int i2, int i3, int i4) {
if ((i4 & 4) != 0) {
i2 = 1;
}
if ((i4 & 8) != 0) {
i3 = Integer.MAX_VALUE;
}
return (int) KztSK1(str, i, i2, i3);
}
public static final Map zt1zKH(Map map) {
ttHtzKt.tzttS1SS1(map, "<this>");
Map.Entry entry = (Map.Entry) map.entrySet().iterator().next();
Map singletonMap = Collections.singletonMap(entry.getKey(), entry.getValue());
ttHtzKt.tz(singletonMap, "with(entries.iterator().…ingletonMap(key, value) }");
return singletonMap;
}
public static final KttSS zzKKKtKHK(ttSztK ttsztk, KSKtt kSKtt) {
ttSztK.SKHKzK.t1H1KH1K t1h1kh1k;
ttHtzKt.tzttS1SS1(ttsztk, "<this>");
ttHtzKt.tzttS1SS1(kSKtt, "classId");
ttSztK.SKHKzK HtSH = ttsztk.HtSH(kSKtt);
if (HtSH == null) {
return null;
}
if (HtSH instanceof ttSztK.SKHKzK.t1H1KH1K) {
t1h1kh1k = (ttSztK.SKHKzK.t1H1KH1K) HtSH;
} else {
t1h1kh1k = null;
}
if (t1h1kh1k == null) {
return null;
}
return t1h1kh1k.SKHKzK;
}
public static final Ktz11zS1 zzKzH1Stt(HSz hSz) {
ttHtzKt.tzttS1SS1(hSz, "<this>");
if (hSz.isEmpty()) {
Ktz11zS1.KtH1t1.getClass();
return Ktz11zS1.HKzHtzz;
}
Ktz11zS1.SKHKzK sKHKzK = Ktz11zS1.KtH1t1;
List tHH1Kt = SHHHS1K.tHH1Kt(new HzSSK1(hSz));
sKHKzK.getClass();
return Ktz11zS1.SKHKzK.HtSH(tHH1Kt);
}
public static final long zzzSztz(String str) {
int i;
boolean z;
int length = str.length();
if (length > 0 && tttt1SH.KHKH1("+-", str.charAt(0))) {
i = 1;
} else {
i = 0;
}
if (length - i > 16) {
HzHHKKH hzHHKKH = new HzHHKKH(i, tttt1SH.S11t1S1SS(str));
if (!(hzHHKKH instanceof Collection) || !((Collection) hzHHKKH).isEmpty()) {
SSS1zt it = hzHHKKH.iterator();
while (it.HKzHtzz) {
if (!new SzttzSz('0', '9').t1S1zKHK(str.charAt(it.nextInt()))) {
z = false;
break;
}
}
}
z = true;
if (z) {
if (str.charAt(0) == '-') {
return Long.MIN_VALUE;
}
return Long.MAX_VALUE;
}
}
if (S1t1HtH.zH1KKKSS(str, "+", false)) {
str = KzStzt.KK(1, str);
}
return Long.parseLong(str);
}
public ztHHt HKS(LinkedHashSet linkedHashSet) {
ttHtzKt.tzttS1SS1(linkedHashSet, "types");
throw new AssertionError("There should be no intersection type in existing descriptors, but found: ".concat(K1H.tSHKHSzH1(linkedHashSet, null, null, null, null, 63)));
}
@Override
public void HtSH(Kz1SK kz1SK) {
}
@Override
public SH1zt1 SKHKzK(K1SHz1H k1SHz1H, JSONObject jSONObject) throws JSONException {
long currentTimeMillis;
jSONObject.optInt("settings_version", 0);
int optInt = jSONObject.optInt("cache_duration", b.cl);
JSONObject jSONObject2 = jSONObject.getJSONObject("fabric");
JSONObject jSONObject3 = jSONObject.getJSONObject("app");
boolean equals = "new".equals(jSONObject3.getString("status"));
String string = jSONObject2.getString("bundle_id");
jSONObject2.getString("org_id");
if (!equals) {
String.format(Locale.US, "https://update.crashlytics.com/spi/v1/platforms/android/apps/%s", string);
}
Locale locale = Locale.US;
String.format(locale, "https://reports.crashlytics.com/spi/v1/platforms/android/apps/%s/reports", string);
String.format(locale, "https://reports.crashlytics.com/sdk-api/v1/platforms/android/apps/%s/minidumps", string);
jSONObject3.optBoolean("update_required", false);
jSONObject3.optInt("report_upload_variant", 0);
jSONObject3.optInt("native_report_upload_variant", 0);
Hz1 hz1 = new Hz1();
tKHSzztHK tkhszzthk = new tKHSzztHK(8);
JSONObject jSONObject4 = jSONObject.getJSONObject("features");
SKStt sKStt = new SKStt(jSONObject4.optBoolean("collect_reports", true), jSONObject4.optBoolean("collect_anrs", false));
long j = optInt;
if (jSONObject.has("expires_at")) {
currentTimeMillis = jSONObject.optLong("expires_at");
} else {
k1SHz1H.getClass();
currentTimeMillis = (j * 1000) + System.currentTimeMillis();
}
return new SH1zt1(currentTimeMillis, hz1, tkhszzthk, sKStt);
}
@Override
public void t1H1KH1K(Kz1SK kz1SK) {
ttHtzKt.tzttS1SS1(kz1SK, "classDescriptor");
}
@Override
public Object then(@NonNull Task task) throws Exception {
if (task.isSuccessful()) {
return null;
}
Log.e("FirebaseCrashlytics", "Error fetching settings.", task.getException());
return null;
}
@Override
@NonNull
public Task then(@Nullable Object obj) throws Exception {
return Tasks.forResult(Boolean.TRUE);
}
}