package androidx.fragment.app;

import android.annotation.SuppressLint;
import android.content.Context;
import android.content.Intent;
import android.content.res.Configuration;
import android.os.Bundle;
import android.os.Looper;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.Log;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import androidx.activity.OnBackPressedDispatcher;
import androidx.activity.OnBackPressedDispatcher.LifecycleOnBackPressedCancellable;
import androidx.activity.result.ActivityResult;
import androidx.activity.result.ActivityResultRegistry;
import androidx.activity.result.IntentSenderRequest;
import androidx.fragment.app.Fragment;
import c.k.b.a0;
import c.k.b.b0;
import c.k.b.c0;
import c.k.b.d0;
import c.k.b.k0;
import c.k.b.q0;
import c.k.b.r;
import c.k.b.r0;
import c.k.b.s;
import c.k.b.s0;
import c.k.b.u;
import c.k.b.v;
import c.k.b.w;
import c.k.b.x;
import c.k.b.z;
import c.l.f0;
import c.l.g0;
import c.l.h0;
import c.l.i0.a;
import c.l.j;
import c.l.n;
import com.ifpdos.debugmenu.R;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicInteger;

/* JADX INFO: loaded from: classes.dex */
public abstract class FragmentManager {
    public boolean A;
    public boolean B;
    public boolean C;
    public boolean D;
    public boolean E;
    public ArrayList<c.k.b.a> F;
    public ArrayList<Boolean> G;
    public ArrayList<Fragment> H;
    public ArrayList<m> I;
    public z J;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public boolean f335b;

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public ArrayList<c.k.b.a> f337d;

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public ArrayList<Fragment> f338e;

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    public OnBackPressedDispatcher f340g;
    public v<?> q;
    public r r;
    public Fragment s;
    public Fragment t;
    public c.a.m.b<Intent> w;
    public c.a.m.b<IntentSenderRequest> x;
    public c.a.m.b<String[]> y;
    public final ArrayList<k> a = new ArrayList<>();

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public final c0 f336c = new c0();

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public final w f339f = new w(this);

    /* JADX INFO: renamed from: h, reason: collision with root package name */
    public final c.a.j f341h = new c(false);

    /* JADX INFO: renamed from: i, reason: collision with root package name */
    public final AtomicInteger f342i = new AtomicInteger();

    /* JADX INFO: renamed from: j, reason: collision with root package name */
    public final Map<String, Bundle> f343j = Collections.synchronizedMap(new HashMap());

    /* JADX INFO: renamed from: k, reason: collision with root package name */
    public final Map<String, ?> f344k = Collections.synchronizedMap(new HashMap());

    /* JADX INFO: renamed from: l, reason: collision with root package name */
    public Map<Fragment, HashSet<c.f.f.c>> f345l = Collections.synchronizedMap(new HashMap());
    public final k0.a m = new d();
    public final x n = new x(this);
    public final CopyOnWriteArrayList<a0> o = new CopyOnWriteArrayList<>();
    public int p = -1;
    public u u = new e();
    public s0 v = new f(this);
    public ArrayDeque<LaunchedFragmentInfo> z = new ArrayDeque<>();
    public Runnable K = new g();

    /* JADX INFO: renamed from: androidx.fragment.app.FragmentManager$6, reason: invalid class name */
    public class AnonymousClass6 implements c.l.l {
        @Override // c.l.l
        public void g(n nVar, j.a aVar) {
            if (aVar == j.a.ON_START || aVar == j.a.ON_DESTROY) {
                throw null;
            }
        }
    }

    public class a implements c.a.m.a<ActivityResult> {
        public a() {
        }

        @Override // c.a.m.a
        public void a(ActivityResult activityResult) {
            ActivityResult activityResult2 = activityResult;
            LaunchedFragmentInfo launchedFragmentInfoPollFirst = FragmentManager.this.z.pollFirst();
            if (launchedFragmentInfoPollFirst == null) {
                Log.w("FragmentManager", "No IntentSenders were started for " + this);
                return;
            }
            String str = launchedFragmentInfoPollFirst.f346b;
            int i2 = launchedFragmentInfoPollFirst.f347e;
            Fragment fragmentE = FragmentManager.this.f336c.e(str);
            if (fragmentE != null) {
                fragmentE.onActivityResult(i2, activityResult2.f23b, activityResult2.f24e);
                return;
            }
            Log.w("FragmentManager", "Intent Sender result delivered for unknown Fragment " + str);
        }
    }

    public class b implements c.a.m.a<Map<String, Boolean>> {
        public b() {
        }

        @Override // c.a.m.a
        @SuppressLint({"SyntheticAccessor"})
        public void a(Map<String, Boolean> map) {
            Map<String, Boolean> map2 = map;
            String[] strArr = (String[]) map2.keySet().toArray(new String[0]);
            ArrayList arrayList = new ArrayList(map2.values());
            int[] iArr = new int[arrayList.size()];
            for (int i2 = 0; i2 < arrayList.size(); i2++) {
                iArr[i2] = ((Boolean) arrayList.get(i2)).booleanValue() ? 0 : -1;
            }
            LaunchedFragmentInfo launchedFragmentInfoPollFirst = FragmentManager.this.z.pollFirst();
            if (launchedFragmentInfoPollFirst == null) {
                Log.w("FragmentManager", "No permissions were requested for " + this);
                return;
            }
            String str = launchedFragmentInfoPollFirst.f346b;
            int i3 = launchedFragmentInfoPollFirst.f347e;
            Fragment fragmentE = FragmentManager.this.f336c.e(str);
            if (fragmentE != null) {
                fragmentE.onRequestPermissionsResult(i3, strArr, iArr);
                return;
            }
            Log.w("FragmentManager", "Permission request result delivered for unknown Fragment " + str);
        }
    }

    public class c extends c.a.j {
        public c(boolean z) {
            super(z);
        }

        @Override // c.a.j
        public void a() {
            FragmentManager fragmentManager = FragmentManager.this;
            fragmentManager.C(true);
            if (fragmentManager.f341h.a) {
                fragmentManager.V();
            } else {
                fragmentManager.f340g.a();
            }
        }
    }

    public class d implements k0.a {
        public d() {
        }

        public void a(Fragment fragment, c.f.f.c cVar) {
            boolean z;
            synchronized (cVar) {
                z = cVar.a;
            }
            if (z) {
                return;
            }
            FragmentManager fragmentManager = FragmentManager.this;
            HashSet<c.f.f.c> hashSet = fragmentManager.f345l.get(fragment);
            if (hashSet != null && hashSet.remove(cVar) && hashSet.isEmpty()) {
                fragmentManager.f345l.remove(fragment);
                if (fragment.mState < 5) {
                    fragmentManager.i(fragment);
                    fragmentManager.S(fragment, fragmentManager.p);
                }
            }
        }

        public void b(Fragment fragment, c.f.f.c cVar) {
            FragmentManager fragmentManager = FragmentManager.this;
            if (fragmentManager.f345l.get(fragment) == null) {
                fragmentManager.f345l.put(fragment, new HashSet<>());
            }
            fragmentManager.f345l.get(fragment).add(cVar);
        }
    }

    public class e extends u {
        public e() {
        }

        @Override // c.k.b.u
        public Fragment a(ClassLoader classLoader, String str) {
            v<?> vVar = FragmentManager.this.q;
            Context context = vVar.f1740e;
            Objects.requireNonNull(vVar);
            return Fragment.instantiate(context, str, null);
        }
    }

    public class f implements s0 {
        public f(FragmentManager fragmentManager) {
        }
    }

    public class g implements Runnable {
        public g() {
        }

        @Override // java.lang.Runnable
        public void run() {
            FragmentManager.this.C(true);
        }
    }

    public class h implements a0 {

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        public final /* synthetic */ Fragment f351b;

        public h(FragmentManager fragmentManager, Fragment fragment) {
            this.f351b = fragment;
        }

        @Override // c.k.b.a0
        public void a(FragmentManager fragmentManager, Fragment fragment) {
            this.f351b.onAttachFragment(fragment);
        }
    }

    public class i implements c.a.m.a<ActivityResult> {
        public i() {
        }

        @Override // c.a.m.a
        public void a(ActivityResult activityResult) {
            ActivityResult activityResult2 = activityResult;
            LaunchedFragmentInfo launchedFragmentInfoPollFirst = FragmentManager.this.z.pollFirst();
            if (launchedFragmentInfoPollFirst == null) {
                Log.w("FragmentManager", "No Activities were started for result for " + this);
                return;
            }
            String str = launchedFragmentInfoPollFirst.f346b;
            int i2 = launchedFragmentInfoPollFirst.f347e;
            Fragment fragmentE = FragmentManager.this.f336c.e(str);
            if (fragmentE != null) {
                fragmentE.onActivityResult(i2, activityResult2.f23b, activityResult2.f24e);
                return;
            }
            Log.w("FragmentManager", "Activity result delivered for unknown Fragment " + str);
        }
    }

    public static class j extends c.a.m.d.a<IntentSenderRequest, ActivityResult> {
        @Override // c.a.m.d.a
        public Intent a(Context context, IntentSenderRequest intentSenderRequest) {
            Bundle bundleExtra;
            IntentSenderRequest intentSenderRequest2 = intentSenderRequest;
            Intent intent = new Intent("androidx.activity.result.contract.action.INTENT_SENDER_REQUEST");
            Intent intent2 = intentSenderRequest2.f42e;
            if (intent2 != null && (bundleExtra = intent2.getBundleExtra("androidx.activity.result.contract.extra.ACTIVITY_OPTIONS_BUNDLE")) != null) {
                intent.putExtra("androidx.activity.result.contract.extra.ACTIVITY_OPTIONS_BUNDLE", bundleExtra);
                intent2.removeExtra("androidx.activity.result.contract.extra.ACTIVITY_OPTIONS_BUNDLE");
                if (intent2.getBooleanExtra("androidx.fragment.extra.ACTIVITY_OPTIONS_BUNDLE", false)) {
                    intentSenderRequest2 = new IntentSenderRequest(intentSenderRequest2.f41b, null, intentSenderRequest2.f43f, intentSenderRequest2.f44g);
                }
            }
            intent.putExtra("androidx.activity.result.contract.extra.INTENT_SENDER_REQUEST", intentSenderRequest2);
            if (FragmentManager.M(2)) {
                Log.v("FragmentManager", "CreateIntent created the following intent: " + intent);
            }
            return intent;
        }

        @Override // c.a.m.d.a
        public ActivityResult c(int i2, Intent intent) {
            return new ActivityResult(i2, intent);
        }
    }

    public interface k {
        boolean a(ArrayList<c.k.b.a> arrayList, ArrayList<Boolean> arrayList2);
    }

    public class l implements k {
        public final int a;

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        public final int f352b;

        public l(String str, int i2, int i3) {
            this.a = i2;
            this.f352b = i3;
        }

        @Override // androidx.fragment.app.FragmentManager.k
        public boolean a(ArrayList<c.k.b.a> arrayList, ArrayList<Boolean> arrayList2) {
            Fragment fragment = FragmentManager.this.t;
            if (fragment == null || this.a >= 0 || !fragment.getChildFragmentManager().V()) {
                return FragmentManager.this.W(arrayList, arrayList2, null, this.a, this.f352b);
            }
            return false;
        }
    }

    public static class m implements Fragment.l {
        public final boolean a;

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        public final c.k.b.a f354b;

        /* JADX INFO: renamed from: c, reason: collision with root package name */
        public int f355c;

        public void a() {
            boolean z = this.f355c > 0;
            for (Fragment fragment : this.f354b.p.f336c.i()) {
                fragment.setOnStartEnterTransitionListener(null);
                if (z && fragment.isPostponed()) {
                    fragment.startPostponedEnterTransition();
                }
            }
            c.k.b.a aVar = this.f354b;
            aVar.p.g(aVar, this.a, !z, true);
        }
    }

    public static boolean M(int i2) {
        return Log.isLoggable("FragmentManager", i2);
    }

    public void A(k kVar, boolean z) {
        if (!z) {
            if (this.q == null) {
                if (!this.D) {
                    throw new IllegalStateException("FragmentManager has not been attached to a host.");
                }
                throw new IllegalStateException("FragmentManager has been destroyed");
            }
            if (Q()) {
                throw new IllegalStateException("Can not perform this action after onSaveInstanceState");
            }
        }
        synchronized (this.a) {
            if (this.q == null) {
                if (!z) {
                    throw new IllegalStateException("Activity has been destroyed");
                }
            } else {
                this.a.add(kVar);
                b0();
            }
        }
    }

    public final void B(boolean z) {
        if (this.f335b) {
            throw new IllegalStateException("FragmentManager is already executing transactions");
        }
        if (this.q == null) {
            if (!this.D) {
                throw new IllegalStateException("FragmentManager has not been attached to a host.");
            }
            throw new IllegalStateException("FragmentManager has been destroyed");
        }
        if (Looper.myLooper() != this.q.f1741f.getLooper()) {
            throw new IllegalStateException("Must be called from main thread of fragment host");
        }
        if (!z && Q()) {
            throw new IllegalStateException("Can not perform this action after onSaveInstanceState");
        }
        if (this.F == null) {
            this.F = new ArrayList<>();
            this.G = new ArrayList<>();
        }
        this.f335b = true;
        try {
            F(null, null);
        } finally {
            this.f335b = false;
        }
    }

    public boolean C(boolean z) {
        boolean zA;
        B(z);
        boolean z2 = false;
        while (true) {
            ArrayList<c.k.b.a> arrayList = this.F;
            ArrayList<Boolean> arrayList2 = this.G;
            synchronized (this.a) {
                if (this.a.isEmpty()) {
                    zA = false;
                } else {
                    int size = this.a.size();
                    zA = false;
                    for (int i2 = 0; i2 < size; i2++) {
                        zA |= this.a.get(i2).a(arrayList, arrayList2);
                    }
                    this.a.clear();
                    this.q.f1741f.removeCallbacks(this.K);
                }
            }
            if (!zA) {
                i0();
                x();
                this.f336c.b();
                return z2;
            }
            this.f335b = true;
            try {
                Y(this.F, this.G);
                e();
                z2 = true;
            } catch (Throwable th) {
                e();
                throw th;
            }
        }
    }

    public void D(k kVar, boolean z) {
        if (z && (this.q == null || this.D)) {
            return;
        }
        B(z);
        ((c.k.b.a) kVar).a(this.F, this.G);
        this.f335b = true;
        try {
            Y(this.F, this.G);
            e();
            i0();
            x();
            this.f336c.b();
        } catch (Throwable th) {
            e();
            throw th;
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:61:0x014f  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public final void E(java.util.ArrayList<c.k.b.a> r20, java.util.ArrayList<java.lang.Boolean> r21, int r22, int r23) {
        /*
            Method dump skipped, instruction units count: 710
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: androidx.fragment.app.FragmentManager.E(java.util.ArrayList, java.util.ArrayList, int, int):void");
    }

    public final void F(ArrayList<c.k.b.a> arrayList, ArrayList<Boolean> arrayList2) {
        int iIndexOf;
        int iIndexOf2;
        ArrayList<m> arrayList3 = this.I;
        int size = arrayList3 == null ? 0 : arrayList3.size();
        int i2 = 0;
        while (i2 < size) {
            m mVar = this.I.get(i2);
            if (arrayList == null || mVar.a || (iIndexOf2 = arrayList.indexOf(mVar.f354b)) == -1 || arrayList2 == null || !arrayList2.get(iIndexOf2).booleanValue()) {
                if ((mVar.f355c == 0) || (arrayList != null && mVar.f354b.k(arrayList, 0, arrayList.size()))) {
                    this.I.remove(i2);
                    i2--;
                    size--;
                    if (arrayList == null || mVar.a || (iIndexOf = arrayList.indexOf(mVar.f354b)) == -1 || arrayList2 == null || !arrayList2.get(iIndexOf).booleanValue()) {
                        mVar.a();
                    } else {
                        c.k.b.a aVar = mVar.f354b;
                        aVar.p.g(aVar, mVar.a, false, false);
                    }
                }
            } else {
                this.I.remove(i2);
                i2--;
                size--;
                c.k.b.a aVar2 = mVar.f354b;
                aVar2.p.g(aVar2, mVar.a, false, false);
            }
            i2++;
        }
    }

    public Fragment G(String str) {
        return this.f336c.d(str);
    }

    public Fragment H(int i2) {
        c0 c0Var = this.f336c;
        int size = c0Var.a.size();
        while (true) {
            size--;
            if (size < 0) {
                for (b0 b0Var : c0Var.f1608b.values()) {
                    if (b0Var != null) {
                        Fragment fragment = b0Var.f1600c;
                        if (fragment.mFragmentId == i2) {
                            return fragment;
                        }
                    }
                }
                return null;
            }
            Fragment fragment2 = c0Var.a.get(size);
            if (fragment2 != null && fragment2.mFragmentId == i2) {
                return fragment2;
            }
        }
    }

    public final ViewGroup I(Fragment fragment) {
        ViewGroup viewGroup = fragment.mContainer;
        if (viewGroup != null) {
            return viewGroup;
        }
        if (fragment.mContainerId > 0 && this.r.c()) {
            View viewB = this.r.b(fragment.mContainerId);
            if (viewB instanceof ViewGroup) {
                return (ViewGroup) viewB;
            }
        }
        return null;
    }

    public u J() {
        Fragment fragment = this.s;
        return fragment != null ? fragment.mFragmentManager.J() : this.u;
    }

    public s0 K() {
        Fragment fragment = this.s;
        return fragment != null ? fragment.mFragmentManager.K() : this.v;
    }

    public void L(Fragment fragment) {
        if (M(2)) {
            Log.v("FragmentManager", "hide: " + fragment);
        }
        if (fragment.mHidden) {
            return;
        }
        fragment.mHidden = true;
        fragment.mHiddenChanged = true ^ fragment.mHiddenChanged;
        f0(fragment);
    }

    public final boolean N(Fragment fragment) {
        boolean z;
        if (fragment.mHasMenu && fragment.mMenuVisible) {
            return true;
        }
        FragmentManager fragmentManager = fragment.mChildFragmentManager;
        Iterator it = ((ArrayList) fragmentManager.f336c.g()).iterator();
        boolean zN = false;
        while (true) {
            if (!it.hasNext()) {
                z = false;
                break;
            }
            Fragment fragment2 = (Fragment) it.next();
            if (fragment2 != null) {
                zN = fragmentManager.N(fragment2);
            }
            if (zN) {
                z = true;
                break;
            }
        }
        return z;
    }

    public boolean O(Fragment fragment) {
        if (fragment == null) {
            return true;
        }
        return fragment.isMenuVisible();
    }

    public boolean P(Fragment fragment) {
        if (fragment == null) {
            return true;
        }
        FragmentManager fragmentManager = fragment.mFragmentManager;
        return fragment.equals(fragmentManager.t) && P(fragmentManager.s);
    }

    public boolean Q() {
        return this.B || this.C;
    }

    public void R(int i2, boolean z) {
        v<?> vVar;
        if (this.q == null && i2 != -1) {
            throw new IllegalStateException("No activity");
        }
        if (z || i2 != this.p) {
            this.p = i2;
            c0 c0Var = this.f336c;
            Iterator<Fragment> it = c0Var.a.iterator();
            while (it.hasNext()) {
                b0 b0Var = c0Var.f1608b.get(it.next().mWho);
                if (b0Var != null) {
                    b0Var.k();
                }
            }
            Iterator<b0> it2 = c0Var.f1608b.values().iterator();
            while (true) {
                boolean z2 = false;
                if (!it2.hasNext()) {
                    break;
                }
                b0 next = it2.next();
                if (next != null) {
                    next.k();
                    Fragment fragment = next.f1600c;
                    if (fragment.mRemoving && !fragment.isInBackStack()) {
                        z2 = true;
                    }
                    if (z2) {
                        c0Var.k(next);
                    }
                }
            }
            h0();
            if (this.A && (vVar = this.q) != null && this.p == 7) {
                vVar.h();
                this.A = false;
            }
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:103:0x01b5  */
    /* JADX WARN: Removed duplicated region for block: B:105:0x01b8  */
    /* JADX WARN: Removed duplicated region for block: B:32:0x006c  */
    /* JADX WARN: Removed duplicated region for block: B:34:0x0071  */
    /* JADX WARN: Removed duplicated region for block: B:36:0x0076  */
    /* JADX WARN: Removed duplicated region for block: B:38:0x007b  */
    /* JADX WARN: Removed duplicated region for block: B:40:0x0080  */
    /* JADX WARN: Removed duplicated region for block: B:97:0x01a5  */
    /* JADX WARN: Removed duplicated region for block: B:99:0x01a8  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public void S(androidx.fragment.app.Fragment r17, int r18) {
        /*
            Method dump skipped, instruction units count: 496
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: androidx.fragment.app.FragmentManager.S(androidx.fragment.app.Fragment, int):void");
    }

    public void T() {
        if (this.q == null) {
            return;
        }
        this.B = false;
        this.C = false;
        this.J.f1753j = false;
        for (Fragment fragment : this.f336c.i()) {
            if (fragment != null) {
                fragment.noteStateNotSaved();
            }
        }
    }

    public void U(b0 b0Var) {
        Fragment fragment = b0Var.f1600c;
        if (fragment.mDeferStart) {
            if (this.f335b) {
                this.E = true;
            } else {
                fragment.mDeferStart = false;
                b0Var.k();
            }
        }
    }

    public boolean V() {
        C(false);
        B(true);
        Fragment fragment = this.t;
        if (fragment != null && fragment.getChildFragmentManager().V()) {
            return true;
        }
        boolean zW = W(this.F, this.G, null, -1, 0);
        if (zW) {
            this.f335b = true;
            try {
                Y(this.F, this.G);
            } finally {
                e();
            }
        }
        i0();
        x();
        this.f336c.b();
        return zW;
    }

    public boolean W(ArrayList<c.k.b.a> arrayList, ArrayList<Boolean> arrayList2, String str, int i2, int i3) {
        ArrayList<c.k.b.a> arrayList3 = this.f337d;
        if (arrayList3 == null) {
            return false;
        }
        if (str == null && i2 < 0 && (i3 & 1) == 0) {
            int size = arrayList3.size() - 1;
            if (size < 0) {
                return false;
            }
            arrayList.add(this.f337d.remove(size));
            arrayList2.add(Boolean.TRUE);
        } else {
            int i4 = -1;
            if (str != null || i2 >= 0) {
                int size2 = arrayList3.size() - 1;
                while (size2 >= 0) {
                    c.k.b.a aVar = this.f337d.get(size2);
                    if ((str != null && str.equals(aVar.f1616h)) || (i2 >= 0 && i2 == aVar.r)) {
                        break;
                    }
                    size2--;
                }
                if (size2 < 0) {
                    return false;
                }
                if ((i3 & 1) != 0) {
                    while (true) {
                        size2--;
                        if (size2 < 0) {
                            break;
                        }
                        c.k.b.a aVar2 = this.f337d.get(size2);
                        if (str == null || !str.equals(aVar2.f1616h)) {
                            if (i2 < 0 || i2 != aVar2.r) {
                                break;
                            }
                        }
                    }
                }
                i4 = size2;
            }
            if (i4 == this.f337d.size() - 1) {
                return false;
            }
            for (int size3 = this.f337d.size() - 1; size3 > i4; size3--) {
                arrayList.add(this.f337d.remove(size3));
                arrayList2.add(Boolean.TRUE);
            }
        }
        return true;
    }

    public void X(Fragment fragment) {
        if (M(2)) {
            Log.v("FragmentManager", "remove: " + fragment + " nesting=" + fragment.mBackStackNesting);
        }
        boolean z = !fragment.isInBackStack();
        if (!fragment.mDetached || z) {
            this.f336c.l(fragment);
            if (N(fragment)) {
                this.A = true;
            }
            fragment.mRemoving = true;
            f0(fragment);
        }
    }

    public final void Y(ArrayList<c.k.b.a> arrayList, ArrayList<Boolean> arrayList2) {
        if (arrayList.isEmpty()) {
            return;
        }
        if (arrayList.size() != arrayList2.size()) {
            throw new IllegalStateException("Internal error with the back stack records");
        }
        F(arrayList, arrayList2);
        int size = arrayList.size();
        int i2 = 0;
        int i3 = 0;
        while (i2 < size) {
            if (!arrayList.get(i2).o) {
                if (i3 != i2) {
                    E(arrayList, arrayList2, i3, i2);
                }
                i3 = i2 + 1;
                if (arrayList2.get(i2).booleanValue()) {
                    while (i3 < size && arrayList2.get(i3).booleanValue() && !arrayList.get(i3).o) {
                        i3++;
                    }
                }
                E(arrayList, arrayList2, i2, i3);
                i2 = i3 - 1;
            }
            i2++;
        }
        if (i3 != size) {
            E(arrayList, arrayList2, i3, size);
        }
    }

    public void Z(Parcelable parcelable) {
        b0 b0Var;
        if (parcelable == null) {
            return;
        }
        FragmentManagerState fragmentManagerState = (FragmentManagerState) parcelable;
        if (fragmentManagerState.f356b == null) {
            return;
        }
        this.f336c.f1608b.clear();
        for (FragmentState fragmentState : fragmentManagerState.f356b) {
            if (fragmentState != null) {
                Fragment fragment = this.J.f1748e.get(fragmentState.f365e);
                if (fragment != null) {
                    if (M(2)) {
                        Log.v("FragmentManager", "restoreSaveState: re-attaching retained " + fragment);
                    }
                    b0Var = new b0(this.n, this.f336c, fragment, fragmentState);
                } else {
                    b0Var = new b0(this.n, this.f336c, this.q.f1740e.getClassLoader(), J(), fragmentState);
                }
                Fragment fragment2 = b0Var.f1600c;
                fragment2.mFragmentManager = this;
                if (M(2)) {
                    StringBuilder sbB = d.b.a.a.a.B("restoreSaveState: active (");
                    sbB.append(fragment2.mWho);
                    sbB.append("): ");
                    sbB.append(fragment2);
                    Log.v("FragmentManager", sbB.toString());
                }
                b0Var.m(this.q.f1740e.getClassLoader());
                this.f336c.j(b0Var);
                b0Var.f1602e = this.p;
            }
        }
        z zVar = this.J;
        Objects.requireNonNull(zVar);
        for (Fragment fragment3 : new ArrayList(zVar.f1748e.values())) {
            if (!this.f336c.c(fragment3.mWho)) {
                if (M(2)) {
                    Log.v("FragmentManager", "Discarding retained Fragment " + fragment3 + " that was not found in the set of active Fragments " + fragmentManagerState.f356b);
                }
                this.J.d(fragment3);
                fragment3.mFragmentManager = this;
                b0 b0Var2 = new b0(this.n, this.f336c, fragment3);
                b0Var2.f1602e = 1;
                b0Var2.k();
                fragment3.mRemoving = true;
                b0Var2.k();
            }
        }
        c0 c0Var = this.f336c;
        ArrayList<String> arrayList = fragmentManagerState.f357e;
        c0Var.a.clear();
        if (arrayList != null) {
            for (String str : arrayList) {
                Fragment fragmentD = c0Var.d(str);
                if (fragmentD == null) {
                    throw new IllegalStateException(d.b.a.a.a.q("No instantiated fragment for (", str, ")"));
                }
                if (M(2)) {
                    Log.v("FragmentManager", "restoreSaveState: added (" + str + "): " + fragmentD);
                }
                c0Var.a(fragmentD);
            }
        }
        Fragment fragment4 = null;
        if (fragmentManagerState.f358f != null) {
            this.f337d = new ArrayList<>(fragmentManagerState.f358f.length);
            int i2 = 0;
            while (true) {
                BackStackState[] backStackStateArr = fragmentManagerState.f358f;
                if (i2 >= backStackStateArr.length) {
                    break;
                }
                BackStackState backStackState = backStackStateArr[i2];
                Objects.requireNonNull(backStackState);
                c.k.b.a aVar = new c.k.b.a(this);
                int i3 = 0;
                int i4 = 0;
                while (true) {
                    int[] iArr = backStackState.f307b;
                    if (i3 >= iArr.length) {
                        break;
                    }
                    d0.a aVar2 = new d0.a();
                    int i5 = i3 + 1;
                    aVar2.a = iArr[i3];
                    if (M(2)) {
                        Log.v("FragmentManager", "Instantiate " + aVar + " op #" + i4 + " base fragment #" + backStackState.f307b[i5]);
                    }
                    String str2 = backStackState.f308e.get(i4);
                    if (str2 != null) {
                        aVar2.f1621b = this.f336c.d(str2);
                    } else {
                        aVar2.f1621b = fragment4;
                    }
                    aVar2.f1626g = j.b.values()[backStackState.f309f[i4]];
                    aVar2.f1627h = j.b.values()[backStackState.f310g[i4]];
                    int[] iArr2 = backStackState.f307b;
                    int i6 = i5 + 1;
                    int i7 = iArr2[i5];
                    aVar2.f1622c = i7;
                    int i8 = i6 + 1;
                    int i9 = iArr2[i6];
                    aVar2.f1623d = i9;
                    int i10 = i8 + 1;
                    int i11 = iArr2[i8];
                    aVar2.f1624e = i11;
                    int i12 = iArr2[i10];
                    aVar2.f1625f = i12;
                    aVar.f1610b = i7;
                    aVar.f1611c = i9;
                    aVar.f1612d = i11;
                    aVar.f1613e = i12;
                    aVar.b(aVar2);
                    i4++;
                    fragment4 = null;
                    i3 = i10 + 1;
                }
                aVar.f1614f = backStackState.f311h;
                aVar.f1616h = backStackState.f312i;
                aVar.r = backStackState.f313j;
                aVar.f1615g = true;
                aVar.f1617i = backStackState.f314k;
                aVar.f1618j = backStackState.f315l;
                aVar.f1619k = backStackState.m;
                aVar.f1620l = backStackState.n;
                aVar.m = backStackState.o;
                aVar.n = backStackState.p;
                aVar.o = backStackState.q;
                aVar.e(1);
                if (M(2)) {
                    StringBuilder sbC = d.b.a.a.a.C("restoreAllState: back stack #", i2, " (index ");
                    sbC.append(aVar.r);
                    sbC.append("): ");
                    sbC.append(aVar);
                    Log.v("FragmentManager", sbC.toString());
                    PrintWriter printWriter = new PrintWriter(new q0("FragmentManager"));
                    aVar.g("  ", printWriter, false);
                    printWriter.close();
                }
                this.f337d.add(aVar);
                i2++;
                fragment4 = null;
            }
        } else {
            this.f337d = null;
        }
        this.f342i.set(fragmentManagerState.f359g);
        String str3 = fragmentManagerState.f360h;
        if (str3 != null) {
            Fragment fragmentG = G(str3);
            this.t = fragmentG;
            t(fragmentG);
        }
        ArrayList<String> arrayList2 = fragmentManagerState.f361i;
        if (arrayList2 != null) {
            for (int i13 = 0; i13 < arrayList2.size(); i13++) {
                Bundle bundle = fragmentManagerState.f362j.get(i13);
                bundle.setClassLoader(this.q.f1740e.getClassLoader());
                this.f343j.put(arrayList2.get(i13), bundle);
            }
        }
        this.z = new ArrayDeque<>(fragmentManagerState.f363k);
    }

    public b0 a(Fragment fragment) {
        if (M(2)) {
            Log.v("FragmentManager", "add: " + fragment);
        }
        b0 b0VarH = h(fragment);
        fragment.mFragmentManager = this;
        this.f336c.j(b0VarH);
        if (!fragment.mDetached) {
            this.f336c.a(fragment);
            fragment.mRemoving = false;
            if (fragment.mView == null) {
                fragment.mHiddenChanged = false;
            }
            if (N(fragment)) {
                this.A = true;
            }
        }
        return b0VarH;
    }

    public Parcelable a0() {
        int i2;
        BackStackState[] backStackStateArr;
        ArrayList<String> arrayList;
        int size;
        Iterator it = ((HashSet) f()).iterator();
        while (true) {
            if (!it.hasNext()) {
                break;
            }
            r0 r0Var = (r0) it.next();
            if (r0Var.f1723e) {
                r0Var.f1723e = false;
                r0Var.c();
            }
        }
        z();
        C(true);
        this.B = true;
        this.J.f1753j = true;
        c0 c0Var = this.f336c;
        Objects.requireNonNull(c0Var);
        ArrayList<FragmentState> arrayList2 = new ArrayList<>(c0Var.f1608b.size());
        Iterator<b0> it2 = c0Var.f1608b.values().iterator();
        while (true) {
            backStackStateArr = null;
            backStackStateArr = null;
            if (!it2.hasNext()) {
                break;
            }
            b0 next = it2.next();
            if (next != null) {
                Fragment fragment = next.f1600c;
                FragmentState fragmentState = new FragmentState(fragment);
                Fragment fragment2 = next.f1600c;
                if (fragment2.mState <= -1 || fragmentState.p != null) {
                    fragmentState.p = fragment2.mSavedFragmentState;
                } else {
                    Bundle bundle = new Bundle();
                    next.f1600c.performSaveInstanceState(bundle);
                    next.a.j(next.f1600c, bundle, false);
                    Bundle bundle2 = bundle.isEmpty() ? null : bundle;
                    if (next.f1600c.mView != null) {
                        next.o();
                    }
                    if (next.f1600c.mSavedViewState != null) {
                        if (bundle2 == null) {
                            bundle2 = new Bundle();
                        }
                        bundle2.putSparseParcelableArray("android:view_state", next.f1600c.mSavedViewState);
                    }
                    if (next.f1600c.mSavedViewRegistryState != null) {
                        if (bundle2 == null) {
                            bundle2 = new Bundle();
                        }
                        bundle2.putBundle("android:view_registry_state", next.f1600c.mSavedViewRegistryState);
                    }
                    if (!next.f1600c.mUserVisibleHint) {
                        if (bundle2 == null) {
                            bundle2 = new Bundle();
                        }
                        bundle2.putBoolean("android:user_visible_hint", next.f1600c.mUserVisibleHint);
                    }
                    fragmentState.p = bundle2;
                    if (next.f1600c.mTargetWho != null) {
                        if (bundle2 == null) {
                            fragmentState.p = new Bundle();
                        }
                        fragmentState.p.putString("android:target_state", next.f1600c.mTargetWho);
                        int i3 = next.f1600c.mTargetRequestCode;
                        if (i3 != 0) {
                            fragmentState.p.putInt("android:target_req_state", i3);
                        }
                    }
                }
                arrayList2.add(fragmentState);
                if (M(2)) {
                    Log.v("FragmentManager", "Saved state of " + fragment + ": " + fragmentState.p);
                }
            }
        }
        if (arrayList2.isEmpty()) {
            if (M(2)) {
                Log.v("FragmentManager", "saveAllState: no fragments!");
            }
            return null;
        }
        c0 c0Var2 = this.f336c;
        synchronized (c0Var2.a) {
            if (c0Var2.a.isEmpty()) {
                arrayList = null;
            } else {
                arrayList = new ArrayList<>(c0Var2.a.size());
                for (Fragment fragment3 : c0Var2.a) {
                    arrayList.add(fragment3.mWho);
                    if (M(2)) {
                        Log.v("FragmentManager", "saveAllState: adding fragment (" + fragment3.mWho + "): " + fragment3);
                    }
                }
            }
        }
        ArrayList<c.k.b.a> arrayList3 = this.f337d;
        if (arrayList3 != null && (size = arrayList3.size()) > 0) {
            backStackStateArr = new BackStackState[size];
            for (i2 = 0; i2 < size; i2++) {
                backStackStateArr[i2] = new BackStackState(this.f337d.get(i2));
                if (M(2)) {
                    StringBuilder sbC = d.b.a.a.a.C("saveAllState: adding back stack #", i2, ": ");
                    sbC.append(this.f337d.get(i2));
                    Log.v("FragmentManager", sbC.toString());
                }
            }
        }
        FragmentManagerState fragmentManagerState = new FragmentManagerState();
        fragmentManagerState.f356b = arrayList2;
        fragmentManagerState.f357e = arrayList;
        fragmentManagerState.f358f = backStackStateArr;
        fragmentManagerState.f359g = this.f342i.get();
        Fragment fragment4 = this.t;
        if (fragment4 != null) {
            fragmentManagerState.f360h = fragment4.mWho;
        }
        fragmentManagerState.f361i.addAll(this.f343j.keySet());
        fragmentManagerState.f362j.addAll(this.f343j.values());
        fragmentManagerState.f363k = new ArrayList<>(this.z);
        return fragmentManagerState;
    }

    /* JADX WARN: Multi-variable type inference failed */
    @SuppressLint({"SyntheticAccessor"})
    public void b(v<?> vVar, r rVar, Fragment fragment) {
        if (this.q != null) {
            throw new IllegalStateException("Already attached");
        }
        this.q = vVar;
        this.r = rVar;
        this.s = fragment;
        if (fragment != null) {
            this.o.add(new h(this, fragment));
        } else if (vVar instanceof a0) {
            this.o.add((a0) vVar);
        }
        if (this.s != null) {
            i0();
        }
        if (vVar instanceof c.a.k) {
            c.a.k kVar = (c.a.k) vVar;
            OnBackPressedDispatcher onBackPressedDispatcher = kVar.getOnBackPressedDispatcher();
            this.f340g = onBackPressedDispatcher;
            n nVar = kVar;
            if (fragment != null) {
                nVar = fragment;
            }
            c.a.j jVar = this.f341h;
            Objects.requireNonNull(onBackPressedDispatcher);
            c.l.j lifecycle = nVar.getLifecycle();
            if (lifecycle.b() != j.b.DESTROYED) {
                jVar.f530b.add(onBackPressedDispatcher.new LifecycleOnBackPressedCancellable(lifecycle, jVar));
                if (c.f.b.h.s()) {
                    onBackPressedDispatcher.b();
                    jVar.f531c = onBackPressedDispatcher.f15c;
                }
            }
        }
        if (fragment != null) {
            z zVar = fragment.mFragmentManager.J;
            z zVar2 = zVar.f1749f.get(fragment.mWho);
            if (zVar2 == null) {
                zVar2 = new z(zVar.f1751h);
                zVar.f1749f.put(fragment.mWho, zVar2);
            }
            this.J = zVar2;
        } else if (vVar instanceof h0) {
            g0 viewModelStore = ((h0) vVar).getViewModelStore();
            f0.b bVar = z.f1747d;
            g.h0.c.l.f(viewModelStore, "store");
            g.h0.c.l.f(bVar, "factory");
            this.J = (z) new f0(viewModelStore, bVar, a.C0020a.f1776b).a(z.class);
        } else {
            this.J = new z(false);
        }
        this.J.f1753j = Q();
        this.f336c.f1609c = this.J;
        Object obj = this.q;
        if (obj instanceof c.a.m.c) {
            ActivityResultRegistry activityResultRegistry = ((c.a.m.c) obj).getActivityResultRegistry();
            String strP = d.b.a.a.a.p("FragmentManager:", fragment != null ? d.b.a.a.a.v(new StringBuilder(), fragment.mWho, ":") : "");
            this.w = activityResultRegistry.c(d.b.a.a.a.p(strP, "StartActivityForResult"), new c.a.m.d.c(), new i());
            this.x = activityResultRegistry.c(d.b.a.a.a.p(strP, "StartIntentSenderForResult"), new j(), new a());
            this.y = activityResultRegistry.c(d.b.a.a.a.p(strP, "RequestPermissions"), new c.a.m.d.b(), new b());
        }
    }

    public void b0() {
        synchronized (this.a) {
            ArrayList<m> arrayList = this.I;
            boolean z = (arrayList == null || arrayList.isEmpty()) ? false : true;
            boolean z2 = this.a.size() == 1;
            if (z || z2) {
                this.q.f1741f.removeCallbacks(this.K);
                this.q.f1741f.post(this.K);
                i0();
            }
        }
    }

    public void c(Fragment fragment) {
        if (M(2)) {
            Log.v("FragmentManager", "attach: " + fragment);
        }
        if (fragment.mDetached) {
            fragment.mDetached = false;
            if (fragment.mAdded) {
                return;
            }
            this.f336c.a(fragment);
            if (M(2)) {
                Log.v("FragmentManager", "add from attach: " + fragment);
            }
            if (N(fragment)) {
                this.A = true;
            }
        }
    }

    public void c0(Fragment fragment, boolean z) {
        ViewGroup viewGroupI = I(fragment);
        if (viewGroupI == null || !(viewGroupI instanceof s)) {
            return;
        }
        ((s) viewGroupI).setDrawDisappearingViewsLast(!z);
    }

    public final void d(Fragment fragment) {
        HashSet<c.f.f.c> hashSet = this.f345l.get(fragment);
        if (hashSet != null) {
            Iterator<c.f.f.c> it = hashSet.iterator();
            while (it.hasNext()) {
                it.next().a();
            }
            hashSet.clear();
            i(fragment);
            this.f345l.remove(fragment);
        }
    }

    public void d0(Fragment fragment, j.b bVar) {
        if (fragment.equals(G(fragment.mWho)) && (fragment.mHost == null || fragment.mFragmentManager == this)) {
            fragment.mMaxState = bVar;
            return;
        }
        throw new IllegalArgumentException("Fragment " + fragment + " is not an active fragment of FragmentManager " + this);
    }

    public final void e() {
        this.f335b = false;
        this.G.clear();
        this.F.clear();
    }

    public void e0(Fragment fragment) {
        if (fragment == null || (fragment.equals(G(fragment.mWho)) && (fragment.mHost == null || fragment.mFragmentManager == this))) {
            Fragment fragment2 = this.t;
            this.t = fragment;
            t(fragment2);
            t(this.t);
            return;
        }
        throw new IllegalArgumentException("Fragment " + fragment + " is not an active fragment of FragmentManager " + this);
    }

    public final Set<r0> f() {
        HashSet hashSet = new HashSet();
        Iterator it = ((ArrayList) this.f336c.f()).iterator();
        while (it.hasNext()) {
            ViewGroup viewGroup = ((b0) it.next()).f1600c.mContainer;
            if (viewGroup != null) {
                hashSet.add(r0.g(viewGroup, K()));
            }
        }
        return hashSet;
    }

    public final void f0(Fragment fragment) {
        ViewGroup viewGroupI = I(fragment);
        if (viewGroupI != null) {
            if (fragment.getPopExitAnim() + fragment.getPopEnterAnim() + fragment.getExitAnim() + fragment.getEnterAnim() > 0) {
                if (viewGroupI.getTag(R.id.visible_removing_fragment_view_tag) == null) {
                    viewGroupI.setTag(R.id.visible_removing_fragment_view_tag, fragment);
                }
                ((Fragment) viewGroupI.getTag(R.id.visible_removing_fragment_view_tag)).setPopDirection(fragment.getPopDirection());
            }
        }
    }

    public void g(c.k.b.a aVar, boolean z, boolean z2, boolean z3) {
        if (z) {
            aVar.i(z3);
        } else {
            aVar.h();
        }
        ArrayList arrayList = new ArrayList(1);
        ArrayList arrayList2 = new ArrayList(1);
        arrayList.add(aVar);
        arrayList2.add(Boolean.valueOf(z));
        if (z2 && this.p >= 1) {
            k0.q(this.q.f1740e, this.r, arrayList, arrayList2, 0, 1, true, this.m);
        }
        if (z3) {
            R(this.p, true);
        }
        for (Fragment fragment : (ArrayList) this.f336c.g()) {
            if (fragment != null && fragment.mView != null && fragment.mIsNewlyAdded && aVar.j(fragment.mContainerId)) {
                float f2 = fragment.mPostponedAlpha;
                if (f2 > 0.0f) {
                    fragment.mView.setAlpha(f2);
                }
                if (z3) {
                    fragment.mPostponedAlpha = 0.0f;
                } else {
                    fragment.mPostponedAlpha = -1.0f;
                    fragment.mIsNewlyAdded = false;
                }
            }
        }
    }

    public void g0(Fragment fragment) {
        if (M(2)) {
            Log.v("FragmentManager", "show: " + fragment);
        }
        if (fragment.mHidden) {
            fragment.mHidden = false;
            fragment.mHiddenChanged = !fragment.mHiddenChanged;
        }
    }

    public b0 h(Fragment fragment) {
        b0 b0VarH = this.f336c.h(fragment.mWho);
        if (b0VarH != null) {
            return b0VarH;
        }
        b0 b0Var = new b0(this.n, this.f336c, fragment);
        b0Var.m(this.q.f1740e.getClassLoader());
        b0Var.f1602e = this.p;
        return b0Var;
    }

    public final void h0() {
        Iterator it = ((ArrayList) this.f336c.f()).iterator();
        while (it.hasNext()) {
            U((b0) it.next());
        }
    }

    public final void i(Fragment fragment) {
        fragment.performDestroyView();
        this.n.n(fragment, false);
        fragment.mContainer = null;
        fragment.mView = null;
        fragment.mViewLifecycleOwner = null;
        fragment.mViewLifecycleOwnerLiveData.i(null);
        fragment.mInLayout = false;
    }

    public final void i0() {
        synchronized (this.a) {
            if (!this.a.isEmpty()) {
                c.a.j jVar = this.f341h;
                jVar.a = true;
                c.f.i.a<Boolean> aVar = jVar.f531c;
                if (aVar != null) {
                    aVar.accept(Boolean.TRUE);
                }
                return;
            }
            c.a.j jVar2 = this.f341h;
            ArrayList<c.k.b.a> arrayList = this.f337d;
            boolean z = (arrayList != null ? arrayList.size() : 0) > 0 && P(this.s);
            jVar2.a = z;
            c.f.i.a<Boolean> aVar2 = jVar2.f531c;
            if (aVar2 != null) {
                aVar2.accept(Boolean.valueOf(z));
            }
        }
    }

    public void j(Fragment fragment) {
        if (M(2)) {
            Log.v("FragmentManager", "detach: " + fragment);
        }
        if (fragment.mDetached) {
            return;
        }
        fragment.mDetached = true;
        if (fragment.mAdded) {
            if (M(2)) {
                Log.v("FragmentManager", "remove from detach: " + fragment);
            }
            this.f336c.l(fragment);
            if (N(fragment)) {
                this.A = true;
            }
            f0(fragment);
        }
    }

    public void k(Configuration configuration) {
        for (Fragment fragment : this.f336c.i()) {
            if (fragment != null) {
                fragment.performConfigurationChanged(configuration);
            }
        }
    }

    public boolean l(MenuItem menuItem) {
        if (this.p < 1) {
            return false;
        }
        for (Fragment fragment : this.f336c.i()) {
            if (fragment != null && fragment.performContextItemSelected(menuItem)) {
                return true;
            }
        }
        return false;
    }

    public void m() {
        this.B = false;
        this.C = false;
        this.J.f1753j = false;
        w(1);
    }

    public boolean n(Menu menu, MenuInflater menuInflater) {
        if (this.p < 1) {
            return false;
        }
        ArrayList<Fragment> arrayList = null;
        boolean z = false;
        for (Fragment fragment : this.f336c.i()) {
            if (fragment != null && O(fragment) && fragment.performCreateOptionsMenu(menu, menuInflater)) {
                if (arrayList == null) {
                    arrayList = new ArrayList<>();
                }
                arrayList.add(fragment);
                z = true;
            }
        }
        if (this.f338e != null) {
            for (int i2 = 0; i2 < this.f338e.size(); i2++) {
                Fragment fragment2 = this.f338e.get(i2);
                if (arrayList == null || !arrayList.contains(fragment2)) {
                    fragment2.onDestroyOptionsMenu();
                }
            }
        }
        this.f338e = arrayList;
        return z;
    }

    public void o() {
        this.D = true;
        C(true);
        z();
        w(-1);
        this.q = null;
        this.r = null;
        this.s = null;
        if (this.f340g != null) {
            Iterator<c.a.h> it = this.f341h.f530b.iterator();
            while (it.hasNext()) {
                it.next().cancel();
            }
            this.f340g = null;
        }
        c.a.m.b<Intent> bVar = this.w;
        if (bVar != null) {
            bVar.b();
            this.x.b();
            this.y.b();
        }
    }

    public void p() {
        for (Fragment fragment : this.f336c.i()) {
            if (fragment != null) {
                fragment.performLowMemory();
            }
        }
    }

    public void q(boolean z) {
        for (Fragment fragment : this.f336c.i()) {
            if (fragment != null) {
                fragment.performMultiWindowModeChanged(z);
            }
        }
    }

    public boolean r(MenuItem menuItem) {
        if (this.p < 1) {
            return false;
        }
        for (Fragment fragment : this.f336c.i()) {
            if (fragment != null && fragment.performOptionsItemSelected(menuItem)) {
                return true;
            }
        }
        return false;
    }

    public void s(Menu menu) {
        if (this.p < 1) {
            return;
        }
        for (Fragment fragment : this.f336c.i()) {
            if (fragment != null) {
                fragment.performOptionsMenuClosed(menu);
            }
        }
    }

    public final void t(Fragment fragment) {
        if (fragment == null || !fragment.equals(G(fragment.mWho))) {
            return;
        }
        fragment.performPrimaryNavigationFragmentChanged();
    }

    public String toString() {
        StringBuilder sb = new StringBuilder(128);
        sb.append("FragmentManager{");
        sb.append(Integer.toHexString(System.identityHashCode(this)));
        sb.append(" in ");
        Fragment fragment = this.s;
        if (fragment != null) {
            sb.append(fragment.getClass().getSimpleName());
            sb.append("{");
            sb.append(Integer.toHexString(System.identityHashCode(this.s)));
            sb.append("}");
        } else {
            v<?> vVar = this.q;
            if (vVar != null) {
                sb.append(vVar.getClass().getSimpleName());
                sb.append("{");
                sb.append(Integer.toHexString(System.identityHashCode(this.q)));
                sb.append("}");
            } else {
                sb.append("null");
            }
        }
        sb.append("}}");
        return sb.toString();
    }

    public void u(boolean z) {
        for (Fragment fragment : this.f336c.i()) {
            if (fragment != null) {
                fragment.performPictureInPictureModeChanged(z);
            }
        }
    }

    public boolean v(Menu menu) {
        boolean z = false;
        if (this.p < 1) {
            return false;
        }
        for (Fragment fragment : this.f336c.i()) {
            if (fragment != null && O(fragment) && fragment.performPrepareOptionsMenu(menu)) {
                z = true;
            }
        }
        return z;
    }

    public final void w(int i2) {
        try {
            this.f335b = true;
            for (b0 b0Var : this.f336c.f1608b.values()) {
                if (b0Var != null) {
                    b0Var.f1602e = i2;
                }
            }
            R(i2, false);
            Iterator it = ((HashSet) f()).iterator();
            while (it.hasNext()) {
                ((r0) it.next()).e();
            }
            this.f335b = false;
            C(true);
        } catch (Throwable th) {
            this.f335b = false;
            throw th;
        }
    }

    public final void x() {
        if (this.E) {
            this.E = false;
            h0();
        }
    }

    public void y(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
        int size;
        int size2;
        String strP = d.b.a.a.a.p(str, "    ");
        c0 c0Var = this.f336c;
        Objects.requireNonNull(c0Var);
        String str2 = str + "    ";
        if (!c0Var.f1608b.isEmpty()) {
            printWriter.print(str);
            printWriter.println("Active Fragments:");
            for (b0 b0Var : c0Var.f1608b.values()) {
                printWriter.print(str);
                if (b0Var != null) {
                    Fragment fragment = b0Var.f1600c;
                    printWriter.println(fragment);
                    fragment.dump(str2, fileDescriptor, printWriter, strArr);
                } else {
                    printWriter.println("null");
                }
            }
        }
        int size3 = c0Var.a.size();
        if (size3 > 0) {
            printWriter.print(str);
            printWriter.println("Added Fragments:");
            for (int i2 = 0; i2 < size3; i2++) {
                Fragment fragment2 = c0Var.a.get(i2);
                printWriter.print(str);
                printWriter.print("  #");
                printWriter.print(i2);
                printWriter.print(": ");
                printWriter.println(fragment2.toString());
            }
        }
        ArrayList<Fragment> arrayList = this.f338e;
        if (arrayList != null && (size2 = arrayList.size()) > 0) {
            printWriter.print(str);
            printWriter.println("Fragments Created Menus:");
            for (int i3 = 0; i3 < size2; i3++) {
                Fragment fragment3 = this.f338e.get(i3);
                printWriter.print(str);
                printWriter.print("  #");
                printWriter.print(i3);
                printWriter.print(": ");
                printWriter.println(fragment3.toString());
            }
        }
        ArrayList<c.k.b.a> arrayList2 = this.f337d;
        if (arrayList2 != null && (size = arrayList2.size()) > 0) {
            printWriter.print(str);
            printWriter.println("Back Stack:");
            for (int i4 = 0; i4 < size; i4++) {
                c.k.b.a aVar = this.f337d.get(i4);
                printWriter.print(str);
                printWriter.print("  #");
                printWriter.print(i4);
                printWriter.print(": ");
                printWriter.println(aVar.toString());
                aVar.g(strP, printWriter, true);
            }
        }
        printWriter.print(str);
        printWriter.println("Back Stack Index: " + this.f342i.get());
        synchronized (this.a) {
            int size4 = this.a.size();
            if (size4 > 0) {
                printWriter.print(str);
                printWriter.println("Pending Actions:");
                for (int i5 = 0; i5 < size4; i5++) {
                    Object obj = (k) this.a.get(i5);
                    printWriter.print(str);
                    printWriter.print("  #");
                    printWriter.print(i5);
                    printWriter.print(": ");
                    printWriter.println(obj);
                }
            }
        }
        printWriter.print(str);
        printWriter.println("FragmentManager misc state:");
        printWriter.print(str);
        printWriter.print("  mHost=");
        printWriter.println(this.q);
        printWriter.print(str);
        printWriter.print("  mContainer=");
        printWriter.println(this.r);
        if (this.s != null) {
            printWriter.print(str);
            printWriter.print("  mParent=");
            printWriter.println(this.s);
        }
        printWriter.print(str);
        printWriter.print("  mCurState=");
        printWriter.print(this.p);
        printWriter.print(" mStateSaved=");
        printWriter.print(this.B);
        printWriter.print(" mStopped=");
        printWriter.print(this.C);
        printWriter.print(" mDestroyed=");
        printWriter.println(this.D);
        if (this.A) {
            printWriter.print(str);
            printWriter.print("  mNeedMenuInvalidate=");
            printWriter.println(this.A);
        }
    }

    public final void z() {
        Iterator it = ((HashSet) f()).iterator();
        while (it.hasNext()) {
            ((r0) it.next()).e();
        }
    }

    @SuppressLint({"BanParcelableUsage"})
    public static class LaunchedFragmentInfo implements Parcelable {
        public static final Parcelable.Creator<LaunchedFragmentInfo> CREATOR = new a();

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        public String f346b;

        /* JADX INFO: renamed from: e, reason: collision with root package name */
        public int f347e;

        public class a implements Parcelable.Creator<LaunchedFragmentInfo> {
            @Override // android.os.Parcelable.Creator
            public LaunchedFragmentInfo createFromParcel(Parcel parcel) {
                return new LaunchedFragmentInfo(parcel);
            }

            @Override // android.os.Parcelable.Creator
            public LaunchedFragmentInfo[] newArray(int i2) {
                return new LaunchedFragmentInfo[i2];
            }
        }

        public LaunchedFragmentInfo(String str, int i2) {
            this.f346b = str;
            this.f347e = i2;
        }

        @Override // android.os.Parcelable
        public int describeContents() {
            return 0;
        }

        @Override // android.os.Parcelable
        public void writeToParcel(Parcel parcel, int i2) {
            parcel.writeString(this.f346b);
            parcel.writeInt(this.f347e);
        }

        public LaunchedFragmentInfo(Parcel parcel) {
            this.f346b = parcel.readString();
            this.f347e = parcel.readInt();
        }
    }
}