Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

apk_decompiled/sources/retrofit2/BuiltInConverters.java

@@ -0,0 +1,108 @@
+package retrofit2;
+
+import e3.M;
+import e3.T;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import kotlin.Unit;
+import retrofit2.Converter;
+import retrofit2.http.Streaming;
+
+/* loaded from: classes3.dex */
+final class BuiltInConverters extends Converter.Factory {
+    private boolean checkForKotlinUnit = true;
+
+    /* loaded from: classes3.dex */
+    public static final class BufferingResponseBodyConverter implements Converter<T, T> {
+        static final BufferingResponseBodyConverter INSTANCE = new BufferingResponseBodyConverter();
+
+        @Override // retrofit2.Converter
+        public T convert(T t2) throws IOException {
+            try {
+                return Utils.buffer(t2);
+            } finally {
+                t2.close();
+            }
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class RequestBodyConverter implements Converter<M, M> {
+        static final RequestBodyConverter INSTANCE = new RequestBodyConverter();
+
+        @Override // retrofit2.Converter
+        public M convert(M m4) {
+            return m4;
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class StreamingResponseBodyConverter implements Converter<T, T> {
+        static final StreamingResponseBodyConverter INSTANCE = new StreamingResponseBodyConverter();
+
+        @Override // retrofit2.Converter
+        public T convert(T t2) {
+            return t2;
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class ToStringConverter implements Converter<Object, String> {
+        static final ToStringConverter INSTANCE = new ToStringConverter();
+
+        @Override // retrofit2.Converter
+        public String convert(Object obj) {
+            return obj.toString();
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class UnitResponseBodyConverter implements Converter<T, Unit> {
+        static final UnitResponseBodyConverter INSTANCE = new UnitResponseBodyConverter();
+
+        @Override // retrofit2.Converter
+        public Unit convert(T t2) {
+            t2.close();
+            return Unit.INSTANCE;
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class VoidResponseBodyConverter implements Converter<T, Void> {
+        static final VoidResponseBodyConverter INSTANCE = new VoidResponseBodyConverter();
+
+        @Override // retrofit2.Converter
+        public Void convert(T t2) {
+            t2.close();
+            return null;
+        }
+    }
+
+    @Override // retrofit2.Converter.Factory
+    public Converter<?, M> requestBodyConverter(Type type, Annotation[] annotationArr, Annotation[] annotationArr2, Retrofit retrofit) {
+        if (M.class.isAssignableFrom(Utils.getRawType(type))) {
+            return RequestBodyConverter.INSTANCE;
+        }
+        return null;
+    }
+
+    @Override // retrofit2.Converter.Factory
+    public Converter<T, ?> responseBodyConverter(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+        if (type == T.class) {
+            return Utils.isAnnotationPresent(annotationArr, Streaming.class) ? StreamingResponseBodyConverter.INSTANCE : BufferingResponseBodyConverter.INSTANCE;
+        }
+        if (type == Void.class) {
+            return VoidResponseBodyConverter.INSTANCE;
+        }
+        if (!this.checkForKotlinUnit || type != Unit.class) {
+            return null;
+        }
+        try {
+            return UnitResponseBodyConverter.INSTANCE;
+        } catch (NoClassDefFoundError unused) {
+            this.checkForKotlinUnit = false;
+            return null;
+        }
+    }
+}

apk_decompiled/sources/retrofit2/Call.java

@@ -0,0 +1,24 @@
+package retrofit2;
+
+import e3.I;
+import java.io.IOException;
+import r3.K;
+
+/* loaded from: classes3.dex */
+public interface Call<T> extends Cloneable {
+    void cancel();
+
+    Call<T> clone();
+
+    void enqueue(Callback<T> callback);
+
+    Response<T> execute() throws IOException;
+
+    boolean isCanceled();
+
+    boolean isExecuted();
+
+    I request();
+
+    K timeout();
+}

apk_decompiled/sources/retrofit2/CallAdapter.java

@@ -0,0 +1,26 @@
+package retrofit2;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+/* loaded from: classes3.dex */
+public interface CallAdapter<R, T> {
+
+    /* loaded from: classes3.dex */
+    public static abstract class Factory {
+        public static Type getParameterUpperBound(int i, ParameterizedType parameterizedType) {
+            return Utils.getParameterUpperBound(i, parameterizedType);
+        }
+
+        public static Class<?> getRawType(Type type) {
+            return Utils.getRawType(type);
+        }
+
+        public abstract CallAdapter<?, ?> get(Type type, Annotation[] annotationArr, Retrofit retrofit);
+    }
+
+    T adapt(Call<R> call);
+
+    Type responseType();
+}

apk_decompiled/sources/retrofit2/Callback.java

@@ -0,0 +1,8 @@
+package retrofit2;
+
+/* loaded from: classes3.dex */
+public interface Callback<T> {
+    void onFailure(Call<T> call, Throwable th);
+
+    void onResponse(Call<T> call, Response<T> response);
+}

apk_decompiled/sources/retrofit2/CompletableFutureCallAdapterFactory.java

@@ -0,0 +1,139 @@
+package retrofit2;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.concurrent.CompletableFuture;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+import retrofit2.CallAdapter;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+@IgnoreJRERequirement
+/* loaded from: classes3.dex */
+public final class CompletableFutureCallAdapterFactory extends CallAdapter.Factory {
+    static final CallAdapter.Factory INSTANCE = new CompletableFutureCallAdapterFactory();
+
+    @IgnoreJRERequirement
+    /* loaded from: classes3.dex */
+    public static final class BodyCallAdapter<R> implements CallAdapter<R, CompletableFuture<R>> {
+        private final Type responseType;
+
+        @IgnoreJRERequirement
+        /* loaded from: classes3.dex */
+        public class BodyCallback implements Callback<R> {
+            private final CompletableFuture<R> future;
+
+            public BodyCallback(CompletableFuture<R> completableFuture) {
+                this.future = completableFuture;
+            }
+
+            @Override // retrofit2.Callback
+            public void onFailure(Call<R> call, Throwable th) {
+                this.future.completeExceptionally(th);
+            }
+
+            @Override // retrofit2.Callback
+            public void onResponse(Call<R> call, Response<R> response) {
+                if (response.isSuccessful()) {
+                    this.future.complete(response.body());
+                } else {
+                    this.future.completeExceptionally(new HttpException(response));
+                }
+            }
+        }
+
+        public BodyCallAdapter(Type type) {
+            this.responseType = type;
+        }
+
+        @Override // retrofit2.CallAdapter
+        public Type responseType() {
+            return this.responseType;
+        }
+
+        @Override // retrofit2.CallAdapter
+        public CompletableFuture<R> adapt(Call<R> call) {
+            CallCancelCompletableFuture callCancelCompletableFuture = new CallCancelCompletableFuture(call);
+            call.enqueue(new BodyCallback(callCancelCompletableFuture));
+            return callCancelCompletableFuture;
+        }
+    }
+
+    @IgnoreJRERequirement
+    /* loaded from: classes3.dex */
+    public static final class CallCancelCompletableFuture<T> extends CompletableFuture<T> {
+        private final Call<?> call;
+
+        public CallCancelCompletableFuture(Call<?> call) {
+            this.call = call;
+        }
+
+        @Override // java.util.concurrent.CompletableFuture, java.util.concurrent.Future
+        public boolean cancel(boolean z3) {
+            if (z3) {
+                this.call.cancel();
+            }
+            return super.cancel(z3);
+        }
+    }
+
+    @IgnoreJRERequirement
+    /* loaded from: classes3.dex */
+    public static final class ResponseCallAdapter<R> implements CallAdapter<R, CompletableFuture<Response<R>>> {
+        private final Type responseType;
+
+        @IgnoreJRERequirement
+        /* loaded from: classes3.dex */
+        public class ResponseCallback implements Callback<R> {
+            private final CompletableFuture<Response<R>> future;
+
+            public ResponseCallback(CompletableFuture<Response<R>> completableFuture) {
+                this.future = completableFuture;
+            }
+
+            @Override // retrofit2.Callback
+            public void onFailure(Call<R> call, Throwable th) {
+                this.future.completeExceptionally(th);
+            }
+
+            @Override // retrofit2.Callback
+            public void onResponse(Call<R> call, Response<R> response) {
+                this.future.complete(response);
+            }
+        }
+
+        public ResponseCallAdapter(Type type) {
+            this.responseType = type;
+        }
+
+        @Override // retrofit2.CallAdapter
+        public Type responseType() {
+            return this.responseType;
+        }
+
+        @Override // retrofit2.CallAdapter
+        public CompletableFuture<Response<R>> adapt(Call<R> call) {
+            CallCancelCompletableFuture callCancelCompletableFuture = new CallCancelCompletableFuture(call);
+            call.enqueue(new ResponseCallback(callCancelCompletableFuture));
+            return callCancelCompletableFuture;
+        }
+    }
+
+    @Override // retrofit2.CallAdapter.Factory
+    public CallAdapter<?, ?> get(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+        if (CallAdapter.Factory.getRawType(type) != CompletableFuture.class) {
+            return null;
+        }
+        if (!(type instanceof ParameterizedType)) {
+            throw new IllegalStateException("CompletableFuture return type must be parameterized as CompletableFuture<Foo> or CompletableFuture<? extends Foo>");
+        }
+        Type parameterUpperBound = CallAdapter.Factory.getParameterUpperBound(0, (ParameterizedType) type);
+        if (CallAdapter.Factory.getRawType(parameterUpperBound) != Response.class) {
+            return new BodyCallAdapter(parameterUpperBound);
+        }
+        if (parameterUpperBound instanceof ParameterizedType) {
+            return new ResponseCallAdapter(CallAdapter.Factory.getParameterUpperBound(0, (ParameterizedType) parameterUpperBound));
+        }
+        throw new IllegalStateException("Response must be parameterized as Response<Foo> or Response<? extends Foo>");
+    }
+}

apk_decompiled/sources/retrofit2/Converter.java

@@ -0,0 +1,37 @@
+package retrofit2;
+
+import e3.M;
+import e3.T;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+/* loaded from: classes3.dex */
+public interface Converter<F, T> {
+
+    /* loaded from: classes3.dex */
+    public static abstract class Factory {
+        public static Type getParameterUpperBound(int i, ParameterizedType parameterizedType) {
+            return Utils.getParameterUpperBound(i, parameterizedType);
+        }
+
+        public static Class<?> getRawType(Type type) {
+            return Utils.getRawType(type);
+        }
+
+        public Converter<?, M> requestBodyConverter(Type type, Annotation[] annotationArr, Annotation[] annotationArr2, Retrofit retrofit) {
+            return null;
+        }
+
+        public Converter<T, ?> responseBodyConverter(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+            return null;
+        }
+
+        public Converter<?, String> stringConverter(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+            return null;
+        }
+    }
+
+    T convert(F f2) throws IOException;
+}

apk_decompiled/sources/retrofit2/DefaultCallAdapterFactory.java

@@ -0,0 +1,158 @@
+package retrofit2;
+
+import e3.I;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Objects;
+import java.util.concurrent.Executor;
+import r3.K;
+import retrofit2.CallAdapter;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public final class DefaultCallAdapterFactory extends CallAdapter.Factory {
+    private final Executor callbackExecutor;
+
+    /* renamed from: retrofit2.DefaultCallAdapterFactory$1 */
+    /* loaded from: classes3.dex */
+    public class AnonymousClass1 implements CallAdapter<Object, Call<?>> {
+        final /* synthetic */ Executor val$executor;
+        final /* synthetic */ Type val$responseType;
+
+        public AnonymousClass1(Type type, Executor executor) {
+            r2 = type;
+            r3 = executor;
+        }
+
+        @Override // retrofit2.CallAdapter
+        public Type responseType() {
+            return r2;
+        }
+
+        @Override // retrofit2.CallAdapter
+        public Call<?> adapt(Call<Object> call) {
+            Executor executor = r3;
+            return executor == null ? call : new ExecutorCallbackCall(executor, call);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class ExecutorCallbackCall<T> implements Call<T> {
+        final Executor callbackExecutor;
+        final Call<T> delegate;
+
+        /* renamed from: retrofit2.DefaultCallAdapterFactory$ExecutorCallbackCall$1 */
+        /* loaded from: classes3.dex */
+        public class AnonymousClass1 implements Callback<T> {
+            final /* synthetic */ Callback val$callback;
+
+            public AnonymousClass1(Callback callback) {
+                this.val$callback = callback;
+            }
+
+            public /* synthetic */ void lambda$onFailure$1(Callback callback, Throwable th) {
+                callback.onFailure(ExecutorCallbackCall.this, th);
+            }
+
+            public /* synthetic */ void lambda$onResponse$0(Callback callback, Response response) {
+                if (ExecutorCallbackCall.this.delegate.isCanceled()) {
+                    callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
+                } else {
+                    callback.onResponse(ExecutorCallbackCall.this, response);
+                }
+            }
+
+            @Override // retrofit2.Callback
+            public void onFailure(Call<T> call, Throwable th) {
+                ExecutorCallbackCall.this.callbackExecutor.execute(new a(this, this.val$callback, th, 1));
+            }
+
+            @Override // retrofit2.Callback
+            public void onResponse(Call<T> call, Response<T> response) {
+                ExecutorCallbackCall.this.callbackExecutor.execute(new a(this, this.val$callback, response, 0));
+            }
+        }
+
+        public ExecutorCallbackCall(Executor executor, Call<T> call) {
+            this.callbackExecutor = executor;
+            this.delegate = call;
+        }
+
+        @Override // retrofit2.Call
+        public void cancel() {
+            this.delegate.cancel();
+        }
+
+        @Override // retrofit2.Call
+        public void enqueue(Callback<T> callback) {
+            Objects.requireNonNull(callback, "callback == null");
+            this.delegate.enqueue(new AnonymousClass1(callback));
+        }
+
+        @Override // retrofit2.Call
+        public Response<T> execute() throws IOException {
+            return this.delegate.execute();
+        }
+
+        @Override // retrofit2.Call
+        public boolean isCanceled() {
+            return this.delegate.isCanceled();
+        }
+
+        @Override // retrofit2.Call
+        public boolean isExecuted() {
+            return this.delegate.isExecuted();
+        }
+
+        @Override // retrofit2.Call
+        public I request() {
+            return this.delegate.request();
+        }
+
+        @Override // retrofit2.Call
+        public K timeout() {
+            return this.delegate.timeout();
+        }
+
+        @Override // retrofit2.Call
+        public Call<T> clone() {
+            return new ExecutorCallbackCall(this.callbackExecutor, this.delegate.clone());
+        }
+    }
+
+    public DefaultCallAdapterFactory(Executor executor) {
+        this.callbackExecutor = executor;
+    }
+
+    @Override // retrofit2.CallAdapter.Factory
+    public CallAdapter<?, ?> get(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+        if (CallAdapter.Factory.getRawType(type) != Call.class) {
+            return null;
+        }
+        if (type instanceof ParameterizedType) {
+            return new CallAdapter<Object, Call<?>>() { // from class: retrofit2.DefaultCallAdapterFactory.1
+                final /* synthetic */ Executor val$executor;
+                final /* synthetic */ Type val$responseType;
+
+                public AnonymousClass1(Type type2, Executor executor) {
+                    r2 = type2;
+                    r3 = executor;
+                }
+
+                @Override // retrofit2.CallAdapter
+                public Type responseType() {
+                    return r2;
+                }
+
+                @Override // retrofit2.CallAdapter
+                public Call<?> adapt(Call<Object> call) {
+                    Executor executor = r3;
+                    return executor == null ? call : new ExecutorCallbackCall(executor, call);
+                }
+            };
+        }
+        throw new IllegalArgumentException("Call return type must be parameterized as Call<Foo> or Call<? extends Foo>");
+    }
+}

apk_decompiled/sources/retrofit2/HttpException.java

@@ -0,0 +1,34 @@
+package retrofit2;
+
+import java.util.Objects;
+
+/* loaded from: classes3.dex */
+public class HttpException extends RuntimeException {
+    private final int code;
+    private final String message;
+    private final transient Response<?> response;
+
+    public HttpException(Response<?> response) {
+        super(getMessage(response));
+        this.code = response.code();
+        this.message = response.message();
+        this.response = response;
+    }
+
+    private static String getMessage(Response<?> response) {
+        Objects.requireNonNull(response, "response == null");
+        return "HTTP " + response.code() + " " + response.message();
+    }
+
+    public int code() {
+        return this.code;
+    }
+
+    public String message() {
+        return this.message;
+    }
+
+    public Response<?> response() {
+        return this.response;
+    }
+}

apk_decompiled/sources/retrofit2/HttpServiceMethod.java

@@ -0,0 +1,143 @@
+package retrofit2;
+
+import e3.InterfaceC0318d;
+import e3.O;
+import e3.T;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import kotlin.coroutines.Continuation;
+import retrofit2.Utils;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
+    private final InterfaceC0318d callFactory;
+    private final RequestFactory requestFactory;
+    private final Converter<T, ResponseT> responseConverter;
+
+    /* loaded from: classes3.dex */
+    public static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> {
+        private final CallAdapter<ResponseT, ReturnT> callAdapter;
+
+        public CallAdapted(RequestFactory requestFactory, InterfaceC0318d interfaceC0318d, Converter<T, ResponseT> converter, CallAdapter<ResponseT, ReturnT> callAdapter) {
+            super(requestFactory, interfaceC0318d, converter);
+            this.callAdapter = callAdapter;
+        }
+
+        @Override // retrofit2.HttpServiceMethod
+        public ReturnT adapt(Call<ResponseT> call, Object[] objArr) {
+            return this.callAdapter.adapt(call);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class SuspendForBody<ResponseT> extends HttpServiceMethod<ResponseT, Object> {
+        private final CallAdapter<ResponseT, Call<ResponseT>> callAdapter;
+        private final boolean isNullable;
+
+        public SuspendForBody(RequestFactory requestFactory, InterfaceC0318d interfaceC0318d, Converter<T, ResponseT> converter, CallAdapter<ResponseT, Call<ResponseT>> callAdapter, boolean z3) {
+            super(requestFactory, interfaceC0318d, converter);
+            this.callAdapter = callAdapter;
+            this.isNullable = z3;
+        }
+
+        @Override // retrofit2.HttpServiceMethod
+        public Object adapt(Call<ResponseT> call, Object[] objArr) {
+            Call<ResponseT> adapt = this.callAdapter.adapt(call);
+            Continuation continuation = (Continuation) objArr[objArr.length - 1];
+            try {
+                return this.isNullable ? KotlinExtensions.awaitNullable(adapt, continuation) : KotlinExtensions.await(adapt, continuation);
+            } catch (Exception e4) {
+                return KotlinExtensions.suspendAndThrow(e4, continuation);
+            }
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class SuspendForResponse<ResponseT> extends HttpServiceMethod<ResponseT, Object> {
+        private final CallAdapter<ResponseT, Call<ResponseT>> callAdapter;
+
+        public SuspendForResponse(RequestFactory requestFactory, InterfaceC0318d interfaceC0318d, Converter<T, ResponseT> converter, CallAdapter<ResponseT, Call<ResponseT>> callAdapter) {
+            super(requestFactory, interfaceC0318d, converter);
+            this.callAdapter = callAdapter;
+        }
+
+        @Override // retrofit2.HttpServiceMethod
+        public Object adapt(Call<ResponseT> call, Object[] objArr) {
+            Call<ResponseT> adapt = this.callAdapter.adapt(call);
+            Continuation continuation = (Continuation) objArr[objArr.length - 1];
+            try {
+                return KotlinExtensions.awaitResponse(adapt, continuation);
+            } catch (Exception e4) {
+                return KotlinExtensions.suspendAndThrow(e4, continuation);
+            }
+        }
+    }
+
+    public HttpServiceMethod(RequestFactory requestFactory, InterfaceC0318d interfaceC0318d, Converter<T, ResponseT> converter) {
+        this.requestFactory = requestFactory;
+        this.callFactory = interfaceC0318d;
+        this.responseConverter = converter;
+    }
+
+    private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(Retrofit retrofit, Method method, Type type, Annotation[] annotationArr) {
+        try {
+            return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(type, annotationArr);
+        } catch (RuntimeException e4) {
+            throw Utils.methodError(method, e4, "Unable to create call adapter for %s", type);
+        }
+    }
+
+    private static <ResponseT> Converter<T, ResponseT> createResponseConverter(Retrofit retrofit, Method method, Type type) {
+        try {
+            return retrofit.responseBodyConverter(type, method.getAnnotations());
+        } catch (RuntimeException e4) {
+            throw Utils.methodError(method, e4, "Unable to create converter for %s", type);
+        }
+    }
+
+    public static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(Retrofit retrofit, Method method, RequestFactory requestFactory) {
+        Type genericReturnType;
+        boolean z3;
+        boolean z4 = requestFactory.isKotlinSuspendFunction;
+        Annotation[] annotations = method.getAnnotations();
+        if (z4) {
+            Type[] genericParameterTypes = method.getGenericParameterTypes();
+            Type parameterLowerBound = Utils.getParameterLowerBound(0, (ParameterizedType) genericParameterTypes[genericParameterTypes.length - 1]);
+            if (Utils.getRawType(parameterLowerBound) == Response.class && (parameterLowerBound instanceof ParameterizedType)) {
+                parameterLowerBound = Utils.getParameterUpperBound(0, (ParameterizedType) parameterLowerBound);
+                z3 = true;
+            } else {
+                z3 = false;
+            }
+            genericReturnType = new Utils.ParameterizedTypeImpl(null, Call.class, parameterLowerBound);
+            annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);
+        } else {
+            genericReturnType = method.getGenericReturnType();
+            z3 = false;
+        }
+        CallAdapter createCallAdapter = createCallAdapter(retrofit, method, genericReturnType, annotations);
+        Type responseType = createCallAdapter.responseType();
+        if (responseType == O.class) {
+            throw Utils.methodError(method, "'" + Utils.getRawType(responseType).getName() + "' is not a valid response body type. Did you mean ResponseBody?", new Object[0]);
+        }
+        if (responseType == Response.class) {
+            throw Utils.methodError(method, "Response must include generic type (e.g., Response<String>)", new Object[0]);
+        }
+        if (requestFactory.httpMethod.equals("HEAD") && !Void.class.equals(responseType)) {
+            throw Utils.methodError(method, "HEAD method must use Void as response type.", new Object[0]);
+        }
+        Converter createResponseConverter = createResponseConverter(retrofit, method, responseType);
+        InterfaceC0318d interfaceC0318d = retrofit.callFactory;
+        return !z4 ? new CallAdapted(requestFactory, interfaceC0318d, createResponseConverter, createCallAdapter) : z3 ? new SuspendForResponse(requestFactory, interfaceC0318d, createResponseConverter, createCallAdapter) : new SuspendForBody(requestFactory, interfaceC0318d, createResponseConverter, createCallAdapter, false);
+    }
+
+    public abstract ReturnT adapt(Call<ResponseT> call, Object[] objArr);
+
+    @Override // retrofit2.ServiceMethod
+    public final ReturnT invoke(Object[] objArr) {
+        return adapt(new OkHttpCall(this.requestFactory, objArr, this.callFactory, this.responseConverter), objArr);
+    }
+}

apk_decompiled/sources/retrofit2/Invocation.java

@@ -0,0 +1,36 @@
+package retrofit2;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+/* loaded from: classes3.dex */
+public final class Invocation {
+    private final List<?> arguments;
+    private final Method method;
+
+    public Invocation(Method method, List<?> list) {
+        this.method = method;
+        this.arguments = Collections.unmodifiableList(list);
+    }
+
+    public static Invocation of(Method method, List<?> list) {
+        Objects.requireNonNull(method, "method == null");
+        Objects.requireNonNull(list, "arguments == null");
+        return new Invocation(method, new ArrayList(list));
+    }
+
+    public List<?> arguments() {
+        return this.arguments;
+    }
+
+    public Method method() {
+        return this.method;
+    }
+
+    public String toString() {
+        return String.format("%s.%s() %s", this.method.getDeclaringClass().getName(), this.method.getName(), this.arguments);
+    }
+}

apk_decompiled/sources/retrofit2/KotlinExtensions$suspendAndThrow$1.java

@@ -0,0 +1,27 @@
+package retrofit2;
+
+import kotlin.Metadata;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.coroutines.jvm.internal.DebugMetadata;
+import kotlin.jvm.internal.IntCompanionObject;
+
+@Metadata(bv = {1, 0, 3}, d1 = {"\u0000\u0018\n\u0000\n\u0002\u0010\u0000\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0000\n\u0002\u0018\u0002\n\u0002\u0010\u0001\u0010\u0000\u001a\u0004\u0018\u00010\u0001*\u00060\u0002j\u0002`\u00032\f\u0010\u0004\u001a\b\u0012\u0004\u0012\u00020\u00060\u0005H\u0080@"}, d2 = {"suspendAndThrow", "", "Ljava/lang/Exception;", "Lkotlin/Exception;", "continuation", "Lkotlin/coroutines/Continuation;", ""}, k = 3, mv = {1, 1, 15})
+@DebugMetadata(c = "retrofit2.KotlinExtensions", f = "KotlinExtensions.kt", i = {0}, l = {113}, m = "suspendAndThrow", n = {"$this$suspendAndThrow"}, s = {"L$0"})
+/* loaded from: classes3.dex */
+public final class KotlinExtensions$suspendAndThrow$1 extends ContinuationImpl {
+    Object L$0;
+    int label;
+    /* synthetic */ Object result;
+
+    public KotlinExtensions$suspendAndThrow$1(Continuation continuation) {
+        super(continuation);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        this.result = obj;
+        this.label |= IntCompanionObject.MIN_VALUE;
+        return KotlinExtensions.suspendAndThrow(null, this);
+    }
+}

apk_decompiled/sources/retrofit2/KotlinExtensions.java

@@ -0,0 +1,255 @@
+package retrofit2;
+
+import e3.I;
+import java.lang.reflect.Method;
+import kotlin.KotlinNullPointerException;
+import kotlin.Metadata;
+import kotlin.Result;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.DebugProbesKt;
+import kotlin.jvm.JvmName;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.CancellableContinuation;
+import kotlinx.coroutines.CancellableContinuationImpl;
+
+@Metadata(bv = {1, 0, 3}, d1 = {"\u0000.\n\u0002\b\u0002\n\u0002\u0010\u0000\n\u0002\u0018\u0002\n\u0002\b\u0003\n\u0002\u0018\u0002\n\u0000\n\u0002\u0018\u0002\n\u0002\b\u0002\n\u0002\u0010\u0001\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\b\u0002\u001a%\u0010\u0000\u001a\u0002H\u0001\"\b\b\u0000\u0010\u0001*\u00020\u0002*\b\u0012\u0004\u0012\u0002H\u00010\u0003H\u0086@ø\u0001\u0000¢\u0006\u0002\u0010\u0004\u001a+\u0010\u0000\u001a\u0004\u0018\u0001H\u0001\"\b\b\u0000\u0010\u0001*\u00020\u0002*\n\u0012\u0006\u0012\u0004\u0018\u0001H\u00010\u0003H\u0087@ø\u0001\u0000¢\u0006\u0004\b\u0005\u0010\u0004\u001a'\u0010\u0006\u001a\b\u0012\u0004\u0012\u0002H\u00010\u0007\"\u0004\b\u0000\u0010\u0001*\b\u0012\u0004\u0012\u0002H\u00010\u0003H\u0086@ø\u0001\u0000¢\u0006\u0002\u0010\u0004\u001a\u001a\u0010\b\u001a\u0002H\u0001\"\u0006\b\u0000\u0010\u0001\u0018\u0001*\u00020\tH\u0086\b¢\u0006\u0002\u0010\n\u001a\u0019\u0010\u000b\u001a\u00020\f*\u00060\rj\u0002`\u000eH\u0080@ø\u0001\u0000¢\u0006\u0002\u0010\u000f\u0082\u0002\u0004\n\u0002\b\u0019¨\u0006\u0010"}, d2 = {"await", "T", "", "Lretrofit2/Call;", "(Lretrofit2/Call;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", "awaitNullable", "awaitResponse", "Lretrofit2/Response;", "create", "Lretrofit2/Retrofit;", "(Lretrofit2/Retrofit;)Ljava/lang/Object;", "suspendAndThrow", "", "Ljava/lang/Exception;", "Lkotlin/Exception;", "(Ljava/lang/Exception;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", "retrofit"}, k = 2, mv = {1, 1, 15})
+@JvmName(name = "KotlinExtensions")
+/* loaded from: classes3.dex */
+public final class KotlinExtensions {
+    public static final <T> Object await(final Call<T> call, Continuation<? super T> continuation) {
+        final CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(IntrinsicsKt.intercepted(continuation), 1);
+        cancellableContinuationImpl.invokeOnCancellation(new Function1<Throwable, Unit>() { // from class: retrofit2.KotlinExtensions$await$$inlined$suspendCancellableCoroutine$lambda$1
+            {
+                super(1);
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(Throwable th) {
+                invoke2(th);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(Throwable th) {
+                Call.this.cancel();
+            }
+        });
+        call.enqueue(new Callback<T>() { // from class: retrofit2.KotlinExtensions$await$2$2
+            @Override // retrofit2.Callback
+            public void onFailure(Call<T> call2, Throwable t2) {
+                Intrinsics.checkParameterIsNotNull(call2, "call");
+                Intrinsics.checkParameterIsNotNull(t2, "t");
+                CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                Result.Companion companion = Result.INSTANCE;
+                cancellableContinuation.resumeWith(Result.m116constructorimpl(ResultKt.createFailure(t2)));
+            }
+
+            @Override // retrofit2.Callback
+            public void onResponse(Call<T> call2, Response<T> response) {
+                Intrinsics.checkParameterIsNotNull(call2, "call");
+                Intrinsics.checkParameterIsNotNull(response, "response");
+                if (!response.isSuccessful()) {
+                    CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                    HttpException httpException = new HttpException(response);
+                    Result.Companion companion = Result.INSTANCE;
+                    cancellableContinuation.resumeWith(Result.m116constructorimpl(ResultKt.createFailure(httpException)));
+                    return;
+                }
+                T body = response.body();
+                if (body != null) {
+                    CancellableContinuation.this.resumeWith(Result.m116constructorimpl(body));
+                    return;
+                }
+                I request = call2.request();
+                request.getClass();
+                Intrinsics.checkNotNullParameter(Invocation.class, "type");
+                Object cast = Invocation.class.cast(request.f6271e.get(Invocation.class));
+                if (cast == null) {
+                    Intrinsics.throwNpe();
+                }
+                Intrinsics.checkExpressionValueIsNotNull(cast, "call.request().tag(Invocation::class.java)!!");
+                Method method = ((Invocation) cast).method();
+                StringBuilder sb = new StringBuilder("Response from ");
+                Intrinsics.checkExpressionValueIsNotNull(method, "method");
+                Class<?> declaringClass = method.getDeclaringClass();
+                Intrinsics.checkExpressionValueIsNotNull(declaringClass, "method.declaringClass");
+                sb.append(declaringClass.getName());
+                sb.append('.');
+                sb.append(method.getName());
+                sb.append(" was null but response body type was declared as non-null");
+                KotlinNullPointerException kotlinNullPointerException = new KotlinNullPointerException(sb.toString());
+                CancellableContinuation cancellableContinuation2 = CancellableContinuation.this;
+                Result.Companion companion2 = Result.INSTANCE;
+                cancellableContinuation2.resumeWith(Result.m116constructorimpl(ResultKt.createFailure(kotlinNullPointerException)));
+            }
+        });
+        Object result = cancellableContinuationImpl.getResult();
+        if (result == IntrinsicsKt.getCOROUTINE_SUSPENDED()) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        return result;
+    }
+
+    @JvmName(name = "awaitNullable")
+    public static final <T> Object awaitNullable(final Call<T> call, Continuation<? super T> continuation) {
+        final CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(IntrinsicsKt.intercepted(continuation), 1);
+        cancellableContinuationImpl.invokeOnCancellation(new Function1<Throwable, Unit>() { // from class: retrofit2.KotlinExtensions$await$$inlined$suspendCancellableCoroutine$lambda$2
+            {
+                super(1);
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(Throwable th) {
+                invoke2(th);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(Throwable th) {
+                Call.this.cancel();
+            }
+        });
+        call.enqueue(new Callback<T>() { // from class: retrofit2.KotlinExtensions$await$4$2
+            @Override // retrofit2.Callback
+            public void onFailure(Call<T> call2, Throwable t2) {
+                Intrinsics.checkParameterIsNotNull(call2, "call");
+                Intrinsics.checkParameterIsNotNull(t2, "t");
+                CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                Result.Companion companion = Result.INSTANCE;
+                cancellableContinuation.resumeWith(Result.m116constructorimpl(ResultKt.createFailure(t2)));
+            }
+
+            @Override // retrofit2.Callback
+            public void onResponse(Call<T> call2, Response<T> response) {
+                Intrinsics.checkParameterIsNotNull(call2, "call");
+                Intrinsics.checkParameterIsNotNull(response, "response");
+                if (response.isSuccessful()) {
+                    CancellableContinuation.this.resumeWith(Result.m116constructorimpl(response.body()));
+                    return;
+                }
+                CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                HttpException httpException = new HttpException(response);
+                Result.Companion companion = Result.INSTANCE;
+                cancellableContinuation.resumeWith(Result.m116constructorimpl(ResultKt.createFailure(httpException)));
+            }
+        });
+        Object result = cancellableContinuationImpl.getResult();
+        if (result == IntrinsicsKt.getCOROUTINE_SUSPENDED()) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        return result;
+    }
+
+    public static final <T> Object awaitResponse(final Call<T> call, Continuation<? super Response<T>> continuation) {
+        final CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(IntrinsicsKt.intercepted(continuation), 1);
+        cancellableContinuationImpl.invokeOnCancellation(new Function1<Throwable, Unit>() { // from class: retrofit2.KotlinExtensions$awaitResponse$$inlined$suspendCancellableCoroutine$lambda$1
+            {
+                super(1);
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(Throwable th) {
+                invoke2(th);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(Throwable th) {
+                Call.this.cancel();
+            }
+        });
+        call.enqueue(new Callback<T>() { // from class: retrofit2.KotlinExtensions$awaitResponse$2$2
+            @Override // retrofit2.Callback
+            public void onFailure(Call<T> call2, Throwable t2) {
+                Intrinsics.checkParameterIsNotNull(call2, "call");
+                Intrinsics.checkParameterIsNotNull(t2, "t");
+                CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                Result.Companion companion = Result.INSTANCE;
+                cancellableContinuation.resumeWith(Result.m116constructorimpl(ResultKt.createFailure(t2)));
+            }
+
+            @Override // retrofit2.Callback
+            public void onResponse(Call<T> call2, Response<T> response) {
+                Intrinsics.checkParameterIsNotNull(call2, "call");
+                Intrinsics.checkParameterIsNotNull(response, "response");
+                CancellableContinuation.this.resumeWith(Result.m116constructorimpl(response));
+            }
+        });
+        Object result = cancellableContinuationImpl.getResult();
+        if (result == IntrinsicsKt.getCOROUTINE_SUSPENDED()) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        return result;
+    }
+
+    public static final /* synthetic */ <T> T create(Retrofit create) {
+        Intrinsics.checkParameterIsNotNull(create, "$this$create");
+        Intrinsics.reifiedOperationMarker(4, "T");
+        return (T) create.create(Object.class);
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:15:0x0035  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final java.lang.Object suspendAndThrow(final java.lang.Exception r4, kotlin.coroutines.Continuation<?> r5) {
+        /*
+            boolean r0 = r5 instanceof retrofit2.KotlinExtensions$suspendAndThrow$1
+            if (r0 == 0) goto L13
+            r0 = r5
+            retrofit2.KotlinExtensions$suspendAndThrow$1 r0 = (retrofit2.KotlinExtensions$suspendAndThrow$1) r0
+            int r1 = r0.label
+            r2 = -2147483648(0xffffffff80000000, float:-0.0)
+            r3 = r1 & r2
+            if (r3 == 0) goto L13
+            int r1 = r1 - r2
+            r0.label = r1
+            goto L18
+        L13:
+            retrofit2.KotlinExtensions$suspendAndThrow$1 r0 = new retrofit2.KotlinExtensions$suspendAndThrow$1
+            r0.<init>(r5)
+        L18:
+            java.lang.Object r5 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L35
+            if (r2 != r3) goto L2d
+            java.lang.Object r4 = r0.L$0
+            java.lang.Exception r4 = (java.lang.Exception) r4
+            kotlin.ResultKt.throwOnFailure(r5)
+            goto L5c
+        L2d:
+            java.lang.IllegalStateException r4 = new java.lang.IllegalStateException
+            java.lang.String r5 = "call to 'resume' before 'invoke' with coroutine"
+            r4.<init>(r5)
+            throw r4
+        L35:
+            kotlin.ResultKt.throwOnFailure(r5)
+            r0.L$0 = r4
+            r0.label = r3
+            kotlinx.coroutines.CoroutineDispatcher r5 = kotlinx.coroutines.Dispatchers.getDefault()
+            kotlin.coroutines.CoroutineContext r2 = r0.get$context()
+            retrofit2.KotlinExtensions$suspendAndThrow$$inlined$suspendCoroutineUninterceptedOrReturn$lambda$1 r3 = new retrofit2.KotlinExtensions$suspendAndThrow$$inlined$suspendCoroutineUninterceptedOrReturn$lambda$1
+            r3.<init>()
+            r5.mo1685dispatch(r2, r3)
+            java.lang.Object r4 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            java.lang.Object r5 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            if (r4 != r5) goto L59
+            kotlin.coroutines.jvm.internal.DebugProbesKt.probeCoroutineSuspended(r0)
+        L59:
+            if (r4 != r1) goto L5c
+            return r1
+        L5c:
+            kotlin.Unit r4 = kotlin.Unit.INSTANCE
+            return r4
+        */
+        throw new UnsupportedOperationException("Method not decompiled: retrofit2.KotlinExtensions.suspendAndThrow(java.lang.Exception, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+}

apk_decompiled/sources/retrofit2/OkHttpCall.java

@@ -0,0 +1,314 @@
+package retrofit2;
+
+import a.AbstractC0105a;
+import e3.A;
+import e3.F;
+import e3.I;
+import e3.InterfaceC0318d;
+import e3.InterfaceC0319e;
+import e3.InterfaceC0320f;
+import e3.N;
+import e3.O;
+import e3.T;
+import i3.j;
+import java.io.IOException;
+import java.util.Objects;
+import kotlin.jvm.internal.Intrinsics;
+import r3.C0576h;
+import r3.InterfaceC0578j;
+import r3.K;
+import r3.p;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public final class OkHttpCall<T> implements Call<T> {
+    private final Object[] args;
+    private final InterfaceC0318d callFactory;
+    private volatile boolean canceled;
+    private Throwable creationFailure;
+    private boolean executed;
+    private InterfaceC0319e rawCall;
+    private final RequestFactory requestFactory;
+    private final Converter<T, T> responseConverter;
+
+    /* loaded from: classes3.dex */
+    public static final class ExceptionCatchingResponseBody extends T {
+        private final T delegate;
+        private final InterfaceC0578j delegateSource;
+        IOException thrownException;
+
+        public ExceptionCatchingResponseBody(T t2) {
+            this.delegate = t2;
+            this.delegateSource = AbstractC0105a.d(new p(t2.source()) { // from class: retrofit2.OkHttpCall.ExceptionCatchingResponseBody.1
+                @Override // r3.p, r3.I
+                public long read(C0576h c0576h, long j4) throws IOException {
+                    try {
+                        return super.read(c0576h, j4);
+                    } catch (IOException e4) {
+                        ExceptionCatchingResponseBody.this.thrownException = e4;
+                        throw e4;
+                    }
+                }
+            });
+        }
+
+        @Override // e3.T, java.io.Closeable, java.lang.AutoCloseable
+        public void close() {
+            this.delegate.close();
+        }
+
+        @Override // e3.T
+        public long contentLength() {
+            return this.delegate.contentLength();
+        }
+
+        @Override // e3.T
+        public A contentType() {
+            return this.delegate.contentType();
+        }
+
+        @Override // e3.T
+        public InterfaceC0578j source() {
+            return this.delegateSource;
+        }
+
+        public void throwIfCaught() throws IOException {
+            IOException iOException = this.thrownException;
+            if (iOException != null) {
+                throw iOException;
+            }
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class NoContentResponseBody extends T {
+        private final long contentLength;
+        private final A contentType;
+
+        public NoContentResponseBody(A a2, long j4) {
+            this.contentType = a2;
+            this.contentLength = j4;
+        }
+
+        @Override // e3.T
+        public long contentLength() {
+            return this.contentLength;
+        }
+
+        @Override // e3.T
+        public A contentType() {
+            return this.contentType;
+        }
+
+        @Override // e3.T
+        public InterfaceC0578j source() {
+            throw new IllegalStateException("Cannot read raw response body of a converted body.");
+        }
+    }
+
+    public OkHttpCall(RequestFactory requestFactory, Object[] objArr, InterfaceC0318d interfaceC0318d, Converter<T, T> converter) {
+        this.requestFactory = requestFactory;
+        this.args = objArr;
+        this.callFactory = interfaceC0318d;
+        this.responseConverter = converter;
+    }
+
+    private InterfaceC0319e createRawCall() throws IOException {
+        InterfaceC0318d interfaceC0318d = this.callFactory;
+        I request = this.requestFactory.create(this.args);
+        F f2 = (F) interfaceC0318d;
+        f2.getClass();
+        Intrinsics.checkNotNullParameter(request, "request");
+        return new j(f2, request);
+    }
+
+    private InterfaceC0319e getRawCall() throws IOException {
+        InterfaceC0319e interfaceC0319e = this.rawCall;
+        if (interfaceC0319e != null) {
+            return interfaceC0319e;
+        }
+        Throwable th = this.creationFailure;
+        if (th != null) {
+            if (th instanceof IOException) {
+                throw ((IOException) th);
+            }
+            if (th instanceof RuntimeException) {
+                throw ((RuntimeException) th);
+            }
+            throw ((Error) th);
+        }
+        try {
+            InterfaceC0319e createRawCall = createRawCall();
+            this.rawCall = createRawCall;
+            return createRawCall;
+        } catch (IOException | Error | RuntimeException e4) {
+            Utils.throwIfFatal(e4);
+            this.creationFailure = e4;
+            throw e4;
+        }
+    }
+
+    @Override // retrofit2.Call
+    public void cancel() {
+        InterfaceC0319e interfaceC0319e;
+        this.canceled = true;
+        synchronized (this) {
+            interfaceC0319e = this.rawCall;
+        }
+        if (interfaceC0319e != null) {
+            ((j) interfaceC0319e).cancel();
+        }
+    }
+
+    @Override // retrofit2.Call
+    public void enqueue(final Callback<T> callback) {
+        InterfaceC0319e interfaceC0319e;
+        Throwable th;
+        Objects.requireNonNull(callback, "callback == null");
+        synchronized (this) {
+            try {
+                if (this.executed) {
+                    throw new IllegalStateException("Already executed.");
+                }
+                this.executed = true;
+                interfaceC0319e = this.rawCall;
+                th = this.creationFailure;
+                if (interfaceC0319e == null && th == null) {
+                    try {
+                        InterfaceC0319e createRawCall = createRawCall();
+                        this.rawCall = createRawCall;
+                        interfaceC0319e = createRawCall;
+                    } catch (Throwable th2) {
+                        th = th2;
+                        Utils.throwIfFatal(th);
+                        this.creationFailure = th;
+                    }
+                }
+            } catch (Throwable th3) {
+                throw th3;
+            }
+        }
+        if (th != null) {
+            callback.onFailure(this, th);
+            return;
+        }
+        if (this.canceled) {
+            ((j) interfaceC0319e).cancel();
+        }
+        ((j) interfaceC0319e).d(new InterfaceC0320f() { // from class: retrofit2.OkHttpCall.1
+            private void callFailure(Throwable th4) {
+                try {
+                    callback.onFailure(OkHttpCall.this, th4);
+                } catch (Throwable th5) {
+                    Utils.throwIfFatal(th5);
+                    th5.printStackTrace();
+                }
+            }
+
+            @Override // e3.InterfaceC0320f
+            public void onFailure(InterfaceC0319e interfaceC0319e2, IOException iOException) {
+                callFailure(iOException);
+            }
+
+            @Override // e3.InterfaceC0320f
+            public void onResponse(InterfaceC0319e interfaceC0319e2, O o4) {
+                try {
+                    try {
+                        callback.onResponse(OkHttpCall.this, OkHttpCall.this.parseResponse(o4));
+                    } catch (Throwable th4) {
+                        Utils.throwIfFatal(th4);
+                        th4.printStackTrace();
+                    }
+                } catch (Throwable th5) {
+                    Utils.throwIfFatal(th5);
+                    callFailure(th5);
+                }
+            }
+        });
+    }
+
+    @Override // retrofit2.Call
+    public Response<T> execute() throws IOException {
+        InterfaceC0319e rawCall;
+        synchronized (this) {
+            if (this.executed) {
+                throw new IllegalStateException("Already executed.");
+            }
+            this.executed = true;
+            rawCall = getRawCall();
+        }
+        if (this.canceled) {
+            ((j) rawCall).cancel();
+        }
+        return parseResponse(((j) rawCall).e());
+    }
+
+    @Override // retrofit2.Call
+    public boolean isCanceled() {
+        boolean z3 = true;
+        if (this.canceled) {
+            return true;
+        }
+        synchronized (this) {
+            InterfaceC0319e interfaceC0319e = this.rawCall;
+            if (interfaceC0319e == null || !((j) interfaceC0319e).f6871n) {
+                z3 = false;
+            }
+        }
+        return z3;
+    }
+
+    @Override // retrofit2.Call
+    public synchronized boolean isExecuted() {
+        return this.executed;
+    }
+
+    public Response<T> parseResponse(O o4) throws IOException {
+        T t2 = o4.f6297g;
+        N s4 = o4.s();
+        s4.f6286g = new NoContentResponseBody(t2.contentType(), t2.contentLength());
+        O a2 = s4.a();
+        int i = a2.f6294d;
+        if (i < 200 || i >= 300) {
+            try {
+                return Response.error(Utils.buffer(t2), a2);
+            } finally {
+                t2.close();
+            }
+        }
+        if (i == 204 || i == 205) {
+            t2.close();
+            return Response.success((Object) null, a2);
+        }
+        ExceptionCatchingResponseBody exceptionCatchingResponseBody = new ExceptionCatchingResponseBody(t2);
+        try {
+            return Response.success(this.responseConverter.convert(exceptionCatchingResponseBody), a2);
+        } catch (RuntimeException e4) {
+            exceptionCatchingResponseBody.throwIfCaught();
+            throw e4;
+        }
+    }
+
+    @Override // retrofit2.Call
+    public synchronized I request() {
+        try {
+        } catch (IOException e4) {
+            throw new RuntimeException("Unable to create request.", e4);
+        }
+        return ((j) getRawCall()).f6861b;
+    }
+
+    @Override // retrofit2.Call
+    public synchronized K timeout() {
+        try {
+        } catch (IOException e4) {
+            throw new RuntimeException("Unable to create call.", e4);
+        }
+        return ((j) getRawCall()).f6863d;
+    }
+
+    @Override // retrofit2.Call
+    public OkHttpCall<T> clone() {
+        return new OkHttpCall<>(this.requestFactory, this.args, this.callFactory, this.responseConverter);
+    }
+}

apk_decompiled/sources/retrofit2/OptionalConverterFactory.java

@@ -0,0 +1,40 @@
+package retrofit2;
+
+import e3.T;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Optional;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+import retrofit2.Converter;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+@IgnoreJRERequirement
+/* loaded from: classes3.dex */
+public final class OptionalConverterFactory extends Converter.Factory {
+    static final Converter.Factory INSTANCE = new OptionalConverterFactory();
+
+    @IgnoreJRERequirement
+    /* loaded from: classes3.dex */
+    public static final class OptionalConverter<T> implements Converter<T, Optional<T>> {
+        final Converter<T, T> delegate;
+
+        public OptionalConverter(Converter<T, T> converter) {
+            this.delegate = converter;
+        }
+
+        @Override // retrofit2.Converter
+        public Optional<T> convert(T t2) throws IOException {
+            return Optional.ofNullable(this.delegate.convert(t2));
+        }
+    }
+
+    @Override // retrofit2.Converter.Factory
+    public Converter<T, ?> responseBodyConverter(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+        if (Converter.Factory.getRawType(type) != Optional.class) {
+            return null;
+        }
+        return new OptionalConverter(retrofit.responseBodyConverter(Converter.Factory.getParameterUpperBound(0, (ParameterizedType) type), annotationArr));
+    }
+}

apk_decompiled/sources/retrofit2/ParameterHandler.java

@@ -0,0 +1,435 @@
+package retrofit2;
+
+import C.w;
+import a.AbstractC0105a;
+import e3.C;
+import e3.C0334u;
+import e3.M;
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Objects;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public abstract class ParameterHandler<T> {
+
+    /* loaded from: classes3.dex */
+    public static final class Body<T> extends ParameterHandler<T> {
+        private final Converter<T, M> converter;
+        private final Method method;
+        private final int p;
+
+        public Body(Method method, int i, Converter<T, M> converter) {
+            this.method = method;
+            this.p = i;
+            this.converter = converter;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) {
+            if (t2 == null) {
+                throw Utils.parameterError(this.method, this.p, "Body parameter value must not be null.", new Object[0]);
+            }
+            try {
+                requestBuilder.setBody(this.converter.convert(t2));
+            } catch (IOException e4) {
+                throw Utils.parameterError(this.method, e4, this.p, "Unable to convert " + t2 + " to RequestBody", new Object[0]);
+            }
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Field<T> extends ParameterHandler<T> {
+        private final boolean encoded;
+        private final String name;
+        private final Converter<T, String> valueConverter;
+
+        public Field(String str, Converter<T, String> converter, boolean z3) {
+            Objects.requireNonNull(str, "name == null");
+            this.name = str;
+            this.valueConverter = converter;
+            this.encoded = z3;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) throws IOException {
+            String convert;
+            if (t2 == null || (convert = this.valueConverter.convert(t2)) == null) {
+                return;
+            }
+            requestBuilder.addFormField(this.name, convert, this.encoded);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class FieldMap<T> extends ParameterHandler<Map<String, T>> {
+        private final boolean encoded;
+        private final Method method;
+        private final int p;
+        private final Converter<T, String> valueConverter;
+
+        public FieldMap(Method method, int i, Converter<T, String> converter, boolean z3) {
+            this.method = method;
+            this.p = i;
+            this.valueConverter = converter;
+            this.encoded = z3;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, Map<String, T> map) throws IOException {
+            if (map != null) {
+                for (Map.Entry<String, T> entry : map.entrySet()) {
+                    String key = entry.getKey();
+                    if (key != null) {
+                        T value = entry.getValue();
+                        if (value != null) {
+                            String convert = this.valueConverter.convert(value);
+                            if (convert != null) {
+                                requestBuilder.addFormField(key, convert, this.encoded);
+                            } else {
+                                throw Utils.parameterError(this.method, this.p, "Field map value '" + value + "' converted to null by " + this.valueConverter.getClass().getName() + " for key '" + key + "'.", new Object[0]);
+                            }
+                        } else {
+                            throw Utils.parameterError(this.method, this.p, w.o("Field map contained null value for key '", key, "'."), new Object[0]);
+                        }
+                    } else {
+                        throw Utils.parameterError(this.method, this.p, "Field map contained null key.", new Object[0]);
+                    }
+                }
+                return;
+            }
+            throw Utils.parameterError(this.method, this.p, "Field map was null.", new Object[0]);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Header<T> extends ParameterHandler<T> {
+        private final String name;
+        private final Converter<T, String> valueConverter;
+
+        public Header(String str, Converter<T, String> converter) {
+            Objects.requireNonNull(str, "name == null");
+            this.name = str;
+            this.valueConverter = converter;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) throws IOException {
+            String convert;
+            if (t2 == null || (convert = this.valueConverter.convert(t2)) == null) {
+                return;
+            }
+            requestBuilder.addHeader(this.name, convert);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class HeaderMap<T> extends ParameterHandler<Map<String, T>> {
+        private final Method method;
+        private final int p;
+        private final Converter<T, String> valueConverter;
+
+        public HeaderMap(Method method, int i, Converter<T, String> converter) {
+            this.method = method;
+            this.p = i;
+            this.valueConverter = converter;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, Map<String, T> map) throws IOException {
+            if (map != null) {
+                for (Map.Entry<String, T> entry : map.entrySet()) {
+                    String key = entry.getKey();
+                    if (key != null) {
+                        T value = entry.getValue();
+                        if (value != null) {
+                            requestBuilder.addHeader(key, this.valueConverter.convert(value));
+                        } else {
+                            throw Utils.parameterError(this.method, this.p, w.o("Header map contained null value for key '", key, "'."), new Object[0]);
+                        }
+                    } else {
+                        throw Utils.parameterError(this.method, this.p, "Header map contained null key.", new Object[0]);
+                    }
+                }
+                return;
+            }
+            throw Utils.parameterError(this.method, this.p, "Header map was null.", new Object[0]);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Headers extends ParameterHandler<C0334u> {
+        private final Method method;
+        private final int p;
+
+        public Headers(Method method, int i) {
+            this.method = method;
+            this.p = i;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, C0334u c0334u) {
+            if (c0334u != null) {
+                requestBuilder.addHeaders(c0334u);
+                return;
+            }
+            throw Utils.parameterError(this.method, this.p, "Headers parameter must not be null.", new Object[0]);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Part<T> extends ParameterHandler<T> {
+        private final Converter<T, M> converter;
+        private final C0334u headers;
+        private final Method method;
+        private final int p;
+
+        public Part(Method method, int i, C0334u c0334u, Converter<T, M> converter) {
+            this.method = method;
+            this.p = i;
+            this.headers = c0334u;
+            this.converter = converter;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) {
+            if (t2 == null) {
+                return;
+            }
+            try {
+                requestBuilder.addPart(this.headers, this.converter.convert(t2));
+            } catch (IOException e4) {
+                throw Utils.parameterError(this.method, this.p, "Unable to convert " + t2 + " to RequestBody", e4);
+            }
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class PartMap<T> extends ParameterHandler<Map<String, T>> {
+        private final Method method;
+        private final int p;
+        private final String transferEncoding;
+        private final Converter<T, M> valueConverter;
+
+        public PartMap(Method method, int i, Converter<T, M> converter, String str) {
+            this.method = method;
+            this.p = i;
+            this.valueConverter = converter;
+            this.transferEncoding = str;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, Map<String, T> map) throws IOException {
+            if (map != null) {
+                for (Map.Entry<String, T> entry : map.entrySet()) {
+                    String key = entry.getKey();
+                    if (key != null) {
+                        T value = entry.getValue();
+                        if (value != null) {
+                            requestBuilder.addPart(AbstractC0105a.I("Content-Disposition", w.o("form-data; name=\"", key, "\""), "Content-Transfer-Encoding", this.transferEncoding), this.valueConverter.convert(value));
+                        } else {
+                            throw Utils.parameterError(this.method, this.p, w.o("Part map contained null value for key '", key, "'."), new Object[0]);
+                        }
+                    } else {
+                        throw Utils.parameterError(this.method, this.p, "Part map contained null key.", new Object[0]);
+                    }
+                }
+                return;
+            }
+            throw Utils.parameterError(this.method, this.p, "Part map was null.", new Object[0]);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Path<T> extends ParameterHandler<T> {
+        private final boolean encoded;
+        private final Method method;
+        private final String name;
+        private final int p;
+        private final Converter<T, String> valueConverter;
+
+        public Path(Method method, int i, String str, Converter<T, String> converter, boolean z3) {
+            this.method = method;
+            this.p = i;
+            Objects.requireNonNull(str, "name == null");
+            this.name = str;
+            this.valueConverter = converter;
+            this.encoded = z3;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) throws IOException {
+            if (t2 == null) {
+                throw Utils.parameterError(this.method, this.p, w.r(new StringBuilder("Path parameter \""), this.name, "\" value must not be null."), new Object[0]);
+            }
+            requestBuilder.addPathParam(this.name, this.valueConverter.convert(t2), this.encoded);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Query<T> extends ParameterHandler<T> {
+        private final boolean encoded;
+        private final String name;
+        private final Converter<T, String> valueConverter;
+
+        public Query(String str, Converter<T, String> converter, boolean z3) {
+            Objects.requireNonNull(str, "name == null");
+            this.name = str;
+            this.valueConverter = converter;
+            this.encoded = z3;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) throws IOException {
+            String convert;
+            if (t2 == null || (convert = this.valueConverter.convert(t2)) == null) {
+                return;
+            }
+            requestBuilder.addQueryParam(this.name, convert, this.encoded);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class QueryMap<T> extends ParameterHandler<Map<String, T>> {
+        private final boolean encoded;
+        private final Method method;
+        private final int p;
+        private final Converter<T, String> valueConverter;
+
+        public QueryMap(Method method, int i, Converter<T, String> converter, boolean z3) {
+            this.method = method;
+            this.p = i;
+            this.valueConverter = converter;
+            this.encoded = z3;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, Map<String, T> map) throws IOException {
+            if (map != null) {
+                for (Map.Entry<String, T> entry : map.entrySet()) {
+                    String key = entry.getKey();
+                    if (key != null) {
+                        T value = entry.getValue();
+                        if (value != null) {
+                            String convert = this.valueConverter.convert(value);
+                            if (convert != null) {
+                                requestBuilder.addQueryParam(key, convert, this.encoded);
+                            } else {
+                                throw Utils.parameterError(this.method, this.p, "Query map value '" + value + "' converted to null by " + this.valueConverter.getClass().getName() + " for key '" + key + "'.", new Object[0]);
+                            }
+                        } else {
+                            throw Utils.parameterError(this.method, this.p, w.o("Query map contained null value for key '", key, "'."), new Object[0]);
+                        }
+                    } else {
+                        throw Utils.parameterError(this.method, this.p, "Query map contained null key.", new Object[0]);
+                    }
+                }
+                return;
+            }
+            throw Utils.parameterError(this.method, this.p, "Query map was null", new Object[0]);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class QueryName<T> extends ParameterHandler<T> {
+        private final boolean encoded;
+        private final Converter<T, String> nameConverter;
+
+        public QueryName(Converter<T, String> converter, boolean z3) {
+            this.nameConverter = converter;
+            this.encoded = z3;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) throws IOException {
+            if (t2 == null) {
+                return;
+            }
+            requestBuilder.addQueryParam(this.nameConverter.convert(t2), null, this.encoded);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class RawPart extends ParameterHandler<C> {
+        static final RawPart INSTANCE = new RawPart();
+
+        private RawPart() {
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, C c4) {
+            if (c4 != null) {
+                requestBuilder.addPart(c4);
+            }
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class RelativeUrl extends ParameterHandler<Object> {
+        private final Method method;
+        private final int p;
+
+        public RelativeUrl(Method method, int i) {
+            this.method = method;
+            this.p = i;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, Object obj) {
+            if (obj == null) {
+                throw Utils.parameterError(this.method, this.p, "@Url parameter is null.", new Object[0]);
+            }
+            requestBuilder.setRelativeUrl(obj);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Tag<T> extends ParameterHandler<T> {
+        final Class<T> cls;
+
+        public Tag(Class<T> cls) {
+            this.cls = cls;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) {
+            requestBuilder.addTag(this.cls, t2);
+        }
+    }
+
+    public abstract void apply(RequestBuilder requestBuilder, T t2) throws IOException;
+
+    public final ParameterHandler<Object> array() {
+        return new ParameterHandler<Object>() { // from class: retrofit2.ParameterHandler.2
+            /* JADX WARN: Multi-variable type inference failed */
+            @Override // retrofit2.ParameterHandler
+            public void apply(RequestBuilder requestBuilder, Object obj) throws IOException {
+                if (obj == null) {
+                    return;
+                }
+                int length = Array.getLength(obj);
+                for (int i = 0; i < length; i++) {
+                    ParameterHandler.this.apply(requestBuilder, Array.get(obj, i));
+                }
+            }
+        };
+    }
+
+    public final ParameterHandler<Iterable<T>> iterable() {
+        return new ParameterHandler<Iterable<T>>() { // from class: retrofit2.ParameterHandler.1
+            @Override // retrofit2.ParameterHandler
+            public void apply(RequestBuilder requestBuilder, Iterable<T> iterable) throws IOException {
+                if (iterable == null) {
+                    return;
+                }
+                Iterator<T> it = iterable.iterator();
+                while (it.hasNext()) {
+                    ParameterHandler.this.apply(requestBuilder, it.next());
+                }
+            }
+        };
+    }
+}

apk_decompiled/sources/retrofit2/Platform.java

@@ -0,0 +1,102 @@
+package retrofit2;
+
+import android.os.Handler;
+import android.os.Looper;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Executor;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+import retrofit2.CallAdapter;
+import retrofit2.Converter;
+
+/* loaded from: classes3.dex */
+class Platform {
+    private static final Platform PLATFORM = findPlatform();
+    private final boolean hasJava8Types;
+    private final Constructor<MethodHandles.Lookup> lookupConstructor;
+
+    /* loaded from: classes3.dex */
+    public static final class Android extends Platform {
+
+        /* loaded from: classes3.dex */
+        public static final class MainThreadExecutor implements Executor {
+            private final Handler handler = new Handler(Looper.getMainLooper());
+
+            @Override // java.util.concurrent.Executor
+            public void execute(Runnable runnable) {
+                this.handler.post(runnable);
+            }
+        }
+
+        public Android() {
+            super(true);
+        }
+
+        @Override // retrofit2.Platform
+        public Executor defaultCallbackExecutor() {
+            return new MainThreadExecutor();
+        }
+
+        @Override // retrofit2.Platform
+        public Object invokeDefaultMethod(Method method, Class<?> cls, Object obj, Object... objArr) throws Throwable {
+            return super.invokeDefaultMethod(method, cls, obj, objArr);
+        }
+    }
+
+    public Platform(boolean z3) {
+        this.hasJava8Types = z3;
+        Constructor<MethodHandles.Lookup> constructor = null;
+        if (z3) {
+            try {
+                constructor = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, Integer.TYPE);
+                constructor.setAccessible(true);
+            } catch (NoClassDefFoundError | NoSuchMethodException unused) {
+            }
+        }
+        this.lookupConstructor = constructor;
+    }
+
+    private static Platform findPlatform() {
+        return "Dalvik".equals(System.getProperty("java.vm.name")) ? new Android() : new Platform(true);
+    }
+
+    public static Platform get() {
+        return PLATFORM;
+    }
+
+    public List<? extends CallAdapter.Factory> defaultCallAdapterFactories(Executor executor) {
+        DefaultCallAdapterFactory defaultCallAdapterFactory = new DefaultCallAdapterFactory(executor);
+        return this.hasJava8Types ? Arrays.asList(CompletableFutureCallAdapterFactory.INSTANCE, defaultCallAdapterFactory) : Collections.singletonList(defaultCallAdapterFactory);
+    }
+
+    public int defaultCallAdapterFactoriesSize() {
+        return this.hasJava8Types ? 2 : 1;
+    }
+
+    public Executor defaultCallbackExecutor() {
+        return null;
+    }
+
+    public List<? extends Converter.Factory> defaultConverterFactories() {
+        return this.hasJava8Types ? Collections.singletonList(OptionalConverterFactory.INSTANCE) : Collections.EMPTY_LIST;
+    }
+
+    public int defaultConverterFactoriesSize() {
+        return this.hasJava8Types ? 1 : 0;
+    }
+
+    @IgnoreJRERequirement
+    public Object invokeDefaultMethod(Method method, Class<?> cls, Object obj, Object... objArr) throws Throwable {
+        Constructor<MethodHandles.Lookup> constructor = this.lookupConstructor;
+        return (constructor != null ? constructor.newInstance(cls, -1) : MethodHandles.lookup()).unreflectSpecial(method, cls).bindTo(obj).invokeWithArguments(objArr);
+    }
+
+    @IgnoreJRERequirement
+    public boolean isDefaultMethod(Method method) {
+        return this.hasJava8Types && method.isDefault();
+    }
+}

apk_decompiled/sources/retrofit2/RequestBuilder.java

@@ -0,0 +1,330 @@
+package retrofit2;
+
+import e3.A;
+import e3.B;
+import e3.C;
+import e3.C0329o;
+import e3.C0331q;
+import e3.C0333t;
+import e3.C0334u;
+import e3.C0335v;
+import e3.D;
+import e3.H;
+import e3.M;
+import e3.r;
+import e3.w;
+import e3.z;
+import f3.c;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.regex.Pattern;
+import kotlin.UByte;
+import kotlin.jvm.internal.Intrinsics;
+import r3.C0576h;
+import r3.InterfaceC0577i;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public final class RequestBuilder {
+    private static final String PATH_SEGMENT_ALWAYS_ENCODE_SET = " \"<>^`{}|\\?#";
+    private final w baseUrl;
+    private M body;
+    private A contentType;
+    private C0331q formBuilder;
+    private final boolean hasBody;
+    private final C0333t headersBuilder;
+    private final String method;
+    private B multipartBuilder;
+    private String relativeUrl;
+    private final H requestBuilder = new H();
+    private C0335v urlBuilder;
+    private static final char[] HEX_DIGITS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+    private static final Pattern PATH_TRAVERSAL = Pattern.compile("(.*/)?(\\.|%2e|%2E){1,2}(/.*)?");
+
+    /* loaded from: classes3.dex */
+    public static class ContentTypeOverridingRequestBody extends M {
+        private final A contentType;
+        private final M delegate;
+
+        public ContentTypeOverridingRequestBody(M m4, A a2) {
+            this.delegate = m4;
+            this.contentType = a2;
+        }
+
+        @Override // e3.M
+        public long contentLength() throws IOException {
+            return this.delegate.contentLength();
+        }
+
+        @Override // e3.M
+        public A contentType() {
+            return this.contentType;
+        }
+
+        @Override // e3.M
+        public void writeTo(InterfaceC0577i interfaceC0577i) throws IOException {
+            this.delegate.writeTo(interfaceC0577i);
+        }
+    }
+
+    public RequestBuilder(String str, w wVar, String str2, C0334u c0334u, A a2, boolean z3, boolean z4, boolean z5) {
+        this.method = str;
+        this.baseUrl = wVar;
+        this.relativeUrl = str2;
+        this.contentType = a2;
+        this.hasBody = z3;
+        if (c0334u != null) {
+            this.headersBuilder = c0334u.c();
+        } else {
+            this.headersBuilder = new C0333t();
+        }
+        if (z4) {
+            this.formBuilder = new C0331q();
+            return;
+        }
+        if (z5) {
+            B b4 = new B();
+            this.multipartBuilder = b4;
+            A type = D.f6208f;
+            Intrinsics.checkNotNullParameter(type, "type");
+            if (Intrinsics.areEqual(type.f6200b, "multipart")) {
+                b4.f6203b = type;
+            } else {
+                throw new IllegalArgumentException(("multipart != " + type).toString());
+            }
+        }
+    }
+
+    /* JADX WARN: Type inference failed for: r3v1, types: [java.lang.Object, r3.h] */
+    private static String canonicalizeForPath(String str, boolean z3) {
+        int length = str.length();
+        int i = 0;
+        while (i < length) {
+            int codePointAt = str.codePointAt(i);
+            if (codePointAt >= 32 && codePointAt < 127 && PATH_SEGMENT_ALWAYS_ENCODE_SET.indexOf(codePointAt) == -1 && (z3 || (codePointAt != 47 && codePointAt != 37))) {
+                i += Character.charCount(codePointAt);
+            } else {
+                ?? obj = new Object();
+                obj.p0(str, 0, i);
+                canonicalizeForPath(obj, str, i, length, z3);
+                return obj.e0();
+            }
+        }
+        return str;
+    }
+
+    public void addFormField(String name, String value, boolean z3) {
+        if (z3) {
+            C0331q c0331q = this.formBuilder;
+            c0331q.getClass();
+            Intrinsics.checkNotNullParameter(name, "name");
+            Intrinsics.checkNotNullParameter(value, "value");
+            c0331q.f6394a.add(C0329o.b(0, 0, 83, name, " \"':;<=>@[]^`{}|/\\?#&!$(),~"));
+            c0331q.f6395b.add(C0329o.b(0, 0, 83, value, " \"':;<=>@[]^`{}|/\\?#&!$(),~"));
+            return;
+        }
+        C0331q c0331q2 = this.formBuilder;
+        c0331q2.getClass();
+        Intrinsics.checkNotNullParameter(name, "name");
+        Intrinsics.checkNotNullParameter(value, "value");
+        c0331q2.f6394a.add(C0329o.b(0, 0, 91, name, " \"':;<=>@[]^`{}|/\\?#&!$(),~"));
+        c0331q2.f6395b.add(C0329o.b(0, 0, 91, value, " \"':;<=>@[]^`{}|/\\?#&!$(),~"));
+    }
+
+    public void addHeader(String str, String str2) {
+        if (!"Content-Type".equalsIgnoreCase(str)) {
+            this.headersBuilder.a(str, str2);
+            return;
+        }
+        try {
+            Pattern pattern = A.f6197d;
+            this.contentType = z.a(str2);
+        } catch (IllegalArgumentException e4) {
+            throw new IllegalArgumentException(C.w.z("Malformed content type: ", str2), e4);
+        }
+    }
+
+    public void addHeaders(C0334u headers) {
+        C0333t c0333t = this.headersBuilder;
+        c0333t.getClass();
+        Intrinsics.checkNotNullParameter(headers, "headers");
+        int size = headers.size();
+        for (int i = 0; i < size; i++) {
+            c0333t.b(headers.b(i), headers.f(i));
+        }
+    }
+
+    public void addPart(C0334u c0334u, M body) {
+        B b4 = this.multipartBuilder;
+        b4.getClass();
+        Intrinsics.checkNotNullParameter(body, "body");
+        Intrinsics.checkNotNullParameter(body, "body");
+        if ((c0334u != null ? c0334u.a("Content-Type") : null) == null) {
+            if ((c0334u != null ? c0334u.a("Content-Length") : null) == null) {
+                C part = new C(c0334u, body);
+                Intrinsics.checkNotNullParameter(part, "part");
+                b4.f6204c.add(part);
+                return;
+            }
+            throw new IllegalArgumentException("Unexpected header: Content-Length");
+        }
+        throw new IllegalArgumentException("Unexpected header: Content-Type");
+    }
+
+    public void addPathParam(String str, String str2, boolean z3) {
+        if (this.relativeUrl == null) {
+            throw new AssertionError();
+        }
+        String canonicalizeForPath = canonicalizeForPath(str2, z3);
+        String replace = this.relativeUrl.replace("{" + str + "}", canonicalizeForPath);
+        if (PATH_TRAVERSAL.matcher(replace).matches()) {
+            throw new IllegalArgumentException(C.w.z("@Path parameters shouldn't perform path traversal ('.' or '..'): ", str2));
+        }
+        this.relativeUrl = replace;
+    }
+
+    public void addQueryParam(String name, String str, boolean z3) {
+        String str2 = this.relativeUrl;
+        if (str2 != null) {
+            C0335v f2 = this.baseUrl.f(str2);
+            this.urlBuilder = f2;
+            if (f2 == null) {
+                throw new IllegalArgumentException("Malformed URL. Base: " + this.baseUrl + ", Relative: " + this.relativeUrl);
+            }
+            this.relativeUrl = null;
+        }
+        if (z3) {
+            C0335v c0335v = this.urlBuilder;
+            c0335v.getClass();
+            Intrinsics.checkNotNullParameter(name, "encodedName");
+            if (c0335v.f6411g == null) {
+                c0335v.f6411g = new ArrayList();
+            }
+            ArrayList arrayList = c0335v.f6411g;
+            Intrinsics.checkNotNull(arrayList);
+            arrayList.add(C0329o.b(0, 0, 211, name, " \"'<>#&="));
+            ArrayList arrayList2 = c0335v.f6411g;
+            Intrinsics.checkNotNull(arrayList2);
+            arrayList2.add(str != null ? C0329o.b(0, 0, 211, str, " \"'<>#&=") : null);
+            return;
+        }
+        C0335v c0335v2 = this.urlBuilder;
+        c0335v2.getClass();
+        Intrinsics.checkNotNullParameter(name, "name");
+        if (c0335v2.f6411g == null) {
+            c0335v2.f6411g = new ArrayList();
+        }
+        ArrayList arrayList3 = c0335v2.f6411g;
+        Intrinsics.checkNotNull(arrayList3);
+        arrayList3.add(C0329o.b(0, 0, 219, name, " !\"#$&'(),/:;<=>?@[]\\^`{|}~"));
+        ArrayList arrayList4 = c0335v2.f6411g;
+        Intrinsics.checkNotNull(arrayList4);
+        arrayList4.add(str != null ? C0329o.b(0, 0, 219, str, " !\"#$&'(),/:;<=>?@[]\\^`{|}~") : null);
+    }
+
+    public <T> void addTag(Class<T> cls, T t2) {
+        this.requestBuilder.f(cls, t2);
+    }
+
+    public H get() {
+        w url;
+        C0335v c0335v = this.urlBuilder;
+        if (c0335v != null) {
+            url = c0335v.a();
+        } else {
+            w wVar = this.baseUrl;
+            String link = this.relativeUrl;
+            wVar.getClass();
+            Intrinsics.checkNotNullParameter(link, "link");
+            C0335v f2 = wVar.f(link);
+            url = f2 != null ? f2.a() : null;
+            if (url == null) {
+                throw new IllegalArgumentException("Malformed URL. Base: " + this.baseUrl + ", Relative: " + this.relativeUrl);
+            }
+        }
+        M m4 = this.body;
+        if (m4 == null) {
+            C0331q c0331q = this.formBuilder;
+            if (c0331q != null) {
+                m4 = new r(c0331q.f6394a, c0331q.f6395b);
+            } else {
+                B b4 = this.multipartBuilder;
+                if (b4 != null) {
+                    ArrayList arrayList = b4.f6204c;
+                    if (arrayList.isEmpty()) {
+                        throw new IllegalStateException("Multipart body must have at least one part.");
+                    }
+                    m4 = new D(b4.f6202a, b4.f6203b, c.w(arrayList));
+                } else if (this.hasBody) {
+                    m4 = M.create((A) null, new byte[0]);
+                }
+            }
+        }
+        A a2 = this.contentType;
+        if (a2 != null) {
+            if (m4 != null) {
+                m4 = new ContentTypeOverridingRequestBody(m4, a2);
+            } else {
+                this.headersBuilder.a("Content-Type", a2.f6199a);
+            }
+        }
+        H h = this.requestBuilder;
+        h.getClass();
+        Intrinsics.checkNotNullParameter(url, "url");
+        h.f6262a = url;
+        C0334u headers = this.headersBuilder.d();
+        Intrinsics.checkNotNullParameter(headers, "headers");
+        h.f6264c = headers.c();
+        h.d(this.method, m4);
+        return h;
+    }
+
+    public void setBody(M m4) {
+        this.body = m4;
+    }
+
+    public void setRelativeUrl(Object obj) {
+        this.relativeUrl = obj.toString();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v0 */
+    /* JADX WARN: Type inference failed for: r0v1 */
+    /* JADX WARN: Type inference failed for: r0v2, types: [r3.h] */
+    /* JADX WARN: Type inference failed for: r0v3, types: [java.lang.Object] */
+    /* JADX WARN: Type inference failed for: r0v4 */
+    /* JADX WARN: Type inference failed for: r0v5 */
+    private static void canonicalizeForPath(C0576h c0576h, String str, int i, int i4, boolean z3) {
+        ?? r02 = 0;
+        while (i < i4) {
+            int codePointAt = str.codePointAt(i);
+            if (!z3 || (codePointAt != 9 && codePointAt != 10 && codePointAt != 12 && codePointAt != 13)) {
+                if (codePointAt >= 32 && codePointAt < 127 && PATH_SEGMENT_ALWAYS_ENCODE_SET.indexOf(codePointAt) == -1 && (z3 || (codePointAt != 47 && codePointAt != 37))) {
+                    c0576h.q0(codePointAt);
+                } else {
+                    if (r02 == 0) {
+                        r02 = new Object();
+                    }
+                    r02.q0(codePointAt);
+                    while (!r02.x()) {
+                        byte readByte = r02.readByte();
+                        int i5 = readByte & UByte.MAX_VALUE;
+                        c0576h.j0(37);
+                        char[] cArr = HEX_DIGITS;
+                        c0576h.j0(cArr[(i5 >> 4) & 15]);
+                        c0576h.j0(cArr[readByte & 15]);
+                    }
+                }
+            }
+            i += Character.charCount(codePointAt);
+            r02 = r02;
+        }
+    }
+
+    public void addPart(C part) {
+        B b4 = this.multipartBuilder;
+        b4.getClass();
+        Intrinsics.checkNotNullParameter(part, "part");
+        b4.f6204c.add(part);
+    }
+}

apk_decompiled/sources/retrofit2/RequestFactory.java

@@ -0,0 +1,636 @@
+package retrofit2;
+
+import a.AbstractC0105a;
+import e3.A;
+import e3.C;
+import e3.C0334u;
+import e3.H;
+import e3.I;
+import e3.w;
+import e3.z;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import kotlin.coroutines.Continuation;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt__StringsKt;
+import retrofit2.ParameterHandler;
+import retrofit2.http.Body;
+import retrofit2.http.DELETE;
+import retrofit2.http.Field;
+import retrofit2.http.FieldMap;
+import retrofit2.http.FormUrlEncoded;
+import retrofit2.http.GET;
+import retrofit2.http.HEAD;
+import retrofit2.http.HTTP;
+import retrofit2.http.Header;
+import retrofit2.http.HeaderMap;
+import retrofit2.http.Headers;
+import retrofit2.http.Multipart;
+import retrofit2.http.OPTIONS;
+import retrofit2.http.PATCH;
+import retrofit2.http.POST;
+import retrofit2.http.PUT;
+import retrofit2.http.Part;
+import retrofit2.http.PartMap;
+import retrofit2.http.Path;
+import retrofit2.http.Query;
+import retrofit2.http.QueryMap;
+import retrofit2.http.QueryName;
+import retrofit2.http.Tag;
+import retrofit2.http.Url;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public final class RequestFactory {
+    private final w baseUrl;
+    private final A contentType;
+    private final boolean hasBody;
+    private final C0334u headers;
+    final String httpMethod;
+    private final boolean isFormEncoded;
+    final boolean isKotlinSuspendFunction;
+    private final boolean isMultipart;
+    private final Method method;
+    private final ParameterHandler<?>[] parameterHandlers;
+    private final String relativeUrl;
+
+    /* loaded from: classes3.dex */
+    public static final class Builder {
+        A contentType;
+        boolean gotBody;
+        boolean gotField;
+        boolean gotPart;
+        boolean gotPath;
+        boolean gotQuery;
+        boolean gotQueryMap;
+        boolean gotQueryName;
+        boolean gotUrl;
+        boolean hasBody;
+        C0334u headers;
+        String httpMethod;
+        boolean isFormEncoded;
+        boolean isKotlinSuspendFunction;
+        boolean isMultipart;
+        final Method method;
+        final Annotation[] methodAnnotations;
+        final Annotation[][] parameterAnnotationsArray;
+        ParameterHandler<?>[] parameterHandlers;
+        final Type[] parameterTypes;
+        String relativeUrl;
+        Set<String> relativeUrlParamNames;
+        final Retrofit retrofit;
+        private static final Pattern PARAM_URL_REGEX = Pattern.compile("\\{([a-zA-Z][a-zA-Z0-9_-]*)\\}");
+        private static final String PARAM = "[a-zA-Z][a-zA-Z0-9_-]*";
+        private static final Pattern PARAM_NAME_REGEX = Pattern.compile(PARAM);
+
+        public Builder(Retrofit retrofit, Method method) {
+            this.retrofit = retrofit;
+            this.method = method;
+            this.methodAnnotations = method.getAnnotations();
+            this.parameterTypes = method.getGenericParameterTypes();
+            this.parameterAnnotationsArray = method.getParameterAnnotations();
+        }
+
+        private static Class<?> boxIfPrimitive(Class<?> cls) {
+            return Boolean.TYPE == cls ? Boolean.class : Byte.TYPE == cls ? Byte.class : Character.TYPE == cls ? Character.class : Double.TYPE == cls ? Double.class : Float.TYPE == cls ? Float.class : Integer.TYPE == cls ? Integer.class : Long.TYPE == cls ? Long.class : Short.TYPE == cls ? Short.class : cls;
+        }
+
+        private C0334u parseHeaders(String[] strArr) {
+            CharSequence trim;
+            ArrayList arrayList = new ArrayList(20);
+            for (String str : strArr) {
+                int indexOf = str.indexOf(58);
+                if (indexOf == -1 || indexOf == 0 || indexOf == str.length() - 1) {
+                    throw Utils.methodError(this.method, "@Headers value must be in the form \"Name: Value\". Found: \"%s\"", str);
+                }
+                String name = str.substring(0, indexOf);
+                String value = str.substring(indexOf + 1).trim();
+                if ("Content-Type".equalsIgnoreCase(name)) {
+                    try {
+                        Pattern pattern = A.f6197d;
+                        this.contentType = z.a(value);
+                    } catch (IllegalArgumentException e4) {
+                        throw Utils.methodError(this.method, e4, "Malformed content type: %s", value);
+                    }
+                } else {
+                    Intrinsics.checkNotNullParameter(name, "name");
+                    Intrinsics.checkNotNullParameter(value, "value");
+                    AbstractC0105a.g(name);
+                    AbstractC0105a.h(value, name);
+                    Intrinsics.checkNotNullParameter(name, "name");
+                    Intrinsics.checkNotNullParameter(value, "value");
+                    arrayList.add(name);
+                    trim = StringsKt__StringsKt.trim((CharSequence) value);
+                    arrayList.add(trim.toString());
+                }
+            }
+            return new C0334u((String[]) arrayList.toArray(new String[0]));
+        }
+
+        private void parseHttpMethodAndPath(String str, String str2, boolean z3) {
+            String str3 = this.httpMethod;
+            if (str3 != null) {
+                throw Utils.methodError(this.method, "Only one HTTP method is allowed. Found: %s and %s.", str3, str);
+            }
+            this.httpMethod = str;
+            this.hasBody = z3;
+            if (str2.isEmpty()) {
+                return;
+            }
+            int indexOf = str2.indexOf(63);
+            if (indexOf != -1 && indexOf < str2.length() - 1) {
+                String substring = str2.substring(indexOf + 1);
+                if (PARAM_URL_REGEX.matcher(substring).find()) {
+                    throw Utils.methodError(this.method, "URL query string \"%s\" must not have replace block. For dynamic query parameters use @Query.", substring);
+                }
+            }
+            this.relativeUrl = str2;
+            this.relativeUrlParamNames = parsePathParameters(str2);
+        }
+
+        private void parseMethodAnnotation(Annotation annotation) {
+            if (annotation instanceof DELETE) {
+                parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
+                return;
+            }
+            if (annotation instanceof GET) {
+                parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
+                return;
+            }
+            if (annotation instanceof HEAD) {
+                parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
+                return;
+            }
+            if (annotation instanceof PATCH) {
+                parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
+                return;
+            }
+            if (annotation instanceof POST) {
+                parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
+                return;
+            }
+            if (annotation instanceof PUT) {
+                parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
+                return;
+            }
+            if (annotation instanceof OPTIONS) {
+                parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
+                return;
+            }
+            if (annotation instanceof HTTP) {
+                HTTP http = (HTTP) annotation;
+                parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
+                return;
+            }
+            if (annotation instanceof Headers) {
+                String[] value = ((Headers) annotation).value();
+                if (value.length == 0) {
+                    throw Utils.methodError(this.method, "@Headers annotation is empty.", new Object[0]);
+                }
+                this.headers = parseHeaders(value);
+                return;
+            }
+            if (annotation instanceof Multipart) {
+                if (this.isFormEncoded) {
+                    throw Utils.methodError(this.method, "Only one encoding annotation is allowed.", new Object[0]);
+                }
+                this.isMultipart = true;
+            } else if (annotation instanceof FormUrlEncoded) {
+                if (this.isMultipart) {
+                    throw Utils.methodError(this.method, "Only one encoding annotation is allowed.", new Object[0]);
+                }
+                this.isFormEncoded = true;
+            }
+        }
+
+        private ParameterHandler<?> parseParameter(int i, Type type, Annotation[] annotationArr, boolean z3) {
+            ParameterHandler<?> parameterHandler;
+            if (annotationArr != null) {
+                parameterHandler = null;
+                for (Annotation annotation : annotationArr) {
+                    ParameterHandler<?> parseParameterAnnotation = parseParameterAnnotation(i, type, annotationArr, annotation);
+                    if (parseParameterAnnotation != null) {
+                        if (parameterHandler != null) {
+                            throw Utils.parameterError(this.method, i, "Multiple Retrofit annotations found, only one allowed.", new Object[0]);
+                        }
+                        parameterHandler = parseParameterAnnotation;
+                    }
+                }
+            } else {
+                parameterHandler = null;
+            }
+            if (parameterHandler != null) {
+                return parameterHandler;
+            }
+            if (z3) {
+                try {
+                    if (Utils.getRawType(type) == Continuation.class) {
+                        this.isKotlinSuspendFunction = true;
+                        return null;
+                    }
+                } catch (NoClassDefFoundError unused) {
+                }
+            }
+            throw Utils.parameterError(this.method, i, "No Retrofit annotation found.", new Object[0]);
+        }
+
+        private ParameterHandler<?> parseParameterAnnotation(int i, Type type, Annotation[] annotationArr, Annotation annotation) {
+            if (annotation instanceof Url) {
+                validateResolvableType(i, type);
+                if (this.gotUrl) {
+                    throw Utils.parameterError(this.method, i, "Multiple @Url method annotations found.", new Object[0]);
+                }
+                if (this.gotPath) {
+                    throw Utils.parameterError(this.method, i, "@Path parameters may not be used with @Url.", new Object[0]);
+                }
+                if (this.gotQuery) {
+                    throw Utils.parameterError(this.method, i, "A @Url parameter must not come after a @Query.", new Object[0]);
+                }
+                if (this.gotQueryName) {
+                    throw Utils.parameterError(this.method, i, "A @Url parameter must not come after a @QueryName.", new Object[0]);
+                }
+                if (this.gotQueryMap) {
+                    throw Utils.parameterError(this.method, i, "A @Url parameter must not come after a @QueryMap.", new Object[0]);
+                }
+                if (this.relativeUrl != null) {
+                    throw Utils.parameterError(this.method, i, "@Url cannot be used with @%s URL", this.httpMethod);
+                }
+                this.gotUrl = true;
+                if (type == w.class || type == String.class || type == URI.class || ((type instanceof Class) && "android.net.Uri".equals(((Class) type).getName()))) {
+                    return new ParameterHandler.RelativeUrl(this.method, i);
+                }
+                throw Utils.parameterError(this.method, i, "@Url must be okhttp3.HttpUrl, String, java.net.URI, or android.net.Uri type.", new Object[0]);
+            }
+            if (annotation instanceof Path) {
+                validateResolvableType(i, type);
+                if (this.gotQuery) {
+                    throw Utils.parameterError(this.method, i, "A @Path parameter must not come after a @Query.", new Object[0]);
+                }
+                if (this.gotQueryName) {
+                    throw Utils.parameterError(this.method, i, "A @Path parameter must not come after a @QueryName.", new Object[0]);
+                }
+                if (this.gotQueryMap) {
+                    throw Utils.parameterError(this.method, i, "A @Path parameter must not come after a @QueryMap.", new Object[0]);
+                }
+                if (this.gotUrl) {
+                    throw Utils.parameterError(this.method, i, "@Path parameters may not be used with @Url.", new Object[0]);
+                }
+                if (this.relativeUrl == null) {
+                    throw Utils.parameterError(this.method, i, "@Path can only be used with relative url on @%s", this.httpMethod);
+                }
+                this.gotPath = true;
+                Path path = (Path) annotation;
+                String value = path.value();
+                validatePathName(i, value);
+                return new ParameterHandler.Path(this.method, i, value, this.retrofit.stringConverter(type, annotationArr), path.encoded());
+            }
+            if (annotation instanceof Query) {
+                validateResolvableType(i, type);
+                Query query = (Query) annotation;
+                String value2 = query.value();
+                boolean encoded = query.encoded();
+                Class<?> rawType = Utils.getRawType(type);
+                this.gotQuery = true;
+                if (!Iterable.class.isAssignableFrom(rawType)) {
+                    if (!rawType.isArray()) {
+                        return new ParameterHandler.Query(value2, this.retrofit.stringConverter(type, annotationArr), encoded);
+                    }
+                    return new ParameterHandler.Query(value2, this.retrofit.stringConverter(boxIfPrimitive(rawType.getComponentType()), annotationArr), encoded).array();
+                }
+                if (type instanceof ParameterizedType) {
+                    return new ParameterHandler.Query(value2, this.retrofit.stringConverter(Utils.getParameterUpperBound(0, (ParameterizedType) type), annotationArr), encoded).iterable();
+                }
+                throw Utils.parameterError(this.method, i, rawType.getSimpleName() + " must include generic type (e.g., " + rawType.getSimpleName() + "<String>)", new Object[0]);
+            }
+            if (annotation instanceof QueryName) {
+                validateResolvableType(i, type);
+                boolean encoded2 = ((QueryName) annotation).encoded();
+                Class<?> rawType2 = Utils.getRawType(type);
+                this.gotQueryName = true;
+                if (!Iterable.class.isAssignableFrom(rawType2)) {
+                    if (!rawType2.isArray()) {
+                        return new ParameterHandler.QueryName(this.retrofit.stringConverter(type, annotationArr), encoded2);
+                    }
+                    return new ParameterHandler.QueryName(this.retrofit.stringConverter(boxIfPrimitive(rawType2.getComponentType()), annotationArr), encoded2).array();
+                }
+                if (type instanceof ParameterizedType) {
+                    return new ParameterHandler.QueryName(this.retrofit.stringConverter(Utils.getParameterUpperBound(0, (ParameterizedType) type), annotationArr), encoded2).iterable();
+                }
+                throw Utils.parameterError(this.method, i, rawType2.getSimpleName() + " must include generic type (e.g., " + rawType2.getSimpleName() + "<String>)", new Object[0]);
+            }
+            if (annotation instanceof QueryMap) {
+                validateResolvableType(i, type);
+                Class<?> rawType3 = Utils.getRawType(type);
+                this.gotQueryMap = true;
+                if (!Map.class.isAssignableFrom(rawType3)) {
+                    throw Utils.parameterError(this.method, i, "@QueryMap parameter type must be Map.", new Object[0]);
+                }
+                Type supertype = Utils.getSupertype(type, rawType3, Map.class);
+                if (!(supertype instanceof ParameterizedType)) {
+                    throw Utils.parameterError(this.method, i, "Map must include generic types (e.g., Map<String, String>)", new Object[0]);
+                }
+                ParameterizedType parameterizedType = (ParameterizedType) supertype;
+                Type parameterUpperBound = Utils.getParameterUpperBound(0, parameterizedType);
+                if (String.class == parameterUpperBound) {
+                    return new ParameterHandler.QueryMap(this.method, i, this.retrofit.stringConverter(Utils.getParameterUpperBound(1, parameterizedType), annotationArr), ((QueryMap) annotation).encoded());
+                }
+                throw Utils.parameterError(this.method, i, "@QueryMap keys must be of type String: " + parameterUpperBound, new Object[0]);
+            }
+            if (annotation instanceof Header) {
+                validateResolvableType(i, type);
+                String value3 = ((Header) annotation).value();
+                Class<?> rawType4 = Utils.getRawType(type);
+                if (!Iterable.class.isAssignableFrom(rawType4)) {
+                    if (!rawType4.isArray()) {
+                        return new ParameterHandler.Header(value3, this.retrofit.stringConverter(type, annotationArr));
+                    }
+                    return new ParameterHandler.Header(value3, this.retrofit.stringConverter(boxIfPrimitive(rawType4.getComponentType()), annotationArr)).array();
+                }
+                if (type instanceof ParameterizedType) {
+                    return new ParameterHandler.Header(value3, this.retrofit.stringConverter(Utils.getParameterUpperBound(0, (ParameterizedType) type), annotationArr)).iterable();
+                }
+                throw Utils.parameterError(this.method, i, rawType4.getSimpleName() + " must include generic type (e.g., " + rawType4.getSimpleName() + "<String>)", new Object[0]);
+            }
+            if (annotation instanceof HeaderMap) {
+                if (type == C0334u.class) {
+                    return new ParameterHandler.Headers(this.method, i);
+                }
+                validateResolvableType(i, type);
+                Class<?> rawType5 = Utils.getRawType(type);
+                if (!Map.class.isAssignableFrom(rawType5)) {
+                    throw Utils.parameterError(this.method, i, "@HeaderMap parameter type must be Map.", new Object[0]);
+                }
+                Type supertype2 = Utils.getSupertype(type, rawType5, Map.class);
+                if (!(supertype2 instanceof ParameterizedType)) {
+                    throw Utils.parameterError(this.method, i, "Map must include generic types (e.g., Map<String, String>)", new Object[0]);
+                }
+                ParameterizedType parameterizedType2 = (ParameterizedType) supertype2;
+                Type parameterUpperBound2 = Utils.getParameterUpperBound(0, parameterizedType2);
+                if (String.class == parameterUpperBound2) {
+                    return new ParameterHandler.HeaderMap(this.method, i, this.retrofit.stringConverter(Utils.getParameterUpperBound(1, parameterizedType2), annotationArr));
+                }
+                throw Utils.parameterError(this.method, i, "@HeaderMap keys must be of type String: " + parameterUpperBound2, new Object[0]);
+            }
+            if (annotation instanceof Field) {
+                validateResolvableType(i, type);
+                if (!this.isFormEncoded) {
+                    throw Utils.parameterError(this.method, i, "@Field parameters can only be used with form encoding.", new Object[0]);
+                }
+                Field field = (Field) annotation;
+                String value4 = field.value();
+                boolean encoded3 = field.encoded();
+                this.gotField = true;
+                Class<?> rawType6 = Utils.getRawType(type);
+                if (!Iterable.class.isAssignableFrom(rawType6)) {
+                    if (!rawType6.isArray()) {
+                        return new ParameterHandler.Field(value4, this.retrofit.stringConverter(type, annotationArr), encoded3);
+                    }
+                    return new ParameterHandler.Field(value4, this.retrofit.stringConverter(boxIfPrimitive(rawType6.getComponentType()), annotationArr), encoded3).array();
+                }
+                if (type instanceof ParameterizedType) {
+                    return new ParameterHandler.Field(value4, this.retrofit.stringConverter(Utils.getParameterUpperBound(0, (ParameterizedType) type), annotationArr), encoded3).iterable();
+                }
+                throw Utils.parameterError(this.method, i, rawType6.getSimpleName() + " must include generic type (e.g., " + rawType6.getSimpleName() + "<String>)", new Object[0]);
+            }
+            if (annotation instanceof FieldMap) {
+                validateResolvableType(i, type);
+                if (!this.isFormEncoded) {
+                    throw Utils.parameterError(this.method, i, "@FieldMap parameters can only be used with form encoding.", new Object[0]);
+                }
+                Class<?> rawType7 = Utils.getRawType(type);
+                if (!Map.class.isAssignableFrom(rawType7)) {
+                    throw Utils.parameterError(this.method, i, "@FieldMap parameter type must be Map.", new Object[0]);
+                }
+                Type supertype3 = Utils.getSupertype(type, rawType7, Map.class);
+                if (!(supertype3 instanceof ParameterizedType)) {
+                    throw Utils.parameterError(this.method, i, "Map must include generic types (e.g., Map<String, String>)", new Object[0]);
+                }
+                ParameterizedType parameterizedType3 = (ParameterizedType) supertype3;
+                Type parameterUpperBound3 = Utils.getParameterUpperBound(0, parameterizedType3);
+                if (String.class == parameterUpperBound3) {
+                    Converter stringConverter = this.retrofit.stringConverter(Utils.getParameterUpperBound(1, parameterizedType3), annotationArr);
+                    this.gotField = true;
+                    return new ParameterHandler.FieldMap(this.method, i, stringConverter, ((FieldMap) annotation).encoded());
+                }
+                throw Utils.parameterError(this.method, i, "@FieldMap keys must be of type String: " + parameterUpperBound3, new Object[0]);
+            }
+            if (annotation instanceof Part) {
+                validateResolvableType(i, type);
+                if (!this.isMultipart) {
+                    throw Utils.parameterError(this.method, i, "@Part parameters can only be used with multipart encoding.", new Object[0]);
+                }
+                Part part = (Part) annotation;
+                this.gotPart = true;
+                String value5 = part.value();
+                Class<?> rawType8 = Utils.getRawType(type);
+                if (value5.isEmpty()) {
+                    if (!Iterable.class.isAssignableFrom(rawType8)) {
+                        if (rawType8.isArray()) {
+                            if (C.class.isAssignableFrom(rawType8.getComponentType())) {
+                                return ParameterHandler.RawPart.INSTANCE.array();
+                            }
+                            throw Utils.parameterError(this.method, i, "@Part annotation must supply a name or use MultipartBody.Part parameter type.", new Object[0]);
+                        }
+                        if (C.class.isAssignableFrom(rawType8)) {
+                            return ParameterHandler.RawPart.INSTANCE;
+                        }
+                        throw Utils.parameterError(this.method, i, "@Part annotation must supply a name or use MultipartBody.Part parameter type.", new Object[0]);
+                    }
+                    if (type instanceof ParameterizedType) {
+                        if (C.class.isAssignableFrom(Utils.getRawType(Utils.getParameterUpperBound(0, (ParameterizedType) type)))) {
+                            return ParameterHandler.RawPart.INSTANCE.iterable();
+                        }
+                        throw Utils.parameterError(this.method, i, "@Part annotation must supply a name or use MultipartBody.Part parameter type.", new Object[0]);
+                    }
+                    throw Utils.parameterError(this.method, i, rawType8.getSimpleName() + " must include generic type (e.g., " + rawType8.getSimpleName() + "<String>)", new Object[0]);
+                }
+                C0334u I3 = AbstractC0105a.I("Content-Disposition", C.w.o("form-data; name=\"", value5, "\""), "Content-Transfer-Encoding", part.encoding());
+                if (!Iterable.class.isAssignableFrom(rawType8)) {
+                    if (!rawType8.isArray()) {
+                        if (C.class.isAssignableFrom(rawType8)) {
+                            throw Utils.parameterError(this.method, i, "@Part parameters using the MultipartBody.Part must not include a part name in the annotation.", new Object[0]);
+                        }
+                        return new ParameterHandler.Part(this.method, i, I3, this.retrofit.requestBodyConverter(type, annotationArr, this.methodAnnotations));
+                    }
+                    Class<?> boxIfPrimitive = boxIfPrimitive(rawType8.getComponentType());
+                    if (C.class.isAssignableFrom(boxIfPrimitive)) {
+                        throw Utils.parameterError(this.method, i, "@Part parameters using the MultipartBody.Part must not include a part name in the annotation.", new Object[0]);
+                    }
+                    return new ParameterHandler.Part(this.method, i, I3, this.retrofit.requestBodyConverter(boxIfPrimitive, annotationArr, this.methodAnnotations)).array();
+                }
+                if (type instanceof ParameterizedType) {
+                    Type parameterUpperBound4 = Utils.getParameterUpperBound(0, (ParameterizedType) type);
+                    if (C.class.isAssignableFrom(Utils.getRawType(parameterUpperBound4))) {
+                        throw Utils.parameterError(this.method, i, "@Part parameters using the MultipartBody.Part must not include a part name in the annotation.", new Object[0]);
+                    }
+                    return new ParameterHandler.Part(this.method, i, I3, this.retrofit.requestBodyConverter(parameterUpperBound4, annotationArr, this.methodAnnotations)).iterable();
+                }
+                throw Utils.parameterError(this.method, i, rawType8.getSimpleName() + " must include generic type (e.g., " + rawType8.getSimpleName() + "<String>)", new Object[0]);
+            }
+            if (annotation instanceof PartMap) {
+                validateResolvableType(i, type);
+                if (!this.isMultipart) {
+                    throw Utils.parameterError(this.method, i, "@PartMap parameters can only be used with multipart encoding.", new Object[0]);
+                }
+                this.gotPart = true;
+                Class<?> rawType9 = Utils.getRawType(type);
+                if (!Map.class.isAssignableFrom(rawType9)) {
+                    throw Utils.parameterError(this.method, i, "@PartMap parameter type must be Map.", new Object[0]);
+                }
+                Type supertype4 = Utils.getSupertype(type, rawType9, Map.class);
+                if (!(supertype4 instanceof ParameterizedType)) {
+                    throw Utils.parameterError(this.method, i, "Map must include generic types (e.g., Map<String, String>)", new Object[0]);
+                }
+                ParameterizedType parameterizedType4 = (ParameterizedType) supertype4;
+                Type parameterUpperBound5 = Utils.getParameterUpperBound(0, parameterizedType4);
+                if (String.class != parameterUpperBound5) {
+                    throw Utils.parameterError(this.method, i, "@PartMap keys must be of type String: " + parameterUpperBound5, new Object[0]);
+                }
+                Type parameterUpperBound6 = Utils.getParameterUpperBound(1, parameterizedType4);
+                if (C.class.isAssignableFrom(Utils.getRawType(parameterUpperBound6))) {
+                    throw Utils.parameterError(this.method, i, "@PartMap values cannot be MultipartBody.Part. Use @Part List<Part> or a different value type instead.", new Object[0]);
+                }
+                return new ParameterHandler.PartMap(this.method, i, this.retrofit.requestBodyConverter(parameterUpperBound6, annotationArr, this.methodAnnotations), ((PartMap) annotation).encoding());
+            }
+            if (annotation instanceof Body) {
+                validateResolvableType(i, type);
+                if (this.isFormEncoded || this.isMultipart) {
+                    throw Utils.parameterError(this.method, i, "@Body parameters cannot be used with form or multi-part encoding.", new Object[0]);
+                }
+                if (this.gotBody) {
+                    throw Utils.parameterError(this.method, i, "Multiple @Body method annotations found.", new Object[0]);
+                }
+                try {
+                    Converter requestBodyConverter = this.retrofit.requestBodyConverter(type, annotationArr, this.methodAnnotations);
+                    this.gotBody = true;
+                    return new ParameterHandler.Body(this.method, i, requestBodyConverter);
+                } catch (RuntimeException e4) {
+                    throw Utils.parameterError(this.method, e4, i, "Unable to create @Body converter for %s", type);
+                }
+            }
+            if (!(annotation instanceof Tag)) {
+                return null;
+            }
+            validateResolvableType(i, type);
+            Class<?> rawType10 = Utils.getRawType(type);
+            for (int i4 = i - 1; i4 >= 0; i4--) {
+                ParameterHandler<?> parameterHandler = this.parameterHandlers[i4];
+                if ((parameterHandler instanceof ParameterHandler.Tag) && ((ParameterHandler.Tag) parameterHandler).cls.equals(rawType10)) {
+                    throw Utils.parameterError(this.method, i, "@Tag type " + rawType10.getName() + " is duplicate of parameter #" + (i4 + 1) + " and would always overwrite its value.", new Object[0]);
+                }
+            }
+            return new ParameterHandler.Tag(rawType10);
+        }
+
+        public static Set<String> parsePathParameters(String str) {
+            Matcher matcher = PARAM_URL_REGEX.matcher(str);
+            LinkedHashSet linkedHashSet = new LinkedHashSet();
+            while (matcher.find()) {
+                linkedHashSet.add(matcher.group(1));
+            }
+            return linkedHashSet;
+        }
+
+        private void validatePathName(int i, String str) {
+            if (!PARAM_NAME_REGEX.matcher(str).matches()) {
+                throw Utils.parameterError(this.method, i, "@Path parameter name must match %s. Found: %s", PARAM_URL_REGEX.pattern(), str);
+            }
+            if (!this.relativeUrlParamNames.contains(str)) {
+                throw Utils.parameterError(this.method, i, "URL \"%s\" does not contain \"{%s}\".", this.relativeUrl, str);
+            }
+        }
+
+        private void validateResolvableType(int i, Type type) {
+            if (Utils.hasUnresolvableType(type)) {
+                throw Utils.parameterError(this.method, i, "Parameter type must not include a type variable or wildcard: %s", type);
+            }
+        }
+
+        public RequestFactory build() {
+            for (Annotation annotation : this.methodAnnotations) {
+                parseMethodAnnotation(annotation);
+            }
+            if (this.httpMethod == null) {
+                throw Utils.methodError(this.method, "HTTP method annotation is required (e.g., @GET, @POST, etc.).", new Object[0]);
+            }
+            if (!this.hasBody) {
+                if (this.isMultipart) {
+                    throw Utils.methodError(this.method, "Multipart can only be specified on HTTP methods with request body (e.g., @POST).", new Object[0]);
+                }
+                if (this.isFormEncoded) {
+                    throw Utils.methodError(this.method, "FormUrlEncoded can only be specified on HTTP methods with request body (e.g., @POST).", new Object[0]);
+                }
+            }
+            int length = this.parameterAnnotationsArray.length;
+            this.parameterHandlers = new ParameterHandler[length];
+            int i = length - 1;
+            int i4 = 0;
+            while (i4 < length) {
+                this.parameterHandlers[i4] = parseParameter(i4, this.parameterTypes[i4], this.parameterAnnotationsArray[i4], i4 == i);
+                i4++;
+            }
+            if (this.relativeUrl == null && !this.gotUrl) {
+                throw Utils.methodError(this.method, "Missing either @%s URL or @Url parameter.", this.httpMethod);
+            }
+            boolean z3 = this.isFormEncoded;
+            if (!z3 && !this.isMultipart && !this.hasBody && this.gotBody) {
+                throw Utils.methodError(this.method, "Non-body HTTP method cannot contain @Body.", new Object[0]);
+            }
+            if (z3 && !this.gotField) {
+                throw Utils.methodError(this.method, "Form-encoded method must contain at least one @Field.", new Object[0]);
+            }
+            if (!this.isMultipart || this.gotPart) {
+                return new RequestFactory(this);
+            }
+            throw Utils.methodError(this.method, "Multipart method must contain at least one @Part.", new Object[0]);
+        }
+    }
+
+    public RequestFactory(Builder builder) {
+        this.method = builder.method;
+        this.baseUrl = builder.retrofit.baseUrl;
+        this.httpMethod = builder.httpMethod;
+        this.relativeUrl = builder.relativeUrl;
+        this.headers = builder.headers;
+        this.contentType = builder.contentType;
+        this.hasBody = builder.hasBody;
+        this.isFormEncoded = builder.isFormEncoded;
+        this.isMultipart = builder.isMultipart;
+        this.parameterHandlers = builder.parameterHandlers;
+        this.isKotlinSuspendFunction = builder.isKotlinSuspendFunction;
+    }
+
+    public static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
+        return new Builder(retrofit, method).build();
+    }
+
+    public I create(Object[] objArr) throws IOException {
+        ParameterHandler<?>[] parameterHandlerArr = this.parameterHandlers;
+        int length = objArr.length;
+        if (length != parameterHandlerArr.length) {
+            throw new IllegalArgumentException(com.google.android.gms.measurement.internal.a.m(C.w.t(length, "Argument count (", ") doesn't match expected count ("), parameterHandlerArr.length, ")"));
+        }
+        RequestBuilder requestBuilder = new RequestBuilder(this.httpMethod, this.baseUrl, this.relativeUrl, this.headers, this.contentType, this.hasBody, this.isFormEncoded, this.isMultipart);
+        if (this.isKotlinSuspendFunction) {
+            length--;
+        }
+        ArrayList arrayList = new ArrayList(length);
+        for (int i = 0; i < length; i++) {
+            arrayList.add(objArr[i]);
+            parameterHandlerArr[i].apply(requestBuilder, objArr[i]);
+        }
+        H h = requestBuilder.get();
+        h.f(Invocation.class, new Invocation(this.method, arrayList));
+        return h.a();
+    }
+}

apk_decompiled/sources/retrofit2/Response.java

@@ -0,0 +1,143 @@
+package retrofit2;
+
+import e3.C0334u;
+import e3.G;
+import e3.H;
+import e3.I;
+import e3.N;
+import e3.O;
+import e3.T;
+import java.util.ArrayList;
+import java.util.Objects;
+import kotlin.jvm.internal.Intrinsics;
+import retrofit2.OkHttpCall;
+
+/* loaded from: classes3.dex */
+public final class Response<T> {
+    private final T body;
+    private final T errorBody;
+    private final O rawResponse;
+
+    private Response(O o4, T t2, T t4) {
+        this.rawResponse = o4;
+        this.body = t2;
+        this.errorBody = t4;
+    }
+
+    public static <T> Response<T> error(int i, T t2) {
+        Objects.requireNonNull(t2, "body == null");
+        if (i >= 400) {
+            ArrayList arrayList = new ArrayList(20);
+            OkHttpCall.NoContentResponseBody noContentResponseBody = new OkHttpCall.NoContentResponseBody(t2.contentType(), t2.contentLength());
+            Intrinsics.checkNotNullParameter("Response.error()", "message");
+            G protocol = G.HTTP_1_1;
+            Intrinsics.checkNotNullParameter(protocol, "protocol");
+            H h = new H();
+            h.g("http://localhost/");
+            I request = h.a();
+            Intrinsics.checkNotNullParameter(request, "request");
+            if (i >= 0) {
+                return error(t2, new O(request, protocol, "Response.error()", i, null, new C0334u((String[]) arrayList.toArray(new String[0])), noContentResponseBody, null, null, null, 0L, 0L, null));
+            }
+            throw new IllegalStateException(com.google.android.gms.measurement.internal.a.l(i, "code < 0: ").toString());
+        }
+        throw new IllegalArgumentException(com.google.android.gms.measurement.internal.a.l(i, "code < 400: "));
+    }
+
+    public static <T> Response<T> success(T t2, C0334u c0334u) {
+        Objects.requireNonNull(c0334u, "headers == null");
+        N n4 = new N();
+        n4.f6282c = 200;
+        Intrinsics.checkNotNullParameter("OK", "message");
+        n4.f6283d = "OK";
+        G protocol = G.HTTP_1_1;
+        Intrinsics.checkNotNullParameter(protocol, "protocol");
+        n4.f6281b = protocol;
+        n4.c(c0334u);
+        H h = new H();
+        h.g("http://localhost/");
+        I request = h.a();
+        Intrinsics.checkNotNullParameter(request, "request");
+        n4.f6280a = request;
+        return success(t2, n4.a());
+    }
+
+    public T body() {
+        return this.body;
+    }
+
+    public int code() {
+        return this.rawResponse.f6294d;
+    }
+
+    public T errorBody() {
+        return this.errorBody;
+    }
+
+    public C0334u headers() {
+        return this.rawResponse.f6296f;
+    }
+
+    public boolean isSuccessful() {
+        return this.rawResponse.e();
+    }
+
+    public String message() {
+        return this.rawResponse.f6293c;
+    }
+
+    public O raw() {
+        return this.rawResponse;
+    }
+
+    public String toString() {
+        return this.rawResponse.toString();
+    }
+
+    public static <T> Response<T> success(T t2, O o4) {
+        Objects.requireNonNull(o4, "rawResponse == null");
+        if (o4.e()) {
+            return new Response<>(o4, t2, null);
+        }
+        throw new IllegalArgumentException("rawResponse must be successful response");
+    }
+
+    public static <T> Response<T> success(int i, T t2) {
+        if (i >= 200 && i < 300) {
+            ArrayList arrayList = new ArrayList(20);
+            Intrinsics.checkNotNullParameter("Response.success()", "message");
+            G protocol = G.HTTP_1_1;
+            Intrinsics.checkNotNullParameter(protocol, "protocol");
+            H h = new H();
+            h.g("http://localhost/");
+            I request = h.a();
+            Intrinsics.checkNotNullParameter(request, "request");
+            if (i >= 0) {
+                return success(t2, new O(request, protocol, "Response.success()", i, null, new C0334u((String[]) arrayList.toArray(new String[0])), null, null, null, null, 0L, 0L, null));
+            }
+            throw new IllegalStateException(com.google.android.gms.measurement.internal.a.l(i, "code < 0: ").toString());
+        }
+        throw new IllegalArgumentException(com.google.android.gms.measurement.internal.a.l(i, "code < 200 or >= 300: "));
+    }
+
+    public static <T> Response<T> error(T t2, O o4) {
+        Objects.requireNonNull(t2, "body == null");
+        Objects.requireNonNull(o4, "rawResponse == null");
+        if (!o4.e()) {
+            return new Response<>(o4, null, t2);
+        }
+        throw new IllegalArgumentException("rawResponse should not be successful response");
+    }
+
+    public static <T> Response<T> success(T t2) {
+        ArrayList arrayList = new ArrayList(20);
+        Intrinsics.checkNotNullParameter("OK", "message");
+        G protocol = G.HTTP_1_1;
+        Intrinsics.checkNotNullParameter(protocol, "protocol");
+        H h = new H();
+        h.g("http://localhost/");
+        I request = h.a();
+        Intrinsics.checkNotNullParameter(request, "request");
+        return success(t2, new O(request, protocol, "OK", 200, null, new C0334u((String[]) arrayList.toArray(new String[0])), null, null, null, null, 0L, 0L, null));
+    }
+}

apk_decompiled/sources/retrofit2/Retrofit.java

@@ -0,0 +1,394 @@
+package retrofit2;
+
+import e3.C0335v;
+import e3.F;
+import e3.InterfaceC0318d;
+import e3.M;
+import e3.T;
+import e3.w;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Proxy;
+import java.lang.reflect.Type;
+import java.net.URL;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+import kotlin.jvm.internal.Intrinsics;
+import retrofit2.BuiltInConverters;
+import retrofit2.CallAdapter;
+import retrofit2.Converter;
+
+/* loaded from: classes3.dex */
+public final class Retrofit {
+    final w baseUrl;
+    final List<CallAdapter.Factory> callAdapterFactories;
+    final InterfaceC0318d callFactory;
+    final Executor callbackExecutor;
+    final List<Converter.Factory> converterFactories;
+    private final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap();
+    final boolean validateEagerly;
+
+    public Retrofit(InterfaceC0318d interfaceC0318d, w wVar, List<Converter.Factory> list, List<CallAdapter.Factory> list2, Executor executor, boolean z3) {
+        this.callFactory = interfaceC0318d;
+        this.baseUrl = wVar;
+        this.converterFactories = list;
+        this.callAdapterFactories = list2;
+        this.callbackExecutor = executor;
+        this.validateEagerly = z3;
+    }
+
+    private void validateServiceInterface(Class<?> cls) {
+        if (!cls.isInterface()) {
+            throw new IllegalArgumentException("API declarations must be interfaces.");
+        }
+        ArrayDeque arrayDeque = new ArrayDeque(1);
+        arrayDeque.add(cls);
+        while (!arrayDeque.isEmpty()) {
+            Class<?> cls2 = (Class) arrayDeque.removeFirst();
+            if (cls2.getTypeParameters().length != 0) {
+                StringBuilder sb = new StringBuilder("Type parameters are unsupported on ");
+                sb.append(cls2.getName());
+                if (cls2 != cls) {
+                    sb.append(" which is an interface of ");
+                    sb.append(cls.getName());
+                }
+                throw new IllegalArgumentException(sb.toString());
+            }
+            Collections.addAll(arrayDeque, cls2.getInterfaces());
+        }
+        if (this.validateEagerly) {
+            Platform platform = Platform.get();
+            for (Method method : cls.getDeclaredMethods()) {
+                if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
+                    loadServiceMethod(method);
+                }
+            }
+        }
+    }
+
+    public w baseUrl() {
+        return this.baseUrl;
+    }
+
+    public CallAdapter<?, ?> callAdapter(Type type, Annotation[] annotationArr) {
+        return nextCallAdapter(null, type, annotationArr);
+    }
+
+    public List<CallAdapter.Factory> callAdapterFactories() {
+        return this.callAdapterFactories;
+    }
+
+    public InterfaceC0318d callFactory() {
+        return this.callFactory;
+    }
+
+    public Executor callbackExecutor() {
+        return this.callbackExecutor;
+    }
+
+    public List<Converter.Factory> converterFactories() {
+        return this.converterFactories;
+    }
+
+    public <T> T create(final Class<T> cls) {
+        validateServiceInterface(cls);
+        return (T) Proxy.newProxyInstance(cls.getClassLoader(), new Class[]{cls}, new InvocationHandler() { // from class: retrofit2.Retrofit.1
+            private final Platform platform = Platform.get();
+            private final Object[] emptyArgs = new Object[0];
+
+            @Override // java.lang.reflect.InvocationHandler
+            public Object invoke(Object obj, Method method, Object[] objArr) throws Throwable {
+                if (method.getDeclaringClass() == Object.class) {
+                    return method.invoke(this, objArr);
+                }
+                if (objArr == null) {
+                    objArr = this.emptyArgs;
+                }
+                return this.platform.isDefaultMethod(method) ? this.platform.invokeDefaultMethod(method, cls, obj, objArr) : Retrofit.this.loadServiceMethod(method).invoke(objArr);
+            }
+        });
+    }
+
+    public ServiceMethod<?> loadServiceMethod(Method method) {
+        ServiceMethod<?> serviceMethod;
+        ServiceMethod<?> serviceMethod2 = this.serviceMethodCache.get(method);
+        if (serviceMethod2 != null) {
+            return serviceMethod2;
+        }
+        synchronized (this.serviceMethodCache) {
+            try {
+                serviceMethod = this.serviceMethodCache.get(method);
+                if (serviceMethod == null) {
+                    serviceMethod = ServiceMethod.parseAnnotations(this, method);
+                    this.serviceMethodCache.put(method, serviceMethod);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return serviceMethod;
+    }
+
+    public Builder newBuilder() {
+        return new Builder(this);
+    }
+
+    public CallAdapter<?, ?> nextCallAdapter(CallAdapter.Factory factory, Type type, Annotation[] annotationArr) {
+        Objects.requireNonNull(type, "returnType == null");
+        Objects.requireNonNull(annotationArr, "annotations == null");
+        int indexOf = this.callAdapterFactories.indexOf(factory) + 1;
+        int size = this.callAdapterFactories.size();
+        for (int i = indexOf; i < size; i++) {
+            CallAdapter<?, ?> callAdapter = this.callAdapterFactories.get(i).get(type, annotationArr, this);
+            if (callAdapter != null) {
+                return callAdapter;
+            }
+        }
+        StringBuilder sb = new StringBuilder("Could not locate call adapter for ");
+        sb.append(type);
+        sb.append(".\n");
+        if (factory != null) {
+            sb.append("  Skipped:");
+            for (int i4 = 0; i4 < indexOf; i4++) {
+                sb.append("\n   * ");
+                sb.append(this.callAdapterFactories.get(i4).getClass().getName());
+            }
+            sb.append('\n');
+        }
+        sb.append("  Tried:");
+        int size2 = this.callAdapterFactories.size();
+        while (indexOf < size2) {
+            sb.append("\n   * ");
+            sb.append(this.callAdapterFactories.get(indexOf).getClass().getName());
+            indexOf++;
+        }
+        throw new IllegalArgumentException(sb.toString());
+    }
+
+    public <T> Converter<T, M> nextRequestBodyConverter(Converter.Factory factory, Type type, Annotation[] annotationArr, Annotation[] annotationArr2) {
+        Objects.requireNonNull(type, "type == null");
+        Objects.requireNonNull(annotationArr, "parameterAnnotations == null");
+        Objects.requireNonNull(annotationArr2, "methodAnnotations == null");
+        int indexOf = this.converterFactories.indexOf(factory) + 1;
+        int size = this.converterFactories.size();
+        for (int i = indexOf; i < size; i++) {
+            Converter<T, M> converter = (Converter<T, M>) this.converterFactories.get(i).requestBodyConverter(type, annotationArr, annotationArr2, this);
+            if (converter != null) {
+                return converter;
+            }
+        }
+        StringBuilder sb = new StringBuilder("Could not locate RequestBody converter for ");
+        sb.append(type);
+        sb.append(".\n");
+        if (factory != null) {
+            sb.append("  Skipped:");
+            for (int i4 = 0; i4 < indexOf; i4++) {
+                sb.append("\n   * ");
+                sb.append(this.converterFactories.get(i4).getClass().getName());
+            }
+            sb.append('\n');
+        }
+        sb.append("  Tried:");
+        int size2 = this.converterFactories.size();
+        while (indexOf < size2) {
+            sb.append("\n   * ");
+            sb.append(this.converterFactories.get(indexOf).getClass().getName());
+            indexOf++;
+        }
+        throw new IllegalArgumentException(sb.toString());
+    }
+
+    public <T> Converter<T, T> nextResponseBodyConverter(Converter.Factory factory, Type type, Annotation[] annotationArr) {
+        Objects.requireNonNull(type, "type == null");
+        Objects.requireNonNull(annotationArr, "annotations == null");
+        int indexOf = this.converterFactories.indexOf(factory) + 1;
+        int size = this.converterFactories.size();
+        for (int i = indexOf; i < size; i++) {
+            Converter<T, T> converter = (Converter<T, T>) this.converterFactories.get(i).responseBodyConverter(type, annotationArr, this);
+            if (converter != null) {
+                return converter;
+            }
+        }
+        StringBuilder sb = new StringBuilder("Could not locate ResponseBody converter for ");
+        sb.append(type);
+        sb.append(".\n");
+        if (factory != null) {
+            sb.append("  Skipped:");
+            for (int i4 = 0; i4 < indexOf; i4++) {
+                sb.append("\n   * ");
+                sb.append(this.converterFactories.get(i4).getClass().getName());
+            }
+            sb.append('\n');
+        }
+        sb.append("  Tried:");
+        int size2 = this.converterFactories.size();
+        while (indexOf < size2) {
+            sb.append("\n   * ");
+            sb.append(this.converterFactories.get(indexOf).getClass().getName());
+            indexOf++;
+        }
+        throw new IllegalArgumentException(sb.toString());
+    }
+
+    public <T> Converter<T, M> requestBodyConverter(Type type, Annotation[] annotationArr, Annotation[] annotationArr2) {
+        return nextRequestBodyConverter(null, type, annotationArr, annotationArr2);
+    }
+
+    public <T> Converter<T, T> responseBodyConverter(Type type, Annotation[] annotationArr) {
+        return nextResponseBodyConverter(null, type, annotationArr);
+    }
+
+    public <T> Converter<T, String> stringConverter(Type type, Annotation[] annotationArr) {
+        Objects.requireNonNull(type, "type == null");
+        Objects.requireNonNull(annotationArr, "annotations == null");
+        int size = this.converterFactories.size();
+        for (int i = 0; i < size; i++) {
+            Converter<T, String> converter = (Converter<T, String>) this.converterFactories.get(i).stringConverter(type, annotationArr, this);
+            if (converter != null) {
+                return converter;
+            }
+        }
+        return BuiltInConverters.ToStringConverter.INSTANCE;
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Builder {
+        private w baseUrl;
+        private final List<CallAdapter.Factory> callAdapterFactories;
+        private InterfaceC0318d callFactory;
+        private Executor callbackExecutor;
+        private final List<Converter.Factory> converterFactories;
+        private final Platform platform;
+        private boolean validateEagerly;
+
+        public Builder(Platform platform) {
+            this.converterFactories = new ArrayList();
+            this.callAdapterFactories = new ArrayList();
+            this.platform = platform;
+        }
+
+        public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
+            List<CallAdapter.Factory> list = this.callAdapterFactories;
+            Objects.requireNonNull(factory, "factory == null");
+            list.add(factory);
+            return this;
+        }
+
+        public Builder addConverterFactory(Converter.Factory factory) {
+            List<Converter.Factory> list = this.converterFactories;
+            Objects.requireNonNull(factory, "factory == null");
+            list.add(factory);
+            return this;
+        }
+
+        public Builder baseUrl(URL url) {
+            Objects.requireNonNull(url, "baseUrl == null");
+            String url2 = url.toString();
+            Intrinsics.checkNotNullParameter(url2, "<this>");
+            C0335v c0335v = new C0335v();
+            c0335v.d(null, url2);
+            return baseUrl(c0335v.a());
+        }
+
+        public Retrofit build() {
+            if (this.baseUrl == null) {
+                throw new IllegalStateException("Base URL required.");
+            }
+            InterfaceC0318d interfaceC0318d = this.callFactory;
+            if (interfaceC0318d == null) {
+                interfaceC0318d = new F();
+            }
+            InterfaceC0318d interfaceC0318d2 = interfaceC0318d;
+            Executor executor = this.callbackExecutor;
+            if (executor == null) {
+                executor = this.platform.defaultCallbackExecutor();
+            }
+            Executor executor2 = executor;
+            ArrayList arrayList = new ArrayList(this.callAdapterFactories);
+            arrayList.addAll(this.platform.defaultCallAdapterFactories(executor2));
+            ArrayList arrayList2 = new ArrayList(this.converterFactories.size() + 1 + this.platform.defaultConverterFactoriesSize());
+            arrayList2.add(new BuiltInConverters());
+            arrayList2.addAll(this.converterFactories);
+            arrayList2.addAll(this.platform.defaultConverterFactories());
+            return new Retrofit(interfaceC0318d2, this.baseUrl, Collections.unmodifiableList(arrayList2), Collections.unmodifiableList(arrayList), executor2, this.validateEagerly);
+        }
+
+        public List<CallAdapter.Factory> callAdapterFactories() {
+            return this.callAdapterFactories;
+        }
+
+        public Builder callFactory(InterfaceC0318d interfaceC0318d) {
+            Objects.requireNonNull(interfaceC0318d, "factory == null");
+            this.callFactory = interfaceC0318d;
+            return this;
+        }
+
+        public Builder callbackExecutor(Executor executor) {
+            Objects.requireNonNull(executor, "executor == null");
+            this.callbackExecutor = executor;
+            return this;
+        }
+
+        public Builder client(F f2) {
+            Objects.requireNonNull(f2, "client == null");
+            return callFactory(f2);
+        }
+
+        public List<Converter.Factory> converterFactories() {
+            return this.converterFactories;
+        }
+
+        public Builder validateEagerly(boolean z3) {
+            this.validateEagerly = z3;
+            return this;
+        }
+
+        public Builder() {
+            this(Platform.get());
+        }
+
+        public Builder(Retrofit retrofit) {
+            this.converterFactories = new ArrayList();
+            this.callAdapterFactories = new ArrayList();
+            Platform platform = Platform.get();
+            this.platform = platform;
+            this.callFactory = retrofit.callFactory;
+            this.baseUrl = retrofit.baseUrl;
+            int size = retrofit.converterFactories.size() - platform.defaultConverterFactoriesSize();
+            for (int i = 1; i < size; i++) {
+                this.converterFactories.add(retrofit.converterFactories.get(i));
+            }
+            int size2 = retrofit.callAdapterFactories.size() - this.platform.defaultCallAdapterFactoriesSize();
+            for (int i4 = 0; i4 < size2; i4++) {
+                this.callAdapterFactories.add(retrofit.callAdapterFactories.get(i4));
+            }
+            this.callbackExecutor = retrofit.callbackExecutor;
+            this.validateEagerly = retrofit.validateEagerly;
+        }
+
+        public Builder baseUrl(String str) {
+            Objects.requireNonNull(str, "baseUrl == null");
+            Intrinsics.checkNotNullParameter(str, "<this>");
+            C0335v c0335v = new C0335v();
+            c0335v.d(null, str);
+            return baseUrl(c0335v.a());
+        }
+
+        public Builder baseUrl(w wVar) {
+            Objects.requireNonNull(wVar, "baseUrl == null");
+            if ("".equals(wVar.f6418f.get(r0.size() - 1))) {
+                this.baseUrl = wVar;
+                return this;
+            }
+            throw new IllegalArgumentException("baseUrl must end in /: " + wVar);
+        }
+    }
+}

apk_decompiled/sources/retrofit2/ServiceMethod.java

@@ -0,0 +1,21 @@
+package retrofit2;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+
+/* loaded from: classes3.dex */
+abstract class ServiceMethod<T> {
+    public static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
+        RequestFactory parseAnnotations = RequestFactory.parseAnnotations(retrofit, method);
+        Type genericReturnType = method.getGenericReturnType();
+        if (Utils.hasUnresolvableType(genericReturnType)) {
+            throw Utils.methodError(method, "Method return type must not include a type variable or wildcard: %s", genericReturnType);
+        }
+        if (genericReturnType != Void.TYPE) {
+            return HttpServiceMethod.parseAnnotations(retrofit, method, parseAnnotations);
+        }
+        throw Utils.methodError(method, "Service methods cannot return void.", new Object[0]);
+    }
+
+    public abstract T invoke(Object[] objArr);
+}

apk_decompiled/sources/retrofit2/SkipCallbackExecutor.java

@@ -0,0 +1,14 @@
+package retrofit2;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface SkipCallbackExecutor {
+}

apk_decompiled/sources/retrofit2/SkipCallbackExecutorImpl.java

@@ -0,0 +1,38 @@
+package retrofit2;
+
+import java.lang.annotation.Annotation;
+
+/* loaded from: classes3.dex */
+final class SkipCallbackExecutorImpl implements SkipCallbackExecutor {
+    private static final SkipCallbackExecutor INSTANCE = new SkipCallbackExecutorImpl();
+
+    public static Annotation[] ensurePresent(Annotation[] annotationArr) {
+        if (Utils.isAnnotationPresent(annotationArr, SkipCallbackExecutor.class)) {
+            return annotationArr;
+        }
+        Annotation[] annotationArr2 = new Annotation[annotationArr.length + 1];
+        annotationArr2[0] = INSTANCE;
+        System.arraycopy(annotationArr, 0, annotationArr2, 1, annotationArr.length);
+        return annotationArr2;
+    }
+
+    @Override // java.lang.annotation.Annotation
+    public Class<? extends Annotation> annotationType() {
+        return SkipCallbackExecutor.class;
+    }
+
+    @Override // java.lang.annotation.Annotation
+    public boolean equals(Object obj) {
+        return obj instanceof SkipCallbackExecutor;
+    }
+
+    @Override // java.lang.annotation.Annotation
+    public int hashCode() {
+        return 0;
+    }
+
+    @Override // java.lang.annotation.Annotation
+    public String toString() {
+        return "@" + SkipCallbackExecutor.class.getName() + "()";
+    }
+}

apk_decompiled/sources/retrofit2/Utils.java

@@ -0,0 +1,467 @@
+package retrofit2;
+
+import C.w;
+import e3.T;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import r3.InterfaceC0578j;
+
+/* loaded from: classes3.dex */
+final class Utils {
+    static final Type[] EMPTY_TYPE_ARRAY = new Type[0];
+
+    /* loaded from: classes3.dex */
+    public static final class GenericArrayTypeImpl implements GenericArrayType {
+        private final Type componentType;
+
+        public GenericArrayTypeImpl(Type type) {
+            this.componentType = type;
+        }
+
+        public boolean equals(Object obj) {
+            return (obj instanceof GenericArrayType) && Utils.equals(this, (GenericArrayType) obj);
+        }
+
+        @Override // java.lang.reflect.GenericArrayType
+        public Type getGenericComponentType() {
+            return this.componentType;
+        }
+
+        public int hashCode() {
+            return this.componentType.hashCode();
+        }
+
+        public String toString() {
+            return w.r(new StringBuilder(), Utils.typeToString(this.componentType), "[]");
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class ParameterizedTypeImpl implements ParameterizedType {
+        private final Type ownerType;
+        private final Type rawType;
+        private final Type[] typeArguments;
+
+        public ParameterizedTypeImpl(Type type, Type type2, Type... typeArr) {
+            if (type2 instanceof Class) {
+                if ((type == null) != (((Class) type2).getEnclosingClass() == null)) {
+                    throw new IllegalArgumentException();
+                }
+            }
+            for (Type type3 : typeArr) {
+                Objects.requireNonNull(type3, "typeArgument == null");
+                Utils.checkNotPrimitive(type3);
+            }
+            this.ownerType = type;
+            this.rawType = type2;
+            this.typeArguments = (Type[]) typeArr.clone();
+        }
+
+        public boolean equals(Object obj) {
+            return (obj instanceof ParameterizedType) && Utils.equals(this, (ParameterizedType) obj);
+        }
+
+        @Override // java.lang.reflect.ParameterizedType
+        public Type[] getActualTypeArguments() {
+            return (Type[]) this.typeArguments.clone();
+        }
+
+        @Override // java.lang.reflect.ParameterizedType
+        public Type getOwnerType() {
+            return this.ownerType;
+        }
+
+        @Override // java.lang.reflect.ParameterizedType
+        public Type getRawType() {
+            return this.rawType;
+        }
+
+        public int hashCode() {
+            int hashCode = Arrays.hashCode(this.typeArguments) ^ this.rawType.hashCode();
+            Type type = this.ownerType;
+            return (type != null ? type.hashCode() : 0) ^ hashCode;
+        }
+
+        public String toString() {
+            Type[] typeArr = this.typeArguments;
+            if (typeArr.length == 0) {
+                return Utils.typeToString(this.rawType);
+            }
+            StringBuilder sb = new StringBuilder((typeArr.length + 1) * 30);
+            sb.append(Utils.typeToString(this.rawType));
+            sb.append("<");
+            sb.append(Utils.typeToString(this.typeArguments[0]));
+            for (int i = 1; i < this.typeArguments.length; i++) {
+                sb.append(", ");
+                sb.append(Utils.typeToString(this.typeArguments[i]));
+            }
+            sb.append(">");
+            return sb.toString();
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class WildcardTypeImpl implements WildcardType {
+        private final Type lowerBound;
+        private final Type upperBound;
+
+        public WildcardTypeImpl(Type[] typeArr, Type[] typeArr2) {
+            if (typeArr2.length > 1) {
+                throw new IllegalArgumentException();
+            }
+            if (typeArr.length != 1) {
+                throw new IllegalArgumentException();
+            }
+            if (typeArr2.length != 1) {
+                typeArr[0].getClass();
+                Utils.checkNotPrimitive(typeArr[0]);
+                this.lowerBound = null;
+                this.upperBound = typeArr[0];
+                return;
+            }
+            typeArr2[0].getClass();
+            Utils.checkNotPrimitive(typeArr2[0]);
+            if (typeArr[0] != Object.class) {
+                throw new IllegalArgumentException();
+            }
+            this.lowerBound = typeArr2[0];
+            this.upperBound = Object.class;
+        }
+
+        public boolean equals(Object obj) {
+            return (obj instanceof WildcardType) && Utils.equals(this, (WildcardType) obj);
+        }
+
+        @Override // java.lang.reflect.WildcardType
+        public Type[] getLowerBounds() {
+            Type type = this.lowerBound;
+            return type != null ? new Type[]{type} : Utils.EMPTY_TYPE_ARRAY;
+        }
+
+        @Override // java.lang.reflect.WildcardType
+        public Type[] getUpperBounds() {
+            return new Type[]{this.upperBound};
+        }
+
+        public int hashCode() {
+            Type type = this.lowerBound;
+            return (this.upperBound.hashCode() + 31) ^ (type != null ? type.hashCode() + 31 : 1);
+        }
+
+        public String toString() {
+            if (this.lowerBound != null) {
+                return "? super " + Utils.typeToString(this.lowerBound);
+            }
+            if (this.upperBound == Object.class) {
+                return "?";
+            }
+            return "? extends " + Utils.typeToString(this.upperBound);
+        }
+    }
+
+    private Utils() {
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v0, types: [r3.i, r3.j, java.lang.Object] */
+    public static T buffer(T t2) throws IOException {
+        ?? obj = new Object();
+        t2.source().U(obj);
+        return T.create(t2.contentType(), t2.contentLength(), (InterfaceC0578j) obj);
+    }
+
+    public static void checkNotPrimitive(Type type) {
+        if ((type instanceof Class) && ((Class) type).isPrimitive()) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    private static Class<?> declaringClassOf(TypeVariable<?> typeVariable) {
+        Object genericDeclaration = typeVariable.getGenericDeclaration();
+        if (genericDeclaration instanceof Class) {
+            return (Class) genericDeclaration;
+        }
+        return null;
+    }
+
+    public static boolean equals(Type type, Type type2) {
+        if (type == type2) {
+            return true;
+        }
+        if (type instanceof Class) {
+            return type.equals(type2);
+        }
+        if (type instanceof ParameterizedType) {
+            if (!(type2 instanceof ParameterizedType)) {
+                return false;
+            }
+            ParameterizedType parameterizedType = (ParameterizedType) type;
+            ParameterizedType parameterizedType2 = (ParameterizedType) type2;
+            Type ownerType = parameterizedType.getOwnerType();
+            Type ownerType2 = parameterizedType2.getOwnerType();
+            return (ownerType == ownerType2 || (ownerType != null && ownerType.equals(ownerType2))) && parameterizedType.getRawType().equals(parameterizedType2.getRawType()) && Arrays.equals(parameterizedType.getActualTypeArguments(), parameterizedType2.getActualTypeArguments());
+        }
+        if (type instanceof GenericArrayType) {
+            if (type2 instanceof GenericArrayType) {
+                return equals(((GenericArrayType) type).getGenericComponentType(), ((GenericArrayType) type2).getGenericComponentType());
+            }
+            return false;
+        }
+        if (type instanceof WildcardType) {
+            if (!(type2 instanceof WildcardType)) {
+                return false;
+            }
+            WildcardType wildcardType = (WildcardType) type;
+            WildcardType wildcardType2 = (WildcardType) type2;
+            return Arrays.equals(wildcardType.getUpperBounds(), wildcardType2.getUpperBounds()) && Arrays.equals(wildcardType.getLowerBounds(), wildcardType2.getLowerBounds());
+        }
+        if (!(type instanceof TypeVariable) || !(type2 instanceof TypeVariable)) {
+            return false;
+        }
+        TypeVariable typeVariable = (TypeVariable) type;
+        TypeVariable typeVariable2 = (TypeVariable) type2;
+        return typeVariable.getGenericDeclaration() == typeVariable2.getGenericDeclaration() && typeVariable.getName().equals(typeVariable2.getName());
+    }
+
+    public static Type getGenericSupertype(Type type, Class<?> cls, Class<?> cls2) {
+        if (cls2 == cls) {
+            return type;
+        }
+        if (cls2.isInterface()) {
+            Class<?>[] interfaces = cls.getInterfaces();
+            int length = interfaces.length;
+            for (int i = 0; i < length; i++) {
+                Class<?> cls3 = interfaces[i];
+                if (cls3 == cls2) {
+                    return cls.getGenericInterfaces()[i];
+                }
+                if (cls2.isAssignableFrom(cls3)) {
+                    return getGenericSupertype(cls.getGenericInterfaces()[i], interfaces[i], cls2);
+                }
+            }
+        }
+        if (!cls.isInterface()) {
+            while (cls != Object.class) {
+                Class<? super Object> superclass = cls.getSuperclass();
+                if (superclass == cls2) {
+                    return cls.getGenericSuperclass();
+                }
+                if (cls2.isAssignableFrom(superclass)) {
+                    return getGenericSupertype(cls.getGenericSuperclass(), superclass, cls2);
+                }
+                cls = superclass;
+            }
+        }
+        return cls2;
+    }
+
+    public static Type getParameterLowerBound(int i, ParameterizedType parameterizedType) {
+        Type type = parameterizedType.getActualTypeArguments()[i];
+        return type instanceof WildcardType ? ((WildcardType) type).getLowerBounds()[0] : type;
+    }
+
+    public static Type getParameterUpperBound(int i, ParameterizedType parameterizedType) {
+        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
+        if (i >= 0 && i < actualTypeArguments.length) {
+            Type type = actualTypeArguments[i];
+            return type instanceof WildcardType ? ((WildcardType) type).getUpperBounds()[0] : type;
+        }
+        StringBuilder t2 = w.t(i, "Index ", " not in range [0,");
+        t2.append(actualTypeArguments.length);
+        t2.append(") for ");
+        t2.append(parameterizedType);
+        throw new IllegalArgumentException(t2.toString());
+    }
+
+    public static Class<?> getRawType(Type type) {
+        Objects.requireNonNull(type, "type == null");
+        if (type instanceof Class) {
+            return (Class) type;
+        }
+        if (type instanceof ParameterizedType) {
+            Type rawType = ((ParameterizedType) type).getRawType();
+            if (rawType instanceof Class) {
+                return (Class) rawType;
+            }
+            throw new IllegalArgumentException();
+        }
+        if (type instanceof GenericArrayType) {
+            return Array.newInstance(getRawType(((GenericArrayType) type).getGenericComponentType()), 0).getClass();
+        }
+        if (type instanceof TypeVariable) {
+            return Object.class;
+        }
+        if (type instanceof WildcardType) {
+            return getRawType(((WildcardType) type).getUpperBounds()[0]);
+        }
+        throw new IllegalArgumentException("Expected a Class, ParameterizedType, or GenericArrayType, but <" + type + "> is of type " + type.getClass().getName());
+    }
+
+    public static Type getSupertype(Type type, Class<?> cls, Class<?> cls2) {
+        if (cls2.isAssignableFrom(cls)) {
+            return resolve(type, cls, getGenericSupertype(type, cls, cls2));
+        }
+        throw new IllegalArgumentException();
+    }
+
+    public static boolean hasUnresolvableType(Type type) {
+        if (type instanceof Class) {
+            return false;
+        }
+        if (type instanceof ParameterizedType) {
+            for (Type type2 : ((ParameterizedType) type).getActualTypeArguments()) {
+                if (hasUnresolvableType(type2)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if (type instanceof GenericArrayType) {
+            return hasUnresolvableType(((GenericArrayType) type).getGenericComponentType());
+        }
+        if ((type instanceof TypeVariable) || (type instanceof WildcardType)) {
+            return true;
+        }
+        throw new IllegalArgumentException("Expected a Class, ParameterizedType, or GenericArrayType, but <" + type + "> is of type " + (type == null ? "null" : type.getClass().getName()));
+    }
+
+    private static int indexOf(Object[] objArr, Object obj) {
+        for (int i = 0; i < objArr.length; i++) {
+            if (obj.equals(objArr[i])) {
+                return i;
+            }
+        }
+        throw new NoSuchElementException();
+    }
+
+    public static boolean isAnnotationPresent(Annotation[] annotationArr, Class<? extends Annotation> cls) {
+        for (Annotation annotation : annotationArr) {
+            if (cls.isInstance(annotation)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static RuntimeException methodError(Method method, String str, Object... objArr) {
+        return methodError(method, null, str, objArr);
+    }
+
+    public static RuntimeException parameterError(Method method, Throwable th, int i, String str, Object... objArr) {
+        return methodError(method, th, str + " (parameter #" + (i + 1) + ")", objArr);
+    }
+
+    public static Type resolve(Type type, Class<?> cls, Type type2) {
+        Type type3 = type2;
+        while (type3 instanceof TypeVariable) {
+            TypeVariable typeVariable = (TypeVariable) type3;
+            Type resolveTypeVariable = resolveTypeVariable(type, cls, typeVariable);
+            if (resolveTypeVariable == typeVariable) {
+                return resolveTypeVariable;
+            }
+            type3 = resolveTypeVariable;
+        }
+        if (type3 instanceof Class) {
+            Class cls2 = (Class) type3;
+            if (cls2.isArray()) {
+                Class<?> componentType = cls2.getComponentType();
+                Type resolve = resolve(type, cls, componentType);
+                return componentType == resolve ? cls2 : new GenericArrayTypeImpl(resolve);
+            }
+        }
+        if (type3 instanceof GenericArrayType) {
+            GenericArrayType genericArrayType = (GenericArrayType) type3;
+            Type genericComponentType = genericArrayType.getGenericComponentType();
+            Type resolve2 = resolve(type, cls, genericComponentType);
+            return genericComponentType == resolve2 ? genericArrayType : new GenericArrayTypeImpl(resolve2);
+        }
+        if (type3 instanceof ParameterizedType) {
+            ParameterizedType parameterizedType = (ParameterizedType) type3;
+            Type ownerType = parameterizedType.getOwnerType();
+            Type resolve3 = resolve(type, cls, ownerType);
+            boolean z3 = resolve3 != ownerType;
+            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
+            int length = actualTypeArguments.length;
+            for (int i = 0; i < length; i++) {
+                Type resolve4 = resolve(type, cls, actualTypeArguments[i]);
+                if (resolve4 != actualTypeArguments[i]) {
+                    if (!z3) {
+                        actualTypeArguments = (Type[]) actualTypeArguments.clone();
+                        z3 = true;
+                    }
+                    actualTypeArguments[i] = resolve4;
+                }
+            }
+            return z3 ? new ParameterizedTypeImpl(resolve3, parameterizedType.getRawType(), actualTypeArguments) : parameterizedType;
+        }
+        boolean z4 = type3 instanceof WildcardType;
+        Type type4 = type3;
+        if (z4) {
+            WildcardType wildcardType = (WildcardType) type3;
+            Type[] lowerBounds = wildcardType.getLowerBounds();
+            Type[] upperBounds = wildcardType.getUpperBounds();
+            if (lowerBounds.length == 1) {
+                Type resolve5 = resolve(type, cls, lowerBounds[0]);
+                type4 = wildcardType;
+                if (resolve5 != lowerBounds[0]) {
+                    return new WildcardTypeImpl(new Type[]{Object.class}, new Type[]{resolve5});
+                }
+            } else {
+                type4 = wildcardType;
+                if (upperBounds.length == 1) {
+                    Type resolve6 = resolve(type, cls, upperBounds[0]);
+                    type4 = wildcardType;
+                    if (resolve6 != upperBounds[0]) {
+                        return new WildcardTypeImpl(new Type[]{resolve6}, EMPTY_TYPE_ARRAY);
+                    }
+                }
+            }
+        }
+        return type4;
+    }
+
+    private static Type resolveTypeVariable(Type type, Class<?> cls, TypeVariable<?> typeVariable) {
+        Class<?> declaringClassOf = declaringClassOf(typeVariable);
+        if (declaringClassOf != null) {
+            Type genericSupertype = getGenericSupertype(type, cls, declaringClassOf);
+            if (genericSupertype instanceof ParameterizedType) {
+                return ((ParameterizedType) genericSupertype).getActualTypeArguments()[indexOf(declaringClassOf.getTypeParameters(), typeVariable)];
+            }
+        }
+        return typeVariable;
+    }
+
+    public static void throwIfFatal(Throwable th) {
+        if (th instanceof VirtualMachineError) {
+            throw ((VirtualMachineError) th);
+        }
+        if (th instanceof ThreadDeath) {
+            throw ((ThreadDeath) th);
+        }
+        if (th instanceof LinkageError) {
+            throw ((LinkageError) th);
+        }
+    }
+
+    public static String typeToString(Type type) {
+        return type instanceof Class ? ((Class) type).getName() : type.toString();
+    }
+
+    public static RuntimeException methodError(Method method, Throwable th, String str, Object... objArr) {
+        return new IllegalArgumentException(String.format(str, objArr) + "\n    for method " + method.getDeclaringClass().getSimpleName() + "." + method.getName(), th);
+    }
+
+    public static RuntimeException parameterError(Method method, int i, String str, Object... objArr) {
+        return methodError(method, str + " (parameter #" + (i + 1) + ")", objArr);
+    }
+}

apk_decompiled/sources/retrofit2/a.java

@@ -0,0 +1,38 @@
+package retrofit2;
+
+import retrofit2.DefaultCallAdapterFactory;
+
+/* loaded from: classes3.dex */
+public final /* synthetic */ class a implements Runnable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f8323a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ DefaultCallAdapterFactory.ExecutorCallbackCall.AnonymousClass1 f8324b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ Callback f8325c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ Object f8326d;
+
+    public /* synthetic */ a(DefaultCallAdapterFactory.ExecutorCallbackCall.AnonymousClass1 anonymousClass1, Callback callback, Object obj, int i) {
+        this.f8323a = i;
+        this.f8324b = anonymousClass1;
+        this.f8325c = callback;
+        this.f8326d = obj;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        switch (this.f8323a) {
+            case 0:
+                DefaultCallAdapterFactory.ExecutorCallbackCall.AnonymousClass1.b(this.f8324b, this.f8325c, (Response) this.f8326d);
+                return;
+            default:
+                DefaultCallAdapterFactory.ExecutorCallbackCall.AnonymousClass1.a(this.f8324b, this.f8325c, (Throwable) this.f8326d);
+                return;
+        }
+    }
+}

apk_decompiled/sources/retrofit2/converter/moshi/MoshiConverterFactory.java

@@ -0,0 +1,96 @@
+package retrofit2.converter.moshi;
+
+import Z2.AbstractC0104l;
+import Z2.D;
+import Z2.G;
+import Z2.o;
+import e3.M;
+import e3.T;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import retrofit2.Converter;
+import retrofit2.Retrofit;
+
+/* loaded from: classes3.dex */
+public final class MoshiConverterFactory extends Converter.Factory {
+    private final boolean failOnUnknown;
+    private final boolean lenient;
+    private final G moshi;
+    private final boolean serializeNulls;
+
+    private MoshiConverterFactory(G g4, boolean z3, boolean z4, boolean z5) {
+        this.moshi = g4;
+        this.lenient = z3;
+        this.failOnUnknown = z4;
+        this.serializeNulls = z5;
+    }
+
+    public static MoshiConverterFactory create() {
+        return create(new G(new D()));
+    }
+
+    private static Set<? extends Annotation> jsonAnnotations(Annotation[] annotationArr) {
+        LinkedHashSet linkedHashSet = null;
+        for (Annotation annotation : annotationArr) {
+            if (annotation.annotationType().isAnnotationPresent(o.class)) {
+                if (linkedHashSet == null) {
+                    linkedHashSet = new LinkedHashSet();
+                }
+                linkedHashSet.add(annotation);
+            }
+        }
+        return linkedHashSet != null ? Collections.unmodifiableSet(linkedHashSet) : Collections.EMPTY_SET;
+    }
+
+    public MoshiConverterFactory asLenient() {
+        return new MoshiConverterFactory(this.moshi, true, this.failOnUnknown, this.serializeNulls);
+    }
+
+    public MoshiConverterFactory failOnUnknown() {
+        return new MoshiConverterFactory(this.moshi, this.lenient, true, this.serializeNulls);
+    }
+
+    @Override // retrofit2.Converter.Factory
+    public Converter<?, M> requestBodyConverter(Type type, Annotation[] annotationArr, Annotation[] annotationArr2, Retrofit retrofit) {
+        AbstractC0104l c4 = this.moshi.c(type, jsonAnnotations(annotationArr), null);
+        if (this.lenient) {
+            c4 = c4.lenient();
+        }
+        if (this.failOnUnknown) {
+            c4 = c4.failOnUnknown();
+        }
+        if (this.serializeNulls) {
+            c4 = c4.serializeNulls();
+        }
+        return new MoshiRequestBodyConverter(c4);
+    }
+
+    @Override // retrofit2.Converter.Factory
+    public Converter<T, ?> responseBodyConverter(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+        AbstractC0104l c4 = this.moshi.c(type, jsonAnnotations(annotationArr), null);
+        if (this.lenient) {
+            c4 = c4.lenient();
+        }
+        if (this.failOnUnknown) {
+            c4 = c4.failOnUnknown();
+        }
+        if (this.serializeNulls) {
+            c4 = c4.serializeNulls();
+        }
+        return new MoshiResponseBodyConverter(c4);
+    }
+
+    public MoshiConverterFactory withNullSerialization() {
+        return new MoshiConverterFactory(this.moshi, this.lenient, this.failOnUnknown, true);
+    }
+
+    public static MoshiConverterFactory create(G g4) {
+        if (g4 != null) {
+            return new MoshiConverterFactory(g4, false, false, false);
+        }
+        throw new NullPointerException("moshi == null");
+    }
+}

apk_decompiled/sources/retrofit2/converter/moshi/MoshiRequestBodyConverter.java

@@ -0,0 +1,40 @@
+package retrofit2.converter.moshi;
+
+import Z2.AbstractC0104l;
+import Z2.t;
+import e3.A;
+import e3.M;
+import e3.z;
+import java.io.IOException;
+import java.util.regex.Pattern;
+import retrofit2.Converter;
+
+/* loaded from: classes3.dex */
+final class MoshiRequestBodyConverter<T> implements Converter<T, M> {
+    private static final A MEDIA_TYPE;
+    private final AbstractC0104l adapter;
+
+    static {
+        Pattern pattern = A.f6197d;
+        MEDIA_TYPE = z.a("application/json; charset=UTF-8");
+    }
+
+    public MoshiRequestBodyConverter(AbstractC0104l abstractC0104l) {
+        this.adapter = abstractC0104l;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // retrofit2.Converter
+    public /* bridge */ /* synthetic */ M convert(Object obj) throws IOException {
+        return convert((MoshiRequestBodyConverter<T>) obj);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    /* JADX WARN: Type inference failed for: r0v0, types: [r3.i, java.lang.Object, r3.h] */
+    @Override // retrofit2.Converter
+    public M convert(T t2) throws IOException {
+        ?? obj = new Object();
+        this.adapter.toJson(new t(obj), t2);
+        return M.create(MEDIA_TYPE, obj.h(obj.f8284b));
+    }
+}

apk_decompiled/sources/retrofit2/converter/moshi/MoshiResponseBodyConverter.java

@@ -0,0 +1,46 @@
+package retrofit2.converter.moshi;
+
+import Z2.AbstractC0104l;
+import Z2.q;
+import Z2.s;
+import e3.T;
+import f0.C0338b;
+import java.io.IOException;
+import r3.C0579k;
+import r3.InterfaceC0578j;
+import retrofit2.Converter;
+
+/* loaded from: classes3.dex */
+final class MoshiResponseBodyConverter<T> implements Converter<T, T> {
+    private static final C0579k UTF8_BOM;
+    private final AbstractC0104l adapter;
+
+    static {
+        C0579k c0579k = C0579k.f8285d;
+        UTF8_BOM = C0338b.m("EFBBBF");
+    }
+
+    public MoshiResponseBodyConverter(AbstractC0104l abstractC0104l) {
+        this.adapter = abstractC0104l;
+    }
+
+    @Override // retrofit2.Converter
+    public T convert(T t2) throws IOException {
+        InterfaceC0578j source = t2.source();
+        try {
+            if (source.H(UTF8_BOM)) {
+                source.l(r1.d());
+            }
+            s sVar = new s(source);
+            T t4 = (T) this.adapter.fromJson(sVar);
+            if (sVar.f0() == q.f2278j) {
+                t2.close();
+                return t4;
+            }
+            throw new RuntimeException("JSON document was not fully consumed.");
+        } catch (Throwable th) {
+            t2.close();
+            throw th;
+        }
+    }
+}

apk_decompiled/sources/retrofit2/converter/moshi/package-info.java

@@ -0,0 +1,5 @@
+@EverythingIsNonNull
+package retrofit2.converter.moshi;
+
+import retrofit2.internal.EverythingIsNonNull;
+

apk_decompiled/sources/retrofit2/http/Body.java

@@ -0,0 +1,14 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Body {
+}

apk_decompiled/sources/retrofit2/http/DELETE.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface DELETE {
+    String value() default "";
+}

apk_decompiled/sources/retrofit2/http/Field.java

@@ -0,0 +1,17 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Field {
+    boolean encoded() default false;
+
+    String value();
+}

apk_decompiled/sources/retrofit2/http/FieldMap.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface FieldMap {
+    boolean encoded() default false;
+}

apk_decompiled/sources/retrofit2/http/FormUrlEncoded.java

@@ -0,0 +1,14 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface FormUrlEncoded {
+}

apk_decompiled/sources/retrofit2/http/GET.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface GET {
+    String value() default "";
+}

apk_decompiled/sources/retrofit2/http/HEAD.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface HEAD {
+    String value() default "";
+}

apk_decompiled/sources/retrofit2/http/HTTP.java

@@ -0,0 +1,19 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface HTTP {
+    boolean hasBody() default false;
+
+    String method();
+
+    String path() default "";
+}

apk_decompiled/sources/retrofit2/http/Header.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Header {
+    String value();
+}

apk_decompiled/sources/retrofit2/http/HeaderMap.java

@@ -0,0 +1,14 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface HeaderMap {
+}

apk_decompiled/sources/retrofit2/http/Headers.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Headers {
+    String[] value();
+}

apk_decompiled/sources/retrofit2/http/Multipart.java

@@ -0,0 +1,14 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Multipart {
+}

apk_decompiled/sources/retrofit2/http/OPTIONS.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface OPTIONS {
+    String value() default "";
+}

apk_decompiled/sources/retrofit2/http/PATCH.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface PATCH {
+    String value() default "";
+}

apk_decompiled/sources/retrofit2/http/POST.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface POST {
+    String value() default "";
+}

apk_decompiled/sources/retrofit2/http/PUT.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface PUT {
+    String value() default "";
+}

apk_decompiled/sources/retrofit2/http/Part.java

@@ -0,0 +1,17 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Part {
+    String encoding() default "binary";
+
+    String value() default "";
+}

apk_decompiled/sources/retrofit2/http/PartMap.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface PartMap {
+    String encoding() default "binary";
+}

apk_decompiled/sources/retrofit2/http/Path.java

@@ -0,0 +1,17 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Path {
+    boolean encoded() default false;
+
+    String value();
+}

apk_decompiled/sources/retrofit2/http/Query.java

@@ -0,0 +1,17 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Query {
+    boolean encoded() default false;
+
+    String value();
+}

apk_decompiled/sources/retrofit2/http/QueryMap.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface QueryMap {
+    boolean encoded() default false;
+}

apk_decompiled/sources/retrofit2/http/QueryName.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface QueryName {
+    boolean encoded() default false;
+}

apk_decompiled/sources/retrofit2/http/Streaming.java

@@ -0,0 +1,14 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Streaming {
+}

apk_decompiled/sources/retrofit2/http/Tag.java

@@ -0,0 +1,14 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Tag {
+}

apk_decompiled/sources/retrofit2/http/Url.java

@@ -0,0 +1,14 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface Url {
+}

apk_decompiled/sources/retrofit2/internal/EverythingIsNonNull.java

@@ -0,0 +1,11 @@
+package retrofit2.internal;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface EverythingIsNonNull {
+}

apk_decompiled/sources/retrofit2/package-info.java

@@ -0,0 +1,5 @@
+@EverythingIsNonNull
+package retrofit2;
+
+import retrofit2.internal.EverythingIsNonNull;
+