gt:             object = this.mBackStack.remove(n2);
context: /*
   * Decompiled with CFR 0_115.
   * 
   * Could not load the following classes:
   *  android.content.Context
   *  android.content.res.Configuration
   *  android.content.res.TypedArray
   *  android.os.Build
   *  android.os.Build$VERSION
   *  android.os.Bundle
   *  android.os.Handler
   *  android.os.Looper
   *  android.os.Parcelable
   *  android.util.AttributeSet
   *  android.util.Log
   *  android.util.SparseArray
   *  android.view.Menu
   *  android.view.MenuInflater
   *  android.view.MenuItem
   *  android.view.View
   *  android.view.animation.AccelerateInterpolator
   *  android.view.animation.AlphaAnimation
   *  android.view.animation.Animation
   *  android.view.animation.Animation$AnimationListener
   *  android.view.animation.AnimationSet
   *  android.view.animation.AnimationUtils
   *  android.view.animation.DecelerateInterpolator
   *  android.view.animation.Interpolator
   *  android.view.animation.ScaleAnimation
   */
  package android.support.v4.app;
  
  import android.content.Context;
  import android.content.res.Configuration;
  import android.content.res.TypedArray;
  import android.os.Build;
  import android.os.Bundle;
  import android.os.Handler;
  import android.os.Looper;
  import android.os.Parcelable;
  import android.support.annotation.CallSuper;
  import android.support.v4.app.BackStackRecord;
  import android.support.v4.app.BackStackState;
  import android.support.v4.app.Fragment;
  import android.support.v4.app.FragmentContainer;
  import android.support.v4.app.FragmentController;
  import android.support.v4.app.FragmentHostCallback;
  import android.support.v4.app.FragmentManager;
  import android.support.v4.app.FragmentManagerNonConfig;
  import android.support.v4.app.FragmentManagerState;
  import android.support.v4.app.FragmentState;
  import android.support.v4.app.FragmentTransaction;
  import android.support.v4.app.LoaderManagerImpl;
  import android.support.v4.os.BuildCompat;
  import android.support.v4.util.DebugUtils;
  import android.support.v4.util.LogWriter;
  import android.support.v4.view.LayoutInflaterFactory;
  import android.support.v4.view.ViewCompat;
  import android.util.AttributeSet;
  import android.util.Log;
  import android.util.SparseArray;
  import android.view.Menu;
  import android.view.MenuInflater;
  import android.view.MenuItem;
  import android.view.View;
  import android.view.animation.AccelerateInterpolator;
  import android.view.animation.AlphaAnimation;
  import android.view.animation.Animation;
  import android.view.animation.AnimationSet;
  import android.view.animation.AnimationUtils;
  import android.view.animation.DecelerateInterpolator;
  import android.view.animation.Interpolator;
  import android.view.animation.ScaleAnimation;
  import java.io.FileDescriptor;
  import java.io.PrintWriter;
  import java.io.Writer;
  import java.lang.reflect.Field;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  
  final class FragmentManagerImpl
  extends FragmentManager
  implements LayoutInflaterFactory {
      static final Interpolator ACCELERATE_CUBIC;
      static final Interpolator ACCELERATE_QUINT;
      static final int ANIM_DUR = 220;
      public static final int ANIM_STYLE_CLOSE_ENTER = 3;
      public static final int ANIM_STYLE_CLOSE_EXIT = 4;
      public static final int ANIM_STYLE_FADE_ENTER = 5;
      public static final int ANIM_STYLE_FADE_EXIT = 6;
      public static final int ANIM_STYLE_OPEN_ENTER = 1;
      public static final int ANIM_STYLE_OPEN_EXIT = 2;
      static boolean DEBUG = false;
      static final Interpolator DECELERATE_CUBIC;
      static final Interpolator DECELERATE_QUINT;
      static final boolean HONEYCOMB;
      static final String TAG = "FragmentManager";
      static final String TARGET_REQUEST_CODE_STATE_TAG = "android:target_req_state";
      static final String TARGET_STATE_TAG = "android:target_state";
      static final String USER_VISIBLE_HINT_TAG = "android:user_visible_hint";
      static final String VIEW_STATE_TAG = "android:view_state";
      static Field sAnimationListenerField;
      ArrayList<Fragment> mActive;
      ArrayList<Fragment> mAdded;
      ArrayList<Integer> mAvailBackStackIndices;
      ArrayList<Integer> mAvailIndices;
      ArrayList<BackStackRecord> mBackStack;
      ArrayList<FragmentManager.OnBackStackChangedListener> mBackStackChangeListeners;
      ArrayList<BackStackRecord> mBackStackIndices;
      FragmentContainer mContainer;
      FragmentController mController;
      ArrayList<Fragment> mCreatedMenus;
      int mCurState = 0;
      boolean mDestroyed;
      Runnable mExecCommit;
      boolean mExecutingActions;
      boolean mHavePendingDeferredStart;
      FragmentHostCallback mHost;
      boolean mNeedMenuInvalidate;
      String mNoTransactionsBecause;
      Fragment mParent;
      ArrayList<Runnable> mPendingActions;
      SparseArray<Parcelable> mStateArray = null;
      Bundle mStateBundle = null;
      boolean mStateSaved;
      Runnable[] mTmpActions;
  
      static {
          boolean bl = false;
          DEBUG = false;
          if (Build.VERSION.SDK_INT >= 11) {
              bl = true;
          }
          HONEYCOMB = bl;
          sAnimationListenerField = null;
          DECELERATE_QUINT = new DecelerateInterpolator(2.5f);
          DECELERATE_CUBIC = new DecelerateInterpolator(1.5f);
          ACCELERATE_QUINT = new AccelerateInterpolator(2.5f);
          ACCELERATE_CUBIC = new AccelerateInterpolator(1.5f);
      }
  
      FragmentManagerImpl() {
          this.mExecCommit = new Runnable(){
  
              @Override
              public void run() {
                  FragmentManagerImpl.this.execPendingActions();
              }
          };
      }
  
      private void checkStateLoss() {
          if (this.mStateSaved) {
              throw new IllegalStateException("Can not perform this action after onSaveInstanceState");
          }
          if (this.mNoTransactionsBecause != null) {
              throw new IllegalStateException("Can not perform this action inside of " + this.mNoTransactionsBecause);
          }
      }
  
      static Animation makeFadeAnimation(Context context, float f2, float f3) {
          context = new AlphaAnimation(f2, f3);
          context.setInterpolator(DECELERATE_CUBIC);
          context.setDuration(220);
          return context;
      }
  
      static Animation makeOpenCloseAnimation(Context context, float f2, float f3, float f4, float f5) {
          context = new AnimationSet(false);
          ScaleAnimation scaleAnimation = new ScaleAnimation(f2, f3, f2, f3, 1, 0.5f, 1, 0.5f);
          scaleAnimation.setInterpolator(DECELERATE_QUINT);
          scaleAnimation.setDuration(220);
          context.addAnimation((Animation)scaleAnimation);
          scaleAnimation = new AlphaAnimation(f4, f5);
          scaleAnimation.setInterpolator(DECELERATE_CUBIC);
          scaleAnimation.setDuration(220);
          context.addAnimation((Animation)scaleAnimation);
          return context;
      }
  
      /*
       * Enabled aggressive block sorting
       * Lifted jumps to return sites
       */
      static boolean modifiesAlpha(Animation object) {
          if (object instanceof AlphaAnimation) {
              return true;
          }
          if (!(object instanceof AnimationSet)) return false;
          object = ((AnimationSet)object).getAnimations();
          int n2 = 0;
          while (n2 < object.size()) {
              if (object.get(n2) instanceof AlphaAnimation) return true;
              ++n2;
          }
          return false;
      }
  
      public static int reverseTransit(int n2) {
          switch (n2) {
              default: {
                  return 0;
              }
              case 4097: {
                  return 8194;
              }
              case 8194: {
                  return 4097;
              }
              case 4099: 
          }
          return 4099;
      }
  
      /*
       * Enabled aggressive block sorting
       * Enabled unnecessary exception pruning
       * Enabled aggressive exception aggregation
       */
      private void setHWLayerAnimListenerIfAlpha(View view, Animation animation) {
          if (view == null || animation == null || !FragmentManagerImpl.shouldRunOnHWLayer(view, animation)) {
              return;
          }
          Animation.AnimationListener animationListener = null;
          try {
              Animation.AnimationListener animationListener2;
              if (sAnimationListenerField == null) {
                  sAnimationListenerField = Animation.class.getDeclaredField("mListener");
                  sAnimationListenerField.setAccessible(true);
              }
              animationListener = animationListener2 = (Animation.AnimationListener)sAnimationListenerField.get((Object)animation);
          }
          catch (NoSuchFieldException var4_5) {
              Log.e((String)"FragmentManager", (String)"No field with the name mListener is found in Animation class", (Throwable)var4_5);
          }
          catch (IllegalAccessException var4_6) {
              Log.e((String)"FragmentManager", (String)"Cannot access Animation's mListener field", (Throwable)var4_6);
          }
          ViewCompat.setLayerType(view, 2, null);
          animation.setAnimationListener((Animation.AnimationListener)new AnimateOnHWLayerIfNeededListener(view, animation, animationListener));
      }
  
      static boolean shouldRunOnHWLayer(View view, Animation animation) {
          if (Build.VERSION.SDK_INT >= 19 && ViewCompat.getLayerType(view) == 0 && ViewCompat.hasOverlappingRendering(view) && FragmentManagerImpl.modifiesAlpha(animation)) {
              return true;
          }
          return false;
      }
  
      /*
       * Enabled force condition propagation
       * Lifted jumps to return sites
       */
      private void throwException(RuntimeException runtimeException) {
          Log.e((String)"FragmentManager", (String)runtimeException.getMessage());
          Log.e((String)"FragmentManager", (String)"Activity state:");
          PrintWriter printWriter = new PrintWriter(new LogWriter("FragmentManager"));
          if (this.mHost != null) {
              try {
                  this.mHost.onDump("  ", null, printWriter, new String[0]);
              }
              catch (Exception var2_3) {
                  Log.e((String)"FragmentManager", (String)"Failed dumping state", (Throwable)var2_3);
                  throw runtimeException;
              }
              do {
                  throw runtimeException;
                  break;
              } while (true);
          }
          try {
              this.dump("  ", null, printWriter, new String[0]);
              throw runtimeException;
          }
          catch (Exception var2_4) {
              Log.e((String)"FragmentManager", (String)"Failed dumping state", (Throwable)var2_4);
              throw runtimeException;
          }
      }
  
      public static int transitToStyleIndex(int n2, boolean bl) {
          switch (n2) {
              default: {
                  return -1;
              }
              case 4097: {
                  if (bl) {
                      return 1;
                  }
                  return 2;
              }
              case 8194: {
                  if (bl) {
                      return 3;
                  }
                  return 4;
              }
              case 4099: 
          }
          if (bl) {
              return 5;
          }
          return 6;
      }
  
      void addBackStackState(BackStackRecord backStackRecord) {
          if (this.mBackStack == null) {
              this.mBackStack = new ArrayList();
          }
          this.mBackStack.add(backStackRecord);
          this.reportBackStackChanged();
      }
  
      public void addFragment(Fragment fragment, boolean bl) {
          if (this.mAdded == null) {
              this.mAdded = new ArrayList();
          }
          if (DEBUG) {
              Log.v((String)"FragmentManager", (String)("add: " + fragment));
          }
          this.makeActive(fragment);
          if (!fragment.mDetached) {
              if (this.mAdded.contains(fragment)) {
                  throw new IllegalStateException("Fragment already added: " + fragment);
              }
              this.mAdded.add(fragment);
              fragment.mAdded = true;
              fragment.mRemoving = false;
              if (fragment.mHasMenu && fragment.mMenuVisible) {
                  this.mNeedMenuInvalidate = true;
              }
              if (bl) {
                  this.moveToState(fragment);
              }
          }
      }
  
      @Override
      public void addOnBackStackChangedListener(FragmentManager.OnBackStackChangedListener onBackStackChangedListener) {
          if (this.mBackStackChangeListeners == null) {
              this.mBackStackChangeListeners = new ArrayList();
          }
          this.mBackStackChangeListeners.add(onBackStackChangedListener);
      }
  
      /*
       * Enabled aggressive block sorting
       * Enabled unnecessary exception pruning
       * Enabled aggressive exception aggregation
       */
      public int allocBackStackIndex(BackStackRecord backStackRecord) {
          synchronized (this) {
              if (this.mAvailBackStackIndices == null || this.mAvailBackStackIndices.size() <= 0) {
                  if (this.mBackStackIndices == null) {
                      this.mBackStackIndices = new ArrayList();
                  }
                  int n2 = this.mBackStackIndices.size();
                  if (DEBUG) {
                      Log.v((String)"FragmentManager", (String)("Setting back stack index " + n2 + " to " + backStackRecord));
                  }
                  this.mBackStackIndices.add(backStackRecord);
                  return n2;
              }
              int n3 = this.mAvailBackStackIndices.remove(this.mAvailBackStackIndices.size() - 1);
              if (DEBUG) {
                  Log.v((String)"FragmentManager", (String)("Adding back stack index " + n3 + " with " + backStackRecord));
              }
              this.mBackStackIndices.set(n3, backStackRecord);
              return n3;
          }
      }
  
      public void attachController(FragmentHostCallback fragmentHostCallback, FragmentContainer fragmentContainer, Fragment fragment) {
          if (this.mHost != null) {
              throw new IllegalStateException("Already attached");
          }
          this.mHost = fragmentHostCallback;
          this.mContainer = fragmentContainer;
          this.mParent = fragment;
      }
  
      public void attachFragment(Fragment fragment, int n2, int n3) {
          if (DEBUG) {
              Log.v((String)"FragmentManager", (String)("attach: " + fragment));
          }
          if (fragment.mDetached) {
              fragment.mDetached = false;
              if (!fragment.mAdded) {
                  if (this.mAdded == null) {
                      this.mAdded = new ArrayList();
                  }
                  if (this.mAdded.contains(fragment)) {
                      throw new IllegalStateException("Fragment already added: " + fragment);
                  }
                  if (DEBUG) {
                      Log.v((String)"FragmentManager", (String)("add from attach: " + fragment));
                  }
                  this.mAdded.add(fragment);
                  fragment.mAdded = true;
                  if (fragment.mHasMenu && fragment.mMenuVisible) {
                      this.mNeedMenuInvalidate = true;
                  }
                  this.moveToState(fragment, this.mCurState, n2, n3, false);
              }
          }
      }
  
      @Override
      public FragmentTransaction beginTransaction() {
          return new BackStackRecord(this);
      }
  
      public void detachFragment(Fragment fragment, int n2, int n3) {
          if (DEBUG) {
              Log.v((String)"FragmentManager", (String)("detach: " + fragment));
          }
          if (!fragment.mDetached) {
              fragment.mDetached = true;
              if (fragment.mAdded) {
                  if (this.mAdded != null) {
                      if (DEBUG) {
                          Log.v((String)"FragmentManager", (String)("remove from detach: " + fragment));
                      }
                      this.mAdded.remove(fragment);
                  }
                  if (fragment.mHasMenu && fragment.mMenuVisible) {
                      this.mNeedMenuInvalidate = true;
                  }
                  fragment.mAdded = false;
                  this.moveToState(fragment, 1, n2, n3, false);
              }
          }
      }
  
      public void dispatchActivityCreated() {
          this.mStateSaved = false;
          this.moveToState(2, false);
      }
  
      public void dispatchConfigurationChanged(Configuration configuration) {
          if (this.mAdded != null) {
              for (int i2 = 0; i2 < this.mAdded.size(); ++i2) {
                  Fragment fragment = this.mAdded.get(i2);
                  if (fragment == null) continue;
                  fragment.performConfigurationChanged(configuration);
              }
          }
      }
  
      public boolean dispatchContextItemSelected(MenuItem menuItem) {
          if (this.mAdded != null) {
              for (int i2 = 0; i2 < this.mAdded.size(); ++i2) {
                  Fragment fragment = this.mAdded.get(i2);
                  if (fragment == null || !fragment.performContextItemSelected(menuItem)) continue;
                  return true;
              }
          }
          return false;
      }
  
      public void dispatchCreate() {
          this.mStateSaved = false;
          this.moveToState(1, false);
      }
  
      public boolean dispatchCreateOptionsMenu(Menu object, MenuInflater menuInflater) {
          int n2;
          boolean bl = false;
          boolean bl2 = false;
          ArrayList<Fragment> arrayList = null;
          ArrayList<Fragment> arrayList2 = null;
          if (this.mAdded != null) {
              n2 = 0;
              do {
                  arrayList = arrayList2;
                  bl = bl2;
                  if (n2 >= this.mAdded.size()) break;
                  Fragment fragment = this.mAdded.get(n2);
                  arrayList = arrayList2;
                  bl = bl2;
                  if (fragment != null) {
                      arrayList = arrayList2;
                      bl = bl2;
                      if (fragment.performCreateOptionsMenu((Menu)object, menuInflater)) {
                          bl = true;
                          arrayList = arrayList2;
                          if (arrayList2 == null) {
                              arrayList = new ArrayList<Fragment>();
                          }
                          arrayList.add(fragment);
                      }
                  }
                  ++n2;
                  arrayList2 = arrayList;
                  bl2 = bl;
              } while (true);
          }
          if (this.mCreatedMenus != null) {
              for (n2 = 0; n2 < this.mCreatedMenus.size(); ++n2) {
                  object = this.mCreatedMenus.get(n2);
                  if (arrayList != null && arrayList.contains(object)) continue;
                  object.onDestroyOptionsMenu();
              }
          }
          this.mCreatedMenus = arrayList;
          return bl;
      }
  
      public void dispatchDestroy() {
          this.mDestroyed = true;
          this.execPendingActions();
          this.moveToState(0, false);
          this.mHost = null;
          this.mContainer = null;
          this.mParent = null;
      }
  
      public void dispatchDestroyView() {
          this.moveToState(1, false);
      }
  
      public void dispatchLowMemory() {
          if (this.mAdded != null) {
              for (int i2 = 0; i2 < this.mAdded.size(); ++i2) {
                  Fragment fragment = this.mAdded.get(i2);
                  if (fragment == null) continue;
                  fragment.performLowMemory();
              }
          }
      }
  
      /*
       * Enabled aggressive block sorting
       */
      public void dispatchMultiWindowModeChanged(boolean bl) {
          if (this.mAdded != null) {
              for (int i2 = this.mAdded.size() - 1; i2 >= 0; --i2) {
                  Fragment fragment = this.mAdded.get(i2);
                  if (fragment == null) continue;
                  fragment.performMultiWindowModeChanged(bl);
              }
          }
      }
  
      public boolean dispatchOptionsItemSelected(MenuItem menuItem) {
          if (this.mAdded != null) {
              for (int i2 = 0; i2 < this.mAdded.size(); ++i2) {
                  Fragment fragment = this.mAdded.get(i2);
                  if (fragment == null || !fragment.performOptionsItemSelected(menuItem)) continue;
                  return true;
              }
          }
          return false;
      }
  
      public void dispatchOptionsMenuClosed(Menu menu2) {
          if (this.mAdded != null) {
              for (int i2 = 0; i2 < this.mAdded.size(); ++i2) {
                  Fragment fragment = this.mAdded.get(i2);
                  if (fragment == null) continue;
                  fragment.performOptionsMenuClosed(menu2);
              }
          }
      }
  
      public void dispatchPause() {
          this.moveToState(4, false);
      }
  
      /*
       * Enabled aggressive block sorting
       */
      public void dispatchPictureInPictureModeChanged(boolean bl) {
          if (this.mAdded != null) {
              for (int i2 = this.mAdded.size() - 1; i2 >= 0; --i2) {
                  Fragment fragment = this.mAdded.get(i2);
                  if (fragment == null) continue;
                  fragment.performPictureInPictureModeChanged(bl);
              }
          }
      }
  
      public boolean dispatchPrepareOptionsMenu(Menu menu2) {
          boolean bl = false;
          boolean bl2 = false;
          if (this.mAdded != null) {
              int n2 = 0;
              do {
                  bl = bl2;
                  if (n2 >= this.mAdded.size()) break;
                  Fragment fragment = this.mAdded.get(n2);
                  bl = bl2;
                  if (fragment != null) {
                      bl = bl2;
                      if (fragment.performPrepareOptionsMenu(menu2)) {
                          bl = true;
                      }
                  }
                  ++n2;
                  bl2 = bl;
              } while (true);
          }
          return bl;
      }
  
      public void dispatchReallyStop() {
          this.moveToState(2, false);
      }
  
      public void dispatchResume() {
          this.mStateSaved = false;
          this.moveToState(5, false);
      }
  
      public void dispatchStart() {
          this.mStateSaved = false;
          this.moveToState(4, false);
      }
  
      public void dispatchStop() {
          this.mStateSaved = true;
          this.moveToState(3, false);
      }
  
      void doPendingDeferredStart() {
          if (this.mHavePendingDeferredStart) {
              boolean bl = false;
              for (int i2 = 0; i2 < this.mActive.size(); ++i2) {
                  Fragment fragment = this.mActive.get(i2);
                  boolean bl2 = bl;
                  if (fragment != null) {
                      bl2 = bl;
                      if (fragment.mLoaderManager != null) {
                          bl2 = bl | fragment.mLoaderManager.hasRunningLoaders();
                      }
                  }
                  bl = bl2;
              }
              if (!bl) {
                  this.mHavePendingDeferredStart = false;
                  this.startPendingDeferredFragments();
              }
          }
      }
  
      /*
       * Enabled aggressive block sorting
       * Enabled unnecessary exception pruning
       * Enabled aggressive exception aggregation
       * Converted monitor instructions to comments
       * Lifted jumps to return sites
       */
      @Override
      public void dump(String string2, FileDescriptor object, PrintWriter printWriter, String[] arrstring) {
          Object object2;
          int n2;
          int n3;
          String string3 = string2 + "    ";
          if (this.mActive != null && (n3 = this.mActive.size()) > 0) {
              printWriter.print(string2);
              printWriter.print("Active Fragments in ");
              printWriter.print(Integer.toHexString(System.identityHashCode(this)));
              printWriter.println(":");
              for (n2 = 0; n2 < n3; ++n2) {
                  object2 = this.mActive.get(n2);
                  printWriter.print(string2);
                  printWriter.print("  #");
                  printWriter.print(n2);
                  printWriter.print(": ");
                  printWriter.println(object2);
                  if (object2 == null) continue;
                  object2.dump(string3, (FileDescriptor)object, printWriter, arrstring);
              }
          }
          if (this.mAdded != null && (n3 = this.mAdded.size()) > 0) {
              printWriter.print(string2);
              printWriter.println("Added Fragments:");
              for (n2 = 0; n2 < n3; ++n2) {
                  object2 = this.mAdded.get(n2);
                  printWriter.print(string2);
                  printWriter.print("  #");
                  printWriter.print(n2);
                  printWriter.print(": ");
                  printWriter.println(object2.toString());
              }
          }
          if (this.mCreatedMenus != null && (n3 = this.mCreatedMenus.size()) > 0) {
              printWriter.print(string2);
              printWriter.println("Fragments Created Menus:");
              for (n2 = 0; n2 < n3; ++n2) {
                  object2 = this.mCreatedMenus.get(n2);
                  printWriter.print(string2);
                  printWriter.print("  #");
                  printWriter.print(n2);
                  printWriter.print(": ");
                  printWriter.println(object2.toString());
              }
          }
          if (this.mBackStack != null && (n3 = this.mBackStack.size()) > 0) {
              printWriter.print(string2);
              printWriter.println("Back Stack:");
              for (n2 = 0; n2 < n3; ++n2) {
                  object2 = this.mBackStack.get(n2);
                  printWriter.print(string2);
                  printWriter.print("  #");
                  printWriter.print(n2);
                  printWriter.print(": ");
                  printWriter.println(object2.toString());
                  object2.dump(string3, (FileDescriptor)object, printWriter, arrstring);
              }
          }
          // MONITORENTER : this
          if (this.mBackStackIndices != null && (n3 = this.mBackStackIndices.size()) > 0) {
              printWriter.print(string2);
              printWriter.println("Back Stack Indices:");
              for (n2 = 0; n2 < n3; ++n2) {
                  object = this.mBackStackIndices.get(n2);
                  printWriter.print(string2);
                  printWriter.print("  #");
                  printWriter.print(n2);
                  printWriter.print(": ");
                  printWriter.println(object);
              }
          }
          if (this.mAvailBackStackIndices != null && this.mAvailBackStackIndices.size() > 0) {
              printWriter.print(string2);
              printWriter.print("mAvailBackStackIndices: ");
              printWriter.println(Arrays.toString(this.mAvailBackStackIndices.toArray()));
          }
          // MONITOREXIT : this
          if (this.mPendingActions != null && (n3 = this.mPendingActions.size()) > 0) {
              printWriter.print(string2);
              printWriter.println("Pending Actions:");
              for (n2 = 0; n2 < n3; ++n2) {
                  object = this.mPendingActions.get(n2);
                  printWriter.print(string2);
                  printWriter.print("  #");
                  printWriter.print(n2);
                  printWriter.print(": ");
                  printWriter.println(object);
              }
          }
          printWriter.print(string2);
          printWriter.println("FragmentManager misc state:");
          printWriter.print(string2);
          printWriter.print("  mHost=");
          printWriter.println(this.mHost);
          printWriter.print(string2);
          printWriter.print("  mContainer=");
          printWriter.println(this.mContainer);
          if (this.mParent != null) {
              printWriter.print(string2);
              printWriter.print("  mParent=");
              printWriter.println(this.mParent);
          }
          printWriter.print(string2);
          printWriter.print("  mCurState=");
          printWriter.print(this.mCurState);
          printWriter.print(" mStateSaved=");
          printWriter.print(this.mStateSaved);
          printWriter.print(" mDestroyed=");
          printWriter.println(this.mDestroyed);
          if (this.mNeedMenuInvalidate) {
              printWriter.print(string2);
              printWriter.print("  mNeedMenuInvalidate=");
              printWriter.println(this.mNeedMenuInvalidate);
          }
          if (this.mNoTransactionsBecause != null) {
              printWriter.print(string2);
              printWriter.print("  mNoTransactionsBecause=");
              printWriter.println(this.mNoTransactionsBecause);
          }
          if (this.mAvailIndices == null) return;
          if (this.mAvailIndices.size() <= 0) return;
          printWriter.print(string2);
          printWriter.print("  mAvailIndices: ");
          printWriter.println(Arrays.toString(this.mAvailIndices.toArray()));
      }
  
      /*
       * Enabled aggressive block sorting
       * Enabled unnecessary exception pruning
       * Enabled aggressive exception aggregation
       */
      public void enqueueAction(Runnable runnable, boolean bl) {
          if (!bl) {
              this.checkStateLoss();
          }
          synchronized (this) {
              if (this.mDestroyed || this.mHost == null) {
                  throw new IllegalStateException("Activity has been destroyed");
              }
              if (this.mPendingActions == null) {
                  this.mPendingActions = new ArrayList();
              }
              this.mPendingActions.add(runnable);
              if (this.mPendingActions.size() == 1) {
                  this.mHost.getHandler().removeCallbacks(this.mExecCommit);
                  this.mHost.getHandler().post(this.mExecCommit);
              }
              return;
          }
      }
  
      /*
       * Enabled aggressive block sorting
       * Enabled unnecessary exception pruning
       * Enabled aggressive exception aggregation
       */
      public boolean execPendingActions() {
          if (this.mExecutingActions) {
              throw new IllegalStateException("FragmentManager is already executing transactions");
          }
          if (Looper.myLooper() != this.mHost.getHandler().getLooper()) {
              throw new IllegalStateException("Must be called from main thread of fragment host");
          }
          boolean bl = false;
          do {
              int n2;
              synchronized (this) {
                  if (this.mPendingActions == null || this.mPendingActions.size() == 0) {
                      // MONITOREXIT [3, 4, 7] lbl9 : MonitorExitStatement: MONITOREXIT : this
                      this.doPendingDeferredStart();
                      return bl;
                  }
                  n2 = this.mPendingActions.size();
                  if (this.mTmpActions == null || this.mTmpActions.length < n2) {
                      this.mTmpActions = new Runnable[n2];
                  }
                  this.mPendingActions.toArray(this.mTmpActions);
                  this.mPendingActions.clear();
                  this.mHost.getHandler().removeCallbacks(this.mExecCommit);
              }
              this.mExecutingActions = true;
              for (int i2 = 0; i2 < n2; ++i2) {
                  this.mTmpActions[i2].run();
                  this.mTmpActions[i2] = null;
              }
              this.mExecutingActions = false;
              bl = true;
          } while (true);
      }
  
      public void execSingleAction(Runnable runnable, boolean bl) {
          if (this.mExecutingActions) {
              throw new IllegalStateException("FragmentManager is already executing transactions");
          }
          if (Looper.myLooper() != this.mHost.getHandler().getLooper()) {
              throw new IllegalStateException("Must be called from main thread of fragment host");
          }
          if (!bl) {
              this.checkStateLoss();
          }
          this.mExecutingActions = true;
          runnable.run();
          this.mExecutingActions = false;
          this.doPendingDeferredStart();
      }
  
      @Override
      public boolean executePendingTransactions() {
          return this.execPendingActions();
      }
  
      /*
       * Enabled aggressive block sorting
       */
      @Override
      public Fragment findFragmentById(int n2) {
          int n3;
          Fragment fragment;
          if (this.mAdded != null) {
              for (n3 = this.mAdded.size() - 1; n3 >= 0; --n3) {
                  fragment = this.mAdded.get(n3);
                  if (fragment != null && fragment.mFragmentId == n2) return fragment;
                  {
                      continue;
                  }
              }
          } else {
              if (this.mActive == null) return null;
              {
                  for (n3 = this.mActive.size() - 1; n3 >= 0; --n3) {
                      Fragment fragment2 = this.mActive.get(n3);
                      if (fragment2 == null) continue;
                      fragment = fragment2;
                      if (fragment2.mFragmentId == n2) return fragment;
                      {
                          continue;
                      }
                  }
              }
              return null;
          }
      }
  
      /*
       * Enabled aggressive block sorting
       */
      @Override
      public Fragment findFragmentByTag(String string2) {
          int n2;
          Fragment fragment;
          if (this.mAdded != null && string2 != null) {
              for (n2 = this.mAdded.size() - 1; n2 >= 0; --n2) {
                  fragment = this.mAdded.get(n2);
                  if (fragment != null && string2.equals(fragment.mTag)) return fragment;
                  {
                      continue;
                  }
              }
          } else {
              if (this.mActive == null || string2 == null) return null;
              {
                  for (n2 = this.mActive.size() - 1; n2 >= 0; --n2) {
                      Fragment fragment2 = this.mActive.get(n2);
                      if (fragment2 == null) continue;
                      fragment = fragment2;
                      if (string2.equals(fragment2.mTag)) return fragment;
                      {
                          continue;
                      }
                  }
              }
              return null;
          }
      }
  
      public Fragment findFragmentByWho(String string2) {
          if (this.mActive != null && string2 != null) {
              for (int i2 = this.mActive.size() - 1; i2 >= 0; --i2) {
                  Fragment fragment = this.mActive.get(i2);
                  if (fragment == null || (fragment = fragment.findFragmentByWho(string2)) == null) continue;
                  return fragment;
              }
          }
          return null;
      }
  
      /*
       * Enabled aggressive block sorting
       * Enabled unnecessary exception pruning
       * Enabled aggressive exception aggregation
       */
      public void freeBackStackIndex(int n2) {
          synchronized (this) {
              this.mBackStackIndices.set(n2, null);
              if (this.mAvailBackStackIndices == null) {
                  this.mAvailBackStackIndices = new ArrayList();
              }
              if (DEBUG) {
                  Log.v((String)"FragmentManager", (String)("Freeing back stack index " + n2));
              }
              this.mAvailBackStackIndices.add(n2);
              return;
          }
      }
  
      @Override
      public FragmentManager.BackStackEntry getBackStackEntryAt(int n2) {
          return this.mBackStack.get(n2);
      }
  
      @Override
      public int getBackStackEntryCount() {
          if (this.mBackStack != null) {
              return this.mBackStack.size();
          }
          return 0;
      }
  
      /*
       * Enabled force condition propagation
       * Lifted jumps to return sites
       */
      @Override
      public Fragment getFragment(Bundle object, String string2) {
          Fragment fragment;
          int n2 = object.getInt(string2, -1);
          if (n2 == -1) {
              return null;
          }
          if (n2 >= this.mActive.size()) {
              this.throwException(new IllegalStateException("Fragment no longer exists for key " + string2 + ": index " + n2));
          }
          object = fragment = this.mActive.get(n2);
          if (fragment != null) return object;
          this.throwException(new IllegalStateException("Fragment no longer exists for key " + string2 + ": index " + n2));
          return fragment;
      }
  
      @Override
      public List<Fragment> getFragments() {
          return this.mActive;
      }
  
      LayoutInflaterFactory getLayoutInflaterFactory() {
          return this;
      }
  
      public void hideFragment(Fragment fragment, int n2, int n3) {
          if (DEBUG) {
              Log.v((String)"FragmentManager", (String)("hide: " + fragment));
          }
          if (!fragment.mHidden) {
              fragment.mHidden = true;
              if (fragment.mView != null) {
                  Animation animation = this.loadAnimation(fragment, n2, false, n3);
                  if (animation != null) {
                      this.setHWLayerAnimListenerIfAlpha(fragment.mView, animation);
                      fragment.mView.startAnimation(animation);
                  }
                  fragment.mView.setVisibility(8);
              }
              if (fragment.mAdded && fragment.mHasMenu && fragment.mMenuVisible) {
                  this.mNeedMenuInvalidate = true;
              }
              fragment.onHiddenChanged(true);
          }
      }
  
      @Override
      public boolean isDestroyed() {
          return this.mDestroyed;
      }
  
      boolean isStateAtLeast(int n2) {
          if (this.mCurState >= n2) {
              return true;
          }
          return false;
      }
  
      Animation loadAnimation(Fragment fragment, int n2, boolean bl, int n3) {
          Animation animation = fragment.onCreateAnimation(n2, bl, fragment.mNextAnim);
          if (animation != null) {
              return animation;
          }
          if (fragment.mNextAnim != 0 && (fragment = AnimationUtils.loadAnimation((Context)this.mHost.getContext(), (int)fragment.mNextAnim)) != null) {
              return fragment;
          }
          if (n2 == 0) {
              return null;
          }
          if ((n2 = FragmentManagerImpl.transitToStyleIndex(n2, bl)) < 0) {
              return null;
          }
          switch (n2) {
              default: {
                  n2 = n3;
                  if (n3 == 0) {
                      n2 = n3;
                      if (this.mHost.onHasWindowAnimations()) {
                          n2 = this.mHost.onGetWindowAnimations();
                      }
                  }
                  if (n2 != 0) break;
                  return null;
              }
              case 1: {
                  return FragmentManagerImpl.makeOpenCloseAnimation(this.mHost.getContext(), 1.125f, 1.0f, 0.0f, 1.0f);
              }
              case 2: {
                  return FragmentManagerImpl.makeOpenCloseAnimation(this.mHost.getContext(), 1.0f, 0.975f, 1.0f, 0.0f);
              }
              case 3: {
                  return FragmentManagerImpl.makeOpenCloseAnimation(this.mHost.getContext(), 0.975f, 1.0f, 0.0f, 1.0f);
              }
              case 4: {
                  return FragmentManagerImpl.makeOpenCloseAnimation(this.mHost.getContext(), 1.0f, 1.075f, 1.0f, 0.0f);
              }
              case 5: {
                  return FragmentManagerImpl.makeFadeAnimation(this.mHost.getContext(), 0.0f, 1.0f);
              }
              case 6: {
                  return FragmentManagerImpl.makeFadeAnimation(this.mHost.getContext(), 1.0f, 0.0f);
              }
          }
          return null;
      }
  
      /*
       * Enabled aggressive block sorting
       * Lifted jumps to return sites
       */
      void makeActive(Fragment fragment) {
          if (fragment.mIndex >= 0) {
              return;
          }
          if (this.mAvailIndices == null || this.mAvailIndices.size() <= 0) {
              if (this.mActive == null) {
                  this.mActive = new ArrayList();
              }
              fragment.setIndex(this.mActive.size(), this.mParent);
              this.mActive.add(fragment);
          } else {
              fragment.setIndex(this.mAvailIndices.remove(this.mAvailIndices.size() - 1), this.mParent);
              this.mActive.set(fragment.mIndex, fragment);
          }
          if (!DEBUG) return;
          Log.v((String)"FragmentManager", (String)("Allocated fragment index " + fragment));
      }
  
      void makeInactive(Fragment fragment) {
          if (fragment.mIndex < 0) {
              return;
          }
          if (DEBUG) {
              Log.v((String)"FragmentManager", (String)("Freeing fragment index " + fragment));
          }
          this.mActive.set(fragment.mIndex, null);
          if (this.mAvailIndices == null) {
              this.mAvailIndices = new ArrayList();
          }
          this.mAvailIndices.add(fragment.mIndex);
          this.mHost.inactivateFragment(fragment.mWho);
          fragment.initState();
      }
  
      /*
       * Enabled aggressive block sorting
       * Lifted jumps to return sites
       */
      void moveToState(int n2, int n3, int n4, boolean bl) {
          if (this.mHost == null && n2 != 0) {
              throw new IllegalStateException("No host");
          }
          if (!bl && this.mCurState == n2) {
              return;
          }
          this.mCurState = n2;
          if (this.mActive == null) return;
          boolean bl2 = false;
          int n5 = 0;
          do {
              if (n5 >= this.mActive.size()) {
                  this.startPendingDeferredFragments();
                  if (!this.mNeedMenuInvalidate) return;
                  if (this.mHost == null) return;
                  if (this.mCurState != 5) return;
                  this.mHost.onSupportInvalidateOptionsMenu();
                  this.mNeedMenuInvalidate = false;
                  return;
              }
              Fragment fragment = this.mActive.get(n5);
              boolean bl3 = bl2;
              if (fragment != null) {
                  this.moveToState(fragment, n2, n3, n4, false);
                  bl3 = bl2;
                  if (fragment.mLoaderManager != null) {
                      bl3 = bl2 | fragment.mLoaderManager.hasRunningLoaders();
                  }
              }
              ++n5;
              bl2 = bl3;
          } while (true);
      }
  
      void moveToState(int n2, boolean bl) {
          this.moveToState(n2, 0, 0, bl);
      }
  
      void moveToState(Fragment fragment) {
          this.moveToState(fragment, this.mCurState, 0, 0, false);
      }
  
      /*
       * Exception decompiling
       */
      void moveToState(Fragment var1_1, int var2_2, int var3_3, int var4_4, boolean var5_5) {
          // This method has failed to decompile.  When submitting a bug report, please provide this stack trace, and (if you hold appropriate legal rights) the relevant class file.
          // org.benf.cfr.reader.util.CannotPerformDecode: reachable test BLOCK was exited and re-entered.
          // org.benf.cfr.reader.bytecode.analysis.opgraph.op3rewriters.Misc.getFarthestReachableInRange(Misc.java:143)
          // org.benf.cfr.reader.bytecode.analysis.opgraph.op3rewriters.SwitchReplacer.examineSwitchContiguity(SwitchReplacer.java:385)
          // org.benf.cfr.reader.bytecode.analysis.opgraph.op3rewriters.SwitchReplacer.rebuildSwitches(SwitchReplacer.java:334)
          // org.benf.cfr.reader.bytecode.CodeAnalyser.getAnalysisInner(CodeAnalyser.java:539)
          // org.benf.cfr.reader.bytecode.CodeAnalyser.getAnalysisOrWrapFail(CodeAnalyser.java:220)
          // org.benf.cfr.reader.bytecode.CodeAnalyser.getAnalysis(CodeAnalyser.java:165)
          // org.benf.cfr.reader.entities.attributes.AttributeCode.analyse(AttributeCode.java:91)
          // org.benf.cfr.reader.entities.Method.analyse(Method.java:354)
          // org.benf.cfr.reader.entities.ClassFile.analyseMid(ClassFile.java:751)
          // org.benf.cfr.reader.entities.ClassFile.analyseTop(ClassFile.java:683)
          // org.benf.cfr.reader.Main.doJar(Main.java:129)
          // org.benf.cfr.reader.Main.main(Main.java:181)
          throw new IllegalStateException("Decompilation failed");
      }
  
      public void noteStateNotSaved() {
          this.mStateSaved = false;
      }
  
      /*
       * Enabled aggressive block sorting
       * Lifted jumps to return sites
       */
      @Override
      public View onCreateView(View object, String object2, Context context, AttributeSet attributeSet) {
          if (!"fragment".equals(object2)) {
              return null;
          }
          object2 = attributeSet.getAttributeValue(null, "class");
          TypedArray typedArray = context.obtainStyledAttributes(attributeSet, FragmentTag.Fragment);
          Object object3 = object2;
          if (object2 == null) {
              object3 = typedArray.getString(0);
          }
          int n2 = typedArray.getResourceId(1, -1);
          String string2 = typedArray.getString(2);
          typedArray.recycle();
          if (!Fragment.isSupportFragmentClass(this.mHost.getContext(), (String)object3)) return null;
          int n3 = object != null ? object.getId() : 0;
          if (n3 == -1 && n2 == -1 && string2 == null) {
              throw new IllegalArgumentException(attributeSet.getPositionDescription() + ": Must specify unique android:id, android:tag, or have a parent with an id for " + (String)object3);
          }
          object2 = n2 != -1 ? this.findFragmentById(n2) : null;
          object = object2;
          if (object2 == null) {
              object = object2;
              if (string2 != null) {
                  object = this.findFragmentByTag(string2);
              }
          }
          object2 = object;
          if (object == null) {
              object2 = object;
              if (n3 != -1) {
                  object2 = this.findFragmentById(n3);
              }
          }
          if (DEBUG) {
              Log.v((String)"FragmentManager", (String)("onCreateView: id=0x" + Integer.toHexString(n2) + " fname=" + (String)object3 + " existing=" + object2));
          }
          if (object2 == null) {
              object = Fragment.instantiate(context, (String)object3);
              object.mFromLayout = true;
              int n4 = n2 != 0 ? n2 : n3;
              object.mFragmentId = n4;
              object.mContainerId = n3;
              object.mTag = string2;
              object.mInLayout = true;
              object.mFragmentManager = this;
              object.mHost = this.mHost;
              object.onInflate(this.mHost.getContext(), attributeSet, object.mSavedFragmentState);
              this.addFragment((Fragment)object, true);
          } else {
              if (object2.mInLayout) {
                  throw new IllegalArgumentException(attributeSet.getPositionDescription() + ": Duplicate id 0x" + Integer.toHexString(n2) + ", tag " + string2 + ", or parent id 0x" + Integer.toHexString(n3) + " with another fragment for " + (String)object3);
              }
              object2.mInLayout = true;
              object2.mHost = this.mHost;
              object = object2;
              if (!object2.mRetaining) {
                  object2.onInflate(this.mHost.getContext(), attributeSet, object2.mSavedFragmentState);
                  object = object2;
              }
          }
          if (this.mCurState < 1 && object.mFromLayout) {
              this.moveToState((Fragment)object, 1, 0, 0, false);
          } else {
              this.moveToState((Fragment)object);
          }
          if (object.mView == null) {
              throw new IllegalStateException("Fragment " + (String)object3 + " did not create a view.");
          }
          if (n2 != 0) {
              object.mView.setId(n2);
          }
          if (object.mView.getTag() != null) return object.mView;
          object.mView.setTag((Object)string2);
          return object.mView;
      }
  
      /*
       * Enabled force condition propagation
       * Lifted jumps to return sites
       */
      public void performPendingDeferredStart(Fragment fragment) {
          if (!fragment.mDeferStart) return;
          if (this.mExecutingActions) {
              this.mHavePendingDeferredStart = true;
              return;
          }
          fragment.mDeferStart = false;
          this.moveToState(fragment, this.mCurState, 0, 0, false);
      }
  
      @Override
      public void popBackStack() {
          this.enqueueAction(new Runnable(){
  
              @Override
              public void run() {
                  FragmentManagerImpl.this.popBackStackState(FragmentManagerImpl.this.mHost.getHandler(), null, -1, 0);
              }
          }, false);
      }
  
      @Override
      public void popBackStack(final int n2, final int n3) {
          if (n2 < 0) {
              throw new IllegalArgumentException("Bad id: " + n2);
          }
          this.enqueueAction(new Runnable(){
  
              @Override
              public void run() {
                  FragmentManagerImpl.this.popBackStackState(FragmentManagerImpl.this.mHost.getHandler(), null, n2, n3);
              }
          }, false);
      }
  
      @Override
      public void popBackStack(final String string2, final int n2) {
          this.enqueueAction(new Runnable(){
  
              @Override
              public void run() {
                  FragmentManagerImpl.this.popBackStackState(FragmentManagerImpl.this.mHost.getHandler(), string2, -1, n2);
              }
          }, false);
      }
  
      @Override
      public boolean popBackStackImmediate() {
          this.checkStateLoss();
          this.executePendingTransactions();
          return this.popBackStackState(this.mHost.getHandler(), null, -1, 0);
      }
  
      @Override
      public boolean popBackStackImmediate(int n2, int n3) {
          this.checkStateLoss();
          this.executePendingTransactions();
          if (n2 < 0) {
              throw new IllegalArgumentException("Bad id: " + n2);
          }
          return this.popBackStackState(this.mHost.getHandler(), null, n2, n3);
      }
  
      @Override
      public boolean popBackStackImmediate(String string2, int n2) {
          this.checkStateLoss();
          this.executePendingTransactions();
          return this.popBackStackState(this.mHost.getHandler(), string2, -1, n2);
      }
  
      /*
       * Enabled aggressive block sorting
       */
      boolean popBackStackState(Handler object, String sparseArray, int n2, int n3) {
          if (this.mBackStack == null) {
              return false;
          }
          if (sparseArray == null && n2 < 0 && (n3 & 1) == 0) {
              n2 = this.mBackStack.size() - 1;
              if (n2 < 0) {
                  return false;
              }
  