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 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 p3, android.app.Activity p4, int p5)
    {
        if (p3 == null) {
            p3 = new android.support.v7.app.ActionBarDrawerToggleHoneycomb$SetIndicatorInfo(p4);
        }
        if (p3.setHomeAsUpIndicator != null) {
            try {
                Exception v4_2 = p4.getActionBar();
                String v0_3 = p3.setHomeActionContentDescription;
                Object[] v1_1 = new Object[1];
                v1_1[0] = Integer.valueOf(p5);
                v0_3.invoke(v4_2, v1_1);
            } catch (Exception v4_1) {
                android.util.Log.w("ActionBarDrawerToggleHC", "Couldn\'t set content description via JB-MR2 API", v4_1);
            }
            if (android.os.Build$VERSION.SDK_INT <= 19) {
                v4_2.setSubtitle(v4_2.getSubtitle());
            }
        }
        return p3;
    }

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


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

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


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

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

Couldn't retrieve source code

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

Couldn't retrieve source code

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


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

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


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

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


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

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


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

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

Couldn't retrieve source code

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


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

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


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

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


    private static String addLikelySubtags(java.util.Locale p3)
    {
        String v3_1 = p3.toString();
        try {
            if (android.support.v4.text.ICUCompat.sAddLikelySubtagsMethod != null) {
                String v0_1 = new Object[1];
                v0_1[0] = v3_1;
                return ((String) android.support.v4.text.ICUCompat.sAddLikelySubtagsMethod.invoke(0, v0_1));
            }
        } catch (String v0_6) {
            android.util.Log.w("ICUCompat", v0_6);
        } catch (String v0_5) {
            android.util.Log.w("ICUCompat", v0_5);
        }
        return v3_1;
    }

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


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

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


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

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


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

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


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

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


    public static void putBinder(android.os.Bundle p7, String p8, android.os.IBinder p9)
    {
        if (!android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethodFetched) {
            try {
                String v5_1 = new Class[2];
                v5_1[0] = String;
                v5_1[1] = android.os.IBinder;
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethod = android.os.Bundle.getMethod("putIBinder", v5_1);
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethod.setAccessible(1);
            } catch (NoSuchMethodException v0_3) {
                android.util.Log.i("BundleCompatBaseImpl", "Failed to retrieve putIBinder method", v0_3);
            }
            android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethodFetched = 1;
        }
        NoSuchMethodException v0_4 = android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethod;
        if (v0_4 != null) {
            try {
                Object[] v2_1 = new Object[2];
                v2_1[0] = p8;
                v2_1[1] = p9;
                v0_4.invoke(p7, v2_1);
            } catch (int v7_1) {
                android.util.Log.i("BundleCompatBaseImpl", "Failed to invoke putIBinder via reflection", v7_1);
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sPutIBinderMethod = 0;
            } catch (int v7_1) {
            } catch (int v7_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 p6, String p7)
    {
        if (!android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethodFetched) {
            try {
                String v4_1 = new Class[1];
                v4_1[0] = String;
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod = android.os.Bundle.getMethod("getIBinder", v4_1);
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod.setAccessible(1);
            } catch (String v0_3) {
                android.util.Log.i("BundleCompatBaseImpl", "Failed to retrieve getIBinder method", v0_3);
            }
            android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethodFetched = 1;
        }
        String v0_4 = android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod;
        if (v0_4 != null) {
            try {
                Object[] v2_1 = new Object[1];
                v2_1[0] = p7;
                return ((android.os.IBinder) v0_4.invoke(p6, v2_1));
            } catch (IllegalArgumentException v6_3) {
                android.util.Log.i("BundleCompatBaseImpl", "Failed to invoke getIBinder via reflection", v6_3);
                android.support.v4.app.BundleCompat$BundleCompatBaseImpl.sGetIBinderMethod = 0;
            } catch (IllegalArgumentException v6_3) {
            } catch (IllegalArgumentException v6_3) {
            }
        }
        return 0;
    }

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


    protected android.view.ViewParent invalidateChildInParentFast(int p6, int p7, android.graphics.Rect p8)
    {
        if (((this.mHostView instanceof android.view.ViewGroup)) && (android.support.transition.ViewOverlayApi14$OverlayViewGroup.sInvalidateChildInParentFastMethod != null)) {
            try {
                reflect.Method v1_0 = new int[2];
                this.getOffset(v1_0);
                android.view.ViewGroup v2 = this.mHostView;
                Object[] v3_1 = new Object[3];
                v3_1[0] = Integer.valueOf(p6);
                v3_1[1] = Integer.valueOf(p7);
                v3_1[2] = p8;
                android.support.transition.ViewOverlayApi14$OverlayViewGroup.sInvalidateChildInParentFastMethod.invoke(v2, v3_1);
            } catch (reflect.InvocationTargetException v6_4) {
                v6_4.printStackTrace();
            } catch (reflect.InvocationTargetException v6_3) {
                v6_3.printStackTrace();
            }
        }
        return 0;
    }

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


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

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


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

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

Couldn't retrieve source code

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


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

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


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

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


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

Method com.google.common.reflect.Element.<init>() calling method java.lang.reflect.AccessibleObject.<init>()


    Element(reflect.AccessibleObject p1)
    {
        com.google.common.base.Preconditions.checkNotNull(p1);
        this.accessibleObject = p1;
        this.member = ((reflect.Member) p1);
        return;
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect.<clinit>() calling method java.lang.reflect.ReflectPermission.<init>()


    static ClassInjector$UsingReflection$Dispatcher$Indirect()
    {
        net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect.ACCESS_PERMISSION = new reflect.ReflectPermission("suppressAccessChecks");
        return;
    }

Method org.junit.internal.runners.SuiteMethod.testFromSuiteMethod() calling method java.lang.reflect.Method.invoke()


    public static junit.framework.Test testFromSuiteMethod(Class p3)
    {
        try {
            boolean v2_0 = new Class[0];
            Exception v0_3 = p3.getMethod("suite", v2_0);
        } catch (String v3_7) {
            throw v3_7.getCause();
        }
        if (!reflect.Modifier.isStatic(v0_3.getModifiers())) {
            StringBuilder v1_2 = new StringBuilder();
            v1_2.append(p3.getName());
            v1_2.append(".suite() must be static");
            throw new Exception(v1_2.toString());
        } else {
            StringBuilder v1_3 = new Object[0];
            return ((junit.framework.Test) v0_3.invoke(0, v1_3));
        }
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForWildcardUpperBoundType.resolve() calling method java.lang.reflect.Method.invoke()


    protected reflect.AnnotatedElement resolve(reflect.AnnotatedElement p3)
    {
        try {
            reflect.AnnotatedElement v3_2;
            String v1_2 = new Object[0];
            reflect.AnnotatedElement v3_7 = net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForWildcardUpperBoundType.GET_ANNOTATED_UPPER_BOUNDS.invoke(p3, v1_2);
        } catch (ClassCastException) {
            return net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$NoOp.INSTANCE;
        } catch (reflect.AnnotatedElement v3_5) {
            throw new IllegalStateException("Cannot access java.lang.reflect.AnnotatedWildcardType#getAnnotatedUpperBounds", v3_5);
        } catch (reflect.AnnotatedElement v3_3) {
            throw new IllegalStateException("Error invoking java.lang.reflect.AnnotatedWildcardType#getAnnotatedUpperBounds", v3_3.getCause());
        }
        if (reflect.Array.getLength(v3_7) != 0) {
            v3_2 = ((reflect.AnnotatedElement) reflect.Array.get(v3_7, this.index));
        } else {
            v3_2 = net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$NoOp.INSTANCE;
        }
        return v3_2;
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForWildcardLowerBoundType.resolve() calling method java.lang.reflect.Method.invoke()


    protected reflect.AnnotatedElement resolve(reflect.AnnotatedElement p3)
    {
        try {
            String v1_3 = new Object[0];
            return ((reflect.AnnotatedElement) reflect.Array.get(net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForWildcardLowerBoundType.GET_ANNOTATED_LOWER_BOUNDS.invoke(p3, v1_3), this.index));
        } catch (ClassCastException) {
            return net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$NoOp.INSTANCE;
        } catch (Throwable v3_3) {
            throw new IllegalStateException("Cannot access java.lang.reflect.AnnotatedWildcardType#getAnnotatedLowerBounds", v3_3);
        } catch (Throwable v3_1) {
            throw new IllegalStateException("Error invoking java.lang.reflect.AnnotatedWildcardType#getAnnotatedLowerBounds", v3_1.getCause());
        }
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForTypeVariableBoundType.resolve() calling method java.lang.reflect.Method.invoke()


    protected reflect.AnnotatedElement resolve(reflect.AnnotatedElement p3)
    {
        try {
            String v1_3 = new Object[0];
            return ((reflect.AnnotatedElement) reflect.Array.get(net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForTypeVariableBoundType.GET_ANNOTATED_BOUNDS.invoke(p3, v1_3), this.index));
        } catch (ClassCastException) {
            return net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$NoOp.INSTANCE;
        } catch (Throwable v3_3) {
            throw new IllegalStateException("Cannot access java.lang.reflect.AnnotatedTypeVariable#getAnnotatedBounds", v3_3);
        } catch (Throwable v3_1) {
            throw new IllegalStateException("Error invoking java.lang.reflect.AnnotatedTypeVariable#getAnnotatedBounds", v3_1.getCause());
        }
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForTypeArgument.resolve() calling method java.lang.reflect.Method.invoke()


    protected reflect.AnnotatedElement resolve(reflect.AnnotatedElement p3)
    {
        try {
            String v1_3 = new Object[0];
            return ((reflect.AnnotatedElement) reflect.Array.get(net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForTypeArgument.GET_ANNOTATED_ACTUAL_TYPE_ARGUMENTS.invoke(p3, v1_3), this.index));
        } catch (ClassCastException) {
            return net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$NoOp.INSTANCE;
        } catch (Throwable v3_3) {
            throw new IllegalStateException("Cannot access java.lang.reflect.AnnotatedParameterizedType#getAnnotatedActualTypeArguments", v3_3);
        } catch (Throwable v3_1) {
            throw new IllegalStateException("Error invoking java.lang.reflect.AnnotatedParameterizedType#getAnnotatedActualTypeArguments", v3_1.getCause());
        }
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForOwnerType.resolve() calling method java.lang.reflect.Method.invoke()


    protected reflect.AnnotatedElement resolve(reflect.AnnotatedElement p3)
    {
        try {
            String v1_3 = new Object[0];
            net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$NoOp v3_5 = ((reflect.AnnotatedElement) net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForOwnerType.GET_ANNOTATED_OWNER_TYPE.invoke(p3, v1_3));
        } catch (ClassCastException) {
            return net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$NoOp.INSTANCE;
        } catch (net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$NoOp v3_2) {
            throw new IllegalStateException("Cannot access java.lang.reflect.AnnotatedType#getAnnotatedOwnerType", v3_2);
        } catch (net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$NoOp v3_6) {
            throw new IllegalStateException("Error invoking java.lang.reflect.AnnotatedType#getAnnotatedOwnerType", v3_6.getCause());
        }
        if (v3_5 == null) {
            v3_5 = net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$NoOp.INSTANCE;
        }
        return v3_5;
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForComponentType.resolve() calling method java.lang.reflect.Method.invoke()


    protected reflect.AnnotatedElement resolve(reflect.AnnotatedElement p3)
    {
        try {
            String v1_3 = new Object[0];
            return ((reflect.AnnotatedElement) net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForComponentType.GET_ANNOTATED_GENERIC_COMPONENT_TYPE.invoke(p3, v1_3));
        } catch (ClassCastException) {
            return net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$NoOp.INSTANCE;
        } catch (Throwable v3_2) {
            throw new IllegalStateException("Cannot access java.lang.reflect.AnnotatedArrayType#getAnnotatedGenericComponentType", v3_2);
        } catch (Throwable v3_6) {
            throw new IllegalStateException("Error invoking java.lang.reflect.AnnotatedArrayType#getAnnotatedGenericComponentType", v3_6.getCause());
        }
    }

Method net.bytebuddy.description.annotation.AnnotationDescription$ForLoadedAnnotation.getValue() calling method java.lang.reflect.Method.invoke()


    public net.bytebuddy.description.annotation.AnnotationValue getValue(net.bytebuddy.description.method.MethodDescription$InDefinedShape p6)
    {
        if (!p6.getDeclaringType().represents(this.annotation.annotationType())) {
            Class v1_0 = new StringBuilder();
            v1_0.append(p6);
            v1_0.append(" does not represent ");
            v1_0.append(this.annotation.annotationType());
            throw new IllegalArgumentException(v1_0.toString());
        } else {
            try {
                Class v1_3;
                Object v0_3 = p6.getDeclaringType().isPublic();
            } catch (Object v0_8) {
                Object[] v2_4 = new StringBuilder();
                v2_4.append("Error reading annotation property ");
                v2_4.append(p6);
                throw new IllegalStateException(v2_4.toString(), v0_8.getCause());
            } catch (Object v0_6) {
                Object[] v2_2 = new StringBuilder();
                v2_2.append("Cannot access annotation property ");
                v2_2.append(p6);
                throw new IllegalStateException(v2_2.toString(), v0_6);
            }
            if (!(p6 instanceof net.bytebuddy.description.method.MethodDescription$ForLoadedMethod)) {
                v1_3 = 0;
            } else {
                v1_3 = ((net.bytebuddy.description.method.MethodDescription$ForLoadedMethod) p6).getLoadedMethod();
            }
            if ((v1_3 == null) || ((v1_3.getDeclaringClass() != this.annotation.annotationType()) || ((v0_3 == null) && (!v1_3.isAccessible())))) {
                Class[] v4_2 = new Class[0];
                v1_3 = this.annotation.annotationType().getMethod(p6.getName(), v4_2);
                if (v0_3 == null) {
                    java.security.AccessController.doPrivileged(new net.bytebuddy.utility.privilege.SetAccessibleAction(v1_3));
                }
            }
            Object[] v2_5 = new Object[0];
            return net.bytebuddy.description.annotation.AnnotationDescription$ForLoadedAnnotation.asValue(v1_3.invoke(this.annotation, v2_5), v1_3.getReturnType());
        }
    }

Method net.bytebuddy.description.annotation.AnnotationDescription$ForLoadedAnnotation.asValue() calling method java.lang.reflect.Method.invoke()


    private static java.util.Map asValue(otation.Annotation p9)
    {
        IllegalStateException v0_1 = new java.util.HashMap();
        String v1_7 = p9.annotationType().getDeclaredMethods();
        String v2_2 = v1_7.length;
        int v4 = 0;
        while (v4 < v2_2) {
            reflect.Method v5 = v1_7[v4];
            try {
                net.bytebuddy.description.annotation.AnnotationValue v7_0 = new Object[0];
                v0_1.put(v5.getName(), net.bytebuddy.description.annotation.AnnotationDescription$ForLoadedAnnotation.asValue(v5.invoke(p9, v7_0), v5.getReturnType()));
                v4++;
            } catch (IllegalAccessException v9_2) {
                String v1_5 = new StringBuilder();
                v1_5.append("Cannot read ");
                v1_5.append(v5);
                throw new IllegalStateException(v1_5.toString(), v9_2.getCause());
            } catch (IllegalAccessException v9_1) {
                String v1_1 = new StringBuilder();
                v1_1.append("Cannot access ");
                v1_1.append(v5);
                throw new IllegalStateException(v1_1.toString(), v9_1);
            }
        }
        return v0_1;
    }

Method kotlin.reflect.jvm.internal.impl.protobuf.GeneratedMessageLite.invokeOrDie() calling method java.lang.reflect.Method.invoke()


    static varargs Object invokeOrDie(reflect.Method p0, Object p1, Object[] p2)
    {
        try {
            return p0.invoke(p1, p2);
        } catch (Error v0_3) {
            throw new RuntimeException("Couldn\'t use Java reflection to implement protocol message reflection.", v0_3);
        } catch (Error v0_4) {
            Error v0_5 = v0_4.getCause();
            if ((v0_5 instanceof RuntimeException)) {
                throw ((RuntimeException) v0_5);
            } else {
                if (!(v0_5 instanceof Error)) {
                    throw new RuntimeException("Unexpected exception thrown by generated accessor method.", v0_5);
                } else {
                    throw ((Error) v0_5);
                }
            }
        }
    }

Method kotlin.reflect.jvm.internal.calls.AnnotationConstructorCallerKt$createAnnotationInstance$2.invoke() calling method java.lang.reflect.Method.invoke()


    public final boolean invoke(Object p7)
    {
        String v0_11;
        int v1_0 = 0;
        if ((p7 instanceof otation.Annotation)) {
            v0_11 = p7;
        } else {
            v0_11 = 0;
        }
        String v0_12 = ((otation.Annotation) v0_11);
        if (v0_12 != null) {
            String v0_15 = kotlin.jvm.JvmClassMappingKt.getAnnotationClass(v0_12);
            if (v0_15 != null) {
                v1_0 = kotlin.jvm.JvmClassMappingKt.getJavaClass(v0_15);
            }
        }
        int v1_1 = 1;
        if (!kotlin.jvm.internal.Intrinsics.areEqual(v1_0, this.$annotationClass)) {
            v1_1 = 0;
        } else {
            kotlin.TypeCastException v7_11;
            String v0_9 = ((Iterable) this.$methods);
            if ((!(v0_9 instanceof java.util.Collection)) || (!((java.util.Collection) v0_9).isEmpty())) {
                String v0_10 = v0_9.iterator();
                while (v0_10.hasNext()) {
                    boolean v3_1;
                    boolean v3_12 = ((reflect.Method) v0_10.next());
                    Object[] v4_6 = this.$values.get(v3_12.getName());
                    boolean v5_1 = new Object[0];
                    boolean v3_13 = v3_12.invoke(p7, v5_1);
                    if (!(v4_6 instanceof boolean[])) {
                        if (!(v4_6 instanceof char[])) {
                            if (!(v4_6 instanceof byte[])) {
                                if (!(v4_6 instanceof short[])) {
                                    if (!(v4_6 instanceof int[])) {
                                        if (!(v4_6 instanceof float[])) {
                                            if (!(v4_6 instanceof long[])) {
                                                if (!(v4_6 instanceof double[])) {
                                                    if (!(v4_6 instanceof Object[])) {
                                                        v3_1 = kotlin.jvm.internal.Intrinsics.areEqual(v4_6, v3_13);
                                                    } else {
                                                        if (!v3_13) {
                                                            throw new kotlin.TypeCastException("null cannot be cast to non-null type kotlin.Array<*>");
                                                        } else {
                                                            v3_1 = java.util.Arrays.equals(((Object[]) v4_6), ((Object[]) v3_13));
                                                        }
                                                    }
                                                } else {
                                                    if (!v3_13) {
                                                        throw new kotlin.TypeCastException("null cannot be cast to non-null type kotlin.DoubleArray");
                                                    } else {
                                                        v3_1 = java.util.Arrays.equals(((double[]) v4_6), ((double[]) v3_13));
                                                    }
                                                }
                                            } else {
                                                if (!v3_13) {
                                                    throw new kotlin.TypeCastException("null cannot be cast to non-null type kotlin.LongArray");
                                                } else {
                                                    v3_1 = java.util.Arrays.equals(((long[]) v4_6), ((long[]) v3_13));
                                                }
                                            }
                                        } else {
                                            if (!v3_13) {
                                                throw new kotlin.TypeCastException("null cannot be cast to non-null type kotlin.FloatArray");
                                            } else {
                                                v3_1 = java.util.Arrays.equals(((float[]) v4_6), ((float[]) v3_13));
                                            }
                                        }
                                    } else {
                                        if (!v3_13) {
                                            throw new kotlin.TypeCastException("null cannot be cast to non-null type kotlin.IntArray");
                                        } else {
                                            v3_1 = java.util.Arrays.equals(((int[]) v4_6), ((int[]) v3_13));
                                        }
                                    }
                                } else {
                                    if (!v3_13) {
                                        throw new kotlin.TypeCastException("null cannot be cast to non-null type kotlin.ShortArray");
                                    } else {
                                        v3_1 = java.util.Arrays.equals(((short[]) v4_6), ((short[]) v3_13));
                                    }
                                }
                            } else {
                                if (!v3_13) {
                                    throw new kotlin.TypeCastException("null cannot be cast to non-null type kotlin.ByteArray");
                                } else {
                                    v3_1 = java.util.Arrays.equals(((byte[]) v4_6), ((byte[]) v3_13));
                                }
                            }
                        } else {
                            if (!v3_13) {
                                throw new kotlin.TypeCastException("null cannot be cast to non-null type kotlin.CharArray");
                            } else {
                                v3_1 = java.util.Arrays.equals(((char[]) v4_6), ((char[]) v3_13));
                            }
                        }
                    } else {
                        if (!v3_13) {
                            throw new kotlin.TypeCastException("null cannot be cast to non-null type kotlin.BooleanArray");
                        } else {
                            v3_1 = java.util.Arrays.equals(((boolean[]) v4_6), ((boolean[]) v3_13));
                        }
                    }
                    if (!v3_1) {
                        v7_11 = 0;
                    }
                }
                v7_11 = 1;
            } else {
                v7_11 = 1;
            }
            if (v7_11 == null) {
            }
        }
        return v1_1;
    }

Method rx.internal.schedulers.NewThreadWorker.tryEnableCancelPolicy() calling method java.lang.reflect.Method.invoke()


    public static boolean tryEnableCancelPolicy(java.util.concurrent.ScheduledExecutorService p5)
    {
        if (rx.internal.schedulers.NewThreadWorker.SHOULD_TRY_ENABLE_CANCEL_POLICY) {
            rx.plugins.RxJavaErrorHandler v0_1;
            if (!(p5 instanceof java.util.concurrent.ScheduledThreadPoolExecutor)) {
                v0_1 = rx.internal.schedulers.NewThreadWorker.findSetRemoveOnCancelPolicyMethod(p5);
            } else {
                rx.plugins.RxJavaErrorHandler v0_5 = rx.internal.schedulers.NewThreadWorker.cachedSetRemoveOnCancelPolicyMethod;
                if (v0_5 != rx.internal.schedulers.NewThreadWorker.SET_REMOVE_ON_CANCEL_POLICY_METHOD_NOT_SUPPORTED) {
                    if (v0_5 != null) {
                        v0_1 = ((reflect.Method) v0_5);
                    } else {
                        Object v2_0;
                        v0_1 = rx.internal.schedulers.NewThreadWorker.findSetRemoveOnCancelPolicyMethod(p5);
                        if (v0_1 == null) {
                            v2_0 = rx.internal.schedulers.NewThreadWorker.SET_REMOVE_ON_CANCEL_POLICY_METHOD_NOT_SUPPORTED;
                        } else {
                            v2_0 = v0_1;
                        }
                        rx.internal.schedulers.NewThreadWorker.cachedSetRemoveOnCancelPolicyMethod = v2_0;
                    }
                } else {
                    return 0;
                }
            }
            if (v0_1 != null) {
                try {
                    Object[] v3 = new Object[1];
                    v3[0] = Boolean.valueOf(1);
                    v0_1.invoke(p5, v3);
                    return 1;
                } catch (Exception v5_1) {
                    rx.plugins.RxJavaPlugins.getInstance().getErrorHandler().handleError(v5_1);
                }
            }
        }
        return 0;
    }

Method org.objenesis.instantiator.gcj.GCJSerializationInstantiator.newInstance() calling method java.lang.reflect.Method.invoke()


    public Object newInstance()
    {
        try {
            Exception v0_0 = this.type;
            Object[] v3_1 = new Object[2];
            v3_1[0] = this.type;
            v3_1[1] = this.superType;
            return v0_0.cast(org.objenesis.instantiator.gcj.GCJSerializationInstantiator.newObjectMethod.invoke(org.objenesis.instantiator.gcj.GCJSerializationInstantiator.dummyStream, v3_1));
        } catch (Exception v0_2) {
            throw new org.objenesis.ObjenesisException(v0_2);
        }
    }

Method org.objenesis.instantiator.gcj.GCJInstantiator.newInstance() calling method java.lang.reflect.Method.invoke()


    public Object newInstance()
    {
        try {
            reflect.InvocationTargetException v0_0 = this.type;
            Object[] v3_1 = new Object[2];
            v3_1[0] = this.type;
            v3_1[1] = Object;
            return v0_0.cast(org.objenesis.instantiator.gcj.GCJInstantiator.newObjectMethod.invoke(org.objenesis.instantiator.gcj.GCJInstantiator.dummyStream, v3_1));
        } catch (reflect.InvocationTargetException v0_4) {
            throw new org.objenesis.ObjenesisException(v0_4);
        } catch (reflect.InvocationTargetException v0_3) {
            throw new org.objenesis.ObjenesisException(v0_3);
        } catch (reflect.InvocationTargetException v0_2) {
            throw new org.objenesis.ObjenesisException(v0_2);
        }
    }

Method net.bytebuddy.utility.JavaConstant$MethodHandle$Dispatcher$ForJava8CapableVm.reveal() calling method java.lang.reflect.Method.invoke()


    public Object reveal(Object p4, Object p5)
    {
        try {
            String v0_0 = this.revealDirect;
            Object[] v1_1 = new Object[1];
            v1_1[0] = p5;
            return v0_0.invoke(p4, v1_1);
        } catch (Throwable v4_2) {
            throw new IllegalStateException("Cannot access java.lang.invoke.MethodHandles.Lookup#revealDirect", v4_2);
        } catch (Throwable v4_4) {
            throw new IllegalStateException("Error invoking java.lang.invoke.MethodHandles.Lookup#revealDirect", v4_4.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Direct$ForJava7CapableVm.getClassLoadingLock() calling method java.lang.reflect.Method.invoke()


    public Object getClassLoadingLock(ClassLoader p4, String p5)
    {
        try {
            String v0_0 = this.getClassLoadingLock;
            Object[] v1_1 = new Object[1];
            v1_1[0] = p5;
            return v0_0.invoke(p4, v1_1);
        } catch (Throwable v4_2) {
            throw new IllegalStateException("Could not access java.lang.ClassLoader#getClassLoadingLock", v4_2);
        } catch (Throwable v4_4) {
            throw new IllegalStateException("Error invoking java.lang.ClassLoader#getClassLoadingLock", v4_4.getCause());
        }
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForTypeVariableBoundType$OfFormalTypeVariable.resolve() calling method java.lang.reflect.Method.invoke()


    public reflect.AnnotatedElement resolve()
    {
        try {
            String v2_3 = new Object[0];
            return ((reflect.AnnotatedElement) reflect.Array.get(net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$ForTypeVariableBoundType$OfFormalTypeVariable.GET_ANNOTATED_BOUNDS.invoke(this.typeVariable, v2_3), this.index));
        } catch (ClassCastException) {
            return net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$NoOp.INSTANCE;
        } catch (Throwable v0_3) {
            throw new IllegalStateException("Cannot access java.lang.reflect.TypeVariable#getAnnotatedBounds", v0_3);
        } catch (Throwable v0_1) {
            throw new IllegalStateException("Error invoking java.lang.reflect.TypeVariable#getAnnotatedBounds", v0_1.getCause());
        }
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm$AnnotatedSuperClass.resolve() calling method java.lang.reflect.Method.invoke()


    public reflect.AnnotatedElement resolve()
    {
        try {
            String v2_3 = new Object[0];
            return ((reflect.AnnotatedElement) net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm.access$300(this.this$0).invoke(this.type, v2_3));
        } catch (Throwable v0_3) {
            throw new IllegalStateException("Cannot access java.lang.Class#getAnnotatedSuperclass", v0_3);
        } catch (Throwable v0_1) {
            throw new IllegalStateException("Error invoking java.lang.Class#getAnnotatedSuperclass", v0_1.getCause());
        }
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm$AnnotatedReturnType.resolve() calling method java.lang.reflect.Method.invoke()


    public reflect.AnnotatedElement resolve()
    {
        try {
            String v2_3 = new Object[0];
            return ((reflect.AnnotatedElement) net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm.access$600(this.this$0).invoke(this.method, v2_3));
        } catch (Throwable v0_3) {
            throw new IllegalStateException("Cannot access java.lang.reflect.Method#getAnnotatedReturnType", v0_3);
        } catch (Throwable v0_1) {
            throw new IllegalStateException("Error invoking java.lang.reflect.Method#getAnnotatedReturnType", v0_1.getCause());
        }
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm$AnnotatedParameterizedType.resolve() calling method java.lang.reflect.Method.invoke()


    public reflect.AnnotatedElement resolve()
    {
        try {
            String v2_3 = new Object[0];
            return ((reflect.AnnotatedElement) reflect.Array.get(net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm.access$700(this.this$0).invoke(this.executable, v2_3), this.index));
        } catch (Throwable v0_6) {
            throw new IllegalStateException("Cannot access java.lang.reflect.Executable#getAnnotatedParameterTypes", v0_6);
        } catch (Throwable v0_3) {
            throw new IllegalStateException("Error invoking java.lang.reflect.Executable#getAnnotatedParameterTypes", v0_3.getCause());
        }
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm$AnnotatedInterfaceType.resolve() calling method java.lang.reflect.Method.invoke()


    public reflect.AnnotatedElement resolve()
    {
        try {
            String v2_3 = new Object[0];
            return ((reflect.AnnotatedElement) reflect.Array.get(net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm.access$400(this.this$0).invoke(this.type, v2_3), this.index));
        } catch (Throwable v0_6) {
            throw new IllegalStateException("Cannot access java.lang.Class#getAnnotatedInterfaces", v0_6);
        } catch (Throwable v0_3) {
            throw new IllegalStateException("Error invoking java.lang.Class#getAnnotatedInterfaces", v0_3.getCause());
        }
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm$AnnotatedFieldType.resolve() calling method java.lang.reflect.Method.invoke()


    public reflect.AnnotatedElement resolve()
    {
        try {
            String v2_3 = new Object[0];
            return ((reflect.AnnotatedElement) net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm.access$500(this.this$0).invoke(this.field, v2_3));
        } catch (Throwable v0_3) {
            throw new IllegalStateException("Cannot access java.lang.reflect.Field#getAnnotatedType", v0_3);
        } catch (Throwable v0_1) {
            throw new IllegalStateException("Error invoking java.lang.reflect.Field#getAnnotatedType", v0_1.getCause());
        }
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm$AnnotatedExceptionType.resolve() calling method java.lang.reflect.Method.invoke()


    public reflect.AnnotatedElement resolve()
    {
        try {
            String v2_3 = new Object[0];
            return ((reflect.AnnotatedElement) reflect.Array.get(net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm.access$800(this.this$0).invoke(this.executable, v2_3), this.index));
        } catch (Throwable v0_6) {
            throw new IllegalStateException("Cannot access java.lang.reflect.Executable#getAnnotatedExceptionTypes", v0_6);
        } catch (Throwable v0_3) {
            throw new IllegalStateException("Error invoking java.lang.reflect.Executable#getAnnotatedExceptionTypes", v0_3.getCause());
        }
    }

Method kotlin.reflect.jvm.internal.structure.ReflectJavaAnnotation.getArguments() calling method java.lang.reflect.Method.invoke()


    public java.util.Collection getArguments()
    {
        reflect.Method[] v0_3 = kotlin.jvm.JvmClassMappingKt.getJavaClass(kotlin.jvm.JvmClassMappingKt.getAnnotationClass(this.annotation)).getDeclaredMethods();
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v0_3, "annotation.annotationClass.java.declaredMethods");
        java.util.Collection v1_1 = ((java.util.Collection) new java.util.ArrayList(v0_3.length));
        int v2_1 = v0_3.length;
        int v4 = 0;
        while (v4 < v2_1) {
            kotlin.reflect.jvm.internal.structure.ReflectJavaAnnotationArgument v5_0 = v0_3[v4];
            String v8_0 = new Object[0];
            Object v7_1 = v5_0.invoke(this.annotation, v8_0);
            kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v7_1, "method.invoke(annotation)");
            kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v5_0, "method");
            v1_1.add(kotlin.reflect.jvm.internal.structure.ReflectJavaAnnotationArgument.Factory.create(v7_1, kotlin.reflect.jvm.internal.impl.name.Name.identifier(v5_0.getName())));
            v4++;
        }
        return ((java.util.Collection) ((java.util.List) v1_1));
    }

Method kotlin.reflect.jvm.internal.calls.CallerImpl$Method.callMethod() calling method java.lang.reflect.Method.invoke()


    protected final Object callMethod(Object p3, Object[] p4)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p4, "args");
        kotlin.Unit v3_1 = ((reflect.Method) this.getMember()).invoke(p3, java.util.Arrays.copyOf(p4, p4.length));
        if (this.isVoidMethod) {
            v3_1 = kotlin.Unit.INSTANCE;
        }
        return v3_1;
    }

Method org.slf4j.helpers.SubstituteLogger.log() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method org.parceler.InjectionUtil$SetMethodPrivilegedAction.run() calling method java.lang.reflect.Method.invoke()


    public Object run(reflect.Method p3)
    {
        return p3.invoke(this.target, this.args);
    }

Method org.objenesis.instantiator.perc.PercSerializationInstantiator.newInstance() calling method java.lang.reflect.Method.invoke()


    public Object newInstance()
    {
        try {
            return this.newInstanceMethod.invoke(0, this.typeArgs);
        } catch (reflect.InvocationTargetException v0_1) {
            throw new org.objenesis.ObjenesisException(v0_1);
        } catch (reflect.InvocationTargetException v0_3) {
            throw new org.objenesis.ObjenesisException(v0_3);
        }
    }

Method org.objenesis.instantiator.perc.PercSerializationInstantiator.<init>() calling method java.lang.reflect.Method.invoke()


    public PercSerializationInstantiator(Class p11)
    {
        org.objenesis.ObjenesisException v0_0 = p11;
        while (java.io.Serializable.isAssignableFrom(v0_0)) {
            v0_0 = v0_0.getSuperclass();
        }
        try {
            Object v1_10 = Class.forName("COM.newmonics.PercClassLoader.Method");
            String v5_0 = new Class[3];
            v5_0[0] = Class;
            v5_0[1] = Object;
            v5_0[2] = v1_10;
            this.newInstanceMethod = java.io.ObjectInputStream.getDeclaredMethod("noArgConstruct", v5_0);
            this.newInstanceMethod.setAccessible(1);
            Object v1_4 = Class.forName("COM.newmonics.PercClassLoader.PercClass");
            Object[] v3_1 = new Class[1];
            v3_1[0] = Class;
            Object v1_5 = v1_4.getDeclaredMethod("getPercClass", v3_1);
            Object[] v3_2 = new Object[1];
            v3_2[0] = v0_0;
            Object v1_6 = v1_5.invoke(0, v3_2);
            Object[] v2_2 = v1_6.getClass();
            String v5_2 = new Class[1];
            v5_2[0] = String;
            Object[] v2_3 = v2_2.getDeclaredMethod("findMethod", v5_2);
            Object[] v3_4 = new Object[1];
            v3_4[0] = "<init>()V";
            Object v1_8 = v2_3.invoke(v1_6, v3_4);
            Object[] v2_4 = new Object[3];
            v2_4[0] = v0_0;
            v2_4[1] = p11;
            v2_4[2] = v1_8;
            this.typeArgs = v2_4;
            return;
        } catch (IllegalAccessException v11_4) {
            throw new org.objenesis.ObjenesisException(v11_4);
        } catch (IllegalAccessException v11_3) {
            throw new org.objenesis.ObjenesisException(v11_3);
        } catch (IllegalAccessException v11_2) {
            throw new org.objenesis.ObjenesisException(v11_2);
        } catch (IllegalAccessException v11_1) {
            throw new org.objenesis.ObjenesisException(v11_1);
        }
    }

Method org.objenesis.instantiator.perc.PercInstantiator.newInstance() calling method java.lang.reflect.Method.invoke()


    public Object newInstance()
    {
        try {
            return this.newInstanceMethod.invoke(0, this.typeArgs);
        } catch (Exception v0_2) {
            throw new org.objenesis.ObjenesisException(v0_2);
        }
    }

Method org.objenesis.instantiator.basic.ObjectStreamClassInstantiator.newInstance() calling method java.lang.reflect.Method.invoke()


    public Object newInstance()
    {
        try {
            Object[] v2_1 = new Object[0];
            return org.objenesis.instantiator.basic.ObjectStreamClassInstantiator.newInstanceMethod.invoke(this.objStreamClass, v2_1);
        } catch (Exception v0_2) {
            throw new org.objenesis.ObjenesisException(v0_2);
        }
    }

Method org.objenesis.instantiator.android.AndroidSerializationInstantiator.newInstance() calling method java.lang.reflect.Method.invoke()


    public Object newInstance()
    {
        try {
            reflect.InvocationTargetException v0_0 = this.type;
            org.objenesis.ObjenesisException v1_0 = this.newInstanceMethod;
            java.io.ObjectStreamClass v2 = this.objectStreamClass;
            Object[] v3_1 = new Object[1];
            v3_1[0] = this.type;
            return v0_0.cast(v1_0.invoke(v2, v3_1));
        } catch (reflect.InvocationTargetException v0_4) {
            throw new org.objenesis.ObjenesisException(v0_4);
        } catch (reflect.InvocationTargetException v0_3) {
            throw new org.objenesis.ObjenesisException(v0_3);
        } catch (reflect.InvocationTargetException v0_2) {
            throw new org.objenesis.ObjenesisException(v0_2);
        }
    }

Method org.objenesis.instantiator.android.AndroidSerializationInstantiator.<init>() calling method java.lang.reflect.Method.invoke()


    public AndroidSerializationInstantiator(Class p7)
    {
        this.type = p7;
        this.newInstanceMethod = org.objenesis.instantiator.android.AndroidSerializationInstantiator.getNewInstanceMethod();
        try {
            Class[] v3 = new Class[1];
            v3[0] = Class;
            org.objenesis.ObjenesisException v0_0 = java.io.ObjectStreamClass.getMethod("lookupAny", v3);
            try {
                Object[] v2_0 = new Object[1];
                v2_0[0] = p7;
                this.objectStreamClass = ((java.io.ObjectStreamClass) v0_0.invoke(0, v2_0));
                return;
            } catch (reflect.InvocationTargetException v7_5) {
                throw new org.objenesis.ObjenesisException(v7_5);
            } catch (reflect.InvocationTargetException v7_4) {
                throw new org.objenesis.ObjenesisException(v7_4);
            }
        } catch (reflect.InvocationTargetException v7_1) {
            throw new org.objenesis.ObjenesisException(v7_1);
        }
        v2_0 = new Object[1];
        v2_0[0] = p7;
        this.objectStreamClass = ((java.io.ObjectStreamClass) v0_0.invoke(0, v2_0));
        return;
    }

Method org.objenesis.instantiator.android.Android18Instantiator.newInstance() calling method java.lang.reflect.Method.invoke()


    public Object newInstance()
    {
        try {
            Exception v0_0 = this.type;
            org.objenesis.ObjenesisException v1_0 = this.newInstanceMethod;
            Object[] v3_1 = new Object[2];
            v3_1[0] = this.type;
            v3_1[1] = this.objectConstructorId;
            return v0_0.cast(v1_0.invoke(0, v3_1));
        } catch (Exception v0_2) {
            throw new org.objenesis.ObjenesisException(v0_2);
        }
    }

Method org.objenesis.instantiator.android.Android18Instantiator.findConstructorIdForJavaLangObjectConstructor() calling method java.lang.reflect.Method.invoke()


    private static Long findConstructorIdForJavaLangObjectConstructor()
    {
        try {
            Class v3_1 = new Class[1];
            v3_1[0] = Class;
            reflect.InvocationTargetException v0_7 = java.io.ObjectStreamClass.getDeclaredMethod("getConstructorId", v3_1);
            v0_7.setAccessible(1);
            Object[] v2_0 = new Object[1];
            v2_0[0] = Object;
            return ((Long) v0_7.invoke(0, v2_0));
        } catch (reflect.InvocationTargetException v0_6) {
            throw new org.objenesis.ObjenesisException(v0_6);
        } catch (reflect.InvocationTargetException v0_5) {
            throw new org.objenesis.ObjenesisException(v0_5);
        } catch (reflect.InvocationTargetException v0_4) {
            throw new org.objenesis.ObjenesisException(v0_4);
        } catch (reflect.InvocationTargetException v0_3) {
            throw new org.objenesis.ObjenesisException(v0_3);
        }
    }

Method org.objenesis.instantiator.android.Android17Instantiator.newInstance() calling method java.lang.reflect.Method.invoke()


    public Object newInstance()
    {
        try {
            Exception v0_0 = this.type;
            org.objenesis.ObjenesisException v1_0 = this.newInstanceMethod;
            Object[] v3_1 = new Object[2];
            v3_1[0] = this.type;
            v3_1[1] = this.objectConstructorId;
            return v0_0.cast(v1_0.invoke(0, v3_1));
        } catch (Exception v0_2) {
            throw new org.objenesis.ObjenesisException(v0_2);
        }
    }

Method org.objenesis.instantiator.android.Android17Instantiator.findConstructorIdForJavaLangObjectConstructor() calling method java.lang.reflect.Method.invoke()


    private static Integer findConstructorIdForJavaLangObjectConstructor()
    {
        try {
            Class v3_1 = new Class[1];
            v3_1[0] = Class;
            reflect.InvocationTargetException v0_7 = java.io.ObjectStreamClass.getDeclaredMethod("getConstructorId", v3_1);
            v0_7.setAccessible(1);
            Object[] v2_0 = new Object[1];
            v2_0[0] = Object;
            return ((Integer) v0_7.invoke(0, v2_0));
        } catch (reflect.InvocationTargetException v0_6) {
            throw new org.objenesis.ObjenesisException(v0_6);
        } catch (reflect.InvocationTargetException v0_5) {
            throw new org.objenesis.ObjenesisException(v0_5);
        } catch (reflect.InvocationTargetException v0_4) {
            throw new org.objenesis.ObjenesisException(v0_4);
        } catch (reflect.InvocationTargetException v0_3) {
            throw new org.objenesis.ObjenesisException(v0_3);
        }
    }

Method org.objenesis.instantiator.android.Android10Instantiator.newInstance() calling method java.lang.reflect.Method.invoke()


    public Object newInstance()
    {
        try {
            Exception v0_0 = this.type;
            org.objenesis.ObjenesisException v1_0 = this.newStaticMethod;
            Object[] v3_1 = new Object[2];
            v3_1[0] = this.type;
            v3_1[1] = Object;
            return v0_0.cast(v1_0.invoke(0, v3_1));
        } catch (Exception v0_2) {
            throw new org.objenesis.ObjenesisException(v0_2);
        }
    }

Method org.mockito.internal.stubbing.defaultanswers.ForwardsInvocations.answer() calling method java.lang.reflect.Method.invoke()


    public Object answer(org.mockito.invocation.InvocationOnMock p5)
    {
        reflect.Method v0 = p5.getMethod();
        try {
            org.mockito.exceptions.base.MockitoException v1_1 = this.getDelegateMethod(v0);
        } catch (NoSuchMethodException) {
            throw org.mockito.internal.exceptions.Reporter.delegatedMethodDoesNotExistOnDelegate(v0, p5.getMock(), this.delegatedObject);
        } catch (Object v5_1) {
            throw v5_1.getCause();
        }
        if (!org.mockito.internal.stubbing.defaultanswers.ForwardsInvocations.compatibleReturnTypes(v0.getReturnType(), v1_1.getReturnType())) {
            throw org.mockito.internal.exceptions.Reporter.delegatedMethodHasWrongReturnType(v0, v1_1, p5.getMock(), this.delegatedObject);
        } else {
            p5 = v1_1.invoke(this.delegatedObject, ((org.mockito.invocation.Invocation) p5).getRawArguments());
            return p5;
        }
    }

Method org.junit.runners.model.FrameworkMethod$1.runReflectiveCall() calling method java.lang.reflect.Method.invoke()


    protected Object runReflectiveCall()
    {
        return org.junit.runners.model.FrameworkMethod.access$000(this.this$0).invoke(this.val$target, this.val$params);
    }

Method org.apache.http.client.utils.JdkIdn.toUnicode() calling method java.lang.reflect.Method.invoke()


    public String toUnicode(String p5)
    {
        try {
            RuntimeException v0_0 = this.toUnicode;
            Object[] v2_1 = new Object[1];
            v2_1[0] = p5;
            return ((String) v0_0.invoke(0, v2_1));
        } catch (Throwable v5_3) {
            throw new IllegalStateException(v5_3.getMessage(), v5_3);
        } catch (Throwable v5_1) {
            Throwable v5_2 = v5_1.getCause();
            throw new RuntimeException(v5_2.getMessage(), v5_2);
        }
    }

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


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

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


    public void configureTlsExtensions(javax.net.ssl.SSLSocket p6, String p7, java.util.List p8)
    {
        String v7_0 = okhttp3.internal.platform.JdkWithJettyBootPlatform.alpnProtocolNames(p8);
        try {
            reflect.Method v8_3 = okhttp3.internal.platform.Platform.getClassLoader();
            int v1_1 = new Class[2];
            v1_1[0] = this.clientProviderClass;
            v1_1[1] = this.serverProviderClass;
            String v7_1 = reflect.Proxy.newProxyInstance(v8_3, v1_1, new okhttp3.internal.platform.JdkWithJettyBootPlatform$JettyNegoProvider(v7_0));
            reflect.Method v8_1 = this.putMethod;
            Object[] v0_0 = new Object[2];
            v0_0[0] = p6;
            v0_0[1] = v7_1;
            v8_1.invoke(0, v0_0);
            return;
        } catch (AssertionError v6_1) {
            throw okhttp3.internal.Util.assertionError("unable to set alpn", v6_1);
        } catch (AssertionError v6_1) {
        }
    }

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


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

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


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

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


    public void configureTlsExtensions(javax.net.ssl.SSLSocket p5, String p6, java.util.List p7)
    {
        try {
            String v6_0 = p5.getSSLParameters();
            Object[] v7_2 = okhttp3.internal.platform.Jdk9Platform.alpnProtocolNames(p7);
            reflect.Method v0 = this.setProtocolMethod;
            Object[] v1_1 = new Object[1];
            String[] v3_0 = new String[v7_2.size()];
            v1_1[0] = v7_2.toArray(v3_0);
            v0.invoke(v6_0, v1_1);
            p5.setSSLParameters(v6_0);
            return;
        } catch (AssertionError v5_1) {
            throw okhttp3.internal.Util.assertionError("unable to set ssl parameters", v5_1);
        } catch (AssertionError v5_1) {
        }
    }

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


    public boolean isCleartextTrafficPermitted(String p5)
    {
        try {
            String v0_2 = Class.forName("android.security.NetworkSecurityPolicy");
            int v3_0 = new Class[0];
            Object[] v2_1 = new Object[0];
            AssertionError v5_1 = this.api24IsCleartextTrafficPermitted(p5, v0_2, v0_2.getMethod("getInstance", v3_0).invoke(0, v2_1));
            return v5_1;
        } catch (ClassNotFoundException) {
            return super.isCleartextTrafficPermitted(v5_1);
        } catch (AssertionError v5_2) {
            throw okhttp3.internal.Util.assertionError("unable to determine cleartext support", v5_2);
        } catch (AssertionError v5_2) {
        } catch (AssertionError v5_2) {
        }
    }

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


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

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


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

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


    public java.security.cert.X509Certificate findByIssuerAndSignature(java.security.cert.X509Certificate p6)
    {
        java.security.cert.X509Certificate v0_0 = 0;
        try {
            reflect.Method v1 = this.findByIssuerAndSignatureMethod;
            javax.net.ssl.X509TrustManager v2 = this.trustManager;
            Object[] v3_1 = new Object[1];
            v3_1[0] = p6;
            AssertionError v6_4 = ((java.security.cert.TrustAnchor) v1.invoke(v2, v3_1));
        } catch (AssertionError v6_1) {
            throw okhttp3.internal.Util.assertionError("unable to get issues and signature", v6_1);
        } catch (reflect.InvocationTargetException) {
            return v0_0;
        }
        if (v6_4 != null) {
            v0_0 = v6_4.getTrustedCert();
        }
        return v0_0;
    }

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


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

Method net.bytebuddy.utility.JavaModule$Dispatcher$Enabled.moduleOf() calling method java.lang.reflect.Method.invoke()


    public net.bytebuddy.utility.JavaModule moduleOf(Class p4)
    {
        try {
            reflect.Method v2_5 = new Object[0];
            return new net.bytebuddy.utility.JavaModule(this.getModule.invoke(p4, v2_5));
        } catch (Throwable v4_2) {
            String v1_5 = new StringBuilder();
            v1_5.append("Cannot access ");
            v1_5.append(this.getModule);
            throw new IllegalStateException(v1_5.toString(), v4_2);
        } catch (Throwable v4_4) {
            String v1_2 = new StringBuilder();
            v1_2.append("Cannot invoke ");
            v1_2.append(this.getModule);
            throw new IllegalStateException(v1_2.toString(), v4_4.getCause());
        }
    }

Method net.bytebuddy.utility.JavaModule$Dispatcher$Enabled.isNamed() calling method java.lang.reflect.Method.invoke()


    public boolean isNamed(Object p4)
    {
        try {
            String v1_4 = new Object[0];
            return ((Boolean) this.isNamed.invoke(p4, v1_4)).booleanValue();
        } catch (Throwable v4_2) {
            String v1_6 = new StringBuilder();
            v1_6.append("Cannot access ");
            v1_6.append(this.isNamed);
            throw new IllegalStateException(v1_6.toString(), v4_2);
        } catch (Throwable v4_6) {
            String v1_2 = new StringBuilder();
            v1_2.append("Cannot invoke ");
            v1_2.append(this.isNamed);
            throw new IllegalStateException(v1_2.toString(), v4_6.getCause());
        }
    }

Method net.bytebuddy.dynamic.ClassFileLocator$AgentBased.fromInstalledAgent() calling method java.lang.reflect.Method.invoke()


    public static net.bytebuddy.dynamic.ClassFileLocator fromInstalledAgent(ClassLoader p5)
    {
        try {
            Class[] v4 = new Class[0];
            Object[] v3_0 = new Object[0];
            return new net.bytebuddy.dynamic.ClassFileLocator$AgentBased(((instrument.Instrumentation) ClassLoader.getSystemClassLoader().loadClass("net.bytebuddy.agent.Installer").getMethod("getInstrumentation", v4).invoke(net.bytebuddy.dynamic.ClassFileLocator$AgentBased.STATIC_MEMBER, v3_0)), p5);
        } catch (Exception v5_2) {
            throw v5_2;
        } catch (Exception v5_1) {
            throw new IllegalStateException("The Byte Buddy agent is not installed or not accessible", v5_1);
        }
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm.resolveReceiverType() calling method java.lang.reflect.Method.invoke()


    public net.bytebuddy.description.type.TypeDescription$Generic resolveReceiverType(reflect.AccessibleObject p3)
    {
        try {
            String v1_3 = new Object[0];
            return this.resolve(((reflect.AnnotatedElement) this.getAnnotatedReceiverType.invoke(p3, v1_3)));
        } catch (Throwable v3_2) {
            throw new IllegalStateException("Cannot access java.lang.reflect.Executable#getAnnotatedReceiverType", v3_2);
        } catch (Throwable v3_6) {
            throw new IllegalStateException("Error invoking java.lang.reflect.Executable#getAnnotatedReceiverType", v3_6.getCause());
        }
    }

Method net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm.resolve() calling method java.lang.reflect.Method.invoke()


    public net.bytebuddy.description.type.TypeDescription$Generic resolve(reflect.AnnotatedElement p3)
    {
        try {
            Throwable v3_1;
            if (p3 != null) {
                String v1_3 = new Object[0];
                v3_1 = net.bytebuddy.description.type.TypeDefinition$Sort.describe(((reflect.Type) this.getType.invoke(p3, v1_3)), new net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm$Resolved(p3));
            } else {
                v3_1 = net.bytebuddy.description.type.TypeDescription$Generic.UNDEFINED;
            }
        } catch (Throwable v3_4) {
            throw new IllegalStateException("Cannot access java.lang.reflect.AnnotatedType#getType", v3_4);
        } catch (Throwable v3_2) {
            throw new IllegalStateException("Error invoking java.lang.reflect.AnnotatedType#getType", v3_2.getCause());
        }
        return v3_1;
    }

Method net.bytebuddy.description.method.ParameterList$ForLoadedExecutable$Dispatcher$ForJava8CapableVm.getParameterCount() calling method java.lang.reflect.Method.invoke()


    public int getParameterCount(Object p3)
    {
        try {
            String v1_3 = new Object[0];
            return ((Integer) this.getParameterCount.invoke(p3, v1_3)).intValue();
        } catch (Throwable v3_2) {
            throw new IllegalStateException("Cannot access java.lang.reflect.Parameter#getModifiers", v3_2);
        } catch (Throwable v3_6) {
            throw new IllegalStateException("Error invoking java.lang.reflect.Parameter#getModifiers", v3_6.getCause());
        }
    }

Method net.bytebuddy.description.method.ParameterDescription$ForLoadedParameter$Dispatcher$ForJava8CapableVm.isNamePresent() calling method java.lang.reflect.Method.invoke()


    public boolean isNamePresent(reflect.AccessibleObject p2, int p3)
    {
        try {
            IllegalStateException v3_6 = new Object[0];
            return ((Boolean) this.isNamePresent.invoke(this.getParameter(p2, p3), v3_6)).booleanValue();
        } catch (Throwable v2_3) {
            throw new IllegalStateException("Cannot access java.lang.reflect.Parameter#isNamePresent", v2_3);
        } catch (Throwable v2_1) {
            throw new IllegalStateException("Error invoking java.lang.reflect.Parameter#isNamePresent", v2_1.getCause());
        }
    }

Method net.bytebuddy.description.method.ParameterDescription$ForLoadedParameter$Dispatcher$ForJava8CapableVm.getName() calling method java.lang.reflect.Method.invoke()


    public String getName(reflect.AccessibleObject p2, int p3)
    {
        try {
            IllegalStateException v3_6 = new Object[0];
            return ((String) this.getName.invoke(this.getParameter(p2, p3), v3_6));
        } catch (Throwable v2_2) {
            throw new IllegalStateException("Cannot access java.lang.reflect.Parameter#getName", v2_2);
        } catch (Throwable v2_6) {
            throw new IllegalStateException("Error invoking java.lang.reflect.Parameter#getName", v2_6.getCause());
        }
    }

Method net.bytebuddy.description.method.ParameterDescription$ForLoadedParameter$Dispatcher$ForJava8CapableVm.getModifiers() calling method java.lang.reflect.Method.invoke()


    public int getModifiers(reflect.AccessibleObject p2, int p3)
    {
        try {
            IllegalStateException v3_6 = new Object[0];
            return ((Integer) this.getModifiers.invoke(this.getParameter(p2, p3), v3_6)).intValue();
        } catch (Throwable v2_3) {
            throw new IllegalStateException("Cannot access java.lang.reflect.Parameter#getModifiers", v2_3);
        } catch (Throwable v2_1) {
            throw new IllegalStateException("Error invoking java.lang.reflect.Parameter#getModifiers", v2_1.getCause());
        }
    }

Method net.bytebuddy.description.method.ParameterDescription$ForLoadedParameter$Dispatcher$ForJava8CapableVm.getParameter() calling method java.lang.reflect.Method.invoke()


    private Object getParameter(reflect.AccessibleObject p3, int p4)
    {
        try {
            Object[] v1_1 = new Object[0];
            return reflect.Array.get(this.getParameters.invoke(p3, v1_1), p4);
        } catch (Throwable v3_2) {
            throw new IllegalStateException("Cannot access java.lang.reflect.Executable#getParameters", v3_2);
        } catch (Throwable v3_5) {
            throw new IllegalStateException("Error invoking java.lang.reflect.Executable#getParameters", v3_5.getCause());
        }
    }

Method net.bytebuddy.agent.builder.AgentBuilder$Default.installOnByteBuddyAgent() calling method java.lang.reflect.Method.invoke()


    public net.bytebuddy.agent.builder.ResettableClassFileTransformer installOnByteBuddyAgent()
    {
        try {
            Class[] v3 = new Class[0];
            String v2_0 = new Object[0];
            return this.installOn(((instrument.Instrumentation) ClassLoader.getSystemClassLoader().loadClass("net.bytebuddy.agent.Installer").getMethod("getInstrumentation", v3).invoke(net.bytebuddy.agent.builder.AgentBuilder$Default.STATIC_MEMBER, v2_0)));
        } catch (Exception v0_5) {
            throw v0_5;
        } catch (Exception v0_4) {
            throw new IllegalStateException("The Byte Buddy agent is not installed or not accessible", v0_4);
        }
    }

Method net.bytebuddy.agent.ByteBuddyAgent$ProcessProvider$ForCurrentVm$ForJava9CapableVm.resolve() calling method java.lang.reflect.Method.invoke()


    public String resolve()
    {
        try {
            Object[] v4 = new Object[0];
            String v2_3 = new Object[0];
            return this.getPid.invoke(this.current.invoke(net.bytebuddy.agent.ByteBuddyAgent.access$100(), v4), v2_3).toString();
        } catch (Throwable v0_5) {
            throw new IllegalStateException("Cannot access Java 9 process API", v0_5);
        } catch (Throwable v0_3) {
            throw new IllegalStateException("Error when accessing Java 9 process API", v0_3.getCause());
        }
    }

Method net.bytebuddy.agent.ByteBuddyAgent$AttachmentTypeEvaluator$ForJava9CapableVm.requiresExternalAttachment() calling method java.lang.reflect.Method.invoke()


    public boolean requiresExternalAttachment(String p6)
    {
        try {
            Object[] v4 = new Object[0];
            Object[] v2_1 = new Object[0];
            return this.getPid.invoke(this.current.invoke(net.bytebuddy.agent.ByteBuddyAgent.access$100(), v4), v2_1).equals(p6);
        } catch (Throwable v6_4) {
            throw new IllegalStateException("Cannot access Java 9 process API", v6_4);
        } catch (Throwable v6_2) {
            throw new IllegalStateException("Error when accessing Java 9 process API", v6_2.getCause());
        }
    }

Method net.bytebuddy.ClassFileVersion$VersionLocator$ForJava9CapableVm.locate() calling method java.lang.reflect.Method.invoke()


    public net.bytebuddy.ClassFileVersion locate()
    {
        try {
            Object[] v4 = new Object[0];
            String v2_3 = new Object[0];
            return net.bytebuddy.ClassFileVersion.ofJavaVersion(((Integer) this.major.invoke(this.current.invoke(net.bytebuddy.ClassFileVersion$VersionLocator$ForJava9CapableVm.STATIC_METHOD, v4), v2_3)).intValue());
        } catch (Throwable v0_6) {
            throw new IllegalStateException("Could not access VM version lookup", v0_6);
        } catch (Throwable v0_4) {
            throw new IllegalStateException("Could not look up VM version", v0_4.getCause());
        }
    }

Method kotlin.reflect.jvm.internal.calls.InternalUnderlyingValOfInlineClass.callMethod() calling method java.lang.reflect.Method.invoke()


    protected final Object callMethod(Object p3, Object[] p4)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p4, "args");
        return this.unboxMethod.invoke(p3, java.util.Arrays.copyOf(p4, p4.length));
    }

Method kotlin.reflect.jvm.internal.calls.InlineClassAwareCaller.call() calling method java.lang.reflect.Method.invoke()


    public Object call(Object[] p10)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p10, "args");
        Object v0_2 = this.data;
        int v1_2 = v0_2.component1();
        Object[] v2_2 = v0_2.component2();
        Object v0_4 = v0_2.component3();
        Object[] v3_0 = java.util.Arrays.copyOf(p10, p10.length);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v3_0, "java.util.Arrays.copyOf(this, size)");
        if (v3_0 == null) {
            throw new kotlin.TypeCastException("null cannot be cast to non-null type kotlin.Array<kotlin.Any?>");
        } else {
            int v4_1 = v1_2.getFirst();
            int v1_0 = v1_2.getLast();
            if (v4_1 <= v1_0) {
                while(true) {
                    reflect.Method v6 = v2_2[v4_1];
                    Object v7 = p10[v4_1];
                    if ((v6 != null) && (v7 != null)) {
                        Object[] v8 = new Object[0];
                        v7 = v6.invoke(v7, v8);
                    }
                    v3_0[v4_1] = v7;
                    if (v4_1 == v1_0) {
                        break;
                    }
                    v4_1++;
                }
            }
            Object v10_4 = this.caller.call(v3_0);
            if (v0_4 != null) {
                Object[] v2_1 = new Object[1];
                v2_1[0] = v10_4;
                Object v0_3 = v0_4.invoke(0, v2_1);
                if (v0_3 != null) {
                    v10_4 = v0_3;
                }
            }
            return v10_4;
        }
    }

Method junit.runner.BaseTestRunner.getTest() calling method java.lang.reflect.Method.invoke()


    public junit.framework.Test getTest(String p5)
    {
        if (p5.length() > 0) {
            try {
                String v5_3 = this.loadSuiteClass(p5);
                try {
                    Class[] v3 = new Class[0];
                    String v5_6 = v5_3.getMethod("suite", v3);
                } catch (Exception) {
                    this.clearStatus();
                    return new junit.framework.TestSuite(v5_6);
                }
                if (reflect.Modifier.isStatic(v5_6.getModifiers())) {
                    try {
                        StringBuilder v0_10 = new Object[0];
                        String v5_8 = ((junit.framework.Test) v5_6.invoke(0, v0_10));
                    } catch (String v5_13) {
                        StringBuilder v0_14 = new StringBuilder();
                        v0_14.append("Failed to invoke suite():");
                        v0_14.append(v5_13.getTargetException().toString());
                        this.runFailed(v0_14.toString());
                        return 0;
                    } catch (String v5_9) {
                        StringBuilder v0_12 = new StringBuilder();
                        v0_12.append("Failed to invoke suite():");
                        v0_12.append(v5_9.toString());
                        this.runFailed(v0_12.toString());
                        return 0;
                    }
                    if (v5_8 != null) {
                        this.clearStatus();
                        return v5_8;
                    } else {
                        return v5_8;
                    }
                } else {
                    this.runFailed("Suite() method must be static");
                    return 0;
                }
            } catch (String v5_11) {
                StringBuilder v0_16 = new StringBuilder();
                v0_16.append("Error: ");
                v0_16.append(v5_11.toString());
                this.runFailed(v0_16.toString());
                return 0;
            } catch (StringBuilder v0_1) {
                StringBuilder v0_2 = v0_1.getMessage();
                if (v0_2 != null) {
                    v5_3 = v0_2;
                }
                StringBuilder v0_4 = new StringBuilder();
                v0_4.append("Class not found \"");
                v0_4.append(v5_3);
                v0_4.append("\"");
                this.runFailed(v0_4.toString());
                return 0;
            }
        } else {
            this.clearStatus();
            return 0;
        }
    }

Method junit.framework.TestCase.runTest() calling method java.lang.reflect.Method.invoke()


    protected void runTest()
    {
        junit.framework.TestCase.assertNotNull("TestCase.fName cannot be null", this.fName);
        try {
            IllegalAccessException v0_1 = this.getClass().getMethod(this.fName, ((Class[]) 0));
        } catch (NoSuchMethodException) {
            Object[] v1_2 = new StringBuilder();
            v1_2.append("Method \"");
            v1_2.append(this.fName);
            v1_2.append("\" not found");
            junit.framework.TestCase.fail(v1_2.toString());
        }
        if (!reflect.Modifier.isPublic(v0_1.getModifiers())) {
            Object[] v1_7 = new StringBuilder();
            v1_7.append("Method \"");
            v1_7.append(this.fName);
            v1_7.append("\" should be public");
            junit.framework.TestCase.fail(v1_7.toString());
        }
        try {
            Object[] v1_10 = new Object[0];
            v0_1.invoke(this, v1_10);
            return;
        } catch (IllegalAccessException v0_4) {
            v0_4.fillInStackTrace();
            throw v0_4.getTargetException();
        } catch (IllegalAccessException v0_3) {
            v0_3.fillInStackTrace();
            throw v0_3;
        }
    }

Method retrofit2.Retrofit$1.invoke() calling method java.lang.reflect.Method.invoke()


    public Object invoke(Object p3, reflect.Method p4, Object[] p5)
    {
        if (p4.getDeclaringClass() != Object) {
            if (!this.platform.isDefaultMethod(p4)) {
                Object v3_1 = this.this$0.loadServiceMethod(p4);
                return v3_1.adapt(new retrofit2.OkHttpCall(v3_1, p5));
            } else {
                return this.platform.invokeDefaultMethod(p4, this.val$service, p3, p5);
            }
        } else {
            return p4.invoke(this, p5);
        }
    }

Method org.objenesis.instantiator.sun.SunReflectionFactoryHelper.newConstructorForSerialization() calling method java.lang.reflect.Method.invoke()


    public static reflect.Constructor newConstructorForSerialization(Class p4, reflect.Constructor p5)
    {
        reflect.Method v0_0 = org.objenesis.instantiator.sun.SunReflectionFactoryHelper.getReflectionFactoryClass();
        Object v1 = org.objenesis.instantiator.sun.SunReflectionFactoryHelper.createReflectionFactory(v0_0);
        reflect.Method v0_1 = org.objenesis.instantiator.sun.SunReflectionFactoryHelper.getNewConstructorForSerializationMethod(v0_0);
        try {
            Object[] v2_1 = new Object[2];
            v2_1[0] = p4;
            v2_1[1] = p5;
            return ((reflect.Constructor) v0_1.invoke(v1, v2_1));
        } catch (reflect.InvocationTargetException v4_6) {
            throw new org.objenesis.ObjenesisException(v4_6);
        } catch (reflect.InvocationTargetException v4_5) {
            throw new org.objenesis.ObjenesisException(v4_5);
        } catch (reflect.InvocationTargetException v4_4) {
            throw new org.objenesis.ObjenesisException(v4_4);
        }
    }

Method org.objenesis.instantiator.sun.SunReflectionFactoryHelper.createReflectionFactory() calling method java.lang.reflect.Method.invoke()


    private static Object createReflectionFactory(Class p3)
    {
        try {
            Class[] v2 = new Class[0];
            Object[] v1_1 = new Object[0];
            return p3.getDeclaredMethod("getReflectionFactory", v2).invoke(0, v1_1);
        } catch (reflect.InvocationTargetException v3_4) {
            throw new org.objenesis.ObjenesisException(v3_4);
        } catch (reflect.InvocationTargetException v3_3) {
            throw new org.objenesis.ObjenesisException(v3_3);
        } catch (reflect.InvocationTargetException v3_2) {
            throw new org.objenesis.ObjenesisException(v3_2);
        } catch (reflect.InvocationTargetException v3_1) {
            throw new org.objenesis.ObjenesisException(v3_1);
        }
    }

Method org.objenesis.instantiator.basic.ClassDefinitionUtils.defineClass() calling method java.lang.reflect.Method.invoke()


    public static Class defineClass(String p4, byte[] p5, ClassLoader p6)
    {
        Object[] v0_1 = new Object[5];
        v0_1[0] = p4;
        v0_1[1] = p5;
        v0_1[2] = new Integer(0);
        v0_1[3] = new Integer(p5.length);
        v0_1[4] = org.objenesis.instantiator.basic.ClassDefinitionUtils.PROTECTION_DOMAIN;
        Class v5_6 = ((Class) org.objenesis.instantiator.basic.ClassDefinitionUtils.DEFINE_CLASS.invoke(p6, v0_1));
        Class.forName(p4, 1, p6);
        return v5_6;
    }

Method org.mockito.internal.util.reflection.BeanPropertySetter.set() calling method java.lang.reflect.Method.invoke()


    public boolean set(Object p9)
    {
        org.mockito.internal.util.reflection.AccessibilityChanger v0_1 = new org.mockito.internal.util.reflection.AccessibilityChanger();
        try {
            RuntimeException v3_5 = this.target.getClass();
            StringBuilder v4_0 = this.setterName(this.field.getName());
            Class[] v6 = new Class[1];
            v6[0] = this.field.getType();
            reflect.Method v2 = v3_5.getMethod(v4_0, v6);
            v0_1.enableAccess(v2);
            RuntimeException v3_0 = this.target;
            StringBuilder v4_1 = new Object[1];
            v4_1[0] = p9;
            v2.invoke(v3_0, v4_1);
        } catch (String v9_7) {
            if (v2 != null) {
                v0_1.safelyDisableAccess(v2);
            }
            throw v9_7;
        } catch (IllegalAccessException v1_1) {
            StringBuilder v4_3 = new StringBuilder();
            v4_3.append("Access not authorized on field \'");
            v4_3.append(this.field);
            v4_3.append("\' of object \'");
            v4_3.append(this.target);
            v4_3.append("\' with value: \'");
            v4_3.append(p9);
            v4_3.append("\'");
            throw new RuntimeException(v4_3.toString(), v1_1);
        }
        if (v2 != null) {
            v0_1.safelyDisableAccess(v2);
        }
        return 1;
    }

Method org.mockito.internal.util.JavaEightUtil.invokeNullaryFactoryMethod() calling method java.lang.reflect.Method.invoke()


    private static Object invokeNullaryFactoryMethod(String p4, String p5)
    {
        try {
            org.mockito.internal.creation.instance.InstantiationException v2_2 = new Class[0];
            Object[] v3_2 = new Object[0];
            String v4_5 = Class.forName(p4).getMethod(p5, v2_2).invoke(0, v3_2);
            return v4_5;
        } catch (Exception v1_0) {
            Object[] v3_1 = new Object[3];
            v3_1[0] = v4_5;
            v3_1[1] = p5;
            v3_1[2] = v1_0;
            throw new org.mockito.internal.creation.instance.InstantiationException(String.format("Could not create %s#%s(): %s", v3_1), v1_0);
        }
    }

Method org.mockito.internal.creation.bytebuddy.MockMethodAdvice.tryInvoke() calling method java.lang.reflect.Method.invoke()


    private static Object tryInvoke(reflect.Method p1, Object p2, Object[] p3)
    {
        try {
            Throwable v1_1 = p1.invoke(p2, p3);
            return v1_1;
        } catch (Throwable v2_1) {
            Throwable v2_2 = v2_1.getCause();
            new org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter().filter(org.mockito.internal.creation.bytebuddy.MockMethodAdvice.hideRecursiveCall(v2_2, new Throwable().getStackTrace().length, v1_1.getDeclaringClass()));
            throw v2_2;
        }
    }

Method org.junit.internal.runners.TestMethod.invoke() calling method java.lang.reflect.Method.invoke()


    public void invoke(Object p3)
    {
        Object[] v1_1 = new Object[0];
        this.method.invoke(p3, v1_1);
        return;
    }

Method org.junit.internal.runners.MethodRoadie.runBefores() calling method java.lang.reflect.Method.invoke()


    private void runBefores()
    {
        try {
            org.junit.internal.runners.FailedBefore v0_8 = this.testMethod.getBefores().iterator();
        } catch (org.junit.internal.runners.FailedBefore v0_9) {
            throw v0_9.getTargetException();
        } catch (org.junit.internal.AssumptionViolatedException) {
            throw new org.junit.internal.runners.FailedBefore();
        } catch (org.junit.internal.runners.FailedBefore v0_2) {
            this.addFailure(v0_2);
            throw new org.junit.internal.runners.FailedBefore();
        }
        while (v0_8.hasNext()) {
            Object[] v3_1 = new Object[0];
            ((reflect.Method) v0_8.next()).invoke(this.test, v3_1);
        }
        return;
    }

Method org.junit.internal.runners.MethodRoadie.runAfters() calling method java.lang.reflect.Method.invoke()


    private void runAfters()
    {
        java.util.Iterator v0_2 = this.testMethod.getAfters().iterator();
        while (v0_2.hasNext()) {
            try {
                Object[] v3_1 = new Object[0];
                ((reflect.Method) v0_2.next()).invoke(this.test, v3_1);
            } catch (Throwable v1_3) {
                this.addFailure(v1_3.getTargetException());
            } catch (Throwable v1_2) {
                this.addFailure(v1_2);
            }
        }
        return;
    }

Method org.junit.internal.runners.ClassRoadie.runBefores() calling method java.lang.reflect.Method.invoke()


    private void runBefores()
    {
        try {
            org.junit.internal.runners.FailedBefore v0_8 = this.testClass.getBefores().iterator();
        } catch (org.junit.internal.runners.FailedBefore v0_9) {
            throw v0_9.getTargetException();
        } catch (org.junit.internal.AssumptionViolatedException) {
            throw new org.junit.internal.runners.FailedBefore();
        } catch (org.junit.internal.runners.FailedBefore v0_2) {
            this.addFailure(v0_2);
            throw new org.junit.internal.runners.FailedBefore();
        }
        while (v0_8.hasNext()) {
            Object[] v3_1 = new Object[0];
            ((reflect.Method) v0_8.next()).invoke(0, v3_1);
        }
        return;
    }

Method org.junit.internal.runners.ClassRoadie.runAfters() calling method java.lang.reflect.Method.invoke()


    private void runAfters()
    {
        java.util.Iterator v0_2 = this.testClass.getAfters().iterator();
        while (v0_2.hasNext()) {
            try {
                Object[] v3_1 = new Object[0];
                ((reflect.Method) v0_2.next()).invoke(0, v3_1);
            } catch (Throwable v1_3) {
                this.addFailure(v1_3.getTargetException());
            } catch (Throwable v1_2) {
                this.addFailure(v1_2);
            }
        }
        return;
    }

Method org.joda.time.DateTimeUtils.getDateFormatSymbols() calling method java.lang.reflect.Method.invoke()


    public static final java.text.DateFormatSymbols getDateFormatSymbols(java.util.Locale p6)
    {
        try {
            Class[] v3 = new Class[1];
            v3[0] = java.util.Locale;
            java.text.DateFormatSymbols v0_5 = java.text.DateFormatSymbols.getMethod("getInstance", v3);
            Object[] v2_0 = new Object[1];
            v2_0[0] = p6;
            return ((java.text.DateFormatSymbols) v0_5.invoke(0, v2_0));
        } catch (Exception) {
            return new java.text.DateFormatSymbols(p6);
        }
    }

Method org.apache.http.impl.client.CloseableHttpResponseProxy.invoke() calling method java.lang.reflect.Method.invoke()


    public Object invoke(Object p2, reflect.Method p3, Object[] p4)
    {
        if (!p3.getName().equals("close")) {
            try {
                return p3.invoke(this.original, p4);
            } catch (reflect.InvocationTargetException v2_1) {
                Throwable v3_1 = v2_1.getCause();
                if (v3_1 == null) {
                    throw v2_1;
                } else {
                    throw v3_1;
                }
            }
        } else {
            this.close();
            return 0;
        }
    }

Method org.apache.http.client.utils.CloneUtilsHC4.cloneObject() calling method java.lang.reflect.Method.invoke()


    public static Object cloneObject(Object p4)
    {
        if (p4 != null) {
            if (!(p4 instanceof Cloneable)) {
                throw new CloneNotSupportedException();
            } else {
                try {
                    try {
                        return p4.getClass().getMethod("clone", ((Class[]) 0)).invoke(p4, ((Object[]) 0));
                    } catch (CloneNotSupportedException v4_4) {
                        throw new IllegalAccessError(v4_4.getMessage());
                    } catch (CloneNotSupportedException v4_6) {
                        CloneNotSupportedException v4_7 = v4_6.getCause();
                        if (!(v4_7 instanceof CloneNotSupportedException)) {
                            throw new Error("Unexpected exception", v4_7);
                        } else {
                            throw ((CloneNotSupportedException) v4_7);
                        }
                    }
                } catch (CloneNotSupportedException v4_1) {
                    throw new NoSuchMethodError(v4_1.getMessage());
                }
                return p4.getClass().getMethod("clone", ((Class[]) 0)).invoke(p4, ((Object[]) 0));
            }
        } else {
            return 0;
        }
    }

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


    public static Object invokeStaticMethod(Class p1, String p2, Object[] p3, Class[] p4)
    {
        NoSuchMethodException v3_1 = org.apache.commons.lang3.ArrayUtils.nullToEmpty(p3);
        StringBuilder v4_2 = org.apache.commons.lang3.reflect.MethodUtils.getMatchingAccessibleMethod(p1, p2, org.apache.commons.lang3.ArrayUtils.nullToEmpty(p4));
        if (v4_2 == null) {
            StringBuilder v4_4 = new StringBuilder();
            v4_4.append("No such accessible method: ");
            v4_4.append(p2);
            v4_4.append("() on class: ");
            v4_4.append(p1.getName());
            throw new NoSuchMethodException(v4_4.toString());
        } else {
            return v4_2.invoke(0, org.apache.commons.lang3.reflect.MethodUtils.toVarArgs(v4_2, v3_1));
        }
    }

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


    public static Object invokeMethod(Object p1, boolean p2, String p3, Object[] p4, Class[] p5)
    {
        StringBuilder v5_2;
        String v2_1;
        StringBuilder v5_1 = org.apache.commons.lang3.ArrayUtils.nullToEmpty(p5);
        NoSuchMethodException v4_2 = org.apache.commons.lang3.ArrayUtils.nullToEmpty(p4);
        if (p2 == null) {
            v2_1 = "No such accessible method: ";
            v5_2 = org.apache.commons.lang3.reflect.MethodUtils.getMatchingAccessibleMethod(p1.getClass(), p3, v5_1);
        } else {
            v2_1 = "No such method: ";
            v5_2 = org.apache.commons.lang3.reflect.MethodUtils.getMatchingMethod(p1.getClass(), p3, v5_1);
            if ((v5_2 != null) && (!v5_2.isAccessible())) {
                v5_2.setAccessible(1);
            }
        }
        if (v5_2 == null) {
            StringBuilder v5_4 = new StringBuilder();
            v5_4.append(v2_1);
            v5_4.append(p3);
            v5_4.append("() on object: ");
            v5_4.append(p1.getClass().getName());
            throw new NoSuchMethodException(v5_4.toString());
        } else {
            return v5_2.invoke(p1, org.apache.commons.lang3.reflect.MethodUtils.toVarArgs(v5_2, v4_2));
        }
    }

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


    public static Object invokeExactStaticMethod(Class p1, String p2, Object[] p3, Class[] p4)
    {
        NoSuchMethodException v3_1 = org.apache.commons.lang3.ArrayUtils.nullToEmpty(p3);
        StringBuilder v4_2 = org.apache.commons.lang3.reflect.MethodUtils.getAccessibleMethod(p1, p2, org.apache.commons.lang3.ArrayUtils.nullToEmpty(p4));
        if (v4_2 == null) {
            StringBuilder v4_4 = new StringBuilder();
            v4_4.append("No such accessible method: ");
            v4_4.append(p2);
            v4_4.append("() on class: ");
            v4_4.append(p1.getName());
            throw new NoSuchMethodException(v4_4.toString());
        } else {
            return v4_2.invoke(0, v3_1);
        }
    }

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


    public static Object invokeExactMethod(Object p1, String p2, Object[] p3, Class[] p4)
    {
        NoSuchMethodException v3_1 = org.apache.commons.lang3.ArrayUtils.nullToEmpty(p3);
        StringBuilder v4_4 = org.apache.commons.lang3.reflect.MethodUtils.getAccessibleMethod(p1.getClass(), p2, org.apache.commons.lang3.ArrayUtils.nullToEmpty(p4));
        if (v4_4 == null) {
            StringBuilder v4_2 = new StringBuilder();
            v4_2.append("No such accessible method: ");
            v4_2.append(p2);
            v4_2.append("() on object: ");
            v4_2.append(p1.getClass().getName());
            throw new NoSuchMethodException(v4_2.toString());
        } else {
            return v4_4.invoke(p1, v3_1);
        }
    }

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

Couldn't retrieve source code

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


    public Object invoke(Object p2, reflect.Method p3, Object[] p4)
    {
        int v2_2 = org.apache.commons.lang3.event.EventListenerSupport.access$000(this.this$0).iterator();
        while (v2_2.hasNext()) {
            p3.invoke(v2_2.next(), p4);
        }
        return 0;
    }

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


    public static Object clone(Object p4)
    {
        if (!(p4 instanceof Cloneable)) {
            return 0;
        } else {
            Throwable v0_3;
            if (!p4.getClass().isArray()) {
                try {
                    String v3_0 = new Class[0];
                    int v1_1 = new Object[0];
                    v0_3 = p4.getClass().getMethod("clone", v3_0).invoke(p4, v1_1);
                } catch (Throwable v0_8) {
                    int v2_6 = new StringBuilder();
                    v2_6.append("Cloneable type ");
                    v2_6.append(p4.getClass().getName());
                    v2_6.append(" has no clone method");
                    throw new org.apache.commons.lang3.exception.CloneFailedException(v2_6.toString(), v0_8);
                } catch (Throwable v0_6) {
                    int v2_4 = new StringBuilder();
                    v2_4.append("Cannot clone Cloneable type ");
                    v2_4.append(p4.getClass().getName());
                    throw new org.apache.commons.lang3.exception.CloneFailedException(v2_4.toString(), v0_6);
                } catch (Throwable v0_4) {
                    int v2_2 = new StringBuilder();
                    v2_2.append("Exception cloning Cloneable type ");
                    v2_2.append(p4.getClass().getName());
                    throw new org.apache.commons.lang3.exception.CloneFailedException(v2_2.toString(), v0_4.getCause());
                }
            } else {
                Throwable v0_11 = p4.getClass().getComponentType();
                if (!v0_11.isPrimitive()) {
                    v0_3 = ((Object[]) p4).clone();
                } else {
                    int v1_9 = reflect.Array.getLength(p4);
                    v0_3 = reflect.Array.newInstance(v0_11, v1_9);
                    while(true) {
                        int v2_7 = (v1_9 - 1);
                        if (v1_9 <= 0) {
                            break;
                        }
                        reflect.Array.set(v0_3, v2_7, reflect.Array.get(p4, v2_7));
                        v1_9 = v2_7;
                    }
                }
            }
            return v0_3;
        }
    }

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


    public static String toString(otation.Annotation p8)
    {
        RuntimeException v0_1 = new org.apache.commons.lang3.builder.ToStringBuilder(p8, org.apache.commons.lang3.AnnotationUtils.TO_STRING_STYLE);
        reflect.Method[] v1_2 = p8.annotationType().getDeclaredMethods();
        int v2 = v1_2.length;
        int v4 = 0;
        while (v4 < v2) {
            Object v5_0 = v1_2[v4];
            if (v5_0.getParameterTypes().length <= 0) {
                try {
                    Object[] v7 = new Object[0];
                    v0_1.append(v5_0.getName(), v5_0.invoke(p8, v7));
                } catch (Exception v8_3) {
                    throw v8_3;
                } catch (Exception v8_2) {
                    throw new RuntimeException(v8_2);
                }
            }
            v4++;
        }
        return v0_1.build();
    }

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


    public static int hashCode(otation.Annotation p7)
    {
        String v0_3 = p7.annotationType().getDeclaredMethods();
        Object[] v1_2 = v0_3.length;
        int v3 = 0;
        int v4 = 0;
        while (v3 < v1_2) {
            int v5_0 = v0_3[v3];
            try {
                Object v6_0 = new Object[0];
                Object v6_1 = v5_0.invoke(p7, v6_0);
            } catch (IllegalStateException v7_4) {
                throw v7_4;
            } catch (IllegalStateException v7_3) {
                throw new RuntimeException(v7_3);
            }
            if (v6_1 == null) {
                Object[] v1_1 = new Object[1];
                v1_1[0] = v5_0;
                throw new IllegalStateException(String.format("Annotation method %s returned null", v1_1));
            } else {
                v4 += org.apache.commons.lang3.AnnotationUtils.hashMember(v5_0.getName(), v6_1);
                v3++;
            }
        }
        return v4;
    }

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


    public static boolean equals(otation.Annotation p8, otation.Annotation p9)
    {
        if (p8 != p9) {
            if ((p8 != null) && (p9 != null)) {
                reflect.Method[] v2_1 = p8.annotationType();
                int v3_2 = p9.annotationType();
                boolean v5_0 = new Object[1];
                v5_0[0] = p8;
                org.apache.commons.lang3.Validate.notNull(v2_1, "Annotation %s with null annotationType()", v5_0);
                boolean v5_1 = new Object[1];
                v5_1[0] = p9;
                org.apache.commons.lang3.Validate.notNull(v3_2, "Annotation %s with null annotationType()", v5_1);
                if (v2_1.equals(v3_2)) {
                    try {
                        reflect.Method[] v2_0 = v2_1.getDeclaredMethods();
                        int v4_1 = 0;
                    } catch (IllegalAccessException) {
                        return 0;
                    }
                    while (v4_1 < v2_0.length) {
                        boolean v5_2 = v2_0[v4_1];
                        if ((v5_2.getParameterTypes().length == 0) && (org.apache.commons.lang3.AnnotationUtils.isValidAnnotationMemberType(v5_2.getReturnType()))) {
                            Object v6_4 = new Object[0];
                            Object v7_0 = new Object[0];
                            if (!org.apache.commons.lang3.AnnotationUtils.memberEquals(v5_2.getReturnType(), v5_2.invoke(p8, v6_4), v5_2.invoke(p9, v7_0))) {
                                return 0;
                            }
                        }
                        v4_1++;
                    }
                    return 1;
                } else {
                    return 0;
                }
            } else {
                return 0;
            }
        } else {
            return 1;
        }
    }

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


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

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


    public varargs Object invoke(Object p4, Object[] p5)
    {
        String v0_1 = this.getMethod(p4.getClass());
        if (v0_1 == null) {
            String v0_4 = new StringBuilder();
            v0_4.append("Method ");
            v0_4.append(this.methodName);
            v0_4.append(" not supported for object ");
            v0_4.append(p4);
            throw new AssertionError(v0_4.toString());
        } else {
            try {
                return v0_1.invoke(p4, p5);
            } catch (IllegalAccessException v4_3) {
                StringBuilder v1_3 = new StringBuilder();
                v1_3.append("Unexpectedly could not call: ");
                v1_3.append(v0_1);
                AssertionError v5_3 = new AssertionError(v1_3.toString());
                v5_3.initCause(v4_3);
                throw v5_3;
            }
        }
    }

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


    public Object invoke(Object p6, reflect.Method p7, Object[] p8)
    {
        String v6_0 = p7.getName();
        boolean v0_0 = p7.getReturnType();
        if (p8 == 0) {
            p8 = okhttp3.internal.Util.EMPTY_STRING_ARRAY;
        }
        if ((!v6_0.equals("supports")) || (Boolean.TYPE != v0_0)) {
            if ((!v6_0.equals("unsupported")) || (Void.TYPE != v0_0)) {
                if ((!v6_0.equals("protocols")) || (p8.length != 0)) {
                    if (((!v6_0.equals("selectProtocol")) && (!v6_0.equals("select"))) || ((String != v0_0) || ((p8.length != 1) || (!(p8[0] instanceof java.util.List))))) {
                        if (((!v6_0.equals("protocolSelected")) && (!v6_0.equals("selected"))) || (p8.length != 1)) {
                            return p7.invoke(this, p8);
                        } else {
                            this.selected = ((String) p8[0]);
                            return 0;
                        }
                    } else {
                        String v6_7 = ((java.util.List) p8[0]);
                        int v7_1 = v6_7.size();
                        int v8_1 = 0;
                        while (v8_1 < v7_1) {
                            if (!this.protocols.contains(v6_7.get(v8_1))) {
                                v8_1++;
                            } else {
                                String v6_12 = ((String) v6_7.get(v8_1));
                                this.selected = v6_12;
                                return v6_12;
                            }
                        }
                        String v6_10 = ((String) this.protocols.get(0));
                        this.selected = v6_10;
                        return v6_10;
                    }
                } else {
                    return this.protocols;
                }
            } else {
                this.unsupported = 1;
                return 0;
            }
        } else {
            return Boolean.valueOf(1);
        }
    }

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

Couldn't retrieve source code

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

Couldn't retrieve source code

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

Couldn't retrieve source code

Method net.bytebuddy.dynamic.Nexus.initialize() calling method java.lang.reflect.Method.invoke()


    public static void initialize(Class p6, int p7)
    {
        Object v7_1 = net.bytebuddy.dynamic.Nexus.TYPE_INITIALIZERS.remove(new net.bytebuddy.dynamic.Nexus(p6, p7));
        if (v7_1 != null) {
            reflect.Method v0_2 = v7_1.getClass();
            Class[] v3 = new Class[1];
            v3[0] = Class;
            reflect.Method v0_1 = v0_2.getMethod("onLoad", v3);
            Object[] v1_1 = new Object[1];
            v1_1[0] = p6;
            v0_1.invoke(v7_1, v1_1);
        }
        return;
    }

Method net.bytebuddy.description.annotation.AnnotationDescription$AnnotationInvocationHandler.equalsRepresentation() calling method java.lang.reflect.Method.invoke()


    private boolean equalsRepresentation(Object p6, Object p7)
    {
        if (p6 != p7) {
            if (this.annotationType.isInstance(p7)) {
                if (reflect.Proxy.isProxyClass(p7.getClass())) {
                    IllegalAccessException v6_2 = reflect.Proxy.getInvocationHandler(p7);
                    if ((v6_2 instanceof net.bytebuddy.description.annotation.AnnotationDescription$AnnotationInvocationHandler)) {
                        return v6_2.equals(this);
                    }
                }
                try {
                    IllegalAccessException v6_6 = this.values.entrySet().iterator();
                } catch (reflect.InvocationTargetException) {
                    return 0;
                } catch (IllegalAccessException v6_8) {
                    throw new IllegalStateException("Could not access annotation property", v6_8);
                }
                while (v6_6.hasNext()) {
                    boolean v2_3 = ((java.util.Map$Entry) v6_6.next());
                    try {
                        Object[] v4 = new Object[0];
                    } catch (RuntimeException) {
                        return 0;
                    }
                    if (!((net.bytebuddy.description.annotation.AnnotationValue$Loaded) v2_3.getValue()).represents(((reflect.Method) v2_3.getKey()).invoke(p7, v4))) {
                        return 0;
                    }
                }
                return 1;
            } else {
                return 0;
            }
        } else {
            return 1;
        }
    }

Method net.bytebuddy.agent.builder.LambdaFactory.invoke() calling method java.lang.reflect.Method.invoke()


    private byte[] invoke(Object p5, String p6, Object p7, Object p8, Object p9, Object p10, boolean p11, java.util.List p12, java.util.List p13, java.util.Collection p14)
    {
        try {
            reflect.Method v0 = this.dispatcher;
            Object v1 = this.target;
            Object[] v2_1 = new Object[10];
            v2_1[0] = p5;
            v2_1[1] = p6;
            v2_1[2] = p7;
            v2_1[3] = p8;
            v2_1[4] = p9;
            v2_1[5] = p10;
            v2_1[6] = Boolean.valueOf(p11);
            v2_1[7] = p12;
            v2_1[8] = p13;
            v2_1[9] = p14;
            return ((byte[]) ((byte[]) v0.invoke(v1, v2_1)));
        } catch (Exception v5_12) {
            throw v5_12;
        } catch (Exception v5_11) {
            throw new IllegalStateException("Cannot create class for lambda expression", v5_11);
        }
    }

Method net.bytebuddy.agent.ByteBuddyAgent.doGetInstrumentation() calling method java.lang.reflect.Method.invoke()


    private static instrument.Instrumentation doGetInstrumentation()
    {
        try {
            Class[] v3 = new Class[0];
            Object[] v2_0 = new Object[0];
            return ((instrument.Instrumentation) ClassLoader.getSystemClassLoader().loadClass(net.bytebuddy.agent.Installer.getName()).getMethod("getInstrumentation", v3).invoke(net.bytebuddy.agent.ByteBuddyAgent.STATIC_MEMBER, v2_0));
        } catch (Exception) {
            return net.bytebuddy.agent.ByteBuddyAgent.UNAVAILABLE;
        }
    }

Method net.bytebuddy.agent.Attacher.install() calling method java.lang.reflect.Method.invoke()


    protected static void install(Class p6, String p7, java.io.File p8, String p9)
    {
        Object[] v2_1 = new Class[1];
        v2_1[0] = String;
        String v0_4 = p6.getMethod("attach", v2_1);
        Class[] v3_2 = new Object[1];
        v3_2[0] = p7;
        Object v7_1 = v0_4.invoke(net.bytebuddy.agent.Attacher.STATIC_MEMBER, v3_2);
        try {
            Class[] v3_0 = new Class[2];
            v3_0[0] = String;
            v3_0[1] = String;
            String v0_2 = p6.getMethod("loadAgent", v3_0);
            Object[] v2_2 = new Object[2];
            v2_2[0] = p8.getAbsolutePath();
            v2_2[1] = p9;
            v0_2.invoke(v7_1, v2_2);
            Object[] v9_1 = new Class[0];
            reflect.Method v6_1 = p6.getMethod("detach", v9_1);
            Throwable v8_3 = new Object[0];
            v6_1.invoke(v7_1, v8_3);
            return;
        } catch (Throwable v8_4) {
            Object[] v9_2 = new Class[0];
            Object[] v9_3 = new Object[0];
            v6_1.getMethod("detach", v9_2).invoke(v7_1, v9_3);
            throw v8_4;
        }
    }

Method kotlin.reflect.jvm.internal.structure.Java8ParameterNamesLoader.loadParameterNames() calling method java.lang.reflect.Method.invoke()


    public final java.util.List loadParameterNames(reflect.Member p8)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p8, "member");
        String v0_2 = kotlin.reflect.jvm.internal.structure.Java8ParameterNamesLoader.cache;
        if (v0_2 == null) {
            v0_2 = this.buildCache(p8);
            kotlin.reflect.jvm.internal.structure.Java8ParameterNamesLoader.cache = v0_2;
        }
        java.util.List v1_4 = v0_2.getGetParameters();
        if (v1_4 == null) {
            return 0;
        } else {
            String v0_1 = v0_2.getGetName();
            if (v0_1 == null) {
                return 0;
            } else {
                int v3_0 = new Object[0];
                kotlin.TypeCastException v8_1 = v1_4.invoke(p8, v3_0);
                if (v8_1 == null) {
                    throw new kotlin.TypeCastException("null cannot be cast to non-null type kotlin.Array<*>");
                } else {
                    kotlin.TypeCastException v8_4 = ((Object[]) v8_1);
                    java.util.List v1_2 = ((java.util.Collection) new java.util.ArrayList(v8_4.length));
                    int v3_2 = v8_4.length;
                    int v4 = 0;
                    while (v4 < v3_2) {
                        Object[] v6 = new Object[0];
                        String v5_1 = v0_1.invoke(v8_4[v4], v6);
                        if (v5_1 == null) {
                            throw new kotlin.TypeCastException("null cannot be cast to non-null type kotlin.String");
                        } else {
                            v1_2.add(((String) v5_1));
                            v4++;
                        }
                    }
                    return ((java.util.List) v1_2);
                }
            }
        }
    }

Method kotlin.reflect.jvm.internal.components.ReflectClassStructure.processAnnotationArguments() calling method java.lang.reflect.Method.invoke()


    private final void processAnnotationArguments(kotlin.reflect.jvm.internal.impl.load.kotlin.KotlinJvmBinaryClass$AnnotationArgumentVisitor p7, otation.Annotation p8, Class p9)
    {
        reflect.Method[] v9_1 = p9.getDeclaredMethods();
        int v0 = v9_1.length;
        int v2 = 0;
        while (v2 < v0) {
            kotlin.reflect.jvm.internal.impl.name.Name v3_2 = v9_1[v2];
            try {
                Object v4_1 = new Object[0];
                Object v4_0 = v3_2.invoke(p8, v4_1);
            } catch (IllegalAccessException) {
                v2++;
            }
            if (v4_0 == null) {
                kotlin.jvm.internal.Intrinsics.throwNpe();
            }
            kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v3_2, "method");
            kotlin.reflect.jvm.internal.impl.name.Name v3_1 = kotlin.reflect.jvm.internal.impl.name.Name.identifier(v3_2.getName());
            kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v3_1, "Name.identifier(method.name)");
            this.processAnnotationArgumentValue(p7, v3_1, v4_0);
        }
        p7.visitEnd();
        return;
    }

Method kotlin.reflect.jvm.internal.calls.InlineClassAwareCallerKt.coerceToExpectedReceiverType() calling method java.lang.reflect.Method.invoke()


    public static final Object coerceToExpectedReceiverType(Object p1, kotlin.reflect.jvm.internal.impl.descriptors.CallableMemberDescriptor p2)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p2, "descriptor");
        if ((!(p2 instanceof kotlin.reflect.jvm.internal.impl.descriptors.PropertyDescriptor)) || (!kotlin.reflect.jvm.internal.impl.resolve.InlineClassesUtilsKt.isUnderlyingPropertyOfInlineClass(((kotlin.reflect.jvm.internal.impl.descriptors.VariableDescriptor) p2)))) {
            Object[] v0_1 = kotlin.reflect.jvm.internal.calls.InlineClassAwareCallerKt.getExpectedReceiverType(p2);
            if (v0_1 != null) {
                Object[] v0_2 = kotlin.reflect.jvm.internal.calls.InlineClassAwareCallerKt.toInlineClass(v0_1);
                if (v0_2 != null) {
                    reflect.Method v2_1 = kotlin.reflect.jvm.internal.calls.InlineClassAwareCallerKt.getUnboxMethod(v0_2, p2);
                    if (v2_1 != null) {
                        Object[] v0_5 = new Object[0];
                        return v2_1.invoke(p1, v0_5);
                    }
                }
            }
            return p1;
        } else {
            return p1;
        }
    }

Method kotlin.coroutines.jvm.internal.ModuleNameRetriever.getModuleName() calling method java.lang.reflect.Method.invoke()


    public final String getModuleName(kotlin.coroutines.jvm.internal.BaseContinuationImpl p6)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p6, "continuation");
        boolean v0_1 = kotlin.coroutines.jvm.internal.ModuleNameRetriever.cache;
        if (!v0_1) {
            v0_1 = this.buildCache(p6);
        }
        if (v0_1 != kotlin.coroutines.jvm.internal.ModuleNameRetriever.notOnJava9) {
            Object[] v1_3 = v0_1.getModuleMethod;
            if (v1_3 != null) {
                Object[] v4_0 = new Object[0];
                String v6_2 = v1_3.invoke(p6.getClass(), v4_0);
                if (v6_2 != null) {
                    Object[] v1_0 = v0_1.getDescriptorMethod;
                    if (v1_0 != null) {
                        Object[] v4_1 = new Object[0];
                        String v6_3 = v1_0.invoke(v6_2, v4_1);
                        if (v6_3 != null) {
                            String v6_4;
                            boolean v0_2 = v0_1.nameMethod;
                            if (!v0_2) {
                                v6_4 = 0;
                            } else {
                                Object[] v1_1 = new Object[0];
                                v6_4 = v0_2.invoke(v6_3, v1_1);
                            }
                            if (!(v6_4 instanceof String)) {
                                v6_4 = 0;
                            }
                            return ((String) v6_4);
                        }
                    }
                    return 0;
                }
            }
            return 0;
        } else {
            return 0;
        }
    }

Method com.google.android.gms.measurement.internal.zzda.zza() calling method java.lang.reflect.Method.invoke()


    private final void zza(String p24, String p25, long p26, android.os.Bundle p28, boolean p29, boolean p30, boolean p31, String p32)
    {
        com.google.android.gms.common.internal.Preconditions.checkNotEmpty(p24);
        if (!this.zzgv().zze(p32, com.google.android.gms.measurement.internal.zzai.zzali)) {
            com.google.android.gms.common.internal.Preconditions.checkNotEmpty(p25);
        }
        com.google.android.gms.common.internal.Preconditions.checkNotNull(p28);
        this.zzaf();
        this.zzcl();
        if (this.zzada.isEnabled()) {
            int v16_0 = 0;
            if (!this.zzard) {
                this.zzard = 1;
                try {
                    int v0_8 = Class.forName("com.google.android.gms.tagmanager.TagManagerService");
                    try {
                        android.os.Bundle v9_14 = new Class[1];
                        v9_14[0] = android.content.Context;
                        int v0_16 = v0_8.getDeclaredMethod("initialize", v9_14);
                        com.google.android.gms.measurement.internal.zzfx v2_21 = new Object[1];
                        v2_21[0] = this.getContext();
                        v0_16.invoke(0, v2_21);
                    } catch (int v0_17) {
                        this.zzgt().zzjj().zzg("Failed to invoke Tag Manager\'s initialize() method", v0_17);
                    }
                } catch (ClassNotFoundException) {
                    this.zzgt().zzjm().zzby("Tag Manager is not found and thus will not be used");
                }
            }
            if (p31) {
                this.zzgw();
                if (!"_iap".equals(p25)) {
                    com.google.android.gms.measurement.internal.zzfx v2_45 = this.zzada.zzgr();
                    java.util.Iterator v10_16 = 2;
                    if (v2_45.zzs("event", p25)) {
                        if (v2_45.zza("event", com.google.android.gms.measurement.internal.zzcu.zzaqt, p25)) {
                            if (v2_45.zza("event", 40, p25)) {
                                v10_16 = 0;
                            }
                        } else {
                            v10_16 = 13;
                        }
                    }
                    if (v10_16 != null) {
                        com.google.android.gms.measurement.internal.zzcy v1_66;
                        this.zzgt().zzji().zzg("Invalid public event name. Event will not be logged (FE)", this.zzgq().zzbt(p25));
                        this.zzada.zzgr();
                        int v0_26 = com.google.android.gms.measurement.internal.zzfx.zza(p25, 40, 1);
                        if (p25 == null) {
                            v1_66 = 0;
                        } else {
                            v1_66 = p25.length();
                        }
                        this.zzada.zzgr().zza(v10_16, "_ev", v0_26, v1_66);
                        return;
                    }
                }
            }
            this.zzgw();
            com.google.android.gms.measurement.internal.zzfx v2_48 = this.zzgm().zzle();
            if ((v2_48 != null) && (!p28.containsKey("_sc"))) {
                v2_48.zzars = 1;
            }
            if ((p29 == null) || (!p31)) {
                android.os.Bundle v9_29 = 0;
            } else {
                v9_29 = 1;
            }
            com.google.android.gms.measurement.internal.zzdy.zza(v2_48, p28, v9_29);
            boolean v17 = "am".equals(p24);
            android.os.Bundle v9_0 = com.google.android.gms.measurement.internal.zzfx.zzcy(p25);
            if ((p29 == null) || ((this.zzarb == null) || ((v9_0 != null) || (v17)))) {
                if (this.zzada.zzkv()) {
                    android.os.Bundle v9_4 = this.zzgr().zzcu(p25);
                    if (v9_4 == null) {
                        String v11_3;
                        int v0_3 = com.google.android.gms.common.util.CollectionUtils.listOf(new String[] {"_o", "_sn", "_sc", "_si"}));
                        int v15_1 = this.zzgr().zza(p32, p25, p28, v0_3, p31, 1);
                        if ((v15_1 != 0) && ((v15_1.containsKey("_sc")) && (v15_1.containsKey("_si")))) {
                            v11_3 = new com.google.android.gms.measurement.internal.zzdx(v15_1.getString("_sn"), v15_1.getString("_sc"), Long.valueOf(v15_1.getLong("_si")).longValue());
                        } else {
                            v11_3 = 0;
                        }
                        com.google.android.gms.measurement.internal.zzdx v14_1;
                        if (v11_3 != null) {
                            v14_1 = v11_3;
                        } else {
                            v14_1 = v2_48;
                        }
                        if (this.zzgv().zzbk(p32)) {
                            this.zzgw();
                            if ((this.zzgm().zzle() != null) && ("_ae".equals(p25))) {
                                com.google.android.gms.measurement.internal.zzcy v1_9 = this.zzgo().zzlp();
                                if (v1_9 > 0) {
                                    this.zzgr().zza(v15_1, v1_9);
                                }
                            }
                        }
                        String v13_2 = new java.util.ArrayList();
                        v13_2.add(v15_1);
                        String v11_6 = this.zzgr().zzmk().nextLong();
                        if ((this.zzgv().zze(this.zzgk().zzal(), com.google.android.gms.measurement.internal.zzai.zzaky)) && ((this.zzgu().zzanq.get() > 0) && ((this.zzgu().zzaf(p26)) && (this.zzgu().zzant.get())))) {
                            this.zzgt().zzjo().zzby("Current session is expired, remove the session number and Id");
                            if (this.zzgv().zze(this.zzgk().zzal(), com.google.android.gms.measurement.internal.zzai.zzaku)) {
                                this.zza("auto", "_sid", 0, this.zzbx().currentTimeMillis());
                            }
                            if (this.zzgv().zze(this.zzgk().zzal(), com.google.android.gms.measurement.internal.zzai.zzakv)) {
                                this.zza("auto", "_sno", 0, this.zzbx().currentTimeMillis());
                            }
                        }
                        com.google.android.gms.measurement.internal.zzda v7_2;
                        if (!this.zzgv().zzbj(this.zzgk().zzal())) {
                            v7_2 = this;
                        } else {
                            if (v15_1.getLong("extend_session", 0) != 1) {
                                v7_2 = this;
                            } else {
                                this.zzgt().zzjo().zzby("EXTEND_SESSION param attached: initiate a new session or extend the current active session");
                                v7_2 = this;
                                this.zzada.zzgo().zza(p26, 1);
                            }
                        }
                        com.google.android.gms.measurement.internal.zzfx v2_14 = new String[p28.size()];
                        com.google.android.gms.measurement.internal.zzcy v1_43 = ((String[]) v15_1.keySet().toArray(v2_14));
                        java.util.Arrays.sort(v1_43);
                        com.google.android.gms.measurement.internal.zzfx v2_15 = v1_43.length;
                        String v3_8 = 0;
                        android.os.Bundle v4_2 = 0;
                        while (v3_8 < v2_15) {
                            com.google.android.gms.measurement.internal.zzdx v19_1;
                            com.google.android.gms.measurement.internal.zzda v28_1;
                            com.google.android.gms.measurement.internal.zzcy v1_52;
                            int v0_18;
                            int v18_1;
                            com.google.android.gms.measurement.internal.zzfx v5_10;
                            android.os.Bundle v29_1;
                            java.util.Iterator v10_9 = v1_43[v3_8];
                            android.os.Bundle v9_17 = v15_1.get(v10_9);
                            this.zzgr();
                            android.os.Bundle v9_18 = com.google.android.gms.measurement.internal.zzfx.zzf(v9_17);
                            if (v9_18 == null) {
                                v29_1 = v0_3;
                                v28_1 = v1_43;
                                v18_1 = v2_15;
                                v5_10 = v11_6;
                                v1_52 = v13_2;
                                v19_1 = v14_1;
                                v0_18 = v15_1;
                            } else {
                                v15_1.putInt(v10_9, v9_18.length);
                                v28_1 = v1_43;
                                com.google.android.gms.measurement.internal.zzfx v8_4 = 0;
                                while (v8_4 < v9_18.length) {
                                    com.google.android.gms.measurement.internal.zzcy v1_54 = v9_18[v8_4];
                                    int v18_2 = v2_15;
                                    com.google.android.gms.measurement.internal.zzdy.zza(v14_1, v1_54, 1);
                                    android.os.Bundle[] v22 = v9_18;
                                    com.google.android.gms.measurement.internal.zzfx v2_32 = v10_9;
                                    com.google.android.gms.measurement.internal.zzfx v5_11 = v11_6;
                                    com.google.android.gms.measurement.internal.zzcy v1_55 = v13_2;
                                    com.google.android.gms.measurement.internal.zzdx v19_3 = v14_1;
                                    android.os.Bundle v29_2 = v0_3;
                                    int v0_19 = v15_1;
                                    android.os.Bundle v9_21 = this.zzgr().zza(p32, "_ep", v1_54, v0_3, p31, 0);
                                    v9_21.putString("_en", p25);
                                    v9_21.putLong("_eid", v5_11);
                                    v9_21.putString("_gn", v2_32);
                                    int v12_5 = v22;
                                    v9_21.putInt("_ll", v12_5.length);
                                    v9_21.putInt("_i", v8_4);
                                    v1_55.add(v9_21);
                                    v8_4++;
                                    v15_1 = v0_19;
                                    v13_2 = v1_55;
                                    v10_9 = v2_32;
                                    v9_18 = v12_5;
                                    v2_15 = v18_2;
                                    v14_1 = v19_3;
                                    v0_3 = v29_2;
                                    v11_6 = v5_11;
                                }
                                v29_1 = v0_3;
                                v18_1 = v2_15;
                                v5_10 = v11_6;
                                v1_52 = v13_2;
                                v19_1 = v14_1;
                                v0_18 = v15_1;
                                v4_2 += v9_18.length;
                            }
                            v3_8++;
                            v15_1 = v0_18;
                            v13_2 = v1_52;
                            v11_6 = v5_10;
                            v2_15 = v18_1;
                            v14_1 = v19_1;
                            com.google.android.gms.measurement.internal.zzfx v8 = 1;
                            v1_43 = v28_1;
                            v0_3 = v29_1;
                        }
                        com.google.android.gms.measurement.internal.zzcy v1_44 = v13_2;
                        int v0_9 = v15_1;
                        if (v4_2 != null) {
                            v0_9.putLong("_eid", v11_6);
                            v0_9.putInt("_epc", v4_2);
                        }
                        int v0_10 = 0;
                        while (v0_10 < v1_44.size()) {
                            String v3_9;
                            com.google.android.gms.measurement.internal.zzfx v2_20 = ((android.os.Bundle) v1_44.get(v0_10));
                            if (v0_10 == 0) {
                                v3_9 = 0;
                            } else {
                                v3_9 = 1;
                            }
                            String v3_10;
                            if (v3_9 == null) {
                                v3_10 = p25;
                            } else {
                                v3_10 = "_ep";
                            }
                            android.os.Bundle v9_15;
                            v2_20.putString("_o", p24);
                            if (!p30) {
                                v9_15 = v2_20;
                            } else {
                                v9_15 = this.zzgr().zze(v2_20);
                            }
                            this.zzgt().zzjn().zze("Logging event (FE)", this.zzgq().zzbt(p25), this.zzgq().zzd(v9_15));
                            java.util.Iterator v10_7 = new com.google.android.gms.measurement.internal.zzag;
                            int v12_2 = v1_44;
                            v10_7(v3_10, new com.google.android.gms.measurement.internal.zzad(v9_15), p24, p26);
                            this.zzgl().zzc(v10_7, p32);
                            if (!v17) {
                                java.util.Iterator v10_8 = v7_2.zzarc.iterator();
                                while (v10_8.hasNext()) {
                                    ((com.google.android.gms.measurement.internal.zzcy) v10_8.next()).onEvent(p24, p25, new android.os.Bundle(v9_15), p26);
                                }
                            }
                            v0_10++;
                            v1_44 = v12_2;
                        }
                        this.zzgw();
                        if ((this.zzgm().zzle() != null) && ("_ae".equals(p25))) {
                            this.zzgo().zza(1, 1);
                        }
                        return;
                    } else {
                        this.zzgt().zzji().zzg("Invalid event name. Event will not be logged (FE)", this.zzgq().zzbt(p25));
                        this.zzgr();
                        int v0_22 = com.google.android.gms.measurement.internal.zzfx.zza(p25, 40, 1);
                        if (p25 != null) {
                            v16_0 = p25.length();
                        }
                        this.zzada.zzgr().zza(p32, v9_4, "_ev", v0_22, v16_0);
                        return;
                    }
                } else {
                    return;
                }
            } else {
                this.zzgt().zzjn().zze("Passing event to registered event handler (FE)", this.zzgq().zzbt(p25), this.zzgq().zzd(p28));
                this.zzarb.interceptEvent(p24, p25, p28, p26);
                return;
            }
        } else {
            this.zzgt().zzjn().zzby("Event not sent since app measurement is disabled");
            return;
        }
    }

Method com.google.android.gms.measurement.internal.zzam.zzjc() calling method java.lang.reflect.Method.invoke()


    private final String zzjc()
    {
        try {
            com.google.android.gms.measurement.internal.zzau v1_9 = this.getContext().getClassLoader().loadClass("com.google.firebase.analytics.FirebaseAnalytics");
        } catch (ClassNotFoundException) {
            return 0;
        }
        if (v1_9 != null) {
            try {
                Class[] v4_0 = new Class[1];
                v4_0[0] = android.content.Context;
                String v2_1 = v1_9.getDeclaredMethod("getInstance", v4_0);
                Object[] v3_1 = new Object[1];
                v3_1[0] = this.getContext();
                String v2_2 = v2_1.invoke(0, v3_1);
            } catch (Exception) {
                this.zzgt().zzjk().zzby("Failed to obtain Firebase Analytics instance");
                return 0;
            }
            if (v2_2 != null) {
                try {
                    Class[] v4_2 = new Class[0];
                    Object[] v3_3 = new Object[0];
                    return ((String) v1_9.getDeclaredMethod("getFirebaseInstanceId", v4_2).invoke(v2_2, v3_3));
                } catch (Exception) {
                    this.zzgt().zzjl().zzby("Failed to retrieve Firebase Instance Id");
                    return 0;
                }
            } else {
                return 0;
            }
        } else {
            return 0;
        }
    }

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


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

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


    public void configureTlsExtensions(javax.net.ssl.SSLSocket p6, String p7, java.util.List p8)
    {
        AssertionError v7_2 = new java.util.ArrayList(p8.size());
        Object[] v0_3 = p8.size();
        int v2_2 = 0;
        while (v2_2 < v0_3) {
            String v3_5 = ((com.squareup.okhttp.Protocol) p8.get(v2_2));
            if (v3_5 != com.squareup.okhttp.Protocol.HTTP_1_0) {
                v7_2.add(v3_5.toString());
            }
            v2_2++;
        }
        try {
            reflect.Method v8_1 = com.squareup.okhttp.internal.Platform.getClassLoader();
            int v2_0 = new Class[2];
            v2_0[0] = this.clientProviderClass;
            v2_0[1] = this.serverProviderClass;
            AssertionError v7_1 = reflect.Proxy.newProxyInstance(v8_1, v2_0, new com.squareup.okhttp.internal.Platform$JettyNegoProvider(v7_2));
            reflect.Method v8_2 = this.putMethod;
            Object[] v0_2 = new Object[2];
            v0_2[0] = p6;
            v0_2[1] = v7_1;
            v8_2.invoke(0, v0_2);
            return;
        } catch (IllegalAccessException v6_1) {
            throw new AssertionError(v6_1);
        } catch (IllegalAccessException v6_1) {
        }
    }

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


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

Method com.google.common.reflect.Invokable$MethodInvokable.invokeInternal() calling method java.lang.reflect.Method.invoke()


    final Object invokeInternal(Object p2, Object[] p3)
    {
        return this.method.invoke(p2, p3);
    }

Method com.google.android.gms.measurement.internal.zzq.zzid() calling method java.lang.reflect.Method.invoke()


    public final String zzid()
    {
        try {
            String v0_2 = Class.forName("android.os.SystemProperties");
            String v3_2 = new Class[2];
            v3_2[0] = String;
            v3_2[1] = String;
            String v0_1 = v0_2.getMethod("get", v3_2);
            String v2_0 = new Object[2];
            v2_0[0] = "debug.firebase.analytics.app";
            v2_0[1] = "";
            return ((String) v0_1.invoke(0, v2_0));
        } catch (String v0_8) {
            this.zzgt().zzjg().zzg("Could not find SystemProperties class", v0_8);
            return "";
        } catch (String v0_7) {
            this.zzgt().zzjg().zzg("Could not find SystemProperties.get() method", v0_7);
            return "";
        } catch (String v0_6) {
            this.zzgt().zzjg().zzg("Could not access SystemProperties.get()", v0_6);
            return "";
        } catch (String v0_5) {
            this.zzgt().zzjg().zzg("SystemProperties.get() threw an exception", v0_5);
            return "";
        }
    }

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


    public boolean isDataCollectionDefaultEnabled()
    {
        try {
            String v3_1 = new Object[0];
            boolean v0_1 = ((Boolean) this.isDataCollectionDefaultEnabledMethod.invoke(this.firebaseAppInstance, v3_1)).booleanValue();
            return v0_1;
        } catch (Exception v1_1) {
            io.fabric.sdk.android.Fabric.getLogger().d("Fabric", "Cannot check isDataCollectionDefaultEnabled on FirebaseApp.", v1_1);
            return v0_1;
        }
    }

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


    public static io.fabric.sdk.android.services.common.FirebaseApp getInstance(android.content.Context p4)
    {
        try {
            int v4_7 = p4.getClassLoader().loadClass("com.google.firebase.FirebaseApp");
            String v2_3 = new Class[0];
            String v1_0 = new Object[0];
            return new io.fabric.sdk.android.services.common.FirebaseAppImpl(v4_7, v4_7.getDeclaredMethod("getInstance", v2_3).invoke(v4_7, v1_0));
        } catch (ClassNotFoundException) {
            io.fabric.sdk.android.Fabric.getLogger().d("Fabric", "Could not find class: com.google.firebase.FirebaseApp");
            return 0;
        } catch (int v4_3) {
            io.fabric.sdk.android.Logger v0_3 = io.fabric.sdk.android.Fabric.getLogger();
            String v2_2 = new StringBuilder();
            v2_2.append("Could not find method: ");
            v2_2.append(v4_3.getMessage());
            v0_3.d("Fabric", v2_2.toString());
            return 0;
        } catch (int v4_2) {
            io.fabric.sdk.android.Fabric.getLogger().d("Fabric", "Unexpected error loading FirebaseApp instance.", v4_2);
            return 0;
        }
    }

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


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

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


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

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


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

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


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

Method com.squareup.okhttp.internal.tls.AndroidTrustRootIndex.findByIssuerAndSignature() calling method java.lang.reflect.Method.invoke()


    public java.security.cert.X509Certificate findByIssuerAndSignature(java.security.cert.X509Certificate p6)
    {
        java.security.cert.X509Certificate v0 = 0;
        try {
            reflect.Method v1 = this.findByIssuerAndSignatureMethod;
            javax.net.ssl.X509TrustManager v2 = this.trustManager;
            Object[] v3_1 = new Object[1];
            v3_1[0] = p6;
            AssertionError v6_4 = ((java.security.cert.TrustAnchor) v1.invoke(v2, v3_1));
        } catch (IllegalAccessException) {
            throw new AssertionError();
        } catch (reflect.InvocationTargetException) {
            return v0;
        }
        if (v6_4 != null) {
            v0 = v6_4.getTrustedCert();
        }
        return v0;
    }

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


    public void untagSocket(java.net.Socket p5)
    {
        RuntimeException v0_0 = this.trafficStatsUntagSocket;
        if (v0_0 != null) {
            try {
                Object[] v2_1 = new Object[1];
                v2_1[0] = p5;
                v0_0.invoke(0, v2_1);
                return;
            } catch (Throwable v5_2) {
                throw new RuntimeException(v5_2);
            } catch (Throwable v5_3) {
                throw new RuntimeException(v5_3.getCause());
            }
        } else {
            return;
        }
    }

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


    public void tagSocket(java.net.Socket p5)
    {
        RuntimeException v0_0 = this.trafficStatsTagSocket;
        if (v0_0 != null) {
            try {
                Object[] v2_1 = new Object[1];
                v2_1[0] = p5;
                v0_0.invoke(0, v2_1);
                return;
            } catch (Throwable v5_2) {
                throw new RuntimeException(v5_2);
            } catch (Throwable v5_3) {
                throw new RuntimeException(v5_3.getCause());
            }
        } else {
            return;
        }
    }

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

Couldn't retrieve source code

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


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

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


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

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


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

Method com.google.common.reflect.Types$JavaVersion$3.typeName() calling method java.lang.reflect.Method.invoke()


    String typeName(reflect.Type p5)
    {
        try {
            Class[] v3 = new Class[0];
            Object[] v1_1 = new Object[0];
            return ((String) reflect.Type.getMethod("getTypeName", v3).invoke(p5, v1_1));
        } catch (NoSuchMethodException) {
            throw new AssertionError("Type.getTypeName should be available in Java 8");
        } catch (IllegalAccessException v5_2) {
            throw new RuntimeException(v5_2);
        } catch (IllegalAccessException v5_1) {
            throw new RuntimeException(v5_1);
        }
    }

Method com.google.common.io.Closer$SuppressingSuppressor.suppress() calling method java.lang.reflect.Method.invoke()


    public void suppress(java.io.Closeable p4, Throwable p5, Throwable p6)
    {
        if (p5 != p6) {
            try {
                Object[] v1_1 = new Object[1];
                v1_1[0] = p6;
                com.google.common.io.Closer$SuppressingSuppressor.addSuppressed.invoke(p5, v1_1);
            } catch (Throwable) {
                com.google.common.io.Closer$LoggingSuppressor.INSTANCE.suppress(p4, p5, p6);
            }
            return;
        } else {
            return;
        }
    }

Method com.zendesk.util.LocaleUtil.createIso639Alpha3LocaleJdk() calling method java.lang.reflect.Method.invoke()


    private static java.util.Locale createIso639Alpha3LocaleJdk(String p8, String p9)
    {
        try {
            Class[] v5 = new Class[2];
            v5[0] = String;
            v5[1] = String;
            String v2_0 = java.util.Locale.getDeclaredMethod("createConstant", v5);
            v2_0.setAccessible(1);
            Object[] v3_0 = new Object[2];
            v3_0[0] = p8;
            v3_0[1] = p9;
            return ((java.util.Locale) v2_0.invoke(0, v3_0));
        } catch (Exception v8_3) {
            Object[] v1_1 = new Object[0];
            com.zendesk.logger.Logger.e(com.zendesk.util.LocaleUtil.LOG_TAG, "Unable to create ISO-6390-Alpha3 per reflection", v8_3, v1_1);
            return 0;
        }
    }

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

Couldn't retrieve source code

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


    public Object invoke(Object p6, reflect.Method p7, Object[] p8)
    {
        String v6_0 = p7.getName();
        boolean v0_0 = p7.getReturnType();
        if (p8 == 0) {
            p8 = com.squareup.okhttp.internal.Util.EMPTY_STRING_ARRAY;
        }
        if ((!v6_0.equals("supports")) || (Boolean.TYPE != v0_0)) {
            if ((!v6_0.equals("unsupported")) || (Void.TYPE != v0_0)) {
                if ((!v6_0.equals("protocols")) || (p8.length != 0)) {
                    if (((!v6_0.equals("selectProtocol")) && (!v6_0.equals("select"))) || ((String != v0_0) || ((p8.length != 1) || (!(p8[0] instanceof java.util.List))))) {
                        if (((!v6_0.equals("protocolSelected")) && (!v6_0.equals("selected"))) || (p8.length != 1)) {
                            return p7.invoke(this, p8);
                        } else {
                            this.selected = ((String) p8[0]);
                            return 0;
                        }
                    } else {
                        String v6_7 = ((java.util.List) p8[0]);
                        int v7_1 = v6_7.size();
                        int v8_1 = 0;
                        while (v8_1 < v7_1) {
                            if (!this.protocols.contains(v6_7.get(v8_1))) {
                                v8_1++;
                            } else {
                                String v6_12 = ((String) v6_7.get(v8_1));
                                this.selected = v6_12;
                                return v6_12;
                            }
                        }
                        String v6_10 = ((String) this.protocols.get(0));
                        this.selected = v6_10;
                        return v6_10;
                    }
                } else {
                    return this.protocols;
                }
            } else {
                this.unsupported = 1;
                return 0;
            }
        } else {
            return Boolean.valueOf(1);
        }
    }

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


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

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


    public varargs Object invoke(Object p4, Object[] p5)
    {
        String v0_1 = this.getMethod(p4.getClass());
        if (v0_1 == null) {
            String v0_4 = new StringBuilder();
            v0_4.append("Method ");
            v0_4.append(this.methodName);
            v0_4.append(" not supported for object ");
            v0_4.append(p4);
            throw new AssertionError(v0_4.toString());
        } else {
            try {
                return v0_1.invoke(p4, p5);
            } catch (IllegalAccessException v4_3) {
                StringBuilder v1_3 = new StringBuilder();
                v1_3.append("Unexpectedly could not call: ");
                v1_3.append(v0_1);
                AssertionError v5_3 = new AssertionError(v1_3.toString());
                v5_3.initCause(v4_3);
                throw v5_3;
            }
        }
    }

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


    public static com.google.gson.internal.UnsafeAllocator create()
    {
        Class[] v3_3 = Class.forName("sun.misc.Unsafe");
        String v4_7 = v3_3.getDeclaredField("theUnsafe");
        v4_7.setAccessible(1);
        String v4_0 = v4_7.get(0);
        Class[] v6_0 = new Class[1];
        v6_0[0] = Class;
        return new com.google.gson.internal.UnsafeAllocator$1(v3_3.getMethod("allocateInstance", v6_0), v4_0);
    }

Method com.google.firebase.FirebaseApp.zza() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method com.google.common.util.concurrent.SimpleTimeLimiter$1$1.call() calling method java.lang.reflect.Method.invoke()


    public Object call()
    {
        try {
            return this.val$method.invoke(this.this$1.val$target, this.val$args);
        } catch (AssertionError v0_4) {
            com.google.common.util.concurrent.SimpleTimeLimiter.access$000(v0_4, 0);
            throw new AssertionError("can\'t get here");
        }
    }

Method com.google.common.util.concurrent.MoreExecutors.platformThreadFactory() calling method java.lang.reflect.Method.invoke()


    public static java.util.concurrent.ThreadFactory platformThreadFactory()
    {
        if (com.google.common.util.concurrent.MoreExecutors.isAppEngine()) {
            try {
                Class[] v3 = new Class[0];
                String v2_0 = new Object[0];
                return ((java.util.concurrent.ThreadFactory) Class.forName("com.google.appengine.api.ThreadManager").getMethod("currentRequestThreadFactory", v3).invoke(0, v2_0));
            } catch (RuntimeException v0_10) {
                throw new RuntimeException("Couldn\'t invoke ThreadManager.currentRequestThreadFactory", v0_10);
            } catch (RuntimeException v0_8) {
                throw new RuntimeException("Couldn\'t invoke ThreadManager.currentRequestThreadFactory", v0_8);
            } catch (RuntimeException v0_7) {
                throw new RuntimeException("Couldn\'t invoke ThreadManager.currentRequestThreadFactory", v0_7);
            } catch (RuntimeException v0_4) {
                throw com.google.common.base.Throwables.propagate(v0_4.getCause());
            }
        } else {
            return java.util.concurrent.Executors.defaultThreadFactory();
        }
    }

Method com.google.common.util.concurrent.MoreExecutors.isAppEngine() calling method java.lang.reflect.Method.invoke()


    private static boolean isAppEngine()
    {
        int v1 = 0;
        if (System.getProperty("com.google.appengine.runtime.environment") != null) {
            try {
                Object[] v3_1 = new Class[0];
                Object[] v3_0 = new Object[0];
            } catch (ClassNotFoundException) {
                return 0;
            } catch (reflect.InvocationTargetException) {
                return 0;
            } catch (IllegalAccessException) {
                return 0;
            } catch (NoSuchMethodException) {
                return 0;
            }
            if (Class.forName("com.google.apphosting.api.ApiProxy").getMethod("getCurrentEnvironment", v3_1).invoke(0, v3_0) != null) {
                v1 = 1;
            }
            return v1;
        } else {
            return 0;
        }
    }

Method com.google.common.eventbus.EventSubscriber.handleEvent() calling method java.lang.reflect.Method.invoke()


    public void handleEvent(Object p5)
    {
        com.google.common.base.Preconditions.checkNotNull(p5);
        try {
            boolean v0_0 = this.method;
            Error v1_0 = this.target;
            StringBuilder v2_3 = new Object[1];
            v2_3[0] = p5;
            v0_0.invoke(v1_0, v2_3);
            return;
        } catch (boolean v0_4) {
            Error v5_7 = String.valueOf(String.valueOf(p5));
            StringBuilder v2_5 = new StringBuilder((v5_7.length() + 33));
            v2_5.append("Method rejected target/argument: ");
            v2_5.append(v5_7);
            throw new Error(v2_5.toString(), v0_4);
        } catch (boolean v0_3) {
            Error v5_4 = String.valueOf(String.valueOf(p5));
            StringBuilder v2_1 = new StringBuilder((v5_4.length() + 28));
            v2_1.append("Method became inaccessible: ");
            v2_1.append(v5_4);
            throw new Error(v2_1.toString(), v0_3);
        } catch (Error v5_9) {
            if (!(v5_9.getCause() instanceof Error)) {
                throw v5_9;
            } else {
                throw ((Error) v5_9.getCause());
            }
        }
    }

Method com.google.common.base.internal.Finalizer.cleanUp() calling method java.lang.reflect.Method.invoke()


    private boolean cleanUp(ref.Reference p6)
    {
        reflect.Method v0 = this.getFinalizeReferentMethod();
        if (v0 == null) {
            return 0;
        }
        do {
            p6.clear();
            if (p6 != this.frqReference) {
                try {
                    java.util.logging.Logger v2_2 = new Object[0];
                    v0.invoke(p6, v2_2);
                } catch (int v6_3) {
                    com.google.common.base.internal.Finalizer.logger.log(java.util.logging.Level.SEVERE, "Error cleaning up after reference.", v6_3);
                }
                p6 = this.queue.poll();
            } else {
                return 0;
            }
        } while(p6 != 0);
        return 1;
    }

Method com.google.common.base.FinalizableReferenceQueue.<init>() calling method java.lang.reflect.Method.invoke()


    public FinalizableReferenceQueue()
    {
        this.queue = new ref.ReferenceQueue();
        this.frqRef = new ref.PhantomReference(this, this.queue);
        int v0_3 = 1;
        try {
            String v4_1 = new Object[3];
            v4_1[0] = com.google.common.base.FinalizableReference;
            v4_1[1] = this.queue;
            v4_1[2] = this.frqRef;
            com.google.common.base.FinalizableReferenceQueue.startFinalizer.invoke(0, v4_1);
        } catch (int v0_4) {
            throw new AssertionError(v0_4);
        } catch (int v0_2) {
            com.google.common.base.FinalizableReferenceQueue.logger.log(java.util.logging.Level.INFO, "Failed to start reference finalizer thread. Reference cleanup will only occur when new references are created.", v0_2);
            v0_3 = 0;
        }
        this.threadStarted = v0_3;
        return;
    }

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


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

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


    public void serializeAsField(Object p5, com.fasterxml.jackson.core.JsonGenerator p6, com.fasterxml.jackson.databind.SerializerProvider p7)
    {
        int v0_1;
        int v0_0 = this._accessorMethod;
        if (v0_0 != 0) {
            com.fasterxml.jackson.databind.JsonSerializer v1_3 = new Object[0];
            v0_1 = v0_0.invoke(p5, v1_3);
        } else {
            v0_1 = this._field.get(p5);
        }
        if (v0_1 != 0) {
            com.fasterxml.jackson.databind.JsonSerializer v1_0 = this._serializer;
            if (v1_0 == null) {
                com.fasterxml.jackson.databind.JsonSerializer v1_1 = v0_1.getClass();
                boolean v2_0 = this._dynamicSerializers;
                Object v3_0 = v2_0.serializerFor(v1_1);
                if (v3_0 != null) {
                    v1_0 = v3_0;
                } else {
                    v1_0 = this._findAndAddDynamic(v2_0, v1_1, p7);
                }
            }
            boolean v2_1 = this._suppressableValue;
            if (v2_1) {
                if (com.fasterxml.jackson.databind.ser.BeanPropertyWriter.MARKER_FOR_EMPTY != v2_1) {
                    if (v2_1.equals(v0_1)) {
                        return;
                    }
                } else {
                    if (v1_0.isEmpty(p7, v0_1)) {
                        return;
                    }
                }
            }
            if ((v0_1 != p5) || (!this._handleSelfReference(p5, p6, p7, v1_0))) {
                p6.writeFieldName(this._name);
                com.fasterxml.jackson.databind.jsontype.TypeSerializer v5_3 = this._typeSerializer;
                if (v5_3 != null) {
                    v1_0.serializeWithType(v0_1, p6, p7, v5_3);
                } else {
                    v1_0.serialize(v0_1, p6, p7);
                }
                return;
            } else {
                return;
            }
        } else {
            if (this._nullSerializer != null) {
                p6.writeFieldName(this._name);
                this._nullSerializer.serialize(0, p6, p7);
            }
            return;
        }
    }

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


    public void serializeAsElement(Object p5, com.fasterxml.jackson.core.JsonGenerator p6, com.fasterxml.jackson.databind.SerializerProvider p7)
    {
        int v0_2;
        int v0_0 = this._accessorMethod;
        if (v0_0 != 0) {
            com.fasterxml.jackson.databind.JsonSerializer v1_3 = new Object[0];
            v0_2 = v0_0.invoke(p5, v1_3);
        } else {
            v0_2 = this._field.get(p5);
        }
        if (v0_2 != 0) {
            com.fasterxml.jackson.databind.JsonSerializer v1_0 = this._serializer;
            if (v1_0 == null) {
                com.fasterxml.jackson.databind.JsonSerializer v1_1 = v0_2.getClass();
                boolean v2_0 = this._dynamicSerializers;
                Object v3_0 = v2_0.serializerFor(v1_1);
                if (v3_0 != null) {
                    v1_0 = v3_0;
                } else {
                    v1_0 = this._findAndAddDynamic(v2_0, v1_1, p7);
                }
            }
            boolean v2_1 = this._suppressableValue;
            if (v2_1) {
                if (com.fasterxml.jackson.databind.ser.BeanPropertyWriter.MARKER_FOR_EMPTY != v2_1) {
                    if (v2_1.equals(v0_2)) {
                        this.serializeAsPlaceholder(p5, p6, p7);
                        return;
                    }
                } else {
                    if (v1_0.isEmpty(p7, v0_2)) {
                        this.serializeAsPlaceholder(p5, p6, p7);
                        return;
                    }
                }
            }
            if ((v0_2 != p5) || (!this._handleSelfReference(p5, p6, p7, v1_0))) {
                com.fasterxml.jackson.databind.jsontype.TypeSerializer v5_2 = this._typeSerializer;
                if (v5_2 != null) {
                    v1_0.serializeWithType(v0_2, p6, p7, v5_2);
                } else {
                    v1_0.serialize(v0_2, p6, p7);
                }
                return;
            } else {
                return;
            }
        } else {
            com.fasterxml.jackson.databind.jsontype.TypeSerializer v5_3 = this._nullSerializer;
            if (v5_3 == null) {
                p6.writeNull();
            } else {
                v5_3.serialize(0, p6, p7);
            }
            return;
        }
    }

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


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

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


    public final void deserializeAndSet(com.fasterxml.jackson.core.JsonParser p3, com.fasterxml.jackson.databind.DeserializationContext p4, Object p5)
    {
        if (p3.getCurrentToken() != com.fasterxml.jackson.core.JsonToken.VALUE_NULL) {
            if (this._valueTypeDeserializer != null) {
                String v4_7 = new StringBuilder();
                v4_7.append("Problem deserializing \'setterless\' property (\"");
                v4_7.append(this.getName());
                v4_7.append("\"): no way to handle typed deser with setterless yet");
                throw com.fasterxml.jackson.databind.JsonMappingException.from(p3, v4_7.toString());
            } else {
                try {
                    Object[] v1_2 = new Object[0];
                    String v5_3 = this._getter.invoke(p5, v1_2);
                } catch (String v4_2) {
                    this._throwAsIOE(p3, v4_2);
                    return;
                }
                if (v5_3 == null) {
                    String v4_4 = new StringBuilder();
                    v4_4.append("Problem deserializing \'setterless\' property \'");
                    v4_4.append(this.getName());
                    v4_4.append("\': get method returned null");
                    throw com.fasterxml.jackson.databind.JsonMappingException.from(p3, v4_4.toString());
                } else {
                    this._valueDeserializer.deserialize(p3, p4, v5_3);
                    return;
                }
            }
        } else {
            return;
        }
    }

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


    public Object setAndReturn(Object p4, Object p5)
    {
        try {
            reflect.Method v0 = this._setter;
            Object[] v1_1 = new Object[1];
            v1_1[0] = p5;
            Object v5_1 = v0.invoke(p4, v1_1);
        } catch (Object v4_2) {
            this._throwAsIOE(v4_2, v5_1);
            return 0;
        }
        if (v5_1 != null) {
            p4 = v5_1;
        }
        return p4;
    }

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


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

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


    public Object deserializeSetAndReturn(com.fasterxml.jackson.core.JsonParser p4, com.fasterxml.jackson.databind.DeserializationContext p5, Object p6)
    {
        Object v5_1 = this.deserialize(p4, p5);
        try {
            reflect.Method v0 = this._setter;
            Object[] v1_1 = new Object[1];
            v1_1[0] = v5_1;
            Exception v4_2 = v0.invoke(p6, v1_1);
        } catch (Exception v6_1) {
            this._throwAsIOE(v4_2, v6_1, v5_1);
            return 0;
        }
        if (v4_2 == null) {
            v4_2 = p6;
        }
        return v4_2;
    }

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


    public void deserializeAndSet(com.fasterxml.jackson.core.JsonParser p4, com.fasterxml.jackson.databind.DeserializationContext p5, Object p6)
    {
        Object v5_1 = this.deserialize(p4, p5);
        try {
            reflect.Method v0 = this._setter;
            Object[] v1_1 = new Object[1];
            v1_1[0] = v5_1;
            v0.invoke(p6, v1_1);
        } catch (Exception v6_1) {
            this._throwAsIOE(p4, v6_1, v5_1);
        }
        return;
    }

Method com.google.android.gms.internal.measurement.zzuo.zza() calling method java.lang.reflect.Method.invoke()


    static varargs Object zza(reflect.Method p0, Object p1, Object[] p2)
    {
        try {
            return p0.invoke(p1, p2);
        } catch (Error v0_3) {
            throw new RuntimeException("Couldn\'t use Java reflection to implement protocol message reflection.", v0_3);
        } catch (Error v0_4) {
            Error v0_5 = v0_4.getCause();
            if ((v0_5 instanceof RuntimeException)) {
                throw ((RuntimeException) v0_5);
            } else {
                if (!(v0_5 instanceof Error)) {
                    throw new RuntimeException("Unexpected exception thrown by generated accessor method.", v0_5);
                } else {
                    throw ((Error) v0_5);
                }
            }
        }
    }

Method com.google.android.gms.internal.icing.zzdj.zza() calling method java.lang.reflect.Method.invoke()


    static varargs Object zza(reflect.Method p0, Object p1, Object[] p2)
    {
        try {
            return p0.invoke(p1, p2);
        } catch (Error v0_3) {
            throw new RuntimeException("Couldn\'t use Java reflection to implement protocol message reflection.", v0_3);
        } catch (Error v0_4) {
            Error v0_5 = v0_4.getCause();
            if ((v0_5 instanceof RuntimeException)) {
                throw ((RuntimeException) v0_5);
            } else {
                if (!(v0_5 instanceof Error)) {
                    throw new RuntimeException("Unexpected exception thrown by generated accessor method.", v0_5);
                } else {
                    throw ((Error) v0_5);
                }
            }
        }
    }

Method com.google.android.gms.internal.firebase-perf.zzep.zza() calling method java.lang.reflect.Method.invoke()


    static varargs Object zza(reflect.Method p0, Object p1, Object[] p2)
    {
        try {
            return p0.invoke(p1, p2);
        } catch (Error v0_3) {
            throw new RuntimeException("Couldn\'t use Java reflection to implement protocol message reflection.", v0_3);
        } catch (Error v0_4) {
            Error v0_5 = v0_4.getCause();
            if ((v0_5 instanceof RuntimeException)) {
                throw ((RuntimeException) v0_5);
            } else {
                if (!(v0_5 instanceof Error)) {
                    throw new RuntimeException("Unexpected exception thrown by generated accessor method.", v0_5);
                } else {
                    throw ((Error) v0_5);
                }
            }
        }
    }

Method com.google.android.gms.internal.clearcut.zzcg.zza() calling method java.lang.reflect.Method.invoke()


    static varargs Object zza(reflect.Method p0, Object p1, Object[] p2)
    {
        try {
            return p0.invoke(p1, p2);
        } catch (Error v0_3) {
            throw new RuntimeException("Couldn\'t use Java reflection to implement protocol message reflection.", v0_3);
        } catch (Error v0_4) {
            Error v0_5 = v0_4.getCause();
            if ((v0_5 instanceof RuntimeException)) {
                throw ((RuntimeException) v0_5);
            } else {
                if (!(v0_5 instanceof Error)) {
                    throw new RuntimeException("Unexpected exception thrown by generated accessor method.", v0_5);
                } else {
                    throw ((Error) v0_5);
                }
            }
        }
    }

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


    public void serializeWithType(Object p4, com.fasterxml.jackson.core.JsonGenerator p5, com.fasterxml.jackson.databind.SerializerProvider p6, com.fasterxml.jackson.databind.jsontype.TypeSerializer p7)
    {
        try {
            com.fasterxml.jackson.databind.JsonSerializer v1_3 = new Object[0];
            Object v0_1 = this._accessorMethod.invoke(p4, v1_3);
        } catch (com.fasterxml.jackson.databind.JsonMappingException v4_2) {
            throw v4_2;
        } catch (Error v5_1) {
        }
        if (v0_1 != null) {
            com.fasterxml.jackson.databind.JsonSerializer v1_2 = this._valueSerializer;
            if (v1_2 != null) {
                if (this._forceTypeInformation) {
                    p7.writeTypePrefixForScalar(p4, p5);
                    v1_2.serialize(v0_1, p5, p6);
                    p7.writeTypeSuffixForScalar(p4, p5);
                    return;
                }
            } else {
                v1_2 = p6.findValueSerializer(v0_1.getClass(), this._property);
            }
            v1_2.serializeWithType(v0_1, p5, p6, p7);
            return;
        } else {
            p6.defaultSerializeNull(p5);
            return;
        }
    }

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


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

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


    protected boolean _acceptJsonFormatVisitorForEnum(com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper p7, com.fasterxml.jackson.databind.JavaType p8, Class p9)
    {
        com.fasterxml.jackson.databind.JsonMappingException v7_1 = p7.expectStringFormat(p8);
        if (v7_1 != null) {
            String v8_7 = new java.util.LinkedHashSet();
            String v9_4 = p9.getEnumConstants();
            int v0 = v9_4.length;
            int v2 = 0;
            while (v2 < v0) {
                Object v3 = v9_4[v2];
                try {
                    Object[] v5 = new Object[0];
                    v8_7.add(String.valueOf(this._accessorMethod.invoke(v3, v5)));
                    v2++;
                } catch (com.fasterxml.jackson.databind.JsonMappingException v7_3) {
                }
            }
            v7_1.enumTypes(v8_7);
        }
        return 1;
    }

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


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

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


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

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


    public final Object call1(Object p4)
    {
        reflect.Method v0 = this._method;
        Object[] v1_1 = new Object[1];
        v1_1[0] = p4;
        return v0.invoke(0, v1_1);
    }

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


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

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


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

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


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

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


    protected final Object finishBuild(com.fasterxml.jackson.databind.DeserializationContext p3, Object p4)
    {
        reflect.Method v0_0 = this._buildMethod;
        if (v0_0 != null) {
            try {
                Object[] v1_1 = new Object[0];
                int v3_1 = v0_0.getMember().invoke(p4, v1_1);
                return v3_1;
            } catch (Exception v4_1) {
                this.wrapInstantiationProblem(v4_1, v3_1);
                return 0;
            }
        } else {
            return p4;
        }
    }

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


    protected android.graphics.Typeface createFromFamiliesWithDefault(Object p6)
    {
        try {
            RuntimeException v0_6 = reflect.Array.newInstance(this.mFontFamily, 1);
            reflect.Array.set(v0_6, 0, p6);
            reflect.InvocationTargetException v6_4 = this.mCreateFromFamiliesWithDefault;
            Object[] v4_1 = new Object[4];
            v4_1[0] = v0_6;
            v4_1[1] = "sans-serif";
            v4_1[2] = Integer.valueOf(-1);
            v4_1[3] = Integer.valueOf(-1);
            return ((android.graphics.Typeface) v6_4.invoke(0, v4_1));
        } catch (reflect.InvocationTargetException v6_3) {
            throw new RuntimeException(v6_3);
        } catch (reflect.InvocationTargetException v6_3) {
        }
    }

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

Couldn't retrieve source code

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


    public Object _parse(String p3, com.fasterxml.jackson.databind.DeserializationContext p4)
    {
        p4 = this._factoryMethod;
        Object[] v0_1 = new Object[1];
        v0_1[0] = p3;
        return p4.invoke(0, v0_1);
    }

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


    public Object deserialize(com.fasterxml.jackson.core.JsonParser p5, com.fasterxml.jackson.databind.DeserializationContext p6)
    {
        com.fasterxml.jackson.databind.JsonMappingException v5_1;
        Class v0_0 = this._deser;
        if (v0_0 == null) {
            Class v0_4 = p5.getCurrentToken();
            if ((v0_4 != com.fasterxml.jackson.core.JsonToken.VALUE_STRING) && (v0_4 != com.fasterxml.jackson.core.JsonToken.FIELD_NAME)) {
                v5_1 = p5.getValueAsString();
            } else {
                v5_1 = p5.getText();
            }
        } else {
            v5_1 = v0_0.deserialize(p5, p6);
        }
        try {
            Class v0_1 = this._factory;
            com.fasterxml.jackson.core.JsonToken v1_0 = this._valueClass;
            Object[] v2_1 = new Object[1];
            v2_1[0] = v5_1;
            return v0_1.invoke(v1_0, v2_1);
        } catch (com.fasterxml.jackson.databind.JsonMappingException v5_3) {
            com.fasterxml.jackson.databind.JsonMappingException v5_4 = com.fasterxml.jackson.databind.util.ClassUtil.getRootCause(v5_3);
            if (!(v5_4 instanceof java.io.IOException)) {
                throw p6.instantiationException(this._valueClass, v5_4);
            } else {
                throw ((java.io.IOException) v5_4);
            }
        }
    }

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


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

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


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

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


    public int getLegacyStreamType()
    {
        IllegalAccessException v0_0 = this.mLegacyStreamType;
        if (v0_0 == -1) {
            IllegalAccessException v0_6 = android.support.v4.media.AudioAttributesImplApi21.getAudioAttributesToLegacyStreamTypeMethod();
            if (v0_6 != null) {
                try {
                    String v3_6 = new Object[1];
                    v3_6[0] = this.mAudioAttributes;
                    return ((Integer) v0_6.invoke(0, v3_6)).intValue();
                } catch (IllegalAccessException v0_4) {
                    String v3_1 = new StringBuilder();
                    v3_1.append("getLegacyStreamType() failed on API: ");
                    v3_1.append(android.os.Build$VERSION.SDK_INT);
                    android.util.Log.w("AudioAttributesCompat21", v3_1.toString(), v0_4);
                    return -1;
                } catch (IllegalAccessException v0_4) {
                    v3_1 = new StringBuilder();
                    v3_1.append("getLegacyStreamType() failed on API: ");
                    v3_1.append(android.os.Build$VERSION.SDK_INT);
                    android.util.Log.w("AudioAttributesCompat21", v3_1.toString(), v0_4);
                    return -1;
                }
            } else {
                String v2_2 = new StringBuilder();
                v2_2.append("No AudioAttributes#toLegacyStreamType() on API: ");
                v2_2.append(android.os.Build$VERSION.SDK_INT);
                android.util.Log.w("AudioAttributesCompat21", v2_2.toString());
                return -1;
            }
        } else {
            return v0_0;
        }
    }

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


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

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


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

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


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

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


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

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


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

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


    protected android.graphics.Typeface createFromFamiliesWithDefault(Object p6)
    {
        try {
            RuntimeException v0_5 = reflect.Array.newInstance(this.mFontFamily, 1);
            reflect.Array.set(v0_5, 0, p6);
            reflect.InvocationTargetException v6_4 = this.mCreateFromFamiliesWithDefault;
            Object[] v4_1 = new Object[3];
            v4_1[0] = v0_5;
            v4_1[1] = Integer.valueOf(-1);
            v4_1[2] = Integer.valueOf(-1);
            return ((android.graphics.Typeface) v6_4.invoke(0, v4_1));
        } catch (reflect.InvocationTargetException v6_3) {
            throw new RuntimeException(v6_3);
        } catch (reflect.InvocationTargetException v6_3) {
        }
    }

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


    private boolean freeze(Object p3)
    {
        try {
            Object[] v1_1 = new Object[0];
            return ((Boolean) this.mFreeze.invoke(p3, v1_1)).booleanValue();
        } catch (reflect.InvocationTargetException v3_1) {
            throw new RuntimeException(v3_1);
        } catch (reflect.InvocationTargetException v3_1) {
        }
    }

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


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

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


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

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


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

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

Couldn't retrieve source code

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

Couldn't retrieve source code

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

Couldn't retrieve source code

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


    private boolean handleAccessibilityExit(android.view.MotionEvent p7)
    {
        if (p7.getAction() == 10) {
            try {
                reflect.Method v7_12 = android.support.v4.widget.ExploreByTouchHelper.getDeclaredField("mHoveredVirtualViewId");
                v7_12.setAccessible(1);
            } catch (reflect.Method v7_8) {
                android.util.Log.e("Chip", "Unable to send Accessibility Exit event", v7_8);
            } catch (reflect.Method v7_7) {
                android.util.Log.e("Chip", "Unable to send Accessibility Exit event", v7_7);
            } catch (reflect.Method v7_6) {
                android.util.Log.e("Chip", "Unable to send Accessibility Exit event", v7_6);
            } catch (reflect.Method v7_5) {
                android.util.Log.e("Chip", "Unable to send Accessibility Exit event", v7_5);
            }
            if (((Integer) v7_12.get(this.touchHelper)).intValue() != -2147483648) {
                Object[] v4_0 = new Class[1];
                v4_0[0] = Integer.TYPE;
                reflect.Method v7_10 = android.support.v4.widget.ExploreByTouchHelper.getDeclaredMethod("updateHoveredVirtualView", v4_0);
                v7_10.setAccessible(1);
                android.support.design.chip.Chip$ChipTouchHelper v3_1 = this.touchHelper;
                Object[] v4_1 = new Object[1];
                v4_1[0] = Integer.valueOf(-2147483648);
                v7_10.invoke(v3_1, v4_1);
                return 1;
            }
        }
        return 0;
    }

Method com.google.android.gms.internal.measurement.zzvk.zzxf() calling method java.lang.reflect.Method.invoke()


    private static com.google.android.gms.internal.measurement.zzvu zzxf()
    {
        try {
            Class[] v3 = new Class[0];
            Object[] v2_1 = new Object[0];
            return ((com.google.android.gms.internal.measurement.zzvu) Class.forName("com.google.protobuf.DescriptorMessageInfoFactory").getDeclaredMethod("getInstance", v3).invoke(0, v2_1));
        } catch (Exception) {
            return com.google.android.gms.internal.measurement.zzvk.zzcai;
        }
    }

Method com.google.android.gms.internal.icing.zzeg.zzcl() calling method java.lang.reflect.Method.invoke()


    private static com.google.android.gms.internal.icing.zzep zzcl()
    {
        try {
            Class[] v3 = new Class[0];
            Object[] v2_1 = new Object[0];
            return ((com.google.android.gms.internal.icing.zzep) Class.forName("com.google.protobuf.DescriptorMessageInfoFactory").getDeclaredMethod("getInstance", v3).invoke(0, v2_1));
        } catch (Exception) {
            return com.google.android.gms.internal.icing.zzeg.zzlw;
        }
    }

Method com.google.android.gms.internal.firebase-perf.zzfn.zzii() calling method java.lang.reflect.Method.invoke()


    private static com.google.android.gms.internal.firebase-perf.zzfx zzii()
    {
        try {
            Class[] v3 = new Class[0];
            Object[] v2_1 = new Object[0];
            return ((com.google.android.gms.internal.firebase-perf.zzfx) Class.forName("com.google.protobuf.DescriptorMessageInfoFactory").getDeclaredMethod("getInstance", v3).invoke(0, v2_1));
        } catch (Exception) {
            return com.google.android.gms.internal.firebase-perf.zzfn.zztb;
        }
    }

Method com.google.android.gms.internal.clearcut.zzdd.zzby() calling method java.lang.reflect.Method.invoke()


    private static com.google.android.gms.internal.clearcut.zzdn zzby()
    {
        try {
            Class[] v3 = new Class[0];
            Object[] v2_1 = new Object[0];
            return ((com.google.android.gms.internal.clearcut.zzdn) Class.forName("com.google.protobuf.DescriptorMessageInfoFactory").getDeclaredMethod("getInstance", v3).invoke(0, v2_1));
        } catch (Exception) {
            return com.google.android.gms.internal.clearcut.zzdd.zzlz;
        }
    }

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


    public boolean register()
    {
        Exception v0_2 = this.getClass("com.google.android.gms.measurement.AppMeasurement");
        if (v0_2 != null) {
            String v2_5 = this.getInstance(v0_2);
            if (v2_5 != null) {
                String v3_0 = this.getClass("com.google.android.gms.measurement.AppMeasurement$OnEventListener");
                if (v3_0 != null) {
                    try {
                        Class[] v6 = new Class[1];
                        v6[0] = v3_0;
                        Exception v0_1 = v0_2.getDeclaredMethod("registerOnMeasurementEventListener", v6);
                        String v5_1 = new Object[1];
                        v5_1[0] = this.getOnEventListenerProxy(v3_0);
                        v0_1.invoke(v2_5, v5_1);
                    } catch (Exception v0_4) {
                        io.fabric.sdk.android.Fabric.getLogger().w("CrashlyticsCore", "Cannot register AppMeasurement Listener for Crashlytics breadcrumbs: Method registerOnMeasurementEventListener not found.", v0_4);
                        return 0;
                    } catch (Exception v0_3) {
                        io.fabric.sdk.android.Logger v1_0 = io.fabric.sdk.android.Fabric.getLogger();
                        String v3_3 = new StringBuilder();
                        v3_3.append("Cannot register AppMeasurement Listener for Crashlytics breadcrumbs: ");
                        v3_3.append(v0_3.getMessage());
                        v1_0.w("CrashlyticsCore", v3_3.toString(), v0_3);
                    }
                    return 1;
                } else {
                    io.fabric.sdk.android.Fabric.getLogger().w("CrashlyticsCore", "Cannot register AppMeasurement Listener for Crashlytics breadcrumbs: Could not get class com.google.android.gms.measurement.AppMeasurement$OnEventListener");
                    return 0;
                }
            } else {
                io.fabric.sdk.android.Fabric.getLogger().w("CrashlyticsCore", "Cannot register AppMeasurement Listener for Crashlytics breadcrumbs: Could not create an instance of Firebase Analytics.");
                return 0;
            }
        } else {
            io.fabric.sdk.android.Fabric.getLogger().d("CrashlyticsCore", "Firebase Analytics is not present; you will not see automatic logging of events before a crash occurs.");
            return 0;
        }
    }

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


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

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


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

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


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

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


    public void show()
    {
        android.os.Handler v0_0 = this.buildDropDown();
        android.support.v7.widget.ListPopupWindow$ListSelectorHider v1_7 = this.isInputMethodNotNeeded();
        android.support.v4.widget.PopupWindowCompat.setWindowLayoutType(this.mPopup, this.mDropDownWindowLayoutType);
        int v3_0 = 1;
        if (!this.mPopup.isShowing()) {
            android.support.v7.widget.ListPopupWindow$ListSelectorHider v1_5 = this.mDropDownWidth;
            if (v1_5 != -1) {
                if (v1_5 == -2) {
                    v1_5 = this.getAnchorView().getWidth();
                }
            } else {
                v1_5 = -1;
            }
            String v2_0 = this.mDropDownHeight;
            if (v2_0 != -1) {
                if (v2_0 != -2) {
                    v0_0 = v2_0;
                }
            } else {
                v0_0 = -1;
            }
            android.support.v7.widget.ListPopupWindow$ListSelectorHider v1_11;
            this.mPopup.setWidth(v1_5);
            this.mPopup.setHeight(v0_0);
            this.setPopupClipToScreenEnabled(1);
            if ((this.mForceIgnoreOutsideTouch) || (this.mDropDownAlwaysVisible)) {
                v1_11 = 0;
            } else {
                v1_11 = 1;
            }
            this.mPopup.setOutsideTouchable(v1_11);
            this.mPopup.setTouchInterceptor(this.mTouchInterceptor);
            if (this.mOverlapAnchorSet) {
                android.support.v4.widget.PopupWindowCompat.setOverlapAnchor(this.mPopup, this.mOverlapAnchor);
            }
            android.os.Handler v0_5 = android.support.v7.widget.ListPopupWindow.sSetEpicenterBoundsMethod;
            if (v0_5 != null) {
                try {
                    android.support.v7.widget.ListPopupWindow$ListSelectorHider v1_14 = this.mPopup;
                    String v2_3 = new Object[1];
                    v2_3[0] = this.mEpicenterBounds;
                    v0_5.invoke(v1_14, v2_3);
                } catch (android.os.Handler v0_6) {
                    android.util.Log.e("ListPopupWindow", "Could not invoke setEpicenterBounds on PopupWindow", v0_6);
                }
            }
            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())) {
                String v2_9 = this.mDropDownWidth;
                if (v2_9 != -1) {
                    if (v2_9 == -2) {
                        v2_9 = this.getAnchorView().getWidth();
                    }
                } else {
                    v2_9 = -1;
                }
                android.widget.PopupWindow v7_1 = this.mDropDownHeight;
                if (v7_1 != -1) {
                    if (v7_1 != -2) {
                        v0_0 = v7_1;
                    }
                } else {
                    if (v1_7 == null) {
                        v0_0 = -1;
                    }
                    if (v1_7 == null) {
                        int v4_1;
                        if (this.mDropDownWidth != -1) {
                            v4_1 = 0;
                        } else {
                            v4_1 = -1;
                        }
                        this.mPopup.setWidth(v4_1);
                        this.mPopup.setHeight(-1);
                    } else {
                        int v4_4;
                        if (this.mDropDownWidth != -1) {
                            v4_4 = 0;
                        } else {
                            v4_4 = -1;
                        }
                        this.mPopup.setWidth(v4_4);
                        this.mPopup.setHeight(0);
                    }
                }
                if ((this.mForceIgnoreOutsideTouch) || (this.mDropDownAlwaysVisible)) {
                    v3_0 = 0;
                }
                int v11;
                this.mPopup.setOutsideTouchable(v3_0);
                android.widget.PopupWindow v7_0 = this.mPopup;
                android.view.View v8 = this.getAnchorView();
                if (v2_9 >= null) {
                    v11 = v2_9;
                } else {
                    v11 = -1;
                }
                boolean v12;
                if (v0_0 >= null) {
                    v12 = v0_0;
                } else {
                    v12 = -1;
                }
                v7_0.update(v8, this.mDropDownHorizontalOffset, this.mDropDownVerticalOffset, v11, v12);
            } else {
                return;
            }
        }
        return;
    }

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


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

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


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

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


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

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


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

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


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

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


    private void setActionBarDescription(int p5)
    {
        String v0_0 = this.mActivityImpl;
        if (v0_0 == 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 {
                        String v0_4 = this.mActivity.getActionBar();
                        String v1_1 = this.mSetIndicatorInfo.mSetHomeActionContentDescription;
                        Object[] v2_1 = new Object[1];
                        v2_1[0] = Integer.valueOf(p5);
                        v1_1.invoke(v0_4, v2_1);
                        v0_4.setSubtitle(v0_4.getSubtitle());
                    } catch (Exception v5_3) {
                        android.util.Log.w("ActionBarDrawerToggle", "Couldn\'t set content description via JB-MR2 API", v5_3);
                    }
                }
            } else {
                String v0_8 = this.mActivity.getActionBar();
                if (v0_8 != null) {
                    v0_8.setHomeActionContentDescription(p5);
                }
            }
            return;
        } else {
            v0_0.setActionBarDescription(p5);
            return;
        }
    }

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

Couldn't retrieve source code

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

Couldn't retrieve source code

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

Couldn't retrieve source code

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

Couldn't retrieve source code

Method com.google.android.gms.internal.measurement.zzyj.zza() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method com.google.android.gms.internal.measurement.zzum.zzd() calling method java.lang.reflect.Method.invoke()


    static com.google.android.gms.internal.measurement.zzub zzd(Class p12)
    {
        com.google.android.gms.internal.measurement.zzub v1_4;
        IllegalStateException v0_6 = com.google.android.gms.internal.measurement.zzum.getClassLoader();
        if (!p12.equals(com.google.android.gms.internal.measurement.zzub)) {
            if (!p12.getPackage().equals(com.google.android.gms.internal.measurement.zzum.getPackage())) {
                throw new IllegalArgumentException(p12.getName());
            } else {
                String v4_11 = new Object[2];
                v4_11[0] = p12.getPackage().getName();
                v4_11[1] = p12.getSimpleName();
                v1_4 = String.format("%s.BlazeGenerated%sLoader", v4_11);
            }
        } else {
            v1_4 = com.google.android.gms.internal.measurement.zzum.zzbyd;
        }
        try {
        } catch (ClassNotFoundException) {
            IllegalStateException v0_9 = java.util.ServiceLoader.load(com.google.android.gms.internal.measurement.zzum, v0_6).iterator();
            com.google.android.gms.internal.measurement.zzub v1_19 = new java.util.ArrayList();
        }
        String v4_12 = new Class[0];
        String v4_13 = new Object[0];
        return ((com.google.android.gms.internal.measurement.zzub) p12.cast(((com.google.android.gms.internal.measurement.zzum) Class.forName(v1_4, 1, v0_6).getConstructor(v4_12).newInstance(v4_13)).zzwd()));
    }

Method com.google.android.gms.internal.measurement.zzua.zzge() calling method java.lang.reflect.Method.invoke()


    private static final com.google.android.gms.internal.measurement.zzub zzge(String p3)
    {
        Class[] v2 = new Class[0];
        Object[] v0_1 = new Object[0];
        return ((com.google.android.gms.internal.measurement.zzub) com.google.android.gms.internal.measurement.zzua.zzbvb.getDeclaredMethod(p3, v2).invoke(0, v0_1));
    }

Method com.google.android.gms.internal.measurement.zzdi.zzfw() calling method java.lang.reflect.Method.invoke()


    private static int zzfw()
    {
        reflect.InvocationTargetException v0_0 = com.google.android.gms.internal.measurement.zzdi.zzacw;
        if (v0_0 != null) {
            try {
                String v3_2 = new Object[0];
                return ((Integer) v0_0.invoke(0, v3_2)).intValue();
            } catch (reflect.InvocationTargetException v0_1) {
                if (android.util.Log.isLoggable("JobSchedulerCompat", 6)) {
                    android.util.Log.e("JobSchedulerCompat", "myUserId invocation illegal", v0_1);
                }
            } catch (reflect.InvocationTargetException v0_1) {
            }
        }
        return 0;
    }

Method com.google.android.gms.internal.measurement.zzdi.zza() calling method java.lang.reflect.Method.invoke()


    private final int zza(android.app.job.JobInfo p5, String p6, int p7, String p8)
    {
        reflect.Method v0 = com.google.android.gms.internal.measurement.zzdi.zzacv;
        if (v0 != null) {
            try {
                android.app.job.JobScheduler v1 = this.zzacu;
                Object[] v2_1 = new Object[4];
                v2_1[0] = p5;
                v2_1[1] = p6;
                v2_1[2] = Integer.valueOf(p7);
                v2_1[3] = p8;
                p5 = ((Integer) v0.invoke(v1, v2_1)).intValue();
                return p5;
            } catch (reflect.InvocationTargetException v6_4) {
                android.util.Log.e(p8, "error calling scheduleAsPackage", v6_4);
            } catch (reflect.InvocationTargetException v6_4) {
            }
        }
        return this.zzacu.schedule(p5);
    }

Method com.google.android.gms.internal.icing.zzcx.zzbb() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method com.google.android.gms.internal.firebase_abt.zzk.zza() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method com.google.android.gms.internal.firebase-perf.zzed.zzhb() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method com.google.android.gms.internal.config.zzbi.zza() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method com.google.android.gms.internal.clearcut.zzga.zza() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

Method com.google.android.gms.internal.clearcut.zzbs.zzal() calling method java.lang.reflect.Method.invoke()

Couldn't retrieve source code

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


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

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


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

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


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

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


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

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


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

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


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

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


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

Method com.facebook.internal.Utility.invokeMethodQuietly() calling method java.lang.reflect.Method.invoke()


    public static varargs Object invokeMethodQuietly(Object p1, reflect.Method p2, Object[] p3)
    {
        try {
            return p2.invoke(p1, p3);
        } catch (IllegalAccessException) {
            return 0;
        } catch (reflect.InvocationTargetException) {
            return 0;
        }
    }

Method com.facebook.appevents.internal.InAppPurchaseEventManager.getServiceInterface() calling method java.lang.reflect.Method.invoke()


    public static Object getServiceInterface(android.content.Context p5, android.os.IBinder p6)
    {
        try {
            reflect.Method v1_3 = ((reflect.Method) com.facebook.appevents.internal.InAppPurchaseEventManager.methodMap.get("iap_get_interface"));
        } catch (Object v5_7) {
            android.util.Log.e(com.facebook.appevents.internal.InAppPurchaseEventManager.TAG, "com.android.vending.billing.IInAppBillingService$Stub is not available, please add com.android.vending.billing.IInAppBillingService to the project.", v5_7);
            return 0;
        } catch (Object v5_6) {
            android.util.Log.e(com.facebook.appevents.internal.InAppPurchaseEventManager.TAG, "com.android.vending.billing.IInAppBillingService$Stub.asInterface method not found", v5_6);
            return 0;
        } catch (Object v5_5) {
            android.util.Log.e(com.facebook.appevents.internal.InAppPurchaseEventManager.TAG, "Illegal access to method com.android.vending.billing.IInAppBillingService$Stub.asInterface", v5_5);
            return 0;
        } catch (Object v5_4) {
            android.util.Log.e(com.facebook.appevents.internal.InAppPurchaseEventManager.TAG, "Invocation target exception in com.android.vending.billing.IInAppBillingService$Stub.asInterface", v5_4);
            return 0;
        }
        if (v1_3 == null) {
            Object v5_2 = p5.getClassLoader().loadClass("com.android.vending.billing.IInAppBillingService$Stub");
            reflect.Method v1_2 = new Class[1];
            v1_2[0] = android.os.IBinder;
            v1_3 = v5_2.getDeclaredMethod("asInterface", v1_2);
            com.facebook.appevents.internal.InAppPurchaseEventManager.methodMap.put("iap_get_interface", v1_3);
        }
        Object v5_8 = new Object[1];
        v5_8[0] = p6;
        com.facebook.internal.Utility.logd(com.facebook.appevents.internal.InAppPurchaseEventManager.TAG, "In-app billing service connected");
        return v1_3.invoke(0, v5_8);
    }

Method com.facebook.appevents.internal.InAppPurchaseEventManager.getPurchaseDetails() calling method java.lang.reflect.Method.invoke()


    public static String getPurchaseDetails(android.content.Context p9, String p10, Object p11, boolean p12)
    {
        if ((p11 != null) && (p10 != "")) {
            try {
                reflect.Method v0_4 = ((reflect.Method) com.facebook.appevents.internal.InAppPurchaseEventManager.methodMap.get("iap_get_sku_details"));
                Object[] v1_1 = ((Class) com.facebook.appevents.internal.InAppPurchaseEventManager.classMap.get("com.android.vending.billing.IInAppBillingService"));
            } catch (String v9_12) {
                android.util.Log.e(com.facebook.appevents.internal.InAppPurchaseEventManager.TAG, "com.android.vending.billing.IInAppBillingService is not available, please add com.android.vending.billing.IInAppBillingService to the project, and import the IInAppBillingService.aidl file into this package", v9_12);
                return "";
            } catch (String v9_11) {
                android.util.Log.e(com.facebook.appevents.internal.InAppPurchaseEventManager.TAG, "com.android.vending.billing.IInAppBillingService.getSkuDetails method is not available", v9_11);
                return "";
            } catch (String v9_10) {
                android.util.Log.e(com.facebook.appevents.internal.InAppPurchaseEventManager.TAG, "Invocation target exception in com.android.vending.billing.IInAppBillingService.getSkuDetails", v9_10);
                return "";
            } catch (String v9_9) {
                android.util.Log.e(com.facebook.appevents.internal.InAppPurchaseEventManager.TAG, "Illegal access to method com.android.vending.billing.IInAppBillingService.getSkuDetails", v9_9);
                return "";
            }
            if ((v0_4 == null) || (v1_1 == null)) {
                v1_1 = p9.getClassLoader().loadClass("com.android.vending.billing.IInAppBillingService");
                reflect.Method v0_2 = new Class[4];
                v0_2[0] = Integer.TYPE;
                v0_2[1] = String;
                v0_2[2] = String;
                v0_2[3] = android.os.Bundle;
                v0_4 = v1_1.getDeclaredMethod("getSkuDetails", v0_2);
                com.facebook.appevents.internal.InAppPurchaseEventManager.methodMap.put("iap_get_sku_details", v0_4);
                com.facebook.appevents.internal.InAppPurchaseEventManager.classMap.put("com.android.vending.billing.IInAppBillingService", v1_1);
            }
            String v9_3;
            java.util.ArrayList v7_8 = new java.util.ArrayList();
            v7_8.add(p10);
            int v10_2 = new android.os.Bundle();
            v10_2.putStringArrayList("ITEM_ID_LIST", v7_8);
            Object v11_1 = v1_1.cast(p11);
            Object[] v1_4 = new Object[4];
            v1_4[0] = Integer.valueOf(3);
            v1_4[1] = p9.getPackageName();
            if (!p12) {
                v9_3 = "inapp";
            } else {
                v9_3 = "subs";
            }
            v1_4[2] = v9_3;
            v1_4[3] = v10_2;
            String v9_5 = ((android.os.Bundle) v0_4.invoke(v11_1, v1_4));
            if (v9_5.getInt("RESPONSE_CODE") != 0) {
                return "";
            } else {
                String v9_8;
                String v9_6 = v9_5.getStringArrayList("DETAILS_LIST");
                if (v9_6.size() >= 1) {
                    v9_8 = ((String) v9_6.get(0));
                } else {
                    v9_8 = "";
                }
                return v9_8;
            }
        } else {
            return "";
        }
    }

Method com.caverock.androidsvg.SVGImageView.setSoftwareLayerType() calling method java.lang.reflect.Method.invoke()


    private void setSoftwareLayerType()
    {
        if (com.caverock.androidsvg.SVGImageView.setLayerTypeMethod != null) {
            try {
                String v2_1 = new Object[2];
                v2_1[0] = Integer.valueOf(android.view.View.getField("LAYER_TYPE_SOFTWARE").getInt(new android.view.View(this.getContext())));
                v2_1[1] = 0;
                com.caverock.androidsvg.SVGImageView.setLayerTypeMethod.invoke(this, v2_1);
            } catch (Exception v0_5) {
                android.util.Log.w("SVGImageView", "Unexpected failure calling setLayerType", v0_5);
            }
            return;
        } else {
            return;
        }
    }

Method bolts.MeasurementEvent.sendBroadcast() calling method java.lang.reflect.Method.invoke()


    private void sendBroadcast()
    {
        if (this.name == null) {
            android.util.Log.d(this.getClass().getName(), "Event name is required");
        }
        try {
            String v0_1 = Class.forName("android.support.v4.content.LocalBroadcastManager");
            android.content.Intent v3_0 = new Class[1];
            v3_0[0] = android.content.Context;
            String v1_1 = v0_1.getMethod("getInstance", v3_0);
            String v4_1 = new Class[1];
            v4_1[0] = android.content.Intent;
            String v0_2 = v0_1.getMethod("sendBroadcast", v4_1);
            String v4_2 = new Object[1];
            v4_2[0] = this.appContext;
            String v1_2 = v1_1.invoke(0, v4_2);
            android.content.Intent v3_4 = new android.content.Intent("com.parse.bolts.measurement_event");
            v3_4.putExtra("event_name", this.name);
            v3_4.putExtra("event_args", this.args);
            Object[] v2_1 = new Object[1];
            v2_1[0] = v3_4;
            v0_2.invoke(v1_2, v2_1);
        } catch (Exception) {
            android.util.Log.d(this.getClass().getName(), "LocalBroadcastManager in android support library is required to raise bolts event.");
        }
        return;
    }

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


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

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


    protected static androidx.versionedparcelable.VersionedParcelable readFromParcel(String p5, androidx.versionedparcelable.VersionedParcel p6)
    {
        try {
            RuntimeException v5_10 = Class.forName(p5, 1, androidx.versionedparcelable.VersionedParcel.getClassLoader());
            Class[] v2 = new Class[1];
            v2[0] = androidx.versionedparcelable.VersionedParcel;
            RuntimeException v5_1 = v5_10.getDeclaredMethod("read", v2);
            Object[] v1_0 = new Object[1];
            v1_0[0] = p6;
            return ((androidx.versionedparcelable.VersionedParcelable) v5_1.invoke(0, v1_0));
        } catch (RuntimeException v5_9) {
            throw new RuntimeException("VersionedParcel encountered IllegalAccessException", v5_9);
        } catch (RuntimeException v5_5) {
            throw new RuntimeException("VersionedParcel encountered NoSuchMethodException", v5_5);
        } catch (RuntimeException v5_4) {
            throw new RuntimeException("VersionedParcel encountered ClassNotFoundException", v5_4);
        } catch (RuntimeException v5_6) {
            if (!(v5_6.getCause() instanceof RuntimeException)) {
                throw new RuntimeException("VersionedParcel encountered InvocationTargetException", v5_6);
            } else {
                throw ((RuntimeException) v5_6.getCause());
            }
        }
    }

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


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

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


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

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

Couldn't retrieve source code

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

Couldn't retrieve source code

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

Couldn't retrieve source code

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


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

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


    private void setRawTextSize(float p4)
    {
        if (p4 != this.mTextView.getPaint().getTextSize()) {
            android.widget.TextView v4_2;
            this.mTextView.getPaint().setTextSize(p4);
            if (android.os.Build$VERSION.SDK_INT < 18) {
                v4_2 = 0;
            } else {
                v4_2 = this.mTextView.isInLayout();
            }
            if (this.mTextView.getLayout() != null) {
                this.mNeedsAutoSizeText = 0;
                try {
                    Exception v0_6 = this.getTextViewMethod("nullLayouts");
                } catch (Exception v0_7) {
                    android.util.Log.w("ACTVAutoSizeHelper", "Failed to invoke TextView#nullLayouts() method", v0_7);
                    if (v4_2 != null) {
                        this.mTextView.forceLayout();
                    } else {
                        this.mTextView.requestLayout();
                    }
                    this.mTextView.invalidate();
                }
                if (v0_6 == null) {
                } else {
                    Object[] v1_2 = new Object[0];
                    v0_6.invoke(this.mTextView, v1_2);
                }
            }
        }
        return;
    }

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


    private Object invokeAndReturnWithDefault(Object p5, String p6, Object p7)
    {
        try {
            StringBuilder v2_1 = new Object[0];
            p7 = this.getTextViewMethod(p6).invoke(p5, v2_1);
        } catch (Exception v5_1) {
            throw v5_1;
        } catch (Exception v5_2) {
            StringBuilder v2_0 = new StringBuilder();
            v2_0.append("Failed to invoke TextView#");
            v2_0.append(p6);
            v2_0.append("() method");
            android.util.Log.w("ACTVAutoSizeHelper", v2_0.toString(), v5_2);
        }
        return p7;
    }

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


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

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


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

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


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

Method net.bytebuddy.utility.JavaModule$Dispatcher$Enabled.getResourceAsStream() calling method java.lang.reflect.Method.invoke()


    public java.io.InputStream getResourceAsStream(Object p4, String p5)
    {
        try {
            String v0_0 = this.getResourceAsStream;
            reflect.Method v1_3 = new Object[1];
            v1_3[0] = p5;
            return ((java.io.InputStream) v0_0.invoke(p4, v1_3));
        } catch (Throwable v4_2) {
            String v0_5 = new StringBuilder();
            v0_5.append("Cannot access ");
            v0_5.append(this.getResourceAsStream);
            throw new IllegalStateException(v0_5.toString(), v4_2);
        } catch (Throwable v4_5) {
            String v0_2 = new StringBuilder();
            v0_2.append("Cannot invoke ");
            v0_2.append(this.getResourceAsStream);
            throw new IllegalStateException(v0_2.toString(), v4_5.getCause());
        }
    }

Method net.bytebuddy.utility.JavaModule$Dispatcher$Enabled.getName() calling method java.lang.reflect.Method.invoke()


    public String getName(Object p4)
    {
        try {
            String v1_3 = new Object[0];
            return ((String) this.getName.invoke(p4, v1_3));
        } catch (Throwable v4_2) {
            String v1_5 = new StringBuilder();
            v1_5.append("Cannot access ");
            v1_5.append(this.getName);
            throw new IllegalStateException(v1_5.toString(), v4_2);
        } catch (Throwable v4_5) {
            String v1_1 = new StringBuilder();
            v1_1.append("Cannot invoke ");
            v1_1.append(this.getName);
            throw new IllegalStateException(v1_1.toString(), v4_5.getCause());
        }
    }

Method net.bytebuddy.utility.JavaModule$Dispatcher$Enabled.getClassLoader() calling method java.lang.reflect.Method.invoke()


    public ClassLoader getClassLoader(Object p4)
    {
        try {
            String v1_3 = new Object[0];
            return ((ClassLoader) this.getClassLoader.invoke(p4, v1_3));
        } catch (Throwable v4_2) {
            String v1_5 = new StringBuilder();
            v1_5.append("Cannot access ");
            v1_5.append(this.getClassLoader);
            throw new IllegalStateException(v1_5.toString(), v4_2);
        } catch (Throwable v4_5) {
            String v1_1 = new StringBuilder();
            v1_1.append("Cannot invoke ");
            v1_1.append(this.getClassLoader);
            throw new IllegalStateException(v1_1.toString(), v4_5.getCause());
        }
    }

Method net.bytebuddy.utility.JavaModule$Dispatcher$Enabled.canRead() calling method java.lang.reflect.Method.invoke()


    public boolean canRead(Object p4, Object p5)
    {
        try {
            String v0_0 = this.canRead;
            reflect.Method v1_3 = new Object[1];
            v1_3[0] = p5;
            return ((Boolean) v0_0.invoke(p4, v1_3)).booleanValue();
        } catch (Throwable v4_3) {
            String v0_5 = new StringBuilder();
            v0_5.append("Cannot access ");
            v0_5.append(this.canRead);
            throw new IllegalStateException(v0_5.toString(), v4_3);
        } catch (Throwable v4_1) {
            String v0_2 = new StringBuilder();
            v0_2.append("Cannot invoke ");
            v0_2.append(this.canRead);
            throw new IllegalStateException(v0_2.toString(), v4_1.getCause());
        }
    }

Method net.bytebuddy.utility.JavaModule$Dispatcher$Enabled.addReads() calling method java.lang.reflect.Method.invoke()


    public void addReads(instrument.Instrumentation p5, Object p6, Object p7)
    {
        try {
            reflect.Method v0_0 = this.isModifiableModule;
            Object[] v2_0 = new Object[1];
            v2_0[0] = p6;
        } catch (Throwable v5_5) {
            String v7_7 = new StringBuilder();
            v7_7.append("Cannot access ");
            v7_7.append(this.redefineModule);
            throw new IllegalStateException(v7_7.toString(), v5_5);
        } catch (Throwable v5_3) {
            String v7_4 = new StringBuilder();
            v7_4.append("Cannot invoke ");
            v7_4.append(this.redefineModule);
            throw new IllegalStateException(v7_4.toString(), v5_3.getCause());
        }
        if (!((Boolean) v0_0.invoke(p5, v2_0)).booleanValue()) {
            String v7_2 = new StringBuilder();
            v7_2.append(p6);
            v7_2.append(" is not modifable");
            throw new IllegalStateException(v7_2.toString());
        } else {
            try {
                reflect.Method v0_5 = this.redefineModule;
                Object[] v2_2 = new Object[6];
                v2_2[0] = p6;
                v2_2[1] = java.util.Collections.singleton(p7);
                v2_2[2] = java.util.Collections.emptyMap();
                v2_2[3] = java.util.Collections.emptyMap();
                v2_2[4] = java.util.Collections.emptySet();
                v2_2[5] = java.util.Collections.emptyMap();
                v0_5.invoke(p5, v2_2);
                return;
            } catch (Throwable v5_8) {
                String v7_17 = new StringBuilder();
                v7_17.append("Cannot access ");
                v7_17.append(this.redefineModule);
                throw new IllegalStateException(v7_17.toString(), v5_8);
            } catch (Throwable v5_6) {
                String v7_14 = new StringBuilder();
                v7_14.append("Cannot invoke ");
                v7_14.append(this.redefineModule);
                throw new IllegalStateException(v7_14.toString(), v5_6.getCause());
            }
        }
    }

Method net.bytebuddy.utility.JavaConstant$MethodType$Dispatcher$ForJava7CapableVm.returnType() calling method java.lang.reflect.Method.invoke()


    public Class returnType(Object p3)
    {
        try {
            String v1_3 = new Object[0];
            return ((Class) this.returnType.invoke(p3, v1_3));
        } catch (Throwable v3_2) {
            throw new IllegalStateException("Cannot access java.lang.invoke.MethodType#returnType", v3_2);
        } catch (Throwable v3_5) {
            throw new IllegalStateException("Error invoking java.lang.invoke.MethodType#returnType", v3_5.getCause());
        }
    }

Method net.bytebuddy.utility.JavaConstant$MethodType$Dispatcher$ForJava7CapableVm.parameterArray() calling method java.lang.reflect.Method.invoke()


    public Class[] parameterArray(Object p3)
    {
        try {
            String v1_3 = new Object[0];
            return ((Class[]) ((Class[]) this.parameterArray.invoke(p3, v1_3)));
        } catch (Throwable v3_2) {
            throw new IllegalStateException("Cannot access java.lang.invoke.MethodType#parameterArray", v3_2);
        } catch (Throwable v3_6) {
            throw new IllegalStateException("Error invoking java.lang.invoke.MethodType#parameterArray", v3_6.getCause());
        }
    }

Method net.bytebuddy.utility.JavaConstant$MethodHandle$Dispatcher$AbstractBase.returnType() calling method java.lang.reflect.Method.invoke()


    public Class returnType(Object p3)
    {
        try {
            String v1_3 = new Object[0];
            return ((Class) this.returnType.invoke(p3, v1_3));
        } catch (Throwable v3_2) {
            throw new IllegalStateException("Cannot access java.lang.invoke.MethodType#returnType", v3_2);
        } catch (Throwable v3_5) {
            throw new IllegalStateException("Error invoking java.lang.reflect.MethodType#returnType", v3_5.getCause());
        }
    }

Method net.bytebuddy.utility.JavaConstant$MethodHandle$Dispatcher$AbstractBase.publicLookup() calling method java.lang.reflect.Method.invoke()


    public Object publicLookup()
    {
        try {
            String v2_3 = new Object[0];
            return this.publicLookup.invoke(0, v2_3);
        } catch (Throwable v0_2) {
            throw new IllegalStateException("Cannot access java.lang.invoke.MethodHandles#publicLookup", v0_2);
        } catch (Throwable v0_4) {
            throw new IllegalStateException("Error invoking java.lang.invoke.MethodHandles#publicLookup", v0_4.getCause());
        }
    }

Method net.bytebuddy.utility.JavaConstant$MethodHandle$Dispatcher$AbstractBase.parameterArray() calling method java.lang.reflect.Method.invoke()


    public java.util.List parameterArray(Object p3)
    {
        try {
            String v1_3 = new Object[0];
            return java.util.Arrays.asList(((Class[]) ((Class[]) this.parameterArray.invoke(p3, v1_3))));
        } catch (Throwable v3_3) {
            throw new IllegalStateException("Cannot access java.lang.reflect.MethodType#parameterArray", v3_3);
        } catch (Throwable v3_1) {
            throw new IllegalStateException("Error invoking java.lang.reflect.MethodType#parameterArray", v3_1.getCause());
        }
    }

Method net.bytebuddy.utility.JavaConstant$MethodHandle$Dispatcher$AbstractBase.lookupType() calling method java.lang.reflect.Method.invoke()


    public Class lookupType(Object p3)
    {
        try {
            String v1_3 = new Object[0];
            return ((Class) this.lookupClass.invoke(p3, v1_3));
        } catch (Throwable v3_2) {
            throw new IllegalStateException("Cannot access java.lang.reflect.MethodHandles.Lookup#lookupClass", v3_2);
        } catch (Throwable v3_5) {
            throw new IllegalStateException("Error invoking java.lang.reflect.MethodHandles.Lookup#lookupClass", v3_5.getCause());
        }
    }

Method net.bytebuddy.utility.JavaConstant$MethodHandle$Dispatcher$AbstractBase.getReferenceKind() calling method java.lang.reflect.Method.invoke()


    public int getReferenceKind(Object p3)
    {
        try {
            String v1_3 = new Object[0];
            return ((Integer) this.getReferenceKind.invoke(p3, v1_3)).intValue();
        } catch (Throwable v3_2) {
            throw new IllegalStateException("Cannot access java.lang.invoke.MethodHandleInfo#getReferenceKind", v3_2);
        } catch (Throwable v3_6) {
            throw new IllegalStateException("Error invoking java.lang.invoke.MethodHandleInfo#getReferenceKind", v3_6.getCause());
        }
    }

Method net.bytebuddy.utility.JavaConstant$MethodHandle$Dispatcher$AbstractBase.getName() calling method java.lang.reflect.Method.invoke()


    public String getName(Object p3)
    {
        try {
            String v1_3 = new Object[0];
            return ((String) this.getName.invoke(p3, v1_3));
        } catch (Throwable v3_2) {
            throw new IllegalStateException("Cannot access java.lang.invoke.MethodHandleInfo#getName", v3_2);
        } catch (Throwable v3_5) {
            throw new IllegalStateException("Error invoking java.lang.invoke.MethodHandleInfo#getName", v3_5.getCause());
        }
    }

Method net.bytebuddy.utility.JavaConstant$MethodHandle$Dispatcher$AbstractBase.getMethodType() calling method java.lang.reflect.Method.invoke()


    public Object getMethodType(Object p3)
    {
        try {
            String v1_3 = new Object[0];
            return this.getMethodType.invoke(p3, v1_3);
        } catch (Throwable v3_1) {
            throw new IllegalStateException("Cannot access java.lang.invoke.MethodHandleInfo#getMethodType", v3_1);
        } catch (Throwable v3_3) {
            throw new IllegalStateException("Error invoking java.lang.invoke.MethodHandleInfo#getMethodType", v3_3.getCause());
        }
    }

Method net.bytebuddy.utility.JavaConstant$MethodHandle$Dispatcher$AbstractBase.getDeclaringClass() calling method java.lang.reflect.Method.invoke()


    public Class getDeclaringClass(Object p3)
    {
        try {
            String v1_3 = new Object[0];
            return ((Class) this.getDeclaringClass.invoke(p3, v1_3));
        } catch (Throwable v3_2) {
            throw new IllegalStateException("Cannot access java.lang.invoke.MethodHandleInfo#getDeclaringClass", v3_2);
        } catch (Throwable v3_5) {
            throw new IllegalStateException("Error invoking java.lang.invoke.MethodHandleInfo#getDeclaringClass", v3_5.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassReloadingStrategy.fromInstalledAgent() calling method java.lang.reflect.Method.invoke()


    public static net.bytebuddy.dynamic.loading.ClassReloadingStrategy fromInstalledAgent()
    {
        try {
            Class[] v3 = new Class[0];
            String v2_0 = new Object[0];
            return net.bytebuddy.dynamic.loading.ClassReloadingStrategy.of(((instrument.Instrumentation) ClassLoader.getSystemClassLoader().loadClass("net.bytebuddy.agent.Installer").getMethod("getInstrumentation", v3).invoke(net.bytebuddy.dynamic.loading.ClassReloadingStrategy.STATIC_MEMBER, v2_0)));
        } catch (Exception v0_5) {
            throw v0_5;
        } catch (Exception v0_4) {
            throw new IllegalStateException("The Byte Buddy agent is not installed or not accessible", v0_4);
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingUnsafe$Dispatcher$Enabled.defineClass() calling method java.lang.reflect.Method.invoke()


    public Class defineClass(ClassLoader p5, String p6, byte[] p7, java.security.ProtectionDomain p8)
    {
        try {
            reflect.Method v0 = this.defineClass;
            Object v1_1 = this.theUnsafe.get(0);
            Object[] v2_2 = new Object[6];
            v2_2[0] = p6;
            v2_2[1] = p7;
            v2_2[2] = Integer.valueOf(0);
            v2_2[3] = Integer.valueOf(p7.length);
            v2_2[4] = p5;
            v2_2[5] = p8;
            return ((Class) v0.invoke(v1_1, v2_2));
        } catch (Throwable v5_6) {
            throw new IllegalStateException("Could not access Unsafe::defineClass", v5_6);
        } catch (Throwable v5_4) {
            throw new IllegalStateException("Error invoking Unsafe::defineClass", v5_4.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect.getPackage() calling method java.lang.reflect.Method.invoke()


    public Package getPackage(ClassLoader p5, String p6)
    {
        try {
            String v0_0 = this.getPackage;
            Object v1 = this.accessor;
            Object[] v2_1 = new Object[2];
            v2_1[0] = p5;
            v2_1[1] = p6;
            return ((Package) v0_0.invoke(v1, v2_1));
        } catch (Throwable v5_4) {
            throw new IllegalStateException("Could not access (accessor)::getPackage", v5_4);
        } catch (Throwable v5_2) {
            throw new IllegalStateException("Error invoking (accessor)::getPackage", v5_2.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect.getClassLoadingLock() calling method java.lang.reflect.Method.invoke()


    public Object getClassLoadingLock(ClassLoader p5, String p6)
    {
        try {
            String v0_0 = this.getClassLoadingLock;
            Object v1 = this.accessor;
            Object[] v2_1 = new Object[2];
            v2_1[0] = p5;
            v2_1[1] = p6;
            return v0_0.invoke(v1, v2_1);
        } catch (Throwable v5_3) {
            throw new IllegalStateException("Could not access (accessor)::getClassLoadingLock", v5_3);
        } catch (Throwable v5_1) {
            throw new IllegalStateException("Error invoking (accessor)::getClassLoadingLock", v5_1.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect.findClass() calling method java.lang.reflect.Method.invoke()


    public Class findClass(ClassLoader p5, String p6)
    {
        try {
            String v0_0 = this.findLoadedClass;
            Object v1 = this.accessor;
            Object[] v2_1 = new Object[2];
            v2_1[0] = p5;
            v2_1[1] = p6;
            return ((Class) v0_0.invoke(v1, v2_1));
        } catch (Throwable v5_4) {
            throw new IllegalStateException("Could not access (accessor)::findLoadedClass", v5_4);
        } catch (Throwable v5_2) {
            throw new IllegalStateException("Error invoking (accessor)::findLoadedClass", v5_2.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect.definePackage() calling method java.lang.reflect.Method.invoke()


    public Package definePackage(ClassLoader p5, String p6, String p7, String p8, String p9, String p10, String p11, String p12, java.net.URL p13)
    {
        try {
            reflect.Method v0 = this.definePackage;
            Object v1 = this.accessor;
            Object[] v2_1 = new Object[9];
            v2_1[0] = p5;
            v2_1[1] = p6;
            v2_1[2] = p7;
            v2_1[3] = p8;
            v2_1[4] = p9;
            v2_1[5] = p10;
            v2_1[6] = p11;
            v2_1[7] = p12;
            v2_1[8] = p13;
            return ((Package) v0.invoke(v1, v2_1));
        } catch (Throwable v5_11) {
            throw new IllegalStateException("Could not access (accessor)::definePackage", v5_11);
        } catch (Throwable v5_9) {
            throw new IllegalStateException("Error invoking (accessor)::definePackage", v5_9.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect.defineClass() calling method java.lang.reflect.Method.invoke()


    public Class defineClass(ClassLoader p5, String p6, byte[] p7, java.security.ProtectionDomain p8)
    {
        try {
            reflect.Method v0 = this.defineClass;
            Object v1 = this.accessor;
            Object[] v2_1 = new Object[6];
            v2_1[0] = p5;
            v2_1[1] = p6;
            v2_1[2] = p7;
            v2_1[3] = Integer.valueOf(0);
            v2_1[4] = Integer.valueOf(p7.length);
            v2_1[5] = p8;
            return ((Class) v0.invoke(v1, v2_1));
        } catch (Throwable v5_8) {
            throw new IllegalStateException("Could not access (accessor)::defineClass", v5_8);
        } catch (Throwable v5_6) {
            throw new IllegalStateException("Error invoking (accessor)::defineClass", v5_6.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect.make() calling method java.lang.reflect.Method.invoke()


    public static net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Initializable make()
    {
        String v0_1 = Class.forName("sun.misc.Unsafe");
        Class[] v1_7 = v0_1.getDeclaredField("theUnsafe");
        v1_7.setAccessible(1);
        Class[] v1_0 = v1_7.get(0);
        try {
            int v6_0 = new Class[1];
            v6_0[0] = String;
            Class v4_6 = ClassLoader.getDeclaredMethod("getDeclaredPackage", v6_0);
        } catch (NoSuchMethodException) {
            int v6_1 = new Class[1];
            v6_1[0] = String;
            v4_6 = ClassLoader.getDeclaredMethod("getPackage", v6_1);
        }
        Class v5_10 = new net.bytebuddy.ByteBuddy().subclass(Object, net.bytebuddy.dynamic.scaffold.subclass.ConstructorStrategy$Default.NO_CONSTRUCTORS);
        int v6_4 = new StringBuilder();
        v6_4.append(ClassLoader.getName());
        v6_4.append("$ByteBuddyAccessor$");
        v6_4.append(net.bytebuddy.utility.RandomString.make());
        Class v5_21 = v5_10.name(v6_4.toString());
        net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect v8_23 = new net.bytebuddy.description.modifier.ModifierContributor$ForMethod[1];
        v8_23[0] = net.bytebuddy.description.modifier.Visibility.PUBLIC;
        Class v5_22 = v5_21.defineMethod("findLoadedClass", Class, v8_23);
        int v7_9 = new reflect.Type[2];
        v7_9[0] = ClassLoader;
        v7_9[1] = String;
        Class v5_23 = v5_22.withParameters(v7_9);
        Class v9_43 = new Class[1];
        v9_43[0] = String;
        int v7_13 = net.bytebuddy.implementation.MethodCall.invoke(ClassLoader.getDeclaredMethod("findLoadedClass", v9_43)).onArgument(0);
        net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect v8_27 = new int[1];
        v8_27[0] = 1;
        Class v5_24 = v5_23.intercept(v7_13.withArgument(v8_27));
        Class v9_44 = new net.bytebuddy.description.modifier.ModifierContributor$ForMethod[1];
        v9_44[0] = net.bytebuddy.description.modifier.Visibility.PUBLIC;
        Class v5_25 = v5_24.defineMethod("defineClass", Class, v9_44);
        net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect v8_29 = new reflect.Type[6];
        v8_29[0] = ClassLoader;
        v8_29[1] = String;
        v8_29[2] = byte[];
        v8_29[3] = Integer.TYPE;
        v8_29[4] = Integer.TYPE;
        v8_29[5] = java.security.ProtectionDomain;
        Class v5_0 = v5_25.withParameters(v8_29);
        int v13_0 = new Class[5];
        v13_0[0] = String;
        v13_0[1] = byte[];
        v13_0[2] = Integer.TYPE;
        v13_0[3] = Integer.TYPE;
        v13_0[4] = java.security.ProtectionDomain;
        net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect v8_3 = net.bytebuddy.implementation.MethodCall.invoke(ClassLoader.getDeclaredMethod("defineClass", v13_0)).onArgument(0);
        Class v9_2 = new int[5];
        v9_2 = {1, 2, 3, 4, 5};
        Class v5_1 = v5_0.intercept(v8_3.withArgument(v9_2));
        int v13_1 = new net.bytebuddy.description.modifier.ModifierContributor$ForMethod[1];
        v13_1[0] = net.bytebuddy.description.modifier.Visibility.PUBLIC;
        Class v5_3 = v5_1.defineMethod("getPackage", Package, v13_1);
        net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect v8_6 = new reflect.Type[2];
        v8_6[0] = ClassLoader;
        v8_6[1] = String;
        Class v5_4 = v5_3.withParameters(v8_6);
        Class v4_2 = net.bytebuddy.implementation.MethodCall.invoke(v4_6).onArgument(0);
        net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect v8_7 = new int[1];
        v8_7[0] = 1;
        Class v4_4 = v5_4.intercept(v4_2.withArgument(v8_7));
        Class v9_6 = new net.bytebuddy.description.modifier.ModifierContributor$ForMethod[1];
        v9_6[0] = net.bytebuddy.description.modifier.Visibility.PUBLIC;
        Class v4_5 = v4_4.defineMethod("definePackage", Package, v9_6);
        net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect v8_9 = new reflect.Type[9];
        v8_9[0] = ClassLoader;
        v8_9[1] = String;
        v8_9[2] = String;
        v8_9[3] = String;
        v8_9[4] = String;
        v8_9[5] = String;
        v8_9[6] = String;
        v8_9[7] = String;
        v8_9[8] = java.net.URL;
        Class v4_7 = v4_5.withParameters(v8_9);
        Class v15_0 = new Class[8];
        v15_0[0] = String;
        v15_0[1] = String;
        v15_0[2] = String;
        v15_0[3] = String;
        v15_0[4] = String;
        v15_0[5] = String;
        v15_0[6] = String;
        v15_0[7] = java.net.URL;
        net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect v8_13 = net.bytebuddy.implementation.MethodCall.invoke(ClassLoader.getDeclaredMethod("definePackage", v15_0)).onArgument(0);
        Class v9_17 = new int[8];
        v9_17 = {1, 2, 3, 4, 5, 6, 7, 8};
        Class v4_9 = v4_7.intercept(v8_13.withArgument(v9_17));
        try {
            Class v15_1 = new net.bytebuddy.description.modifier.ModifierContributor$ForMethod[1];
            v15_1[0] = net.bytebuddy.description.modifier.Visibility.PUBLIC;
            net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect v8_16 = v4_9.defineMethod("getClassLoadingLock", Object, v15_1);
            Class v9_19 = new reflect.Type[2];
            v9_19[0] = ClassLoader;
            v9_19[1] = String;
            net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect v8_17 = v8_16.withParameters(v9_19);
            Class[] v14_7 = new Class[1];
            v14_7[0] = String;
            Class v9_23 = net.bytebuddy.implementation.MethodCall.invoke(ClassLoader.getDeclaredMethod("getClassLoadingLock", v14_7)).onArgument(0);
            Class[] v14_8 = new int[1];
            v14_8[0] = 1;
            Class v4_10 = v8_17.intercept(v9_23.withArgument(v14_8));
        } catch (NoSuchMethodException) {
            Class[] v14_9 = new net.bytebuddy.description.modifier.ModifierContributor$ForMethod[1];
            v14_9[0] = net.bytebuddy.description.modifier.Visibility.PUBLIC;
            Class v4_11 = v4_10.defineMethod("getClassLoadingLock", Object, v14_9);
            net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect v8_19 = new reflect.Type[2];
            v8_19[0] = ClassLoader;
            v8_19[1] = String;
            v4_10 = v4_11.withParameters(v8_19).intercept(net.bytebuddy.implementation.FixedValue.argument(0));
        }
        Class v4_15 = v4_10.make().load(net.bytebuddy.dynamic.loading.ClassLoadingStrategy.BOOTSTRAP_LOADER, new net.bytebuddy.dynamic.loading.ClassLoadingStrategy$ForUnsafeInjection()).getLoaded();
        net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect v8_22 = new net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect;
        Class[] v14_10 = new Class[1];
        v14_10[0] = Class;
        String v0_2 = v0_1.getDeclaredMethod("allocateInstance", v14_10);
        Class v9_31 = new Object[1];
        v9_31[0] = v4_15;
        Object v18 = v0_2.invoke(v1_0, v9_31);
        Class[] v1_1 = new Class[2];
        v1_1[0] = ClassLoader;
        v1_1[1] = String;
        reflect.Method v19 = v4_15.getMethod("findLoadedClass", v1_1);
        Class[] v1_2 = new Class[6];
        v1_2[0] = ClassLoader;
        v1_2[1] = String;
        v1_2[2] = byte[];
        v1_2[3] = Integer.TYPE;
        v1_2[4] = Integer.TYPE;
        v1_2[5] = java.security.ProtectionDomain;
        reflect.Method v20 = v4_15.getMethod("defineClass", v1_2);
        Class[] v1_4 = new Class[2];
        v1_4[0] = ClassLoader;
        v1_4[1] = String;
        reflect.Method v21 = v4_15.getMethod("getPackage", v1_4);
        Class[] v1_5 = new Class[9];
        v1_5[0] = ClassLoader;
        v1_5[1] = String;
        v1_5[2] = String;
        v1_5[3] = String;
        v1_5[4] = String;
        v1_5[5] = String;
        v1_5[6] = String;
        v1_5[7] = String;
        v1_5[8] = java.net.URL;
        reflect.Method v22 = v4_15.getMethod("definePackage", v1_5);
        Class[] v1_6 = new Class[2];
        v1_6[0] = ClassLoader;
        v1_6[1] = String;
        v8_22(v18, v19, v20, v21, v22, v4_15.getMethod("getClassLoadingLock", v1_6));
        return v8_22;
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Direct.getPackage() calling method java.lang.reflect.Method.invoke()


    public Package getPackage(ClassLoader p4, String p5)
    {
        try {
            String v0_0 = this.getPackage;
            Object[] v1_1 = new Object[1];
            v1_1[0] = p5;
            return ((Package) v0_0.invoke(p4, v1_1));
        } catch (Throwable v4_2) {
            throw new IllegalStateException("Could not access java.lang.ClassLoader#findClass", v4_2);
        } catch (Throwable v4_5) {
            throw new IllegalStateException("Error invoking java.lang.ClassLoader#findClass", v4_5.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Direct.findClass() calling method java.lang.reflect.Method.invoke()


    public Class findClass(ClassLoader p4, String p5)
    {
        try {
            String v0_0 = this.findLoadedClass;
            Object[] v1_1 = new Object[1];
            v1_1[0] = p5;
            return ((Class) v0_0.invoke(p4, v1_1));
        } catch (Throwable v4_2) {
            throw new IllegalStateException("Could not access java.lang.ClassLoader#findClass", v4_2);
        } catch (Throwable v4_5) {
            throw new IllegalStateException("Error invoking java.lang.ClassLoader#findClass", v4_5.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Direct.definePackage() calling method java.lang.reflect.Method.invoke()


    public Package definePackage(ClassLoader p4, String p5, String p6, String p7, String p8, String p9, String p10, String p11, java.net.URL p12)
    {
        try {
            reflect.Method v0 = this.definePackage;
            Object[] v1_1 = new Object[8];
            v1_1[0] = p5;
            v1_1[1] = p6;
            v1_1[2] = p7;
            v1_1[3] = p8;
            v1_1[4] = p9;
            v1_1[5] = p10;
            v1_1[6] = p11;
            v1_1[7] = p12;
            return ((Package) v0.invoke(p4, v1_1));
        } catch (Throwable v4_5) {
            throw new IllegalStateException("Could not access java.lang.ClassLoader#findClass", v4_5);
        } catch (Throwable v4_3) {
            throw new IllegalStateException("Error invoking java.lang.ClassLoader#findClass", v4_3.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Direct.defineClass() calling method java.lang.reflect.Method.invoke()


    public Class defineClass(ClassLoader p4, String p5, byte[] p6, java.security.ProtectionDomain p7)
    {
        try {
            reflect.Method v0 = this.defineClass;
            Object[] v1_1 = new Object[5];
            v1_1[0] = p5;
            v1_1[1] = p6;
            v1_1[2] = Integer.valueOf(0);
            v1_1[3] = Integer.valueOf(p6.length);
            v1_1[4] = p7;
            return ((Class) v0.invoke(p4, v1_1));
        } catch (Throwable v4_5) {
            throw new IllegalStateException("Could not access java.lang.ClassLoader#findClass", v4_5);
        } catch (Throwable v4_3) {
            throw new IllegalStateException("Error invoking java.lang.ClassLoader#findClass", v4_3.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingLookup$Dispatcher$ForJava9CapableVm.lookupType() calling method java.lang.reflect.Method.invoke()


    public Class lookupType(Object p3)
    {
        try {
            String v1_3 = new Object[0];
            return ((Class) this.lookupClass.invoke(p3, v1_3));
        } catch (Throwable v3_2) {
            throw new IllegalStateException("Cannot access java.lang.invoke.MethodHandles$Lookup#lookupClass", v3_2);
        } catch (Throwable v3_5) {
            throw new IllegalStateException("Error invoking java.lang.invoke.MethodHandles$Lookup#lookupClass", v3_5.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingLookup$Dispatcher$ForJava9CapableVm.lookupModes() calling method java.lang.reflect.Method.invoke()


    public int lookupModes(Object p3)
    {
        try {
            String v1_3 = new Object[0];
            return ((Integer) this.lookupModes.invoke(p3, v1_3)).intValue();
        } catch (Throwable v3_2) {
            throw new IllegalStateException("Cannot access java.lang.invoke.MethodHandles$Lookup#lookupModes", v3_2);
        } catch (Throwable v3_6) {
            throw new IllegalStateException("Error invoking java.lang.invoke.MethodHandles$Lookup#lookupModes", v3_6.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingLookup$Dispatcher$ForJava9CapableVm.dropLookupMode() calling method java.lang.reflect.Method.invoke()


    public Object dropLookupMode(Object p4, int p5)
    {
        try {
            String v0_0 = this.dropLookupMode;
            Object[] v1_1 = new Object[1];
            v1_1[0] = Integer.valueOf(p5);
            return v0_0.invoke(p4, v1_1);
        } catch (Throwable v4_3) {
            throw new IllegalStateException("Cannot access java.lang.invoke.MethodHandles$Lookup#lookupModes", v4_3);
        } catch (Throwable v4_1) {
            throw new IllegalStateException("Error invoking java.lang.invoke.MethodHandles$Lookup#lookupModes", v4_1.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ClassInjector$UsingLookup$Dispatcher$ForJava9CapableVm.defineClass() calling method java.lang.reflect.Method.invoke()


    public Class defineClass(Object p4, byte[] p5)
    {
        try {
            String v0_0 = this.defineClass;
            Object[] v1_1 = new Object[1];
            v1_1[0] = p5;
            return ((Class) v0_0.invoke(p4, v1_1));
        } catch (Throwable v4_2) {
            throw new IllegalStateException("Cannot access java.lang.invoke.MethodHandles$Lookup#defineClass", v4_2);
        } catch (Throwable v4_5) {
            throw new IllegalStateException("Error invoking java.lang.invoke.MethodHandles$Lookup#defineClass", v4_5.getCause());
        }
    }

Method net.bytebuddy.dynamic.loading.ByteArrayClassLoader$SynchronizationStrategy$ForJava7CapableVm.getClassLoadingLock() calling method java.lang.reflect.Method.invoke()


    public Object getClassLoadingLock(ClassLoader p5, String p6)
    {
        try {
            reflect.InvocationTargetException v0_0 = this.method;
            IllegalStateException v1_1 = new Object[1];
            v1_1[0] = p6;
            String v5_3 = v0_0.invoke(p5, v1_1);
            return v5_3;
        } catch (reflect.InvocationTargetException v0_1) {
            StringBuilder v2_3 = new StringBuilder();
            v2_3.append("Cannot access class loading lock for ");
            v2_3.append(p6);
            v2_3.append(" on ");
            v2_3.append(v5_3);
            throw new IllegalStateException(v2_3.toString(), v0_1);
        } catch (reflect.InvocationTargetException v0_2) {
            StringBuilder v2_1 = new StringBuilder();
            v2_1.append("Error when getting ");
            v2_1.append(p6);
            v2_1.append(" on ");
            v2_1.append(v5_3);
            throw new IllegalStateException(v2_1.toString(), v0_2);
        }
    }

Method net.bytebuddy.dynamic.loading.ByteArrayClassLoader$PackageLookupStrategy$ForJava9CapableVm.apply() calling method java.lang.reflect.Method.invoke()


    public Package apply(net.bytebuddy.dynamic.loading.ByteArrayClassLoader p4, String p5)
    {
        try {
            String v0_0 = this.getDefinedPackage;
            reflect.Method v1_3 = new Object[1];
            v1_3[0] = p5;
            return ((Package) v0_0.invoke(p4, v1_3));
        } catch (Throwable v4_2) {
            String v0_5 = new StringBuilder();
            v0_5.append("Cannot access ");
            v0_5.append(this.getDefinedPackage);
            throw new IllegalStateException(v0_5.toString(), v4_2);
        } catch (Throwable v4_5) {
            String v0_2 = new StringBuilder();
            v0_2.append("Cannot invoke ");
            v0_2.append(this.getDefinedPackage);
            throw new IllegalStateException(v0_2.toString(), v4_5.getCause());
        }
    }

Method net.bytebuddy.dynamic.NexusAccessor$Dispatcher$Available.register() calling method java.lang.reflect.Method.invoke()


    public void register(String p5, ClassLoader p6, ref.ReferenceQueue p7, int p8, net.bytebuddy.implementation.LoadedTypeInitializer p9)
    {
        try {
            reflect.Method v0 = this.register;
            Object[] v2_1 = new Object[5];
            v2_1[0] = p5;
            v2_1[1] = p6;
            v2_1[2] = p7;
            v2_1[3] = Integer.valueOf(p8);
            v2_1[4] = p9;
            v0.invoke(net.bytebuddy.dynamic.NexusAccessor$Dispatcher$Available.STATIC_METHOD, v2_1);
            return;
        } catch (Throwable v5_5) {
            String v7_5 = new StringBuilder();
            v7_5.append("Cannot access: ");
            v7_5.append(this.register);
            throw new IllegalStateException(v7_5.toString(), v5_5);
        } catch (Throwable v5_3) {
            String v7_2 = new StringBuilder();
            v7_2.append("Cannot invoke: ");
            v7_2.append(this.register);
            throw new IllegalStateException(v7_2.toString(), v5_3.getCause());
        }
    }

Method net.bytebuddy.dynamic.NexusAccessor$Dispatcher$Available.clean() calling method java.lang.reflect.Method.invoke()


    public void clean(ref.Reference p5)
    {
        try {
            IllegalStateException v0_0 = this.clean;
            reflect.Method v2_5 = new Object[1];
            v2_5[0] = p5;
            v0_0.invoke(net.bytebuddy.dynamic.NexusAccessor$Dispatcher$Available.STATIC_METHOD, v2_5);
            return;
        } catch (Throwable v5_2) {
            String v1_5 = new StringBuilder();
            v1_5.append("Cannot access: ");
            v1_5.append(this.clean);
            throw new IllegalStateException(v1_5.toString(), v5_2);
        } catch (Throwable v5_3) {
            String v1_2 = new StringBuilder();
            v1_2.append("Cannot invoke: ");
            v1_2.append(this.clean);
            throw new IllegalStateException(v1_2.toString(), v5_3.getCause());
        }
    }

Method net.bytebuddy.dynamic.ClassFileLocator$ForModule.ofBootLayer() calling method java.lang.reflect.Method.invoke()


    public static net.bytebuddy.dynamic.ClassFileLocator ofBootLayer()
    {
        try {
            Exception v0_1 = new java.util.HashMap();
            net.bytebuddy.dynamic.ClassFileLocator$PackageDiscriminating v1_8 = Class.forName("java.lang.ModuleLayer");
            net.bytebuddy.dynamic.ClassFileLocator v5_0 = new Class[0];
            String v2_0 = net.bytebuddy.utility.JavaType.MODULE.load().getMethod("getPackages", v5_0);
            net.bytebuddy.dynamic.ClassFileLocator v5_1 = new Class[0];
            int v6_0 = new Class[0];
            int v6_1 = new Object[0];
            net.bytebuddy.dynamic.ClassFileLocator v5_4 = new Object[0];
            net.bytebuddy.dynamic.ClassFileLocator$PackageDiscriminating v1_5 = ((java.util.Set) v1_8.getMethod("modules", v5_1).invoke(v1_8.getMethod("boot", v6_0).invoke(0, v6_1), v5_4)).iterator();
        } catch (Exception v0_2) {
            throw new IllegalStateException("Cannot process boot layer", v0_2);
        }
        while (v1_5.hasNext()) {
            String[] v3_3 = v1_5.next();
            net.bytebuddy.dynamic.ClassFileLocator v5_6 = net.bytebuddy.dynamic.ClassFileLocator$ForModule.of(net.bytebuddy.utility.JavaModule.of(v3_3));
            int v6_2 = new Object[0];
            String[] v3_6 = ((String[]) ((String[]) v2_0.invoke(v3_3, v6_2)));
            int v6_3 = v3_6.length;
            int v7 = 0;
            while (v7 < v6_3) {
                v0_1.put(v3_6[v7], v5_6);
                v7++;
            }
        }
        return new net.bytebuddy.dynamic.ClassFileLocator$PackageDiscriminating(v0_1);
    }