Info Call to Reflection API

Description

List of calls allowing the application to examine and modify the structure and behavior of an object at runtime.

Recommendation

This entry is informative, no recommendations applicable.

Technical details

Method kotlinx.coroutines.CommonPool.isGoodCommonPool$kotlinx_coroutines_core() calling method java.lang.reflect.Method.invoke()


    public final boolean isGoodCommonPool$kotlinx_coroutines_core(Class p8, java.util.concurrent.ExecutorService p9)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p8, "fjpClass");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p9, "executor");
        p9.submit(((Runnable) kotlinx.coroutines.CommonPool$isGoodCommonPool$1.INSTANCE));
        int v1 = 0;
        Integer v3 = 0;
        try {
            boolean v6_0 = new Class[0];
            boolean v6_1 = new Object[0];
            int v5_2 = p8.getMethod("getPoolSize", v6_0).invoke(p9, v6_1);
        } catch (Integer v3) {
            Integer v3_0 = 0;
            if (v3_0 == null) {
                return 0;
            } else {
                if (v3_0.intValue() >= 1) {
                    v1 = 1;
                }
                return v1;
            }
        }
        if (!(v5_2 instanceof Integer)) {
            v5_2 = 0;
        }
        v3_0 = ((Integer) v5_2);
    }

Method kotlinx.coroutines.CommonPool.createPool() calling method java.lang.reflect.Method.invoke()


    private final java.util.concurrent.ExecutorService createPool()
    {
        if (System.getSecurityManager() == null) {
            int v3 = 0;
            try {
                boolean v5_0 = Class.forName("java.util.concurrent.ForkJoinPool");
            } catch (boolean v5) {
                v5_0 = 0;
            }
            if (!v5_0) {
                return this.createPlainPool();
            } else {
                java.util.concurrent.ExecutorService v0_2 = v5_0;
                if ((!kotlinx.coroutines.CommonPool.usePrivatePool) && (kotlinx.coroutines.CommonPool.requestedParallelism < 0)) {
                    try {
                        int v6_3;
                        int v6_2;
                        java.util.concurrent.ExecutorService v7_1 = new Class[0];
                        int v6_1 = v0_2.getMethod("commonPool", v7_1);
                    } catch (int v6) {
                        v6_3 = 0;
                        if (v6_3 != 0) {
                            if (!kotlinx.coroutines.CommonPool.INSTANCE.isGoodCommonPool$kotlinx_coroutines_core(v0_2, v6_3)) {
                                v6_3 = 0;
                            }
                            if (v6_3 != 0) {
                                return v6_3;
                            }
                        }
                    }
                    if (v6_1 == 0) {
                        v6_2 = 0;
                    } else {
                        java.util.concurrent.ExecutorService v7_2 = new Object[0];
                        v6_2 = v6_1.invoke(0, v7_2);
                    }
                    if (!(v6_2 instanceof java.util.concurrent.ExecutorService)) {
                        v6_2 = 0;
                    }
                    v6_3 = ((java.util.concurrent.ExecutorService) v6_2);
                }
                try {
                    kotlinx.coroutines.CommonPool v8_1 = new Class[1];
                    v8_1[0] = Integer.TYPE;
                    kotlinx.coroutines.CommonPool v8_2 = v0_2.getConstructor(v8_1);
                    int v6_5 = new Object[1];
                    v6_5[0] = Integer.valueOf(kotlinx.coroutines.CommonPool.INSTANCE.getParallelism());
                    int v1_1 = v8_2.newInstance(v6_5);
                } catch (int v1) {
                    int v1_2 = 0;
                    if (v1_2 == 0) {
                        return this.createPlainPool();
                    } else {
                        return v1_2;
                    }
                }
                if (!(v1_1 instanceof java.util.concurrent.ExecutorService)) {
                    v1_1 = 0;
                }
                v1_2 = ((java.util.concurrent.ExecutorService) v1_1);
            }
        } else {
            return this.createPlainPool();
        }
    }

Method kotlinx.coroutines.android.AndroidExceptionPreHandler.handleException() calling method java.lang.reflect.Method.invoke()


    public void handleException(kotlin.coroutines.CoroutineContext p4, Throwable p5)
    {
        Thread$UncaughtExceptionHandler v0_1;
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p4, "context");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p5, "exception");
        Thread$UncaughtExceptionHandler v0_4 = kotlinx.coroutines.android.AndroidExceptionPreHandlerKt.access$getGetter$p();
        if (v0_4 == null) {
            v0_1 = 0;
        } else {
            boolean v2_1 = new Object[0];
            v0_1 = v0_4.invoke(0, v2_1);
        }
        if (!(v0_1 instanceof Thread$UncaughtExceptionHandler)) {
            v0_1 = 0;
        }
        Thread$UncaughtExceptionHandler v0_2 = ((Thread$UncaughtExceptionHandler) v0_1);
        if (v0_2 != null) {
            v0_2.uncaughtException(Thread.currentThread(), p5);
        }
        return;
    }

Method org.apache.commons.math3.stat.descriptive.DescriptiveStatistics.setPercentileImpl() calling method java.lang.reflect.Method.invoke()


    public declared_synchronized void setPercentileImpl(org.apache.commons.math3.stat.descriptive.UnivariateStatistic p8)
    {
        try {
            IllegalAccessException v3_1 = p8.getClass();
            org.apache.commons.math3.exception.util.LocalizedFormats v5_4 = new Class[1];
            v5_4[0] = Double.TYPE;
            IllegalAccessException v3_0 = v3_1.getMethod("setQuantile", v5_4);
            org.apache.commons.math3.exception.MathIllegalArgumentException v4_0 = new Object[1];
            v4_0[0] = Double.valueOf(50.0);
            v3_0.invoke(p8, v4_0);
        } catch (Throwable v8_1) {
            throw v8_1;
        } catch (reflect.InvocationTargetException v0_1) {
            throw new IllegalArgumentException(v0_1.getCause());
        }
        this.percentileImpl = p8;
        return;
    }

Method org.apache.commons.math3.stat.descriptive.DescriptiveStatistics.getPercentile() calling method java.lang.reflect.Method.invoke()


    public double getPercentile(double p8)
    {
        if (!(this.percentileImpl instanceof org.apache.commons.math3.stat.descriptive.rank.Percentile)) {
            try {
                IllegalAccessException v3_2 = this.percentileImpl.getClass();
                org.apache.commons.math3.exception.util.LocalizedFormats v5_0 = new Class[1];
                v5_0[0] = Double.TYPE;
                IllegalAccessException v3_0 = v3_2.getMethod("setQuantile", v5_0);
                org.apache.commons.math3.exception.MathIllegalStateException v4_0 = this.percentileImpl;
                org.apache.commons.math3.exception.util.LocalizedFormats v5_1 = new Object[1];
                v5_1[0] = Double.valueOf(p8);
                v3_0.invoke(v4_0, v5_1);
            } catch (IllegalAccessException v3) {
                reflect.InvocationTargetException v0_5 = new Object[2];
                v0_5[0] = this.percentileImpl.getClass().getName();
                v0_5[1] = "setQuantile";
                throw new org.apache.commons.math3.exception.MathIllegalStateException(org.apache.commons.math3.exception.util.LocalizedFormats.PERCENTILE_IMPLEMENTATION_UNSUPPORTED_METHOD, v0_5);
            } catch (IllegalAccessException v3) {
                reflect.InvocationTargetException v0_4 = new Object[2];
                v0_4[0] = "setQuantile";
                v0_4[1] = this.percentileImpl.getClass().getName();
                throw new org.apache.commons.math3.exception.MathIllegalStateException(org.apache.commons.math3.exception.util.LocalizedFormats.PERCENTILE_IMPLEMENTATION_CANNOT_ACCESS_METHOD, v0_4);
            } catch (reflect.InvocationTargetException v0_2) {
                throw new IllegalStateException(v0_2.getCause());
            }
        } else {
            ((org.apache.commons.math3.stat.descriptive.rank.Percentile) this.percentileImpl).setQuantile(p8);
        }
        return this.apply(this.percentileImpl);
    }

Method okhttp3.internal.platform.JdkWithJettyBootPlatform.getSelectedProtocol() calling method java.lang.reflect.Method.invoke()


    public String getSelectedProtocol(javax.net.ssl.SSLSocket p6)
    {
        try {
            reflect.InvocationTargetException v0_0 = this.getMethod;
            okhttp3.internal.platform.Platform v1_4 = new Object[1];
            v1_4[0] = p6;
            String v2_0 = 0;
            reflect.InvocationTargetException v0_1 = ((okhttp3.internal.platform.JdkWithJettyBootPlatform$JettyNegoProvider) reflect.Proxy.getInvocationHandler(v0_0.invoke(0, v1_4)));
        } catch (reflect.InvocationTargetException v0_2) {
            throw okhttp3.internal.Util.assertionError("unable to get selected protocol", v0_2);
        }
        if ((v0_1.unsupported) || (v0_1.selected != null)) {
            if (!v0_1.unsupported) {
                v2_0 = v0_1.selected;
            } else {
            }
            return v2_0;
        } else {
            okhttp3.internal.platform.Platform.get().log(4, "ALPN callback dropped: HTTP/2 is disabled. Is alpn-boot on the boot class path?", 0);
            return 0;
        }
    }

Method okhttp3.internal.platform.JdkWithJettyBootPlatform.configureTlsExtensions() calling method java.lang.reflect.Method.invoke()


    public void configureTlsExtensions(javax.net.ssl.SSLSocket p8, String p9, java.util.List p10)
    {
        java.util.List v0 = okhttp3.internal.platform.JdkWithJettyBootPlatform.alpnProtocolNames(p10);
        try {
            reflect.InvocationTargetException v1_3 = okhttp3.internal.platform.Platform.getClassLoader();
            reflect.Method v3_1 = new Class[2];
            v3_1[0] = this.clientProviderClass;
            v3_1[1] = this.serverProviderClass;
            reflect.InvocationTargetException v1_0 = reflect.Proxy.newProxyInstance(v1_3, v3_1, new okhttp3.internal.platform.JdkWithJettyBootPlatform$JettyNegoProvider(v0));
            reflect.Method v3_0 = this.putMethod;
            AssertionError v2_0 = new Object[2];
            v2_0[0] = p8;
            v2_0[1] = v1_0;
            v3_0.invoke(0, v2_0);
            return;
        } catch (reflect.InvocationTargetException v1_2) {
            throw okhttp3.internal.Util.assertionError("unable to set alpn", v1_2);
        }
    }

Method okhttp3.internal.platform.JdkWithJettyBootPlatform.afterHandshake() calling method java.lang.reflect.Method.invoke()


    public void afterHandshake(javax.net.ssl.SSLSocket p5)
    {
        try {
            IllegalAccessException v0_0 = this.removeMethod;
            Object[] v2_1 = new Object[1];
            v2_1[0] = p5;
            v0_0.invoke(0, v2_1);
            return;
        } catch (IllegalAccessException v0_1) {
            throw okhttp3.internal.Util.assertionError("unable to remove alpn", v0_1);
        }
    }

Method okhttp3.internal.platform.Jdk9Platform.getSelectedProtocol() calling method java.lang.reflect.Method.invoke()


    public String getSelectedProtocol(javax.net.ssl.SSLSocket p3)
    {
        try {
            int v1_5 = new Object[0];
            IllegalAccessException v0_2 = ((String) this.getProtocolMethod.invoke(p3, v1_5));
        } catch (IllegalAccessException v0_3) {
            throw okhttp3.internal.Util.assertionError("unable to get selected protocols", v0_3);
        }
        if ((v0_2 != null) && (!v0_2.equals(""))) {
            return v0_2;
        } else {
            return 0;
        }
    }

Method okhttp3.internal.platform.Jdk9Platform.configureTlsExtensions() calling method java.lang.reflect.Method.invoke()


    public void configureTlsExtensions(javax.net.ssl.SSLSocket p7, String p8, java.util.List p9)
    {
        try {
            IllegalAccessException v0_0 = p7.getSSLParameters();
            AssertionError v1_2 = okhttp3.internal.platform.Jdk9Platform.alpnProtocolNames(p9);
            reflect.Method v2 = this.setProtocolMethod;
            Object[] v3_1 = new Object[1];
            Object[] v5_0 = new String[v1_2.size()];
            v3_1[0] = v1_2.toArray(v5_0);
            v2.invoke(v0_0, v3_1);
            p7.setSSLParameters(v0_0);
            return;
        } catch (IllegalAccessException v0_1) {
            throw okhttp3.internal.Util.assertionError("unable to set ssl parameters", v0_1);
        }
    }

Method okhttp3.internal.platform.AndroidPlatform.isCleartextTrafficPermitted() calling method java.lang.reflect.Method.invoke()


    public boolean isCleartextTrafficPermitted(String p5)
    {
        try {
            IllegalAccessException v0_2 = Class.forName("android.security.NetworkSecurityPolicy");
            boolean v3_1 = new Class[0];
            Object v2_2 = new Object[0];
            return this.api24IsCleartextTrafficPermitted(p5, v0_2, v0_2.getMethod("getInstance", v3_1).invoke(0, v2_2));
        } catch (IllegalAccessException v0) {
            return super.isCleartextTrafficPermitted(p5);
        } catch (IllegalAccessException v0_1) {
            throw okhttp3.internal.Util.assertionError("unable to determine cleartext support", v0_1);
        }
    }

Method okhttp3.internal.platform.AndroidPlatform.api24IsCleartextTrafficPermitted() calling method java.lang.reflect.Method.invoke()


    private boolean api24IsCleartextTrafficPermitted(String p6, Class p7, Object p8)
    {
        try {
            Class[] v2 = new Class[1];
            v2[0] = String;
            NoSuchMethodException v0_1 = p7.getMethod("isCleartextTrafficPermitted", v2);
            boolean v1_5 = new Object[1];
            v1_5[0] = p6;
            return ((Boolean) v0_1.invoke(p8, v1_5)).booleanValue();
        } catch (NoSuchMethodException v0) {
            return this.api23IsCleartextTrafficPermitted(p6, p7, p8);
        }
    }

Method okhttp3.internal.platform.AndroidPlatform.api23IsCleartextTrafficPermitted() calling method java.lang.reflect.Method.invoke()


    private boolean api23IsCleartextTrafficPermitted(String p4, Class p5, Object p6)
    {
        try {
            Class[] v2 = new Class[0];
            boolean v1_3 = new Object[0];
            return ((Boolean) p5.getMethod("isCleartextTrafficPermitted", v2).invoke(p6, v1_3)).booleanValue();
        } catch (NoSuchMethodException v0) {
            return super.isCleartextTrafficPermitted(p4);
        }
    }

Method okhttp3.internal.platform.AndroidPlatform$AndroidTrustRootIndex.findByIssuerAndSignature() calling method java.lang.reflect.Method.invoke()


    public java.security.cert.X509Certificate findByIssuerAndSignature(java.security.cert.X509Certificate p6)
    {
        java.security.cert.X509Certificate v0_0 = 0;
        try {
            reflect.InvocationTargetException v1_0 = this.findByIssuerAndSignatureMethod;
            java.security.cert.X509Certificate v2_0 = this.trustManager;
            Object[] v3_1 = new Object[1];
            v3_1[0] = p6;
            reflect.InvocationTargetException v1_4 = ((java.security.cert.TrustAnchor) v1_0.invoke(v2_0, v3_1));
        } catch (java.security.cert.X509Certificate v0_1) {
            throw okhttp3.internal.Util.assertionError("unable to get issues and signature", v0_1);
        } catch (reflect.InvocationTargetException v1) {
            return 0;
        }
        if (v1_4 == null) {
        } else {
            v0_0 = v1_4.getTrustedCert();
        }
        return v0_0;
    }

Method okhttp3.internal.platform.AndroidPlatform$AndroidCertificateChainCleaner.clean() calling method java.lang.reflect.Method.invoke()


    public java.util.List clean(java.util.List p7, String p8)
    {
        try {
            IllegalAccessException v0_1 = new java.security.cert.X509Certificate[p7.size()];
            AssertionError v1_6 = this.checkServerTrusted;
            String v2_1 = this.x509TrustManagerExtensions;
            Object[] v3_1 = new Object[3];
            v3_1[0] = ((java.security.cert.X509Certificate[]) p7.toArray(v0_1));
            v3_1[1] = "RSA";
            v3_1[2] = p8;
            return ((java.util.List) v1_6.invoke(v2_1, v3_1));
        } catch (IllegalAccessException v0_3) {
            AssertionError v1_5 = new javax.net.ssl.SSLPeerUnverifiedException(v0_3.getMessage());
            v1_5.initCause(v0_3);
            throw v1_5;
        } catch (IllegalAccessException v0_2) {
            throw new AssertionError(v0_2);
        }
    }

Method net.minidev.json.reader.BeansWriter.writeJSONString() calling method java.lang.reflect.Method.invoke()


    public void writeJSONString(Object p18, Appendable p19, net.minidev.json.JSONStyle p20)
    {
        try {
            Object v0_9 = p18.getClass();
            p20.objectStart(p19);
            Class v4_1 = v0_9;
            Object v0_14 = 0;
        } catch (Object v0_15) {
            throw new RuntimeException(v0_15);
        }
        while (v4_1 != Object) {
            reflect.Field[] v5_1 = v4_1.getDeclaredFields();
            int v6 = v5_1.length;
            int v9 = v0_14;
            int v8 = 0;
            while (v8 < v6) {
                reflect.Field v10 = v5_1[v8];
                int v11 = v10.getModifiers();
                if ((v11 & 152) <= 0) {
                    Object v0_12;
                    if ((v11 & 1) <= 0) {
                        try {
                            Object v0_7 = new Class[0];
                            reflect.Method v14 = v4_1.getDeclaredMethod(net.minidev.json.JSONUtil.getGetterName(v10.getName()), v0_7);
                        } catch (Object v0) {
                        }
                        if (v14 == null) {
                            Object v0_10 = v10.getType();
                            if ((v0_10 == Boolean.TYPE) || (v0_10 == Boolean)) {
                                reflect.Method v15_4 = new Class[0];
                                v14 = v4_1.getDeclaredMethod(net.minidev.json.JSONUtil.getIsName(v10.getName()), v15_4);
                            }
                        }
                        if (v14 != null) {
                            Object v0_11 = new Object[0];
                            v0_12 = v14.invoke(p18, v0_11);
                        } else {
                            v8++;
                        }
                    } else {
                        v0_12 = v10.get(p18);
                    }
                    if ((v0_12 != null) || (!p20.ignoreNull())) {
                        if (v9 == 0) {
                            v9 = 1;
                        } else {
                            p20.objectNext(p19);
                        }
                        net.minidev.json.reader.JsonWriter.writeJSONKV(v10.getName(), v0_12, p19, p20);
                    } else {
                    }
                } else {
                }
            }
            v4_1 = v4_1.getSuperclass();
            v0_14 = v9;
        }
        p20.objectStop(p19);
        return;
    }

Method org.greenrobot.eventbus.EventBus.invokeSubscriber() calling method java.lang.reflect.Method.invoke()


    void invokeSubscriber(org.greenrobot.eventbus.Subscription p5, Object p6)
    {
        try {
            IllegalAccessException v0_1 = p5.subscriberMethod.method;
            IllegalStateException v1_2 = p5.subscriber;
            String v2_2 = new Object[1];
            v2_2[0] = p6;
            v0_1.invoke(v1_2, v2_2);
        } catch (IllegalAccessException v0_2) {
            this.handleSubscriberException(p5, p6, v0_2.getCause());
        } catch (IllegalAccessException v0_3) {
            throw new IllegalStateException("Unexpected exception", v0_3);
        }
        return;
    }

Method okhttp3.internal.platform.OptionalMethod.invokeOptional() calling method java.lang.reflect.Method.invoke()


    public varargs Object invokeOptional(Object p4, Object[] p5)
    {
        reflect.Method v0_1 = this.getMethod(p4.getClass());
        if (v0_1 != null) {
            try {
                return v0_1.invoke(p4, p5);
            } catch (IllegalAccessException v2) {
                return 0;
            }
        } else {
            return 0;
        }
    }

Method okhttp3.internal.platform.OptionalMethod.invoke() calling method java.lang.reflect.Method.invoke()


    public varargs Object invoke(Object p6, Object[] p7)
    {
        reflect.Method v0_1 = this.getMethod(p6.getClass());
        if (v0_1 == null) {
            AssertionError v2_4 = new StringBuilder();
            v2_4.append("Method ");
            v2_4.append(this.methodName);
            v2_4.append(" not supported for object ");
            v2_4.append(p6);
            throw new AssertionError(v2_4.toString());
        } else {
            try {
                return v0_1.invoke(p6, p7);
            } catch (IllegalAccessException v1_2) {
                String v3_3 = new StringBuilder();
                v3_3.append("Unexpectedly could not call: ");
                v3_3.append(v0_1);
                AssertionError v2_2 = new AssertionError(v3_3.toString());
                v2_2.initCause(v1_2);
                throw v2_2;
            }
        }
    }

Method okhttp3.internal.platform.JdkWithJettyBootPlatform$JettyNegoProvider.invoke() calling method java.lang.reflect.Method.invoke()


    public Object invoke(Object p9, reflect.Method p10, Object[] p11)
    {
        String v0 = p10.getName();
        Class v1 = p10.getReturnType();
        if (p11 == null) {
            p11 = okhttp3.internal.Util.EMPTY_STRING_ARRAY;
        }
        if ((!v0.equals("supports")) || (Boolean.TYPE != v1)) {
            if ((!v0.equals("unsupported")) || (Void.TYPE != v1)) {
                if ((!v0.equals("protocols")) || (p11.length != 0)) {
                    if (((!v0.equals("selectProtocol")) && (!v0.equals("select"))) || ((String != v1) || ((p11.length != 1) || (!(p11[0] instanceof java.util.List))))) {
                        if (((!v0.equals("protocolSelected")) && (!v0.equals("selected"))) || (p11.length != 1)) {
                            return p10.invoke(this, p11);
                        } else {
                            this.selected = ((String) p11[0]);
                            return 0;
                        }
                    } else {
                        java.util.List v2_25 = ((java.util.List) p11[0]);
                        int v3_0 = 0;
                        int v4_1 = v2_25.size();
                        while (v3_0 < v4_1) {
                            if (!this.protocols.contains(v2_25.get(v3_0))) {
                                v3_0++;
                            } else {
                                String v5_2 = ((String) v2_25.get(v3_0));
                                this.selected = v5_2;
                                return v5_2;
                            }
                        }
                        int v3_3 = ((String) this.protocols.get(0));
                        this.selected = v3_3;
                        return v3_3;
                    }
                } else {
                    return this.protocols;
                }
            } else {
                this.unsupported = 1;
                return 0;
            }
        } else {
            return Boolean.valueOf(1);
        }
    }

Method okhttp3.internal.platform.AndroidPlatform$CloseGuard.warnIfOpen() calling method java.lang.reflect.Method.invoke()


    boolean warnIfOpen(Object p4)
    {
        int v0 = 0;
        if (p4 != null) {
            try {
                Object[] v2_1 = new Object[0];
                this.warnIfOpenMethod.invoke(p4, v2_1);
                v0 = 1;
            } catch (Exception v1) {
            }
        }
        return v0;
    }

Method okhttp3.internal.platform.AndroidPlatform$CloseGuard.createAndOpen() calling method java.lang.reflect.Method.invoke()


    Object createAndOpen(String p6)
    {
        if (this.getMethod != null) {
            try {
                reflect.Method v3_0 = new Object[0];
                Exception v0_2 = this.getMethod.invoke(0, v3_0);
                reflect.Method v3_1 = this.openMethod;
                Object[] v4_0 = new Object[1];
                v4_0[0] = p6;
                v3_1.invoke(v0_2, v4_0);
                return v0_2;
            } catch (Exception v0) {
            }
        }
        return 0;
    }

Method okhttp3.internal.connection.RouteException.addSuppressedIfPossible() calling method java.lang.reflect.Method.invoke()


    private void addSuppressedIfPossible(java.io.IOException p4, java.io.IOException p5)
    {
        if (okhttp3.internal.connection.RouteException.addSuppressedExceptionMethod != null) {
            try {
                Object[] v1_1 = new Object[1];
                v1_1[0] = p5;
                okhttp3.internal.connection.RouteException.addSuppressedExceptionMethod.invoke(p4, v1_1);
            } catch (reflect.InvocationTargetException v0) {
            }
        }
        return;
    }

Method net.minidev.asm.DynamicClassLoader.defineClass() calling method java.lang.reflect.Method.invoke()


    Class defineClass(String p7, byte[] p8)
    {
        try {
            int v1_2 = ClassLoader.getDeclaredMethod("defineClass", net.minidev.asm.DynamicClassLoader.DEF_CLASS_SIG);
            v1_2.setAccessible(1);
            ClassLoader v3_1 = this.getParent();
            Object[] v4_1 = new Object[4];
            v4_1[0] = p7;
            v4_1[1] = p8;
            v4_1[2] = Integer.valueOf(0);
            v4_1[3] = Integer.valueOf(p8.length);
            return ((Class) v1_2.invoke(v3_1, v4_1));
        } catch (int v1) {
            return this.defineClass(p7, p8, 0, p8.length);
        }
    }

Method kotlinx.coroutines.internal.ConcurrentKt.removeFutureOnCancel() calling method java.lang.reflect.Method.invoke()


    public static final boolean removeFutureOnCancel(java.util.concurrent.Executor p6)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p6, "executor");
        try {
            java.util.concurrent.ScheduledExecutorService v1_1;
            if ((p6 instanceof java.util.concurrent.ScheduledExecutorService)) {
                v1_1 = p6;
            } else {
                v1_1 = 0;
            }
        } catch (java.util.concurrent.ScheduledExecutorService v1) {
            return 1;
        }
        java.util.concurrent.ScheduledExecutorService v1_2 = ((java.util.concurrent.ScheduledExecutorService) v1_1);
        if (v1_2 == null) {
            return 0;
        } else {
            reflect.Method v3 = kotlinx.coroutines.internal.ConcurrentKt.REMOVE_FUTURE_ON_CANCEL;
            if (v3 == null) {
                return 0;
            } else {
                Object[] v4 = new Object[1];
                v4[0] = Boolean.valueOf(1);
                v3.invoke(v1_2, v4);
                return 1;
            }
        }
    }

Method kotlinx.coroutines.android.HandlerDispatcherKt.asHandler() calling method java.lang.reflect.Method.invoke()


    public static final android.os.Handler asHandler(android.os.Looper p9, boolean p10)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p9, "receiver$0");
        if ((p10) && (android.os.Build$VERSION.SDK_INT >= 16)) {
            if (android.os.Build$VERSION.SDK_INT < 28) {
                try {
                    String v6_0 = new Class[3];
                    v6_0[0] = android.os.Looper;
                    v6_0[1] = android.os.Handler$Callback;
                    v6_0[2] = Boolean.TYPE;
                    NoSuchMethodException v1_1 = android.os.Handler.getDeclaredConstructor(v6_0);
                    kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v1_1, "Handler::class.java.getD\u2026:class.javaPrimitiveType)");
                    reflect.Constructor v0_1 = v1_1;
                    NoSuchMethodException v1_2 = new Object[3];
                    v1_2[0] = p9;
                    v1_2[1] = 0;
                    v1_2[2] = Boolean.valueOf(1);
                    NoSuchMethodException v1_3 = v0_1.newInstance(v1_2);
                    kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v1_3, "constructor.newInstance(this, null, true)");
                    return ((android.os.Handler) v1_3);
                } catch (NoSuchMethodException v1) {
                    return new android.os.Handler(p9);
                }
            } else {
                int v5_1 = new Class[1];
                v5_1[0] = android.os.Looper;
                reflect.Constructor v0_4 = android.os.Handler.getDeclaredMethod("createAsync", v5_1);
                NoSuchMethodException v1_7 = new Object[1];
                v1_7[0] = p9;
                NoSuchMethodException v1_8 = v0_4.invoke(0, v1_7);
                if (v1_8 == null) {
                    throw new kotlin.TypeCastException("null cannot be cast to non-null type android.os.Handler");
                } else {
                    return ((android.os.Handler) v1_8);
                }
            }
        } else {
            return new android.os.Handler(p9);
        }
    }

Method android.support.v4.graphics.TypefaceCompatApi28Impl.createFromFamiliesWithDefault() calling method java.lang.reflect.Method.invoke()


    protected android.graphics.Typeface createFromFamiliesWithDefault(Object p8)
    {
        try {
            IllegalAccessException v0_2 = reflect.Array.newInstance(this.mFontFamily, 1);
            reflect.Array.set(v0_2, 0, p8);
            reflect.Method v3 = this.mCreateFromFamiliesWithDefault;
            Object[] v5_1 = new Object[4];
            v5_1[0] = v0_2;
            v5_1[1] = "sans-serif";
            v5_1[2] = Integer.valueOf(-1);
            v5_1[3] = Integer.valueOf(-1);
            return ((android.graphics.Typeface) v3.invoke(0, v5_1));
        } catch (IllegalAccessException v0_1) {
            throw new RuntimeException(v0_1);
        }
    }

Method android.support.transition.ViewUtilsApi22.setLeftTopRightBottom() calling method java.lang.reflect.Method.invoke()


    public void setLeftTopRightBottom(android.view.View p5, int p6, int p7, int p8, int p9)
    {
        this.fetchSetLeftTopRightBottomMethod();
        if (android.support.transition.ViewUtilsApi22.sSetLeftTopRightBottomMethod != null) {
            try {
                RuntimeException v1_3 = new Object[4];
                v1_3[0] = Integer.valueOf(p6);
                v1_3[1] = Integer.valueOf(p7);
                v1_3[2] = Integer.valueOf(p8);
                v1_3[3] = Integer.valueOf(p9);
                android.support.transition.ViewUtilsApi22.sSetLeftTopRightBottomMethod.invoke(p5, v1_3);
            } catch (reflect.InvocationTargetException v0) {
            } catch (reflect.InvocationTargetException v0_1) {
                throw new RuntimeException(v0_1.getCause());
            }
        }
        return;
    }

Method com.google.android.exoplayer2.upstream.DefaultHttpDataSource.maybeTerminateInputStream() calling method java.lang.reflect.Method.invoke()


    private static void maybeTerminateInputStream(java.net.HttpURLConnection p6, long p7)
    {
        if ((com.google.android.exoplayer2.util.Util.SDK_INT == 19) || (com.google.android.exoplayer2.util.Util.SDK_INT == 20)) {
            try {
                Exception v0_2 = p6.getInputStream();
            } catch (Exception v0) {
                return;
            }
            if (p7 != -1) {
                if (p7 <= 2048) {
                    return;
                }
            } else {
                if (v0_2.read() == -1) {
                    return;
                }
            }
            String v1_5 = v0_2.getClass().getName();
            if ((!"com.android.okhttp.internal.http.HttpTransport$ChunkedInputStream".equals(v1_5)) && (!"com.android.okhttp.internal.http.HttpTransport$FixedLengthInputStream".equals(v1_5))) {
                return;
            } else {
                int v5_0 = new Class[0];
                reflect.Method v3_1 = v0_2.getClass().getSuperclass().getDeclaredMethod("unexpectedEndOfInput", v5_0);
                v3_1.setAccessible(1);
                Object[] v4_1 = new Object[0];
                v3_1.invoke(v0_2, v4_1);
                return;
            }
        } else {
            return;
        }
    }

Method android.support.v7.widget.MenuPopupWindow.setTouchModal() calling method java.lang.reflect.Method.invoke()


    public void setTouchModal(boolean p6)
    {
        if (android.support.v7.widget.MenuPopupWindow.sSetTouchModalMethod != null) {
            try {
                String v1_1 = this.mPopup;
                String v2_2 = new Object[1];
                v2_2[0] = Boolean.valueOf(p6);
                android.support.v7.widget.MenuPopupWindow.sSetTouchModalMethod.invoke(v1_1, v2_2);
            } catch (Exception v0) {
                android.util.Log.i("MenuPopupWindow", "Could not invoke setTouchModal() on PopupWindow. Oh well.");
            }
        }
        return;
    }

Method android.support.v7.view.menu.MenuItemWrapperICS.setExclusiveCheckable() calling method java.lang.reflect.Method.invoke()


    public void setExclusiveCheckable(boolean p7)
    {
        try {
            if (this.mSetExclusiveCheckableMethod != null) {
                reflect.Method v0_3 = this.mSetExclusiveCheckableMethod;
                Object v3_0 = this.mWrappedObject;
                Object[] v2_2 = new Object[1];
                v2_2[0] = Boolean.valueOf(p7);
                v0_3.invoke(v3_0, v2_2);
            } else {
                reflect.Method v0_6 = ((android.support.v4.internal.view.SupportMenuItem) this.mWrappedObject).getClass();
                Boolean v4_1 = new Class[1];
                v4_1[0] = Boolean.TYPE;
                this.mSetExclusiveCheckableMethod = v0_6.getDeclaredMethod("setExclusiveCheckable", v4_1);
            }
        } catch (reflect.Method v0_2) {
            android.util.Log.w("MenuItemWrapper", "Error while calling setExclusiveCheckable", v0_2);
        }
        return;
    }

Method android.support.v4.media.AudioAttributesImplApi21.getLegacyStreamType() calling method java.lang.reflect.Method.invoke()


    public int getLegacyStreamType()
    {
        if (this.mLegacyStreamType == -1) {
            reflect.Method v0_1 = android.support.v4.media.AudioAttributesImplApi21.getAudioAttributesToLegacyStreamTypeMethod();
            if (v0_1 != null) {
                try {
                    String v3_8 = new Object[1];
                    v3_8[0] = this.mAudioAttributes;
                    return ((Integer) v0_1.invoke(0, v3_8)).intValue();
                } catch (reflect.InvocationTargetException v2_1) {
                    String v4_1 = new StringBuilder();
                    v4_1.append("getLegacyStreamType() failed on API: ");
                    v4_1.append(android.os.Build$VERSION.SDK_INT);
                    android.util.Log.w("AudioAttributesCompat21", v4_1.toString(), v2_1);
                    return -1;
                }
            } else {
                String v3_5 = new StringBuilder();
                v3_5.append("No AudioAttributes#toLegacyStreamType() on API: ");
                v3_5.append(android.os.Build$VERSION.SDK_INT);
                android.util.Log.w("AudioAttributesCompat21", v3_5.toString());
                return -1;
            }
        } else {
            return this.mLegacyStreamType;
        }
    }

Method android.support.v4.graphics.drawable.WrappedDrawableApi21.isProjected() calling method java.lang.reflect.Method.invoke()


    public boolean isProjected()
    {
        if ((this.mDrawable != null) && (android.support.v4.graphics.drawable.WrappedDrawableApi21.sIsProjectedDrawableMethod != null)) {
            try {
                String v3_1 = new Object[0];
                return ((Boolean) android.support.v4.graphics.drawable.WrappedDrawableApi21.sIsProjectedDrawableMethod.invoke(this.mDrawable, v3_1)).booleanValue();
            } catch (Exception v0_3) {
                android.util.Log.w("WrappedDrawableApi21", "Error calling Drawable#isProjected() method", v0_3);
            }
        }
        return 0;
    }

Method android.support.v4.graphics.drawable.IconCompat.getUri() calling method java.lang.reflect.Method.invoke()


    private static android.net.Uri getUri(android.graphics.drawable.Icon p5)
    {
        if (android.os.Build$VERSION.SDK_INT < 28) {
            try {
                Class[] v4 = new Class[0];
                String v2_0 = new Object[0];
                return ((android.net.Uri) p5.getClass().getMethod("getUri", v4).invoke(p5, v2_0));
            } catch (NoSuchMethodException v1_6) {
                android.util.Log.e("IconCompat", "Unable to get icon uri", v1_6);
                return 0;
            } catch (NoSuchMethodException v1_5) {
                android.util.Log.e("IconCompat", "Unable to get icon uri", v1_5);
                return 0;
            } catch (NoSuchMethodException v1_4) {
                android.util.Log.e("IconCompat", "Unable to get icon uri", v1_4);
                return 0;
            }
        } else {
            return p5.getUri();
        }
    }

Method android.support.v4.graphics.drawable.IconCompat.getType() calling method java.lang.reflect.Method.invoke()


    private static int getType(android.graphics.drawable.Icon p5)
    {
        if (android.os.Build$VERSION.SDK_INT < 28) {
            try {
                String v4_3 = new Class[0];
                String v2_0 = new Object[0];
                return ((Integer) p5.getClass().getMethod("getType", v4_3).invoke(p5, v2_0)).intValue();
            } catch (NoSuchMethodException v1_7) {
                String v3_7 = new StringBuilder();
                v3_7.append("Unable to get icon type ");
                v3_7.append(p5);
                android.util.Log.e("IconCompat", v3_7.toString(), v1_7);
                return -1;
            } catch (NoSuchMethodException v1_6) {
                String v3_4 = new StringBuilder();
                v3_4.append("Unable to get icon type ");
                v3_4.append(p5);
                android.util.Log.e("IconCompat", v3_4.toString(), v1_6);
                return -1;
            } catch (NoSuchMethodException v1_5) {
                String v3_1 = new StringBuilder();
                v3_1.append("Unable to get icon type ");
                v3_1.append(p5);
                android.util.Log.e("IconCompat", v3_1.toString(), v1_5);
                return -1;
            }
        } else {
            return p5.getType();
        }
    }

Method android.support.v4.graphics.drawable.IconCompat.getResPackage() calling method java.lang.reflect.Method.invoke()


    private static String getResPackage(android.graphics.drawable.Icon p5)
    {
        if (android.os.Build$VERSION.SDK_INT < 28) {
            try {
                Class[] v4 = new Class[0];
                String v2_0 = new Object[0];
                return ((String) p5.getClass().getMethod("getResPackage", v4).invoke(p5, v2_0));
            } catch (NoSuchMethodException v1_6) {
                android.util.Log.e("IconCompat", "Unable to get icon package", v1_6);
                return 0;
            } catch (NoSuchMethodException v1_5) {
                android.util.Log.e("IconCompat", "Unable to get icon package", v1_5);
                return 0;
            } catch (NoSuchMethodException v1_4) {
                android.util.Log.e("IconCompat", "Unable to get icon package", v1_4);
                return 0;
            }
        } else {
            return p5.getResPackage();
        }
    }

Method android.support.v4.graphics.drawable.IconCompat.getResId() calling method java.lang.reflect.Method.invoke()


    private static int getResId(android.graphics.drawable.Icon p4)
    {
        if (android.os.Build$VERSION.SDK_INT < 28) {
            try {
                String v3_3 = new Class[0];
                String v2_0 = new Object[0];
                return ((Integer) p4.getClass().getMethod("getResId", v3_3).invoke(p4, v2_0)).intValue();
            } catch (NoSuchMethodException v1_6) {
                android.util.Log.e("IconCompat", "Unable to get icon resource", v1_6);
                return 0;
            } catch (NoSuchMethodException v1_5) {
                android.util.Log.e("IconCompat", "Unable to get icon resource", v1_5);
                return 0;
            } catch (NoSuchMethodException v1_4) {
                android.util.Log.e("IconCompat", "Unable to get icon resource", v1_4);
                return 0;
            }
        } else {
            return p4.getResId();
        }
    }

Method android.support.v4.graphics.TypefaceCompatApi26Impl.createFromFamiliesWithDefault() calling method java.lang.reflect.Method.invoke()


    protected android.graphics.Typeface createFromFamiliesWithDefault(Object p8)
    {
        try {
            IllegalAccessException v0_2 = reflect.Array.newInstance(this.mFontFamily, 1);
            reflect.Array.set(v0_2, 0, p8);
            reflect.Method v3 = this.mCreateFromFamiliesWithDefault;
            Object[] v5_1 = new Object[3];
            v5_1[0] = v0_2;
            v5_1[1] = Integer.valueOf(-1);
            v5_1[2] = Integer.valueOf(-1);
            return ((android.graphics.Typeface) v3.invoke(0, v5_1));
        } catch (IllegalAccessException v0_1) {
            throw new RuntimeException(v0_1);
        }
    }

Method android.support.v4.graphics.TypefaceCompatApi26Impl.freeze() calling method java.lang.reflect.Method.invoke()


    private boolean freeze(Object p3)
    {
        try {
            RuntimeException v1_3 = new Object[0];
            return ((Boolean) this.mFreeze.invoke(p3, v1_3)).booleanValue();
        } catch (IllegalAccessException v0_3) {
            throw new RuntimeException(v0_3);
        }
    }

Method android.support.v4.graphics.TypefaceCompatApi26Impl.addFontFromBuffer() calling method java.lang.reflect.Method.invoke()


    private boolean addFontFromBuffer(Object p5, java.nio.ByteBuffer p6, int p7, int p8, int p9)
    {
        try {
            IllegalAccessException v0_0 = this.mAddFontFromBuffer;
            RuntimeException v1_1 = new Object[5];
            v1_1[0] = p6;
            v1_1[1] = Integer.valueOf(p7);
            v1_1[2] = 0;
            v1_1[3] = Integer.valueOf(p8);
            v1_1[4] = Integer.valueOf(p9);
            return ((Boolean) v0_0.invoke(p5, v1_1)).booleanValue();
        } catch (IllegalAccessException v0_3) {
            throw new RuntimeException(v0_3);
        }
    }

Method android.support.v4.graphics.TypefaceCompatApi26Impl.addFontFromAssetManager() calling method java.lang.reflect.Method.invoke()


    private boolean addFontFromAssetManager(android.content.Context p6, Object p7, String p8, int p9, int p10, int p11, android.graphics.fonts.FontVariationAxis[] p12)
    {
        try {
            IllegalAccessException v0_0 = this.mAddFontFromAssetManager;
            RuntimeException v1_1 = new Object[8];
            v1_1[0] = p6.getAssets();
            v1_1[1] = p8;
            v1_1[2] = Integer.valueOf(0);
            v1_1[3] = Boolean.valueOf(0);
            v1_1[4] = Integer.valueOf(p9);
            v1_1[5] = Integer.valueOf(p10);
            v1_1[6] = Integer.valueOf(p11);
            v1_1[7] = p12;
            return ((Boolean) v0_0.invoke(p7, v1_1)).booleanValue();
        } catch (IllegalAccessException v0_3) {
            throw new RuntimeException(v0_3);
        }
    }

Method android.support.v4.graphics.TypefaceCompatApi26Impl.abortCreation() calling method java.lang.reflect.Method.invoke()


    private void abortCreation(Object p3)
    {
        try {
            RuntimeException v1_1 = new Object[0];
            this.mAbortCreation.invoke(p3, v1_1);
            return;
        } catch (IllegalAccessException v0_1) {
            throw new RuntimeException(v0_1);
        }
    }

Method android.support.transition.ViewUtilsApi21.transformMatrixToLocal() calling method java.lang.reflect.Method.invoke()


    public void transformMatrixToLocal(android.view.View p4, android.graphics.Matrix p5)
    {
        this.fetchTransformMatrixToLocalMethod();
        if (android.support.transition.ViewUtilsApi21.sTransformMatrixToLocalMethod != null) {
            try {
                RuntimeException v1_3 = new Object[1];
                v1_3[0] = p5;
                android.support.transition.ViewUtilsApi21.sTransformMatrixToLocalMethod.invoke(p4, v1_3);
            } catch (reflect.InvocationTargetException v0) {
            } catch (reflect.InvocationTargetException v0_2) {
                throw new RuntimeException(v0_2.getCause());
            }
        }
        return;
    }

Method android.support.transition.ViewUtilsApi21.transformMatrixToGlobal() calling method java.lang.reflect.Method.invoke()


    public void transformMatrixToGlobal(android.view.View p4, android.graphics.Matrix p5)
    {
        this.fetchTransformMatrixToGlobalMethod();
        if (android.support.transition.ViewUtilsApi21.sTransformMatrixToGlobalMethod != null) {
            try {
                RuntimeException v1_3 = new Object[1];
                v1_3[0] = p5;
                android.support.transition.ViewUtilsApi21.sTransformMatrixToGlobalMethod.invoke(p4, v1_3);
            } catch (reflect.InvocationTargetException v0) {
            } catch (reflect.InvocationTargetException v0_2) {
                throw new RuntimeException(v0_2.getCause());
            }
        }
        return;
    }

Method android.support.transition.ViewUtilsApi21.setAnimationMatrix() calling method java.lang.reflect.Method.invoke()


    public void setAnimationMatrix(android.view.View p4, android.graphics.Matrix p5)
    {
        this.fetchSetAnimationMatrix();
        if (android.support.transition.ViewUtilsApi21.sSetAnimationMatrixMethod != null) {
            try {
                RuntimeException v1_3 = new Object[1];
                v1_3[0] = p5;
                android.support.transition.ViewUtilsApi21.sSetAnimationMatrixMethod.invoke(p4, v1_3);
            } catch (IllegalAccessException v0) {
            } catch (IllegalAccessException v0_2) {
                throw new RuntimeException(v0_2.getCause());
            }
        }
        return;
    }

Method android.support.design.chip.Chip.handleAccessibilityExit() calling method java.lang.reflect.Method.invoke()


    private boolean handleAccessibilityExit(android.view.MotionEvent p10)
    {
        if (p10.getAction() == 10) {
            try {
                NoSuchFieldException v0_6 = android.support.v4.widget.ExploreByTouchHelper.getDeclaredField("mHoveredVirtualViewId");
                v0_6.setAccessible(1);
            } catch (NoSuchFieldException v0_4) {
                android.util.Log.e("Chip", "Unable to send Accessibility Exit event", v0_4);
            } catch (NoSuchFieldException v0_3) {
                android.util.Log.e("Chip", "Unable to send Accessibility Exit event", v0_3);
            } catch (NoSuchFieldException v0_2) {
                android.util.Log.e("Chip", "Unable to send Accessibility Exit event", v0_2);
            } catch (NoSuchFieldException v0_1) {
                android.util.Log.e("Chip", "Unable to send Accessibility Exit event", v0_1);
            }
            if (((Integer) v0_6.get(this.touchHelper)).intValue() == -2147483648) {
            } else {
                Object[] v7_0 = new Class[1];
                v7_0[0] = Integer.TYPE;
                reflect.Method v5_1 = android.support.v4.widget.ExploreByTouchHelper.getDeclaredMethod("updateHoveredVirtualView", v7_0);
                v5_1.setAccessible(1);
                android.support.design.chip.Chip$ChipTouchHelper v6_1 = this.touchHelper;
                Object[] v7_1 = new Object[1];
                v7_1[0] = Integer.valueOf(-2147483648);
                v5_1.invoke(v6_1, v7_1);
                return 1;
            }
        }
        return 0;
    }

Method io.fabric.sdk.android.services.common.AdvertisingInfoReflectionStrategy.isGooglePlayServiceAvailable() calling method java.lang.reflect.Method.invoke()


    boolean isGooglePlayServiceAvailable(android.content.Context p7)
    {
        int v0 = 0;
        try {
            Exception v1_2 = Class.forName("com.google.android.gms.common.GooglePlayServicesUtil");
            int v4_2 = new Class[1];
            v4_2[0] = android.content.Context;
            Exception v1_1 = v1_2.getMethod("isGooglePlayServicesAvailable", v4_2);
            int v4_0 = new Object[1];
            v4_0[0] = p7;
        } catch (Exception v1) {
            return 0;
        }
        if (((Integer) v1_1.invoke(0, v4_0)).intValue() == 0) {
            v0 = 1;
        }
        return v0;
    }

Method io.fabric.sdk.android.services.common.AdvertisingInfoReflectionStrategy.isLimitAdTrackingEnabled() calling method java.lang.reflect.Method.invoke()


    private boolean isLimitAdTrackingEnabled()
    {
        try {
            String v3_2 = new Class[0];
            String v3_0 = new Object[0];
            return ((Boolean) Class.forName("com.google.android.gms.ads.identifier.AdvertisingIdClient$Info").getMethod("isLimitAdTrackingEnabled", v3_2).invoke(this.getInfo(), v3_0)).booleanValue();
        } catch (Exception v1) {
            io.fabric.sdk.android.Fabric.getLogger().w("Fabric", "Could not call isLimitAdTrackingEnabled on com.google.android.gms.ads.identifier.AdvertisingIdClient$Info");
            return 0;
        }
    }

Method io.fabric.sdk.android.services.common.AdvertisingInfoReflectionStrategy.getInfo() calling method java.lang.reflect.Method.invoke()


    private Object getInfo()
    {
        try {
            Exception v1_2 = Class.forName("com.google.android.gms.ads.identifier.AdvertisingIdClient");
            String v4_1 = new Class[1];
            v4_1[0] = android.content.Context;
            Exception v1_1 = v1_2.getMethod("getAdvertisingIdInfo", v4_1);
            io.fabric.sdk.android.Logger v2_0 = new Object[1];
            v2_0[0] = this.context;
            return v1_1.invoke(0, v2_0);
        } catch (Exception v1) {
            io.fabric.sdk.android.Fabric.getLogger().w("Fabric", "Could not call getAdvertisingIdInfo on com.google.android.gms.ads.identifier.AdvertisingIdClient");
            return 0;
        }
    }

Method io.fabric.sdk.android.services.common.AdvertisingInfoReflectionStrategy.getAdvertisingId() calling method java.lang.reflect.Method.invoke()


    private String getAdvertisingId()
    {
        try {
            String v3_1 = new Class[0];
            String v2_0 = new Object[0];
            return ((String) Class.forName("com.google.android.gms.ads.identifier.AdvertisingIdClient$Info").getMethod("getId", v3_1).invoke(this.getInfo(), v2_0));
        } catch (int v0) {
            io.fabric.sdk.android.Fabric.getLogger().w("Fabric", "Could not call getId on com.google.android.gms.ads.identifier.AdvertisingIdClient$Info");
            return 0;
        }
    }

Method com.squareup.okhttp.internal.Platform$JdkWithJettyBootPlatform.getSelectedProtocol() calling method java.lang.reflect.Method.invoke()


    public String getSelectedProtocol(javax.net.ssl.SSLSocket p6)
    {
        try {
            reflect.InvocationTargetException v0_0 = this.getMethod;
            java.util.logging.Logger v1_4 = new Object[1];
            v1_4[0] = p6;
            String v2_0 = 0;
            reflect.InvocationTargetException v0_1 = ((com.squareup.okhttp.internal.Platform$JettyNegoProvider) reflect.Proxy.getInvocationHandler(v0_0.invoke(0, v1_4)));
        } catch (reflect.InvocationTargetException v0) {
            throw new AssertionError();
        }
        if ((com.squareup.okhttp.internal.Platform$JettyNegoProvider.access$000(v0_1)) || (com.squareup.okhttp.internal.Platform$JettyNegoProvider.access$100(v0_1) != null)) {
            if (!com.squareup.okhttp.internal.Platform$JettyNegoProvider.access$000(v0_1)) {
                v2_0 = com.squareup.okhttp.internal.Platform$JettyNegoProvider.access$100(v0_1);
            } else {
            }
            return v2_0;
        } else {
            com.squareup.okhttp.internal.Internal.logger.log(java.util.logging.Level.INFO, "ALPN callback dropped: SPDY and HTTP/2 are disabled. Is alpn-boot on the boot class path?");
            return 0;
        }
    }

Method com.squareup.okhttp.internal.Platform$JdkWithJettyBootPlatform.configureTlsExtensions() calling method java.lang.reflect.Method.invoke()


    public void configureTlsExtensions(javax.net.ssl.SSLSocket p8, String p9, java.util.List p10)
    {
        java.util.ArrayList v0_1 = new java.util.ArrayList(p10.size());
        int v1_4 = 0;
        AssertionError v2_4 = p10.size();
        while (v1_4 < v2_4) {
            reflect.Method v3_3 = ((com.squareup.okhttp.Protocol) p10.get(v1_4));
            if (v3_3 != com.squareup.okhttp.Protocol.HTTP_1_0) {
                v0_1.add(v3_3.toString());
            }
            v1_4++;
        }
        try {
            int v1_0 = com.squareup.okhttp.internal.Platform.getClassLoader();
            reflect.Method v3_0 = new Class[2];
            v3_0[0] = this.clientProviderClass;
            v3_0[1] = this.serverProviderClass;
            int v1_2 = reflect.Proxy.newProxyInstance(v1_0, v3_0, new com.squareup.okhttp.internal.Platform$JettyNegoProvider(v0_1));
            reflect.Method v3_1 = this.putMethod;
            AssertionError v2_1 = new Object[2];
            v2_1[0] = p8;
            v2_1[1] = v1_2;
            v3_1.invoke(0, v2_1);
            return;
        } catch (int v1_3) {
            throw new AssertionError(v1_3);
        }
    }

Method com.squareup.okhttp.internal.Platform$JdkWithJettyBootPlatform.afterHandshake() calling method java.lang.reflect.Method.invoke()


    public void afterHandshake(javax.net.ssl.SSLSocket p5)
    {
        try {
            IllegalAccessException v0 = this.removeMethod;
            Object[] v2_1 = new Object[1];
            v2_1[0] = p5;
            v0.invoke(0, v2_1);
            return;
        } catch (IllegalAccessException v0) {
            throw new AssertionError();
        }
    }

Method com.squareup.okhttp.internal.Platform$Android.untagSocket() calling method java.lang.reflect.Method.invoke()


    public void untagSocket(java.net.Socket p5)
    {
        if (this.trafficStatsUntagSocket != null) {
            try {
                reflect.InvocationTargetException v0_3 = this.trafficStatsUntagSocket;
                Throwable v2_2 = new Object[1];
                v2_2[0] = p5;
                v0_3.invoke(0, v2_2);
                return;
            } catch (reflect.InvocationTargetException v0_2) {
                throw new RuntimeException(v0_2);
            } catch (reflect.InvocationTargetException v0_1) {
                throw new RuntimeException(v0_1.getCause());
            }
        } else {
            return;
        }
    }

Method com.squareup.okhttp.internal.Platform$Android.tagSocket() calling method java.lang.reflect.Method.invoke()


    public void tagSocket(java.net.Socket p5)
    {
        if (this.trafficStatsTagSocket != null) {
            try {
                reflect.InvocationTargetException v0_3 = this.trafficStatsTagSocket;
                Throwable v2_2 = new Object[1];
                v2_2[0] = p5;
                v0_3.invoke(0, v2_2);
                return;
            } catch (reflect.InvocationTargetException v0_2) {
                throw new RuntimeException(v0_2);
            } catch (reflect.InvocationTargetException v0_1) {
                throw new RuntimeException(v0_1.getCause());
            }
        } else {
            return;
        }
    }

Method com.google.gson.internal.reflect.UnsafeReflectionAccessor.makeAccessibleWithUnsafe() calling method java.lang.reflect.Method.invoke()


    boolean makeAccessibleWithUnsafe(reflect.AccessibleObject p12)
    {
        if ((this.theUnsafe != null) && (this.overrideField != null)) {
            try {
                long v4_2 = new Class[1];
                v4_2[0] = reflect.Field;
                Exception v0_1 = com.google.gson.internal.reflect.UnsafeReflectionAccessor.unsafeClass.getMethod("objectFieldOffset", v4_2);
                reflect.Method v2_0 = this.theUnsafe;
                long v4_0 = new Object[1];
                v4_0[0] = this.overrideField;
                long v4_1 = ((Long) v0_1.invoke(v2_0, v4_0)).longValue();
                Boolean v8_0 = new Class[3];
                v8_0[0] = Object;
                v8_0[1] = Long.TYPE;
                v8_0[2] = Boolean.TYPE;
                reflect.Method v2_4 = com.google.gson.internal.reflect.UnsafeReflectionAccessor.unsafeClass.getMethod("putBoolean", v8_0);
                Object v6_1 = this.theUnsafe;
                Object[] v7_1 = new Object[3];
                v7_1[0] = p12;
                v7_1[1] = Long.valueOf(v4_1);
                v7_1[2] = Boolean.valueOf(1);
                v2_4.invoke(v6_1, v7_1);
                return 1;
            } catch (Exception v0) {
            }
        }
        return 0;
    }

Method com.google.gson.internal.UnsafeAllocator$3.newInstance() calling method java.lang.reflect.Method.invoke()


    public Object newInstance(Class p5)
    {
        com.google.gson.internal.UnsafeAllocator$3.assertInstantiable(p5);
        Object v0_0 = this.val$newInstance;
        Object[] v1_1 = new Object[2];
        v1_1[0] = p5;
        v1_1[1] = Object;
        return v0_0.invoke(0, v1_1);
    }

Method com.google.gson.internal.UnsafeAllocator$2.newInstance() calling method java.lang.reflect.Method.invoke()


    public Object newInstance(Class p5)
    {
        com.google.gson.internal.UnsafeAllocator$2.assertInstantiable(p5);
        Object v0_0 = this.val$newInstance;
        Object[] v1_1 = new Object[2];
        v1_1[0] = p5;
        v1_1[1] = Integer.valueOf(this.val$constructorId);
        return v0_0.invoke(0, v1_1);
    }

Method com.google.gson.internal.UnsafeAllocator$1.newInstance() calling method java.lang.reflect.Method.invoke()


    public Object newInstance(Class p5)
    {
        com.google.gson.internal.UnsafeAllocator$1.assertInstantiable(p5);
        Object v0_0 = this.val$allocateInstance;
        Object v1 = this.val$unsafe;
        Object[] v2_1 = new Object[1];
        v2_1[0] = p5;
        return v0_0.invoke(v1, v2_1);
    }

Method com.crashlytics.android.core.DefaultAppMeasurementEventListenerRegistrar.invoke() calling method java.lang.reflect.Method.invoke()


    private boolean invoke(Class p8, Object p9, String p10)
    {
        Class v0_1 = this.getClass("com.google.android.gms.measurement.AppMeasurement$OnEventListener");
        try {
            io.fabric.sdk.android.Logger v3_3 = new Class[1];
            v3_3[0] = v0_1;
            io.fabric.sdk.android.Logger v3_4 = p8.getDeclaredMethod(p10, v3_3);
            String v4_3 = new Object[1];
            v4_3[0] = this.onEventListenerProxy(v0_1);
            v3_4.invoke(p9, v4_3);
            return 1;
        } catch (IllegalAccessException v1_3) {
            io.fabric.sdk.android.Logger v3_2 = io.fabric.sdk.android.Fabric.getLogger();
            String v5_8 = new StringBuilder();
            v5_8.append("Expected method missing: ");
            v5_8.append(p10);
            v3_2.w("CrashlyticsCore", v5_8.toString(), v1_3);
            return 0;
        } catch (IllegalAccessException v1_1) {
            io.fabric.sdk.android.Logger v3_1 = io.fabric.sdk.android.Fabric.getLogger();
            String v5_5 = new StringBuilder();
            v5_5.append("Cannot invoke method: ");
            v5_5.append(p10);
            v3_1.w("CrashlyticsCore", v5_5.toString(), v1_1);
            return 0;
        } catch (IllegalAccessException v1_0) {
            io.fabric.sdk.android.Logger v3_0 = io.fabric.sdk.android.Fabric.getLogger();
            String v5_2 = new StringBuilder();
            v5_2.append("Cannot access method: ");
            v5_2.append(p10);
            v3_0.w("CrashlyticsCore", v5_2.toString(), v1_0);
            return 0;
        }
    }

Method com.crashlytics.android.core.DefaultAppMeasurementEventListenerRegistrar.getInstance() calling method java.lang.reflect.Method.invoke()


    private Object getInstance(Class p6)
    {
        try {
            android.content.Context v2_1 = new Class[1];
            v2_1[0] = android.content.Context;
            Exception v0_1 = p6.getDeclaredMethod("getInstance", v2_1);
            int v1_3 = new Object[1];
            v1_3[0] = this.crashlyticsCore.getContext();
            return v0_1.invoke(p6, v1_3);
        } catch (Exception v0) {
            return 0;
        }
    }

Method com.crashlytics.android.answers.AppMeasurementEventLogger.logEvent() calling method java.lang.reflect.Method.invoke()


    public void logEvent(String p5, String p6, android.os.Bundle p7)
    {
        try {
            Exception v0 = this.logEventMethod;
            Object v1 = this.logEventInstance;
            Object[] v2_1 = new Object[3];
            v2_1[0] = p5;
            v2_1[1] = p6;
            v2_1[2] = p7;
            v0.invoke(v1, v2_1);
        } catch (Exception v0) {
        }
        return;
    }

Method com.crashlytics.android.answers.AppMeasurementEventLogger.getInstance() calling method java.lang.reflect.Method.invoke()


    private static Object getInstance(android.content.Context p5, Class p6)
    {
        try {
            Class[] v2 = new Class[1];
            v2[0] = android.content.Context;
            Exception v0_1 = p6.getDeclaredMethod("getInstance", v2);
            int v1_3 = new Object[1];
            v1_3[0] = p5;
            return v0_1.invoke(p6, v1_3);
        } catch (Exception v0) {
            return 0;
        }
    }

Method android.support.v7.widget.ListPopupWindow.show() calling method java.lang.reflect.Method.invoke()


    public void show()
    {
        int v0 = this.buildDropDown();
        boolean v1 = this.isInputMethodNotNeeded();
        android.support.v4.widget.PopupWindowCompat.setWindowLayoutType(this.mPopup, this.mDropDownWindowLayoutType);
        android.os.Handler v3_0 = 1;
        if (!this.mPopup.isShowing()) {
            int v2_3;
            if (this.mDropDownWidth != -1) {
                if (this.mDropDownWidth != -2) {
                    v2_3 = this.mDropDownWidth;
                } else {
                    v2_3 = this.getAnchorView().getWidth();
                }
            } else {
                v2_3 = -1;
            }
            int v4_2;
            if (this.mDropDownHeight != -1) {
                if (this.mDropDownHeight != -2) {
                    v4_2 = this.mDropDownHeight;
                } else {
                    v4_2 = v0;
                }
            } else {
                v4_2 = -1;
            }
            int v8_9;
            this.mPopup.setWidth(v2_3);
            this.mPopup.setHeight(v4_2);
            this.setPopupClipToScreenEnabled(1);
            if ((this.mForceIgnoreOutsideTouch) || (this.mDropDownAlwaysVisible)) {
                v8_9 = 0;
            } else {
                v8_9 = 1;
            }
            this.mPopup.setOutsideTouchable(v8_9);
            this.mPopup.setTouchInterceptor(this.mTouchInterceptor);
            if (this.mOverlapAnchorSet) {
                android.support.v4.widget.PopupWindowCompat.setOverlapAnchor(this.mPopup, this.mOverlapAnchor);
            }
            if (android.support.v7.widget.ListPopupWindow.sSetEpicenterBoundsMethod != null) {
                try {
                    int v8_12 = this.mPopup;
                    android.os.Handler v3_2 = new Object[1];
                    v3_2[0] = this.mEpicenterBounds;
                    android.support.v7.widget.ListPopupWindow.sSetEpicenterBoundsMethod.invoke(v8_12, v3_2);
                } catch (android.os.Handler v3_3) {
                    android.util.Log.e("ListPopupWindow", "Could not invoke setEpicenterBounds on PopupWindow", v3_3);
                }
            }
            android.support.v4.widget.PopupWindowCompat.showAsDropDown(this.mPopup, this.getAnchorView(), this.mDropDownHorizontalOffset, this.mDropDownVerticalOffset, this.mDropDownGravity);
            this.mDropDownList.setSelection(-1);
            if ((!this.mModal) || (this.mDropDownList.isInTouchMode())) {
                this.clearListSelection();
            }
            if (!this.mModal) {
                this.mHandler.post(this.mHideSelector);
            }
        } else {
            if (android.support.v4.view.ViewCompat.isAttachedToWindow(this.getAnchorView())) {
                int v2_0;
                if (this.mDropDownWidth != -1) {
                    if (this.mDropDownWidth != -2) {
                        v2_0 = this.mDropDownWidth;
                    } else {
                        v2_0 = this.getAnchorView().getWidth();
                    }
                } else {
                    v2_0 = -1;
                }
                int v4_0;
                if (this.mDropDownHeight != -1) {
                    if (this.mDropDownHeight != -2) {
                        v4_0 = this.mDropDownHeight;
                    } else {
                        v4_0 = v0;
                    }
                } else {
                    if (!v1) {
                        v4_0 = -1;
                    } else {
                        v4_0 = v0;
                    }
                    if (!v1) {
                        int v8_1;
                        if (this.mDropDownWidth != -1) {
                            v8_1 = 0;
                        } else {
                            v8_1 = -1;
                        }
                        this.mPopup.setWidth(v8_1);
                        this.mPopup.setHeight(-1);
                    } else {
                        int v8_3;
                        if (this.mDropDownWidth != -1) {
                            v8_3 = 0;
                        } else {
                            v8_3 = -1;
                        }
                        this.mPopup.setWidth(v8_3);
                        this.mPopup.setHeight(0);
                    }
                }
                if ((this.mForceIgnoreOutsideTouch) || (this.mDropDownAlwaysVisible)) {
                    v3_0 = 0;
                }
                int v12;
                this.mPopup.setOutsideTouchable(v3_0);
                int v8_6 = this.mPopup;
                int v9_0 = this.getAnchorView();
                if (v2_0 >= 0) {
                    v12 = v2_0;
                } else {
                    v12 = -1;
                }
                int v13;
                if (v4_0 >= 0) {
                    v13 = v4_0;
                } else {
                    v13 = -1;
                }
                v8_6.update(v9_0, this.mDropDownHorizontalOffset, this.mDropDownVerticalOffset, v12, v13);
            } else {
                return;
            }
        }
        return;
    }

Method android.support.v7.widget.ListPopupWindow.setPopupClipToScreenEnabled() calling method java.lang.reflect.Method.invoke()


    private void setPopupClipToScreenEnabled(boolean p6)
    {
        if (android.support.v7.widget.ListPopupWindow.sClipToWindowEnabledMethod != null) {
            try {
                String v1_1 = this.mPopup;
                String v2_2 = new Object[1];
                v2_2[0] = Boolean.valueOf(p6);
                android.support.v7.widget.ListPopupWindow.sClipToWindowEnabledMethod.invoke(v1_1, v2_2);
            } catch (Exception v0) {
                android.util.Log.i("ListPopupWindow", "Could not call setClipToScreenEnabled() on PopupWindow. Oh well.");
            }
        }
        return;
    }

Method android.support.v7.widget.ListPopupWindow.getMaxAvailableHeight() calling method java.lang.reflect.Method.invoke()


    private int getMaxAvailableHeight(android.view.View p6, int p7, boolean p8)
    {
        if (android.support.v7.widget.ListPopupWindow.sGetMaxAvailableHeightMethod != null) {
            try {
                String v1_1 = this.mPopup;
                String v2_2 = new Object[3];
                v2_2[0] = p6;
                v2_2[1] = Integer.valueOf(p7);
                v2_2[2] = Boolean.valueOf(p8);
                return ((Integer) android.support.v7.widget.ListPopupWindow.sGetMaxAvailableHeightMethod.invoke(v1_1, v2_2)).intValue();
            } catch (Exception v0) {
                android.util.Log.i("ListPopupWindow", "Could not call getMaxAvailableHeightMethod(View, int, boolean) on PopupWindow. Using the public version.");
            }
        }
        return this.mPopup.getMaxAvailableHeight(p6, p7);
    }

Method android.support.v4.graphics.TypefaceCompatApi24Impl.createFromFamiliesWithDefault() calling method java.lang.reflect.Method.invoke()


    private static android.graphics.Typeface createFromFamiliesWithDefault(Object p5)
    {
        try {
            IllegalAccessException v0_2 = reflect.Array.newInstance(android.support.v4.graphics.TypefaceCompatApi24Impl.sFontFamily, 1);
            reflect.Array.set(v0_2, 0, p5);
            RuntimeException v1_5 = new Object[1];
            v1_5[0] = v0_2;
            return ((android.graphics.Typeface) android.support.v4.graphics.TypefaceCompatApi24Impl.sCreateFromFamiliesWithDefault.invoke(0, v1_5));
        } catch (IllegalAccessException v0_1) {
            throw new RuntimeException(v0_1);
        }
    }

Method android.support.v4.graphics.TypefaceCompatApi24Impl.addFontWeightStyle() calling method java.lang.reflect.Method.invoke()


    private static boolean addFontWeightStyle(Object p4, java.nio.ByteBuffer p5, int p6, int p7, boolean p8)
    {
        try {
            RuntimeException v1_1 = new Object[5];
            v1_1[0] = p5;
            v1_1[1] = Integer.valueOf(p6);
            v1_1[2] = 0;
            v1_1[3] = Integer.valueOf(p7);
            v1_1[4] = Boolean.valueOf(p8);
            return ((Boolean) android.support.v4.graphics.TypefaceCompatApi24Impl.sAddFontWeightStyle.invoke(p4, v1_1)).booleanValue();
        } catch (IllegalAccessException v0_3) {
            throw new RuntimeException(v0_3);
        }
    }

Method android.support.v4.app.ActionBarDrawerToggle.setActionBarUpIndicator() calling method java.lang.reflect.Method.invoke()


    private void setActionBarUpIndicator(android.graphics.drawable.Drawable p6, int p7)
    {
        if (this.mActivityImpl == null) {
            if (android.os.Build$VERSION.SDK_INT < 18) {
                if (this.mSetIndicatorInfo == null) {
                    this.mSetIndicatorInfo = new android.support.v4.app.ActionBarDrawerToggle$SetIndicatorInfo(this.mActivity);
                }
                if (this.mSetIndicatorInfo.mSetHomeAsUpIndicator == null) {
                    if (this.mSetIndicatorInfo.mUpIndicatorView == null) {
                        android.util.Log.w("ActionBarDrawerToggle", "Couldn\'t set home-as-up indicator");
                    } else {
                        this.mSetIndicatorInfo.mUpIndicatorView.setImageDrawable(p6);
                    }
                } else {
                    try {
                        String v0_10 = this.mActivity.getActionBar();
                        String v1_2 = this.mSetIndicatorInfo.mSetHomeAsUpIndicator;
                        Integer v3_0 = new Object[1];
                        v3_0[0] = p6;
                        v1_2.invoke(v0_10, v3_0);
                        String v1_5 = this.mSetIndicatorInfo.mSetHomeActionContentDescription;
                        String v2_1 = new Object[1];
                        v2_1[0] = Integer.valueOf(p7);
                        v1_5.invoke(v0_10, v2_1);
                    } catch (String v0_11) {
                        android.util.Log.w("ActionBarDrawerToggle", "Couldn\'t set home-as-up indicator via JB-MR2 API", v0_11);
                    }
                }
            } else {
                String v0_13 = this.mActivity.getActionBar();
                if (v0_13 != null) {
                    v0_13.setHomeAsUpIndicator(p6);
                    v0_13.setHomeActionContentDescription(p7);
                }
            }
            return;
        } else {
            this.mActivityImpl.setActionBarUpIndicator(p6, p7);
            return;
        }
    }

Method android.support.v4.app.ActionBarDrawerToggle.setActionBarDescription() calling method java.lang.reflect.Method.invoke()


    private void setActionBarDescription(int p6)
    {
        if (this.mActivityImpl == null) {
            if (android.os.Build$VERSION.SDK_INT < 18) {
                if (this.mSetIndicatorInfo == null) {
                    this.mSetIndicatorInfo = new android.support.v4.app.ActionBarDrawerToggle$SetIndicatorInfo(this.mActivity);
                }
                if (this.mSetIndicatorInfo.mSetHomeAsUpIndicator != null) {
                    try {
                        Exception v0_4 = this.mActivity.getActionBar();
                        String v1_1 = this.mSetIndicatorInfo.mSetHomeActionContentDescription;
                        String v2_1 = new Object[1];
                        v2_1[0] = Integer.valueOf(p6);
                        v1_1.invoke(v0_4, v2_1);
                        v0_4.setSubtitle(v0_4.getSubtitle());
                    } catch (Exception v0_6) {
                        android.util.Log.w("ActionBarDrawerToggle", "Couldn\'t set content description via JB-MR2 API", v0_6);
                    }
                }
            } else {
                Exception v0_8 = this.mActivity.getActionBar();
                if (v0_8 != null) {
                    v0_8.setHomeActionContentDescription(p6);
                }
            }
            return;
        } else {
            this.mActivityImpl.setActionBarDescription(p6);
            return;
        }
    }

Method android.support.transition.ViewUtilsApi19.setTransitionAlpha() calling method java.lang.reflect.Method.invoke()


    public void setTransitionAlpha(android.view.View p5, float p6)
    {
        this.fetchSetTransitionAlphaMethod();
        if (android.support.transition.ViewUtilsApi19.sSetTransitionAlphaMethod == null) {
            p5.setAlpha(p6);
        } else {
            try {
                RuntimeException v1_3 = new Object[1];
                v1_3[0] = Float.valueOf(p6);
                android.support.transition.ViewUtilsApi19.sSetTransitionAlphaMethod.invoke(p5, v1_3);
            } catch (reflect.InvocationTargetException v0) {
            } catch (reflect.InvocationTargetException v0_1) {
                throw new RuntimeException(v0_1.getCause());
            }
        }
        return;
    }

Method android.support.transition.ViewUtilsApi19.getTransitionAlpha() calling method java.lang.reflect.Method.invoke()


    public float getTransitionAlpha(android.view.View p4)
    {
        this.fetchGetTransitionAlphaMethod();
        if (android.support.transition.ViewUtilsApi19.sGetTransitionAlphaMethod != null) {
            try {
                RuntimeException v1_3 = new Object[0];
                return ((Float) android.support.transition.ViewUtilsApi19.sGetTransitionAlphaMethod.invoke(p4, v1_3)).floatValue();
            } catch (reflect.InvocationTargetException v0) {
            } catch (reflect.InvocationTargetException v0_2) {
                throw new RuntimeException(v0_2.getCause());
            }
        }
        return super.getTransitionAlpha(p4);
    }

Method android.support.transition.GhostViewApi21.removeGhost() calling method java.lang.reflect.Method.invoke()


    static void removeGhost(android.view.View p4)
    {
        android.support.transition.GhostViewApi21.fetchRemoveGhostMethod();
        if (android.support.transition.GhostViewApi21.sRemoveGhostMethod != null) {
            try {
                Throwable v2_2 = new Object[1];
                v2_2[0] = p4;
                android.support.transition.GhostViewApi21.sRemoveGhostMethod.invoke(0, v2_2);
            } catch (reflect.InvocationTargetException v0) {
            } catch (reflect.InvocationTargetException v0_1) {
                throw new RuntimeException(v0_1.getCause());
            }
        }
        return;
    }

Method android.support.transition.GhostViewApi21.addGhost() calling method java.lang.reflect.Method.invoke()


    static android.support.transition.GhostViewImpl addGhost(android.view.View p5, android.view.ViewGroup p6, android.graphics.Matrix p7)
    {
        android.support.transition.GhostViewApi21.fetchAddGhostMethod();
        if (android.support.transition.GhostViewApi21.sAddGhostMethod != null) {
            try {
                Object[] v3_1 = new Object[3];
                v3_1[0] = p5;
                v3_1[1] = p6;
                v3_1[2] = p7;
                return new android.support.transition.GhostViewApi21(((android.view.View) android.support.transition.GhostViewApi21.sAddGhostMethod.invoke(0, v3_1)));
            } catch (reflect.InvocationTargetException v0) {
            } catch (reflect.InvocationTargetException v0_2) {
                throw new RuntimeException(v0_2.getCause());
            }
        }
        return 0;
    }

Method com.squareup.okhttp.internal.http.RouteException.addSuppressedIfPossible() calling method java.lang.reflect.Method.invoke()


    private void addSuppressedIfPossible(java.io.IOException p4, java.io.IOException p5)
    {
        if (com.squareup.okhttp.internal.http.RouteException.addSuppressedExceptionMethod != null) {
            try {
                Object[] v1_1 = new Object[1];
                v1_1[0] = p5;
                com.squareup.okhttp.internal.http.RouteException.addSuppressedExceptionMethod.invoke(p4, v1_1);
            } catch (reflect.InvocationTargetException v0) {
            }
        }
        return;
    }

Method com.squareup.okhttp.internal.Platform$JettyNegoProvider.invoke() calling method java.lang.reflect.Method.invoke()


    public Object invoke(Object p9, reflect.Method p10, Object[] p11)
    {
        String v0 = p10.getName();
        Class v1 = p10.getReturnType();
        if (p11 == null) {
            p11 = com.squareup.okhttp.internal.Util.EMPTY_STRING_ARRAY;
        }
        if ((!v0.equals("supports")) || (Boolean.TYPE != v1)) {
            if ((!v0.equals("unsupported")) || (Void.TYPE != v1)) {
                if ((!v0.equals("protocols")) || (p11.length != 0)) {
                    if (((!v0.equals("selectProtocol")) && (!v0.equals("select"))) || ((String != v1) || ((p11.length != 1) || (!(p11[0] instanceof java.util.List))))) {
                        if (((!v0.equals("protocolSelected")) && (!v0.equals("selected"))) || (p11.length != 1)) {
                            return p10.invoke(this, p11);
                        } else {
                            this.selected = ((String) p11[0]);
                            return 0;
                        }
                    } else {
                        java.util.List v2_25 = ((java.util.List) p11[0]);
                        int v3_0 = 0;
                        int v4_1 = v2_25.size();
                        while (v3_0 < v4_1) {
                            if (!this.protocols.contains(v2_25.get(v3_0))) {
                                v3_0++;
                            } else {
                                String v5_2 = ((String) v2_25.get(v3_0));
                                this.selected = v5_2;
                                return v5_2;
                            }
                        }
                        int v3_3 = ((String) this.protocols.get(0));
                        this.selected = v3_3;
                        return v3_3;
                    }
                } else {
                    return this.protocols;
                }
            } else {
                this.unsupported = 1;
                return 0;
            }
        } else {
            return Boolean.valueOf(1);
        }
    }

Method com.squareup.okhttp.internal.OptionalMethod.invokeOptional() calling method java.lang.reflect.Method.invoke()


    public varargs Object invokeOptional(Object p4, Object[] p5)
    {
        reflect.Method v0_1 = this.getMethod(p4.getClass());
        if (v0_1 != null) {
            try {
                return v0_1.invoke(p4, p5);
            } catch (IllegalAccessException v2) {
                return 0;
            }
        } else {
            return 0;
        }
    }

Method com.squareup.okhttp.internal.OptionalMethod.invoke() calling method java.lang.reflect.Method.invoke()


    public varargs Object invoke(Object p6, Object[] p7)
    {
        reflect.Method v0_1 = this.getMethod(p6.getClass());
        if (v0_1 == null) {
            AssertionError v2_4 = new StringBuilder();
            v2_4.append("Method ");
            v2_4.append(this.methodName);
            v2_4.append(" not supported for object ");
            v2_4.append(p6);
            throw new AssertionError(v2_4.toString());
        } else {
            try {
                return v0_1.invoke(p6, p7);
            } catch (IllegalAccessException v1_2) {
                String v3_3 = new StringBuilder();
                v3_3.append("Unexpectedly could not call: ");
                v3_3.append(v0_1);
                AssertionError v2_2 = new AssertionError(v3_3.toString());
                v2_2.initCause(v1_2);
                throw v2_2;
            }
        }
    }

Method com.microsoft.aad.adal.PRNGFixes.applyOpenSSLFix() calling method java.lang.reflect.Method.invoke()


    private static void applyOpenSSLFix()
    {
        if ((android.os.Build$VERSION.SDK_INT >= 16) && (android.os.Build$VERSION.SDK_INT <= 18)) {
            try {
                java.io.IOException v1_12 = Class.forName("org.apache.harmony.xnet.provider.jsse.NativeCrypto");
                String v4_0 = new Class[1];
                v4_0[0] = byte[];
                java.io.IOException v1_1 = v1_12.getMethod("RAND_seed", v4_0);
                java.io.IOException v2_1 = new Object[1];
                v2_1[0] = com.microsoft.aad.adal.PRNGFixes.generateSeed();
                v1_1.invoke(0, v2_1);
                java.io.IOException v1_3 = Class.forName("org.apache.harmony.xnet.provider.jsse.NativeCrypto");
                Class[] v7 = new Class[2];
                v7[0] = String;
                v7[1] = Long.TYPE;
                java.io.IOException v1_4 = v1_3.getMethod("RAND_load_file", v7);
                java.io.IOException v2_4 = new Object[2];
                v2_4[0] = "/dev/urandom";
                v2_4[1] = Integer.valueOf(1024);
                java.io.IOException v1_8 = ((Integer) v1_4.invoke(0, v2_4)).intValue();
            } catch (java.io.IOException v1_9) {
                com.microsoft.aad.adal.Logger.e("PRNGFixes:applyOpenSSLFix", "Failed to seed OpenSSL PRNG. ", "", com.microsoft.aad.adal.ADALError.DEVICE_PRNG_FIX_ERROR, v1_9);
                throw new SecurityException("Failed to seed OpenSSL PRNG", v1_9);
            }
            if (v1_8 != 1024) {
                String v3_2 = new StringBuilder();
                v3_2.append("Unexpected number of bytes read from Linux PRNG: ");
                v3_2.append(v1_8);
                throw new java.io.IOException(v3_2.toString());
            } else {
                return;
            }
        } else {
            com.microsoft.aad.adal.Logger.v("PRNGFixes:applyOpenSSLFix", "No need to apply the OpenSSL fix.");
            return;
        }
    }

Method android.support.v4.media.session.MediaSessionCompatApi24.getCallingPackage() calling method java.lang.reflect.Method.invoke()


    public static String getCallingPackage(Object p5)
    {
        try {
            Class[] v4 = new Class[0];
            String v2_4 = new Object[0];
            return ((String) ((android.media.session.MediaSession) p5).getClass().getMethod("getCallingPackage", v4).invoke(((android.media.session.MediaSession) p5), v2_4));
        } catch (int v1_0) {
            android.util.Log.e("MediaSessionCompatApi24", "Cannot execute MediaSession.getCallingPackage()", v1_0);
            return 0;
        }
    }

Method android.support.v4.graphics.drawable.DrawableCompat.setLayoutDirection() calling method java.lang.reflect.Method.invoke()


    public static boolean setLayoutDirection(android.graphics.drawable.Drawable p6, int p7)
    {
        if (android.os.Build$VERSION.SDK_INT < 23) {
            if (android.os.Build$VERSION.SDK_INT < 17) {
                return 0;
            } else {
                if (!android.support.v4.graphics.drawable.DrawableCompat.sSetLayoutDirectionMethodFetched) {
                    try {
                        Integer v4_0 = new Class[1];
                        v4_0[0] = Integer.TYPE;
                        android.support.v4.graphics.drawable.DrawableCompat.sSetLayoutDirectionMethod = android.graphics.drawable.Drawable.getDeclaredMethod("setLayoutDirection", v4_0);
                        android.support.v4.graphics.drawable.DrawableCompat.sSetLayoutDirectionMethod.setAccessible(1);
                    } catch (Exception v0_4) {
                        android.util.Log.i("DrawableCompat", "Failed to retrieve setLayoutDirection(int) method", v0_4);
                    }
                    android.support.v4.graphics.drawable.DrawableCompat.sSetLayoutDirectionMethodFetched = 1;
                }
                if (android.support.v4.graphics.drawable.DrawableCompat.sSetLayoutDirectionMethod != null) {
                    try {
                        String v3_2 = new Object[1];
                        v3_2[0] = Integer.valueOf(p7);
                        android.support.v4.graphics.drawable.DrawableCompat.sSetLayoutDirectionMethod.invoke(p6, v3_2);
                        return 1;
                    } catch (Exception v0_8) {
                        android.util.Log.i("DrawableCompat", "Failed to invoke setLayoutDirection(int) via reflection", v0_8);
                        android.support.v4.graphics.drawable.DrawableCompat.sSetLayoutDirectionMethod = 0;
                    }
                }
                return 0;
            }
        } else {
            return p6.setLayoutDirection(p7);
        }
    }

Method android.support.v4.graphics.drawable.DrawableCompat.getLayoutDirection() calling method java.lang.reflect.Method.invoke()


    public static int getLayoutDirection(android.graphics.drawable.Drawable p5)
    {
        if (android.os.Build$VERSION.SDK_INT < 23) {
            if (android.os.Build$VERSION.SDK_INT < 17) {
                return 0;
            } else {
                if (!android.support.v4.graphics.drawable.DrawableCompat.sGetLayoutDirectionMethodFetched) {
                    try {
                        String v4_0 = new Class[0];
                        android.support.v4.graphics.drawable.DrawableCompat.sGetLayoutDirectionMethod = android.graphics.drawable.Drawable.getDeclaredMethod("getLayoutDirection", v4_0);
                        android.support.v4.graphics.drawable.DrawableCompat.sGetLayoutDirectionMethod.setAccessible(1);
                    } catch (int v1_4) {
                        android.util.Log.i("DrawableCompat", "Failed to retrieve getLayoutDirection() method", v1_4);
                    }
                    android.support.v4.graphics.drawable.DrawableCompat.sGetLayoutDirectionMethodFetched = 1;
                }
                if (android.support.v4.graphics.drawable.DrawableCompat.sGetLayoutDirectionMethod != null) {
                    try {
                        int v1_5 = new Object[0];
                        return ((Integer) android.support.v4.graphics.drawable.DrawableCompat.sGetLayoutDirectionMethod.invoke(p5, v1_5)).intValue();
                    } catch (Exception v0_8) {
                        android.util.Log.i("DrawableCompat", "Failed to invoke getLayoutDirection() via reflection", v0_8);
                        android.support.v4.graphics.drawable.DrawableCompat.sGetLayoutDirectionMethod = 0;
                    }
                }
                return 0;
            }
        } else {
            return p5.getLayoutDirection();
        }
    }

Method android.support.v4.app.NotificationManagerCompat.areNotificationsEnabled() calling method java.lang.reflect.Method.invoke()


    public boolean areNotificationsEnabled()
    {
        if (android.os.Build$VERSION.SDK_INT < 24) {
            int v2 = 1;
            if (android.os.Build$VERSION.SDK_INT < 19) {
                return 1;
            } else {
                android.app.AppOpsManager v0_2 = ((android.app.AppOpsManager) this.mContext.getSystemService("appops"));
                android.content.pm.ApplicationInfo v1_2 = this.mContext.getApplicationInfo();
                String v3_2 = this.mContext.getApplicationContext().getPackageName();
                int v4 = v1_2.uid;
                try {
                    ClassNotFoundException v5_2 = Class.forName(android.app.AppOpsManager.getName());
                    reflect.Field v8_0 = new Class[3];
                    v8_0[0] = Integer.TYPE;
                    v8_0[1] = Integer.TYPE;
                    v8_0[2] = String;
                    reflect.Method v6_1 = v5_2.getMethod("checkOpNoThrow", v8_0);
                    int v7_1 = new Object[3];
                    v7_1[0] = Integer.valueOf(((Integer) v5_2.getDeclaredField("OP_POST_NOTIFICATION").get(Integer)).intValue());
                    v7_1[1] = Integer.valueOf(v4);
                    v7_1[2] = v3_2;
                } catch (ClassNotFoundException v5) {
                    return 1;
                }
                if (((Integer) v6_1.invoke(v0_2, v7_1)).intValue() != 0) {
                    v2 = 0;
                }
                return v2;
            }
        } else {
            return this.mNotificationManager.areNotificationsEnabled();
        }
    }

Method android.support.v4.app.BundleCompat$BundleCompatBaseImpl.putBinder() calling method java.lang.reflect.Method.invoke()


    public static void putBinder(android.os.Bundle p7, String p8, android.os.IBinder p9)
    {
        if (!android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethodFetched) {
            try {
                String v5_1 = new Class[2];
                v5_1[0] = String;
                v5_1[1] = android.os.IBinder;
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethod = android.os.Bundle.getMethod("putIBinder", v5_1);
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethod.setAccessible(1);
            } catch (reflect.InvocationTargetException v0_3) {
                android.util.Log.i("BundleCompatBaseImpl", "Failed to retrieve putIBinder method", v0_3);
            }
            android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethodFetched = 1;
        }
        if (android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethod != null) {
            try {
                String v2_1 = new Object[2];
                v2_1[0] = p8;
                v2_1[1] = p9;
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethod.invoke(p7, v2_1);
            } catch (reflect.InvocationTargetException v0_6) {
                android.util.Log.i("BundleCompatBaseImpl", "Failed to invoke putIBinder via reflection", v0_6);
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethod = 0;
            }
        }
        return;
    }

Method android.support.v4.app.BundleCompat$BundleCompatBaseImpl.getBinder() calling method java.lang.reflect.Method.invoke()


    public static android.os.IBinder getBinder(android.os.Bundle p6, String p7)
    {
        if (!android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethodFetched) {
            try {
                String v4_1 = new Class[1];
                v4_1[0] = String;
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod = android.os.Bundle.getMethod("getIBinder", v4_1);
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod.setAccessible(1);
            } catch (reflect.InvocationTargetException v0_3) {
                android.util.Log.i("BundleCompatBaseImpl", "Failed to retrieve getIBinder method", v0_3);
            }
            android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethodFetched = 1;
        }
        if (android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod != null) {
            try {
                String v2_1 = new Object[1];
                v2_1[0] = p7;
                return ((android.os.IBinder) android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod.invoke(p6, v2_1));
            } catch (reflect.InvocationTargetException v0_8) {
                android.util.Log.i("BundleCompatBaseImpl", "Failed to invoke getIBinder via reflection", v0_8);
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod = 0;
            }
        }
        return 0;
    }

Method android.support.transition.ViewOverlayApi14$OverlayViewGroup.invalidateChildInParentFast() calling method java.lang.reflect.Method.invoke()


    protected android.view.ViewParent invalidateChildInParentFast(int p8, int p9, android.graphics.Rect p10)
    {
        if (((this.mHostView instanceof android.view.ViewGroup)) && (android.support.transition.ViewOverlayApi14$OverlayViewGroup.sInvalidateChildInParentFastMethod != null)) {
            try {
                int[] v1 = new int[2];
                this.getOffset(v1);
                android.view.ViewGroup v3 = this.mHostView;
                Object[] v4_1 = new Object[3];
                v4_1[0] = Integer.valueOf(p8);
                v4_1[1] = Integer.valueOf(p9);
                v4_1[2] = p10;
                android.support.transition.ViewOverlayApi14$OverlayViewGroup.sInvalidateChildInParentFastMethod.invoke(v3, v4_1);
            } catch (reflect.InvocationTargetException v0_3) {
                v0_3.printStackTrace();
            } catch (reflect.InvocationTargetException v0_2) {
                v0_2.printStackTrace();
            }
        }
        return 0;
    }

Method android.support.transition.ViewGroupUtilsApi18.suppressLayout() calling method java.lang.reflect.Method.invoke()


    static void suppressLayout(android.view.ViewGroup p4, boolean p5)
    {
        android.support.transition.ViewGroupUtilsApi18.fetchSuppressLayoutMethod();
        if (android.support.transition.ViewGroupUtilsApi18.sSuppressLayoutMethod != null) {
            try {
                String v1_3 = new Object[1];
                v1_3[0] = Boolean.valueOf(p5);
                android.support.transition.ViewGroupUtilsApi18.sSuppressLayoutMethod.invoke(p4, v1_3);
            } catch (reflect.InvocationTargetException v0_2) {
                android.util.Log.i("ViewUtilsApi18", "Failed to invoke suppressLayout method", v0_2);
            } catch (reflect.InvocationTargetException v0_1) {
                android.util.Log.i("ViewUtilsApi18", "Error invoking suppressLayout method", v0_1);
            }
        }
        return;
    }

Method android.support.transition.ViewGroupUtilsApi14.cancelLayoutTransition() calling method java.lang.reflect.Method.invoke()


    private static void cancelLayoutTransition(android.animation.LayoutTransition p5)
    {
        if (!android.support.transition.ViewGroupUtilsApi14.sCancelMethodFetched) {
            try {
                String v4_1 = new Class[0];
                android.support.transition.ViewGroupUtilsApi14.sCancelMethod = android.animation.LayoutTransition.getDeclaredMethod("cancel", v4_1);
                android.support.transition.ViewGroupUtilsApi14.sCancelMethod.setAccessible(1);
            } catch (String v2) {
                android.util.Log.i("ViewGroupUtilsApi14", "Failed to access cancel method by reflection");
            }
            android.support.transition.ViewGroupUtilsApi14.sCancelMethodFetched = 1;
        }
        if (android.support.transition.ViewGroupUtilsApi14.sCancelMethod != null) {
            try {
                String v1_1 = new Object[0];
                android.support.transition.ViewGroupUtilsApi14.sCancelMethod.invoke(p5, v1_1);
            } catch (reflect.InvocationTargetException v0) {
                android.util.Log.i("ViewGroupUtilsApi14", "Failed to access cancel method by reflection");
            } catch (reflect.InvocationTargetException v0) {
                android.util.Log.i("ViewGroupUtilsApi14", "Failed to invoke cancel method by reflection");
            }
        }
        return;
    }

Method android.support.transition.ImageViewUtils.animateTransform() calling method java.lang.reflect.Method.invoke()


    static void animateTransform(android.widget.ImageView p3, android.graphics.Matrix p4)
    {
        if (android.os.Build$VERSION.SDK_INT >= 21) {
            android.support.transition.ImageViewUtils.fetchAnimateTransformMethod();
            if (android.support.transition.ImageViewUtils.sAnimateTransformMethod != null) {
                try {
                    RuntimeException v1_4 = new Object[1];
                    v1_4[0] = p4;
                    android.support.transition.ImageViewUtils.sAnimateTransformMethod.invoke(p3, v1_4);
                } catch (reflect.InvocationTargetException v0) {
                } catch (reflect.InvocationTargetException v0_1) {
                    throw new RuntimeException(v0_1.getCause());
                }
            }
        } else {
            p3.setImageMatrix(p4);
        }
        return;
    }

Method android.support.design.widget.DrawableUtils.setContainerConstantStateV9() calling method java.lang.reflect.Method.invoke()


    private static boolean setContainerConstantStateV9(android.graphics.drawable.DrawableContainer p6, android.graphics.drawable.Drawable$ConstantState p7)
    {
        if (!android.support.design.widget.DrawableUtils.setConstantStateMethodFetched) {
            try {
                String v4_1 = new Class[1];
                v4_1[0] = android.graphics.drawable.DrawableContainer$DrawableContainerState;
                android.support.design.widget.DrawableUtils.setConstantStateMethod = android.graphics.drawable.DrawableContainer.getDeclaredMethod("setConstantState", v4_1);
                android.support.design.widget.DrawableUtils.setConstantStateMethod.setAccessible(1);
            } catch (Exception v0) {
                android.util.Log.e("DrawableUtils", "Could not fetch setConstantState(). Oh well.");
            }
            android.support.design.widget.DrawableUtils.setConstantStateMethodFetched = 1;
        }
        if (android.support.design.widget.DrawableUtils.setConstantStateMethod != null) {
            try {
                String v3_1 = new Object[1];
                v3_1[0] = p7;
                android.support.design.widget.DrawableUtils.setConstantStateMethod.invoke(p6, v3_1);
                return 1;
            } catch (Exception v0) {
                android.util.Log.e("DrawableUtils", "Could not invoke setConstantState(). Oh well.");
            }
        }
        return 0;
    }

Method android.arch.lifecycle.ClassesInfoCache$MethodReference.invokeCallback() calling method java.lang.reflect.Method.invoke()


    void invokeCallback(android.arch.lifecycle.LifecycleOwner p5, android.arch.lifecycle.Lifecycle$Event p6, Object p7)
    {
        try {
            switch (this.mCallType) {
                case 0:
                    Object[] v1_2 = new Object[0];
                    this.mMethod.invoke(p7, v1_2);
                    break;
                case 1:
                    reflect.Method v0_1 = this.mMethod;
                    Object[] v1_1 = new Object[1];
                    v1_1[0] = p5;
                    v0_1.invoke(p7, v1_1);
                    break;
                case 2:
                    reflect.Method v0_5 = this.mMethod;
                    Object[] v3_2 = new Object[2];
                    v3_2[0] = p5;
                    v3_2[1] = p6;
                    v0_5.invoke(p7, v3_2);
                    break;
                default:
            }
        } catch (reflect.Method v0_4) {
            throw new RuntimeException("Failed to call observer method", v0_4.getCause());
        } catch (reflect.Method v0_3) {
            throw new RuntimeException(v0_3);
        }
        return;
    }

Method com.google.gson.internal.UnsafeAllocator.create() calling method java.lang.reflect.Method.invoke()


    public static com.google.gson.internal.UnsafeAllocator create()
    {
        try {
            Class[] v3_2 = Class.forName("sun.misc.Unsafe");
            String v4_4 = v3_2.getDeclaredField("theUnsafe");
            v4_4.setAccessible(1);
            Class v5_0 = v4_4.get(0);
            Class[] v7_0 = new Class[1];
            v7_0[0] = Class;
            return new com.google.gson.internal.UnsafeAllocator$1(v3_2.getMethod("allocateInstance", v7_0), v5_0);
        } catch (Class[] v3) {
            try {
                com.google.gson.internal.UnsafeAllocator$2 v6_2 = new Class[1];
                v6_2[0] = Class;
                String v4_1 = java.io.ObjectStreamClass.getDeclaredMethod("getConstructorId", v6_2);
                v4_1.setAccessible(1);
                Class v5_2 = new Object[1];
                v5_2[0] = Object;
                com.google.gson.internal.UnsafeAllocator$4 v0_3 = ((Integer) v4_1.invoke(0, v5_2)).intValue();
                Class[] v7_4 = new Class[2];
                v7_4[0] = Class;
                v7_4[1] = Integer.TYPE;
                Class v5_4 = java.io.ObjectStreamClass.getDeclaredMethod("newInstance", v7_4);
                v5_4.setAccessible(1);
                return new com.google.gson.internal.UnsafeAllocator$2(v5_4, v0_3);
            } catch (com.google.gson.internal.UnsafeAllocator$4 v0) {
                try {
                    Class[] v3_3 = new Class[2];
                    v3_3[0] = Class;
                    v3_3[1] = Class;
                    com.google.gson.internal.UnsafeAllocator$4 v0_5 = java.io.ObjectInputStream.getDeclaredMethod("newInstance", v3_3);
                    v0_5.setAccessible(1);
                    return new com.google.gson.internal.UnsafeAllocator$3(v0_5);
                } catch (com.google.gson.internal.UnsafeAllocator$4 v0) {
                    return new com.google.gson.internal.UnsafeAllocator$4();
                }
            }
        }
    }

Method com.google.android.gms.security.ProviderInstaller.installIfNeeded() calling method java.lang.reflect.Method.invoke()


    public static void installIfNeeded(android.content.Context p8)
    {
        com.google.android.gms.common.internal.Preconditions.checkNotNull(p8, "Context must not be null");
        com.google.android.gms.security.ProviderInstaller.zzacw.verifyGooglePlayServicesIsAvailable(p8, 11925000);
        try {
            String v8_17 = com.google.android.gms.common.GooglePlayServicesUtilLight.getRemoteContext(p8);
        } catch (String v8) {
            if (android.util.Log.isLoggable("ProviderInstaller", 6)) {
                android.util.Log.e("ProviderInstaller", "Failed to get remote context - resource not found");
            }
            throw new com.google.android.gms.common.GooglePlayServicesNotAvailableException(8);
        }
        if (v8_17 != null) {
            if (com.google.android.gms.security.ProviderInstaller.zzacx == null) {
                String v3_2 = v8_17.getClassLoader().loadClass("com.google.android.gms.common.security.ProviderInstallerImpl");
                int v6_1 = new Class[1];
                v6_1[0] = android.content.Context;
                com.google.android.gms.security.ProviderInstaller.zzacx = v3_2.getMethod("insertProvider", v6_1);
            }
            Object[] v5_1 = new Object[1];
            v5_1[0] = v8_17;
            com.google.android.gms.security.ProviderInstaller.zzacx.invoke(0, v5_1);
            return;
        } else {
            if (android.util.Log.isLoggable("ProviderInstaller", 6)) {
                android.util.Log.e("ProviderInstaller", "Failed to get remote context");
            }
            throw new com.google.android.gms.common.GooglePlayServicesNotAvailableException(8);
        }
    }

Method com.google.android.gms.common.util.WorkSourceUtil.size() calling method java.lang.reflect.Method.invoke()


    public static int size(android.os.WorkSource p3)
    {
        if (com.google.android.gms.common.util.WorkSourceUtil.zzaap != null) {
            try {
                String v2_1 = new Object[0];
                return ((Integer) com.google.android.gms.common.util.WorkSourceUtil.zzaap.invoke(p3, v2_1)).intValue();
            } catch (Exception v3_1) {
                android.util.Log.wtf("WorkSourceUtil", "Unable to assign blame through WorkSource", v3_1);
            }
        }
        return 0;
    }

Method com.google.android.gms.common.util.WorkSourceUtil.getName() calling method java.lang.reflect.Method.invoke()


    public static String getName(android.os.WorkSource p3, int p4)
    {
        if (com.google.android.gms.common.util.WorkSourceUtil.zzaar != null) {
            try {
                Object[] v1_1 = new Object[1];
                v1_1[0] = Integer.valueOf(p4);
                return ((String) com.google.android.gms.common.util.WorkSourceUtil.zzaar.invoke(p3, v1_1));
            } catch (Exception v3_3) {
                android.util.Log.wtf("WorkSourceUtil", "Unable to assign blame through WorkSource", v3_3);
            }
        }
        return 0;
    }

Method com.google.android.gms.common.util.WorkSourceUtil.get() calling method java.lang.reflect.Method.invoke()


    public static int get(android.os.WorkSource p3, int p4)
    {
        if (com.google.android.gms.common.util.WorkSourceUtil.zzaaq != null) {
            try {
                Object[] v2_1 = new Object[1];
                v2_1[0] = Integer.valueOf(p4);
                return ((Integer) com.google.android.gms.common.util.WorkSourceUtil.zzaaq.invoke(p3, v2_1)).intValue();
            } catch (Exception v3_4) {
                android.util.Log.wtf("WorkSourceUtil", "Unable to assign blame through WorkSource", v3_4);
            }
        }
        return 0;
    }

Method com.google.android.gms.common.util.WorkSourceUtil.fromPackageAndModuleExperimentalPi() calling method java.lang.reflect.Method.invoke()


    public static android.os.WorkSource fromPackageAndModuleExperimentalPi(android.content.Context p7, String p8, String p9)
    {
        if ((p7 != null) && ((p7.getPackageManager() != null) && ((p9 != null) && (p8 != null)))) {
            reflect.Method v7_5 = com.google.android.gms.common.util.WorkSourceUtil.zzc(p7, p8);
            if (v7_5 >= null) {
                android.os.WorkSource v0_2 = new android.os.WorkSource();
                if ((com.google.android.gms.common.util.WorkSourceUtil.zzaas != null) && (com.google.android.gms.common.util.WorkSourceUtil.zzaat != null)) {
                    try {
                        Integer v3_0 = new Object[0];
                        Object v1_3 = com.google.android.gms.common.util.WorkSourceUtil.zzaas.invoke(v0_2, v3_0);
                    } catch (reflect.Method v7_2) {
                        android.util.Log.w("WorkSourceUtil", "Unable to assign chained blame through WorkSource", v7_2);
                    }
                    if (v7_5 != com.google.android.gms.common.util.WorkSourceUtil.zzaam) {
                        Object[] v6 = new Object[2];
                        v6[0] = Integer.valueOf(v7_5);
                        v6[1] = p8;
                        com.google.android.gms.common.util.WorkSourceUtil.zzaat.invoke(v1_3, v6);
                    }
                    Object[] v8_2 = new Object[2];
                    v8_2[0] = Integer.valueOf(com.google.android.gms.common.util.WorkSourceUtil.zzaam);
                    v8_2[1] = p9;
                    com.google.android.gms.common.util.WorkSourceUtil.zzaat.invoke(v1_3, v8_2);
                } else {
                    com.google.android.gms.common.util.WorkSourceUtil.add(v0_2, v7_5, p8);
                }
                return v0_2;
            } else {
                return 0;
            }
        } else {
            android.util.Log.w("WorkSourceUtil", "Unexpected null arguments");
            return 0;
        }
    }

Method com.google.android.gms.common.util.WorkSourceUtil.add() calling method java.lang.reflect.Method.invoke()


    public static void add(android.os.WorkSource p4, int p5, String p6)
    {
        if (com.google.android.gms.common.util.WorkSourceUtil.zzaao == null) {
            if (com.google.android.gms.common.util.WorkSourceUtil.zzaan != null) {
                try {
                    Object[] v0_2 = new Object[1];
                    v0_2[0] = Integer.valueOf(p5);
                    com.google.android.gms.common.util.WorkSourceUtil.zzaan.invoke(p4, v0_2);
                    return;
                } catch (Exception v4_1) {
                    android.util.Log.wtf("WorkSourceUtil", "Unable to assign blame through WorkSource", v4_1);
                }
            }
            return;
        } else {
            if (p6 == null) {
                p6 = "";
            }
            try {
                Object[] v3_1 = new Object[2];
                v3_1[0] = Integer.valueOf(p5);
                v3_1[1] = p6;
                com.google.android.gms.common.util.WorkSourceUtil.zzaao.invoke(p4, v3_1);
                return;
            } catch (Exception v4_2) {
                android.util.Log.wtf("WorkSourceUtil", "Unable to assign blame through WorkSource", v4_2);
                return;
            }
        }
    }

Method com.google.android.gms.common.server.response.FastJsonResponse.getFieldValue() calling method java.lang.reflect.Method.invoke()


    protected Object getFieldValue(com.google.android.gms.common.server.response.FastJsonResponse$Field p8)
    {
        RuntimeException v0_0 = p8.getOutputFieldName();
        if (p8.getConcreteType() == null) {
            return this.getValueObject(p8.getOutputFieldName());
        } else {
            Class[] v1_2;
            if (this.getValueObject(p8.getOutputFieldName()) != null) {
                v1_2 = 0;
            } else {
                v1_2 = 1;
            }
            Exception v8_2;
            Object[] v5 = new Object[1];
            v5[0] = p8.getOutputFieldName();
            com.google.android.gms.common.internal.Preconditions.checkState(v1_2, "Concrete field shouldn\'t be value object: %s", v5);
            if (!p8.isTypeOutArray()) {
                v8_2 = this.getConcreteTypes();
            } else {
                v8_2 = this.getConcreteTypeArrays();
            }
            if (v8_2 == null) {
                try {
                    Exception v8_4 = Character.toUpperCase(v0_0.charAt(0));
                    RuntimeException v0_1 = v0_0.substring(1);
                    StringBuilder v2_2 = new StringBuilder((String.valueOf(v0_1).length() + 4));
                    v2_2.append("get");
                    v2_2.append(v8_4);
                    v2_2.append(v0_1);
                    Class[] v1_8 = new Class[0];
                    RuntimeException v0_3 = new Object[0];
                    return this.getClass().getMethod(v2_2.toString(), v1_8).invoke(this, v0_3);
                } catch (Exception v8_9) {
                    throw new RuntimeException(v8_9);
                }
            } else {
                return v8_2.get(v0_0);
            }
        }
    }

Method com.google.android.gms.common.net.SSLCertificateSocketFactory.setUseSessionTickets() calling method java.lang.reflect.Method.invoke()


    public void setUseSessionTickets(java.net.Socket p7, boolean p8)
    {
        try {
            RuntimeException v0_0 = p7.getClass();
            Class[] v3 = new Class[1];
            v3[0] = Boolean.TYPE;
            RuntimeException v0_7 = v0_0.getMethod("setUseSessionTickets", v3);
            String v1_0 = new Object[1];
            v1_0[0] = Boolean.valueOf(p8);
            v0_7.invoke(p7, v1_0);
            return;
        } catch (NoSuchMethodException v8_2) {
            String v7_2 = String.valueOf(p7.getClass());
            StringBuilder v2_1 = new StringBuilder((String.valueOf(v7_2).length() + 40));
            v2_1.append(v7_2);
            v2_1.append(" does not implement setUseSessionTickets");
            throw new IllegalArgumentException(v2_1.toString(), v8_2);
        } catch (NoSuchMethodException v8_3) {
            RuntimeException v0_3 = v8_3.getCause();
            if (!(v0_3 instanceof RuntimeException)) {
                String v7_6 = String.valueOf(p7.getClass());
                StringBuilder v2_4 = new StringBuilder((String.valueOf(v7_6).length() + 41));
                v2_4.append("Failed to invoke setUseSessionTickets on ");
                v2_4.append(v7_6);
                throw new RuntimeException(v2_4.toString(), v8_3);
            } else {
                throw ((RuntimeException) v0_3);
            }
        }
    }

Method com.google.android.gms.common.net.SSLCertificateSocketFactory.setSoWriteTimeout() calling method java.lang.reflect.Method.invoke()


    public void setSoWriteTimeout(java.net.Socket p7, int p8)
    {
        try {
            RuntimeException v0_0 = p7.getClass();
            Class[] v3 = new Class[1];
            v3[0] = Integer.TYPE;
            RuntimeException v0_8 = v0_0.getMethod("setSoWriteTimeout", v3);
            String v1_0 = new Object[1];
            v1_0[0] = Integer.valueOf(p8);
            v0_8.invoke(p7, v1_0);
            return;
        } catch (NoSuchMethodException v8_2) {
            String v7_2 = String.valueOf(p7.getClass());
            StringBuilder v2_1 = new StringBuilder((String.valueOf(v7_2).length() + 37));
            v2_1.append(v7_2);
            v2_1.append(" does not implement setSoWriteTimeout");
            throw new IllegalArgumentException(v2_1.toString(), v8_2);
        } catch (NoSuchMethodException v8_3) {
            RuntimeException v0_3 = v8_3.getCause();
            if ((v0_3 instanceof java.net.SocketException)) {
                throw ((java.net.SocketException) v0_3);
            } else {
                if (!(v0_3 instanceof RuntimeException)) {
                    String v7_6 = String.valueOf(p7.getClass());
                    StringBuilder v2_4 = new StringBuilder((String.valueOf(v7_6).length() + 38));
                    v2_4.append("Failed to invoke setSoWriteTimeout on ");
                    v2_4.append(v7_6);
                    throw new RuntimeException(v2_4.toString(), v8_3);
                } else {
                    throw ((RuntimeException) v0_3);
                }
            }
        }
    }

Method com.google.android.gms.common.net.SSLCertificateSocketFactory.setHostname() calling method java.lang.reflect.Method.invoke()


    public void setHostname(java.net.Socket p7, String p8)
    {
        try {
            RuntimeException v0_0 = p7.getClass();
            Class[] v3 = new Class[1];
            v3[0] = String;
            RuntimeException v0_7 = v0_0.getMethod("setHostname", v3);
            String v1_0 = new Object[1];
            v1_0[0] = p8;
            v0_7.invoke(p7, v1_0);
            return;
        } catch (NoSuchMethodException v8_1) {
            String v7_2 = String.valueOf(p7.getClass());
            StringBuilder v2_1 = new StringBuilder((String.valueOf(v7_2).length() + 31));
            v2_1.append(v7_2);
            v2_1.append(" does not implement setHostname");
            throw new IllegalArgumentException(v2_1.toString(), v8_1);
        } catch (NoSuchMethodException v8_2) {
            RuntimeException v0_3 = v8_2.getCause();
            if (!(v0_3 instanceof RuntimeException)) {
                String v7_6 = String.valueOf(p7.getClass());
                StringBuilder v2_4 = new StringBuilder((String.valueOf(v7_6).length() + 32));
                v2_4.append("Failed to invoke setHostname on ");
                v2_4.append(v7_6);
                throw new RuntimeException(v2_4.toString(), v8_2);
            } else {
                throw ((RuntimeException) v0_3);
            }
        }
    }

Method com.google.android.gms.common.net.SSLCertificateSocketFactory.getNpnSelectedProtocol() calling method java.lang.reflect.Method.invoke()


    public byte[] getNpnSelectedProtocol(java.net.Socket p5)
    {
        try {
            StringBuilder v3_2 = new Class[0];
            RuntimeException v1_7 = new Object[0];
            return ((byte[]) p5.getClass().getMethod("getNpnSelectedProtocol", v3_2).invoke(p5, v1_7));
        } catch (NoSuchMethodException v0_2) {
            String v5_2 = String.valueOf(p5.getClass());
            StringBuilder v3_1 = new StringBuilder((String.valueOf(v5_2).length() + 42));
            v3_1.append(v5_2);
            v3_1.append(" does not implement getNpnSelectedProtocol");
            throw new IllegalArgumentException(v3_1.toString(), v0_2);
        } catch (NoSuchMethodException v0_3) {
            RuntimeException v1_3 = v0_3.getCause();
            if (!(v1_3 instanceof RuntimeException)) {
                String v5_6 = String.valueOf(p5.getClass());
                StringBuilder v3_4 = new StringBuilder((String.valueOf(v5_6).length() + 43));
                v3_4.append("Failed to invoke getNpnSelectedProtocol on ");
                v3_4.append(v5_6);
                throw new RuntimeException(v3_4.toString(), v0_3);
            } else {
                throw ((RuntimeException) v1_3);
            }
        }
    }

Method com.google.android.gms.common.net.SSLCertificateSocketFactory.getAlpnSelectedProtocol() calling method java.lang.reflect.Method.invoke()


    public byte[] getAlpnSelectedProtocol(java.net.Socket p5)
    {
        try {
            StringBuilder v3_2 = new Class[0];
            RuntimeException v1_7 = new Object[0];
            return ((byte[]) p5.getClass().getMethod("getAlpnSelectedProtocol", v3_2).invoke(p5, v1_7));
        } catch (NoSuchMethodException v0_2) {
            String v5_2 = String.valueOf(p5.getClass());
            StringBuilder v3_1 = new StringBuilder((String.valueOf(v5_2).length() + 43));
            v3_1.append(v5_2);
            v3_1.append(" does not implement getAlpnSelectedProtocol");
            throw new IllegalArgumentException(v3_1.toString(), v0_2);
        } catch (NoSuchMethodException v0_3) {
            RuntimeException v1_3 = v0_3.getCause();
            if (!(v1_3 instanceof RuntimeException)) {
                String v5_6 = String.valueOf(p5.getClass());
                StringBuilder v3_4 = new StringBuilder((String.valueOf(v5_6).length() + 44));
                v3_4.append("Failed to invoke getAlpnSelectedProtocol on ");
                v3_4.append(v5_6);
                throw new RuntimeException(v3_4.toString(), v0_3);
            } else {
                throw ((RuntimeException) v1_3);
            }
        }
    }

Method com.google.android.gms.common.net.SSLCertificateSocketFactory.zzb() calling method java.lang.reflect.Method.invoke()


    private static void zzb(java.net.Socket p6, byte[] p7)
    {
        if (p6 != null) {
            try {
                RuntimeException v0_2 = p6.getClass();
                Class[] v3 = new Class[1];
                v3[0] = byte[];
                RuntimeException v0_0 = v0_2.getMethod("setAlpnProtocols", v3);
                String v1_0 = new Object[1];
                v1_0[0] = p7;
                v0_0.invoke(p6, v1_0);
            } catch (NoSuchMethodException v7_1) {
                String v6_2 = String.valueOf(p6.getClass());
                StringBuilder v2_1 = new StringBuilder((String.valueOf(v6_2).length() + 36));
                v2_1.append(v6_2);
                v2_1.append(" does not implement setAlpnProtocols");
                throw new IllegalArgumentException(v2_1.toString(), v7_1);
            } catch (NoSuchMethodException v7_2) {
                RuntimeException v0_4 = v7_2.getCause();
                if (!(v0_4 instanceof RuntimeException)) {
                    String v6_6 = String.valueOf(p6.getClass());
                    StringBuilder v2_4 = new StringBuilder((String.valueOf(v6_6).length() + 37));
                    v2_4.append("Failed to invoke setAlpnProtocols on ");
                    v2_4.append(v6_6);
                    throw new RuntimeException(v2_4.toString(), v7_2);
                } else {
                    throw ((RuntimeException) v0_4);
                }
            }
        }
        return;
    }

Method com.google.android.gms.common.net.SSLCertificateSocketFactory.zza() calling method java.lang.reflect.Method.invoke()


    private static void zza(java.net.Socket p6, byte[] p7)
    {
        if (p6 != null) {
            try {
                RuntimeException v0_2 = p6.getClass();
                Class[] v3 = new Class[1];
                v3[0] = byte[];
                RuntimeException v0_0 = v0_2.getMethod("setNpnProtocols", v3);
                String v1_0 = new Object[1];
                v1_0[0] = p7;
                v0_0.invoke(p6, v1_0);
            } catch (NoSuchMethodException v7_1) {
                String v6_2 = String.valueOf(p6.getClass());
                StringBuilder v2_1 = new StringBuilder((String.valueOf(v6_2).length() + 35));
                v2_1.append(v6_2);
                v2_1.append(" does not implement setNpnProtocols");
                throw new IllegalArgumentException(v2_1.toString(), v7_1);
            } catch (NoSuchMethodException v7_2) {
                RuntimeException v0_4 = v7_2.getCause();
                if (!(v0_4 instanceof RuntimeException)) {
                    String v6_6 = String.valueOf(p6.getClass());
                    StringBuilder v2_4 = new StringBuilder((String.valueOf(v6_6).length() + 36));
                    v2_4.append("Failed to invoke setNpnProtocols on ");
                    v2_4.append(v6_6);
                    throw new RuntimeException(v2_4.toString(), v7_2);
                } else {
                    throw ((RuntimeException) v0_4);
                }
            }
        }
        return;
    }

Method com.google.android.gms.common.net.SSLCertificateSocketFactory.zza() calling method java.lang.reflect.Method.invoke()


    private static void zza(java.net.Socket p6, java.security.PrivateKey p7)
    {
        if (p6 != null) {
            try {
                RuntimeException v0_2 = p6.getClass();
                Class[] v3 = new Class[1];
                v3[0] = java.security.PrivateKey;
                RuntimeException v0_0 = v0_2.getMethod("setChannelIdPrivateKey", v3);
                String v1_0 = new Object[1];
                v1_0[0] = p7;
                v0_0.invoke(p6, v1_0);
            } catch (NoSuchMethodException v7_1) {
                String v6_2 = String.valueOf(p6.getClass());
                StringBuilder v2_1 = new StringBuilder((String.valueOf(v6_2).length() + 42));
                v2_1.append(v6_2);
                v2_1.append(" does not implement setChannelIdPrivateKey");
                throw new IllegalArgumentException(v2_1.toString(), v7_1);
            } catch (NoSuchMethodException v7_2) {
                RuntimeException v0_4 = v7_2.getCause();
                if (!(v0_4 instanceof RuntimeException)) {
                    String v6_6 = String.valueOf(p6.getClass());
                    StringBuilder v2_4 = new StringBuilder((String.valueOf(v6_6).length() + 43));
                    v2_4.append("Failed to invoke setChannelIdPrivateKey on ");
                    v2_4.append(v6_6);
                    throw new RuntimeException(v2_4.toString(), v7_2);
                } else {
                    throw ((RuntimeException) v0_4);
                }
            }
        }
        return;
    }

Method com.google.android.gms.common.net.SSLCertificateSocketFactory.zza() calling method java.lang.reflect.Method.invoke()


    private static void zza(java.net.Socket p6, int p7)
    {
        if (p6 != null) {
            try {
                RuntimeException v0_2 = p6.getClass();
                Class[] v3 = new Class[1];
                v3[0] = Integer.TYPE;
                RuntimeException v0_0 = v0_2.getMethod("setHandshakeTimeout", v3);
                String v1_0 = new Object[1];
                v1_0[0] = Integer.valueOf(p7);
                v0_0.invoke(p6, v1_0);
            } catch (NoSuchMethodException v7_2) {
                String v6_2 = String.valueOf(p6.getClass());
                StringBuilder v2_1 = new StringBuilder((String.valueOf(v6_2).length() + 45));
                v2_1.append(v6_2);
                v2_1.append(" does not implement setSocketHandshakeTimeout");
                throw new IllegalArgumentException(v2_1.toString(), v7_2);
            } catch (NoSuchMethodException v7_3) {
                RuntimeException v0_4 = v7_3.getCause();
                if (!(v0_4 instanceof RuntimeException)) {
                    String v6_6 = String.valueOf(p6.getClass());
                    StringBuilder v2_4 = new StringBuilder((String.valueOf(v6_6).length() + 46));
                    v2_4.append("Failed to invoke setSocketHandshakeTimeout on ");
                    v2_4.append(v6_6);
                    throw new RuntimeException(v2_4.toString(), v7_3);
                } else {
                    throw ((RuntimeException) v0_4);
                }
            }
        }
        return;
    }

Method com.google.android.exoplayer2.util.Util.getPhysicalDisplaySize() calling method java.lang.reflect.Method.invoke()


    public static android.graphics.Point getPhysicalDisplaySize(android.content.Context p7, android.view.Display p8)
    {
        if ((com.google.android.exoplayer2.util.Util.SDK_INT < 25) && (p8.getDisplayId() == 0)) {
            if ((!"Sony".equals(com.google.android.exoplayer2.util.Util.MANUFACTURER)) || ((!com.google.android.exoplayer2.util.Util.MODEL.startsWith("BRAVIA")) || (!p7.getPackageManager().hasSystemFeature("com.sony.dtv.hardware.panel.qfhd")))) {
                if ((("NVIDIA".equals(com.google.android.exoplayer2.util.Util.MANUFACTURER)) && (com.google.android.exoplayer2.util.Util.MODEL.contains("SHIELD"))) || (("philips".equals(com.google.android.exoplayer2.util.Util.toLowerInvariant(com.google.android.exoplayer2.util.Util.MANUFACTURER))) && ((com.google.android.exoplayer2.util.Util.MODEL.startsWith("QM1")) || ((com.google.android.exoplayer2.util.Util.MODEL.equals("QV151E")) || (com.google.android.exoplayer2.util.Util.MODEL.equals("TPM171E")))))) {
                    try {
                        String v3_2 = Class.forName("android.os.SystemProperties");
                        int v5_0 = new Class[1];
                        v5_0[0] = String;
                        android.graphics.Point v4_3 = v3_2.getMethod("get", v5_0);
                        int v5_1 = new Object[1];
                        v5_1[0] = "sys.display-size";
                        boolean v0_23 = ((String) v4_3.invoke(v3_2, v5_1));
                    } catch (String v3_3) {
                        android.util.Log.e("Util", "Failed to read sys.display-size", v3_3);
                    }
                    if (!android.text.TextUtils.isEmpty(v0_23)) {
                        try {
                            String v3_6 = com.google.android.exoplayer2.util.Util.split(v0_23.trim(), "x");
                        } catch (String v1) {
                            String v2_9 = new StringBuilder();
                            v2_9.append("Invalid sys.display-size: ");
                            v2_9.append(v0_23);
                            android.util.Log.e("Util", v2_9.toString());
                        }
                        if (v3_6.length != 2) {
                        } else {
                            String v1_17 = Integer.parseInt(v3_6[0]);
                            String v2_7 = Integer.parseInt(v3_6[1]);
                            if ((v1_17 <= null) || (v2_7 <= null)) {
                            } else {
                                return new android.graphics.Point(v1_17, v2_7);
                            }
                        }
                    }
                }
            } else {
                return new android.graphics.Point(3840, 2160);
            }
        }
        boolean v0_2 = new android.graphics.Point();
        if (com.google.android.exoplayer2.util.Util.SDK_INT < 23) {
            if (com.google.android.exoplayer2.util.Util.SDK_INT < 17) {
                if (com.google.android.exoplayer2.util.Util.SDK_INT < 16) {
                    com.google.android.exoplayer2.util.Util.getDisplaySizeV9(p8, v0_2);
                } else {
                    com.google.android.exoplayer2.util.Util.getDisplaySizeV16(p8, v0_2);
                }
            } else {
                com.google.android.exoplayer2.util.Util.getDisplaySizeV17(p8, v0_2);
            }
        } else {
            com.google.android.exoplayer2.util.Util.getDisplaySizeV23(p8, v0_2);
        }
        return v0_2;
    }

Method com.google.android.exoplayer2.audio.AudioTrackPositionTracker.maybeUpdateLatency() calling method java.lang.reflect.Method.invoke()


    private void maybeUpdateLatency(long p8)
    {
        if ((this.isOutputPcm) && ((this.getLatencyMethod != null) && ((p8 - this.lastLatencySampleTimeUs) >= 500000))) {
            try {
                this.latencyUs = ((((long) ((Integer) this.getLatencyMethod.invoke(this.audioTrack, ((Object[]) 0))).intValue()) * 1000) - this.bufferSizeUs);
                this.latencyUs = Math.max(this.latencyUs, 0);
            } catch (com.google.android.exoplayer2.audio.AudioTrackPositionTracker$Listener v1) {
                this.getLatencyMethod = 0;
                this.lastLatencySampleTimeUs = p8;
            }
            if (this.latencyUs <= 5000000) {
            } else {
                this.listener.onInvalidLatency(this.latencyUs);
                this.latencyUs = 0;
            }
        }
        return;
    }

Method androidx.versionedparcelable.VersionedParcel.writeToParcel() calling method java.lang.reflect.Method.invoke()


    protected static void writeToParcel(androidx.versionedparcelable.VersionedParcelable p7, androidx.versionedparcelable.VersionedParcel p8)
    {
        try {
            ClassNotFoundException v0_0 = androidx.versionedparcelable.VersionedParcel.findParcelClass(p7);
            int v3_1 = new Class[2];
            v3_1[0] = p7.getClass();
            v3_1[1] = androidx.versionedparcelable.VersionedParcel;
            RuntimeException v1_0 = v0_0.getDeclaredMethod("write", v3_1);
            String v2_0 = new Object[2];
            v2_0[0] = p7;
            v2_0[1] = p8;
            v1_0.invoke(0, v2_0);
            return;
        } catch (ClassNotFoundException v0_4) {
            throw new RuntimeException("VersionedParcel encountered IllegalAccessException", v0_4);
        } catch (ClassNotFoundException v0_2) {
            throw new RuntimeException("VersionedParcel encountered NoSuchMethodException", v0_2);
        } catch (ClassNotFoundException v0_1) {
            throw new RuntimeException("VersionedParcel encountered ClassNotFoundException", v0_1);
        } catch (ClassNotFoundException v0_3) {
            if (!(v0_3.getCause() instanceof RuntimeException)) {
                throw new RuntimeException("VersionedParcel encountered InvocationTargetException", v0_3);
            } else {
                throw ((RuntimeException) v0_3.getCause());
            }
        }
    }

Method androidx.versionedparcelable.VersionedParcel.readFromParcel() calling method java.lang.reflect.Method.invoke()


    protected static androidx.versionedparcelable.VersionedParcelable readFromParcel(String p6, androidx.versionedparcelable.VersionedParcel p7)
    {
        try {
            ClassNotFoundException v0_6 = Class.forName(p6, 1, androidx.versionedparcelable.VersionedParcel.getClassLoader());
            int v3_1 = new Class[1];
            v3_1[0] = androidx.versionedparcelable.VersionedParcel;
            String v2_0 = v0_6.getDeclaredMethod("read", v3_1);
            RuntimeException v1_0 = new Object[1];
            v1_0[0] = p7;
            return ((androidx.versionedparcelable.VersionedParcelable) v2_0.invoke(0, v1_0));
        } catch (ClassNotFoundException v0_5) {
            throw new RuntimeException("VersionedParcel encountered IllegalAccessException", v0_5);
        } catch (ClassNotFoundException v0_3) {
            throw new RuntimeException("VersionedParcel encountered NoSuchMethodException", v0_3);
        } catch (ClassNotFoundException v0_2) {
            throw new RuntimeException("VersionedParcel encountered ClassNotFoundException", v0_2);
        } catch (ClassNotFoundException v0_4) {
            if (!(v0_4.getCause() instanceof RuntimeException)) {
                throw new RuntimeException("VersionedParcel encountered InvocationTargetException", v0_4);
            } else {
                throw ((RuntimeException) v0_4.getCause());
            }
        }
    }

Method android.support.v7.widget.ViewUtils.makeOptionalFitsSystemWindows() calling method java.lang.reflect.Method.invoke()


    public static void makeOptionalFitsSystemWindows(android.view.View p4)
    {
        if (android.os.Build$VERSION.SDK_INT >= 16) {
            try {
                Class[] v3 = new Class[0];
                IllegalAccessException v0_4 = p4.getClass().getMethod("makeOptionalFitsSystemWindows", v3);
            } catch (IllegalAccessException v0) {
                android.util.Log.d("ViewUtils", "Could not find method makeOptionalFitsSystemWindows. Oh well...");
            } catch (IllegalAccessException v0_2) {
                android.util.Log.d("ViewUtils", "Could not invoke makeOptionalFitsSystemWindows", v0_2);
            } catch (IllegalAccessException v0_1) {
                android.util.Log.d("ViewUtils", "Could not invoke makeOptionalFitsSystemWindows", v0_1);
            }
            if (!v0_4.isAccessible()) {
                v0_4.setAccessible(1);
            }
            Object[] v1_6 = new Object[0];
            v0_4.invoke(p4, v1_6);
        }
        return;
    }

Method android.support.v7.widget.ViewUtils.computeFitSystemWindows() calling method java.lang.reflect.Method.invoke()


    public static void computeFitSystemWindows(android.view.View p3, android.graphics.Rect p4, android.graphics.Rect p5)
    {
        if (android.support.v7.widget.ViewUtils.sComputeFitSystemWindowsMethod != null) {
            try {
                String v1_2 = new Object[2];
                v1_2[0] = p4;
                v1_2[1] = p5;
                android.support.v7.widget.ViewUtils.sComputeFitSystemWindowsMethod.invoke(p3, v1_2);
            } catch (Exception v0_1) {
                android.util.Log.d("ViewUtils", "Could not invoke computeFitSystemWindows", v0_1);
            }
        }
        return;
    }

Method android.support.v7.widget.SearchView$AutoCompleteTextViewReflector.ensureImeVisible() calling method java.lang.reflect.Method.invoke()


    void ensureImeVisible(android.widget.AutoCompleteTextView p5, boolean p6)
    {
        if (this.ensureImeVisible != null) {
            try {
                Exception v0_1 = this.ensureImeVisible;
                Object[] v1_1 = new Object[1];
                v1_1[0] = Boolean.valueOf(p6);
                v0_1.invoke(p5, v1_1);
            } catch (Exception v0) {
            }
        }
        return;
    }

Method android.support.v7.widget.SearchView$AutoCompleteTextViewReflector.doBeforeTextChanged() calling method java.lang.reflect.Method.invoke()


    void doBeforeTextChanged(android.widget.AutoCompleteTextView p3)
    {
        if (this.doBeforeTextChanged != null) {
            try {
                Object[] v1_1 = new Object[0];
                this.doBeforeTextChanged.invoke(p3, v1_1);
            } catch (Exception v0) {
            }
        }
        return;
    }

Method android.support.v7.widget.SearchView$AutoCompleteTextViewReflector.doAfterTextChanged() calling method java.lang.reflect.Method.invoke()


    void doAfterTextChanged(android.widget.AutoCompleteTextView p3)
    {
        if (this.doAfterTextChanged != null) {
            try {
                Object[] v1_1 = new Object[0];
                this.doAfterTextChanged.invoke(p3, v1_1);
            } catch (Exception v0) {
            }
        }
        return;
    }

Method android.support.v7.widget.DrawableUtils.getOpticalBounds() calling method java.lang.reflect.Method.invoke()


    public static android.graphics.Rect getOpticalBounds(android.graphics.drawable.Drawable p12)
    {
        if (android.support.v7.widget.DrawableUtils.sInsetsClazz != null) {
            try {
                android.graphics.drawable.Drawable v12_1 = android.support.v4.graphics.drawable.DrawableCompat.unwrap(p12);
                android.graphics.Rect v3_2 = new Class[0];
                String v1_0 = new Object[0];
                String v1_1 = v12_1.getClass().getMethod("getOpticalInsets", v3_2).invoke(v12_1, v1_0);
            } catch (Exception v0) {
                android.util.Log.e("DrawableUtils", "Couldn\'t obtain the optical insets. Ignoring.");
            }
            if (v1_1 != null) {
                android.graphics.Rect v3_1 = new android.graphics.Rect();
                reflect.Field[] v4_1 = android.support.v7.widget.DrawableUtils.sInsetsClazz.getFields();
                int v5 = v4_1.length;
                int v6 = 0;
                while (v6 < v5) {
                    int v8_2;
                    reflect.Field v7 = v4_1[v6];
                    int v8_0 = v7.getName();
                    String v10_0 = v8_0.hashCode();
                    if (v10_0 == -1383228885) {
                        if (!v8_0.equals("bottom")) {
                            v8_2 = -1;
                        } else {
                            v8_2 = 3;
                        }
                    } else {
                        if (v10_0 == 115029) {
                            if (!v8_0.equals("top")) {
                            } else {
                                v8_2 = 1;
                            }
                        } else {
                            if (v10_0 == 3317767) {
                                if (!v8_0.equals("left")) {
                                } else {
                                    v8_2 = 0;
                                }
                            } else {
                                if (v10_0 == 108511772) {
                                    if (!v8_0.equals("right")) {
                                    } else {
                                        v8_2 = 2;
                                    }
                                } else {
                                }
                            }
                        }
                    }
                    switch (v8_2) {
                        case 0:
                            v3_1.left = v7.getInt(v1_1);
                            break;
                        case 1:
                            v3_1.top = v7.getInt(v1_1);
                            break;
                        case 2:
                            v3_1.right = v7.getInt(v1_1);
                            break;
                        case 3:
                            v3_1.bottom = v7.getInt(v1_1);
                            break;
                        default:
                    }
                    v6++;
                }
                return v3_1;
            }
        }
        return android.support.v7.widget.DrawableUtils.INSETS_NONE;
    }

Method android.support.v7.widget.AppCompatTextViewAutoSizeHelper.setRawTextSize() calling method java.lang.reflect.Method.invoke()


    private void setRawTextSize(float p6)
    {
        if (p6 != this.mTextView.getPaint().getTextSize()) {
            this.mTextView.getPaint().setTextSize(p6);
            boolean v0_1 = 0;
            if (android.os.Build$VERSION.SDK_INT >= 18) {
                v0_1 = this.mTextView.isInLayout();
            }
            if (this.mTextView.getLayout() != null) {
                this.mNeedsAutoSizeText = 0;
                try {
                    String v3_1 = this.getTextViewMethod("nullLayouts");
                } catch (android.widget.TextView v1_6) {
                    android.util.Log.w("ACTVAutoSizeHelper", "Failed to invoke TextView#nullLayouts() method", v1_6);
                    if (v0_1) {
                        this.mTextView.forceLayout();
                    } else {
                        this.mTextView.requestLayout();
                    }
                    this.mTextView.invalidate();
                }
                if (v3_1 == null) {
                } else {
                    android.widget.TextView v1_5 = new Object[0];
                    v3_1.invoke(this.mTextView, v1_5);
                }
            }
        }
        return;
    }

Method android.support.v7.widget.AppCompatTextViewAutoSizeHelper.invokeAndReturnWithDefault() calling method java.lang.reflect.Method.invoke()


    private Object invokeAndReturnWithDefault(Object p7, String p8, Object p9)
    {
        int v2 = 0;
        try {
            Exception v1_3 = new Object[0];
            Object v0 = this.getTextViewMethod(p8).invoke(p7, v1_3);
        } catch (Exception v1_2) {
            if (v0 == null) {
                // Both branches of the condition point to the same code.
                // if (v2 == 0) {
                // }
            }
            throw v1_2;
        } catch (Exception v1_1) {
            v2 = 1;
            String v4_1 = new StringBuilder();
            v4_1.append("Failed to invoke TextView#");
            v4_1.append(p8);
            v4_1.append("() method");
            android.util.Log.w("ACTVAutoSizeHelper", v4_1.toString(), v1_1);
            if (v0 != null) {
                return v0;
            } else {
                if (1 == 0) {
                    return v0;
                } else {
                    v0 = p9;
                    return v0;
                }
            }
        }
        if ((v0 != null) || (0 == 0)) {
            return v0;
        } else {
        }
    }

Method android.support.v7.view.SupportMenuInflater$InflatedOnMenuItemClickListener.onMenuItemClick() calling method java.lang.reflect.Method.invoke()


    public boolean onMenuItemClick(android.view.MenuItem p6)
    {
        try {
            if (this.mMethod.getReturnType() != Boolean.TYPE) {
                reflect.Method v0_7 = this.mMethod;
                Object v1_4 = this.mRealOwner;
                Object[] v4 = new Object[1];
                v4[0] = p6;
                v0_7.invoke(v1_4, v4);
                return 1;
            } else {
                reflect.Method v0_1 = this.mMethod;
                Object v1_0 = this.mRealOwner;
                Object[] v3_0 = new Object[1];
                v3_0[0] = p6;
                return ((Boolean) v0_1.invoke(v1_0, v3_0)).booleanValue();
            }
        } catch (reflect.Method v0_6) {
            throw new RuntimeException(v0_6);
        }
    }

Method android.support.v7.app.AppCompatViewInflater$DeclaredOnClickListener.onClick() calling method java.lang.reflect.Method.invoke()


    public void onClick(android.view.View p5)
    {
        if (this.mResolvedMethod == null) {
            this.resolveMethod(this.mHostView.getContext(), this.mMethodName);
        }
        try {
            reflect.InvocationTargetException v0_5 = this.mResolvedMethod;
            IllegalStateException v1_5 = this.mResolvedContext;
            String v2_0 = new Object[1];
            v2_0[0] = p5;
            v0_5.invoke(v1_5, v2_0);
            return;
        } catch (reflect.InvocationTargetException v0_3) {
            throw new IllegalStateException("Could not execute non-public method for android:onClick", v0_3);
        } catch (reflect.InvocationTargetException v0_1) {
            throw new IllegalStateException("Could not execute method for android:onClick", v0_1);
        }
    }

Method android.support.v7.app.ActionBarDrawerToggleHoneycomb.setActionBarUpIndicator() calling method java.lang.reflect.Method.invoke()


    public static android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo setActionBarUpIndicator(android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo p5, android.app.Activity p6, android.graphics.drawable.Drawable p7, int p8)
    {
        p5 = new android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo(p6);
        if (p5.setHomeAsUpIndicator == null) {
            if (p5.upIndicatorView == null) {
                android.util.Log.w("ActionBarDrawerToggleHC", "Couldn\'t set home-as-up indicator");
            } else {
                p5.upIndicatorView.setImageDrawable(p7);
            }
        } else {
            try {
                String v0_3 = p6.getActionBar();
                String v1_0 = p5.setHomeAsUpIndicator;
                Integer v3_0 = new Object[1];
                v3_0[0] = p7;
                v1_0.invoke(v0_3, v3_0);
                String v1_1 = p5.setHomeActionContentDescription;
                String v2_1 = new Object[1];
                v2_1[0] = Integer.valueOf(p8);
                v1_1.invoke(v0_3, v2_1);
            } catch (String v0_4) {
                android.util.Log.w("ActionBarDrawerToggleHC", "Couldn\'t set home-as-up indicator via JB-MR2 API", v0_4);
            }
        }
        return p5;
    }

Method android.support.v7.app.ActionBarDrawerToggleHoneycomb.setActionBarDescription() calling method java.lang.reflect.Method.invoke()


    public static android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo setActionBarDescription(android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo p5, android.app.Activity p6, int p7)
    {
        if (p5 == null) {
            p5 = new android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo(p6);
        }
        if (p5.setHomeAsUpIndicator != null) {
            try {
                Exception v0_4 = p6.getActionBar();
                CharSequence v1_3 = p5.setHomeActionContentDescription;
                String v2_0 = new Object[1];
                v2_0[0] = Integer.valueOf(p7);
                v1_3.invoke(v0_4, v2_0);
            } catch (Exception v0_2) {
                android.util.Log.w("ActionBarDrawerToggleHC", "Couldn\'t set content description via JB-MR2 API", v0_2);
            }
            if (android.os.Build$VERSION.SDK_INT <= 19) {
                v0_4.setSubtitle(v0_4.getSubtitle());
            }
        }
        return p5;
    }

Method android.support.v4.widget.TextViewCompat$OreoCallback.recomputeProcessTextMenuItems() calling method java.lang.reflect.Method.invoke()


    private void recomputeProcessTextMenuItems(android.view.Menu p10)
    {
        android.content.Context v0_1 = this.mTextView.getContext();
        android.content.pm.PackageManager v1 = v0_1.getPackageManager();
        if (!this.mInitializedMenuBuilderReferences) {
            this.mInitializedMenuBuilderReferences = 1;
            try {
                this.mMenuBuilderClass = Class.forName("com.android.internal.view.menu.MenuBuilder");
                java.util.List v2_2 = this.mMenuBuilderClass;
                android.content.pm.ResolveInfo v6_0 = new Class[1];
                v6_0[0] = Integer.TYPE;
                this.mMenuBuilderRemoveItemAtMethod = v2_2.getDeclaredMethod("removeItemAt", v6_0);
                this.mCanUseMenuBuilderReferences = 1;
            } catch (java.util.List v2) {
                this.mMenuBuilderClass = 0;
                this.mMenuBuilderRemoveItemAtMethod = 0;
                this.mCanUseMenuBuilderReferences = 0;
            }
        }
        try {
            if ((!this.mCanUseMenuBuilderReferences) || (!this.mMenuBuilderClass.isInstance(p10))) {
                java.util.List v2_7 = p10.getClass();
                android.content.pm.ResolveInfo v6_1 = new Class[1];
                v6_1[0] = Integer.TYPE;
                java.util.List v2_8 = v2_7.getDeclaredMethod("removeItemAt", v6_1);
            } else {
                v2_8 = this.mMenuBuilderRemoveItemAtMethod;
            }
        } catch (java.util.List v2) {
            return;
        }
        int v5_4 = (p10.size() - 1);
        while (v5_4 >= 0) {
            android.content.pm.ResolveInfo v6_5 = p10.getItem(v5_4);
            if ((v6_5.getIntent() != null) && ("android.intent.action.PROCESS_TEXT".equals(v6_5.getIntent().getAction()))) {
                android.view.MenuItem v7_8 = new Object[1];
                v7_8[0] = Integer.valueOf(v5_4);
                v2_8.invoke(p10, v7_8);
            }
            v5_4--;
        }
        java.util.List v2_10 = this.getSupportedActivities(v0_1, v1);
        int v5_5 = 0;
        while (v5_5 < v2_10.size()) {
            android.content.pm.ResolveInfo v6_4 = ((android.content.pm.ResolveInfo) v2_10.get(v5_5));
            p10.add(0, 0, (v5_5 + 100), v6_4.loadLabel(v1)).setIntent(this.createProcessTextIntentForResolveInfo(v6_4, this.mTextView)).setShowAsAction(1);
            v5_5++;
        }
        return;
    }

Method android.support.v4.widget.SlidingPaneLayout.invalidateChildRegion() calling method java.lang.reflect.Method.invoke()


    void invalidateChildRegion(android.view.View p6)
    {
        if (android.os.Build$VERSION.SDK_INT < 17) {
            if (android.os.Build$VERSION.SDK_INT >= 16) {
                if (!this.mDisplayListReflectionLoaded) {
                    try {
                        this.mGetDisplayList = android.view.View.getDeclaredMethod("getDisplayList", ((Class[]) 0));
                        try {
                            this.mRecreateDisplayList = android.view.View.getDeclaredField("mRecreateDisplayList");
                            this.mRecreateDisplayList.setAccessible(1);
                        } catch (Exception v0_7) {
                            android.util.Log.e("SlidingPaneLayout", "Couldn\'t fetch mRecreateDisplayList field; dimming will be slow.", v0_7);
                        }
                        this.mDisplayListReflectionLoaded = 1;
                    } catch (Exception v0_3) {
                        android.util.Log.e("SlidingPaneLayout", "Couldn\'t fetch getDisplayList method; dimming won\'t work right.", v0_3);
                    }
                }
                if ((this.mGetDisplayList != null) && (this.mRecreateDisplayList != null)) {
                    try {
                        this.mRecreateDisplayList.setBoolean(p6, 1);
                        this.mGetDisplayList.invoke(p6, ((Object[]) 0));
                    } catch (Exception v0_13) {
                        android.util.Log.e("SlidingPaneLayout", "Error refreshing display list state", v0_13);
                    }
                } else {
                    p6.invalidate();
                    return;
                }
            }
            android.support.v4.view.ViewCompat.postInvalidateOnAnimation(this, p6.getLeft(), p6.getTop(), p6.getRight(), p6.getBottom());
            return;
        } else {
            android.support.v4.view.ViewCompat.setLayerPaint(p6, ((android.support.v4.widget.SlidingPaneLayout$LayoutParams) p6.getLayoutParams()).dimPaint);
            return;
        }
    }

Method android.support.v4.widget.PopupWindowCompat.setWindowLayoutType() calling method java.lang.reflect.Method.invoke()


    public static void setWindowLayoutType(android.widget.PopupWindow p6, int p7)
    {
        if (android.os.Build$VERSION.SDK_INT < 23) {
            if (!android.support.v4.widget.PopupWindowCompat.sSetWindowLayoutTypeMethodAttempted) {
                try {
                    Class[] v4 = new Class[1];
                    v4[0] = Integer.TYPE;
                    android.support.v4.widget.PopupWindowCompat.sSetWindowLayoutTypeMethod = android.widget.PopupWindow.getDeclaredMethod("setWindowLayoutType", v4);
                    android.support.v4.widget.PopupWindowCompat.sSetWindowLayoutTypeMethod.setAccessible(1);
                } catch (Exception v0) {
                }
                android.support.v4.widget.PopupWindowCompat.sSetWindowLayoutTypeMethodAttempted = 1;
            }
            if (android.support.v4.widget.PopupWindowCompat.sSetWindowLayoutTypeMethod != null) {
                try {
                    Object[] v2_0 = new Object[1];
                    v2_0[0] = Integer.valueOf(p7);
                    android.support.v4.widget.PopupWindowCompat.sSetWindowLayoutTypeMethod.invoke(p6, v2_0);
                } catch (Exception v0) {
                }
            }
            return;
        } else {
            p6.setWindowLayoutType(p7);
            return;
        }
    }

Method android.support.v4.widget.PopupWindowCompat.getWindowLayoutType() calling method java.lang.reflect.Method.invoke()


    public static int getWindowLayoutType(android.widget.PopupWindow p5)
    {
        if (android.os.Build$VERSION.SDK_INT < 23) {
            if (!android.support.v4.widget.PopupWindowCompat.sGetWindowLayoutTypeMethodAttempted) {
                try {
                    Class[] v4 = new Class[0];
                    android.support.v4.widget.PopupWindowCompat.sGetWindowLayoutTypeMethod = android.widget.PopupWindow.getDeclaredMethod("getWindowLayoutType", v4);
                    android.support.v4.widget.PopupWindowCompat.sGetWindowLayoutTypeMethod.setAccessible(1);
                } catch (Exception v2) {
                }
                android.support.v4.widget.PopupWindowCompat.sGetWindowLayoutTypeMethodAttempted = 1;
            }
            if (android.support.v4.widget.PopupWindowCompat.sGetWindowLayoutTypeMethod != null) {
                try {
                    Exception v2_2 = new Object[0];
                    return ((Integer) android.support.v4.widget.PopupWindowCompat.sGetWindowLayoutTypeMethod.invoke(p5, v2_2)).intValue();
                } catch (Exception v0) {
                }
            }
            return 0;
        } else {
            return p5.getWindowLayoutType();
        }
    }

Method android.support.v4.view.ViewConfigurationCompat.getLegacyScrollFactor() calling method java.lang.reflect.Method.invoke()


    private static float getLegacyScrollFactor(android.view.ViewConfiguration p4, android.content.Context p5)
    {
        if ((android.os.Build$VERSION.SDK_INT >= 25) && (android.support.v4.view.ViewConfigurationCompat.sGetScaledScrollFactorMethod != null)) {
            try {
                String v1_9 = new Object[0];
                return ((float) ((Integer) android.support.v4.view.ViewConfigurationCompat.sGetScaledScrollFactorMethod.invoke(p4, v1_9)).intValue());
            } catch (Exception v0) {
                android.util.Log.i("ViewConfigCompat", "Could not find method getScaledScrollFactor() on ViewConfiguration");
            }
        }
        Exception v0_5 = new android.util.TypedValue();
        if (!p5.getTheme().resolveAttribute(16842829, v0_5, 1)) {
            return 0;
        } else {
            return v0_5.getDimension(p5.getResources().getDisplayMetrics());
        }
    }

Method android.support.v4.view.ViewCompat.setChildrenDrawingOrderEnabled() calling method java.lang.reflect.Method.invoke()


    public static void setChildrenDrawingOrderEnabled(android.view.ViewGroup p6, boolean p7)
    {
        if (android.support.v4.view.ViewCompat.sChildrenDrawingOrderMethod == null) {
            try {
                String v4_1 = new Class[1];
                v4_1[0] = Boolean.TYPE;
                android.support.v4.view.ViewCompat.sChildrenDrawingOrderMethod = android.view.ViewGroup.getDeclaredMethod("setChildrenDrawingOrderEnabled", v4_1);
            } catch (reflect.InvocationTargetException v0_2) {
                android.util.Log.e("ViewCompat", "Unable to find childrenDrawingOrderEnabled", v0_2);
            }
            android.support.v4.view.ViewCompat.sChildrenDrawingOrderMethod.setAccessible(1);
        }
        try {
            String v2_0 = new Object[1];
            v2_0[0] = Boolean.valueOf(p7);
            android.support.v4.view.ViewCompat.sChildrenDrawingOrderMethod.invoke(p6, v2_0);
        } catch (reflect.InvocationTargetException v0_7) {
            android.util.Log.e("ViewCompat", "Unable to invoke childrenDrawingOrderEnabled", v0_7);
        } catch (reflect.InvocationTargetException v0_6) {
            android.util.Log.e("ViewCompat", "Unable to invoke childrenDrawingOrderEnabled", v0_6);
        } catch (reflect.InvocationTargetException v0_5) {
            android.util.Log.e("ViewCompat", "Unable to invoke childrenDrawingOrderEnabled", v0_5);
            return;
        }
        return;
    }

Method android.support.v4.view.ViewCompat.dispatchStartTemporaryDetach() calling method java.lang.reflect.Method.invoke()


    public static void dispatchStartTemporaryDetach(android.view.View p3)
    {
        if (android.os.Build$VERSION.SDK_INT < 24) {
            if (!android.support.v4.view.ViewCompat.sTempDetachBound) {
                android.support.v4.view.ViewCompat.bindTempDetach();
            }
            if (android.support.v4.view.ViewCompat.sDispatchStartTemporaryDetach == null) {
                p3.onStartTemporaryDetach();
            } else {
                try {
                    String v1_2 = new Object[0];
                    android.support.v4.view.ViewCompat.sDispatchStartTemporaryDetach.invoke(p3, v1_2);
                } catch (Exception v0_1) {
                    android.util.Log.d("ViewCompat", "Error calling dispatchStartTemporaryDetach", v0_1);
                }
            }
        } else {
            p3.dispatchStartTemporaryDetach();
        }
        return;
    }

Method android.support.v4.view.ViewCompat.dispatchFinishTemporaryDetach() calling method java.lang.reflect.Method.invoke()


    public static void dispatchFinishTemporaryDetach(android.view.View p3)
    {
        if (android.os.Build$VERSION.SDK_INT < 24) {
            if (!android.support.v4.view.ViewCompat.sTempDetachBound) {
                android.support.v4.view.ViewCompat.bindTempDetach();
            }
            if (android.support.v4.view.ViewCompat.sDispatchFinishTemporaryDetach == null) {
                p3.onFinishTemporaryDetach();
            } else {
                try {
                    String v1_2 = new Object[0];
                    android.support.v4.view.ViewCompat.sDispatchFinishTemporaryDetach.invoke(p3, v1_2);
                } catch (Exception v0_1) {
                    android.util.Log.d("ViewCompat", "Error calling dispatchFinishTemporaryDetach", v0_1);
                }
            }
        } else {
            p3.dispatchFinishTemporaryDetach();
        }
        return;
    }

Method android.support.v4.view.KeyEventDispatcher.actionBarOnMenuKeyEventPre28() calling method java.lang.reflect.Method.invoke()


    private static boolean actionBarOnMenuKeyEventPre28(android.app.ActionBar p6, android.view.KeyEvent p7)
    {
        if (!android.support.v4.view.KeyEventDispatcher.sActionBarFieldsFetched) {
            try {
                reflect.InvocationTargetException v0_7 = p6.getClass();
                Class[] v4 = new Class[1];
                v4[0] = android.view.KeyEvent;
                android.support.v4.view.KeyEventDispatcher.sActionBarOnMenuKeyMethod = v0_7.getMethod("onMenuKeyEvent", v4);
            } catch (reflect.InvocationTargetException v0) {
            }
            android.support.v4.view.KeyEventDispatcher.sActionBarFieldsFetched = 1;
        }
        if (android.support.v4.view.KeyEventDispatcher.sActionBarOnMenuKeyMethod != null) {
            try {
                Object[] v1_1 = new Object[1];
                v1_1[0] = p7;
                return ((Boolean) android.support.v4.view.KeyEventDispatcher.sActionBarOnMenuKeyMethod.invoke(p6, v1_1)).booleanValue();
            } catch (reflect.InvocationTargetException v0) {
            } catch (reflect.InvocationTargetException v0) {
            }
        }
        return 0;
    }

Method android.support.v4.text.ICUCompat.maximizeAndGetScript() calling method java.lang.reflect.Method.invoke()


    public static String maximizeAndGetScript(java.util.Locale p3)
    {
        if (android.os.Build$VERSION.SDK_INT < 21) {
            String v0_6 = android.support.v4.text.ICUCompat.addLikelySubtags(p3);
            if (v0_6 == null) {
                return 0;
            } else {
                return android.support.v4.text.ICUCompat.getScript(v0_6);
            }
        } else {
            try {
                String v0_2 = new Object[1];
                v0_2[0] = p3;
                return ((java.util.Locale) android.support.v4.text.ICUCompat.sAddLikelySubtagsMethod.invoke(0, v0_2)).getScript();
            } catch (String v0_4) {
                android.util.Log.w("ICUCompat", v0_4);
                return p3.getScript();
            } catch (String v0_3) {
                android.util.Log.w("ICUCompat", v0_3);
                return p3.getScript();
            }
        }
    }

Method android.support.v4.text.ICUCompat.getScript() calling method java.lang.reflect.Method.invoke()


    private static String getScript(String p3)
    {
        try {
            if (android.support.v4.text.ICUCompat.sGetScriptMethod == null) {
            } else {
                Object[] v1_2 = new Object[1];
                v1_2[0] = p3;
                return ((String) android.support.v4.text.ICUCompat.sGetScriptMethod.invoke(0, v1_2));
            }
        } catch (Object[] v1_4) {
            android.util.Log.w("ICUCompat", v1_4);
        } catch (Object[] v1_3) {
            android.util.Log.w("ICUCompat", v1_3);
        }
        return 0;
    }

Method android.support.v4.text.ICUCompat.addLikelySubtags() calling method java.lang.reflect.Method.invoke()


    private static String addLikelySubtags(java.util.Locale p4)
    {
        String v0 = p4.toString();
        try {
            if (android.support.v4.text.ICUCompat.sAddLikelySubtagsMethod == null) {
            } else {
                Object[] v1_1 = new Object[1];
                v1_1[0] = v0;
                return ((String) android.support.v4.text.ICUCompat.sAddLikelySubtagsMethod.invoke(0, v1_1));
            }
        } catch (Object[] v1_4) {
            android.util.Log.w("ICUCompat", v1_4);
        } catch (Object[] v1_3) {
            android.util.Log.w("ICUCompat", v1_3);
        }
        return v0;
    }