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 org.spongycastle.jcajce.provider.symmetric.GcmSpecUtil.extractGcmParameters() calling method java.lang.reflect.Method.invoke()


    static org.spongycastle.asn1.cms.GCMParameters extractGcmParameters(java.security.spec.AlgorithmParameterSpec p6)
    {
        try {
            org.spongycastle.asn1.cms.GCMParameters v5_3 = new Class[0];
            org.spongycastle.asn1.cms.GCMParameters v5_5 = new Class[0];
            java.security.spec.InvalidParameterSpecException v3_2 = new Object[0];
            String v4_2 = new Object[0];
            return new org.spongycastle.asn1.cms.GCMParameters(((byte[]) ((byte[]) org.spongycastle.jcajce.provider.symmetric.GcmSpecUtil.gcmSpecClass.getDeclaredMethod("getIV", v5_5).invoke(p6, v3_2))), (((Integer) org.spongycastle.jcajce.provider.symmetric.GcmSpecUtil.gcmSpecClass.getDeclaredMethod("getTLen", v5_3).invoke(p6, v4_2)).intValue() / 8));
        } catch (Exception v0) {
            throw new java.security.spec.InvalidParameterSpecException("Cannot process GCMParameterSpec");
        }
    }

Method org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher.engineInit() calling method java.lang.reflect.Method.invoke()


    protected void engineInit(int p23, java.security.Key p24, java.security.spec.AlgorithmParameterSpec p25, java.security.SecureRandom p26)
    {
        this.pbeSpec = 0;
        this.pbeAlgorithm = 0;
        this.engineParams = 0;
        this.aeadParams = 0;
        if ((p24 instanceof javax.crypto.SecretKey)) {
            if ((p25 != null) || (!this.baseEngine.getAlgorithmName().startsWith("RC5-64"))) {
                if ((this.scheme != 2) && (!(p24 instanceof org.spongycastle.jcajce.PKCS12Key))) {
                    if (!(p24 instanceof org.spongycastle.jcajce.PBKDF1Key)) {
                        if (!(p24 instanceof org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey)) {
                            if (!(p24 instanceof javax.crypto.interfaces.PBEKey)) {
                                if ((p24 instanceof org.spongycastle.jcajce.spec.RepeatedSecretKeySpec)) {
                                    org.spongycastle.crypto.params.ParametersWithIV v17_0 = 0;
                                } else {
                                    if ((this.scheme != 0) && ((this.scheme != 4) && ((this.scheme != 1) && (this.scheme != 5)))) {
                                        v17_0 = new org.spongycastle.crypto.params.KeyParameter;
                                        v17_0(p24.getEncoded());
                                    } else {
                                        throw new java.security.InvalidKeyException("Algorithm requires a PBE key");
                                    }
                                }
                            } else {
                                this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p25);
                                if (((((javax.crypto.interfaces.PBEKey) p24) instanceof org.spongycastle.jcajce.PKCS12KeyWithParameters)) && (this.pbeSpec == null)) {
                                    this.pbeSpec = new javax.crypto.spec.PBEParameterSpec(((javax.crypto.interfaces.PBEKey) p24).getSalt(), ((javax.crypto.interfaces.PBEKey) p24).getIterationCount());
                                }
                                v17_0 = org.spongycastle.jcajce.provider.symmetric.util.PBE$Util.makePBEParameters(((javax.crypto.interfaces.PBEKey) p24).getEncoded(), this.scheme, this.digest, this.keySizeInBits, (this.ivLength * 8), this.pbeSpec, this.cipher.getAlgorithmName());
                                if ((v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                                    this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                                }
                            }
                        } else {
                            if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p24).getOID() == null) {
                                this.pbeAlgorithm = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p24).getAlgorithm();
                            } else {
                                this.pbeAlgorithm = ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p24).getOID().getId();
                            }
                            if (((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p24).getParam() == null) {
                                if (!(p25 instanceof javax.crypto.spec.PBEParameterSpec)) {
                                    throw new java.security.InvalidAlgorithmParameterException("PBE requires PBE parameters to be set.");
                                } else {
                                    this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p25);
                                    v17_0 = org.spongycastle.jcajce.provider.symmetric.util.PBE$Util.makePBEParameters(((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p24), p25, this.cipher.getUnderlyingCipher().getAlgorithmName());
                                }
                            } else {
                                v17_0 = this.adjustParameters(p25, ((org.spongycastle.jcajce.provider.symmetric.util.BCPBEKey) p24).getParam());
                            }
                            if ((v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                                this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                            }
                        }
                    } else {
                        if ((p25 instanceof javax.crypto.spec.PBEParameterSpec)) {
                            this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p25);
                        }
                        if (((((org.spongycastle.jcajce.PBKDF1Key) p24) instanceof org.spongycastle.jcajce.PBKDF1KeyWithParameters)) && (this.pbeSpec == null)) {
                            this.pbeSpec = new javax.crypto.spec.PBEParameterSpec(((org.spongycastle.jcajce.PBKDF1KeyWithParameters) ((org.spongycastle.jcajce.PBKDF1Key) p24)).getSalt(), ((org.spongycastle.jcajce.PBKDF1KeyWithParameters) ((org.spongycastle.jcajce.PBKDF1Key) p24)).getIterationCount());
                        }
                        v17_0 = org.spongycastle.jcajce.provider.symmetric.util.PBE$Util.makePBEParameters(((org.spongycastle.jcajce.PBKDF1Key) p24).getEncoded(), 0, this.digest, this.keySizeInBits, (this.ivLength * 8), this.pbeSpec, this.cipher.getAlgorithmName());
                        if ((v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                            this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                        }
                    }
                } else {
                    try {
                        if ((p25 instanceof javax.crypto.spec.PBEParameterSpec)) {
                            this.pbeSpec = ((javax.crypto.spec.PBEParameterSpec) p25);
                        }
                    } catch (Exception v10) {
                        throw new java.security.InvalidKeyException("PKCS12 requires a SecretKey/PBEKey");
                    }
                    if (((((javax.crypto.SecretKey) p24) instanceof javax.crypto.interfaces.PBEKey)) && (this.pbeSpec == null)) {
                        this.pbeSpec = new javax.crypto.spec.PBEParameterSpec(((javax.crypto.interfaces.PBEKey) ((javax.crypto.SecretKey) p24)).getSalt(), ((javax.crypto.interfaces.PBEKey) ((javax.crypto.SecretKey) p24)).getIterationCount());
                    }
                    if ((this.pbeSpec != null) || ((((javax.crypto.SecretKey) p24) instanceof javax.crypto.interfaces.PBEKey))) {
                        v17_0 = org.spongycastle.jcajce.provider.symmetric.util.PBE$Util.makePBEParameters(((javax.crypto.SecretKey) p24).getEncoded(), 2, this.digest, this.keySizeInBits, (this.ivLength * 8), this.pbeSpec, this.cipher.getAlgorithmName());
                        if ((v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                            this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                        }
                    } else {
                        throw new java.security.InvalidKeyException("Algorithm requires a PBE key");
                    }
                }
                if (!(p25 instanceof javax.crypto.spec.IvParameterSpec)) {
                    if (!(p25 instanceof org.spongycastle.jcajce.spec.GOST28147ParameterSpec)) {
                        if (!(p25 instanceof javax.crypto.spec.RC2ParameterSpec)) {
                            if (!(p25 instanceof javax.crypto.spec.RC5ParameterSpec)) {
                                if ((org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher.gcmSpecClass == null) || (!org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher.gcmSpecClass.isInstance(p25))) {
                                    if ((p25 != null) && (!(p25 instanceof javax.crypto.spec.PBEParameterSpec))) {
                                        throw new java.security.InvalidAlgorithmParameterException("unknown parameter type.");
                                    }
                                } else {
                                    if ((this.isAEADModeName(this.modeName)) || ((this.cipher instanceof org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher$AEADGenericBlockCipher))) {
                                        try {
                                            org.spongycastle.crypto.params.KeyParameter v15_0;
                                            String v5_5 = new Class[0];
                                            reflect.Method v21 = org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher.gcmSpecClass.getDeclaredMethod("getTLen", v5_5);
                                            String v5_7 = new Class[0];
                                            byte[] v12_0 = org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher.gcmSpecClass.getDeclaredMethod("getIV", v5_7);
                                        } catch (Exception v10) {
                                            throw new java.security.InvalidAlgorithmParameterException("Cannot process GCMParameterSpec.");
                                        }
                                        if (!(v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                                            v15_0 = ((org.spongycastle.crypto.params.KeyParameter) v17_0);
                                        } else {
                                            v15_0 = ((org.spongycastle.crypto.params.KeyParameter) ((org.spongycastle.crypto.params.ParametersWithIV) v17_0).getParameters());
                                        }
                                        v17_0 = new org.spongycastle.crypto.params.AEADParameters;
                                        org.spongycastle.crypto.params.ParametersWithIV v3_79 = new Object[0];
                                        org.spongycastle.crypto.params.ParametersWithIV v3_83 = new Object[0];
                                        v17_0(v15_0, ((Integer) v21.invoke(p25, v3_79)).intValue(), ((byte[]) ((byte[]) v12_0.invoke(p25, v3_83))));
                                        this.aeadParams = v17_0;
                                    } else {
                                        throw new java.security.InvalidAlgorithmParameterException("GCMParameterSpec can only be used with AEAD modes.");
                                    }
                                }
                            } else {
                                v17_0 = new org.spongycastle.crypto.params.RC5Parameters;
                                v17_0(p24.getEncoded(), ((javax.crypto.spec.RC5ParameterSpec) p25).getRounds());
                                if (!this.baseEngine.getAlgorithmName().startsWith("RC5")) {
                                    throw new java.security.InvalidAlgorithmParameterException("RC5 parameters passed to a cipher that is not RC5.");
                                } else {
                                    if (!this.baseEngine.getAlgorithmName().equals("RC5-32")) {
                                        if ((this.baseEngine.getAlgorithmName().equals("RC5-64")) && (((javax.crypto.spec.RC5ParameterSpec) p25).getWordSize() != 64)) {
                                            throw new java.security.InvalidAlgorithmParameterException(new StringBuilder().append("RC5 already set up for a word size of 64 not ").append(((javax.crypto.spec.RC5ParameterSpec) p25).getWordSize()).append(".").toString());
                                        }
                                    } else {
                                        if (((javax.crypto.spec.RC5ParameterSpec) p25).getWordSize() != 32) {
                                            throw new java.security.InvalidAlgorithmParameterException(new StringBuilder().append("RC5 already set up for a word size of 32 not ").append(((javax.crypto.spec.RC5ParameterSpec) p25).getWordSize()).append(".").toString());
                                        }
                                    }
                                    if ((((javax.crypto.spec.RC5ParameterSpec) p25).getIV() != null) && (this.ivLength != 0)) {
                                        if (!(v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                                            org.spongycastle.crypto.params.ParametersWithIV v18_0 = new org.spongycastle.crypto.params.ParametersWithIV;
                                            v18_0(v17_0, ((javax.crypto.spec.RC5ParameterSpec) p25).getIV());
                                            v17_0 = v18_0;
                                        } else {
                                            org.spongycastle.crypto.params.ParametersWithIV v18_1 = new org.spongycastle.crypto.params.ParametersWithIV;
                                            v18_1(((org.spongycastle.crypto.params.ParametersWithIV) v17_0).getParameters(), ((javax.crypto.spec.RC5ParameterSpec) p25).getIV());
                                            v17_0 = v18_1;
                                        }
                                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                                    }
                                }
                            }
                        } else {
                            v17_0 = new org.spongycastle.crypto.params.RC2Parameters;
                            v17_0(p24.getEncoded(), ((javax.crypto.spec.RC2ParameterSpec) p25).getEffectiveKeyBits());
                            if ((((javax.crypto.spec.RC2ParameterSpec) p25).getIV() != null) && (this.ivLength != 0)) {
                                if (!(v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                                    org.spongycastle.crypto.params.ParametersWithIV v18_2 = new org.spongycastle.crypto.params.ParametersWithIV;
                                    v18_2(v17_0, ((javax.crypto.spec.RC2ParameterSpec) p25).getIV());
                                    v17_0 = v18_2;
                                } else {
                                    org.spongycastle.crypto.params.ParametersWithIV v18_3 = new org.spongycastle.crypto.params.ParametersWithIV;
                                    v18_3(((org.spongycastle.crypto.params.ParametersWithIV) v17_0).getParameters(), ((javax.crypto.spec.RC2ParameterSpec) p25).getIV());
                                    v17_0 = v18_3;
                                }
                                this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                            }
                        }
                    } else {
                        v17_0 = new org.spongycastle.crypto.params.ParametersWithSBox;
                        v17_0(new org.spongycastle.crypto.params.KeyParameter(p24.getEncoded()), ((org.spongycastle.jcajce.spec.GOST28147ParameterSpec) p25).getSbox());
                        if ((((org.spongycastle.jcajce.spec.GOST28147ParameterSpec) p25).getIV() != null) && (this.ivLength != 0)) {
                            if (!(v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                                org.spongycastle.crypto.params.ParametersWithIV v18_4 = new org.spongycastle.crypto.params.ParametersWithIV;
                                v18_4(v17_0, ((org.spongycastle.jcajce.spec.GOST28147ParameterSpec) p25).getIV());
                                v17_0 = v18_4;
                            } else {
                                org.spongycastle.crypto.params.ParametersWithIV v18_5 = new org.spongycastle.crypto.params.ParametersWithIV;
                                v18_5(((org.spongycastle.crypto.params.ParametersWithIV) v17_0).getParameters(), ((org.spongycastle.jcajce.spec.GOST28147ParameterSpec) p25).getIV());
                                v17_0 = v18_5;
                            }
                            this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                        }
                    }
                } else {
                    if (this.ivLength == 0) {
                        if ((this.modeName != null) && (this.modeName.equals("ECB"))) {
                            throw new java.security.InvalidAlgorithmParameterException("ECB mode does not use an IV");
                        }
                    } else {
                        if ((((javax.crypto.spec.IvParameterSpec) p25).getIV().length == this.ivLength) || (((this.cipher instanceof org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher$AEADGenericBlockCipher)) || (!this.fixedIv))) {
                            if (!(v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) {
                                org.spongycastle.crypto.params.ParametersWithIV v18_6 = new org.spongycastle.crypto.params.ParametersWithIV;
                                v18_6(v17_0, ((javax.crypto.spec.IvParameterSpec) p25).getIV());
                                v17_0 = v18_6;
                            } else {
                                org.spongycastle.crypto.params.ParametersWithIV v18_7 = new org.spongycastle.crypto.params.ParametersWithIV;
                                v18_7(((org.spongycastle.crypto.params.ParametersWithIV) v17_0).getParameters(), ((javax.crypto.spec.IvParameterSpec) p25).getIV());
                                v17_0 = v18_7;
                            }
                            this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v17_0);
                        } else {
                            throw new java.security.InvalidAlgorithmParameterException(new StringBuilder().append("IV must be ").append(this.ivLength).append(" bytes long.").toString());
                        }
                    }
                }
                if ((this.ivLength == 0) || (((v17_0 instanceof org.spongycastle.crypto.params.ParametersWithIV)) || ((v17_0 instanceof org.spongycastle.crypto.params.AEADParameters)))) {
                    org.spongycastle.crypto.params.ParametersWithIV v18_8 = v17_0;
                } else {
                    java.security.SecureRandom v13_0 = p26;
                    if (p26 == null) {
                        v13_0 = new java.security.SecureRandom();
                    }
                    if ((p23 != 1) && (p23 != 3)) {
                        if (this.cipher.getUnderlyingCipher().getAlgorithmName().indexOf("PGPCFB") >= 0) {
                        } else {
                            throw new java.security.InvalidAlgorithmParameterException("no IV set when one expected");
                        }
                    } else {
                        byte[] v12_1 = new byte[this.ivLength];
                        v13_0.nextBytes(v12_1);
                        v18_8 = new org.spongycastle.crypto.params.ParametersWithIV;
                        v18_8(v17_0, v12_1);
                        this.ivParam = ((org.spongycastle.crypto.params.ParametersWithIV) v18_8);
                    }
                }
                if ((p26 == null) || (!this.padded)) {
                    org.spongycastle.crypto.params.ParametersWithIV v17_6 = v18_8;
                } else {
                    v17_6 = new org.spongycastle.crypto.params.ParametersWithRandom;
                    v17_6(v18_8, p26);
                }
                try {
                    switch (p23) {
                        case 1:
                        case 3:
                            this.cipher.init(1, v17_6);
                            return;
                        case 2:
                        case 4:
                            this.cipher.init(0, v17_6);
                            return;
                        default:
                            throw new java.security.InvalidParameterException(new StringBuilder().append("unknown opmode ").append(p23).append(" passed").toString());
                    }
                } catch (Exception v10) {
                }
                throw new org.spongycastle.jcajce.provider.symmetric.util.BaseBlockCipher$1(this, v10.getMessage(), v10);
            } else {
                throw new java.security.InvalidAlgorithmParameterException("RC5 requires an RC5ParametersSpec to be passed in.");
            }
        } else {
            throw new java.security.InvalidKeyException(new StringBuilder().append("Key for algorithm ").append(p24.getAlgorithm()).append(" not suitable for symmetric enryption.").toString());
        }
    }

Method org.apache.http.util.ExceptionUtils.initCause() calling method java.lang.reflect.Method.invoke()


    public static void initCause(Throwable p3, Throwable p4)
    {
        if (org.apache.http.util.ExceptionUtils.INIT_CAUSE_METHOD != null) {
            try {
                Object[] v1_1 = new Object[1];
                v1_1[0] = p4;
                org.apache.http.util.ExceptionUtils.INIT_CAUSE_METHOD.invoke(p3, v1_1);
            } catch (Exception v0) {
            }
        }
        return;
    }

Method org.apache.commons.validator.ValidatorAction.executeValidationMethod() calling method java.lang.reflect.Method.invoke()


    boolean executeValidationMethod(org.apache.commons.validator.Field p10, java.util.Map p11, org.apache.commons.validator.ValidatorResults p12, int p13)
    {
        p11.put("org.apache.commons.validator.ValidatorAction", this);
        try {
            if (this.validationMethod != null) {
                Object[] v2 = this.getParameterValues(p11);
                if (p10.isIndexed()) {
                    this.handleIndexedField(p10, p13, v2);
                }
                try {
                    Object v3 = this.validationMethod.invoke(this.getValidationClassInstance(), v2);
                } catch (reflect.InvocationTargetException v0_2) {
                    throw new org.apache.commons.validator.ValidatorException(v0_2.getMessage());
                }
                boolean v4 = this.isValid(v3);
                if ((!v4) || ((v4) && (!this.onlyReturnErrors(p11)))) {
                    p12.add(p10, this.name, v4, v3);
                }
                int v5_22;
                if (v4) {
                    v5_22 = 1;
                } else {
                    v5_22 = 0;
                }
            } else {
                ClassLoader v1 = this.getClassLoader(p11);
                this.loadValidationClass(v1);
                this.loadParameterClasses(v1);
                this.loadValidationMethod();
            }
        } catch (reflect.InvocationTargetException v0_3) {
            if (!(v0_3 instanceof org.apache.commons.validator.ValidatorException)) {
                this.getLog().error(new StringBuffer().append("Unhandled exception thrown during validation: ").append(v0_3.getMessage()).toString(), v0_3);
                p12.add(p10, this.name, 0);
                v5_22 = 0;
            } else {
                throw ((org.apache.commons.validator.ValidatorException) v0_3);
            }
        }
        return v5_22;
    }

Method org.apache.commons.lang3.reflect.MethodUtils.invokeStaticMethod() calling method java.lang.reflect.Method.invoke()


    public static Object invokeStaticMethod(Class p4, String p5, Object[] p6, Class[] p7)
    {
        Object[] v6_1 = org.apache.commons.lang3.ArrayUtils.nullToEmpty(p6);
        reflect.Method v0 = org.apache.commons.lang3.reflect.MethodUtils.getMatchingAccessibleMethod(p4, p5, org.apache.commons.lang3.ArrayUtils.nullToEmpty(p7));
        if (v0 != null) {
            return v0.invoke(0, v6_1);
        } else {
            throw new NoSuchMethodException(new StringBuilder().append("No such accessible method: ").append(p5).append("() on class: ").append(p4.getName()).toString());
        }
    }

Method org.apache.commons.lang3.reflect.MethodUtils.invokeMethod() calling method java.lang.reflect.Method.invoke()


    public static Object invokeMethod(Object p4, String p5, Object[] p6, Class[] p7)
    {
        Class[] v7_1 = org.apache.commons.lang3.ArrayUtils.nullToEmpty(p7);
        Object[] v6_1 = org.apache.commons.lang3.ArrayUtils.nullToEmpty(p6);
        reflect.Method v0 = org.apache.commons.lang3.reflect.MethodUtils.getMatchingAccessibleMethod(p4.getClass(), p5, v7_1);
        if (v0 != null) {
            return v0.invoke(p4, v6_1);
        } else {
            throw new NoSuchMethodException(new StringBuilder().append("No such accessible method: ").append(p5).append("() on object: ").append(p4.getClass().getName()).toString());
        }
    }

Method org.apache.commons.lang3.reflect.MethodUtils.invokeExactStaticMethod() calling method java.lang.reflect.Method.invoke()


    public static Object invokeExactStaticMethod(Class p4, String p5, Object[] p6, Class[] p7)
    {
        Object[] v6_1 = org.apache.commons.lang3.ArrayUtils.nullToEmpty(p6);
        reflect.Method v0 = org.apache.commons.lang3.reflect.MethodUtils.getAccessibleMethod(p4, p5, org.apache.commons.lang3.ArrayUtils.nullToEmpty(p7));
        if (v0 != null) {
            return v0.invoke(0, v6_1);
        } else {
            throw new NoSuchMethodException(new StringBuilder().append("No such accessible method: ").append(p5).append("() on class: ").append(p4.getName()).toString());
        }
    }

Method org.apache.commons.lang3.reflect.MethodUtils.invokeExactMethod() calling method java.lang.reflect.Method.invoke()


    public static Object invokeExactMethod(Object p4, String p5, Object[] p6, Class[] p7)
    {
        Object[] v6_1 = org.apache.commons.lang3.ArrayUtils.nullToEmpty(p6);
        reflect.Method v0 = org.apache.commons.lang3.reflect.MethodUtils.getAccessibleMethod(p4.getClass(), p5, org.apache.commons.lang3.ArrayUtils.nullToEmpty(p7));
        if (v0 != null) {
            return v0.invoke(p4, v6_1);
        } else {
            throw new NoSuchMethodException(new StringBuilder().append("No such accessible method: ").append(p5).append("() on object: ").append(p4.getClass().getName()).toString());
        }
    }

Method org.apache.commons.lang3.exception.ExceptionUtils.getCauseUsingMethodName() calling method java.lang.reflect.Method.invoke()


    private static Throwable getCauseUsingMethodName(Throwable p3, String p4)
    {
        try {
            Class v2_2 = new Class[0];
            reflect.Method v0 = p3.getClass().getMethod(p4, v2_2);
        } catch (reflect.InvocationTargetException v1) {
        } catch (reflect.InvocationTargetException v1) {
        }
        if ((v0 == null) || (!Throwable.isAssignableFrom(v0.getReturnType()))) {
            reflect.InvocationTargetException v1_6 = 0;
        } else {
            try {
                reflect.InvocationTargetException v1_3 = new Object[0];
                v1_6 = ((Throwable) v0.invoke(p3, v1_3));
            } catch (reflect.InvocationTargetException v1) {
            } catch (reflect.InvocationTargetException v1) {
            } catch (reflect.InvocationTargetException v1) {
            }
        }
        return v1_6;
    }

Method org.apache.commons.lang3.event.EventListenerSupport$ProxyInvocationHandler.invoke() calling method java.lang.reflect.Method.invoke()


    public Object invoke(Object p4, reflect.Method p5, Object[] p6)
    {
        java.util.Iterator v0 = org.apache.commons.lang3.event.EventListenerSupport.access$000(this.this$0).iterator();
        while (v0.hasNext()) {
            p5.invoke(v0.next(), p6);
        }
        return 0;
    }

Method org.apache.commons.lang3.ObjectUtils.clone() calling method java.lang.reflect.Method.invoke()


    public static Object clone(Object p10)
    {
        Object v0;
        if (!(p10 instanceof Cloneable)) {
            v0 = 0;
        } else {
            Object v6;
            if (!p10.getClass().isArray()) {
                try {
                    Throwable v9_1 = new Class[0];
                    Object v7_2 = new Object[0];
                    v6 = p10.getClass().getMethod("clone", v9_1).invoke(p10, v7_2);
                } catch (reflect.InvocationTargetException v3_2) {
                    throw new org.apache.commons.lang3.exception.CloneFailedException(new StringBuilder().append("Cloneable type ").append(p10.getClass().getName()).append(" has no clone method").toString(), v3_2);
                } catch (reflect.InvocationTargetException v3_1) {
                    throw new org.apache.commons.lang3.exception.CloneFailedException(new StringBuilder().append("Cannot clone Cloneable type ").append(p10.getClass().getName()).toString(), v3_1);
                } catch (reflect.InvocationTargetException v3_0) {
                    throw new org.apache.commons.lang3.exception.CloneFailedException(new StringBuilder().append("Exception cloning Cloneable type ").append(p10.getClass().getName()).toString(), v3_0.getCause());
                }
            } else {
                Class v2 = p10.getClass().getComponentType();
                if (v2.isPrimitive()) {
                    int v4_0 = reflect.Array.getLength(p10);
                    v6 = reflect.Array.newInstance(v2, v4_0);
                    int v5 = v4_0;
                    while(true) {
                        int v4_1 = (v5 - 1);
                        if (v5 <= 0) {
                            break;
                        }
                        reflect.Array.set(v6, v4_1, reflect.Array.get(p10, v4_1));
                        v5 = v4_1;
                    }
                } else {
                    v6 = ((Object[]) ((Object[]) p10)).clone();
                }
            }
            v0 = v6;
        }
        return v0;
    }

Method org.apache.commons.lang3.AnnotationUtils.toString() calling method java.lang.reflect.Method.invoke()


    public static String toString(otation.Annotation p8)
    {
        org.apache.commons.lang3.builder.ToStringBuilder v1_1 = new org.apache.commons.lang3.builder.ToStringBuilder(p8, org.apache.commons.lang3.AnnotationUtils.TO_STRING_STYLE);
        reflect.Method[] v0 = p8.annotationType().getDeclaredMethods();
        int v4 = v0.length;
        int v3 = 0;
        while (v3 < v4) {
            reflect.Method v5 = v0[v3];
            if (v5.getParameterTypes().length <= 0) {
                try {
                    Object v7_1 = new Object[0];
                    v1_1.append(v5.getName(), v5.invoke(p8, v7_1));
                } catch (Exception v2_1) {
                    throw v2_1;
                } catch (Exception v2_0) {
                    throw new RuntimeException(v2_0);
                }
            }
            v3++;
        }
        return v1_1.build();
    }

Method org.apache.commons.lang3.AnnotationUtils.hashCode() calling method java.lang.reflect.Method.invoke()


    public static int hashCode(otation.Annotation p12)
    {
        int v5 = 0;
        reflect.Method[] v0 = p12.annotationType().getDeclaredMethods();
        int v3 = v0.length;
        int v2 = 0;
        while (v2 < v3) {
            reflect.Method v4 = v0[v2];
            try {
                int v8_1 = new Object[0];
                Object v7 = v4.invoke(p12, v8_1);
            } catch (Exception v1_1) {
                throw v1_1;
            } catch (Exception v1_0) {
                throw new RuntimeException(v1_0);
            }
            if (v7 != null) {
                v5 += org.apache.commons.lang3.AnnotationUtils.hashMember(v4.getName(), v7);
                v2++;
            } else {
                Object[] v10_1 = new Object[1];
                v10_1[0] = v4;
                throw new IllegalStateException(String.format("Annotation method %s returned null", v10_1));
            }
        }
        return v5;
    }

Method org.apache.commons.lang3.AnnotationUtils.equals() calling method java.lang.reflect.Method.invoke()


    public static boolean equals(otation.Annotation p13, otation.Annotation p14)
    {
        int v9 = 1;
        if (p13 != p14) {
            if ((p13 != null) && (p14 != null)) {
                Class v5 = p13.annotationType();
                Class v6 = p14.annotationType();
                Object[] v12_0 = new Object[1];
                v12_0[0] = p13;
                org.apache.commons.lang3.Validate.notNull(v5, "Annotation %s with null annotationType()", v12_0);
                Object[] v12_1 = new Object[1];
                v12_1[0] = p14;
                org.apache.commons.lang3.Validate.notNull(v6, "Annotation %s with null annotationType()", v12_1);
                if (v5.equals(v6)) {
                    try {
                        reflect.Method[] v0 = v5.getDeclaredMethods();
                        int v2 = 0;
                    } catch (reflect.InvocationTargetException v1) {
                        v9 = 0;
                    } catch (reflect.InvocationTargetException v1) {
                        v9 = 0;
                    }
                    while (v2 < v0.length) {
                        reflect.Method v4 = v0[v2];
                        if ((v4.getParameterTypes().length == 0) && (org.apache.commons.lang3.AnnotationUtils.isValidAnnotationMemberType(v4.getReturnType()))) {
                            boolean v11_7 = new Object[0];
                            boolean v11_9 = new Object[0];
                            if (!org.apache.commons.lang3.AnnotationUtils.memberEquals(v4.getReturnType(), v4.invoke(p13, v11_7), v4.invoke(p14, v11_9))) {
                                v9 = 0;
                                break;
                            }
                        }
                        v2++;
                    }
                } else {
                    v9 = 0;
                }
            } else {
                v9 = 0;
            }
        }
        return v9;
    }

Method com.zebra.sdk.util.internal.ReflectionUtil.invokeZebraImageFactory_getImage() calling method java.lang.reflect.Method.invoke()


    public static com.zebra.sdk.graphics.ZebraImageI invokeZebraImageFactory_getImage(String p5)
    {
        try {
            String v0_8 = Thread.currentThread().getContextClassLoader().loadClass("com.zebra.sdk.graphics.ZebraImageFactory");
            Object[] v2_3 = new Class[1];
            v2_3[0] = String;
            String v0_1 = v0_8.getMethod("getImage", v2_3);
            Object[] v2_1 = new Object[1];
            v2_1[0] = p5;
            return ((com.zebra.sdk.graphics.ZebraImageI) v0_1.invoke(0, v2_1));
        } catch (String v0_4) {
            throw new java.io.IOException(v0_4.getCause().getLocalizedMessage());
        }
    }

Method com.zebra.sdk.util.internal.ReflectionUtil.invokeZebraImageFactory_getImage() calling method java.lang.reflect.Method.invoke()


    public static com.zebra.sdk.graphics.ZebraImageI invokeZebraImageFactory_getImage(java.io.InputStream p5)
    {
        try {
            String v0_8 = Thread.currentThread().getContextClassLoader().loadClass("com.zebra.sdk.graphics.ZebraImageFactory");
            Object[] v2_3 = new Class[1];
            v2_3[0] = java.io.InputStream;
            String v0_1 = v0_8.getMethod("getImage", v2_3);
            Object[] v2_1 = new Object[1];
            v2_1[0] = p5;
            return ((com.zebra.sdk.graphics.ZebraImageI) v0_1.invoke(0, v2_1));
        } catch (String v0_4) {
            throw new java.io.IOException(v0_4.getCause().getLocalizedMessage());
        }
    }

Method com.zebra.sdk.util.fileConversion.internal.PrinterPngToGrfConverterStream.pngToGrf() calling method java.lang.reflect.Method.invoke()


    private byte[] pngToGrf(java.io.InputStream p7)
    {
        try {
            byte[] v0_6 = Class.forName("com.zebra.sdk.graphics.internal.PngToGrfConverterDesktop");
        } catch (byte[] v0) {
            v0_6 = Class.forName("com.zebra.sdk.graphics.internal.PngToGrfConverterAndroid");
        } catch (byte[] v0_5) {
            v0_5.printStackTrace();
            byte[] v0_4 = 0;
            return v0_4;
        }
        Object[] v3_0 = new Class[1];
        v3_0[0] = java.io.InputStream;
        byte[] v0_1 = v0_6.getMethod("pngToGrf", v3_0);
        Object[] v3_2 = new Object[1];
        v3_2[0] = p7;
        v0_4 = ((byte[]) ((byte[]) v0_1.invoke(0, v3_2)));
        return v0_4;
    }

Method com.zebra.sdk.util.fileConversion.internal.GrfToPrinterPngConverterStream.grfToPng() calling method java.lang.reflect.Method.invoke()


    private byte[] grfToPng(java.io.InputStream p7, int p8, int p9)
    {
        try {
            byte[] v0_2 = Class.forName("com.zebra.sdk.graphics.internal.GrfToPngConverterDesktop");
        } catch (byte[] v0) {
            v0_2 = Class.forName("com.zebra.sdk.graphics.internal.GrfToPngConverterAndroid");
        } catch (byte[] v0) {
            byte[] v0_5 = 0;
            return v0_5;
        }
        Object[] v3_0 = new Class[3];
        v3_0[0] = java.io.InputStream;
        v3_0[1] = Integer.TYPE;
        v3_0[2] = Integer.TYPE;
        byte[] v0_1 = v0_2.getMethod("grfToPng", v3_0);
        Object[] v3_2 = new Object[3];
        v3_2[0] = p7;
        v3_2[1] = Integer.valueOf(p8);
        v3_2[2] = Integer.valueOf(p9);
        v0_5 = ((byte[]) ((byte[]) v0_1.invoke(0, v3_2)));
        return v0_5;
    }

Method com.zebra.sdk.comm.internal.ZebraBluetoothSocket.unpairDevice() calling method java.lang.reflect.Method.invoke()


    private void unpairDevice(android.bluetooth.BluetoothDevice p4)
    {
        try {
            p4.getClass().getMethod("removeBond", ((Class[]) 0)).invoke(p4, ((Object[]) 0));
        } catch (Exception v0_0) {
            v0_0.printStackTrace();
        }
        return;
    }

Method com.zebra.sdk.comm.internal.ConnectionBuilderInternal.reflectivelyLoadImplementingClasses() calling method java.lang.reflect.Method.invoke()


    private static void reflectivelyLoadImplementingClasses()
    {
        try {
            Object[] v2_3 = new Class[0];
            Exception v0_2 = Class.forName("com.zebra.sdk.comm.ConnectionBuilder").getDeclaredMethod("initializeClasses", v2_3);
            v0_2.setAccessible(1);
            Object[] v2_1 = new Object[0];
            v0_2.invoke(0, v2_1);
        } catch (Exception v0) {
        }
        return;
    }

Method com.fasterxml.jackson.databind.util.EnumResolver.constructUsingMethod() calling method java.lang.reflect.Method.invoke()


    public static com.fasterxml.jackson.databind.util.EnumResolver constructUsingMethod(Class p5, reflect.Method p6)
    {
        String v0_2 = ((Enum[]) p5.getEnumConstants());
        StringBuilder v2_6 = new java.util.HashMap();
        IllegalArgumentException v1_2 = v0_2.length;
        do {
            v1_2--;
            if (v1_2 < null) {
                return new com.fasterxml.jackson.databind.util.EnumResolver(p5, v0_2, v2_6);
            } else {
                String v3_0 = v0_2[v1_2];
                try {
                    String v4_1 = new Object[0];
                    String v4_2 = p6.invoke(v3_0, v4_1);
                } catch (String v0_1) {
                    throw new IllegalArgumentException(new StringBuilder().append("Failed to access @JsonValue of Enum value ").append(v3_0).append(": ").append(v0_1.getMessage()).toString());
                }
            }
        } while(v4_2 == null);
        v2_6.put(v4_2.toString(), v3_0);
    }

Method com.fasterxml.jackson.databind.ser.std.JsonValueSerializer.serializeWithType() calling method java.lang.reflect.Method.invoke()


    public void serializeWithType(Object p4, com.fasterxml.jackson.core.JsonGenerator p5, com.fasterxml.jackson.databind.SerializerProvider p6, com.fasterxml.jackson.databind.jsontype.TypeSerializer p7)
    {
        try {
            String v1_1 = new Object[0];
            String v1_9 = this._accessorMethod.invoke(p4, v1_1);
        } catch (com.fasterxml.jackson.databind.JsonMappingException v0_6) {
            throw v0_6;
        } catch (com.fasterxml.jackson.databind.JsonMappingException v0_3) {
        }
        if (v1_9 != null) {
            com.fasterxml.jackson.databind.JsonMappingException v0_2 = this._valueSerializer;
            if (v0_2 != null) {
                if (this._forceTypeInformation) {
                    p7.writeTypePrefixForScalar(p4, p5);
                    v0_2.serialize(v1_9, p5, p6);
                    p7.writeTypeSuffixForScalar(p4, p5);
                    return;
                }
            } else {
                v0_2 = p6.findValueSerializer(v1_9.getClass(), this._property);
            }
            v0_2.serializeWithType(v1_9, p5, p6, p7);
        } else {
            p6.defaultSerializeNull(p5);
        }
        return;
    }

Method com.fasterxml.jackson.databind.ser.std.JsonValueSerializer.serialize() calling method java.lang.reflect.Method.invoke()


    public void serialize(Object p5, com.fasterxml.jackson.core.JsonGenerator p6, com.fasterxml.jackson.databind.SerializerProvider p7)
    {
        try {
            String v1_2 = new Object[0];
            String v1_10 = this._accessorMethod.invoke(p5, v1_2);
        } catch (com.fasterxml.jackson.databind.JsonMappingException v0_5) {
            throw v0_5;
        } catch (com.fasterxml.jackson.databind.JsonMappingException v0_2) {
        }
        if (v1_10 != null) {
            com.fasterxml.jackson.databind.JsonMappingException v0_1 = this._valueSerializer;
            if (v0_1 == null) {
                v0_1 = p7.findTypedValueSerializer(v1_10.getClass(), 1, this._property);
            }
            v0_1.serialize(v1_10, p6, p7);
        } else {
            p7.defaultSerializeNull(p6);
        }
        return;
    }

Method com.fasterxml.jackson.databind.ser.BeanPropertyWriter.get() calling method java.lang.reflect.Method.invoke()


    public final Object get(Object p3)
    {
        Object v0_2;
        if (this._accessorMethod == null) {
            v0_2 = this._field.get(p3);
        } else {
            Object[] v1_1 = new Object[0];
            v0_2 = this._accessorMethod.invoke(p3, v1_1);
        }
        return v0_2;
    }

Method com.fasterxml.jackson.databind.introspect.AnnotatedMethod.setValue() calling method java.lang.reflect.Method.invoke()


    public void setValue(Object p5, Object p6)
    {
        try {
            reflect.InvocationTargetException v0_0 = this._method;
            IllegalArgumentException v1_1 = new Object[1];
            v1_1[0] = p6;
            v0_0.invoke(p5, v1_1);
            return;
        } catch (reflect.InvocationTargetException v0_1) {
            throw new IllegalArgumentException(new StringBuilder().append("Failed to setValue() with method ").append(this.getFullName()).append(": ").append(v0_1.getMessage()).toString(), v0_1);
        } catch (reflect.InvocationTargetException v0_2) {
            throw new IllegalArgumentException(new StringBuilder().append("Failed to setValue() with method ").append(this.getFullName()).append(": ").append(v0_2.getMessage()).toString(), v0_2);
        }
    }

Method com.fasterxml.jackson.databind.introspect.AnnotatedMethod.getValue() calling method java.lang.reflect.Method.invoke()


    public Object getValue(Object p5)
    {
        try {
            IllegalArgumentException v1_1 = new Object[0];
            return this._method.invoke(p5, v1_1);
        } catch (reflect.InvocationTargetException v0_1) {
            throw new IllegalArgumentException(new StringBuilder().append("Failed to getValue() with method ").append(this.getFullName()).append(": ").append(v0_1.getMessage()).toString(), v0_1);
        } catch (reflect.InvocationTargetException v0_3) {
            throw new IllegalArgumentException(new StringBuilder().append("Failed to getValue() with method ").append(this.getFullName()).append(": ").append(v0_3.getMessage()).toString(), v0_3);
        }
    }

Method com.fasterxml.jackson.databind.introspect.AnnotatedMethod.call1() calling method java.lang.reflect.Method.invoke()


    public final Object call1(Object p5)
    {
        Object v0_0 = this._method;
        Object[] v2_1 = new Object[1];
        v2_1[0] = p5;
        return v0_0.invoke(0, v2_1);
    }

Method com.fasterxml.jackson.databind.introspect.AnnotatedMethod.call() calling method java.lang.reflect.Method.invoke()


    public final Object call(Object[] p3)
    {
        return this._method.invoke(0, p3);
    }

Method com.fasterxml.jackson.databind.introspect.AnnotatedMethod.call() calling method java.lang.reflect.Method.invoke()


    public final Object call()
    {
        Object[] v2_1 = new Object[0];
        return this._method.invoke(0, v2_1);
    }

Method com.fasterxml.jackson.databind.deser.std.StdKeyDeserializer$StringFactoryKeyDeserializer._parse() calling method java.lang.reflect.Method.invoke()


    public Object _parse(String p5, com.fasterxml.jackson.databind.DeserializationContext p6)
    {
        Object v0_0 = this._factoryMethod;
        Object[] v2_1 = new Object[1];
        v2_1[0] = p5;
        return v0_0.invoke(0, v2_1);
    }

Method com.fasterxml.jackson.databind.deser.std.EnumDeserializer$FactoryBasedDeserializer.deserialize() calling method java.lang.reflect.Method.invoke()


    public Object deserialize(com.fasterxml.jackson.core.JsonParser p6, com.fasterxml.jackson.databind.DeserializationContext p7)
    {
        com.fasterxml.jackson.databind.JsonMappingException v0_3;
        if (this._inputType != null) {
            if (this._inputType != Integer) {
                if (this._inputType != Long) {
                    throw p7.mappingException(this._enumClass);
                } else {
                    v0_3 = Long.valueOf(p6.getValueAsLong());
                }
            } else {
                v0_3 = Integer.valueOf(p6.getValueAsInt());
            }
        } else {
            v0_3 = p6.getText();
        }
        try {
            Class v1_0 = this._factory;
            Class v2 = this._enumClass;
            Object[] v3_1 = new Object[1];
            v3_1[0] = v0_3;
            com.fasterxml.jackson.databind.JsonMappingException v0_6 = v1_0.invoke(v2, v3_1);
        } catch (com.fasterxml.jackson.databind.JsonMappingException v0_7) {
            com.fasterxml.jackson.databind.util.ClassUtil.unwrapAndThrowAsIAE(v0_7);
            v0_6 = 0;
        }
        return v0_6;
    }

Method com.fasterxml.jackson.databind.deser.impl.SetterlessProperty.deserializeAndSet() calling method java.lang.reflect.Method.invoke()


    public final void deserializeAndSet(com.fasterxml.jackson.core.JsonParser p4, com.fasterxml.jackson.databind.DeserializationContext p5, Object p6)
    {
        if (p4.getCurrentToken() != com.fasterxml.jackson.core.JsonToken.VALUE_NULL) {
            try {
                com.fasterxml.jackson.databind.JsonDeserializer v1_9 = new Object[0];
                com.fasterxml.jackson.databind.JsonMappingException v0_5 = this._getter.invoke(p6, v1_9);
            } catch (com.fasterxml.jackson.databind.JsonMappingException v0_1) {
                this._throwAsIOE(v0_1);
            }
            if (v0_5 != null) {
                this._valueDeserializer.deserialize(p4, p5, v0_5);
            } else {
                throw new com.fasterxml.jackson.databind.JsonMappingException(new StringBuilder().append("Problem deserializing \'setterless\' property \'").append(this.getName()).append("\': get method returned null").toString());
            }
        }
        return;
    }

Method com.fasterxml.jackson.databind.deser.impl.MethodProperty.setAndReturn() calling method java.lang.reflect.Method.invoke()


    public Object setAndReturn(Object p4, Object p5)
    {
        try {
            Exception v0_0 = this._setter;
            Object[] v1_1 = new Object[1];
            v1_1[0] = p5;
            Exception v0_1 = v0_0.invoke(p4, v1_1);
        } catch (Exception v0_2) {
            this._throwAsIOE(v0_2, p5);
            p4 = 0;
            return p4;
        }
        if (v0_1 != null) {
            p4 = v0_1;
            return p4;
        } else {
            return p4;
        }
    }

Method com.fasterxml.jackson.databind.deser.impl.MethodProperty.set() calling method java.lang.reflect.Method.invoke()


    public final void set(Object p4, Object p5)
    {
        try {
            Exception v0_0 = this._setter;
            Object[] v1_1 = new Object[1];
            v1_1[0] = p5;
            v0_0.invoke(p4, v1_1);
        } catch (Exception v0_1) {
            this._throwAsIOE(v0_1, p5);
        }
        return;
    }

Method com.fasterxml.jackson.databind.deser.impl.BeanAsArrayBuilderDeserializer.finishBuild() calling method java.lang.reflect.Method.invoke()


    protected final Object finishBuild(com.fasterxml.jackson.databind.DeserializationContext p3, Object p4)
    {
        try {
            Object[] v1_1 = new Object[0];
            int v0_2 = this._buildMethod.getMember().invoke(p4, v1_1);
        } catch (int v0_3) {
            this.wrapInstantiationProblem(v0_3, p3);
            v0_2 = 0;
        }
        return v0_2;
    }

Method com.fasterxml.jackson.databind.deser.SettableAnyProperty.set() calling method java.lang.reflect.Method.invoke()


    public final void set(Object p4, String p5, Object p6)
    {
        try {
            Exception v0_0 = this._setter;
            Object[] v1_1 = new Object[2];
            v1_1[0] = p5;
            v1_1[1] = p6;
            v0_0.invoke(p4, v1_1);
        } catch (Exception v0_1) {
            this._throwAsIOE(v0_1, p5, p6);
        }
        return;
    }

Method com.fasterxml.jackson.databind.deser.BuilderBasedDeserializer.finishBuild() calling method java.lang.reflect.Method.invoke()


    protected final Object finishBuild(com.fasterxml.jackson.databind.DeserializationContext p3, Object p4)
    {
        try {
            Object[] v1_1 = new Object[0];
            int v0_2 = this._buildMethod.getMember().invoke(p4, v1_1);
        } catch (int v0_3) {
            this.wrapInstantiationProblem(v0_3, p3);
            v0_2 = 0;
        }
        return v0_2;
    }

Method au.com.bytecode.opencsv.bean.CsvToBean.processLine() calling method java.lang.reflect.Method.invoke()


    protected Object processLine(au.com.bytecode.opencsv.bean.MappingStrategy p7, String[] p8)
    {
        Object v2 = p7.createBean();
        int v0 = 0;
        while (v0 < p8.length) {
            Object v3_2 = p8[v0];
            reflect.Method v4_1 = p7.findDescriptor(v0);
            if (v4_1 != null) {
                Object v3_0 = this.convertValue(v3_2, v4_1);
                reflect.Method v4_0 = v4_1.getWriteMethod();
                Object[] v5_1 = new Object[1];
                v5_1[0] = v3_0;
                v4_0.invoke(v2, v5_1);
            }
            v0++;
        }
        return v2;
    }

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


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

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


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

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


    void showSoftInputUnchecked(android.view.inputmethod.InputMethodManager p5, android.view.View p6, int p7)
    {
        if (this.showSoftInputUnchecked == null) {
            p5.showSoftInput(p6, p7);
        } else {
            try {
                Exception v0_1 = this.showSoftInputUnchecked;
                Object[] v1_1 = new Object[2];
                v1_1[0] = Integer.valueOf(p7);
                v1_1[1] = 0;
                v0_1.invoke(p5, v1_1);
            } catch (Exception v0) {
            }
        }
        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.MenuPopupWindow.setTouchModal() calling method java.lang.reflect.Method.invoke()


    public void setTouchModal(boolean p7)
    {
        if (android.support.v7.widget.MenuPopupWindow.sSetTouchModalMethod != null) {
            try {
                String v2_1 = this.mPopup;
                Object[] v3_1 = new Object[1];
                v3_1[0] = Boolean.valueOf(p7);
                android.support.v7.widget.MenuPopupWindow.sSetTouchModalMethod.invoke(v2_1, v3_1);
            } catch (Exception v0) {
                android.util.Log.i("MenuPopupWindow", "Could not invoke setTouchModal() on PopupWindow. Oh well.");
            }
        }
        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)
    {
        android.graphics.Rect v4_1;
        if (android.support.v7.widget.DrawableUtils.sInsetsClazz == null) {
            v4_1 = android.support.v7.widget.DrawableUtils.INSETS_NONE;
        } else {
            try {
                android.graphics.drawable.Drawable v12_1 = android.support.v4.graphics.drawable.DrawableCompat.unwrap(p12);
                reflect.Field[] v8_2 = new Class[0];
                int v5_2 = new Object[0];
                Object v3 = v12_1.getClass().getMethod("getOpticalInsets", v8_2).invoke(v12_1, v5_2);
            } catch (Exception v0) {
                android.util.Log.e("DrawableUtils", "Couldn\'t obtain the optical insets. Ignoring.");
            }
            if (v3 == null) {
            } else {
                v4_1 = new android.graphics.Rect();
                reflect.Field[] v8_0 = android.support.v7.widget.DrawableUtils.sInsetsClazz.getFields();
                int v9 = v8_0.length;
                int v7_0 = 0;
                while (v7_0 < v9) {
                    reflect.Field v1 = v8_0[v7_0];
                    boolean v10_0 = v1.getName();
                    int v5_4 = -1;
                    switch (v10_0.hashCode()) {
                        case -1383228885:
                            if (!v10_0.equals("bottom")) {
                            } else {
                                v5_4 = 3;
                            }
                            break;
                        case 115029:
                            if (!v10_0.equals("top")) {
                            } else {
                                v5_4 = 1;
                            }
                            break;
                        case 3317767:
                            if (!v10_0.equals("left")) {
                            } else {
                                v5_4 = 0;
                            }
                            break;
                        case 108511772:
                            if (!v10_0.equals("right")) {
                            } else {
                                v5_4 = 2;
                            }
                            break;
                    }
                    switch (v5_4) {
                        case 0:
                            v4_1.left = v1.getInt(v3);
                            break;
                        case 1:
                            v4_1.top = v1.getInt(v3);
                            break;
                        case 2:
                            v4_1.right = v1.getInt(v3);
                            break;
                        case 3:
                            v4_1.bottom = v1.getInt(v3);
                            break;
                    }
                    v7_0++;
                }
            }
        }
        return v4_1;
    }

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


    public void show()
    {
        int v2_0 = 1;
        android.support.v7.widget.ListPopupWindow$ListSelectorHider v1_0 = 0;
        int v5 = -1;
        int v7 = this.buildDropDown();
        boolean v9 = this.isInputMethodNotNeeded();
        android.support.v4.widget.PopupWindowCompat.setWindowLayoutType(this.mPopup, this.mDropDownWindowLayoutType);
        if (!this.mPopup.isShowing()) {
            int v10_0;
            if (this.mDropDownWidth != -1) {
                if (this.mDropDownWidth != -2) {
                    v10_0 = this.mDropDownWidth;
                } else {
                    v10_0 = this.getAnchorView().getWidth();
                }
            } else {
                v10_0 = -1;
            }
            int v8_1;
            if (this.mDropDownHeight != -1) {
                if (this.mDropDownHeight != -2) {
                    v8_1 = this.mDropDownHeight;
                } else {
                    v8_1 = v7;
                }
            } else {
                v8_1 = -1;
            }
            this.mPopup.setWidth(v10_0);
            this.mPopup.setHeight(v8_1);
            this.setPopupClipToScreenEnabled(1);
            if ((this.mForceIgnoreOutsideTouch) || (this.mDropDownAlwaysVisible)) {
                v2_0 = 0;
            }
            this.mPopup.setOutsideTouchable(v2_0);
            this.mPopup.setTouchInterceptor(this.mTouchInterceptor);
            if (android.support.v7.widget.ListPopupWindow.sSetEpicenterBoundsMethod != null) {
                try {
                    android.support.v7.widget.ListPopupWindow$ListSelectorHider v1_3 = this.mPopup;
                    int v2_3 = new Object[1];
                    v2_3[0] = this.mEpicenterBounds;
                    android.support.v7.widget.ListPopupWindow.sSetEpicenterBoundsMethod.invoke(v1_3, v2_3);
                } catch (Exception v6) {
                    android.util.Log.e("ListPopupWindow", "Could not invoke setEpicenterBounds on PopupWindow", v6);
                }
            }
            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 {
            int v10_1;
            if (this.mDropDownWidth != -1) {
                if (this.mDropDownWidth != -2) {
                    v10_1 = this.mDropDownWidth;
                } else {
                    v10_1 = this.getAnchorView().getWidth();
                }
            } else {
                v10_1 = -1;
            }
            int v8_0;
            if (this.mDropDownHeight != -1) {
                if (this.mDropDownHeight != -2) {
                    v8_0 = this.mDropDownHeight;
                } else {
                    v8_0 = v7;
                }
            } else {
                if (!v9) {
                    v8_0 = -1;
                } else {
                    v8_0 = v7;
                }
                if (!v9) {
                    android.os.Handler v0_1;
                    if (this.mDropDownWidth != -1) {
                        v0_1 = 0;
                    } else {
                        v0_1 = -1;
                    }
                    this.mPopup.setWidth(v0_1);
                    this.mPopup.setHeight(-1);
                } else {
                    android.os.Handler v0_5;
                    if (this.mDropDownWidth != -1) {
                        v0_5 = 0;
                    } else {
                        v0_5 = -1;
                    }
                    this.mPopup.setWidth(v0_5);
                    this.mPopup.setHeight(0);
                }
            }
            if ((!this.mForceIgnoreOutsideTouch) && (!this.mDropDownAlwaysVisible)) {
                v1_0 = 1;
            }
            int v4_1;
            this.mPopup.setOutsideTouchable(v1_0);
            android.os.Handler v0_8 = this.mPopup;
            android.support.v7.widget.ListPopupWindow$ListSelectorHider v1_1 = this.getAnchorView();
            if (v10_1 >= 0) {
                v4_1 = v10_1;
            } else {
                v4_1 = -1;
            }
            if (v8_0 >= 0) {
                v5 = v8_0;
            }
            v0_8.update(v1_1, this.mDropDownHorizontalOffset, this.mDropDownVerticalOffset, v4_1, v5);
        }
        return;
    }

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


    private void setPopupClipToScreenEnabled(boolean p7)
    {
        if (android.support.v7.widget.ListPopupWindow.sClipToWindowEnabledMethod != null) {
            try {
                String v2_1 = this.mPopup;
                Object[] v3_1 = new Object[1];
                v3_1[0] = Boolean.valueOf(p7);
                android.support.v7.widget.ListPopupWindow.sClipToWindowEnabledMethod.invoke(v2_1, v3_1);
            } 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 p7, int p8, boolean p9)
    {
        String v1_4;
        if (android.support.v7.widget.ListPopupWindow.sGetMaxAvailableHeightMethod == null) {
            v1_4 = this.mPopup.getMaxAvailableHeight(p7, p8);
        } else {
            try {
                String v2_1 = this.mPopup;
                Object[] v3_1 = new Object[3];
                v3_1[0] = p7;
                v3_1[1] = Integer.valueOf(p8);
                v3_1[2] = Boolean.valueOf(p9);
                v1_4 = ((Integer) android.support.v7.widget.ListPopupWindow.sGetMaxAvailableHeightMethod.invoke(v2_1, v3_1)).intValue();
            } catch (Exception v0) {
                android.util.Log.i("ListPopupWindow", "Could not call getMaxAvailableHeightMethod(View, int, boolean) on PopupWindow. Using the public version.");
            }
        }
        return v1_4;
    }

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 v1_2 = this.mSetExclusiveCheckableMethod;
                Object v2_0 = this.mWrappedObject;
                Object[] v3_1 = new Object[1];
                v3_1[0] = Boolean.valueOf(p7);
                v1_2.invoke(v2_0, v3_1);
            } else {
                reflect.Method v1_6 = ((android.support.v4.internal.view.SupportMenuItem) this.mWrappedObject).getClass();
                Object[] v3_3 = new Class[1];
                v3_3[0] = Boolean.TYPE;
                this.mSetExclusiveCheckableMethod = v1_6.getDeclaredMethod("setExclusiveCheckable", v3_3);
            }
        } catch (Exception v0) {
            android.util.Log.w("MenuItemWrapper", "Error while calling setExclusiveCheckable", v0);
        }
        return;
    }

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


    public boolean onMenuItemClick(android.view.MenuItem p7)
    {
        boolean v1_0 = 1;
        try {
            if (this.mMethod.getReturnType() != Boolean.TYPE) {
                reflect.Method v2_3 = this.mMethod;
                Object v3_3 = this.mRealOwner;
                Object[] v4_2 = new Object[1];
                v4_2[0] = p7;
                v2_3.invoke(v3_3, v4_2);
            } else {
                boolean v1_1 = this.mMethod;
                reflect.Method v2_1 = this.mRealOwner;
                Object v3_1 = new Object[1];
                v3_1[0] = p7;
                v1_0 = ((Boolean) v1_1.invoke(v2_1, v3_1)).booleanValue();
            }
        } catch (Exception v0) {
            throw new RuntimeException(v0);
        }
        return v1_0;
    }

Method android.support.v7.media.MediaRouterJellybeanMr1$IsConnectingWorkaround.isConnecting() calling method java.lang.reflect.Method.invoke()


    public boolean isConnecting(Object p6)
    {
        int v2_2;
        if (this.mGetStatusCodeMethod == null) {
            v2_2 = 0;
        } else {
            try {
                Object[] v4_1 = new Object[0];
            } catch (int v2) {
            } catch (int v2) {
            }
            if (((Integer) this.mGetStatusCodeMethod.invoke(((android.media.MediaRouter$RouteInfo) p6), v4_1)).intValue() != this.mStatusConnecting) {
                v2_2 = 0;
            } else {
                v2_2 = 1;
            }
        }
        return v2_2;
    }

Method android.support.v7.media.MediaRouterJellybeanMr1$ActiveScanWorkaround.run() calling method java.lang.reflect.Method.invoke()


    public void run()
    {
        if (this.mActivelyScanningWifiDisplays) {
            try {
                Object[] v3_1 = new Object[0];
                this.mScanWifiDisplaysMethod.invoke(this.mDisplayManager, v3_1);
            } catch (reflect.InvocationTargetException v0_0) {
                android.util.Log.w("MediaRouterJellybeanMr1", "Cannot scan for wifi displays.", v0_0);
            } catch (reflect.InvocationTargetException v0_1) {
                android.util.Log.w("MediaRouterJellybeanMr1", "Cannot scan for wifi displays.", v0_1);
            }
            this.mHandler.postDelayed(this, 15000);
        }
        return;
    }

Method android.support.v7.media.MediaRouterJellybean.checkRoutedToBluetooth() calling method java.lang.reflect.Method.invoke()


    static boolean checkRoutedToBluetooth(android.content.Context p11)
    {
        try {
            int v4_6;
            android.media.AudioManager v0_1 = ((android.media.AudioManager) p11.getSystemService("audio"));
            int v4_7 = v0_1.getClass();
            Integer v8_0 = new Class[1];
            v8_0[0] = Integer.TYPE;
            reflect.Method v3 = v4_7.getDeclaredMethod("getDevicesForStream", v8_0);
            int v4_1 = new Object[1];
            v4_1[0] = Integer.valueOf(3);
        } catch (Exception v2) {
            v4_6 = 0;
            return v4_6;
        }
        if ((((Integer) v3.invoke(v0_1, v4_1)).intValue() & 896) == 0) {
            v4_6 = 0;
            return v4_6;
        } else {
            v4_6 = 1;
            return v4_6;
        }
    }

Method android.support.v7.media.MediaRouterJellybean$SelectRouteWorkaround.selectRoute() calling method java.lang.reflect.Method.invoke()


    public void selectRoute(Object p9, int p10, Object p11)
    {
        if ((8388608 & ((android.media.MediaRouter$RouteInfo) p11).getSupportedTypes()) != 0) {
            ((android.media.MediaRouter) p9).selectRoute(p10, ((android.media.MediaRouter$RouteInfo) p11));
        } else {
            if (this.mSelectRouteIntMethod == null) {
                android.util.Log.w("MediaRouterJellybean", "Cannot programmatically select non-user route because the platform is missing the selectRouteInt() method.  Media routing may not work.");
            } else {
                try {
                    String v4_1 = this.mSelectRouteIntMethod;
                    String v5_2 = new Object[2];
                    v5_2[0] = Integer.valueOf(p10);
                    v5_2[1] = ((android.media.MediaRouter$RouteInfo) p11);
                    v4_1.invoke(((android.media.MediaRouter) p9), v5_2);
                } catch (reflect.InvocationTargetException v0_1) {
                    android.util.Log.w("MediaRouterJellybean", "Cannot programmatically select non-user route.  Media routing may not work.", v0_1);
                } catch (reflect.InvocationTargetException v0_0) {
                    android.util.Log.w("MediaRouterJellybean", "Cannot programmatically select non-user route.  Media routing may not work.", v0_0);
                }
            }
        }
        return;
    }

Method android.support.v7.media.MediaRouterJellybean$GetDefaultRouteWorkaround.getDefaultRoute() calling method java.lang.reflect.Method.invoke()


    public Object getDefaultRoute(Object p5)
    {
        reflect.InvocationTargetException v1_0;
        if (this.mGetSystemAudioRouteMethod == null) {
            v1_0 = ((android.media.MediaRouter) p5).getRouteAt(0);
        } else {
            try {
                Object[] v2_1 = new Object[0];
                v1_0 = this.mGetSystemAudioRouteMethod.invoke(((android.media.MediaRouter) p5), v2_1);
            } catch (reflect.InvocationTargetException v1) {
            } catch (reflect.InvocationTargetException v1) {
            }
        }
        return v1_0;
    }

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


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

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 p6, android.app.Activity p7, android.graphics.drawable.Drawable p8, int p9)
    {
        android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo v6_1 = new android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo(p7);
        if (v6_1.setHomeAsUpIndicator == null) {
            if (v6_1.upIndicatorView == null) {
                android.util.Log.w("ActionBarDrawerToggleHoneycomb", "Couldn\'t set home-as-up indicator");
            } else {
                v6_1.upIndicatorView.setImageDrawable(p8);
            }
        } else {
            try {
                android.app.ActionBar v0 = p7.getActionBar();
                String v2_0 = v6_1.setHomeAsUpIndicator;
                String v3_1 = new Object[1];
                v3_1[0] = p8;
                v2_0.invoke(v0, v3_1);
                String v2_1 = v6_1.setHomeActionContentDescription;
                String v3_3 = new Object[1];
                v3_3[0] = Integer.valueOf(p9);
                v2_1.invoke(v0, v3_3);
            } catch (Exception v1) {
                android.util.Log.w("ActionBarDrawerToggleHoneycomb", "Couldn\'t set home-as-up indicator via JB-MR2 API", v1);
            }
        }
        return v6_1;
    }

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 p6, android.app.Activity p7, int p8)
    {
        if (p6 == null) {
            p6 = new android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo(p7);
        }
        if (p6.setHomeAsUpIndicator != null) {
            try {
                android.app.ActionBar v0 = p7.getActionBar();
                CharSequence v2_4 = p6.setHomeActionContentDescription;
                String v3_3 = new Object[1];
                v3_3[0] = Integer.valueOf(p8);
                v2_4.invoke(v0, v3_3);
            } catch (Exception v1) {
                android.util.Log.w("ActionBarDrawerToggleHoneycomb", "Couldn\'t set content description via JB-MR2 API", v1);
            }
            if (android.os.Build$VERSION.SDK_INT <= 19) {
                v0.setSubtitle(v0.getSubtitle());
            }
        }
        return p6;
    }

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


    public void invalidateChildRegion(android.support.v4.widget.SlidingPaneLayout p4, android.view.View p5)
    {
        if ((this.mGetDisplayList == null) || (this.mRecreateDisplayList == null)) {
            p5.invalidate();
        } else {
            try {
                this.mRecreateDisplayList.setBoolean(p5, 1);
                this.mGetDisplayList.invoke(p5, ((Object[]) 0));
            } catch (Exception v0) {
                android.util.Log.e("SlidingPaneLayout", "Error refreshing display list state", v0);
            }
            super.invalidateChildRegion(p4, p5);
        }
        return;
    }

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


    public void setWindowLayoutType(android.widget.PopupWindow p7, int p8)
    {
        if (!android.support.v4.widget.PopupWindowCompat$BasePopupWindowImpl.sSetWindowLayoutTypeMethodAttempted) {
            try {
                int v2_2 = new Class[1];
                v2_2[0] = Integer.TYPE;
                android.support.v4.widget.PopupWindowCompat$BasePopupWindowImpl.sSetWindowLayoutTypeMethod = android.widget.PopupWindow.getDeclaredMethod("setWindowLayoutType", v2_2);
                android.support.v4.widget.PopupWindowCompat$BasePopupWindowImpl.sSetWindowLayoutTypeMethod.setAccessible(1);
            } catch (Exception v0) {
            }
            android.support.v4.widget.PopupWindowCompat$BasePopupWindowImpl.sSetWindowLayoutTypeMethodAttempted = 1;
        }
        if (android.support.v4.widget.PopupWindowCompat$BasePopupWindowImpl.sSetWindowLayoutTypeMethod != null) {
            try {
                Object[] v1_2 = new Object[1];
                v1_2[0] = Integer.valueOf(p8);
                android.support.v4.widget.PopupWindowCompat$BasePopupWindowImpl.sSetWindowLayoutTypeMethod.invoke(p7, v1_2);
            } catch (Exception v0) {
            }
        }
        return;
    }

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


    public int getWindowLayoutType(android.widget.PopupWindow p6)
    {
        if (!android.support.v4.widget.PopupWindowCompat$BasePopupWindowImpl.sGetWindowLayoutTypeMethodAttempted) {
            try {
                Class[] v3_1 = new Class[0];
                android.support.v4.widget.PopupWindowCompat$BasePopupWindowImpl.sGetWindowLayoutTypeMethod = android.widget.PopupWindow.getDeclaredMethod("getWindowLayoutType", v3_1);
                android.support.v4.widget.PopupWindowCompat$BasePopupWindowImpl.sGetWindowLayoutTypeMethod.setAccessible(1);
            } catch (Exception v0) {
            }
            android.support.v4.widget.PopupWindowCompat$BasePopupWindowImpl.sGetWindowLayoutTypeMethodAttempted = 1;
        }
        Exception v0_6;
        if (android.support.v4.widget.PopupWindowCompat$BasePopupWindowImpl.sGetWindowLayoutTypeMethod == null) {
            v0_6 = 0;
        } else {
            try {
                Object[] v2_2 = new Object[0];
                v0_6 = ((Integer) android.support.v4.widget.PopupWindowCompat$BasePopupWindowImpl.sGetWindowLayoutTypeMethod.invoke(p6, v2_2)).intValue();
            } catch (Exception v0) {
            }
        }
        return v0_6;
    }

Method android.support.v4.view.ViewPager.setChildrenDrawingOrderEnabledCompat() calling method java.lang.reflect.Method.invoke()


    void setChildrenDrawingOrderEnabledCompat(boolean p7)
    {
        if (android.os.Build$VERSION.SDK_INT >= 7) {
            if (this.mSetChildrenDrawingOrderEnabled == null) {
                try {
                    int v3_2 = new Class[1];
                    v3_2[0] = Boolean.TYPE;
                    this.mSetChildrenDrawingOrderEnabled = android.view.ViewGroup.getDeclaredMethod("setChildrenDrawingOrderEnabled", v3_2);
                } catch (Exception v0_0) {
                    android.util.Log.e("ViewPager", "Can\'t find setChildrenDrawingOrderEnabled", v0_0);
                }
                String v1_3 = this.mSetChildrenDrawingOrderEnabled;
                String v2_3 = new Object[1];
                v2_3[0] = Boolean.valueOf(p7);
                v1_3.invoke(this, v2_3);
                return;
            }
            try {
            } catch (Exception v0_1) {
                android.util.Log.e("ViewPager", "Error changing children drawing order", v0_1);
            }
        }
        return;
    }

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


    public void setChildrenDrawingOrderEnabled(android.view.ViewGroup p8, boolean p9)
    {
        if (android.support.v4.view.ViewCompat$BaseViewCompatImpl.sChildrenDrawingOrderMethod == null) {
            try {
                int v3_2 = new Class[1];
                v3_2[0] = Boolean.TYPE;
                android.support.v4.view.ViewCompat$BaseViewCompatImpl.sChildrenDrawingOrderMethod = android.view.ViewGroup.getDeclaredMethod("setChildrenDrawingOrderEnabled", v3_2);
            } catch (reflect.InvocationTargetException v0_0) {
                android.util.Log.e("ViewCompat", "Unable to find childrenDrawingOrderEnabled", v0_0);
            }
            android.support.v4.view.ViewCompat$BaseViewCompatImpl.sChildrenDrawingOrderMethod.setAccessible(1);
        }
        try {
            String v2_2 = new Object[1];
            v2_2[0] = Boolean.valueOf(p9);
            android.support.v4.view.ViewCompat$BaseViewCompatImpl.sChildrenDrawingOrderMethod.invoke(p8, v2_2);
        } catch (reflect.InvocationTargetException v0_3) {
            android.util.Log.e("ViewCompat", "Unable to invoke childrenDrawingOrderEnabled", v0_3);
        } catch (reflect.InvocationTargetException v0_2) {
            android.util.Log.e("ViewCompat", "Unable to invoke childrenDrawingOrderEnabled", v0_2);
        } catch (reflect.InvocationTargetException v0_1) {
            android.util.Log.e("ViewCompat", "Unable to invoke childrenDrawingOrderEnabled", v0_1);
        }
        return;
    }

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


    public void dispatchStartTemporaryDetach(android.view.View p4)
    {
        if (!this.mTempDetachBound) {
            this.bindTempDetach();
        }
        if (this.mDispatchStartTemporaryDetach == null) {
            p4.onStartTemporaryDetach();
        } else {
            try {
                String v2_2 = new Object[0];
                this.mDispatchStartTemporaryDetach.invoke(p4, v2_2);
            } catch (Exception v0) {
                android.util.Log.d("ViewCompat", "Error calling dispatchStartTemporaryDetach", v0);
            }
        }
        return;
    }

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


    public void dispatchFinishTemporaryDetach(android.view.View p4)
    {
        if (!this.mTempDetachBound) {
            this.bindTempDetach();
        }
        if (this.mDispatchFinishTemporaryDetach == null) {
            p4.onFinishTemporaryDetach();
        } else {
            try {
                String v2_2 = new Object[0];
                this.mDispatchFinishTemporaryDetach.invoke(p4, v2_2);
            } catch (Exception v0) {
                android.util.Log.d("ViewCompat", "Error calling dispatchFinishTemporaryDetach", v0);
            }
        }
        return;
    }

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


    private static String getScript(String p5)
    {
        try {
            int v2_2;
            if (android.support.v4.text.ICUCompatIcs.sGetScriptMethod == null) {
                v2_2 = 0;
            } else {
                Object[] v0 = new Object[1];
                v0[0] = p5;
                v2_2 = ((String) android.support.v4.text.ICUCompatIcs.sGetScriptMethod.invoke(0, v0));
            }
        } catch (reflect.InvocationTargetException v1_1) {
            android.util.Log.w("ICUCompatIcs", v1_1);
        } catch (reflect.InvocationTargetException v1_0) {
            android.util.Log.w("ICUCompatIcs", v1_0);
        }
        return v2_2;
    }

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


    private static String addLikelySubtags(java.util.Locale p5)
    {
        String v2 = p5.toString();
        try {
            String v3_1;
            if (android.support.v4.text.ICUCompatIcs.sAddLikelySubtagsMethod == null) {
                v3_1 = v2;
            } else {
                Object[] v0 = new Object[1];
                v0[0] = v2;
                v3_1 = ((String) android.support.v4.text.ICUCompatIcs.sAddLikelySubtagsMethod.invoke(0, v0));
            }
        } catch (reflect.InvocationTargetException v1_1) {
            android.util.Log.w("ICUCompatIcs", v1_1);
        } catch (reflect.InvocationTargetException v1_0) {
            android.util.Log.w("ICUCompatIcs", v1_0);
        }
        return v3_1;
    }

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


    public static String maximizeAndGetScript(java.util.Locale p4)
    {
        try {
            Object[] v0 = new Object[1];
            v0[0] = p4;
            String v2_1 = ((java.util.Locale) android.support.v4.text.ICUCompatApi23.sAddLikelySubtagsMethod.invoke(0, v0)).getScript();
        } catch (IllegalAccessException v1_1) {
            android.util.Log.w("ICUCompatIcs", v1_1);
            v2_1 = p4.getScript();
        } catch (IllegalAccessException v1_0) {
            android.util.Log.w("ICUCompatIcs", v1_0);
        }
        return v2_1;
    }

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


    public static String getCallingPackage(Object p6)
    {
        try {
            Class[] v5_1 = new Class[0];
            int v3_0 = new Object[0];
            int v3_2 = ((String) ((android.media.session.MediaSession) p6).getClass().getMethod("getCallingPackage", v5_1).invoke(((android.media.session.MediaSession) p6), v3_0));
        } catch (IllegalAccessException v0) {
            android.util.Log.e("MediaSessionCompatApi24", "Cannot execute MediaSession.getCallingPackage()", v0);
            v3_2 = 0;
        } catch (IllegalAccessException v0) {
        } catch (IllegalAccessException v0) {
        }
        return v3_2;
    }

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


    public static boolean setLayoutDirection(android.graphics.drawable.Drawable p8, int p9)
    {
        int v1_0 = 1;
        if (!android.support.v4.graphics.drawable.DrawableCompatJellybeanMr1.sSetLayoutDirectionMethodFetched) {
            try {
                int v5_2 = new Class[1];
                v5_2[0] = Integer.TYPE;
                android.support.v4.graphics.drawable.DrawableCompatJellybeanMr1.sSetLayoutDirectionMethod = android.graphics.drawable.Drawable.getDeclaredMethod("setLayoutDirection", v5_2);
                android.support.v4.graphics.drawable.DrawableCompatJellybeanMr1.sSetLayoutDirectionMethod.setAccessible(1);
            } catch (Exception v0_0) {
                android.util.Log.i("DrawableCompatJellybeanMr1", "Failed to retrieve setLayoutDirection(int) method", v0_0);
            }
            android.support.v4.graphics.drawable.DrawableCompatJellybeanMr1.sSetLayoutDirectionMethodFetched = 1;
        }
        if (android.support.v4.graphics.drawable.DrawableCompatJellybeanMr1.sSetLayoutDirectionMethod == null) {
            v1_0 = 0;
        } else {
            try {
                Object[] v4_3 = new Object[1];
                v4_3[0] = Integer.valueOf(p9);
                android.support.v4.graphics.drawable.DrawableCompatJellybeanMr1.sSetLayoutDirectionMethod.invoke(p8, v4_3);
            } catch (Exception v0_1) {
                android.util.Log.i("DrawableCompatJellybeanMr1", "Failed to invoke setLayoutDirection(int) via reflection", v0_1);
                android.support.v4.graphics.drawable.DrawableCompatJellybeanMr1.sSetLayoutDirectionMethod = 0;
            }
        }
        return v1_0;
    }

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


    public static int getLayoutDirection(android.graphics.drawable.Drawable p5)
    {
        if (!android.support.v4.graphics.drawable.DrawableCompatJellybeanMr1.sGetLayoutDirectionMethodFetched) {
            try {
                Class[] v3_1 = new Class[0];
                android.support.v4.graphics.drawable.DrawableCompatJellybeanMr1.sGetLayoutDirectionMethod = android.graphics.drawable.Drawable.getDeclaredMethod("getLayoutDirection", v3_1);
                android.support.v4.graphics.drawable.DrawableCompatJellybeanMr1.sGetLayoutDirectionMethod.setAccessible(1);
            } catch (Exception v0_0) {
                android.util.Log.i("DrawableCompatJellybeanMr1", "Failed to retrieve getLayoutDirection() method", v0_0);
            }
            android.support.v4.graphics.drawable.DrawableCompatJellybeanMr1.sGetLayoutDirectionMethodFetched = 1;
        }
        int v1_7;
        if (android.support.v4.graphics.drawable.DrawableCompatJellybeanMr1.sGetLayoutDirectionMethod == null) {
            v1_7 = -1;
        } else {
            try {
                String v2_3 = new Object[0];
                v1_7 = ((Integer) android.support.v4.graphics.drawable.DrawableCompatJellybeanMr1.sGetLayoutDirectionMethod.invoke(p5, v2_3)).intValue();
            } catch (Exception v0_1) {
                android.util.Log.i("DrawableCompatJellybeanMr1", "Failed to invoke getLayoutDirection() via reflection", v0_1);
                android.support.v4.graphics.drawable.DrawableCompatJellybeanMr1.sGetLayoutDirectionMethod = 0;
            }
        }
        return v1_7;
    }

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


    public static boolean areNotificationsEnabled(android.content.Context p15)
    {
        android.app.AppOpsManager v1_1 = ((android.app.AppOpsManager) p15.getSystemService("appops"));
        android.content.pm.ApplicationInfo v0 = p15.getApplicationInfo();
        String v6 = p15.getApplicationContext().getPackageName();
        int v7 = v0.uid;
        try {
            int v9_13;
            Class v2 = Class.forName(android.app.AppOpsManager.getName());
            int v12_1 = new Class[3];
            v12_1[0] = Integer.TYPE;
            v12_1[1] = Integer.TYPE;
            v12_1[2] = String;
            reflect.Method v3 = v2.getMethod("checkOpNoThrow", v12_1);
            int v9_9 = new Object[3];
            v9_9[0] = Integer.valueOf(((Integer) v2.getDeclaredField("OP_POST_NOTIFICATION").get(Integer)).intValue());
            v9_9[1] = Integer.valueOf(v7);
            v9_9[2] = v6;
        } catch (RuntimeException v4) {
            v9_13 = 1;
            return v9_13;
        } catch (RuntimeException v4) {
        } catch (RuntimeException v4) {
        } catch (RuntimeException v4) {
        } catch (RuntimeException v4) {
        } catch (RuntimeException v4) {
        }
        if (((Integer) v3.invoke(v1_1, v9_9)).intValue() != 0) {
            v9_13 = 0;
            return v9_13;
        } else {
            v9_13 = 1;
            return v9_13;
        }
    }

Method android.support.v4.app.NotificationCompatBase.add() calling method java.lang.reflect.Method.invoke()


    public static android.app.Notification add(android.app.Notification p6, android.content.Context p7, CharSequence p8, CharSequence p9, android.app.PendingIntent p10, android.app.PendingIntent p11)
    {
        if (android.support.v4.app.NotificationCompatBase.sSetLatestEventInfo == null) {
            try {
                int v3_5 = new Class[4];
                v3_5[0] = android.content.Context;
                v3_5[1] = CharSequence;
                v3_5[2] = CharSequence;
                v3_5[3] = android.app.PendingIntent;
                android.support.v4.app.NotificationCompatBase.sSetLatestEventInfo = android.app.Notification.getMethod("setLatestEventInfo", v3_5);
            } catch (reflect.InvocationTargetException v0_0) {
                throw new RuntimeException(v0_0);
            }
            Object[] v2_1 = new Object[4];
            v2_1[0] = p7;
            v2_1[1] = p8;
            v2_1[2] = p9;
            v2_1[3] = p10;
            android.support.v4.app.NotificationCompatBase.sSetLatestEventInfo.invoke(p6, v2_1);
            p6.fullScreenIntent = p11;
            return p6;
        }
        try {
            v2_1 = new Object[4];
            v2_1[0] = p7;
            v2_1[1] = p8;
            v2_1[2] = p9;
            v2_1[3] = p10;
            android.support.v4.app.NotificationCompatBase.sSetLatestEventInfo.invoke(p6, v2_1);
            p6.fullScreenIntent = p11;
            return p6;
        } catch (reflect.InvocationTargetException v0_1) {
            throw new RuntimeException(v0_1);
        } catch (reflect.InvocationTargetException v0_1) {
        }
    }

Method android.support.v4.app.BundleCompatGingerbread.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.BundleCompatGingerbread.sPutIBinderMethodFetched) {
            try {
                int v3_3 = new Class[2];
                v3_3[0] = String;
                v3_3[1] = android.os.IBinder;
                android.support.v4.app.BundleCompatGingerbread.sPutIBinderMethod = android.os.Bundle.getMethod("putIBinder", v3_3);
                android.support.v4.app.BundleCompatGingerbread.sPutIBinderMethod.setAccessible(1);
            } catch (IllegalArgumentException v0_0) {
                android.util.Log.i("BundleCompatGingerbread", "Failed to retrieve putIBinder method", v0_0);
            }
            android.support.v4.app.BundleCompatGingerbread.sPutIBinderMethodFetched = 1;
        }
        if (android.support.v4.app.BundleCompatGingerbread.sPutIBinderMethod != null) {
            try {
                String v2_3 = new Object[2];
                v2_3[0] = p8;
                v2_3[1] = p9;
                android.support.v4.app.BundleCompatGingerbread.sPutIBinderMethod.invoke(p7, v2_3);
            } catch (IllegalArgumentException v0_1) {
                android.util.Log.i("BundleCompatGingerbread", "Failed to invoke putIBinder via reflection", v0_1);
                android.support.v4.app.BundleCompatGingerbread.sPutIBinderMethod = 0;
            } catch (IllegalArgumentException v0_1) {
            } catch (IllegalArgumentException v0_1) {
            }
        }
        return;
    }

Method android.support.v4.app.BundleCompatGingerbread.getBinder() calling method java.lang.reflect.Method.invoke()


    public static android.os.IBinder getBinder(android.os.Bundle p8, String p9)
    {
        if (!android.support.v4.app.BundleCompatGingerbread.sGetIBinderMethodFetched) {
            try {
                int v4_2 = new Class[1];
                v4_2[0] = String;
                android.support.v4.app.BundleCompatGingerbread.sGetIBinderMethod = android.os.Bundle.getMethod("getIBinder", v4_2);
                android.support.v4.app.BundleCompatGingerbread.sGetIBinderMethod.setAccessible(1);
            } catch (IllegalArgumentException v0_0) {
                android.util.Log.i("BundleCompatGingerbread", "Failed to retrieve getIBinder method", v0_0);
            }
            android.support.v4.app.BundleCompatGingerbread.sGetIBinderMethodFetched = 1;
        }
        String v1_7;
        if (android.support.v4.app.BundleCompatGingerbread.sGetIBinderMethod == null) {
            v1_7 = 0;
        } else {
            try {
                String v3_3 = new Object[1];
                v3_3[0] = p9;
                v1_7 = ((android.os.IBinder) android.support.v4.app.BundleCompatGingerbread.sGetIBinderMethod.invoke(p8, v3_3));
            } catch (IllegalArgumentException v0_1) {
                android.util.Log.i("BundleCompatGingerbread", "Failed to invoke getIBinder via reflection", v0_1);
                android.support.v4.app.BundleCompatGingerbread.sGetIBinderMethod = 0;
            } catch (IllegalArgumentException v0_1) {
            } catch (IllegalArgumentException v0_1) {
            }
        }
        return v1_7;
    }

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


    public static Object setActionBarUpIndicator(Object p7, android.app.Activity p8, android.graphics.drawable.Drawable p9, int p10)
    {
        if (p7 == null) {
            p7 = new android.support.v4.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo(p8);
        }
        if (((android.support.v4.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo) p7).setHomeAsUpIndicator == null) {
            if (((android.support.v4.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo) p7).upIndicatorView == null) {
                android.util.Log.w("ActionBarDrawerToggleHoneycomb", "Couldn\'t set home-as-up indicator");
            } else {
                ((android.support.v4.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo) p7).upIndicatorView.setImageDrawable(p9);
            }
        } else {
            try {
                android.app.ActionBar v0 = p8.getActionBar();
                String v3_1 = ((android.support.v4.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo) p7).setHomeAsUpIndicator;
                String v4_2 = new Object[1];
                v4_2[0] = p9;
                v3_1.invoke(v0, v4_2);
                String v3_2 = ((android.support.v4.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo) p7).setHomeActionContentDescription;
                String v4_4 = new Object[1];
                v4_4[0] = Integer.valueOf(p10);
                v3_2.invoke(v0, v4_4);
            } catch (Exception v1) {
                android.util.Log.w("ActionBarDrawerToggleHoneycomb", "Couldn\'t set home-as-up indicator via JB-MR2 API", v1);
            }
        }
        return p7;
    }

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


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

Method android.support.transition.ViewOverlay$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.ViewOverlay$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.ViewOverlay$OverlayViewGroup.sInvalidateChildInParentFastMethod.invoke(v3, v4_1);
            } catch (reflect.InvocationTargetException v0_1) {
                v0_1.printStackTrace();
            } catch (reflect.InvocationTargetException v0_0) {
                v0_0.printStackTrace();
            }
        }
        return 0;
    }

Method android.support.transition.SceneKitKat.updateCurrentScene() calling method java.lang.reflect.Method.invoke()


    private void updateCurrentScene(android.view.View p7)
    {
        if (android.support.transition.SceneKitKat.sSetCurrentScene == null) {
            try {
                Object[] v3_3 = new Class[2];
                v3_3[0] = android.view.View;
                v3_3[1] = android.transition.Scene;
                android.support.transition.SceneKitKat.sSetCurrentScene = android.transition.Scene.getDeclaredMethod("setCurrentScene", v3_3);
                android.support.transition.SceneKitKat.sSetCurrentScene.setAccessible(1);
            } catch (reflect.InvocationTargetException v0_0) {
                throw new RuntimeException(v0_0);
            }
            Object[] v3_1 = new Object[2];
            v3_1[0] = p7;
            v3_1[1] = this.mScene;
            android.support.transition.SceneKitKat.sSetCurrentScene.invoke(0, v3_1);
            return;
        }
        try {
            v3_1 = new Object[2];
            v3_1[0] = p7;
            v3_1[1] = this.mScene;
            android.support.transition.SceneKitKat.sSetCurrentScene.invoke(0, v3_1);
            return;
        } catch (reflect.InvocationTargetException v0_1) {
            throw new RuntimeException(v0_1);
        } catch (reflect.InvocationTargetException v0_1) {
        }
    }

Method android.support.multidex.MultiDexExtractor.apply() calling method java.lang.reflect.Method.invoke()


    private static void apply(android.content.SharedPreferences$Editor p2)
    {
        if (android.support.multidex.MultiDexExtractor.sApplyMethod == null) {
            p2.commit();
        } else {
            try {
                Object[] v1_1 = new Object[0];
                android.support.multidex.MultiDexExtractor.sApplyMethod.invoke(p2, v1_1);
            } catch (IllegalAccessException v0) {
            } catch (IllegalAccessException v0) {
            }
        }
        return;
    }

Method android.support.multidex.MultiDex$V19.makeDexElements() calling method java.lang.reflect.Method.invoke()


    private static Object[] makeDexElements(Object p8, java.util.ArrayList p9, java.io.File p10, java.util.ArrayList p11)
    {
        Class[] v2 = new Class[3];
        v2[0] = java.util.ArrayList;
        v2[1] = java.io.File;
        v2[2] = java.util.ArrayList;
        reflect.Method v0 = android.support.multidex.MultiDex.access$500(p8, "makeDexElements", v2);
        Object[] v1_0 = new Object[3];
        v1_0[0] = p9;
        v1_0[1] = p10;
        v1_0[2] = p11;
        return ((Object[]) ((Object[]) v0.invoke(p8, v1_0)));
    }

Method android.support.multidex.MultiDex$V14.makeDexElements() calling method java.lang.reflect.Method.invoke()


    private static Object[] makeDexElements(Object p7, java.util.ArrayList p8, java.io.File p9)
    {
        Class[] v2 = new Class[2];
        v2[0] = java.util.ArrayList;
        v2[1] = java.io.File;
        reflect.Method v0 = android.support.multidex.MultiDex.access$500(p7, "makeDexElements", v2);
        Object[] v1_0 = new Object[2];
        v1_0[0] = p8;
        v1_0[1] = p9;
        return ((Object[]) ((Object[]) v0.invoke(p7, v1_0)));
    }

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


    private static boolean setContainerConstantStateV9(android.graphics.drawable.DrawableContainer p8, android.graphics.drawable.Drawable$ConstantState p9)
    {
        String v1_0 = 1;
        if (!android.support.design.widget.DrawableUtils.sSetConstantStateMethodFetched) {
            try {
                int v5_2 = new Class[1];
                v5_2[0] = android.graphics.drawable.DrawableContainer$DrawableContainerState;
                android.support.design.widget.DrawableUtils.sSetConstantStateMethod = android.graphics.drawable.DrawableContainer.getDeclaredMethod("setConstantState", v5_2);
                android.support.design.widget.DrawableUtils.sSetConstantStateMethod.setAccessible(1);
            } catch (Exception v0) {
                android.util.Log.e("DrawableUtils", "Could not fetch setConstantState(). Oh well.");
            }
            android.support.design.widget.DrawableUtils.sSetConstantStateMethodFetched = 1;
        }
        if (android.support.design.widget.DrawableUtils.sSetConstantStateMethod == null) {
            v1_0 = 0;
        } else {
            try {
                Object[] v4_3 = new Object[1];
                v4_3[0] = p9;
                android.support.design.widget.DrawableUtils.sSetConstantStateMethod.invoke(p8, v4_3);
            } catch (Exception v0) {
                android.util.Log.e("DrawableUtils", "Could not invoke setConstantState(). Oh well.");
            }
        }
        return v1_0;
    }