Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

decompiled-community/sources/org/apache/http/impl/AbstractHttpClientConnection.java

@@ -0,0 +1,95 @@
+package org.apache.http.impl;
+
+import java.io.IOException;
+import org.apache.http.HttpClientConnection;
+import org.apache.http.HttpConnectionMetrics;
+import org.apache.http.HttpEntityEnclosingRequest;
+import org.apache.http.HttpException;
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpResponseFactory;
+import org.apache.http.impl.entity.EntityDeserializer;
+import org.apache.http.impl.entity.EntitySerializer;
+import org.apache.http.io.HttpMessageParser;
+import org.apache.http.io.HttpMessageWriter;
+import org.apache.http.io.SessionInputBuffer;
+import org.apache.http.io.SessionOutputBuffer;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AbstractHttpClientConnection implements HttpClientConnection {
+    public abstract void assertOpen() throws IllegalStateException;
+
+    public AbstractHttpClientConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public EntityDeserializer createEntityDeserializer() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public EntitySerializer createEntitySerializer() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HttpResponseFactory createHttpResponseFactory() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HttpMessageParser createResponseParser(SessionInputBuffer sessionInputBuffer, HttpResponseFactory httpResponseFactory, HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HttpMessageWriter createRequestWriter(SessionOutputBuffer sessionOutputBuffer, HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void init(SessionInputBuffer sessionInputBuffer, SessionOutputBuffer sessionOutputBuffer, HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public boolean isResponseAvailable(int i) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public void sendRequestHeader(HttpRequest httpRequest) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public void sendRequestEntity(HttpEntityEnclosingRequest httpEntityEnclosingRequest) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void doFlush() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public void flush() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public HttpResponse receiveResponseHeader() throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public void receiveResponseEntity(HttpResponse httpResponse) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public boolean isStale() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public HttpConnectionMetrics getMetrics() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/AbstractHttpServerConnection.java

@@ -0,0 +1,90 @@
+package org.apache.http.impl;
+
+import java.io.IOException;
+import org.apache.http.HttpConnectionMetrics;
+import org.apache.http.HttpEntityEnclosingRequest;
+import org.apache.http.HttpException;
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpRequestFactory;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpServerConnection;
+import org.apache.http.impl.entity.EntityDeserializer;
+import org.apache.http.impl.entity.EntitySerializer;
+import org.apache.http.io.HttpMessageParser;
+import org.apache.http.io.HttpMessageWriter;
+import org.apache.http.io.SessionInputBuffer;
+import org.apache.http.io.SessionOutputBuffer;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AbstractHttpServerConnection implements HttpServerConnection {
+    public abstract void assertOpen() throws IllegalStateException;
+
+    public AbstractHttpServerConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public EntityDeserializer createEntityDeserializer() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public EntitySerializer createEntitySerializer() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HttpRequestFactory createHttpRequestFactory() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HttpMessageParser createRequestParser(SessionInputBuffer sessionInputBuffer, HttpRequestFactory httpRequestFactory, HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HttpMessageWriter createResponseWriter(SessionOutputBuffer sessionOutputBuffer, HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void init(SessionInputBuffer sessionInputBuffer, SessionOutputBuffer sessionOutputBuffer, HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpServerConnection
+    public HttpRequest receiveRequestHeader() throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpServerConnection
+    public void receiveRequestEntity(HttpEntityEnclosingRequest httpEntityEnclosingRequest) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void doFlush() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpServerConnection
+    public void flush() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpServerConnection
+    public void sendResponseHeader(HttpResponse httpResponse) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpServerConnection
+    public void sendResponseEntity(HttpResponse httpResponse) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public boolean isStale() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public HttpConnectionMetrics getMetrics() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/DefaultConnectionReuseStrategy.java

@@ -0,0 +1,24 @@
+package org.apache.http.impl;
+
+import org.apache.http.ConnectionReuseStrategy;
+import org.apache.http.HeaderIterator;
+import org.apache.http.HttpResponse;
+import org.apache.http.TokenIterator;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultConnectionReuseStrategy implements ConnectionReuseStrategy {
+    public DefaultConnectionReuseStrategy() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.ConnectionReuseStrategy
+    public boolean keepAlive(HttpResponse httpResponse, HttpContext httpContext) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public TokenIterator createTokenIterator(HeaderIterator headerIterator) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/DefaultHttpClientConnection.java

@@ -0,0 +1,22 @@
+package org.apache.http.impl;
+
+import java.io.IOException;
+import java.net.Socket;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultHttpClientConnection extends SocketHttpClientConnection {
+    public DefaultHttpClientConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.SocketHttpClientConnection
+    public void bind(Socket socket, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public String toString() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/DefaultHttpRequestFactory.java

@@ -0,0 +1,24 @@
+package org.apache.http.impl;
+
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpRequestFactory;
+import org.apache.http.MethodNotSupportedException;
+import org.apache.http.RequestLine;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultHttpRequestFactory implements HttpRequestFactory {
+    public DefaultHttpRequestFactory() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpRequestFactory
+    public HttpRequest newHttpRequest(RequestLine requestLine) throws MethodNotSupportedException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpRequestFactory
+    public HttpRequest newHttpRequest(String str, String str2) throws MethodNotSupportedException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/DefaultHttpResponseFactory.java

@@ -0,0 +1,37 @@
+package org.apache.http.impl;
+
+import java.util.Locale;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpResponseFactory;
+import org.apache.http.ProtocolVersion;
+import org.apache.http.ReasonPhraseCatalog;
+import org.apache.http.StatusLine;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultHttpResponseFactory implements HttpResponseFactory {
+    protected final ReasonPhraseCatalog reasonCatalog;
+
+    public DefaultHttpResponseFactory(ReasonPhraseCatalog reasonPhraseCatalog) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public DefaultHttpResponseFactory() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpResponseFactory
+    public HttpResponse newHttpResponse(ProtocolVersion protocolVersion, int i, HttpContext httpContext) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpResponseFactory
+    public HttpResponse newHttpResponse(StatusLine statusLine, HttpContext httpContext) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Locale determineLocale(HttpContext httpContext) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/DefaultHttpServerConnection.java

@@ -0,0 +1,22 @@
+package org.apache.http.impl;
+
+import java.io.IOException;
+import java.net.Socket;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultHttpServerConnection extends SocketHttpServerConnection {
+    public DefaultHttpServerConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.SocketHttpServerConnection
+    public void bind(Socket socket, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public String toString() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/EnglishReasonPhraseCatalog.java

@@ -0,0 +1,19 @@
+package org.apache.http.impl;
+
+import java.util.Locale;
+import org.apache.http.ReasonPhraseCatalog;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class EnglishReasonPhraseCatalog implements ReasonPhraseCatalog {
+    public static final EnglishReasonPhraseCatalog INSTANCE = null;
+
+    public EnglishReasonPhraseCatalog() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.ReasonPhraseCatalog
+    public String getReason(int i, Locale locale) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/HttpConnectionMetricsImpl.java

@@ -0,0 +1,59 @@
+package org.apache.http.impl;
+
+import org.apache.http.HttpConnectionMetrics;
+import org.apache.http.io.HttpTransportMetrics;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class HttpConnectionMetricsImpl implements HttpConnectionMetrics {
+    public static final String RECEIVED_BYTES_COUNT = "http.received-bytes-count";
+    public static final String REQUEST_COUNT = "http.request-count";
+    public static final String RESPONSE_COUNT = "http.response-count";
+    public static final String SENT_BYTES_COUNT = "http.sent-bytes-count";
+
+    public HttpConnectionMetricsImpl(HttpTransportMetrics httpTransportMetrics, HttpTransportMetrics httpTransportMetrics2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnectionMetrics
+    public long getReceivedBytesCount() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnectionMetrics
+    public long getSentBytesCount() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnectionMetrics
+    public long getRequestCount() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void incrementRequestCount() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnectionMetrics
+    public long getResponseCount() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void incrementResponseCount() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnectionMetrics
+    public Object getMetric(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void setMetric(String str, Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnectionMetrics
+    public void reset() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/NoConnectionReuseStrategy.java

@@ -0,0 +1,18 @@
+package org.apache.http.impl;
+
+import org.apache.http.ConnectionReuseStrategy;
+import org.apache.http.HttpResponse;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class NoConnectionReuseStrategy implements ConnectionReuseStrategy {
+    public NoConnectionReuseStrategy() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.ConnectionReuseStrategy
+    public boolean keepAlive(HttpResponse httpResponse, HttpContext httpContext) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/SocketHttpClientConnection.java

@@ -0,0 +1,87 @@
+package org.apache.http.impl;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import org.apache.http.HttpInetConnection;
+import org.apache.http.io.SessionInputBuffer;
+import org.apache.http.io.SessionOutputBuffer;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class SocketHttpClientConnection extends AbstractHttpClientConnection implements HttpInetConnection {
+    public SocketHttpClientConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void assertNotOpen() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.AbstractHttpClientConnection
+    public void assertOpen() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public SessionInputBuffer createSessionInputBuffer(Socket socket, int i, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public SessionOutputBuffer createSessionOutputBuffer(Socket socket, int i, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void bind(Socket socket, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public boolean isOpen() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Socket getSocket() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public InetAddress getLocalAddress() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public int getLocalPort() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public InetAddress getRemoteAddress() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public int getRemotePort() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public void setSocketTimeout(int i) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public int getSocketTimeout() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public void shutdown() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public void close() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/SocketHttpServerConnection.java

@@ -0,0 +1,87 @@
+package org.apache.http.impl;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import org.apache.http.HttpInetConnection;
+import org.apache.http.io.SessionInputBuffer;
+import org.apache.http.io.SessionOutputBuffer;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class SocketHttpServerConnection extends AbstractHttpServerConnection implements HttpInetConnection {
+    public SocketHttpServerConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void assertNotOpen() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.AbstractHttpServerConnection
+    public void assertOpen() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public SessionInputBuffer createHttpDataReceiver(Socket socket, int i, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public SessionOutputBuffer createHttpDataTransmitter(Socket socket, int i, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void bind(Socket socket, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Socket getSocket() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public boolean isOpen() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public InetAddress getLocalAddress() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public int getLocalPort() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public InetAddress getRemoteAddress() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public int getRemotePort() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public void setSocketTimeout(int i) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public int getSocketTimeout() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public void shutdown() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public void close() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/auth/AuthSchemeBase.java

@@ -0,0 +1,25 @@
+package org.apache.http.impl.auth;
+
+import org.apache.http.Header;
+import org.apache.http.auth.AuthScheme;
+import org.apache.http.auth.MalformedChallengeException;
+import org.apache.http.util.CharArrayBuffer;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AuthSchemeBase implements AuthScheme {
+    public abstract void parseChallenge(CharArrayBuffer charArrayBuffer, int i, int i2) throws MalformedChallengeException;
+
+    public AuthSchemeBase() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public void processChallenge(Header header) throws MalformedChallengeException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean isProxy() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/auth/BasicScheme.java

@@ -0,0 +1,44 @@
+package org.apache.http.impl.auth;
+
+import org.apache.http.Header;
+import org.apache.http.HttpRequest;
+import org.apache.http.auth.AuthenticationException;
+import org.apache.http.auth.Credentials;
+import org.apache.http.auth.MalformedChallengeException;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicScheme extends RFC2617Scheme {
+    public BasicScheme() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public String getSchemeName() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.auth.AuthSchemeBase, org.apache.http.auth.AuthScheme
+    public void processChallenge(Header header) throws MalformedChallengeException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public boolean isComplete() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public boolean isConnectionBased() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public Header authenticate(Credentials credentials, HttpRequest httpRequest) throws AuthenticationException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static Header authenticate(Credentials credentials, String str, boolean z) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/auth/BasicSchemeFactory.java

@@ -0,0 +1,18 @@
+package org.apache.http.impl.auth;
+
+import org.apache.http.auth.AuthScheme;
+import org.apache.http.auth.AuthSchemeFactory;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicSchemeFactory implements AuthSchemeFactory {
+    public BasicSchemeFactory() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthSchemeFactory
+    public AuthScheme newInstance(HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/auth/DigestScheme.java

@@ -0,0 +1,48 @@
+package org.apache.http.impl.auth;
+
+import org.apache.http.Header;
+import org.apache.http.HttpRequest;
+import org.apache.http.auth.AuthenticationException;
+import org.apache.http.auth.Credentials;
+import org.apache.http.auth.MalformedChallengeException;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DigestScheme extends RFC2617Scheme {
+    public DigestScheme() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.auth.AuthSchemeBase, org.apache.http.auth.AuthScheme
+    public void processChallenge(Header header) throws MalformedChallengeException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public boolean isComplete() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public String getSchemeName() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public boolean isConnectionBased() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void overrideParamter(String str, String str2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public Header authenticate(Credentials credentials, HttpRequest httpRequest) throws AuthenticationException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static String createCnonce() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/auth/DigestSchemeFactory.java

@@ -0,0 +1,18 @@
+package org.apache.http.impl.auth;
+
+import org.apache.http.auth.AuthScheme;
+import org.apache.http.auth.AuthSchemeFactory;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DigestSchemeFactory implements AuthSchemeFactory {
+    public DigestSchemeFactory() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthSchemeFactory
+    public AuthScheme newInstance(HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/auth/NTLMEngine.java

@@ -0,0 +1,9 @@
+package org.apache.http.impl.auth;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public interface NTLMEngine {
+    String generateType1Msg(String str, String str2) throws NTLMEngineException;
+
+    String generateType3Msg(String str, String str2, String str3, String str4, String str5) throws NTLMEngineException;
+}

decompiled-community/sources/org/apache/http/impl/auth/NTLMEngineException.java

@@ -0,0 +1,19 @@
+package org.apache.http.impl.auth;
+
+import org.apache.http.auth.AuthenticationException;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class NTLMEngineException extends AuthenticationException {
+    public NTLMEngineException() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public NTLMEngineException(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public NTLMEngineException(String str, Throwable th) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/auth/NTLMScheme.java

@@ -0,0 +1,51 @@
+package org.apache.http.impl.auth;
+
+import org.apache.http.Header;
+import org.apache.http.HttpRequest;
+import org.apache.http.auth.AuthenticationException;
+import org.apache.http.auth.Credentials;
+import org.apache.http.auth.MalformedChallengeException;
+import org.apache.http.util.CharArrayBuffer;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class NTLMScheme extends AuthSchemeBase {
+    public NTLMScheme(NTLMEngine nTLMEngine) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public String getSchemeName() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public String getParameter(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public String getRealm() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public boolean isConnectionBased() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.auth.AuthSchemeBase
+    public void parseChallenge(CharArrayBuffer charArrayBuffer, int i, int i2) throws MalformedChallengeException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public Header authenticate(Credentials credentials, HttpRequest httpRequest) throws AuthenticationException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public boolean isComplete() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/auth/RFC2617Scheme.java

@@ -0,0 +1,32 @@
+package org.apache.http.impl.auth;
+
+import java.util.Map;
+import org.apache.http.auth.MalformedChallengeException;
+import org.apache.http.util.CharArrayBuffer;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class RFC2617Scheme extends AuthSchemeBase {
+    public RFC2617Scheme() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.auth.AuthSchemeBase
+    public void parseChallenge(CharArrayBuffer charArrayBuffer, int i, int i2) throws MalformedChallengeException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Map<String, String> getParameters() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public String getParameter(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.auth.AuthScheme
+    public String getRealm() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/auth/UnsupportedDigestAlgorithmException.java

@@ -0,0 +1,17 @@
+package org.apache.http.impl.auth;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class UnsupportedDigestAlgorithmException extends RuntimeException {
+    public UnsupportedDigestAlgorithmException() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public UnsupportedDigestAlgorithmException(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public UnsupportedDigestAlgorithmException(String str, Throwable th) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/AbstractAuthenticationHandler.java

@@ -0,0 +1,32 @@
+package org.apache.http.impl.client;
+
+import java.util.List;
+import java.util.Map;
+import org.apache.http.Header;
+import org.apache.http.HttpResponse;
+import org.apache.http.auth.AuthScheme;
+import org.apache.http.auth.AuthenticationException;
+import org.apache.http.auth.MalformedChallengeException;
+import org.apache.http.client.AuthenticationHandler;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AbstractAuthenticationHandler implements AuthenticationHandler {
+    public AbstractAuthenticationHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Map<String, Header> parseChallenges(Header[] headerArr) throws MalformedChallengeException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public List<String> getAuthPreferences() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.AuthenticationHandler
+    public AuthScheme selectScheme(Map<String, Header> map, HttpResponse httpResponse, HttpContext httpContext) throws AuthenticationException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/AbstractHttpClient.java

@@ -0,0 +1,286 @@
+package org.apache.http.impl.client;
+
+import java.io.IOException;
+import org.apache.http.ConnectionReuseStrategy;
+import org.apache.http.HttpHost;
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpRequestInterceptor;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpResponseInterceptor;
+import org.apache.http.auth.AuthSchemeRegistry;
+import org.apache.http.client.AuthenticationHandler;
+import org.apache.http.client.ClientProtocolException;
+import org.apache.http.client.CookieStore;
+import org.apache.http.client.CredentialsProvider;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.HttpRequestRetryHandler;
+import org.apache.http.client.RedirectHandler;
+import org.apache.http.client.RequestDirector;
+import org.apache.http.client.ResponseHandler;
+import org.apache.http.client.UserTokenHandler;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.conn.ConnectionKeepAliveStrategy;
+import org.apache.http.conn.routing.HttpRoutePlanner;
+import org.apache.http.cookie.CookieSpecRegistry;
+import org.apache.http.params.HttpParams;
+import org.apache.http.protocol.BasicHttpProcessor;
+import org.apache.http.protocol.HttpContext;
+import org.apache.http.protocol.HttpProcessor;
+import org.apache.http.protocol.HttpRequestExecutor;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AbstractHttpClient implements HttpClient {
+    public abstract AuthSchemeRegistry createAuthSchemeRegistry();
+
+    public abstract ClientConnectionManager createClientConnectionManager();
+
+    public abstract ConnectionKeepAliveStrategy createConnectionKeepAliveStrategy();
+
+    public abstract ConnectionReuseStrategy createConnectionReuseStrategy();
+
+    public abstract CookieSpecRegistry createCookieSpecRegistry();
+
+    public abstract CookieStore createCookieStore();
+
+    public abstract CredentialsProvider createCredentialsProvider();
+
+    public abstract HttpContext createHttpContext();
+
+    public abstract HttpParams createHttpParams();
+
+    public abstract BasicHttpProcessor createHttpProcessor();
+
+    public abstract HttpRequestRetryHandler createHttpRequestRetryHandler();
+
+    public abstract HttpRoutePlanner createHttpRoutePlanner();
+
+    public abstract AuthenticationHandler createProxyAuthenticationHandler();
+
+    public abstract RedirectHandler createRedirectHandler();
+
+    public abstract HttpRequestExecutor createRequestExecutor();
+
+    public abstract AuthenticationHandler createTargetAuthenticationHandler();
+
+    public abstract UserTokenHandler createUserTokenHandler();
+
+    public AbstractHttpClient(ClientConnectionManager clientConnectionManager, HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.HttpClient
+    public final synchronized HttpParams getParams() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void setParams(HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.HttpClient
+    public final synchronized ClientConnectionManager getConnectionManager() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized HttpRequestExecutor getRequestExecutor() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized AuthSchemeRegistry getAuthSchemes() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void setAuthSchemes(AuthSchemeRegistry authSchemeRegistry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized CookieSpecRegistry getCookieSpecs() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void setCookieSpecs(CookieSpecRegistry cookieSpecRegistry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized ConnectionReuseStrategy getConnectionReuseStrategy() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void setReuseStrategy(ConnectionReuseStrategy connectionReuseStrategy) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized ConnectionKeepAliveStrategy getConnectionKeepAliveStrategy() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void setKeepAliveStrategy(ConnectionKeepAliveStrategy connectionKeepAliveStrategy) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized HttpRequestRetryHandler getHttpRequestRetryHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void setHttpRequestRetryHandler(HttpRequestRetryHandler httpRequestRetryHandler) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized RedirectHandler getRedirectHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void setRedirectHandler(RedirectHandler redirectHandler) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized AuthenticationHandler getTargetAuthenticationHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void setTargetAuthenticationHandler(AuthenticationHandler authenticationHandler) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized AuthenticationHandler getProxyAuthenticationHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void setProxyAuthenticationHandler(AuthenticationHandler authenticationHandler) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized CookieStore getCookieStore() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void setCookieStore(CookieStore cookieStore) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized CredentialsProvider getCredentialsProvider() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void setCredentialsProvider(CredentialsProvider credentialsProvider) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized HttpRoutePlanner getRoutePlanner() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void setRoutePlanner(HttpRoutePlanner httpRoutePlanner) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized UserTokenHandler getUserTokenHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void setUserTokenHandler(UserTokenHandler userTokenHandler) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final synchronized BasicHttpProcessor getHttpProcessor() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void addResponseInterceptor(HttpResponseInterceptor httpResponseInterceptor) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void addResponseInterceptor(HttpResponseInterceptor httpResponseInterceptor, int i) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized HttpResponseInterceptor getResponseInterceptor(int i) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized int getResponseInterceptorCount() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void clearResponseInterceptors() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void removeResponseInterceptorByClass(Class<? extends HttpResponseInterceptor> cls) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void addRequestInterceptor(HttpRequestInterceptor httpRequestInterceptor) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void addRequestInterceptor(HttpRequestInterceptor httpRequestInterceptor, int i) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized HttpRequestInterceptor getRequestInterceptor(int i) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized int getRequestInterceptorCount() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void clearRequestInterceptors() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void removeRequestInterceptorByClass(Class<? extends HttpRequestInterceptor> cls) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.HttpClient
+    public final HttpResponse execute(HttpUriRequest httpUriRequest) throws IOException, ClientProtocolException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.HttpClient
+    public final HttpResponse execute(HttpUriRequest httpUriRequest, HttpContext httpContext) throws IOException, ClientProtocolException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.HttpClient
+    public final HttpResponse execute(HttpHost httpHost, HttpRequest httpRequest) throws IOException, ClientProtocolException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.HttpClient
+    public final HttpResponse execute(HttpHost httpHost, HttpRequest httpRequest, HttpContext httpContext) throws IOException, ClientProtocolException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public RequestDirector createClientRequestDirector(HttpRequestExecutor httpRequestExecutor, ClientConnectionManager clientConnectionManager, ConnectionReuseStrategy connectionReuseStrategy, ConnectionKeepAliveStrategy connectionKeepAliveStrategy, HttpRoutePlanner httpRoutePlanner, HttpProcessor httpProcessor, HttpRequestRetryHandler httpRequestRetryHandler, RedirectHandler redirectHandler, AuthenticationHandler authenticationHandler, AuthenticationHandler authenticationHandler2, UserTokenHandler userTokenHandler, HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HttpParams determineParams(HttpRequest httpRequest) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.HttpClient
+    public <T> T execute(HttpUriRequest httpUriRequest, ResponseHandler<? extends T> responseHandler) throws IOException, ClientProtocolException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.HttpClient
+    public <T> T execute(HttpUriRequest httpUriRequest, ResponseHandler<? extends T> responseHandler, HttpContext httpContext) throws IOException, ClientProtocolException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.HttpClient
+    public <T> T execute(HttpHost httpHost, HttpRequest httpRequest, ResponseHandler<? extends T> responseHandler) throws IOException, ClientProtocolException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.HttpClient
+    public <T> T execute(HttpHost httpHost, HttpRequest httpRequest, ResponseHandler<? extends T> responseHandler, HttpContext httpContext) throws IOException, ClientProtocolException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/BasicCookieStore.java

@@ -0,0 +1,42 @@
+package org.apache.http.impl.client;
+
+import java.util.Date;
+import java.util.List;
+import org.apache.http.client.CookieStore;
+import org.apache.http.cookie.Cookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicCookieStore implements CookieStore {
+    public BasicCookieStore() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.CookieStore
+    public synchronized void addCookie(Cookie cookie) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public synchronized void addCookies(Cookie[] cookieArr) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.CookieStore
+    public synchronized List<Cookie> getCookies() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.CookieStore
+    public synchronized boolean clearExpired(Date date) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public String toString() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.CookieStore
+    public synchronized void clear() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/BasicCredentialsProvider.java

@@ -0,0 +1,32 @@
+package org.apache.http.impl.client;
+
+import org.apache.http.auth.AuthScope;
+import org.apache.http.auth.Credentials;
+import org.apache.http.client.CredentialsProvider;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicCredentialsProvider implements CredentialsProvider {
+    public BasicCredentialsProvider() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.CredentialsProvider
+    public synchronized void setCredentials(AuthScope authScope, Credentials credentials) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.CredentialsProvider
+    public synchronized Credentials getCredentials(AuthScope authScope) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public String toString() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.CredentialsProvider
+    public synchronized void clear() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/BasicResponseHandler.java

@@ -0,0 +1,19 @@
+package org.apache.http.impl.client;
+
+import java.io.IOException;
+import org.apache.http.HttpResponse;
+import org.apache.http.client.HttpResponseException;
+import org.apache.http.client.ResponseHandler;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicResponseHandler implements ResponseHandler<String> {
+    public BasicResponseHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.ResponseHandler
+    public String handleResponse(HttpResponse httpResponse) throws HttpResponseException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/ClientParamsStack.java

@@ -0,0 +1,61 @@
+package org.apache.http.impl.client;
+
+import org.apache.http.params.AbstractHttpParams;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class ClientParamsStack extends AbstractHttpParams {
+    protected final HttpParams applicationParams;
+    protected final HttpParams clientParams;
+    protected final HttpParams overrideParams;
+    protected final HttpParams requestParams;
+
+    public ClientParamsStack(HttpParams httpParams, HttpParams httpParams2, HttpParams httpParams3, HttpParams httpParams4) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public ClientParamsStack(ClientParamsStack clientParamsStack) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public ClientParamsStack(ClientParamsStack clientParamsStack, HttpParams httpParams, HttpParams httpParams2, HttpParams httpParams3, HttpParams httpParams4) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final HttpParams getApplicationParams() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final HttpParams getClientParams() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final HttpParams getRequestParams() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final HttpParams getOverrideParams() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.params.HttpParams
+    public Object getParameter(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.params.HttpParams
+    public HttpParams setParameter(String str, Object obj) throws UnsupportedOperationException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.params.HttpParams
+    public boolean removeParameter(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.params.HttpParams
+    public HttpParams copy() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/DefaultConnectionKeepAliveStrategy.java

@@ -0,0 +1,18 @@
+package org.apache.http.impl.client;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.conn.ConnectionKeepAliveStrategy;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultConnectionKeepAliveStrategy implements ConnectionKeepAliveStrategy {
+    public DefaultConnectionKeepAliveStrategy() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ConnectionKeepAliveStrategy
+    public long getKeepAliveDuration(HttpResponse httpResponse, HttpContext httpContext) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/DefaultHttpClient.java

@@ -0,0 +1,122 @@
+package org.apache.http.impl.client;
+
+import org.apache.http.ConnectionReuseStrategy;
+import org.apache.http.auth.AuthSchemeRegistry;
+import org.apache.http.client.AuthenticationHandler;
+import org.apache.http.client.CookieStore;
+import org.apache.http.client.CredentialsProvider;
+import org.apache.http.client.HttpRequestRetryHandler;
+import org.apache.http.client.RedirectHandler;
+import org.apache.http.client.UserTokenHandler;
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.conn.ConnectionKeepAliveStrategy;
+import org.apache.http.conn.routing.HttpRoutePlanner;
+import org.apache.http.cookie.CookieSpecRegistry;
+import org.apache.http.params.HttpParams;
+import org.apache.http.protocol.BasicHttpProcessor;
+import org.apache.http.protocol.HttpContext;
+import org.apache.http.protocol.HttpRequestExecutor;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultHttpClient extends AbstractHttpClient {
+    public DefaultHttpClient(ClientConnectionManager clientConnectionManager, HttpParams httpParams) {
+        super(null, null);
+        throw new RuntimeException("Stub!");
+    }
+
+    public DefaultHttpClient(HttpParams httpParams) {
+        super(null, null);
+        throw new RuntimeException("Stub!");
+    }
+
+    public DefaultHttpClient() {
+        super(null, null);
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public HttpParams createHttpParams() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public HttpRequestExecutor createRequestExecutor() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public ClientConnectionManager createClientConnectionManager() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public HttpContext createHttpContext() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public ConnectionReuseStrategy createConnectionReuseStrategy() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public ConnectionKeepAliveStrategy createConnectionKeepAliveStrategy() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public AuthSchemeRegistry createAuthSchemeRegistry() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public CookieSpecRegistry createCookieSpecRegistry() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public BasicHttpProcessor createHttpProcessor() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public HttpRequestRetryHandler createHttpRequestRetryHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public RedirectHandler createRedirectHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public AuthenticationHandler createTargetAuthenticationHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public AuthenticationHandler createProxyAuthenticationHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public CookieStore createCookieStore() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public CredentialsProvider createCredentialsProvider() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public HttpRoutePlanner createHttpRoutePlanner() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.AbstractHttpClient
+    public UserTokenHandler createUserTokenHandler() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/DefaultHttpRequestRetryHandler.java

@@ -0,0 +1,30 @@
+package org.apache.http.impl.client;
+
+import java.io.IOException;
+import org.apache.http.client.HttpRequestRetryHandler;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultHttpRequestRetryHandler implements HttpRequestRetryHandler {
+    public DefaultHttpRequestRetryHandler(int i, boolean z) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public DefaultHttpRequestRetryHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.HttpRequestRetryHandler
+    public boolean retryRequest(IOException iOException, int i, HttpContext httpContext) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean isRequestSentRetryEnabled() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public int getRetryCount() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/DefaultProxyAuthenticationHandler.java

@@ -0,0 +1,25 @@
+package org.apache.http.impl.client;
+
+import java.util.Map;
+import org.apache.http.Header;
+import org.apache.http.HttpResponse;
+import org.apache.http.auth.MalformedChallengeException;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultProxyAuthenticationHandler extends AbstractAuthenticationHandler {
+    public DefaultProxyAuthenticationHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.AuthenticationHandler
+    public boolean isAuthenticationRequested(HttpResponse httpResponse, HttpContext httpContext) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.AuthenticationHandler
+    public Map<String, Header> getChallenges(HttpResponse httpResponse, HttpContext httpContext) throws MalformedChallengeException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/DefaultRedirectHandler.java

@@ -0,0 +1,25 @@
+package org.apache.http.impl.client;
+
+import java.net.URI;
+import org.apache.http.HttpResponse;
+import org.apache.http.ProtocolException;
+import org.apache.http.client.RedirectHandler;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultRedirectHandler implements RedirectHandler {
+    public DefaultRedirectHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.RedirectHandler
+    public boolean isRedirectRequested(HttpResponse httpResponse, HttpContext httpContext) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.RedirectHandler
+    public URI getLocationURI(HttpResponse httpResponse, HttpContext httpContext) throws ProtocolException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/DefaultRequestDirector.java

@@ -0,0 +1,79 @@
+package org.apache.http.impl.client;
+
+import java.io.IOException;
+import org.apache.http.ConnectionReuseStrategy;
+import org.apache.http.HttpException;
+import org.apache.http.HttpHost;
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpResponse;
+import org.apache.http.ProtocolException;
+import org.apache.http.client.AuthenticationHandler;
+import org.apache.http.client.HttpRequestRetryHandler;
+import org.apache.http.client.RedirectHandler;
+import org.apache.http.client.RequestDirector;
+import org.apache.http.client.UserTokenHandler;
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.conn.ConnectionKeepAliveStrategy;
+import org.apache.http.conn.ManagedClientConnection;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.conn.routing.HttpRoutePlanner;
+import org.apache.http.params.HttpParams;
+import org.apache.http.protocol.HttpContext;
+import org.apache.http.protocol.HttpProcessor;
+import org.apache.http.protocol.HttpRequestExecutor;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultRequestDirector implements RequestDirector {
+    protected final ClientConnectionManager connManager;
+    protected final HttpProcessor httpProcessor;
+    protected final ConnectionKeepAliveStrategy keepAliveStrategy;
+    protected ManagedClientConnection managedConn;
+    protected final HttpParams params;
+    protected final RedirectHandler redirectHandler;
+    protected final HttpRequestExecutor requestExec;
+    protected final HttpRequestRetryHandler retryHandler;
+    protected final ConnectionReuseStrategy reuseStrategy;
+    protected final HttpRoutePlanner routePlanner;
+
+    public DefaultRequestDirector(HttpRequestExecutor httpRequestExecutor, ClientConnectionManager clientConnectionManager, ConnectionReuseStrategy connectionReuseStrategy, ConnectionKeepAliveStrategy connectionKeepAliveStrategy, HttpRoutePlanner httpRoutePlanner, HttpProcessor httpProcessor, HttpRequestRetryHandler httpRequestRetryHandler, RedirectHandler redirectHandler, AuthenticationHandler authenticationHandler, AuthenticationHandler authenticationHandler2, UserTokenHandler userTokenHandler, HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void rewriteRequestURI(RequestWrapper requestWrapper, HttpRoute httpRoute) throws ProtocolException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.RequestDirector
+    public HttpResponse execute(HttpHost httpHost, HttpRequest httpRequest, HttpContext httpContext) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void releaseConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HttpRoute determineRoute(HttpHost httpHost, HttpRequest httpRequest, HttpContext httpContext) throws HttpException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void establishRoute(HttpRoute httpRoute, HttpContext httpContext) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean createTunnelToTarget(HttpRoute httpRoute, HttpContext httpContext) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean createTunnelToProxy(HttpRoute httpRoute, int i, HttpContext httpContext) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HttpRequest createConnectRequest(HttpRoute httpRoute, HttpContext httpContext) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public RoutedRequest handleResponse(RoutedRequest routedRequest, HttpResponse httpResponse, HttpContext httpContext) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/DefaultTargetAuthenticationHandler.java

@@ -0,0 +1,25 @@
+package org.apache.http.impl.client;
+
+import java.util.Map;
+import org.apache.http.Header;
+import org.apache.http.HttpResponse;
+import org.apache.http.auth.MalformedChallengeException;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultTargetAuthenticationHandler extends AbstractAuthenticationHandler {
+    public DefaultTargetAuthenticationHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.AuthenticationHandler
+    public boolean isAuthenticationRequested(HttpResponse httpResponse, HttpContext httpContext) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.AuthenticationHandler
+    public Map<String, Header> getChallenges(HttpResponse httpResponse, HttpContext httpContext) throws MalformedChallengeException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/DefaultUserTokenHandler.java

@@ -0,0 +1,17 @@
+package org.apache.http.impl.client;
+
+import org.apache.http.client.UserTokenHandler;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultUserTokenHandler implements UserTokenHandler {
+    public DefaultUserTokenHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.UserTokenHandler
+    public Object getUserToken(HttpContext httpContext) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/EntityEnclosingRequestWrapper.java

@@ -0,0 +1,34 @@
+package org.apache.http.impl.client;
+
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpEntityEnclosingRequest;
+import org.apache.http.ProtocolException;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class EntityEnclosingRequestWrapper extends RequestWrapper implements HttpEntityEnclosingRequest {
+    public EntityEnclosingRequestWrapper(HttpEntityEnclosingRequest httpEntityEnclosingRequest) throws ProtocolException {
+        super(null);
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpEntityEnclosingRequest
+    public HttpEntity getEntity() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpEntityEnclosingRequest
+    public void setEntity(HttpEntity httpEntity) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpEntityEnclosingRequest
+    public boolean expectContinue() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.client.RequestWrapper
+    public boolean isRepeatable() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/RedirectLocations.java

@@ -0,0 +1,23 @@
+package org.apache.http.impl.client;
+
+import java.net.URI;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RedirectLocations {
+    public RedirectLocations() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean contains(URI uri) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void add(URI uri) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean remove(URI uri) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/RequestWrapper.java

@@ -0,0 +1,79 @@
+package org.apache.http.impl.client;
+
+import java.net.URI;
+import org.apache.http.HttpRequest;
+import org.apache.http.ProtocolException;
+import org.apache.http.ProtocolVersion;
+import org.apache.http.RequestLine;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.message.AbstractHttpMessage;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RequestWrapper extends AbstractHttpMessage implements HttpUriRequest {
+    public RequestWrapper(HttpRequest httpRequest) throws ProtocolException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void resetHeaders() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.methods.HttpUriRequest
+    public String getMethod() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void setMethod(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpMessage
+    public ProtocolVersion getProtocolVersion() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void setProtocolVersion(ProtocolVersion protocolVersion) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.methods.HttpUriRequest
+    public URI getURI() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void setURI(URI uri) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpRequest
+    public RequestLine getRequestLine() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.methods.HttpUriRequest, org.apache.http.client.methods.AbortableHttpRequest
+    public void abort() throws UnsupportedOperationException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.client.methods.HttpUriRequest
+    public boolean isAborted() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HttpRequest getOriginal() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean isRepeatable() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public int getExecCount() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void incrementExecCount() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/RoutedRequest.java

@@ -0,0 +1,22 @@
+package org.apache.http.impl.client;
+
+import org.apache.http.conn.routing.HttpRoute;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RoutedRequest {
+    protected final RequestWrapper request;
+    protected final HttpRoute route;
+
+    public RoutedRequest(RequestWrapper requestWrapper, HttpRoute httpRoute) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final RequestWrapper getRequest() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final HttpRoute getRoute() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/client/TunnelRefusedException.java

@@ -0,0 +1,16 @@
+package org.apache.http.impl.client;
+
+import org.apache.http.HttpException;
+import org.apache.http.HttpResponse;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class TunnelRefusedException extends HttpException {
+    public TunnelRefusedException(String str, HttpResponse httpResponse) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HttpResponse getResponse() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/AbstractClientConnAdapter.java

@@ -0,0 +1,158 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.net.InetAddress;
+import java.util.concurrent.TimeUnit;
+import javax.net.ssl.SSLSession;
+import org.apache.http.HttpConnectionMetrics;
+import org.apache.http.HttpEntityEnclosingRequest;
+import org.apache.http.HttpException;
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpResponse;
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.conn.ManagedClientConnection;
+import org.apache.http.conn.OperatedClientConnection;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AbstractClientConnAdapter implements ManagedClientConnection {
+    public AbstractClientConnAdapter(ClientConnectionManager clientConnectionManager, OperatedClientConnection operatedClientConnection) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void detach() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public OperatedClientConnection getWrappedConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public ClientConnectionManager getManager() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void assertNotAborted() throws InterruptedIOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void assertValid(OperatedClientConnection operatedClientConnection) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public boolean isOpen() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public boolean isStale() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public void setSocketTimeout(int i) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public int getSocketTimeout() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public HttpConnectionMetrics getMetrics() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public void flush() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public boolean isResponseAvailable(int i) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public void receiveResponseEntity(HttpResponse httpResponse) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public HttpResponse receiveResponseHeader() throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public void sendRequestEntity(HttpEntityEnclosingRequest httpEntityEnclosingRequest) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public void sendRequestHeader(HttpRequest httpRequest) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public InetAddress getLocalAddress() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public int getLocalPort() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public InetAddress getRemoteAddress() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public int getRemotePort() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public boolean isSecure() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public SSLSession getSSLSession() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void markReusable() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void unmarkReusable() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public boolean isMarkedReusable() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void setIdleDuration(long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ConnectionReleaseTrigger
+    public void releaseConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ConnectionReleaseTrigger
+    public void abortConnection() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/AbstractPoolEntry.java

@@ -0,0 +1,52 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import org.apache.http.HttpHost;
+import org.apache.http.conn.ClientConnectionOperator;
+import org.apache.http.conn.OperatedClientConnection;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.conn.routing.RouteTracker;
+import org.apache.http.params.HttpParams;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AbstractPoolEntry {
+    protected final ClientConnectionOperator connOperator;
+    protected final OperatedClientConnection connection;
+    protected volatile HttpRoute route;
+    protected volatile Object state;
+    protected volatile RouteTracker tracker;
+
+    public AbstractPoolEntry(ClientConnectionOperator clientConnectionOperator, HttpRoute httpRoute) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Object getState() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void setState(Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void open(HttpRoute httpRoute, HttpContext httpContext, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void tunnelTarget(boolean z, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void tunnelProxy(HttpHost httpHost, boolean z, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void layerProtocol(HttpContext httpContext, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void shutdownEntry() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/AbstractPooledConnAdapter.java

@@ -0,0 +1,73 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import org.apache.http.HttpHost;
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.params.HttpParams;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AbstractPooledConnAdapter extends AbstractClientConnAdapter {
+    protected volatile AbstractPoolEntry poolEntry;
+
+    public AbstractPooledConnAdapter(ClientConnectionManager clientConnectionManager, AbstractPoolEntry abstractPoolEntry) {
+        super(null, null);
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void assertAttached() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.AbstractClientConnAdapter
+    public void detach() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public HttpRoute getRoute() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void open(HttpRoute httpRoute, HttpContext httpContext, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void tunnelTarget(boolean z, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void tunnelProxy(HttpHost httpHost, boolean z, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void layerProtocol(HttpContext httpContext, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public void close() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public void shutdown() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public Object getState() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void setState(Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/DefaultClientConnection.java

@@ -0,0 +1,88 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import java.net.Socket;
+import org.apache.http.HttpException;
+import org.apache.http.HttpHost;
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpResponseFactory;
+import org.apache.http.conn.OperatedClientConnection;
+import org.apache.http.impl.SocketHttpClientConnection;
+import org.apache.http.io.HttpMessageParser;
+import org.apache.http.io.SessionInputBuffer;
+import org.apache.http.io.SessionOutputBuffer;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultClientConnection extends SocketHttpClientConnection implements OperatedClientConnection {
+    public DefaultClientConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.OperatedClientConnection
+    public final HttpHost getTargetHost() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.OperatedClientConnection
+    public final boolean isSecure() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.SocketHttpClientConnection, org.apache.http.conn.OperatedClientConnection
+    public final Socket getSocket() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.OperatedClientConnection
+    public void opening(Socket socket, HttpHost httpHost) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.OperatedClientConnection
+    public void openCompleted(boolean z, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.SocketHttpClientConnection, org.apache.http.HttpConnection
+    public void shutdown() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.SocketHttpClientConnection, org.apache.http.HttpConnection
+    public void close() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.SocketHttpClientConnection
+    public SessionInputBuffer createSessionInputBuffer(Socket socket, int i, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.SocketHttpClientConnection
+    public SessionOutputBuffer createSessionOutputBuffer(Socket socket, int i, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.AbstractHttpClientConnection
+    public HttpMessageParser createResponseParser(SessionInputBuffer sessionInputBuffer, HttpResponseFactory httpResponseFactory, HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.OperatedClientConnection
+    public void update(Socket socket, HttpHost httpHost, boolean z, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.AbstractHttpClientConnection, org.apache.http.HttpClientConnection
+    public HttpResponse receiveResponseHeader() throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.AbstractHttpClientConnection, org.apache.http.HttpClientConnection
+    public void sendRequestHeader(HttpRequest httpRequest) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/DefaultClientConnectionOperator.java

@@ -0,0 +1,40 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import org.apache.http.HttpHost;
+import org.apache.http.conn.ClientConnectionOperator;
+import org.apache.http.conn.OperatedClientConnection;
+import org.apache.http.conn.scheme.SchemeRegistry;
+import org.apache.http.params.HttpParams;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultClientConnectionOperator implements ClientConnectionOperator {
+    protected SchemeRegistry schemeRegistry;
+
+    public DefaultClientConnectionOperator(SchemeRegistry schemeRegistry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionOperator
+    public OperatedClientConnection createConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionOperator
+    public void openConnection(OperatedClientConnection operatedClientConnection, HttpHost httpHost, InetAddress inetAddress, HttpContext httpContext, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionOperator
+    public void updateSecureConnection(OperatedClientConnection operatedClientConnection, HttpHost httpHost, HttpContext httpContext, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void prepareSocket(Socket socket, HttpContext httpContext, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/DefaultHttpRoutePlanner.java

@@ -0,0 +1,24 @@
+package org.apache.http.impl.conn;
+
+import org.apache.http.HttpException;
+import org.apache.http.HttpHost;
+import org.apache.http.HttpRequest;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.conn.routing.HttpRoutePlanner;
+import org.apache.http.conn.scheme.SchemeRegistry;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultHttpRoutePlanner implements HttpRoutePlanner {
+    protected SchemeRegistry schemeRegistry;
+
+    public DefaultHttpRoutePlanner(SchemeRegistry schemeRegistry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.routing.HttpRoutePlanner
+    public HttpRoute determineRoute(HttpHost httpHost, HttpRequest httpRequest, HttpContext httpContext) throws HttpException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/DefaultResponseParser.java

@@ -0,0 +1,24 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import org.apache.http.HttpException;
+import org.apache.http.HttpMessage;
+import org.apache.http.HttpResponseFactory;
+import org.apache.http.impl.io.AbstractMessageParser;
+import org.apache.http.io.SessionInputBuffer;
+import org.apache.http.message.LineParser;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultResponseParser extends AbstractMessageParser {
+    public DefaultResponseParser(SessionInputBuffer sessionInputBuffer, LineParser lineParser, HttpResponseFactory httpResponseFactory, HttpParams httpParams) {
+        super(null, null, null);
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.io.AbstractMessageParser
+    public HttpMessage parseHead(SessionInputBuffer sessionInputBuffer) throws IOException, HttpException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/IdleConnectionHandler.java

@@ -0,0 +1,32 @@
+package org.apache.http.impl.conn;
+
+import java.util.concurrent.TimeUnit;
+import org.apache.http.HttpConnection;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class IdleConnectionHandler {
+    public IdleConnectionHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void add(HttpConnection httpConnection, long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean remove(HttpConnection httpConnection) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void removeAll() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void closeIdleConnections(long j) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void closeExpiredConnections() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/LoggingSessionInputBuffer.java

@@ -0,0 +1,49 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import org.apache.http.io.HttpTransportMetrics;
+import org.apache.http.io.SessionInputBuffer;
+import org.apache.http.util.CharArrayBuffer;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class LoggingSessionInputBuffer implements SessionInputBuffer {
+    public LoggingSessionInputBuffer(SessionInputBuffer sessionInputBuffer, Wire wire) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionInputBuffer
+    public boolean isDataAvailable(int i) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionInputBuffer
+    public int read(byte[] bArr, int i, int i2) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionInputBuffer
+    public int read() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionInputBuffer
+    public int read(byte[] bArr) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionInputBuffer
+    public String readLine() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionInputBuffer
+    public int readLine(CharArrayBuffer charArrayBuffer) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionInputBuffer
+    public HttpTransportMetrics getMetrics() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/LoggingSessionOutputBuffer.java

@@ -0,0 +1,49 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import org.apache.http.io.HttpTransportMetrics;
+import org.apache.http.io.SessionOutputBuffer;
+import org.apache.http.util.CharArrayBuffer;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class LoggingSessionOutputBuffer implements SessionOutputBuffer {
+    public LoggingSessionOutputBuffer(SessionOutputBuffer sessionOutputBuffer, Wire wire) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionOutputBuffer
+    public void write(byte[] bArr, int i, int i2) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionOutputBuffer
+    public void write(int i) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionOutputBuffer
+    public void write(byte[] bArr) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionOutputBuffer
+    public void flush() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionOutputBuffer
+    public void writeLine(CharArrayBuffer charArrayBuffer) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionOutputBuffer
+    public void writeLine(String str) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionOutputBuffer
+    public HttpTransportMetrics getMetrics() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/ProxySelectorRoutePlanner.java

@@ -0,0 +1,49 @@
+package org.apache.http.impl.conn;
+
+import java.net.InetSocketAddress;
+import java.net.Proxy;
+import java.net.ProxySelector;
+import java.util.List;
+import org.apache.http.HttpException;
+import org.apache.http.HttpHost;
+import org.apache.http.HttpRequest;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.conn.routing.HttpRoutePlanner;
+import org.apache.http.conn.scheme.SchemeRegistry;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class ProxySelectorRoutePlanner implements HttpRoutePlanner {
+    protected ProxySelector proxySelector;
+    protected SchemeRegistry schemeRegistry;
+
+    public ProxySelectorRoutePlanner(SchemeRegistry schemeRegistry, ProxySelector proxySelector) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public ProxySelector getProxySelector() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void setProxySelector(ProxySelector proxySelector) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.routing.HttpRoutePlanner
+    public HttpRoute determineRoute(HttpHost httpHost, HttpRequest httpRequest, HttpContext httpContext) throws HttpException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HttpHost determineProxy(HttpHost httpHost, HttpRequest httpRequest, HttpContext httpContext) throws HttpException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public String getHost(InetSocketAddress inetSocketAddress) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Proxy chooseProxy(List<Proxy> list, HttpHost httpHost, HttpRequest httpRequest, HttpContext httpContext) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/SingleClientConnManager.java

@@ -0,0 +1,101 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.conn.ClientConnectionOperator;
+import org.apache.http.conn.ClientConnectionRequest;
+import org.apache.http.conn.ManagedClientConnection;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.conn.scheme.SchemeRegistry;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class SingleClientConnManager implements ClientConnectionManager {
+    public static final String MISUSE_MESSAGE = "Invalid use of SingleClientConnManager: connection still allocated.\nMake sure to release the connection before allocating another one.";
+    protected boolean alwaysShutDown;
+    protected ClientConnectionOperator connOperator;
+    protected long connectionExpiresTime;
+    protected volatile boolean isShutDown;
+    protected long lastReleaseTime;
+    protected ConnAdapter managedConn;
+    protected SchemeRegistry schemeRegistry;
+    protected PoolEntry uniquePoolEntry;
+
+    public class PoolEntry extends AbstractPoolEntry {
+        public PoolEntry() {
+            super(null, null);
+            throw new RuntimeException("Stub!");
+        }
+
+        public void close() throws IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void shutdown() throws IOException {
+            throw new RuntimeException("Stub!");
+        }
+    }
+
+    public class ConnAdapter extends AbstractPooledConnAdapter {
+        public ConnAdapter(PoolEntry poolEntry, HttpRoute httpRoute) {
+            super(null, null);
+            throw new RuntimeException("Stub!");
+        }
+    }
+
+    public SingleClientConnManager(HttpParams httpParams, SchemeRegistry schemeRegistry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void finalize() throws Throwable {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public SchemeRegistry getSchemeRegistry() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public ClientConnectionOperator createConnectionOperator(SchemeRegistry schemeRegistry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void assertStillUp() throws IllegalStateException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public final ClientConnectionRequest requestConnection(HttpRoute httpRoute, Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public ManagedClientConnection getConnection(HttpRoute httpRoute, Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void releaseConnection(ManagedClientConnection managedClientConnection, long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void closeExpiredConnections() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void closeIdleConnections(long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void shutdown() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void revokeConnection() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/Wire.java

@@ -0,0 +1,57 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import java.io.InputStream;
+import org.apache.commons.logging.Log;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class Wire {
+    public Wire(Log log) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean enabled() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void output(InputStream inputStream) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void input(InputStream inputStream) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void output(byte[] bArr, int i, int i2) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void input(byte[] bArr, int i, int i2) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void output(byte[] bArr) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void input(byte[] bArr) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void output(int i) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void input(int i) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void output(String str) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void input(String str) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/tsccm/AbstractConnPool.java

@@ -0,0 +1,63 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
+import org.apache.http.conn.ConnectionPoolTimeoutException;
+import org.apache.http.conn.OperatedClientConnection;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.impl.conn.IdleConnectionHandler;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AbstractConnPool implements RefQueueHandler {
+    protected IdleConnectionHandler idleConnHandler;
+    protected volatile boolean isShutDown;
+    protected Set<BasicPoolEntryRef> issuedConnections;
+    protected int numConnections;
+    protected final Lock poolLock;
+    protected ReferenceQueue<Object> refQueue;
+
+    public abstract void deleteClosedConnections();
+
+    public abstract void freeEntry(BasicPoolEntry basicPoolEntry, boolean z, long j, TimeUnit timeUnit);
+
+    public abstract void handleLostEntry(HttpRoute httpRoute);
+
+    public abstract PoolEntryRequest requestPoolEntry(HttpRoute httpRoute, Object obj);
+
+    public AbstractConnPool() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void enableConnectionGC() throws IllegalStateException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final BasicPoolEntry getEntry(HttpRoute httpRoute, Object obj, long j, TimeUnit timeUnit) throws ConnectionPoolTimeoutException, InterruptedException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.tsccm.RefQueueHandler
+    public void handleReference(Reference reference) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void closeIdleConnections(long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void closeExpiredConnections() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void shutdown() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void closeConnection(OperatedClientConnection operatedClientConnection) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/tsccm/BasicPoolEntry.java

@@ -0,0 +1,28 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.lang.ref.ReferenceQueue;
+import org.apache.http.conn.ClientConnectionOperator;
+import org.apache.http.conn.OperatedClientConnection;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.impl.conn.AbstractPoolEntry;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicPoolEntry extends AbstractPoolEntry {
+    public BasicPoolEntry(ClientConnectionOperator clientConnectionOperator, HttpRoute httpRoute, ReferenceQueue<Object> referenceQueue) {
+        super(null, null);
+        throw new RuntimeException("Stub!");
+    }
+
+    public final OperatedClientConnection getConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final HttpRoute getPlannedRoute() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final BasicPoolEntryRef getWeakRef() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/tsccm/BasicPoolEntryRef.java

@@ -0,0 +1,18 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+import org.apache.http.conn.routing.HttpRoute;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicPoolEntryRef extends WeakReference<BasicPoolEntry> {
+    public BasicPoolEntryRef(BasicPoolEntry basicPoolEntry, ReferenceQueue<Object> referenceQueue) {
+        super(null, null);
+        throw new RuntimeException("Stub!");
+    }
+
+    public final HttpRoute getRoute() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/tsccm/BasicPooledConnAdapter.java

@@ -0,0 +1,28 @@
+package org.apache.http.impl.conn.tsccm;
+
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.impl.conn.AbstractPoolEntry;
+import org.apache.http.impl.conn.AbstractPooledConnAdapter;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicPooledConnAdapter extends AbstractPooledConnAdapter {
+    public BasicPooledConnAdapter(ThreadSafeClientConnManager threadSafeClientConnManager, AbstractPoolEntry abstractPoolEntry) {
+        super(null, null);
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.AbstractClientConnAdapter
+    public ClientConnectionManager getManager() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public AbstractPoolEntry getPoolEntry() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.AbstractPooledConnAdapter, org.apache.http.impl.conn.AbstractClientConnAdapter
+    public void detach() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/tsccm/ConnPoolByRoute.java

@@ -0,0 +1,101 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.util.Map;
+import java.util.Queue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Condition;
+import org.apache.http.conn.ClientConnectionOperator;
+import org.apache.http.conn.ConnectionPoolTimeoutException;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class ConnPoolByRoute extends AbstractConnPool {
+    protected Queue<BasicPoolEntry> freeConnections;
+    protected final int maxTotalConnections;
+    protected final ClientConnectionOperator operator;
+    protected final Map<HttpRoute, RouteSpecificPool> routeToPool;
+    protected Queue<WaitingThread> waitingThreads;
+
+    public ConnPoolByRoute(ClientConnectionOperator clientConnectionOperator, HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Queue<BasicPoolEntry> createFreeConnQueue() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Queue<WaitingThread> createWaitingThreadQueue() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Map<HttpRoute, RouteSpecificPool> createRouteToPoolMap() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public RouteSpecificPool newRouteSpecificPool(HttpRoute httpRoute) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public WaitingThread newWaitingThread(Condition condition, RouteSpecificPool routeSpecificPool) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public RouteSpecificPool getRoutePool(HttpRoute httpRoute, boolean z) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public int getConnectionsInPool(HttpRoute httpRoute) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.tsccm.AbstractConnPool
+    public PoolEntryRequest requestPoolEntry(HttpRoute httpRoute, Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public BasicPoolEntry getEntryBlocking(HttpRoute httpRoute, Object obj, long j, TimeUnit timeUnit, WaitingThreadAborter waitingThreadAborter) throws ConnectionPoolTimeoutException, InterruptedException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.tsccm.AbstractConnPool
+    public void freeEntry(BasicPoolEntry basicPoolEntry, boolean z, long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public BasicPoolEntry getFreeEntry(RouteSpecificPool routeSpecificPool, Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public BasicPoolEntry createEntry(RouteSpecificPool routeSpecificPool, ClientConnectionOperator clientConnectionOperator) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void deleteEntry(BasicPoolEntry basicPoolEntry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void deleteLeastUsedEntry() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.tsccm.AbstractConnPool
+    public void handleLostEntry(HttpRoute httpRoute) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void notifyWaitingThread(RouteSpecificPool routeSpecificPool) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.tsccm.AbstractConnPool
+    public void deleteClosedConnections() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.tsccm.AbstractConnPool
+    public void shutdown() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/tsccm/PoolEntryRequest.java

@@ -0,0 +1,12 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.util.concurrent.TimeUnit;
+import org.apache.http.conn.ConnectionPoolTimeoutException;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public interface PoolEntryRequest {
+    void abortRequest();
+
+    BasicPoolEntry getPoolEntry(long j, TimeUnit timeUnit) throws InterruptedException, ConnectionPoolTimeoutException;
+}

decompiled-community/sources/org/apache/http/impl/conn/tsccm/RefQueueHandler.java

@@ -0,0 +1,9 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.lang.ref.Reference;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public interface RefQueueHandler {
+    void handleReference(Reference<?> reference);
+}

decompiled-community/sources/org/apache/http/impl/conn/tsccm/RefQueueWorker.java

@@ -0,0 +1,28 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.lang.ref.ReferenceQueue;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RefQueueWorker implements Runnable {
+    protected final RefQueueHandler refHandler;
+    protected final ReferenceQueue<?> refQueue;
+    protected volatile Thread workerThread;
+
+    public RefQueueWorker(ReferenceQueue<?> referenceQueue, RefQueueHandler refQueueHandler) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // java.lang.Runnable
+    public void run() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void shutdown() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public String toString() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/tsccm/RouteSpecificPool.java

@@ -0,0 +1,75 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import org.apache.http.conn.routing.HttpRoute;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RouteSpecificPool {
+    protected final LinkedList<BasicPoolEntry> freeEntries;
+    protected final int maxEntries;
+    protected int numEntries;
+    protected final HttpRoute route;
+    protected final Queue<WaitingThread> waitingThreads;
+
+    public RouteSpecificPool(HttpRoute httpRoute, int i) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final HttpRoute getRoute() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final int getMaxEntries() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean isUnused() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public int getCapacity() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final int getEntryCount() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public BasicPoolEntry allocEntry(Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void freeEntry(BasicPoolEntry basicPoolEntry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void createdEntry(BasicPoolEntry basicPoolEntry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean deleteEntry(BasicPoolEntry basicPoolEntry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void dropEntry() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void queueThread(WaitingThread waitingThread) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean hasThread() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public WaitingThread nextThread() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void removeThread(WaitingThread waitingThread) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/tsccm/ThreadSafeClientConnManager.java

@@ -0,0 +1,72 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.util.concurrent.TimeUnit;
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.conn.ClientConnectionOperator;
+import org.apache.http.conn.ClientConnectionRequest;
+import org.apache.http.conn.ManagedClientConnection;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.conn.scheme.SchemeRegistry;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class ThreadSafeClientConnManager implements ClientConnectionManager {
+    protected ClientConnectionOperator connOperator;
+    protected final AbstractConnPool connectionPool;
+    protected SchemeRegistry schemeRegistry;
+
+    public ThreadSafeClientConnManager(HttpParams httpParams, SchemeRegistry schemeRegistry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void finalize() throws Throwable {
+        throw new RuntimeException("Stub!");
+    }
+
+    public AbstractConnPool createConnectionPool(HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public ClientConnectionOperator createConnectionOperator(SchemeRegistry schemeRegistry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public SchemeRegistry getSchemeRegistry() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public ClientConnectionRequest requestConnection(HttpRoute httpRoute, Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void releaseConnection(ManagedClientConnection managedClientConnection, long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void shutdown() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public int getConnectionsInPool(HttpRoute httpRoute) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public int getConnectionsInPool() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void closeIdleConnections(long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void closeExpiredConnections() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/tsccm/WaitingThread.java

@@ -0,0 +1,36 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.util.Date;
+import java.util.concurrent.locks.Condition;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class WaitingThread {
+    public WaitingThread(Condition condition, RouteSpecificPool routeSpecificPool) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final Condition getCondition() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final RouteSpecificPool getPool() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final Thread getThread() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean await(Date date) throws InterruptedException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void wakeup() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void interrupt() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/conn/tsccm/WaitingThreadAborter.java

@@ -0,0 +1,17 @@
+package org.apache.http.impl.conn.tsccm;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class WaitingThreadAborter {
+    public WaitingThreadAborter() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void abort() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void setWaitingThread(WaitingThread waitingThread) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/AbstractCookieAttributeHandler.java

@@ -0,0 +1,24 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieAttributeHandler;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AbstractCookieAttributeHandler implements CookieAttributeHandler {
+    public AbstractCookieAttributeHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public boolean match(Cookie cookie, CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/AbstractCookieSpec.java

@@ -0,0 +1,29 @@
+package org.apache.http.impl.cookie;
+
+import java.util.Collection;
+import org.apache.http.cookie.CookieAttributeHandler;
+import org.apache.http.cookie.CookieSpec;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AbstractCookieSpec implements CookieSpec {
+    public AbstractCookieSpec() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void registerAttribHandler(String str, CookieAttributeHandler cookieAttributeHandler) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public CookieAttributeHandler findAttribHandler(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public CookieAttributeHandler getAttribHandler(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Collection<CookieAttributeHandler> getAttribHandlers() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/BasicClientCookie.java

@@ -0,0 +1,130 @@
+package org.apache.http.impl.cookie;
+
+import java.util.Date;
+import org.apache.http.cookie.ClientCookie;
+import org.apache.http.cookie.SetCookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicClientCookie implements SetCookie, ClientCookie {
+    public BasicClientCookie(String str, String str2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.Cookie
+    public String getName() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.Cookie
+    public String getValue() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.SetCookie
+    public void setValue(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.Cookie
+    public String getComment() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.SetCookie
+    public void setComment(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.Cookie
+    public String getCommentURL() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.Cookie
+    public Date getExpiryDate() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.SetCookie
+    public void setExpiryDate(Date date) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.Cookie
+    public boolean isPersistent() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.Cookie
+    public String getDomain() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.SetCookie
+    public void setDomain(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.Cookie
+    public String getPath() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.SetCookie
+    public void setPath(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.Cookie
+    public boolean isSecure() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.SetCookie
+    public void setSecure(boolean z) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.Cookie
+    public int[] getPorts() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.Cookie
+    public int getVersion() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.SetCookie
+    public void setVersion(int i) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.Cookie
+    public boolean isExpired(Date date) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void setAttribute(String str, String str2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.ClientCookie
+    public String getAttribute(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.ClientCookie
+    public boolean containsAttribute(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Object clone() throws CloneNotSupportedException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public String toString() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/BasicClientCookie2.java

@@ -0,0 +1,53 @@
+package org.apache.http.impl.cookie;
+
+import java.util.Date;
+import org.apache.http.cookie.SetCookie2;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicClientCookie2 extends BasicClientCookie implements SetCookie2 {
+    public BasicClientCookie2(String str, String str2) {
+        super(null, null);
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.BasicClientCookie, org.apache.http.cookie.Cookie
+    public int[] getPorts() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.SetCookie2
+    public void setPorts(int[] iArr) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.BasicClientCookie, org.apache.http.cookie.Cookie
+    public String getCommentURL() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.SetCookie2
+    public void setCommentURL(String str) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.SetCookie2
+    public void setDiscard(boolean z) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.BasicClientCookie, org.apache.http.cookie.Cookie
+    public boolean isPersistent() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.BasicClientCookie, org.apache.http.cookie.Cookie
+    public boolean isExpired(Date date) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.BasicClientCookie
+    public Object clone() throws CloneNotSupportedException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/BasicCommentHandler.java

@@ -0,0 +1,17 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.cookie.SetCookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicCommentHandler extends AbstractCookieAttributeHandler {
+    public BasicCommentHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void parse(SetCookie setCookie, String str) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/BasicDomainHandler.java

@@ -0,0 +1,30 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieAttributeHandler;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.cookie.SetCookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicDomainHandler implements CookieAttributeHandler {
+    public BasicDomainHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void parse(SetCookie setCookie, String str) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public boolean match(Cookie cookie, CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/BasicExpiresHandler.java

@@ -0,0 +1,17 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.cookie.SetCookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicExpiresHandler extends AbstractCookieAttributeHandler {
+    public BasicExpiresHandler(String[] strArr) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void parse(SetCookie setCookie, String str) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/BasicMaxAgeHandler.java

@@ -0,0 +1,17 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.cookie.SetCookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicMaxAgeHandler extends AbstractCookieAttributeHandler {
+    public BasicMaxAgeHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void parse(SetCookie setCookie, String str) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/BasicPathHandler.java

@@ -0,0 +1,30 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieAttributeHandler;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.cookie.SetCookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicPathHandler implements CookieAttributeHandler {
+    public BasicPathHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void parse(SetCookie setCookie, String str) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public boolean match(Cookie cookie, CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/BasicSecureHandler.java

@@ -0,0 +1,24 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.cookie.SetCookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicSecureHandler extends AbstractCookieAttributeHandler {
+    public BasicSecureHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void parse(SetCookie setCookie, String str) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.AbstractCookieAttributeHandler, org.apache.http.cookie.CookieAttributeHandler
+    public boolean match(Cookie cookie, CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/BestMatchSpec.java

@@ -0,0 +1,50 @@
+package org.apache.http.impl.cookie;
+
+import java.util.List;
+import org.apache.http.Header;
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.CookieSpec;
+import org.apache.http.cookie.MalformedCookieException;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BestMatchSpec implements CookieSpec {
+    public BestMatchSpec(String[] strArr, boolean z) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public BestMatchSpec() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public List<Cookie> parse(Header header, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public boolean match(Cookie cookie, CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public List<Header> formatCookies(List<Cookie> list) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public int getVersion() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public Header getVersionHeader() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/BestMatchSpecFactory.java

@@ -0,0 +1,18 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.CookieSpec;
+import org.apache.http.cookie.CookieSpecFactory;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BestMatchSpecFactory implements CookieSpecFactory {
+    public BestMatchSpecFactory() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpecFactory
+    public CookieSpec newInstance(HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/BrowserCompatSpec.java

@@ -0,0 +1,41 @@
+package org.apache.http.impl.cookie;
+
+import java.util.List;
+import org.apache.http.Header;
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BrowserCompatSpec extends CookieSpecBase {
+    protected static final String[] DATE_PATTERNS = null;
+
+    public BrowserCompatSpec(String[] strArr) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public BrowserCompatSpec() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public List<Cookie> parse(Header header, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public List<Header> formatCookies(List<Cookie> list) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public int getVersion() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public Header getVersionHeader() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/BrowserCompatSpecFactory.java

@@ -0,0 +1,18 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.CookieSpec;
+import org.apache.http.cookie.CookieSpecFactory;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BrowserCompatSpecFactory implements CookieSpecFactory {
+    public BrowserCompatSpecFactory() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpecFactory
+    public CookieSpec newInstance(HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/CookieSpecBase.java

@@ -0,0 +1,37 @@
+package org.apache.http.impl.cookie;
+
+import java.util.List;
+import org.apache.http.HeaderElement;
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class CookieSpecBase extends AbstractCookieSpec {
+    public CookieSpecBase() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static String getDefaultPath(CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static String getDefaultDomain(CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public List<Cookie> parse(HeaderElement[] headerElementArr, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public boolean match(Cookie cookie, CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/DateParseException.java

@@ -0,0 +1,13 @@
+package org.apache.http.impl.cookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DateParseException extends Exception {
+    public DateParseException() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public DateParseException(String str) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/DateUtils.java

@@ -0,0 +1,37 @@
+package org.apache.http.impl.cookie;
+
+import java.util.Date;
+import java.util.TimeZone;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public final class DateUtils {
+    public static final TimeZone GMT = null;
+    public static final String PATTERN_ASCTIME = "EEE MMM d HH:mm:ss yyyy";
+    public static final String PATTERN_RFC1036 = "EEEE, dd-MMM-yy HH:mm:ss zzz";
+    public static final String PATTERN_RFC1123 = "EEE, dd MMM yyyy HH:mm:ss zzz";
+
+    public DateUtils() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static Date parseDate(String str) throws DateParseException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static Date parseDate(String str, String[] strArr) throws DateParseException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static Date parseDate(String str, String[] strArr, Date date) throws DateParseException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static String formatDate(Date date) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public static String formatDate(Date date, String str) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/NetscapeDomainHandler.java

@@ -0,0 +1,23 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class NetscapeDomainHandler extends BasicDomainHandler {
+    public NetscapeDomainHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.BasicDomainHandler, org.apache.http.cookie.CookieAttributeHandler
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.BasicDomainHandler, org.apache.http.cookie.CookieAttributeHandler
+    public boolean match(Cookie cookie, CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/NetscapeDraftHeaderParser.java

@@ -0,0 +1,20 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.HeaderElement;
+import org.apache.http.ParseException;
+import org.apache.http.message.ParserCursor;
+import org.apache.http.util.CharArrayBuffer;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class NetscapeDraftHeaderParser {
+    public static final NetscapeDraftHeaderParser DEFAULT = null;
+
+    public NetscapeDraftHeaderParser() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HeaderElement parseHeader(CharArrayBuffer charArrayBuffer, ParserCursor parserCursor) throws ParseException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/NetscapeDraftSpec.java

@@ -0,0 +1,41 @@
+package org.apache.http.impl.cookie;
+
+import java.util.List;
+import org.apache.http.Header;
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class NetscapeDraftSpec extends CookieSpecBase {
+    protected static final String EXPIRES_PATTERN = "EEE, dd-MMM-yyyy HH:mm:ss z";
+
+    public NetscapeDraftSpec(String[] strArr) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public NetscapeDraftSpec() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public List<Cookie> parse(Header header, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public List<Header> formatCookies(List<Cookie> list) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public int getVersion() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public Header getVersionHeader() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/NetscapeDraftSpecFactory.java

@@ -0,0 +1,18 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.CookieSpec;
+import org.apache.http.cookie.CookieSpecFactory;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class NetscapeDraftSpecFactory implements CookieSpecFactory {
+    public NetscapeDraftSpecFactory() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpecFactory
+    public CookieSpec newInstance(HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/RFC2109DomainHandler.java

@@ -0,0 +1,30 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieAttributeHandler;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.cookie.SetCookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RFC2109DomainHandler implements CookieAttributeHandler {
+    public RFC2109DomainHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void parse(SetCookie setCookie, String str) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public boolean match(Cookie cookie, CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/RFC2109Spec.java

@@ -0,0 +1,53 @@
+package org.apache.http.impl.cookie;
+
+import java.util.List;
+import org.apache.http.Header;
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.util.CharArrayBuffer;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RFC2109Spec extends CookieSpecBase {
+    public RFC2109Spec(String[] strArr, boolean z) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public RFC2109Spec() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public List<Cookie> parse(Header header, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.CookieSpecBase, org.apache.http.cookie.CookieSpec
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public List<Header> formatCookies(List<Cookie> list) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void formatParamAsVer(CharArrayBuffer charArrayBuffer, String str, String str2, int i) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void formatCookieAsVer(CharArrayBuffer charArrayBuffer, Cookie cookie, int i) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public int getVersion() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpec
+    public Header getVersionHeader() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/RFC2109SpecFactory.java

@@ -0,0 +1,18 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.CookieSpec;
+import org.apache.http.cookie.CookieSpecFactory;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RFC2109SpecFactory implements CookieSpecFactory {
+    public RFC2109SpecFactory() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpecFactory
+    public CookieSpec newInstance(HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/RFC2109VersionHandler.java

@@ -0,0 +1,24 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.cookie.SetCookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RFC2109VersionHandler extends AbstractCookieAttributeHandler {
+    public RFC2109VersionHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void parse(SetCookie setCookie, String str) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.AbstractCookieAttributeHandler, org.apache.http.cookie.CookieAttributeHandler
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/RFC2965CommentUrlAttributeHandler.java

@@ -0,0 +1,30 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieAttributeHandler;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.cookie.SetCookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RFC2965CommentUrlAttributeHandler implements CookieAttributeHandler {
+    public RFC2965CommentUrlAttributeHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void parse(SetCookie setCookie, String str) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public boolean match(Cookie cookie, CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/RFC2965DiscardAttributeHandler.java

@@ -0,0 +1,30 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieAttributeHandler;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.cookie.SetCookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RFC2965DiscardAttributeHandler implements CookieAttributeHandler {
+    public RFC2965DiscardAttributeHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void parse(SetCookie setCookie, String str) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public boolean match(Cookie cookie, CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/RFC2965DomainAttributeHandler.java

@@ -0,0 +1,34 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieAttributeHandler;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.cookie.SetCookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RFC2965DomainAttributeHandler implements CookieAttributeHandler {
+    public RFC2965DomainAttributeHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void parse(SetCookie setCookie, String str) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean domainMatch(String str, String str2) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public boolean match(Cookie cookie, CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/RFC2965PortAttributeHandler.java

@@ -0,0 +1,30 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieAttributeHandler;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.cookie.SetCookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RFC2965PortAttributeHandler implements CookieAttributeHandler {
+    public RFC2965PortAttributeHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void parse(SetCookie setCookie, String str) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public boolean match(Cookie cookie, CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/RFC2965Spec.java

@@ -0,0 +1,50 @@
+package org.apache.http.impl.cookie;
+
+import java.util.List;
+import org.apache.http.Header;
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.util.CharArrayBuffer;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RFC2965Spec extends RFC2109Spec {
+    public RFC2965Spec() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public RFC2965Spec(String[] strArr, boolean z) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.RFC2109Spec, org.apache.http.cookie.CookieSpec
+    public List<Cookie> parse(Header header, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.RFC2109Spec, org.apache.http.impl.cookie.CookieSpecBase, org.apache.http.cookie.CookieSpec
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.CookieSpecBase, org.apache.http.cookie.CookieSpec
+    public boolean match(Cookie cookie, CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.RFC2109Spec
+    public void formatCookieAsVer(CharArrayBuffer charArrayBuffer, Cookie cookie, int i) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.RFC2109Spec, org.apache.http.cookie.CookieSpec
+    public int getVersion() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.cookie.RFC2109Spec, org.apache.http.cookie.CookieSpec
+    public Header getVersionHeader() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/RFC2965SpecFactory.java

@@ -0,0 +1,18 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.CookieSpec;
+import org.apache.http.cookie.CookieSpecFactory;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RFC2965SpecFactory implements CookieSpecFactory {
+    public RFC2965SpecFactory() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieSpecFactory
+    public CookieSpec newInstance(HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/cookie/RFC2965VersionAttributeHandler.java

@@ -0,0 +1,30 @@
+package org.apache.http.impl.cookie;
+
+import org.apache.http.cookie.Cookie;
+import org.apache.http.cookie.CookieAttributeHandler;
+import org.apache.http.cookie.CookieOrigin;
+import org.apache.http.cookie.MalformedCookieException;
+import org.apache.http.cookie.SetCookie;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RFC2965VersionAttributeHandler implements CookieAttributeHandler {
+    public RFC2965VersionAttributeHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void parse(SetCookie setCookie, String str) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public void validate(Cookie cookie, CookieOrigin cookieOrigin) throws MalformedCookieException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.cookie.CookieAttributeHandler
+    public boolean match(Cookie cookie, CookieOrigin cookieOrigin) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/entity/EntityDeserializer.java

@@ -0,0 +1,25 @@
+package org.apache.http.impl.entity;
+
+import java.io.IOException;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpException;
+import org.apache.http.HttpMessage;
+import org.apache.http.entity.BasicHttpEntity;
+import org.apache.http.entity.ContentLengthStrategy;
+import org.apache.http.io.SessionInputBuffer;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class EntityDeserializer {
+    public EntityDeserializer(ContentLengthStrategy contentLengthStrategy) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public BasicHttpEntity doDeserialize(SessionInputBuffer sessionInputBuffer, HttpMessage httpMessage) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HttpEntity deserialize(SessionInputBuffer sessionInputBuffer, HttpMessage httpMessage) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled-community/sources/org/apache/http/impl/entity/EntitySerializer.java

@@ -0,0 +1,25 @@
+package org.apache.http.impl.entity;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpException;
+import org.apache.http.HttpMessage;
+import org.apache.http.entity.ContentLengthStrategy;
+import org.apache.http.io.SessionOutputBuffer;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class EntitySerializer {
+    public EntitySerializer(ContentLengthStrategy contentLengthStrategy) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public OutputStream doSerialize(SessionOutputBuffer sessionOutputBuffer, HttpMessage httpMessage) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void serialize(SessionOutputBuffer sessionOutputBuffer, HttpMessage httpMessage, HttpEntity httpEntity) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+}