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 gnu.expr.PrimProcedure.apply() calling method java.lang.reflect.Method.invoke()


    public void apply(gnu.mapping.CallContext p23)
    {
        int v16;
        int v4 = this.argTypes.length;
        boolean v11 = this.isConstructor();
        if ((!v11) || (!this.method.getDeclaringClass().hasOuterLink())) {
            v16 = 0;
        } else {
            v16 = 1;
        }
        try {
            if (this.member == null) {
                reflect.Method v18_21;
                Class v7 = this.method.getDeclaringClass().getReflectClass();
                if (v16 == 0) {
                    v18_21 = 0;
                } else {
                    v18_21 = 1;
                }
                Class[] v14 = new Class[(v18_21 + v4)];
                int v10 = v4;
                while(true) {
                    v10--;
                    if (v10 < 0) {
                        break;
                    }
                    reflect.Method v18_14;
                    if (v16 == 0) {
                        v18_14 = 0;
                    } else {
                        v18_14 = 1;
                    }
                    v14[(v18_14 + v10)] = this.argTypes[v10].getReflectClass();
                }
                if (v16 != 0) {
                    v14[0] = this.method.getDeclaringClass().getOuterLinkType().getReflectClass();
                }
                if (!v11) {
                    if (this.method != gnu.bytecode.Type.clone_method) {
                        this.member = v7.getMethod(this.method.getName(), v14);
                    }
                } else {
                    this.member = v7.getConstructor(v14);
                }
            }
        } catch (reflect.InvocationTargetException v9) {
            throw v9.getTargetException();
        }
        Object v15;
        if (!v11) {
            if (this.method != gnu.bytecode.Type.clone_method) {
                v15 = this.retType.coerceToObject(((reflect.Method) this.member).invoke(p23.value1, p23.values));
            } else {
                Object v6 = p23.value1;
                Class v8 = v6.getClass().getComponentType();
                int v12 = reflect.Array.getLength(v6);
                v15 = reflect.Array.newInstance(v8, v12);
                System.arraycopy(v6, 0, v15, 0, v12);
            }
        } else {
            Object[] v5 = p23.values;
            if (v16 != 0) {
                int v13 = (v5.length + 1);
                reflect.Method v0_7 = new Object[v13];
                Object[] v17 = v0_7;
                System.arraycopy(v5, 0, v17, 1, (v13 - 1));
                v17[0] = ((gnu.expr.PairClassType) p23.value1).staticLink;
                v5 = v17;
            }
            v15 = ((reflect.Constructor) this.member).newInstance(v5);
        }
        if (!this.takesContext()) {
            p23.consumer.writeObject(v15);
        }
        return;
    }

Method kawa.repl.shouldUseGuiConsole() calling method java.lang.reflect.Method.invoke()


    public static boolean shouldUseGuiConsole()
    {
        int v0 = 1;
        if (!kawa.repl.noConsole) {
            try {
                Object[] v4_3 = new Class[0];
                Object[] v3_1 = new Object[0];
                Object[] v4_1 = new Object[0];
            } catch (int v0) {
                v0 = 0;
            }
            if (Class.forName("java.lang.System").getMethod("console", v4_3).invoke(v3_1, v4_1) != null) {
            }
        }
        return v0;
    }

Method gnu.kawa.reflect.SlotSet.apply() calling method java.lang.reflect.Method.invoke()


    public static void apply(boolean p21, Object p22, Object p23, Object p24)
    {
        int v3;
        String v14;
        String v6;
        gnu.expr.Language v13 = gnu.expr.Language.getDefaultLanguage();
        int v12 = 0;
        if ((!(p23 instanceof String)) && ((!(p23 instanceof gnu.lists.FString)) && (!(p23 instanceof gnu.mapping.Symbol)))) {
            v14 = ((gnu.bytecode.Member) p23).getName();
            v6 = v14;
            v3 = 0;
        } else {
            v14 = p23.toString();
            v6 = gnu.expr.Compilation.mangleNameIfNeeded(v14);
            if (!p21) {
                v3 = p22.getClass();
            } else {
                v3 = gnu.kawa.reflect.SlotGet.coerceToClass(p22);
            }
        }
        try {
            reflect.Field v5;
            if (!(p23 instanceof gnu.bytecode.Field)) {
                v5 = v3.getField(v6);
                v5.set(p22, v13.coerceFromObject(v5.getType(), p24));
            } else {
                v5 = ((gnu.bytecode.Field) p23).getReflectField();
            }
        } catch (int v18) {
            try {
                int v11 = (p23 instanceof gnu.bytecode.Method);
            } catch (IllegalAccessException v4) {
                throw gnu.mapping.WrappedException.wrapIfNeeded(v4.getTargetException());
            } catch (IllegalAccessException v4) {
                v12 = 1;
                if (v12 == 0) {
                    throw new RuntimeException(new StringBuilder().append("no such field ").append(v14).append(" in ").append(v3.getName()).toString());
                } else {
                    throw new RuntimeException(new StringBuilder().append("illegal access for field ").append(v14).toString());
                }
                return;
            } catch (int v18) {
            }
            if (v11 == 0) {
                String v16 = gnu.expr.ClassExp.slotToMethodName("set", v14);
            } else {
                v16 = v6;
            }
            if (v11 != 0) {
                if (!v16.startsWith("set")) {
                    v11 = 0;
                }
            }
            try {
                if (v11 == 0) {
                    String v9_1 = gnu.expr.ClassExp.slotToMethodName("get", v14);
                    reflect.Method v10 = v3.getMethod(v9_1, gnu.kawa.reflect.SlotGet.noClasses);
                } else {
                    v9_1 = new StringBuilder().append("get").append(v16.substring(3)).toString();
                }
            } catch (Exception v8) {
                if (v11 == 0) {
                    String v9_0 = gnu.expr.ClassExp.slotToMethodName("is", v14);
                } else {
                    v9_0 = new StringBuilder().append("is").append(v16.substring(3)).toString();
                }
                v10 = v3.getMethod(v9_0, gnu.kawa.reflect.SlotGet.noClasses);
            }
            Class[] v15 = new Class[1];
            v15[0] = v10.getReturnType();
            reflect.Method v17 = v3.getMethod(v16, v15);
            Object[] v2 = new Object[1];
            v2[0] = v13.coerceFromObject(v15[0], p24);
            v17.invoke(p22, v2);
        } catch (IllegalAccessException v4) {
            v12 = 1;
        }
        return;
    }

Method gnu.kawa.reflect.SlotGet.getSlotValue() calling method java.lang.reflect.Method.invoke()


    public static Object getSlotValue(boolean p13, Object p14, String p15, String p16, String p17, String p18, gnu.expr.Language p19)
    {
        Object v1;
        if (!p13) {
            v1 = p14.getClass();
        } else {
            v1 = gnu.kawa.reflect.SlotGet.coerceToClass(p14);
        }
        if ((p16 != "length") || (!v1.isArray())) {
            if (p16 != "class") {
                int v6 = 0;
                if (p16 != null) {
                    try {
                        int v3 = v1.getField(p16);
                    } catch (Exception v2) {
                        v3 = 0;
                    }
                    if (v3 != 0) {
                        if ((!p13) || ((v3.getModifiers() & 8) != 0)) {
                            try {
                                v1 = p19.coerceToObject(v3.getType(), v3.get(p14));
                            } catch (Exception v2) {
                                v6 = 1;
                            } catch (Exception v2_1) {
                                v2_1.printStackTrace();
                            }
                            return v1;
                        } else {
                            throw new RuntimeException(new StringBuilder().append("cannot access non-static field \'").append(p16).append(39).toString());
                        }
                    }
                }
                String v8;
                reflect.Method v5 = 0;
                try {
                    if (p17 == null) {
                        v8 = gnu.expr.ClassExp.slotToMethodName("get", p15);
                        v5 = v1.getMethod(v8, gnu.kawa.reflect.SlotGet.noClasses);
                        if ((!p13) || ((v5.getModifiers() & 8) != 0)) {
                            v1 = p19.coerceToObject(v5.getReturnType(), v5.invoke(p14, gnu.mapping.Values.noArgs));
                            return v1;
                        } else {
                            throw new RuntimeException(new StringBuilder().append("cannot call non-static getter method \'").append(v8).append(39).toString());
                        }
                    } else {
                        v8 = p17;
                    }
                } catch (Exception v2_0) {
                    throw gnu.mapping.WrappedException.wrapIfNeeded(v2_0.getTargetException());
                } catch (Exception v2) {
                    v6 = 1;
                } catch (RuntimeException v10) {
                } catch (Exception v4) {
                    if (p18 == null) {
                        v8 = gnu.expr.ClassExp.slotToMethodName("is", p15);
                    } else {
                        v8 = p18;
                    }
                    v5 = v1.getMethod(v8, gnu.kawa.reflect.SlotGet.noClasses);
                }
                if (v6 == 0) {
                    throw new RuntimeException(new StringBuilder().append("no such field ").append(p16).append(" in ").append(v1.getName()).toString());
                } else {
                    throw new RuntimeException(new StringBuilder().append("illegal access for field ").append(p16).toString());
                }
            }
        } else {
            v1 = Integer.valueOf(reflect.Array.getLength(p14));
        }
        return v1;
    }

Method gnu.expr.InlineCalls.maybeInline() calling method java.lang.reflect.Method.invoke()


    public gnu.expr.Expression maybeInline(gnu.expr.ApplyExp p15, gnu.bytecode.Type p16, gnu.mapping.Procedure p17)
    {
        try {
            gnu.expr.Expression v10_2;
        } catch (Throwable v4_0) {
            if ((v4_0 instanceof reflect.InvocationTargetException)) {
                v4_0 = ((reflect.InvocationTargetException) v4_0).getTargetException();
            }
            this.messages.error(101, new StringBuilder().append("caught exception in inliner for ").append(p17).append(" - ").append(v4_0).toString(), v4_0);
            v10_2 = 0;
            return v10_2;
        }
        reflect.Method v5_0 = p17.getProperty(gnu.mapping.Procedure.validateApplyKey, 0);
        if ((v5_0 instanceof String)) {
            String v6 = ((String) v5_0);
            int v3 = v6.indexOf(58);
            reflect.Method v7 = 0;
            if (v3 > 0) {
                v7 = Class.forName(v6.substring(0, v3), 1, p17.getClass().getClassLoader()).getDeclaredMethod(v6.substring((v3 + 1)), gnu.expr.InlineCalls.getInlinerMethodArgTypes());
            }
            if (v7 != null) {
                v5_0 = v7;
            } else {
                this.error(101, new StringBuilder().append("inliner property string for ").append(p17).append(" is not of the form CLASS:METHOD").toString());
                v10_2 = 0;
                return v10_2;
            }
        }
        if (v5_0 == null) {
        } else {
            Object[] v9 = new Object[4];
            v9[0] = p15;
            v9[1] = this;
            v9[2] = p16;
            v9[3] = p17;
            if (!(v5_0 instanceof gnu.mapping.Procedure)) {
                if (!(v5_0 instanceof reflect.Method)) {
                } else {
                    v10_2 = ((gnu.expr.Expression) ((reflect.Method) v5_0).invoke(0, v9));
                    return v10_2;
                }
            } else {
                v10_2 = ((gnu.expr.Expression) ((gnu.mapping.Procedure) v5_0).applyN(v9));
                return v10_2;
            }
        }
    }

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


    public boolean isProjected()
    {
        if ((this.mDrawable == null) || (android.support.v4.graphics.drawable.DrawableWrapperApi21.sIsProjectedDrawableMethod == null)) {
            String v1_3 = 0;
        } else {
            try {
                Object[] v4_1 = new Object[0];
                v1_3 = ((Boolean) android.support.v4.graphics.drawable.DrawableWrapperApi21.sIsProjectedDrawableMethod.invoke(this.mDrawable, v4_1)).booleanValue();
            } catch (Exception v0) {
                android.util.Log.w("DrawableWrapperApi21", "Error calling Drawable#isProjected() method", v0);
            }
        }
        return v1_3;
    }

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


    private static boolean freeze(Object p4)
    {
        try {
            Object[] v3_1 = new Object[0];
            return ((Boolean) android.support.v4.graphics.TypefaceCompatApi26Impl.sFreeze.invoke(p4, v3_1)).booleanValue();
        } catch (reflect.InvocationTargetException v0) {
            throw new RuntimeException(v0);
        } catch (reflect.InvocationTargetException v0) {
        }
    }

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


    private static android.graphics.Typeface createFromFamiliesWithDefault(Object p7)
    {
        try {
            Object v1 = reflect.Array.newInstance(android.support.v4.graphics.TypefaceCompatApi26Impl.sFontFamily, 1);
            reflect.Array.set(v1, 0, p7);
            Object[] v4_1 = new Object[3];
            v4_1[0] = v1;
            v4_1[1] = Integer.valueOf(-1);
            v4_1[2] = Integer.valueOf(-1);
            return ((android.graphics.Typeface) android.support.v4.graphics.TypefaceCompatApi26Impl.sCreateFromFamiliesWithDefault.invoke(0, v4_1));
        } catch (reflect.InvocationTargetException v0) {
            throw new RuntimeException(v0);
        } catch (reflect.InvocationTargetException v0) {
        }
    }

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


    private static boolean addFontFromBuffer(Object p6, java.nio.ByteBuffer p7, int p8, int p9, int p10)
    {
        try {
            Object[] v3_1 = new Object[5];
            v3_1[0] = p7;
            v3_1[1] = Integer.valueOf(p8);
            v3_1[2] = 0;
            v3_1[3] = Integer.valueOf(p9);
            v3_1[4] = Integer.valueOf(p10);
            return ((Boolean) android.support.v4.graphics.TypefaceCompatApi26Impl.sAddFontFromBuffer.invoke(p6, v3_1)).booleanValue();
        } catch (reflect.InvocationTargetException v0) {
            throw new RuntimeException(v0);
        } catch (reflect.InvocationTargetException v0) {
        }
    }

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


    private static boolean addFontFromAssetManager(android.content.Context p6, Object p7, String p8, int p9, int p10, int p11)
    {
        try {
            Object[] v3_1 = new Object[8];
            v3_1[0] = p6.getAssets();
            v3_1[1] = p8;
            v3_1[2] = Integer.valueOf(0);
            v3_1[3] = Boolean.valueOf(0);
            v3_1[4] = Integer.valueOf(p9);
            v3_1[5] = Integer.valueOf(p10);
            v3_1[6] = Integer.valueOf(p11);
            v3_1[7] = 0;
            return ((Boolean) android.support.v4.graphics.TypefaceCompatApi26Impl.sAddFontFromAssetManager.invoke(p7, v3_1)).booleanValue();
        } catch (reflect.InvocationTargetException v0) {
            throw new RuntimeException(v0);
        } catch (reflect.InvocationTargetException v0) {
        }
    }

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


    private static boolean abortCreation(Object p4)
    {
        try {
            Object[] v3_1 = new Object[0];
            return ((Boolean) android.support.v4.graphics.TypefaceCompatApi26Impl.sAbortCreation.invoke(p4, v3_1)).booleanValue();
        } catch (reflect.InvocationTargetException v0) {
            throw new RuntimeException(v0);
        } catch (reflect.InvocationTargetException v0) {
        }
    }

Method com.google.appinventor.components.runtime.Form.callInitialize() calling method java.lang.reflect.Method.invoke()


    public void callInitialize(Object p6)
    {
        try {
            reflect.Method v1 = p6.getClass().getMethod("Initialize", ((Class[]) 0));
            try {
                android.util.Log.i("Form", new StringBuilder().append("calling Initialize method for Object ").append(p6.toString()).toString());
                v1.invoke(p6, ((Object[]) 0));
            } catch (reflect.InvocationTargetException v0_0) {
                android.util.Log.i("Form", new StringBuilder().append("invoke exception: ").append(v0_0.getMessage()).toString());
                throw v0_0.getTargetException();
            }
            return;
        } catch (reflect.InvocationTargetException v0_1) {
            android.util.Log.i("Form", new StringBuilder().append("Security exception ").append(v0_1.getMessage()).toString());
            return;
        } catch (reflect.InvocationTargetException 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.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.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.graphics.TypefaceCompatApi24Impl.createFromFamiliesWithDefault() calling method java.lang.reflect.Method.invoke()


    private static android.graphics.Typeface createFromFamiliesWithDefault(Object p6)
    {
        try {
            Object v1 = reflect.Array.newInstance(android.support.v4.graphics.TypefaceCompatApi24Impl.sFontFamily, 1);
            reflect.Array.set(v1, 0, p6);
            Object[] v4_1 = new Object[1];
            v4_1[0] = v1;
            return ((android.graphics.Typeface) android.support.v4.graphics.TypefaceCompatApi24Impl.sCreateFromFamiliesWithDefault.invoke(0, v4_1));
        } catch (reflect.InvocationTargetException v0) {
            throw new RuntimeException(v0);
        } catch (reflect.InvocationTargetException v0) {
        }
    }

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


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

Method android.arch.lifecycle.ReflectiveGenericLifecycleObserver.invokeCallback() calling method java.lang.reflect.Method.invoke()


    private void invokeCallback(android.arch.lifecycle.ReflectiveGenericLifecycleObserver$MethodReference p6, android.arch.lifecycle.LifecycleOwner p7, android.arch.lifecycle.Lifecycle$Event p8)
    {
        try {
            switch (p6.mCallType) {
                case 0:
                    Object[] v3_3 = new Object[0];
                    p6.mMethod.invoke(this.mWrapped, v3_3);
                    return;
                case 1:
                    reflect.Method v1_1 = p6.mMethod;
                    Object v2_0 = this.mWrapped;
                    Object[] v3_1 = new Object[1];
                    v3_1[0] = p7;
                    v1_1.invoke(v2_0, v3_1);
                    return;
                case 2:
                    reflect.Method v1_3 = p6.mMethod;
                    Object v2_2 = this.mWrapped;
                    Object[] v3_6 = new Object[2];
                    v3_6[0] = p7;
                    v3_6[1] = p8;
                    v1_3.invoke(v2_2, v3_6);
                    return;
                default:
                    return;
            }
        } catch (IllegalAccessException v0_1) {
        } catch (IllegalAccessException v0_0) {
            throw new RuntimeException(v0_0);
        }
        throw new RuntimeException("Failed to call observer method", v0_1.getCause());
    }

Method gnu.mapping.LazyPropertyKey.get() calling method java.lang.reflect.Method.invoke()


    public Object get(gnu.mapping.PropertySet p19, Object p20)
    {
        Object v12;
        Object v11 = p19.getProperty(this, p20);
        if (!(v11 instanceof String)) {
            v12 = v11;
        } else {
            int v6;
            String v13_1 = ((String) v11);
            if (v13_1.charAt(0) != 42) {
                v6 = 0;
            } else {
                v6 = 1;
            }
            int v5 = v13_1.indexOf(58);
            if ((v5 > v6) && (v5 < (v13_1.length() - 1))) {
                String v4 = v13_1.substring(v6, v5);
                String v10 = v13_1.substring((v5 + 1));
                try {
                    Class v3 = Class.forName(v4, 1, p19.getClass().getClassLoader());
                } catch (Throwable v7) {
                    Object[] v16_7 = new StringBuilder().append("lazy property ").append(this).append(" has specifier \"").append(v13_1).append("\" but there is no such ");
                    if (v6 != 0) {
                        String v14_18 = "method";
                    } else {
                        v14_18 = "field";
                    }
                    throw new RuntimeException(v16_7.append(v14_18).toString(), v7);
                }
                if (v6 != 0) {
                    String v14_9 = new Class[1];
                    v14_9[0] = Object;
                    String v14_10 = v3.getDeclaredMethod(v10, v14_9);
                    Object[] v0_3 = new Object[1];
                    Object[] v16_3 = v0_3;
                    v16_3[0] = p19;
                    v12 = v14_10.invoke(0, v16_3);
                } else {
                    v12 = v3.getField(v10).get(0);
                }
                p19.setProperty(this, v12);
            } else {
                throw new RuntimeException(new StringBuilder().append("lazy property ").append(this).append(" must have the form \"ClassName:fieldName\" or \"ClassName:staticMethodName\"").toString());
            }
        }
        return v12;
    }

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_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_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_1);
            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 (this.mOverlapAnchorSet) {
                android.support.v4.widget.PopupWindowCompat.setOverlapAnchor(this.mPopup, this.mOverlapAnchor);
            }
            if (android.support.v7.widget.ListPopupWindow.sSetEpicenterBoundsMethod != null) {
                try {
                    android.support.v7.widget.ListPopupWindow$ListSelectorHider v1_4 = this.mPopup;
                    int v2_3 = new Object[1];
                    v2_3[0] = this.mEpicenterBounds;
                    android.support.v7.widget.ListPopupWindow.sSetEpicenterBoundsMethod.invoke(v1_4, 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 {
            if (android.support.v4.view.ViewCompat.isAttachedToWindow(this.getAnchorView())) {
                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_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_4;
                        if (this.mDropDownWidth != -1) {
                            v0_4 = 0;
                        } else {
                            v0_4 = -1;
                        }
                        this.mPopup.setWidth(v0_4);
                        this.mPopup.setHeight(-1);
                    } else {
                        android.os.Handler v0_7;
                        if (this.mDropDownWidth != -1) {
                            v0_7 = 0;
                        } else {
                            v0_7 = -1;
                        }
                        this.mPopup.setWidth(v0_7);
                        this.mPopup.setHeight(0);
                    }
                }
                if ((!this.mForceIgnoreOutsideTouch) && (!this.mDropDownAlwaysVisible)) {
                    v1_0 = 1;
                }
                int v4_1;
                this.mPopup.setOutsideTouchable(v1_0);
                android.os.Handler v0_11 = this.mPopup;
                android.support.v7.widget.ListPopupWindow$ListSelectorHider v1_1 = this.getAnchorView();
                if (v10_0 >= 0) {
                    v4_1 = v10_0;
                } else {
                    v4_1 = -1;
                }
                if (v8_0 >= 0) {
                    v5 = v8_0;
                }
                v0_11.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.v4.graphics.drawable.DrawableCompat$DrawableCompatApi17Impl.setLayoutDirection() calling method java.lang.reflect.Method.invoke()


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

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


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

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


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

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


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

Method org.acra.collector.ReflectionCollector.collectStaticGettersResults() calling method java.lang.reflect.Method.invoke()


    public static String collectStaticGettersResults(Class p8)
    {
        StringBuilder v5_1 = new StringBuilder();
        reflect.Method[] v0 = p8.getMethods();
        int v2 = v0.length;
        int v1 = 0;
        while (v1 < v2) {
            reflect.Method v3 = v0[v1];
            if (((v3.getParameterTypes().length == 0) && ((v3.getName().startsWith("get")) || (v3.getName().startsWith("is")))) && (!v3.getName().equals("getClass"))) {
                try {
                    v5_1.append(v3.getName());
                    v5_1.append(61);
                    v5_1.append(v3.invoke(0, ((Object[]) 0)));
                    v5_1.append("\n");
                } catch (reflect.InvocationTargetException v6) {
                } catch (reflect.InvocationTargetException v6) {
                } catch (reflect.InvocationTargetException v6) {
                }
            }
            v1++;
        }
        return v5_1.toString();
    }

Method org.acra.collector.MediaCodecListCollector.identifyCodecType() calling method java.lang.reflect.Method.invoke()


    private static org.acra.collector.MediaCodecListCollector$CodecType identifyCodecType(Object p7)
    {
        Object[] v6_1 = new Object[0];
        String v3_1 = ((String) org.acra.collector.MediaCodecListCollector.getNameMethod.invoke(p7, v6_1));
        String[] v0_3 = org.acra.collector.MediaCodecListCollector.AVC_TYPES;
        int v1_3 = 0;
        while (v1_3 < v0_3.length) {
            if (!v3_1.contains(v0_3[v1_3])) {
                v1_3++;
            } else {
                org.acra.collector.MediaCodecListCollector$CodecType v5_1 = org.acra.collector.MediaCodecListCollector$CodecType.AVC;
            }
            return v5_1;
        }
        String[] v0_0 = org.acra.collector.MediaCodecListCollector.H263_TYPES;
        int v1_0 = 0;
        while (v1_0 < v0_0.length) {
            if (!v3_1.contains(v0_0[v1_0])) {
                v1_0++;
            } else {
                v5_1 = org.acra.collector.MediaCodecListCollector$CodecType.H263;
            }
            return v5_1;
        }
        String[] v0_1 = org.acra.collector.MediaCodecListCollector.MPEG4_TYPES;
        int v1_1 = 0;
        while (v1_1 < v0_1.length) {
            if (!v3_1.contains(v0_1[v1_1])) {
                v1_1++;
            } else {
                v5_1 = org.acra.collector.MediaCodecListCollector$CodecType.MPEG4;
            }
            return v5_1;
        }
        String[] v0_2 = org.acra.collector.MediaCodecListCollector.AAC_TYPES;
        int v1_2 = 0;
        while (v1_2 < v0_2.length) {
            if (!v3_1.contains(v0_2[v1_2])) {
                v1_2++;
            } else {
                v5_1 = org.acra.collector.MediaCodecListCollector$CodecType.AAC;
            }
            return v5_1;
        }
        v5_1 = 0;
        return v5_1;
    }

Method org.acra.collector.MediaCodecListCollector.collectCapabilitiesForType() calling method java.lang.reflect.Method.invoke()


    private static String collectCapabilitiesForType(Object p13, String p14)
    {
        StringBuilder v7_1 = new StringBuilder();
        StringBuilder v9_8 = new Object[1];
        v9_8[0] = p14;
        Object v0 = org.acra.collector.MediaCodecListCollector.getCapabilitiesForTypeMethod.invoke(p13, v9_8);
        int[] v3_1 = ((int[]) ((int[]) org.acra.collector.MediaCodecListCollector.colorFormatsField.get(v0)));
        if (v3_1.length > 0) {
            v7_1.append(p14).append(" color formats:");
            int v4_1 = 0;
            while (v4_1 < v3_1.length) {
                v7_1.append(((String) org.acra.collector.MediaCodecListCollector.mColorFormatValues.get(v3_1[v4_1])));
                if (v4_1 < (v3_1.length - 1)) {
                    v7_1.append(44);
                }
                v4_1++;
            }
            v7_1.append("\n");
        }
        Object[] v1_1 = ((Object[]) ((Object[]) org.acra.collector.MediaCodecListCollector.profileLevelsField.get(v0)));
        if (v1_1.length > 0) {
            v7_1.append(p14).append(" profile levels:");
            int v4_0 = 0;
            while (v4_0 < v1_1.length) {
                org.acra.collector.MediaCodecListCollector$CodecType v2 = org.acra.collector.MediaCodecListCollector.identifyCodecType(p13);
                int v6 = org.acra.collector.MediaCodecListCollector.profileField.getInt(v1_1[v4_0]);
                int v5 = org.acra.collector.MediaCodecListCollector.levelField.getInt(v1_1[v4_0]);
                if (v2 == null) {
                    v7_1.append(v6).append(45).append(v5);
                }
                switch (org.acra.collector.MediaCodecListCollector$1.$SwitchMap$org$acra$collector$MediaCodecListCollector$CodecType[v2.ordinal()]) {
                    case 1:
                        v7_1.append(v6).append(((String) org.acra.collector.MediaCodecListCollector.mAVCProfileValues.get(v6))).append(45).append(((String) org.acra.collector.MediaCodecListCollector.mAVCLevelValues.get(v5)));
                        break;
                    case 2:
                        v7_1.append(((String) org.acra.collector.MediaCodecListCollector.mH263ProfileValues.get(v6))).append(45).append(((String) org.acra.collector.MediaCodecListCollector.mH263LevelValues.get(v5)));
                        break;
                    case 3:
                        v7_1.append(((String) org.acra.collector.MediaCodecListCollector.mMPEG4ProfileValues.get(v6))).append(45).append(((String) org.acra.collector.MediaCodecListCollector.mMPEG4LevelValues.get(v5)));
                        break;
                    case 4:
                        v7_1.append(((String) org.acra.collector.MediaCodecListCollector.mAACProfileValues.get(v6)));
                        break;
                }
                if (v4_0 < (v1_1.length - 1)) {
                    v7_1.append(44);
                }
                v4_0++;
            }
            v7_1.append("\n");
        }
        return v7_1.append("\n").toString();
    }

Method org.acra.collector.MediaCodecListCollector.collecMediaCodecList() calling method java.lang.reflect.Method.invoke()


    public static String collecMediaCodecList()
    {
        StringBuilder v7_1 = new StringBuilder();
        if ((org.acra.collector.MediaCodecListCollector.mediaCodecListClass != null) && (org.acra.collector.MediaCodecListCollector.mediaCodecInfoClass != null)) {
            try {
                Object[] v12_9 = new Class[0];
                Object[] v12_1 = new Object[0];
                int v2 = ((Integer) ((Integer) org.acra.collector.MediaCodecListCollector.mediaCodecListClass.getMethod("getCodecCount", v12_9).invoke(0, v12_1))).intValue();
                int v3 = 0;
            } catch (String v10) {
            } catch (String v10) {
            } catch (String v10) {
            }
            while (v3 < v2) {
                v7_1.append("\n");
                Object[] v12_3 = new Object[1];
                v12_3[0] = Integer.valueOf(v3);
                Object v4 = org.acra.collector.MediaCodecListCollector.getCodecInfoAtMethod.invoke(0, v12_3);
                Object[] v12_5 = new Object[0];
                v7_1.append(v3).append(": ").append(org.acra.collector.MediaCodecListCollector.getNameMethod.invoke(v4, v12_5)).append("\n");
                Object[] v12_7 = new Object[0];
                v7_1.append("isEncoder: ").append(org.acra.collector.MediaCodecListCollector.isEncoderMethod.invoke(v4, v12_7)).append("\n");
                String v11_10 = new Object[0];
                String[] v8 = ((String[]) ((String[]) org.acra.collector.MediaCodecListCollector.getSupportedTypesMethod.invoke(v4, v11_10)));
                v7_1.append("Supported types: ").append(java.util.Arrays.toString(v8)).append("\n");
                String[] v1 = v8;
                int v6 = v1.length;
                int v5 = 0;
                while (v5 < v6) {
                    v7_1.append(org.acra.collector.MediaCodecListCollector.collectCapabilitiesForType(v4, v1[v5]));
                    v5++;
                }
                v7_1.append("\n");
                v3++;
            }
        }
        return v7_1.toString();
    }

Method org.acra.collector.DropBoxCollector.read() calling method java.lang.reflect.Method.invoke()


    public static String read(android.content.Context p27, String[] p28)
    {
        try {
            Object[] v22_25;
            String v13 = org.acra.collector.Compatibility.getDropBoxServiceName();
        } catch (NoSuchFieldException v7) {
            android.util.Log.i(org.acra.ACRA.LOG_TAG, "DropBoxManager not available.");
            v22_25 = "N/A";
            return v22_25;
        } catch (NoSuchFieldException v7) {
            android.util.Log.i(org.acra.ACRA.LOG_TAG, "DropBoxManager not available.");
        } catch (NoSuchFieldException v7) {
            android.util.Log.i(org.acra.ACRA.LOG_TAG, "DropBoxManager not available.");
        } catch (NoSuchFieldException v7) {
            android.util.Log.i(org.acra.ACRA.LOG_TAG, "DropBoxManager not available.");
        } catch (NoSuchFieldException v7) {
            android.util.Log.i(org.acra.ACRA.LOG_TAG, "DropBoxManager not available.");
        } catch (NoSuchFieldException v7) {
            android.util.Log.i(org.acra.ACRA.LOG_TAG, "DropBoxManager not available.");
        }
        if (v13 != null) {
            Object v5 = p27.getSystemService(v13);
            Object[] v22_43 = v5.getClass();
            Object[] v0_2 = new Class[2];
            Long v24_3 = v0_2;
            v24_3[0] = String;
            v24_3[1] = Long.TYPE;
            reflect.Method v9 = v22_43.getMethod("getNextEntry", v24_3);
            if (v9 != null) {
                android.text.format.Time v19_1 = new android.text.format.Time();
                v19_1.setToNow();
                v19_1.minute = (v19_1.minute - org.acra.ACRA.getConfig().dropboxCollectionMinutes());
                v19_1.normalize(0);
                long v20 = v19_1.toMillis(0);
                java.util.ArrayList v17_1 = new java.util.ArrayList();
                if (org.acra.ACRA.getConfig().includeDropBoxSystemTags()) {
                    v17_1.addAll(java.util.Arrays.asList(org.acra.collector.DropBoxCollector.SYSTEM_TAGS));
                }
                if ((p28 != null) && (p28.length > 0)) {
                    v17_1.addAll(java.util.Arrays.asList(p28));
                }
                if (!v17_1.isEmpty()) {
                    StringBuilder v6_1 = new StringBuilder();
                    java.util.Iterator v12 = v17_1.iterator();
                    while (v12.hasNext()) {
                        String v16_1 = ((String) v12.next());
                        v6_1.append("Tag: ").append(v16_1).append(10);
                        Object[] v0_34 = new Object[2];
                        Object[] v22_49 = v0_34;
                        v22_49[0] = v16_1;
                        v22_49[1] = Long.valueOf(v20);
                        Object v8 = v9.invoke(v5, v22_49);
                        if (v8 != null) {
                            Object[] v22_0 = v8.getClass();
                            Object[] v0_4 = new Class[1];
                            Long v24_2 = v0_4;
                            v24_2[0] = Integer.TYPE;
                            reflect.Method v10 = v22_0.getMethod("getText", v24_2);
                            reflect.Method v11 = v8.getClass().getMethod("getTimeMillis", ((Class[]) 0));
                            reflect.Method v4 = v8.getClass().getMethod("close", ((Class[]) 0));
                            while (v8 != null) {
                                long v14 = ((Long) v11.invoke(v8, ((Object[]) 0))).longValue();
                                v19_1.set(v14);
                                v6_1.append("@").append(v19_1.format2445()).append(10);
                                Object[] v0_11 = new Object[1];
                                Object[] v22_13 = v0_11;
                                v22_13[0] = Integer.valueOf(500);
                                String v18_1 = ((String) v10.invoke(v8, v22_13));
                                if (v18_1 == null) {
                                    v6_1.append("Not Text!").append(10);
                                } else {
                                    v6_1.append("Text: ").append(v18_1).append(10);
                                }
                                v4.invoke(v8, ((Object[]) 0));
                                Object[] v0_18 = new Object[2];
                                Object[] v22_22 = v0_18;
                                v22_22[0] = v16_1;
                                v22_22[1] = Long.valueOf(v14);
                                v8 = v9.invoke(v5, v22_22);
                            }
                        } else {
                            v6_1.append("Nothing.").append(10);
                        }
                    }
                    v22_25 = v6_1.toString();
                    return v22_25;
                } else {
                    v22_25 = "No tag configured for collection.";
                    return v22_25;
                }
            } else {
                v22_25 = "";
                return v22_25;
            }
        } else {
            v22_25 = "N/A";
            return v22_25;
        }
    }

Method org.acra.collector.DeviceFeaturesCollector.getFeatures() calling method java.lang.reflect.Method.invoke()


    public static String getFeatures(android.content.Context p16)
    {
        String v13_18;
        if (org.acra.collector.Compatibility.getAPILevel() >= 5) {
            StringBuilder v12_1 = new StringBuilder();
            try {
                String v13_4 = new Object[0];
                Object[] v1 = ((Object[]) ((Object[]) android.content.pm.PackageManager.getMethod("getSystemAvailableFeatures", ((Class[]) 0)).invoke(p16.getPackageManager(), v13_4)));
                int v10 = v1.length;
                int v9 = 0;
            } catch (Throwable v2) {
                android.util.Log.w(org.acra.ACRA.LOG_TAG, new StringBuilder().append("Couldn\'t retrieve DeviceFeatures for ").append(p16.getPackageName()).toString(), v2);
                v12_1.append("Could not retrieve data: ");
                v12_1.append(v2.getMessage());
                v13_18 = v12_1.toString();
            }
            while (v9 < v10) {
                Object v3 = v1[v9];
                String v4_1 = ((String) v3.getClass().getField("name").get(v3));
                if (v4_1 == null) {
                    String v13_12 = new Object[0];
                    String v8_1 = ((String) v3.getClass().getMethod("getGlEsVersion", ((Class[]) 0)).invoke(v3, v13_12));
                    v12_1.append("glEsVersion = ");
                    v12_1.append(v8_1);
                } else {
                    v12_1.append(v4_1);
                }
                v12_1.append("\n");
                v9++;
            }
        } else {
            v13_18 = "Data available only with API Level >= 5";
        }
        return v13_18;
    }

Method kawa.Shell.getOutputConsumer() calling method java.lang.reflect.Method.invoke()


    public static gnu.lists.Consumer getOutputConsumer(gnu.mapping.OutPort p8)
    {
        Object[] v4 = kawa.Shell.defaultFormatInfo;
        if (p8 != null) {
            if (v4 != null) {
                try {
                    Object[] v0 = new Object[(v4.length - 4)];
                    System.arraycopy(v4, 4, v0, 0, v0.length);
                    int v3 = v0.length;
                } catch (Throwable v1) {
                    throw new RuntimeException(new StringBuilder().append("cannot get output-format \'").append(kawa.Shell.defaultFormatName).append("\' - caught ").append(v1).toString());
                }
                while(true) {
                    v3--;
                    if (v3 < 0) {
                        break;
                    }
                    if (v0[v3] == kawa.Shell.portArg) {
                        v0[v3] = p8;
                    }
                }
                gnu.lists.Consumer v2_0 = kawa.Shell.defaultFormatMethod.invoke(0, v0);
                if (!(v2_0 instanceof gnu.lists.AbstractFormat)) {
                    p8 = ((gnu.lists.Consumer) v2_0);
                } else {
                    p8.objectFormat = ((gnu.lists.AbstractFormat) v2_0);
                }
            } else {
                p8 = gnu.expr.Language.getDefaultLanguage().getOutputConsumer(p8);
            }
        } else {
            p8 = gnu.lists.VoidConsumer.getInstance();
        }
        return p8;
    }

Method gnu.text.WriterManager.registerShutdownHook() calling method java.lang.reflect.Method.invoke()


    public boolean registerShutdownHook()
    {
        int v6 = 1;
        try {
            Runtime v5 = Runtime.getRuntime();
            Class v4 = v5.getClass();
            Class[] v3 = new Class[1];
            v3[0] = Thread;
            reflect.Method v2 = v4.getDeclaredMethod("addShutdownHook", v3);
            Object[] v0 = new Object[1];
            v0[0] = new Thread(this);
            v2.invoke(v5, v0);
        } catch (Throwable v1) {
            v6 = 0;
        }
        return v6;
    }

Method gnu.kawa.models.Display.getInstance() calling method java.lang.reflect.Method.invoke()


    public static gnu.kawa.models.Display getInstance()
    {
        gnu.kawa.models.Display v2_1;
        gnu.kawa.models.Display v2_0 = gnu.kawa.models.Display.myDisplay.get(0);
        if (!(v2_0 instanceof gnu.kawa.models.Display)) {
            String v5;
            if (v2_0 != null) {
                v5 = v2_0.toString();
            } else {
                v5 = "swing";
            }
            Class[] v6 = new Class[0];
            while(true) {
                int v1 = v5.indexOf(44);
                String v7 = 0;
                if (v1 >= 0) {
                    v7 = v5.substring((v1 + 1));
                    v5 = v5.substring(0, v1);
                }
                if (!v5.equals("swing")) {
                    if (!v5.equals("swt")) {
                        if (v5.equals("echo2")) {
                            v5 = "gnu.kawa.echo2.Echo2Display";
                        }
                    } else {
                        v5 = "gnu.kawa.swtviews.SwtDisplay";
                    }
                } else {
                    v5 = "gnu.kawa.swingviews.SwingDisplay";
                }
                try {
                    String v9_2 = new Object[0];
                    v2_1 = ((gnu.kawa.models.Display) Class.forName(v5).getDeclaredMethod("getInstance", v6).invoke(0, v9_2));
                } catch (Throwable v3) {
                    throw gnu.mapping.WrappedException.wrapIfNeeded(v3);
                } catch (Throwable v3) {
                    if (v7 == null) {
                        break;
                    }
                    v5 = v7;
                }
            }
            throw new RuntimeException(new StringBuilder().append("no display toolkit: ").append(v2_1).toString());
        } else {
            v2_1 = ((gnu.kawa.models.Display) v2_0);
        }
        return v2_1;
    }

Method gnu.expr.Language.getInstance() calling method java.lang.reflect.Method.invoke()


    public static gnu.expr.Language getInstance(String p9, Class p10)
    {
        try {
            Class[] v0 = new Class[0];
        } catch (Exception v2_0) {
            String v9_1 = p10.getName();
            if (!(v2_0 instanceof reflect.InvocationTargetException)) {
                reflect.InvocationTargetException v5 = v2_0;
            } else {
                v5 = ((reflect.InvocationTargetException) v2_0).getTargetException();
            }
            throw new gnu.mapping.WrappedException(new StringBuilder().append("getInstance for \'").append(v9_1).append("\' failed").toString(), v5);
        }
        try {
            reflect.Method v3 = p10.getDeclaredMethod(new StringBuilder().append("get").append(new StringBuilder().append(Character.toTitleCase(p9.charAt(0))).append(p9.substring(1).toLowerCase()).toString()).append("Instance").toString(), v0);
        } catch (Exception v2) {
            v3 = p10.getDeclaredMethod("getInstance", v0);
        }
        return ((gnu.expr.Language) v3.invoke(0, gnu.mapping.Values.noArgs));
    }

Method com.google.appinventor.components.runtime.util.ScreenDensityUtil.getRawScreenDim() calling method java.lang.reflect.Method.invoke()


    public static void getRawScreenDim(android.content.Context p10, android.graphics.Point p11)
    {
        new android.util.DisplayMetrics();
        android.view.Display v0 = ((android.view.WindowManager) p10.getSystemService("window")).getDefaultDisplay();
        int v5 = com.google.appinventor.components.runtime.util.SdkLevel.getLevel();
        if (v5 < 17) {
            if (v5 <= 10) {
                p11.x = v0.getWidth();
                p11.y = v0.getHeight();
            } else {
                try {
                    Class[] v9_1 = new Class[0];
                    reflect.Method v2 = android.view.Display.getMethod("getRawHeight", v9_1);
                    Class[] v9_3 = new Class[0];
                    try {
                        String v7_8 = new Object[0];
                        p11.x = ((Integer) android.view.Display.getMethod("getRawWidth", v9_3).invoke(v0, v7_8)).intValue();
                        String v7_13 = new Object[0];
                        p11.y = ((Integer) v2.invoke(v0, v7_13)).intValue();
                    } catch (reflect.InvocationTargetException v1_2) {
                        android.util.Log.e("ScreenDensityUtil", "Error reading raw screen size", v1_2);
                    } catch (reflect.InvocationTargetException v1_1) {
                        android.util.Log.e("ScreenDensityUtil", "Error reading raw screen size", v1_1);
                    } catch (reflect.InvocationTargetException v1_0) {
                        android.util.Log.e("ScreenDensityUtil", "Error reading raw screen size", v1_0);
                    }
                } catch (reflect.InvocationTargetException v1_3) {
                    android.util.Log.e("ScreenDensityUtil", "Error reading raw screen size", v1_3);
                }
            }
        } else {
            com.google.appinventor.components.runtime.util.JellybeanUtil.getRealSize(v0, p11);
        }
        return;
    }

Method com.google.appinventor.components.runtime.util.PropertyUtil.copyComponentProperties() calling method java.lang.reflect.Method.invoke()


    public static com.google.appinventor.components.runtime.Component copyComponentProperties(com.google.appinventor.components.runtime.Component p16, com.google.appinventor.components.runtime.Component p17)
    {
        if (p16.getClass().equals(p17.getClass())) {
            Class v1 = p16.getClass();
            reflect.Method[] v3 = v1.getMethods();
            int v13_0 = v3.length;
            Throwable v12_1 = 0;
            while (v12_1 < v13_0) {
                reflect.Method v2 = v3[v12_1];
                try {
                    if ((v2.isAnnotationPresent(com.google.appinventor.components.annotations.SimpleProperty)) && (v2.getParameterTypes().length == 1)) {
                        reflect.Method v9 = v2;
                        String v8 = v9.getName();
                        reflect.Method v6 = com.google.appinventor.components.runtime.util.PropertyUtil.getPropertyCopierMethod(new StringBuilder().append("Copy").append(v8).toString(), v1);
                        if (v6 == null) {
                            Object[] v14_10 = new Class[0];
                            reflect.Method v7 = v1.getMethod(v8, v14_10);
                            if ((v7.isAnnotationPresent(com.google.appinventor.components.annotations.SimpleProperty)) && (v9.getParameterTypes()[0].isAssignableFrom(v7.getReturnType()))) {
                                Object[] v14_17 = new Object[0];
                                Object[] v14_19 = new Object[1];
                                v14_19[0] = v7.invoke(p16, v14_17);
                                v9.invoke(p17, v14_19);
                            }
                        } else {
                            Object[] v14_21 = new Object[1];
                            v14_21[0] = p16;
                            v6.invoke(p17, v14_21);
                        }
                    }
                    v12_1++;
                } catch (NoSuchMethodException v4) {
                } catch (reflect.InvocationTargetException v5) {
                    throw v5.getCause();
                }
            }
            return p17;
        } else {
            throw new IllegalArgumentException("Source and target classes must be identical");
        }
    }

Method com.google.appinventor.components.runtime.util.BluetoothReflection.invokeStaticMethod() calling method java.lang.reflect.Method.invoke()


    private static Object invokeStaticMethod(reflect.Method p4)
    {
        try {
            Object[] v3_1 = new Object[0];
            return p4.invoke(0, v3_1);
        } catch (reflect.InvocationTargetException v1_0) {
            throw new RuntimeException(v1_0);
        } catch (reflect.InvocationTargetException v1_1) {
            RuntimeException v0_1 = v1_1.getCause();
            v0_1.printStackTrace();
            if (!(v0_1 instanceof RuntimeException)) {
                throw new RuntimeException(v0_1);
            } else {
                throw ((RuntimeException) v0_1);
            }
        }
    }

Method com.google.appinventor.components.runtime.util.BluetoothReflection.invokeMethodThrowsIllegalArgumentException() calling method java.lang.reflect.Method.invoke()


    private static varargs Object invokeMethodThrowsIllegalArgumentException(reflect.Method p3, Object p4, Object[] p5)
    {
        try {
            return p3.invoke(p4, p5);
        } catch (reflect.InvocationTargetException v1_0) {
            throw new RuntimeException(v1_0);
        } catch (reflect.InvocationTargetException v1_1) {
            RuntimeException v0_2 = v1_1.getCause();
            v0_2.printStackTrace();
            if (!(v0_2 instanceof IllegalArgumentException)) {
                if (!(v0_2 instanceof RuntimeException)) {
                    throw new RuntimeException(v1_1);
                } else {
                    throw ((RuntimeException) v0_2);
                }
            } else {
                throw ((IllegalArgumentException) v0_2);
            }
        }
    }

Method com.google.appinventor.components.runtime.util.BluetoothReflection.invokeMethodThrowsIOException() calling method java.lang.reflect.Method.invoke()


    private static varargs Object invokeMethodThrowsIOException(reflect.Method p3, Object p4, Object[] p5)
    {
        try {
            return p3.invoke(p4, p5);
        } catch (reflect.InvocationTargetException v1_0) {
            throw new RuntimeException(v1_0);
        } catch (reflect.InvocationTargetException v1_1) {
            RuntimeException v0_2 = v1_1.getCause();
            v0_2.printStackTrace();
            if (!(v0_2 instanceof java.io.IOException)) {
                if (!(v0_2 instanceof RuntimeException)) {
                    throw new RuntimeException(v1_1);
                } else {
                    throw ((RuntimeException) v0_2);
                }
            } else {
                throw ((java.io.IOException) v0_2);
            }
        }
    }

Method com.google.appinventor.components.runtime.util.BluetoothReflection.invokeMethod() calling method java.lang.reflect.Method.invoke()


    private static varargs Object invokeMethod(reflect.Method p3, Object p4, Object[] p5)
    {
        try {
            return p3.invoke(p4, p5);
        } catch (reflect.InvocationTargetException v1_0) {
            throw new RuntimeException(v1_0);
        } catch (reflect.InvocationTargetException v1_1) {
            RuntimeException v0_1 = v1_1.getCause();
            v0_1.printStackTrace();
            if (!(v0_1 instanceof RuntimeException)) {
                throw new RuntimeException(v0_1);
            } else {
                throw ((RuntimeException) v0_1);
            }
        }
    }

Method com.google.appinventor.components.runtime.multidex.MultiDexExtractor.apply() calling method java.lang.reflect.Method.invoke()


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

Method com.google.appinventor.components.runtime.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 = com.google.appinventor.components.runtime.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 com.google.appinventor.components.runtime.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 = com.google.appinventor.components.runtime.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.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.ensureImeVisible() calling method java.lang.reflect.Method.invoke()


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

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


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

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


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

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


    public static android.graphics.Rect getOpticalBounds(android.graphics.drawable.Drawable p12)
    {
        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.AppCompatTextViewAutoSizeHelper.setRawTextSize() calling method java.lang.reflect.Method.invoke()


    private void setRawTextSize(float p8)
    {
        if (p8 != this.mTextView.getPaint().getTextSize()) {
            this.mTextView.getPaint().setTextSize(p8);
            boolean v1 = 0;
            if (android.os.Build$VERSION.SDK_INT >= 18) {
                v1 = this.mTextView.isInLayout();
            }
            if (this.mTextView.getLayout() != null) {
                this.mNeedsAutoSizeText = 0;
                try {
                    reflect.Method v2 = this.getTextViewMethod("nullLayouts");
                } catch (Exception v0) {
                    android.util.Log.w("ACTVAutoSizeHelper", "Failed to invoke TextView#nullLayouts() method", v0);
                    if (v1) {
                        this.mTextView.forceLayout();
                    } else {
                        this.mTextView.requestLayout();
                    }
                    this.mTextView.invalidate();
                }
                if (v2 == null) {
                } else {
                    Object[] v5_2 = new Object[0];
                    v2.invoke(this.mTextView, v5_2);
                }
            }
        }
        return;
    }

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


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

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.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.PopupWindowCompat$PopupWindowCompatBaseImpl.setWindowLayoutType() calling method java.lang.reflect.Method.invoke()


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

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


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

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


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

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


    public void setChildrenDrawingOrderEnabled(android.view.ViewGroup p8, boolean p9)
    {
        if (android.support.v4.view.ViewCompat$ViewCompatBaseImpl.sChildrenDrawingOrderMethod == null) {
            try {
                int v3_2 = new Class[1];
                v3_2[0] = Boolean.TYPE;
                android.support.v4.view.ViewCompat$ViewCompatBaseImpl.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$ViewCompatBaseImpl.sChildrenDrawingOrderMethod.setAccessible(1);
        }
        try {
            String v2_2 = new Object[1];
            v2_2[0] = Boolean.valueOf(p9);
            android.support.v4.view.ViewCompat$ViewCompatBaseImpl.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$ViewCompatBaseImpl.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$ViewCompatBaseImpl.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.ICUCompatApi21.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.ICUCompatApi21.sAddLikelySubtagsMethod.invoke(0, v0)).getScript();
        } catch (IllegalAccessException v1_1) {
            android.util.Log.w("ICUCompatApi21", v1_1);
            v2_1 = p4.getScript();
        } catch (IllegalAccessException v1_0) {
            android.util.Log.w("ICUCompatApi21", 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.media.AudioAttributesCompatApi21.toLegacyStreamType() calling method java.lang.reflect.Method.invoke()


    public static int toLegacyStreamType(android.support.v4.media.AudioAttributesCompatApi21$Wrapper p8)
    {
        android.media.AudioAttributes v0 = p8.unwrap();
        try {
            if (android.support.v4.media.AudioAttributesCompatApi21.sAudioAttributesToLegacyStreamType != null) {
                Object[] v5_1 = new Object[1];
                v5_1[0] = v0;
                int v3_3 = ((Integer) android.support.v4.media.AudioAttributesCompatApi21.sAudioAttributesToLegacyStreamType.invoke(0, v5_1)).intValue();
            } else {
                Object[] v5_3 = new Class[1];
                v5_3[0] = android.media.AudioAttributes;
                android.support.v4.media.AudioAttributesCompatApi21.sAudioAttributesToLegacyStreamType = android.media.AudioAttributes.getMethod("toLegacyStreamType", v5_3);
            }
        } catch (ClassCastException v1) {
            android.util.Log.w("AudioAttributesCompat", "getLegacyStreamType() failed on API21+", v1);
            v3_3 = -1;
        } catch (ClassCastException v1) {
        } catch (ClassCastException v1) {
        } catch (ClassCastException v1) {
        }
        return v3_3;
    }

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


    public boolean areNotificationsEnabled()
    {
        int v10 = 1;
        if (android.os.Build$VERSION.SDK_INT < 24) {
            if (android.os.Build$VERSION.SDK_INT >= 19) {
                android.app.AppOpsManager v1_1 = ((android.app.AppOpsManager) this.mContext.getSystemService("appops"));
                android.content.pm.ApplicationInfo v0 = this.mContext.getApplicationInfo();
                String v6 = this.mContext.getApplicationContext().getPackageName();
                int v7 = v0.uid;
                try {
                    int v9_17;
                    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_13 = new Object[3];
                    v9_13[0] = Integer.valueOf(((Integer) v2.getDeclaredField("OP_POST_NOTIFICATION").get(Integer)).intValue());
                    v9_13[1] = Integer.valueOf(v7);
                    v9_13[2] = v6;
                } catch (RuntimeException v4) {
                } catch (RuntimeException v4) {
                } catch (RuntimeException v4) {
                } catch (RuntimeException v4) {
                } catch (RuntimeException v4) {
                } catch (RuntimeException v4) {
                }
                if (((Integer) v3.invoke(v1_1, v9_13)).intValue() != 0) {
                    v9_17 = 0;
                } else {
                    v9_17 = 1;
                }
                v10 = v9_17;
            }
        } else {
            v10 = this.mNotificationManager.areNotificationsEnabled();
        }
        return v10;
    }

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


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

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


    public static android.os.IBinder getBinder(android.os.Bundle p8, String p9)
    {
        if (!android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethodFetched) {
            try {
                int v4_2 = new Class[1];
                v4_2[0] = String;
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod = android.os.Bundle.getMethod("getIBinder", v4_2);
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod.setAccessible(1);
            } catch (IllegalArgumentException v0_0) {
                android.util.Log.i("BundleCompatBaseImpl", "Failed to retrieve getIBinder method", v0_0);
            }
            android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethodFetched = 1;
        }
        String v1_7;
        if (android.support.v4.app.BundleCompat$BundleCompatBaseImpl.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.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod.invoke(p8, v3_3));
            } catch (IllegalArgumentException v0_1) {
                android.util.Log.i("BundleCompatBaseImpl", "Failed to invoke getIBinder via reflection", v0_1);
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod = 0;
            } catch (IllegalArgumentException v0_1) {
            } catch (IllegalArgumentException v0_1) {
            }
        }
        return v1_7;
    }