Kaspi.kz v5.85.1 - bSO.java 源代码

package o;

import java.io.IOException;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

public class bSO extends bNa {
    public static final bNc AudioAttributesCompatParcelizer;
    public static final Hashtable AudioAttributesImplApi21Parcelizer;
    public static final bNc AudioAttributesImplApi26Parcelizer;
    public static boolean AudioAttributesImplBaseParcelizer;
    public static final Hashtable ComponentActivity2;
    public static final bNc ComponentActivity3;
    public static final bNc ComponentActivity4;
    public static final bNc ComponentActivity6;
    public static final Hashtable IconCompatParcelizer;
    public static final bNc MediaBrowserCompatCustomActionResultReceiver;
    public static final bNc MediaBrowserCompatItemReceiver;
    public static final bNc MediaBrowserCompatMediaItem;
    public static final bNc MediaBrowserCompatSearchResultReceiver;
    public static final bNc MediaControllerCompatMediaControllerImplApi21ExtraBinderRequestResultReceiver;
    public static final bNc MediaDescriptionCompat;
    public static final bNc MediaMetadataCompat;
    public static final bNc MediaSessionCompatQueueItem;
    public static final bNc MediaSessionCompatResultReceiverWrapper;
    public static final Hashtable MediaSessionCompatToken;
    public static final bNc ParcelableVolumeInfo;
    public static final Hashtable PlaybackStateCompat;
    public static final bNc PlaybackStateCompatCustomAction;
    public static final bNc RatingCompat;
    public static final bNc RemoteActionCompatParcelizer;
    public static final bNc addContentView;
    public static final bNc getLifecycle;
    public static final bNc getLifecycleRegistry;
    public static final bNc getOnBackPressedDispatcher;
    public static final Hashtable getOnBackPressedDispatcherannotations;
    private static final Boolean getSavedStateRegistry;
    public static final bNc initializeViewTreeOwners;
    public static final bNc onBackPressed;
    public static final bNc onBackPressedDispatcherlambda1;
    private static final Boolean onCreate;
    public static final bNc r8lambdaqrzmfDOyDuplJFtpJLozn3P9EZI;
    public static final bNc read;
    public static final bNc setBackground;
    public static final bNc setContentView;
    public static final bNc setElement;
    public static final bNc setError;
    public static final bNc setFieldValue;
    public static final bNc setLabel;
    public static final bNc setOptions;
    public static final bNc write;
    private bSR ActivityResultRegistry1;
    private int ImmLeaksCleaner;
    private Vector OnBackPressedDispatcherLifecycleOnBackPressedCancellable;
    private Vector onSaveInstanceState;
    private boolean onStart;
    private bNh onStop;
    private Vector valueOf;

    static {
        bNc bnc = new bNc("2.5.4.6");
        setBackground = bnc;
        bNc bnc2 = new bNc("2.5.4.10");
        MediaSessionCompatResultReceiverWrapper = bnc2;
        bNc bnc3 = new bNc("2.5.4.11");
        MediaSessionCompatQueueItem = bnc3;
        bNc bnc4 = new bNc("2.5.4.12");
        getOnBackPressedDispatcher = bnc4;
        bNc bnc5 = new bNc("2.5.4.3");
        setFieldValue = bnc5;
        bNc bnc6 = new bNc("2.5.4.5");
        ComponentActivity6 = bnc6;
        bNc bnc7 = new bNc("2.5.4.9");
        r8lambdaqrzmfDOyDuplJFtpJLozn3P9EZI = bnc7;
        getLifecycleRegistry = bnc6;
        bNc bnc8 = new bNc("2.5.4.7");
        MediaBrowserCompatMediaItem = bnc8;
        bNc bnc9 = new bNc("2.5.4.8");
        ComponentActivity3 = bnc9;
        bNc bnc10 = new bNc("2.5.4.4");
        ComponentActivity4 = bnc10;
        bNc bnc11 = new bNc("2.5.4.42");
        MediaMetadataCompat = bnc11;
        bNc bnc12 = new bNc("2.5.4.43");
        MediaBrowserCompatSearchResultReceiver = bnc12;
        bNc bnc13 = new bNc("2.5.4.44");
        MediaDescriptionCompat = bnc13;
        bNc bnc14 = new bNc("2.5.4.45");
        onBackPressedDispatcherlambda1 = bnc14;
        bNc bnc15 = new bNc("2.5.4.15");
        setError = bnc15;
        bNc bnc16 = new bNc("2.5.4.17");
        setContentView = bnc16;
        bNc bnc17 = new bNc("2.5.4.46");
        read = bnc17;
        bNc bnc18 = new bNc("2.5.4.65");
        PlaybackStateCompatCustomAction = bnc18;
        bNc bnc19 = new bNc("1.3.6.1.5.5.7.9.1");
        setElement = bnc19;
        bNc bnc20 = new bNc("1.3.6.1.5.5.7.9.2");
        RatingCompat = bnc20;
        bNc bnc21 = new bNc("1.3.6.1.5.5.7.9.3");
        AudioAttributesCompatParcelizer = bnc21;
        bNc bnc22 = new bNc("1.3.6.1.5.5.7.9.4");
        setOptions = bnc22;
        bNc bnc23 = new bNc("1.3.6.1.5.5.7.9.5");
        setLabel = bnc23;
        bNc bnc24 = new bNc("1.3.36.8.3.14");
        MediaControllerCompatMediaControllerImplApi21ExtraBinderRequestResultReceiver = bnc24;
        bNc bnc25 = new bNc("2.5.4.16");
        ParcelableVolumeInfo = bnc25;
        write = new bNc("2.5.4.54");
        bNc bnc26 = bSN.AudioAttributesImplBaseParcelizer;
        addContentView = bnc26;
        bNc bnc27 = bSN.write;
        MediaBrowserCompatItemReceiver = bnc27;
        bNc bnc28 = bQA.setInitialActivityCount;
        MediaBrowserCompatCustomActionResultReceiver = bnc28;
        bNc bnc29 = bQA.setSupportBackgroundTintList;
        onBackPressed = bnc29;
        bNc bnc30 = bQA.setKeyListener;
        initializeViewTreeOwners = bnc30;
        AudioAttributesImplApi26Parcelizer = bnc28;
        bNc bnc31 = new bNc("0.9.2342.19200300.100.1.25");
        RemoteActionCompatParcelizer = bnc31;
        bNc bnc32 = new bNc("0.9.2342.19200300.100.1.1");
        getLifecycle = bnc32;
        AudioAttributesImplBaseParcelizer = false;
        Hashtable hashtable = new Hashtable();
        AudioAttributesImplApi21Parcelizer = hashtable;
        Hashtable hashtable2 = new Hashtable();
        ComponentActivity2 = hashtable2;
        Hashtable hashtable3 = new Hashtable();
        PlaybackStateCompat = hashtable3;
        Hashtable hashtable4 = new Hashtable();
        IconCompatParcelizer = hashtable4;
        MediaSessionCompatToken = hashtable;
        getOnBackPressedDispatcherannotations = hashtable4;
        onCreate = new Boolean(true);
        getSavedStateRegistry = new Boolean(false);
        hashtable.put(bnc, "C");
        hashtable.put(bnc2, "O");
        hashtable.put(bnc4, "T");
        hashtable.put(bnc3, "OU");
        hashtable.put(bnc5, "CN");
        hashtable.put(bnc8, "L");
        hashtable.put(bnc9, "ST");
        hashtable.put(bnc6, "SERIALNUMBER");
        hashtable.put(bnc28, "E");
        hashtable.put(bnc31, "DC");
        hashtable.put(bnc32, "UID");
        hashtable.put(bnc7, "STREET");
        hashtable.put(bnc10, "SURNAME");
        hashtable.put(bnc11, "GIVENNAME");
        hashtable.put(bnc12, "INITIALS");
        hashtable.put(bnc13, "GENERATION");
        hashtable.put(bnc30, "unstructuredAddress");
        hashtable.put(bnc29, "unstructuredName");
        hashtable.put(bnc14, "UniqueIdentifier");
        hashtable.put(bnc17, "DN");
        hashtable.put(bnc18, "Pseudonym");
        hashtable.put(bnc25, "PostalAddress");
        hashtable.put(bnc24, "NameAtBirth");
        hashtable.put(bnc22, "CountryOfCitizenship");
        hashtable.put(bnc23, "CountryOfResidence");
        hashtable.put(bnc21, "Gender");
        hashtable.put(bnc20, "PlaceOfBirth");
        hashtable.put(bnc19, "DateOfBirth");
        hashtable.put(bnc16, "PostalCode");
        hashtable.put(bnc15, "BusinessCategory");
        hashtable.put(bnc26, "TelephoneNumber");
        hashtable.put(bnc27, "Name");
        hashtable2.put(bnc, "C");
        hashtable2.put(bnc2, "O");
        hashtable2.put(bnc3, "OU");
        hashtable2.put(bnc5, "CN");
        hashtable2.put(bnc8, "L");
        hashtable2.put(bnc9, "ST");
        hashtable2.put(bnc7, "STREET");
        hashtable2.put(bnc31, "DC");
        hashtable2.put(bnc32, "UID");
        hashtable3.put(bnc, "C");
        hashtable3.put(bnc2, "O");
        hashtable3.put(bnc3, "OU");
        hashtable3.put(bnc5, "CN");
        hashtable3.put(bnc8, "L");
        hashtable3.put(bnc9, "ST");
        hashtable3.put(bnc7, "STREET");
        hashtable4.put("c", bnc);
        hashtable4.put("o", bnc2);
        hashtable4.put("t", bnc4);
        hashtable4.put("ou", bnc3);
        hashtable4.put("cn", bnc5);
        hashtable4.put("l", bnc8);
        hashtable4.put("st", bnc9);
        hashtable4.put("sn", bnc6);
        hashtable4.put("serialnumber", bnc6);
        hashtable4.put("street", bnc7);
        hashtable4.put("emailaddress", bnc28);
        hashtable4.put("dc", bnc31);
        hashtable4.put("e", bnc28);
        hashtable4.put("uid", bnc32);
        hashtable4.put("surname", bnc10);
        hashtable4.put("givenname", bnc11);
        hashtable4.put("initials", bnc12);
        hashtable4.put("generation", bnc13);
        hashtable4.put("unstructuredaddress", bnc30);
        hashtable4.put("unstructuredname", bnc29);
        hashtable4.put("uniqueidentifier", bnc14);
        hashtable4.put("dn", bnc17);
        hashtable4.put("pseudonym", bnc18);
        hashtable4.put("postaladdress", bnc25);
        hashtable4.put("nameofbirth", bnc24);
        hashtable4.put("countryofcitizenship", bnc22);
        hashtable4.put("countryofresidence", bnc23);
        hashtable4.put(setScreenFlashOverlayColor.AudioAttributesImplBaseParcelizer, bnc21);
        hashtable4.put("placeofbirth", bnc20);
        hashtable4.put("dateofbirth", bnc19);
        hashtable4.put("postalcode", bnc16);
        hashtable4.put("businesscategory", bnc15);
        hashtable4.put("telephonenumber", bnc26);
        hashtable4.put("name", bnc27);
    }

    protected bSO() {
        this.ActivityResultRegistry1 = null;
        this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable = new Vector();
        this.valueOf = new Vector();
        this.onSaveInstanceState = new Vector();
    }

    public bSO(String str) {
        this(AudioAttributesImplBaseParcelizer, IconCompatParcelizer, str);
    }

    public bSO(String str, bSR bsr) {
        this(AudioAttributesImplBaseParcelizer, IconCompatParcelizer, str, bsr);
    }

    public bSO(Hashtable hashtable) {
        this((Vector) null, hashtable);
    }

    public bSO(Vector vector, Hashtable hashtable) {
        this(vector, hashtable, (bSR) new bSK());
    }

    public bSO(Vector vector, Hashtable hashtable, bSR bsr) {
        this.ActivityResultRegistry1 = null;
        this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable = new Vector();
        this.valueOf = new Vector();
        this.onSaveInstanceState = new Vector();
        this.ActivityResultRegistry1 = bsr;
        if (vector != null) {
            for (int i = 0; i != vector.size(); i++) {
                this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.addElement(vector.elementAt(i));
                this.onSaveInstanceState.addElement(getSavedStateRegistry);
            }
        } else {
            Enumeration keys = hashtable.keys();
            while (keys.hasMoreElements()) {
                this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.addElement(keys.nextElement());
                this.onSaveInstanceState.addElement(getSavedStateRegistry);
            }
        }
        for (int i2 = 0; i2 != this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.size(); i2++) {
            bNc bnc = (bNc) this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.elementAt(i2);
            if (hashtable.get(bnc) == null) {
                throw new IllegalArgumentException("No attribute for object id - " + bnc.setLabel() + " - passed to distinguished name");
            }
            this.valueOf.addElement(hashtable.get(bnc));
        }
    }

    public bSO(Vector vector, Vector vector2) {
        this(vector, vector2, (bSR) new bSK());
    }

    public bSO(Vector vector, Vector vector2, bSR bsr) {
        this.ActivityResultRegistry1 = null;
        this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable = new Vector();
        this.valueOf = new Vector();
        this.onSaveInstanceState = new Vector();
        this.ActivityResultRegistry1 = bsr;
        if (vector.size() != vector2.size()) {
            throw new IllegalArgumentException("oids vector must be same length as values.");
        }
        for (int i = 0; i < vector.size(); i++) {
            this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.addElement(vector.elementAt(i));
            this.valueOf.addElement(vector2.elementAt(i));
            this.onSaveInstanceState.addElement(getSavedStateRegistry);
        }
    }

    public bSO(bNh bnh) {
        Vector vector;
        this.ActivityResultRegistry1 = null;
        this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable = new Vector();
        this.valueOf = new Vector();
        this.onSaveInstanceState = new Vector();
        this.onStop = bnh;
        Enumeration background = bnh.setBackground();
        while (background.hasMoreElements()) {
            AbstractC0028bNn fieldValue = AbstractC0028bNn.setFieldValue(((bMM) background.nextElement()).AudioAttributesImplApi21Parcelizer());
            int i = 0;
            while (i < fieldValue.setBackground()) {
                bNh label = bNh.setLabel(fieldValue.setBackground(i).AudioAttributesImplApi21Parcelizer());
                if (label.IconCompatParcelizer() != 2) {
                    throw new IllegalArgumentException("badly sized pair");
                }
                this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.addElement(bNc.setBackground(label.setLabel(0)));
                bNj label2 = label.setLabel(1);
                if (!(label2 instanceof bNj) || (label2 instanceof AbstractC0032bNu)) {
                    try {
                        this.valueOf.addElement("#" + setBackground(cFk.setLabel(label2.AudioAttributesImplApi21Parcelizer().setOptions("DER"))));
                    } catch (IOException unused) {
                        throw new IllegalArgumentException("cannot encode value");
                    }
                } else {
                    String error = label2.setError();
                    if (error.length() <= 0 || error.charAt(0) != '#') {
                        vector = this.valueOf;
                    } else {
                        vector = this.valueOf;
                        error = "\\" + error;
                    }
                    vector.addElement(error);
                }
                this.onSaveInstanceState.addElement(i != 0 ? onCreate : getSavedStateRegistry);
                i++;
            }
        }
    }

    public bSO(boolean z, String str) {
        this(z, IconCompatParcelizer, str);
    }

    public bSO(boolean z, String str, bSR bsr) {
        this(z, IconCompatParcelizer, str, bsr);
    }

    public bSO(boolean z, Hashtable hashtable, String str) {
        this(z, hashtable, str, new bSK());
    }

    public bSO(boolean z, Hashtable hashtable, String str, bSR bsr) {
        this.ActivityResultRegistry1 = null;
        this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable = new Vector();
        this.valueOf = new Vector();
        this.onSaveInstanceState = new Vector();
        this.ActivityResultRegistry1 = bsr;
        bSQ bsq = new bSQ(str);
        while (bsq.setLabel()) {
            String background = bsq.setBackground();
            if (background.indexOf(43) > 0) {
                bSQ bsq2 = new bSQ(background, '+');
                String background2 = bsq2.setBackground();
                Boolean bool = getSavedStateRegistry;
                while (true) {
                    setFieldValue(hashtable, background2, bool);
                    if (bsq2.setLabel()) {
                        background2 = bsq2.setBackground();
                        bool = onCreate;
                    }
                }
            } else {
                setFieldValue(hashtable, background, getSavedStateRegistry);
            }
        }
        if (z) {
            Vector vector = new Vector();
            Vector vector2 = new Vector();
            Vector vector3 = new Vector();
            int i = 1;
            for (int i2 = 0; i2 < this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.size(); i2++) {
                if (((Boolean) this.onSaveInstanceState.elementAt(i2)).booleanValue()) {
                    vector.insertElementAt(this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.elementAt(i2), i);
                    vector2.insertElementAt(this.valueOf.elementAt(i2), i);
                    vector3.insertElementAt(this.onSaveInstanceState.elementAt(i2), i);
                    i++;
                } else {
                    vector.insertElementAt(this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.elementAt(i2), 0);
                    vector2.insertElementAt(this.valueOf.elementAt(i2), 0);
                    vector3.insertElementAt(this.onSaveInstanceState.elementAt(i2), 0);
                    i = 1;
                }
            }
            this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable = vector;
            this.valueOf = vector2;
            this.onSaveInstanceState = vector3;
        }
    }

    private String setBackground(String str) {
        String error = cFa.setError(str.trim());
        if (error.length() <= 0 || error.charAt(0) != '#') {
            return error;
        }
        bNj label = setLabel(error);
        return label instanceof bNj ? cFa.setError(label.setError().trim()) : error;
    }

    private String setBackground(byte[] bArr) {
        int length = bArr.length;
        char[] cArr = new char[length];
        for (int i = 0; i != length; i++) {
            cArr[i] = (char) (bArr[i] & 255);
        }
        return new String(cArr);
    }

    public static bSO setBackground(AbstractC0031bNr abstractC0031bNr, boolean z) {
        return setError(bNh.setOptions(abstractC0031bNr, z));
    }

    private String setError(String str) {
        StringBuffer stringBuffer = new StringBuffer();
        if (str.length() != 0) {
            char charAt = str.charAt(0);
            stringBuffer.append(charAt);
            int i = 1;
            while (i < str.length()) {
                char charAt2 = str.charAt(i);
                if (charAt != ' ' || charAt2 != ' ') {
                    stringBuffer.append(charAt2);
                }
                i++;
                charAt = charAt2;
            }
        }
        return stringBuffer.toString();
    }

    public static bSO setError(Object obj) {
        if (obj instanceof bSO) {
            return (bSO) obj;
        }
        if (obj instanceof C0053bRb) {
            return new bSO(bNh.setLabel(((C0053bRb) obj).AudioAttributesImplApi21Parcelizer()));
        }
        if (obj != null) {
            return new bSO(bNh.setLabel(obj));
        }
        return null;
    }

    private String setFieldValue(String str) {
        int i;
        if (str.length() == 0 || (str.indexOf(92) < 0 && str.indexOf(34) < 0)) {
            return str.trim();
        }
        char[] charArray = str.toCharArray();
        StringBuffer stringBuffer = new StringBuffer(str.length());
        if (charArray[0] == '\\' && charArray[1] == '#') {
            stringBuffer.append("\\#");
            i = 2;
        } else {
            i = 0;
        }
        boolean z = false;
        int i2 = 0;
        boolean z2 = false;
        boolean z3 = false;
        while (i != charArray.length) {
            char c = charArray[i];
            if (c != ' ') {
                z3 = true;
            }
            if (c != '\"') {
                if (c == '\\' && !z && !z2) {
                    i2 = stringBuffer.length();
                    z = true;
                } else if (c == ' ' && !z && !z3) {
                }
                i++;
            } else if (!z) {
                z2 = !z2;
                z = false;
                i++;
            }
            stringBuffer.append(c);
            z = false;
            i++;
        }
        if (stringBuffer.length() > 0) {
            while (stringBuffer.charAt(stringBuffer.length() - 1) == ' ' && i2 != stringBuffer.length() - 1) {
                stringBuffer.setLength(stringBuffer.length() - 1);
            }
        }
        return stringBuffer.toString();
    }

    private void setFieldValue(Hashtable hashtable, String str, Boolean bool) {
        bSQ bsq = new bSQ(str, '=');
        String background = bsq.setBackground();
        if (!bsq.setLabel()) {
            throw new IllegalArgumentException("badly formatted directory string");
        }
        String background2 = bsq.setBackground();
        this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.addElement(setOptions(background, hashtable));
        this.valueOf.addElement(setFieldValue(background2));
        this.onSaveInstanceState.addElement(bool);
    }

    private bNe setLabel(String str) {
        try {
            return bNe.setElement(cFk.setFieldValue(str, 1, str.length() - 1));
        } catch (IOException e) {
            throw new IllegalStateException("unknown encoding in name: " + e);
        }
    }

    private bNc setOptions(String str, Hashtable hashtable) {
        String trim = str.trim();
        if (trim.regionMatches(true, 0, "OID.", 0, 4)) {
            return new bNc(trim.substring(4));
        }
        bNc error = bNc.setError(trim);
        if (error != null) {
            return error;
        }
        bNc bnc = (bNc) hashtable.get(cFa.setError(trim));
        if (bnc != null) {
            return bnc;
        }
        throw new IllegalArgumentException("Unknown object id - " + trim + " - passed to distinguished name");
    }

    private void setOptions(StringBuffer stringBuffer, Hashtable hashtable, bNc bnc, String str) {
        String str2 = (String) hashtable.get(bnc);
        if (str2 == null) {
            str2 = bnc.setLabel();
        }
        stringBuffer.append(str2);
        stringBuffer.append('=');
        int length = stringBuffer.length();
        stringBuffer.append(str);
        int length2 = stringBuffer.length();
        if (str.length() >= 2 && str.charAt(0) == '\\' && str.charAt(1) == '#') {
            length += 2;
        }
        while (length < length2 && stringBuffer.charAt(length) == ' ') {
            stringBuffer.insert(length, "\\");
            length += 2;
            length2++;
        }
        while (true) {
            length2--;
            if (length2 <= length || stringBuffer.charAt(length2) != ' ') {
                break;
            } else {
                stringBuffer.insert(length2, '\\');
            }
        }
        while (length <= length2) {
            char charAt = stringBuffer.charAt(length);
            if (charAt != '\"' && charAt != '\\' && charAt != '+' && charAt != ',') {
                switch (charAt) {
                    case ';':
                    case '<':
                    case '=':
                    case '>':
                        break;
                    default:
                        length++;
                        break;
                }
            }
            stringBuffer.insert(length, "\\");
            length += 2;
            length2++;
        }
    }

    private boolean setOptions(String str, String str2) {
        String background = setBackground(str);
        String background2 = setBackground(str2);
        return background.equals(background2) || setError(background).equals(setError(background2));
    }

    public bNe AudioAttributesImplApi21Parcelizer() {
        C0044bOk c0044bOk;
        if (this.onStop == null) {
            bMK bmk = new bMK();
            bMK bmk2 = new bMK();
            bNc bnc = null;
            int i = 0;
            while (i != this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.size()) {
                bMK bmk3 = new bMK(2);
                bNc bnc2 = (bNc) this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.elementAt(i);
                bmk3.setBackground((bMM) bnc2);
                bmk3.setBackground((bMM) this.ActivityResultRegistry1.setBackground(bnc2, (String) this.valueOf.elementAt(i)));
                if (bnc == null || ((Boolean) this.onSaveInstanceState.elementAt(i)).booleanValue()) {
                    c0044bOk = new C0044bOk(bmk3);
                } else {
                    bmk.setBackground((bMM) new C0042bOh(bmk2));
                    bmk2 = new bMK();
                    c0044bOk = new C0044bOk(bmk3);
                }
                bmk2.setBackground((bMM) c0044bOk);
                i++;
                bnc = bnc2;
            }
            bmk.setBackground((bMM) new C0042bOh(bmk2));
            this.onStop = new C0044bOk(bmk);
        }
        return this.onStop;
    }

    public boolean equals(java.lang.Object r12) {
        throw new UnsupportedOperationException("Method not decompiled: o.bSO.equals(java.lang.Object):boolean");
    }

    public int hashCode() {
        if (this.onStart) {
            return this.ImmLeaksCleaner;
        }
        this.onStart = true;
        for (int i = 0; i != this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.size(); i++) {
            String error = setError(setBackground((String) this.valueOf.elementAt(i)));
            int hashCode = this.ImmLeaksCleaner ^ this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.elementAt(i).hashCode();
            this.ImmLeaksCleaner = hashCode;
            this.ImmLeaksCleaner = error.hashCode() ^ hashCode;
        }
        return this.ImmLeaksCleaner;
    }

    public boolean setError(Object obj, boolean z) {
        if (!z) {
            return equals(obj);
        }
        if (obj == this) {
            return true;
        }
        if (!(obj instanceof bSO) && !(obj instanceof bNh)) {
            return false;
        }
        if (AudioAttributesImplApi21Parcelizer().setLabel(((bMM) obj).AudioAttributesImplApi21Parcelizer())) {
            return true;
        }
        try {
            bSO error = setError(obj);
            int size = this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.size();
            if (size != error.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.size()) {
                return false;
            }
            for (int i = 0; i < size; i++) {
                if (!((bNc) this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.elementAt(i)).setLabel((bNc) error.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.elementAt(i)) || !setOptions((String) this.valueOf.elementAt(i), (String) error.valueOf.elementAt(i))) {
                    return false;
                }
            }
            return true;
        } catch (IllegalArgumentException unused) {
            return false;
        }
    }

    public String setFieldValue(boolean z, Hashtable hashtable) {
        StringBuffer stringBuffer = new StringBuffer();
        Vector vector = new Vector();
        StringBuffer stringBuffer2 = null;
        for (int i = 0; i < this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.size(); i++) {
            if (((Boolean) this.onSaveInstanceState.elementAt(i)).booleanValue()) {
                stringBuffer2.append('+');
                setOptions(stringBuffer2, hashtable, (bNc) this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.elementAt(i), (String) this.valueOf.elementAt(i));
            } else {
                stringBuffer2 = new StringBuffer();
                setOptions(stringBuffer2, hashtable, (bNc) this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.elementAt(i), (String) this.valueOf.elementAt(i));
                vector.addElement(stringBuffer2);
            }
        }
        boolean z2 = true;
        if (z) {
            for (int size = vector.size() - 1; size >= 0; size--) {
                if (z2) {
                    z2 = false;
                } else {
                    stringBuffer.append(',');
                }
                stringBuffer.append(vector.elementAt(size).toString());
            }
        } else {
            for (int i2 = 0; i2 < vector.size(); i2++) {
                if (z2) {
                    z2 = false;
                } else {
                    stringBuffer.append(',');
                }
                stringBuffer.append(vector.elementAt(i2).toString());
            }
        }
        return stringBuffer.toString();
    }

    public Vector setFieldValue() {
        Vector vector = new Vector();
        for (int i = 0; i != this.valueOf.size(); i++) {
            vector.addElement(this.valueOf.elementAt(i));
        }
        return vector;
    }

    public Vector setLabel() {
        Vector vector = new Vector();
        for (int i = 0; i != this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.size(); i++) {
            vector.addElement(this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.elementAt(i));
        }
        return vector;
    }

    public Vector setLabel(bNc bnc) {
        Vector vector = new Vector();
        for (int i = 0; i != this.valueOf.size(); i++) {
            if (this.OnBackPressedDispatcherLifecycleOnBackPressedCancellable.elementAt(i).equals(bnc)) {
                String str = (String) this.valueOf.elementAt(i);
                if (str.length() > 2 && str.charAt(0) == '\\' && str.charAt(1) == '#') {
                    str = str.substring(1);
                }
                vector.addElement(str);
            }
        }
        return vector;
    }

    public String toString() {
        return setFieldValue(AudioAttributesImplBaseParcelizer, AudioAttributesImplApi21Parcelizer);
    }
}