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

package o;

import android.util.SparseArray;
import androidx.annotation.Nullable;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import o.UPCEANExtensionSupport;
import o.UPCEANReader;
import o.getBytes;
import o.getEvenRoundingErrors;
import o.hasMoreCharacters;
import o.removePartialRows;
import o.setZoom;
import o.signalEncoderChange;

public final class getRemainingCharacters implements UPCEANExtensionSupport, getEvenRoundingErrors.setFieldValue<removePartialRows<hasMoreCharacters>>, removePartialRows.setFieldValue<hasMoreCharacters> {
    private static final Pattern setBackground = Pattern.compile("CC([1-4])=(.+)");
    private static final Pattern setLabel = Pattern.compile("([1-4])=lang:(\\w+)(,.+)?");
    private final long AudioAttributesCompatParcelizer;
    private final getEDFBytes AudioAttributesImplApi21Parcelizer;
    private List<findMinimums> AudioAttributesImplApi26Parcelizer;
    private final getBytes.setOptions AudioAttributesImplBaseParcelizer;
    private final hasMoreCharacters.setError IconCompatParcelizer;
    private final bitMatrixFromEncoder MediaBrowserCompatItemReceiver;
    private final getRowCount MediaBrowserCompatMediaItem;
    private encodeHighLevel MediaBrowserCompatSearchResultReceiver;
    private final DecodedBitStreamParser1 MediaControllerCompatMediaControllerImplApi21ExtraBinderRequestResultReceiver;
    private final UPCEANReader.setLabel MediaDescriptionCompat;
    private int MediaMetadataCompat;
    private final setLabel[] MediaSessionCompatQueueItem;
    private final addOrTally ParcelableVolumeInfo;
    private final signalEncoderChange RatingCompat;
    private final EAN13Writer RemoteActionCompatParcelizer;
    private final PDF417Writer read;
    private final Reader setContentView;
    private getEvenRoundingErrors setElement;
    public final int setError;
    private final getCurrentChar setFieldValue;
    private final setLastSegment setOptions;
    private UPCEANExtensionSupport.setOptions write;
    private removePartialRows<hasMoreCharacters>[] MediaSessionCompatToken = setOptions(0);
    private writeCodewords[] MediaBrowserCompatCustomActionResultReceiver = new writeCodewords[0];
    private final IdentityHashMap<removePartialRows<hasMoreCharacters>, signalEncoderChange.setOptions> MediaSessionCompatResultReceiverWrapper = new IdentityHashMap<>();

    @Override
    public long setElement() {
        return -9223372036854775807L;
    }

    public getRemainingCharacters(int i, encodeHighLevel encodehighlevel, getCurrentChar getcurrentchar, int i2, hasMoreCharacters.setError seterror, @Nullable Reader reader, @Nullable PDF417Writer pDF417Writer, getEDFBytes getedfbytes, getBytes.setOptions setoptions, bitMatrixFromEncoder bitmatrixfromencoder, UPCEANReader.setLabel setlabel, long j, getRowCount getrowcount, setLastSegment setlastsegment, EAN13Writer eAN13Writer, signalEncoderChange.setFieldValue setfieldvalue, DecodedBitStreamParser1 decodedBitStreamParser1) {
        this.setError = i;
        this.MediaBrowserCompatSearchResultReceiver = encodehighlevel;
        this.setFieldValue = getcurrentchar;
        this.MediaMetadataCompat = i2;
        this.IconCompatParcelizer = seterror;
        this.setContentView = reader;
        this.read = pDF417Writer;
        this.AudioAttributesImplApi21Parcelizer = getedfbytes;
        this.AudioAttributesImplBaseParcelizer = setoptions;
        this.MediaBrowserCompatItemReceiver = bitmatrixfromencoder;
        this.MediaDescriptionCompat = setlabel;
        this.AudioAttributesCompatParcelizer = j;
        this.MediaBrowserCompatMediaItem = getrowcount;
        this.setOptions = setlastsegment;
        this.RemoteActionCompatParcelizer = eAN13Writer;
        this.MediaControllerCompatMediaControllerImplApi21ExtraBinderRequestResultReceiver = decodedBitStreamParser1;
        this.RatingCompat = new signalEncoderChange(encodehighlevel, setfieldvalue, setlastsegment);
        this.setElement = eAN13Writer.setOptions();
        getMinimumCount background = encodehighlevel.setBackground(i2);
        List<findMinimums> list = background.setLabel;
        this.AudioAttributesImplApi26Parcelizer = list;
        android.util.Pair<addOrTally, setLabel[]> label = setLabel(getedfbytes, seterror, background.setFieldValue, list);
        this.ParcelableVolumeInfo = (addOrTally) label.first;
        this.MediaSessionCompatQueueItem = (setLabel[]) label.second;
    }

    public void setLabel(o.encodeHighLevel r10, int r11) {
        throw new UnsupportedOperationException("Method not decompiled: o.getRemainingCharacters.setLabel(o.encodeHighLevel, int):void");
    }

    public void write() {
        this.RatingCompat.setOptions();
        for (removePartialRows<hasMoreCharacters> removepartialrows : this.MediaSessionCompatToken) {
            removepartialrows.setOptions(this);
        }
        this.write = null;
    }

    @Override
    public void setLabel(removePartialRows<hasMoreCharacters> removepartialrows) {
        synchronized (this) {
            signalEncoderChange.setOptions remove = this.MediaSessionCompatResultReceiverWrapper.remove(removepartialrows);
            if (remove != null) {
                remove.setFieldValue();
            }
        }
    }

    @Override
    public void setFieldValue(UPCEANExtensionSupport.setOptions setoptions, long j) {
        this.write = setoptions;
        setoptions.setError(this);
    }

    @Override
    public void setError() throws IOException {
        this.MediaBrowserCompatMediaItem.setBackground();
    }

    @Override
    public addOrTally setLabel() {
        return this.ParcelableVolumeInfo;
    }

    @Override
    public List<InputImage> setError(List<getMinWidth> list) {
        List<writeCodeword> list2 = this.MediaBrowserCompatSearchResultReceiver.setBackground(this.MediaMetadataCompat).setFieldValue;
        ArrayList arrayList = new ArrayList();
        for (getMinWidth getminwidth : list) {
            setLabel setlabel = this.MediaSessionCompatQueueItem[this.ParcelableVolumeInfo.setFieldValue(getminwidth.RemoteActionCompatParcelizer())];
            if (setlabel.read == 0) {
                int[] iArr = setlabel.setBackground;
                int AudioAttributesImplApi26Parcelizer = getminwidth.AudioAttributesImplApi26Parcelizer();
                int[] iArr2 = new int[AudioAttributesImplApi26Parcelizer];
                for (int i = 0; i < getminwidth.AudioAttributesImplApi26Parcelizer(); i++) {
                    iArr2[i] = getminwidth.setOptions(i);
                }
                Arrays.sort(iArr2);
                int size = list2.get(iArr[0]).setOptions.size();
                int i2 = 0;
                int i3 = 0;
                for (int i4 = 0; i4 < AudioAttributesImplApi26Parcelizer; i4++) {
                    int i5 = iArr2[i4];
                    while (true) {
                        int i6 = i2 + size;
                        if (i5 >= i6) {
                            i3++;
                            size = list2.get(iArr[i3]).setOptions.size();
                            i2 = i6;
                        }
                    }
                    arrayList.add(new InputImage(this.MediaMetadataCompat, iArr[i3], i5 - i2));
                }
            }
        }
        return arrayList;
    }

    @Override
    public long setOptions(getMinWidth[] getminwidthArr, boolean[] zArr, getOddCounts[] getoddcountsArr, boolean[] zArr2, long j) {
        int[] label = setLabel(getminwidthArr);
        setOptions(getminwidthArr, zArr, getoddcountsArr);
        setFieldValue(getminwidthArr, getoddcountsArr, label);
        setFieldValue(getminwidthArr, getoddcountsArr, zArr2, j, label);
        ArrayList arrayList = new ArrayList();
        ArrayList arrayList2 = new ArrayList();
        for (getOddCounts getoddcounts : getoddcountsArr) {
            if (getoddcounts instanceof removePartialRows) {
                arrayList.add((removePartialRows) getoddcounts);
            } else if (getoddcounts instanceof writeCodewords) {
                arrayList2.add((writeCodewords) getoddcounts);
            }
        }
        removePartialRows<hasMoreCharacters>[] options = setOptions(arrayList.size());
        this.MediaSessionCompatToken = options;
        arrayList.toArray(options);
        writeCodewords[] writecodewordsArr = new writeCodewords[arrayList2.size()];
        this.MediaBrowserCompatCustomActionResultReceiver = writecodewordsArr;
        arrayList2.toArray(writecodewordsArr);
        this.setElement = this.RemoteActionCompatParcelizer.setError(arrayList, getTypeResolver.setFieldValue((List) arrayList, (accessorErasedOverridabilityConditionlambda0) new getNewEncoding()));
        return j;
    }

    public static List setOptions(removePartialRows removepartialrows) {
        return getJavaModuleResolver.setLabel(Integer.valueOf(removepartialrows.setBackground));
    }

    @Override
    public void setBackground(long j, boolean z) {
        for (removePartialRows<hasMoreCharacters> removepartialrows : this.MediaSessionCompatToken) {
            removepartialrows.setBackground(j, z);
        }
    }

    @Override
    public void setError(long j) {
        this.setElement.setError(j);
    }

    @Override
    public boolean setFieldValue(vinCharValue vincharvalue) {
        return this.setElement.setFieldValue(vincharvalue);
    }

    @Override
    public boolean setFieldValue() {
        return this.setElement.setFieldValue();
    }

    @Override
    public long setBackground() {
        return this.setElement.setBackground();
    }

    @Override
    public long ac_() {
        return this.setElement.ac_();
    }

    @Override
    public long setFieldValue(long j) {
        for (removePartialRows<hasMoreCharacters> removepartialrows : this.MediaSessionCompatToken) {
            removepartialrows.setFieldValue(j);
        }
        for (writeCodewords writecodewords : this.MediaBrowserCompatCustomActionResultReceiver) {
            writecodewords.setError(j);
        }
        return j;
    }

    @Override
    public long setBackground(long j, unset unsetVar) {
        for (removePartialRows<hasMoreCharacters> removepartialrows : this.MediaSessionCompatToken) {
            if (removepartialrows.setBackground == 2) {
                return removepartialrows.setLabel(j, unsetVar);
            }
        }
        return j;
    }

    @Override
    public void setBackground(removePartialRows<hasMoreCharacters> removepartialrows) {
        this.write.setBackground(this);
    }

    private int[] setLabel(getMinWidth[] getminwidthArr) {
        int[] iArr = new int[getminwidthArr.length];
        for (int i = 0; i < getminwidthArr.length; i++) {
            getMinWidth getminwidth = getminwidthArr[i];
            if (getminwidth != null) {
                iArr[i] = this.ParcelableVolumeInfo.setFieldValue(getminwidth.RemoteActionCompatParcelizer());
            } else {
                iArr[i] = -1;
            }
        }
        return iArr;
    }

    private void setOptions(getMinWidth[] getminwidthArr, boolean[] zArr, getOddCounts[] getoddcountsArr) {
        for (int i = 0; i < getminwidthArr.length; i++) {
            if (getminwidthArr[i] == null || !zArr[i]) {
                getOddCounts getoddcounts = getoddcountsArr[i];
                if (getoddcounts instanceof removePartialRows) {
                    ((removePartialRows) getoddcounts).setOptions(this);
                } else if (getoddcounts instanceof removePartialRows.setBackground) {
                    ((removePartialRows.setBackground) getoddcounts).setLabel();
                }
                getoddcountsArr[i] = null;
            }
        }
    }

    private void setFieldValue(o.getMinWidth[] r5, o.getOddCounts[] r6, int[] r7) {
        throw new UnsupportedOperationException("Method not decompiled: o.getRemainingCharacters.setFieldValue(o.getMinWidth[], o.getOddCounts[], int[]):void");
    }

    private void setFieldValue(getMinWidth[] getminwidthArr, getOddCounts[] getoddcountsArr, boolean[] zArr, long j, int[] iArr) {
        for (int i = 0; i < getminwidthArr.length; i++) {
            getMinWidth getminwidth = getminwidthArr[i];
            if (getminwidth != null) {
                getOddCounts getoddcounts = getoddcountsArr[i];
                if (getoddcounts == null) {
                    zArr[i] = true;
                    setLabel setlabel = this.MediaSessionCompatQueueItem[iArr[i]];
                    int i2 = setlabel.read;
                    if (i2 == 0) {
                        getoddcountsArr[i] = setLabel(setlabel, getminwidth, j);
                    } else if (i2 == 2) {
                        getoddcountsArr[i] = new writeCodewords(this.AudioAttributesImplApi26Parcelizer.get(setlabel.setFieldValue), getminwidth.RemoteActionCompatParcelizer().setError(0), this.MediaBrowserCompatSearchResultReceiver.setOptions);
                    }
                } else if (getoddcounts instanceof removePartialRows) {
                    ((hasMoreCharacters) ((removePartialRows) getoddcounts).setError()).setLabel(getminwidth);
                }
            }
        }
        for (int i3 = 0; i3 < getminwidthArr.length; i3++) {
            if (getoddcountsArr[i3] == null && getminwidthArr[i3] != null) {
                setLabel setlabel2 = this.MediaSessionCompatQueueItem[iArr[i3]];
                if (setlabel2.read == 1) {
                    int error = setError(i3, iArr);
                    if (error == -1) {
                        getoddcountsArr[i3] = new decodeEnd();
                    } else {
                        getoddcountsArr[i3] = ((removePartialRows) getoddcountsArr[error]).setLabel(j, setlabel2.setElement);
                    }
                }
            }
        }
    }

    private int setError(int i, int[] iArr) {
        int i2 = iArr[i];
        if (i2 == -1) {
            return -1;
        }
        int i3 = this.MediaSessionCompatQueueItem[i2].write;
        for (int i4 = 0; i4 < iArr.length; i4++) {
            int i5 = iArr[i4];
            if (i5 == i3 && this.MediaSessionCompatQueueItem[i5].read == 0) {
                return i4;
            }
        }
        return -1;
    }

    private static android.util.Pair<addOrTally, setLabel[]> setLabel(getEDFBytes getedfbytes, hasMoreCharacters.setError seterror, List<writeCodeword> list, List<findMinimums> list2) {
        int[][] background = setBackground(list);
        int length = background.length;
        boolean[] zArr = new boolean[length];
        setZoom[][] setzoomArr = new setZoom[length][];
        int label = setLabel(length, list, background, zArr, setzoomArr) + length + list2.size();
        getPlanes[] getplanesArr = new getPlanes[label];
        setLabel[] setlabelArr = new setLabel[label];
        setError(list2, getplanesArr, setlabelArr, setOptions(getedfbytes, seterror, list, background, length, zArr, setzoomArr, getplanesArr, setlabelArr));
        return android.util.Pair.create(new addOrTally(getplanesArr), setlabelArr);
    }

    private static int[][] setBackground(List<writeCodeword> list) {
        determineConsecutiveDigitCount options;
        Integer num;
        int size = list.size();
        HashMap label = SingleModuleClassResolver.setLabel(size);
        ArrayList arrayList = new ArrayList(size);
        SparseArray sparseArray = new SparseArray(size);
        for (int i = 0; i < size; i++) {
            label.put(Long.valueOf(list.get(i).setBackground), Integer.valueOf(i));
            ArrayList arrayList2 = new ArrayList();
            arrayList2.add(Integer.valueOf(i));
            arrayList.add(arrayList2);
            sparseArray.put(i, arrayList2);
        }
        for (int i2 = 0; i2 < size; i2++) {
            writeCodeword writecodeword = list.get(i2);
            determineConsecutiveDigitCount label2 = setLabel(writecodeword.setLabel);
            if (label2 == null) {
                label2 = setLabel(writecodeword.read);
            }
            int intValue = (label2 == null || (num = (Integer) label.get(Long.valueOf(Long.parseLong(label2.setBackground)))) == null) ? i2 : num.intValue();
            if (intValue == i2 && (options = setOptions(writecodeword.read)) != null) {
                for (String str : getLandmarkType.setFieldValue(options.setBackground, ",")) {
                    Integer num2 = (Integer) label.get(Long.valueOf(Long.parseLong(str)));
                    if (num2 != null) {
                        intValue = Math.min(intValue, num2.intValue());
                    }
                }
            }
            if (intValue != i2) {
                List list2 = (List) sparseArray.get(i2);
                List list3 = (List) sparseArray.get(intValue);
                list3.addAll(list2);
                sparseArray.put(i2, list3);
                arrayList.remove(list2);
            }
        }
        int size2 = arrayList.size();
        int[][] iArr = new int[size2][];
        for (int i3 = 0; i3 < size2; i3++) {
            int[] fieldValue = JavaClassifierType.setFieldValue((Collection<? extends Number>) arrayList.get(i3));
            iArr[i3] = fieldValue;
            Arrays.sort(fieldValue);
        }
        return iArr;
    }

    private static int setLabel(int i, List<writeCodeword> list, int[][] iArr, boolean[] zArr, setZoom[][] setzoomArr) {
        int i2 = 0;
        for (int i3 = 0; i3 < i; i3++) {
            if (setError(list, iArr[i3])) {
                zArr[i3] = true;
                i2++;
            }
            setZoom[] background = setBackground(list, iArr[i3]);
            setzoomArr[i3] = background;
            if (background.length != 0) {
                i2++;
            }
        }
        return i2;
    }

    private static int setOptions(getEDFBytes getedfbytes, hasMoreCharacters.setError seterror, List<writeCodeword> list, int[][] iArr, int i, boolean[] zArr, setZoom[][] setzoomArr, getPlanes[] getplanesArr, setLabel[] setlabelArr) {
        int i2;
        int i3;
        int i4 = 0;
        int i5 = 0;
        while (i4 < i) {
            int[] iArr2 = iArr[i4];
            ArrayList arrayList = new ArrayList();
            for (int i6 : iArr2) {
                arrayList.addAll(list.get(i6).setOptions);
            }
            int size = arrayList.size();
            setZoom[] setzoomArr2 = new setZoom[size];
            for (int i7 = 0; i7 < size; i7++) {
                setZoom setzoom = ((isDigit) arrayList.get(i7)).setFieldValue;
                setzoomArr2[i7] = setzoom.setFieldValue().setBackground(getedfbytes.setFieldValue(setzoom)).setFieldValue();
            }
            writeCodeword writecodeword = list.get(iArr2[0]);
            long j = writecodeword.setBackground;
            String l = j != -1 ? Long.toString(j) : "unset:" + i4;
            int i8 = i5 + 1;
            if (zArr[i4]) {
                i2 = i8;
                i8 = i5 + 2;
            } else {
                i2 = -1;
            }
            if (setzoomArr[i4].length != 0) {
                i3 = i8 + 1;
            } else {
                i3 = i8;
                i8 = -1;
            }
            setBackground(seterror, setzoomArr2);
            getplanesArr[i5] = new getPlanes(l, setzoomArr2);
            setlabelArr[i5] = setLabel.setFieldValue(writecodeword.write, iArr2, i5, i2, i8);
            if (i2 != -1) {
                String str = l + ":emsg";
                getplanesArr[i2] = new getPlanes(str, new setZoom[]{new setZoom.setOptions().setError(str).read("application/x-emsg").setFieldValue()});
                setlabelArr[i2] = setLabel.setOptions(iArr2, i5);
            }
            if (i8 != -1) {
                setlabelArr[i8] = setLabel.setFieldValue(iArr2, i5, getJavaModuleResolver.setError(setzoomArr[i4]));
                setBackground(seterror, setzoomArr[i4]);
                getplanesArr[i8] = new getPlanes(l + ":cc", setzoomArr[i4]);
            }
            i4++;
            i5 = i3;
        }
        return i5;
    }

    private static void setError(List<findMinimums> list, getPlanes[] getplanesArr, setLabel[] setlabelArr, int i) {
        int i2 = 0;
        while (i2 < list.size()) {
            findMinimums findminimums = list.get(i2);
            getplanesArr[i] = new getPlanes(findminimums.setError() + ":" + i2, new setZoom[]{new setZoom.setOptions().setError(findminimums.setError()).read("application/x-emsg").setFieldValue()});
            setlabelArr[i] = setLabel.setFieldValue(i2);
            i2++;
            i++;
        }
    }

    private removePartialRows<hasMoreCharacters> setLabel(setLabel setlabel, getMinWidth getminwidth, long j) {
        int i;
        getPlanes getplanes;
        getJavaModuleResolver error;
        int i2;
        int i3 = setlabel.setError;
        boolean z = i3 != -1;
        signalEncoderChange.setOptions setoptions = null;
        if (z) {
            getplanes = this.ParcelableVolumeInfo.setOptions(i3);
            i = 1;
        } else {
            i = 0;
            getplanes = null;
        }
        int i4 = setlabel.setLabel;
        if (i4 != -1) {
            error = this.MediaSessionCompatQueueItem[i4].setOptions;
        } else {
            error = getJavaModuleResolver.setError();
        }
        int size = i + error.size();
        setZoom[] setzoomArr = new setZoom[size];
        int[] iArr = new int[size];
        if (z) {
            setzoomArr[0] = getplanes.setError(0);
            iArr[0] = 5;
            i2 = 1;
        } else {
            i2 = 0;
        }
        ArrayList arrayList = new ArrayList();
        for (int i5 = 0; i5 < error.size(); i5++) {
            setZoom setzoom = (setZoom) error.get(i5);
            setzoomArr[i2] = setzoom;
            iArr[i2] = 3;
            arrayList.add(setzoom);
            i2++;
        }
        if (this.MediaBrowserCompatSearchResultReceiver.setOptions && z) {
            setoptions = this.RatingCompat.setLabel();
        }
        signalEncoderChange.setOptions setoptions2 = setoptions;
        removePartialRows<hasMoreCharacters> removepartialrows = new removePartialRows<>(setlabel.setElement, iArr, setzoomArr, this.IconCompatParcelizer.setFieldValue(this.MediaBrowserCompatMediaItem, this.MediaBrowserCompatSearchResultReceiver, this.setFieldValue, this.MediaMetadataCompat, setlabel.setBackground, getminwidth, setlabel.setElement, this.AudioAttributesCompatParcelizer, z, arrayList, setoptions2, this.setContentView, this.MediaControllerCompatMediaControllerImplApi21ExtraBinderRequestResultReceiver, this.read), this, this.setOptions, j, this.AudioAttributesImplApi21Parcelizer, this.AudioAttributesImplBaseParcelizer, this.MediaBrowserCompatItemReceiver, this.MediaDescriptionCompat);
        synchronized (this) {
            this.MediaSessionCompatResultReceiverWrapper.put(removepartialrows, setoptions2);
        }
        return removepartialrows;
    }

    private static determineConsecutiveDigitCount setOptions(List<determineConsecutiveDigitCount> list) {
        return setError(list, "urn:mpeg:dash:adaptation-set-switching:2016");
    }

    private static determineConsecutiveDigitCount setLabel(List<determineConsecutiveDigitCount> list) {
        return setError(list, "http://dashif.org/guidelines/trickmode");
    }

    private static determineConsecutiveDigitCount setError(List<determineConsecutiveDigitCount> list, String str) {
        for (int i = 0; i < list.size(); i++) {
            determineConsecutiveDigitCount determineconsecutivedigitcount = list.get(i);
            if (str.equals(determineconsecutivedigitcount.setOptions)) {
                return determineconsecutivedigitcount;
            }
        }
        return null;
    }

    private static boolean setError(List<writeCodeword> list, int[] iArr) {
        for (int i : iArr) {
            List<isDigit> list2 = list.get(i).setOptions;
            for (int i2 = 0; i2 < list2.size(); i2++) {
                if (!list2.get(i2).setLabel.isEmpty()) {
                    return true;
                }
            }
        }
        return false;
    }

    private static setZoom[] setBackground(List<writeCodeword> list, int[] iArr) {
        for (int i : iArr) {
            writeCodeword writecodeword = list.get(i);
            List<determineConsecutiveDigitCount> list2 = list.get(i).setFieldValue;
            for (int i2 = 0; i2 < list2.size(); i2++) {
                determineConsecutiveDigitCount determineconsecutivedigitcount = list2.get(i2);
                if ("urn:scte:dash:cc:cea-608:2015".equals(determineconsecutivedigitcount.setOptions)) {
                    return setError(determineconsecutivedigitcount, setBackground, new setZoom.setOptions().read("application/cea-608").setError(writecodeword.setBackground + ":cea608").setFieldValue());
                }
                if ("urn:scte:dash:cc:cea-708:2015".equals(determineconsecutivedigitcount.setOptions)) {
                    return setError(determineconsecutivedigitcount, setLabel, new setZoom.setOptions().read("application/cea-708").setError(writecodeword.setBackground + ":cea708").setFieldValue());
                }
            }
        }
        return new setZoom[0];
    }

    private static setZoom[] setError(determineConsecutiveDigitCount determineconsecutivedigitcount, Pattern pattern, setZoom setzoom) {
        String str = determineconsecutivedigitcount.setBackground;
        if (str == null) {
            return new setZoom[]{setzoom};
        }
        String[] fieldValue = getLandmarkType.setFieldValue(str, ";");
        setZoom[] setzoomArr = new setZoom[fieldValue.length];
        for (int i = 0; i < fieldValue.length; i++) {
            Matcher matcher = pattern.matcher(fieldValue[i]);
            if (!matcher.matches()) {
                return new setZoom[]{setzoom};
            }
            int parseInt = Integer.parseInt(matcher.group(1));
            setzoomArr[i] = setzoom.setFieldValue().setError(setzoom.MediaBrowserCompatSearchResultReceiver + ":" + parseInt).setOptions(parseInt).setOptions(matcher.group(2)).setFieldValue();
        }
        return setzoomArr;
    }

    private static void setBackground(hasMoreCharacters.setError seterror, setZoom[] setzoomArr) {
        for (int i = 0; i < setzoomArr.length; i++) {
            setzoomArr[i] = seterror.setOptions(setzoomArr[i]);
        }
    }

    private static removePartialRows<hasMoreCharacters>[] setOptions(int i) {
        return new removePartialRows[i];
    }
}