package o;

import java.io.BufferedReader;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Serializable;
import java.text.ParseException;
import java.util.HashMap;
import java.util.StringTokenizer;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import org.bouncycastle.crypto.tls.CipherSuite;
import org.threeten.bp.DateTimeException;
import org.threeten.bp.temporal.UnsupportedTemporalTypeException;

/* loaded from: classes6.dex */
public final class gsX extends gsK<gsX> implements Serializable {
    private static final Long[] ADJUSTED_CYCLES;
    private static final HashMap<Integer, Integer[]> ADJUSTED_CYCLE_YEARS;
    private static final Integer[] ADJUSTED_LEAST_MAX_VALUES;
    private static final Integer[] ADJUSTED_MAX_VALUES;
    private static final Integer[] ADJUSTED_MIN_VALUES;
    private static final HashMap<Integer, Integer[]> ADJUSTED_MONTH_DAYS;
    private static final HashMap<Integer, Integer[]> ADJUSTED_MONTH_LENGTHS;
    private static final String DEFAULT_CONFIG_FILENAME = "hijrah_deviation.cfg";
    private static final String DEFAULT_CONFIG_PATH;
    private static final Integer[] DEFAULT_CYCLE_YEARS;
    private static final Integer[] DEFAULT_LEAP_MONTH_DAYS;
    private static final Integer[] DEFAULT_LEAP_MONTH_LENGTHS;
    private static final Integer[] DEFAULT_MONTH_DAYS;
    private static final Integer[] DEFAULT_MONTH_LENGTHS;
    private static final char FILE_SEP;
    private static final int HIJRAH_JAN_1_1_GREGORIAN_DAY = -492148;
    private static final int MAX_ADJUSTED_CYCLE = 334;
    public static final int MIN_VALUE_OF_ERA = 1;
    private static final String PATH_SEP;
    private static final int POSITION_DAY_OF_MONTH = 5;
    private static final int POSITION_DAY_OF_YEAR = 6;
    private static final long serialVersionUID = -5207853542612002020L;
    private final transient int dayOfMonth;
    private final transient EnumC15515gsk dayOfWeek;
    private final transient int dayOfYear;
    private final transient EnumC15504gsZ era;
    private final long gregorianEpochDay;
    private final transient boolean isLeapYear;
    private final transient int monthOfYear;
    private final transient int yearOfEra;
    private static final int[] NUM_DAYS = {0, 30, 59, 89, 118, CipherSuite.TLS_RSA_PSK_WITH_AES_128_CBC_SHA, CipherSuite.TLS_PSK_WITH_NULL_SHA384, 207, 236, 266, 295, 325};
    private static final int[] LEAP_NUM_DAYS = {0, 30, 59, 89, 118, CipherSuite.TLS_RSA_PSK_WITH_AES_128_CBC_SHA, CipherSuite.TLS_PSK_WITH_NULL_SHA384, 207, 236, 266, 295, 325};
    private static final int[] MONTH_LENGTH = {30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29};
    private static final int[] LEAP_MONTH_LENGTH = {30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 30};
    private static final int[] MIN_VALUES = {0, 1, 0, 1, 0, 1, 1};
    public static final int MAX_VALUE_OF_ERA = 9999;
    private static final int[] LEAST_MAX_VALUES = {1, MAX_VALUE_OF_ERA, 11, 51, 5, 29, 354};
    private static final int[] MAX_VALUES = {1, MAX_VALUE_OF_ERA, 11, 52, 6, 30, 355};
    private static final int[] CYCLEYEAR_START_DATE = {0, 354, 709, 1063, 1417, 1772, 2126, 2481, 2835, 3189, 3544, 3898, 4252, 4607, 4961, 5315, 5670, 6024, 6379, 6733, 7087, 7442, 7796, 8150, 8505, 8859, 9214, 9568, 9922, 10277};

    @Override // o.gsK, o.InterfaceC15536gtL
    public final /* bridge */ /* synthetic */ long until(InterfaceC15536gtL interfaceC15536gtL, InterfaceC15539gtV interfaceC15539gtV) {
        return super.until(interfaceC15536gtL, interfaceC15539gtV);
    }

    @Override // o.gsK, o.gsJ
    public final /* bridge */ /* synthetic */ gsT until(gsJ gsj) {
        return super.until(gsj);
    }

    static {
        char c = File.separatorChar;
        FILE_SEP = c;
        PATH_SEP = File.pathSeparator;
        StringBuilder sb = new StringBuilder("org");
        sb.append(c);
        sb.append("threeten");
        sb.append(c);
        sb.append("bp");
        sb.append(c);
        sb.append("chrono");
        DEFAULT_CONFIG_PATH = sb.toString();
        ADJUSTED_MONTH_DAYS = new HashMap<>();
        ADJUSTED_MONTH_LENGTHS = new HashMap<>();
        ADJUSTED_CYCLE_YEARS = new HashMap<>();
        DEFAULT_MONTH_DAYS = new Integer[12];
        int i = 0;
        int i2 = 0;
        while (true) {
            int[] iArr = NUM_DAYS;
            if (i2 >= iArr.length) {
                break;
            }
            DEFAULT_MONTH_DAYS[i2] = Integer.valueOf(iArr[i2]);
            i2++;
        }
        DEFAULT_LEAP_MONTH_DAYS = new Integer[LEAP_NUM_DAYS.length];
        int i3 = 0;
        while (true) {
            int[] iArr2 = LEAP_NUM_DAYS;
            if (i3 >= iArr2.length) {
                break;
            }
            DEFAULT_LEAP_MONTH_DAYS[i3] = Integer.valueOf(iArr2[i3]);
            i3++;
        }
        DEFAULT_MONTH_LENGTHS = new Integer[MONTH_LENGTH.length];
        int i4 = 0;
        while (true) {
            int[] iArr3 = MONTH_LENGTH;
            if (i4 >= iArr3.length) {
                break;
            }
            DEFAULT_MONTH_LENGTHS[i4] = Integer.valueOf(iArr3[i4]);
            i4++;
        }
        DEFAULT_LEAP_MONTH_LENGTHS = new Integer[LEAP_MONTH_LENGTH.length];
        int i5 = 0;
        while (true) {
            int[] iArr4 = LEAP_MONTH_LENGTH;
            if (i5 >= iArr4.length) {
                break;
            }
            DEFAULT_LEAP_MONTH_LENGTHS[i5] = Integer.valueOf(iArr4[i5]);
            i5++;
        }
        DEFAULT_CYCLE_YEARS = new Integer[CYCLEYEAR_START_DATE.length];
        int i6 = 0;
        while (true) {
            int[] iArr5 = CYCLEYEAR_START_DATE;
            if (i6 >= iArr5.length) {
                break;
            }
            DEFAULT_CYCLE_YEARS[i6] = Integer.valueOf(iArr5[i6]);
            i6++;
        }
        ADJUSTED_CYCLES = new Long[MAX_ADJUSTED_CYCLE];
        int i7 = 0;
        while (true) {
            Long[] lArr = ADJUSTED_CYCLES;
            if (i7 >= lArr.length) {
                break;
            }
            lArr[i7] = Long.valueOf(i7 * 10631);
            i7++;
        }
        ADJUSTED_MIN_VALUES = new Integer[MIN_VALUES.length];
        int i8 = 0;
        while (true) {
            int[] iArr6 = MIN_VALUES;
            if (i8 >= iArr6.length) {
                break;
            }
            ADJUSTED_MIN_VALUES[i8] = Integer.valueOf(iArr6[i8]);
            i8++;
        }
        ADJUSTED_LEAST_MAX_VALUES = new Integer[LEAST_MAX_VALUES.length];
        int i9 = 0;
        while (true) {
            int[] iArr7 = LEAST_MAX_VALUES;
            if (i9 >= iArr7.length) {
                break;
            }
            ADJUSTED_LEAST_MAX_VALUES[i9] = Integer.valueOf(iArr7[i9]);
            i9++;
        }
        ADJUSTED_MAX_VALUES = new Integer[MAX_VALUES.length];
        while (true) {
            int[] iArr8 = MAX_VALUES;
            if (i < iArr8.length) {
                ADJUSTED_MAX_VALUES[i] = Integer.valueOf(iArr8[i]);
                i++;
            } else {
                try {
                    readDeviationConfig();
                    return;
                } catch (IOException | ParseException unused) {
                    return;
                }
            }
        }
    }

    public static gsX now() {
        return now(AbstractC15514gsj.systemDefaultZone());
    }

    public static gsX now(AbstractC15502gsH abstractC15502gsH) {
        return now(AbstractC15514gsj.system(abstractC15502gsH));
    }

    public static gsX now(AbstractC15514gsj abstractC15514gsj) {
        return C15540gta.INSTANCE.dateNow(abstractC15514gsj);
    }

    public static gsX of(int i, int i2, int i3) {
        if (i > 0) {
            return of(EnumC15504gsZ.AH, i, i2, i3);
        }
        return of(EnumC15504gsZ.BEFORE_AH, 1 - i, i2, i3);
    }

    static gsX of(EnumC15504gsZ enumC15504gsZ, int i, int i2, int i3) {
        gtG.requireNonNull(enumC15504gsZ, "era");
        checkValidYearOfEra(i);
        checkValidMonth(i2);
        checkValidDayOfMonth(i3);
        return new gsX(getGregorianEpochDay(enumC15504gsZ.prolepticYear(i), i2, i3));
    }

    private static void checkValidYearOfEra(int i) {
        if (i <= 0 || i > 9999) {
            throw new DateTimeException("Invalid year of Hijrah Era");
        }
    }

    private static void checkValidDayOfYear(int i) {
        if (i <= 0 || i > getMaximumDayOfYear()) {
            throw new DateTimeException("Invalid day of year of Hijrah date");
        }
    }

    private static void checkValidMonth(int i) {
        if (i <= 0 || i > 12) {
            throw new DateTimeException("Invalid month of Hijrah date");
        }
    }

    private static void checkValidDayOfMonth(int i) {
        if (i <= 0 || i > getMaximumDayOfMonth()) {
            StringBuilder sb = new StringBuilder("Invalid day of month of Hijrah date, day ");
            sb.append(i);
            sb.append(" greater than ");
            sb.append(getMaximumDayOfMonth());
            sb.append(" or less than 1");
            throw new DateTimeException(sb.toString());
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static gsX of(C15520gsp c15520gsp) {
        return new gsX(c15520gsp.toEpochDay());
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static gsX ofEpochDay(long j) {
        return new gsX(j);
    }

    public static gsX from(gtK gtk) {
        return C15540gta.INSTANCE.date(gtk);
    }

    private gsX(long j) {
        int[] hijrahDateInfo = getHijrahDateInfo(j);
        checkValidYearOfEra(hijrahDateInfo[1]);
        checkValidMonth(hijrahDateInfo[2]);
        checkValidDayOfMonth(hijrahDateInfo[3]);
        checkValidDayOfYear(hijrahDateInfo[4]);
        this.era = EnumC15504gsZ.of(hijrahDateInfo[0]);
        int i = hijrahDateInfo[1];
        this.yearOfEra = i;
        this.monthOfYear = hijrahDateInfo[2];
        this.dayOfMonth = hijrahDateInfo[3];
        this.dayOfYear = hijrahDateInfo[4];
        this.dayOfWeek = EnumC15515gsk.of(hijrahDateInfo[5]);
        this.gregorianEpochDay = j;
        this.isLeapYear = isLeapYear(i);
    }

    private Object readResolve() {
        return new gsX(this.gregorianEpochDay);
    }

    @Override // o.gsJ
    public final C15540gta getChronology() {
        return C15540gta.INSTANCE;
    }

    @Override // o.gtE, o.gtK
    public final gtT range(InterfaceC15537gtP interfaceC15537gtP) {
        if (interfaceC15537gtP instanceof EnumC15534gtD) {
            if (isSupported(interfaceC15537gtP)) {
                EnumC15534gtD enumC15534gtD = (EnumC15534gtD) interfaceC15537gtP;
                int i = AnonymousClass3.$SwitchMap$org$threeten$bp$temporal$ChronoField[enumC15534gtD.ordinal()];
                if (i == 1) {
                    return gtT.of(1L, lengthOfMonth());
                }
                if (i == 2) {
                    return gtT.of(1L, lengthOfYear());
                }
                if (i == 3) {
                    return gtT.of(1L, 5L);
                }
                if (i == 4) {
                    return gtT.of(1L, 1000L);
                }
                return getChronology().range(enumC15534gtD);
            }
            throw new UnsupportedTemporalTypeException("Unsupported field: ".concat(String.valueOf(interfaceC15537gtP)));
        }
        return interfaceC15537gtP.rangeRefinedBy(this);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: o.gsX$3, reason: invalid class name */
    /* loaded from: classes6.dex */
    public static /* synthetic */ class AnonymousClass3 {
        static final int[] $SwitchMap$org$threeten$bp$temporal$ChronoField;

        static {
            int[] iArr = new int[EnumC15534gtD.values().length];
            $SwitchMap$org$threeten$bp$temporal$ChronoField = iArr;
            try {
                iArr[EnumC15534gtD.DAY_OF_MONTH.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$org$threeten$bp$temporal$ChronoField[EnumC15534gtD.DAY_OF_YEAR.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                $SwitchMap$org$threeten$bp$temporal$ChronoField[EnumC15534gtD.ALIGNED_WEEK_OF_MONTH.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                $SwitchMap$org$threeten$bp$temporal$ChronoField[EnumC15534gtD.YEAR_OF_ERA.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
            try {
                $SwitchMap$org$threeten$bp$temporal$ChronoField[EnumC15534gtD.DAY_OF_WEEK.ordinal()] = 5;
            } catch (NoSuchFieldError unused5) {
            }
            try {
                $SwitchMap$org$threeten$bp$temporal$ChronoField[EnumC15534gtD.ALIGNED_DAY_OF_WEEK_IN_MONTH.ordinal()] = 6;
            } catch (NoSuchFieldError unused6) {
            }
            try {
                $SwitchMap$org$threeten$bp$temporal$ChronoField[EnumC15534gtD.ALIGNED_DAY_OF_WEEK_IN_YEAR.ordinal()] = 7;
            } catch (NoSuchFieldError unused7) {
            }
            try {
                $SwitchMap$org$threeten$bp$temporal$ChronoField[EnumC15534gtD.EPOCH_DAY.ordinal()] = 8;
            } catch (NoSuchFieldError unused8) {
            }
            try {
                $SwitchMap$org$threeten$bp$temporal$ChronoField[EnumC15534gtD.ALIGNED_WEEK_OF_YEAR.ordinal()] = 9;
            } catch (NoSuchFieldError unused9) {
            }
            try {
                $SwitchMap$org$threeten$bp$temporal$ChronoField[EnumC15534gtD.MONTH_OF_YEAR.ordinal()] = 10;
            } catch (NoSuchFieldError unused10) {
            }
            try {
                $SwitchMap$org$threeten$bp$temporal$ChronoField[EnumC15534gtD.YEAR.ordinal()] = 11;
            } catch (NoSuchFieldError unused11) {
            }
            try {
                $SwitchMap$org$threeten$bp$temporal$ChronoField[EnumC15534gtD.ERA.ordinal()] = 12;
            } catch (NoSuchFieldError unused12) {
            }
        }
    }

    /* JADX WARN: Failed to find 'out' block for switch in B:4:0x000f. Please report as an issue. */
    @Override // o.gtK
    public final long getLong(InterfaceC15537gtP interfaceC15537gtP) {
        int i;
        int i2;
        if (interfaceC15537gtP instanceof EnumC15534gtD) {
            switch (AnonymousClass3.$SwitchMap$org$threeten$bp$temporal$ChronoField[((EnumC15534gtD) interfaceC15537gtP).ordinal()]) {
                case 1:
                    i = this.dayOfMonth;
                    return i;
                case 2:
                    i = this.dayOfYear;
                    return i;
                case 3:
                    i2 = (this.dayOfMonth - 1) / 7;
                    i = i2 + 1;
                    return i;
                case 4:
                    i = this.yearOfEra;
                    return i;
                case 5:
                    i = this.dayOfWeek.getValue();
                    return i;
                case 6:
                    i2 = (this.dayOfMonth - 1) % 7;
                    i = i2 + 1;
                    return i;
                case 7:
                    i2 = (this.dayOfYear - 1) % 7;
                    i = i2 + 1;
                    return i;
                case 8:
                    return toEpochDay();
                case 9:
                    i2 = (this.dayOfYear - 1) / 7;
                    i = i2 + 1;
                    return i;
                case 10:
                    i = this.monthOfYear;
                    return i;
                case 11:
                    i = this.yearOfEra;
                    return i;
                case 12:
                    i = this.era.getValue();
                    return i;
                default:
                    throw new UnsupportedTemporalTypeException("Unsupported field: ".concat(String.valueOf(interfaceC15537gtP)));
            }
        }
        return interfaceC15537gtP.getFrom(this);
    }

    @Override // o.gsJ, o.AbstractC15535gtF, o.InterfaceC15536gtL
    public final gsX with(gtJ gtj) {
        return (gsX) super.with(gtj);
    }

    /* JADX WARN: Type inference failed for: r5v14, types: [o.gsX] */
    /* JADX WARN: Type inference failed for: r5v16, types: [o.gsX] */
    /* JADX WARN: Type inference failed for: r5v18, types: [o.gsX] */
    /* JADX WARN: Type inference failed for: r5v21, types: [o.gsX] */
    /* JADX WARN: Type inference failed for: r5v8, types: [o.gsX] */
    @Override // o.gsJ, o.InterfaceC15536gtL
    public final gsX with(InterfaceC15537gtP interfaceC15537gtP, long j) {
        if (interfaceC15537gtP instanceof EnumC15534gtD) {
            EnumC15534gtD enumC15534gtD = (EnumC15534gtD) interfaceC15537gtP;
            enumC15534gtD.checkValidValue(j);
            int i = (int) j;
            switch (AnonymousClass3.$SwitchMap$org$threeten$bp$temporal$ChronoField[enumC15534gtD.ordinal()]) {
                case 1:
                    return resolvePreviousValid(this.yearOfEra, this.monthOfYear, i);
                case 2:
                    int i2 = i - 1;
                    return resolvePreviousValid(this.yearOfEra, (i2 / 30) + 1, (i2 % 30) + 1);
                case 3:
                    return plusDays((j - getLong(EnumC15534gtD.ALIGNED_WEEK_OF_MONTH)) * 7);
                case 4:
                    if (this.yearOfEra <= 0) {
                        i = 1 - i;
                    }
                    return resolvePreviousValid(i, this.monthOfYear, this.dayOfMonth);
                case 5:
                    return plusDays(j - this.dayOfWeek.getValue());
                case 6:
                    return plusDays(j - getLong(EnumC15534gtD.ALIGNED_DAY_OF_WEEK_IN_MONTH));
                case 7:
                    return plusDays(j - getLong(EnumC15534gtD.ALIGNED_DAY_OF_WEEK_IN_YEAR));
                case 8:
                    return new gsX(i);
                case 9:
                    return plusDays((j - getLong(EnumC15534gtD.ALIGNED_WEEK_OF_YEAR)) * 7);
                case 10:
                    return resolvePreviousValid(this.yearOfEra, i, this.dayOfMonth);
                case 11:
                    return resolvePreviousValid(i, this.monthOfYear, this.dayOfMonth);
                case 12:
                    return resolvePreviousValid(1 - this.yearOfEra, this.monthOfYear, this.dayOfMonth);
                default:
                    throw new UnsupportedTemporalTypeException("Unsupported field: ".concat(String.valueOf(interfaceC15537gtP)));
            }
        }
        return (gsX) interfaceC15537gtP.adjustInto(this, j);
    }

    private static gsX resolvePreviousValid(int i, int i2, int i3) {
        int monthDays = getMonthDays(i2 - 1, i);
        if (i3 > monthDays) {
            i3 = monthDays;
        }
        return of(i, i2, i3);
    }

    @Override // o.gsJ, o.AbstractC15535gtF, o.InterfaceC15536gtL
    public final gsX plus(gtN gtn) {
        return (gsX) super.plus(gtn);
    }

    @Override // o.gsK, o.gsJ, o.InterfaceC15536gtL
    public final gsX plus(long j, InterfaceC15539gtV interfaceC15539gtV) {
        return (gsX) super.plus(j, interfaceC15539gtV);
    }

    @Override // o.gsJ, o.AbstractC15535gtF, o.InterfaceC15536gtL
    public final gsX minus(gtN gtn) {
        return (gsX) super.minus(gtn);
    }

    @Override // o.gsJ, o.AbstractC15535gtF, o.InterfaceC15536gtL
    public final gsX minus(long j, InterfaceC15539gtV interfaceC15539gtV) {
        return (gsX) super.minus(j, interfaceC15539gtV);
    }

    @Override // o.gsK, o.gsJ
    public final gsO<gsX> atTime(C15521gsq c15521gsq) {
        return super.atTime(c15521gsq);
    }

    @Override // o.gsJ
    public final long toEpochDay() {
        return getGregorianEpochDay(this.yearOfEra, this.monthOfYear, this.dayOfMonth);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    @Override // o.gsK
    public final gsK<gsX> plusYears(long j) {
        if (j == 0) {
            return this;
        }
        return of(this.era, gtG.safeAdd(this.yearOfEra, (int) j), this.monthOfYear, this.dayOfMonth);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    @Override // o.gsK
    public final gsK<gsX> plusMonths(long j) {
        if (j == 0) {
            return this;
        }
        int i = (this.monthOfYear - 1) + ((int) j);
        int i2 = i / 12;
        int i3 = i % 12;
        while (i3 < 0) {
            i3 += 12;
            i2 = gtG.safeSubtract(i2, 1);
        }
        return of(this.era, gtG.safeAdd(this.yearOfEra, i2), i3 + 1, this.dayOfMonth);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    @Override // o.gsK
    public final gsK<gsX> plusDays(long j) {
        return new gsX(this.gregorianEpochDay + j);
    }

    private static int[] getHijrahDateInfo(long j) {
        int i;
        int i2;
        int monthOfYear;
        int dayOfMonth;
        int value;
        long j2 = 492148 + j;
        if (j2 >= 0) {
            int cycleNumber = getCycleNumber(j2);
            int dayOfCycle = getDayOfCycle(j2, cycleNumber);
            int yearInCycle = getYearInCycle(cycleNumber, dayOfCycle);
            i2 = getDayOfYear(cycleNumber, dayOfCycle, yearInCycle);
            i = (cycleNumber * 30) + yearInCycle + 1;
            monthOfYear = getMonthOfYear(i2, i);
            dayOfMonth = getDayOfMonth(i2, monthOfYear, i) + 1;
            value = EnumC15504gsZ.AH.getValue();
        } else {
            int i3 = (int) j2;
            int i4 = i3 / 10631;
            int i5 = i3 % 10631;
            if (i5 == 0) {
                i4++;
                i5 = -10631;
            }
            int yearInCycle2 = getYearInCycle(i4, i5);
            int dayOfYear = getDayOfYear(i4, i5, yearInCycle2);
            i = 1 - ((i4 * 30) - yearInCycle2);
            i2 = isLeapYear((long) i) ? dayOfYear + 355 : dayOfYear + 354;
            monthOfYear = getMonthOfYear(i2, i);
            dayOfMonth = getDayOfMonth(i2, monthOfYear, i) + 1;
            value = EnumC15504gsZ.BEFORE_AH.getValue();
        }
        int i6 = (int) ((j + 492153) % 7);
        return new int[]{value, i, monthOfYear + 1, dayOfMonth, i2 + 1, i6 + (i6 <= 0 ? 7 : 0)};
    }

    private static long getGregorianEpochDay(int i, int i2, int i3) {
        return yearToGregorianEpochDay(i) + getMonthDays(i2 - 1, i) + i3;
    }

    private static long yearToGregorianEpochDay(int i) {
        Long l;
        int i2 = i - 1;
        int i3 = i2 / 30;
        int i4 = i2 % 30;
        int intValue = getAdjustedCycle(i3)[Math.abs(i4)].intValue();
        if (i4 < 0) {
            intValue = -intValue;
        }
        try {
            l = ADJUSTED_CYCLES[i3];
        } catch (ArrayIndexOutOfBoundsException unused) {
            l = null;
        }
        if (l == null) {
            l = Long.valueOf(i3 * 10631);
        }
        return (l.longValue() + intValue) - 492149;
    }

    private static int getCycleNumber(long j) {
        Long[] lArr = ADJUSTED_CYCLES;
        for (int i = 0; i < lArr.length; i++) {
            try {
                if (j < lArr[i].longValue()) {
                    return i - 1;
                }
            } catch (ArrayIndexOutOfBoundsException unused) {
                return ((int) j) / 10631;
            }
        }
        return ((int) j) / 10631;
    }

    private static int getDayOfCycle(long j, int i) {
        Long l;
        try {
            l = ADJUSTED_CYCLES[i];
        } catch (ArrayIndexOutOfBoundsException unused) {
            l = null;
        }
        if (l == null) {
            l = Long.valueOf(i * 10631);
        }
        return (int) (j - l.longValue());
    }

    private static int getYearInCycle(int i, long j) {
        Integer[] adjustedCycle = getAdjustedCycle(i);
        int i2 = 0;
        if (j == 0) {
            return 0;
        }
        if (j > 0) {
            while (i2 < adjustedCycle.length) {
                if (j < adjustedCycle[i2].intValue()) {
                    return i2 - 1;
                }
                i2++;
            }
            return 29;
        }
        long j2 = -j;
        while (i2 < adjustedCycle.length) {
            if (j2 <= adjustedCycle[i2].intValue()) {
                return i2 - 1;
            }
            i2++;
        }
        return 29;
    }

    private static Integer[] getAdjustedCycle(int i) {
        Integer[] numArr;
        try {
            numArr = ADJUSTED_CYCLE_YEARS.get(Integer.valueOf(i));
        } catch (ArrayIndexOutOfBoundsException unused) {
            numArr = null;
        }
        return numArr == null ? DEFAULT_CYCLE_YEARS : numArr;
    }

    private static Integer[] getAdjustedMonthDays(int i) {
        Integer[] numArr;
        try {
            numArr = ADJUSTED_MONTH_DAYS.get(Integer.valueOf(i));
        } catch (ArrayIndexOutOfBoundsException unused) {
            numArr = null;
        }
        return numArr == null ? isLeapYear((long) i) ? DEFAULT_LEAP_MONTH_DAYS : DEFAULT_MONTH_DAYS : numArr;
    }

    private static Integer[] getAdjustedMonthLength(int i) {
        Integer[] numArr;
        try {
            numArr = ADJUSTED_MONTH_LENGTHS.get(Integer.valueOf(i));
        } catch (ArrayIndexOutOfBoundsException unused) {
            numArr = null;
        }
        return numArr == null ? isLeapYear((long) i) ? DEFAULT_LEAP_MONTH_LENGTHS : DEFAULT_MONTH_LENGTHS : numArr;
    }

    private static int getDayOfYear(int i, int i2, int i3) {
        Integer[] adjustedCycle = getAdjustedCycle(i);
        if (i2 > 0) {
            return i2 - adjustedCycle[i3].intValue();
        }
        return adjustedCycle[i3].intValue() + i2;
    }

    private static int getMonthOfYear(int i, int i2) {
        Integer[] adjustedMonthDays = getAdjustedMonthDays(i2);
        int i3 = 0;
        if (i >= 0) {
            while (i3 < adjustedMonthDays.length) {
                if (i < adjustedMonthDays[i3].intValue()) {
                    return i3 - 1;
                }
                i3++;
            }
            return 11;
        }
        int i4 = isLeapYear((long) i2) ? i + 355 : i + 354;
        while (i3 < adjustedMonthDays.length) {
            if (i4 < adjustedMonthDays[i3].intValue()) {
                return i3 - 1;
            }
            i3++;
        }
        return 11;
    }

    private static int getDayOfMonth(int i, int i2, int i3) {
        int intValue;
        Integer[] adjustedMonthDays = getAdjustedMonthDays(i3);
        if (i < 0) {
            i = isLeapYear((long) i3) ? i + 355 : i + 354;
            if (i2 <= 0) {
                return i;
            }
            intValue = adjustedMonthDays[i2].intValue();
        } else {
            if (i2 <= 0) {
                return i;
            }
            intValue = adjustedMonthDays[i2].intValue();
        }
        return i - intValue;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static boolean isLeapYear(long j) {
        if (j <= 0) {
            j = -j;
        }
        return ((j * 11) + 14) % 30 < 11;
    }

    private static int getMonthDays(int i, int i2) {
        return getAdjustedMonthDays(i2)[i].intValue();
    }

    static int getMonthLength(int i, int i2) {
        return getAdjustedMonthLength(i2)[i].intValue();
    }

    @Override // o.gsJ
    public final int lengthOfMonth() {
        return getMonthLength(this.monthOfYear - 1, this.yearOfEra);
    }

    static int getYearLength(int i) {
        Integer[] numArr;
        int i2 = i - 1;
        int i3 = i2 / 30;
        try {
            numArr = ADJUSTED_CYCLE_YEARS.get(Integer.valueOf(i3));
        } catch (ArrayIndexOutOfBoundsException unused) {
            numArr = null;
        }
        if (numArr == null) {
            return isLeapYear((long) i) ? 355 : 354;
        }
        int i4 = i2 % 30;
        if (i4 == 29) {
            Long[] lArr = ADJUSTED_CYCLES;
            return (lArr[i3 + 1].intValue() - lArr[i3].intValue()) - numArr[i4].intValue();
        }
        return numArr[i4 + 1].intValue() - numArr[i4].intValue();
    }

    @Override // o.gsJ
    public final int lengthOfYear() {
        return getYearLength(this.yearOfEra);
    }

    static int getMaximumDayOfMonth() {
        return ADJUSTED_MAX_VALUES[5].intValue();
    }

    static int getSmallestMaximumDayOfMonth() {
        return ADJUSTED_LEAST_MAX_VALUES[5].intValue();
    }

    static int getMaximumDayOfYear() {
        return ADJUSTED_MAX_VALUES[6].intValue();
    }

    static int getSmallestMaximumDayOfYear() {
        return ADJUSTED_LEAST_MAX_VALUES[6].intValue();
    }

    private static void addDeviationAsHijrah(int i, int i2, int i3, int i4, int i5) {
        if (i <= 0) {
            throw new IllegalArgumentException("startYear < 1");
        }
        if (i3 <= 0) {
            throw new IllegalArgumentException("endYear < 1");
        }
        if (i2 < 0 || i2 > 11) {
            throw new IllegalArgumentException("startMonth < 0 || startMonth > 11");
        }
        if (i4 < 0 || i4 > 11) {
            throw new IllegalArgumentException("endMonth < 0 || endMonth > 11");
        }
        if (i3 > 9999) {
            throw new IllegalArgumentException("endYear > 9999");
        }
        if (i3 < i) {
            throw new IllegalArgumentException("startYear > endYear");
        }
        if (i3 == i && i4 < i2) {
            throw new IllegalArgumentException("startYear == endYear && endMonth < startMonth");
        }
        boolean isLeapYear = isLeapYear(i);
        Integer[] numArr = ADJUSTED_MONTH_DAYS.get(Integer.valueOf(i));
        if (numArr == null) {
            if (isLeapYear) {
                numArr = new Integer[LEAP_NUM_DAYS.length];
                int i6 = 0;
                while (true) {
                    int[] iArr = LEAP_NUM_DAYS;
                    if (i6 >= iArr.length) {
                        break;
                    }
                    numArr[i6] = Integer.valueOf(iArr[i6]);
                    i6++;
                }
            } else {
                numArr = new Integer[NUM_DAYS.length];
                int i7 = 0;
                while (true) {
                    int[] iArr2 = NUM_DAYS;
                    if (i7 >= iArr2.length) {
                        break;
                    }
                    numArr[i7] = Integer.valueOf(iArr2[i7]);
                    i7++;
                }
            }
        }
        Integer[] numArr2 = new Integer[numArr.length];
        for (int i8 = 0; i8 < 12; i8++) {
            if (i8 > i2) {
                numArr2[i8] = Integer.valueOf(numArr[i8].intValue() - i5);
            } else {
                numArr2[i8] = Integer.valueOf(numArr[i8].intValue());
            }
        }
        ADJUSTED_MONTH_DAYS.put(Integer.valueOf(i), numArr2);
        Integer[] numArr3 = ADJUSTED_MONTH_LENGTHS.get(Integer.valueOf(i));
        if (numArr3 == null) {
            if (isLeapYear) {
                numArr3 = new Integer[LEAP_MONTH_LENGTH.length];
                int i9 = 0;
                while (true) {
                    int[] iArr3 = LEAP_MONTH_LENGTH;
                    if (i9 >= iArr3.length) {
                        break;
                    }
                    numArr3[i9] = Integer.valueOf(iArr3[i9]);
                    i9++;
                }
            } else {
                numArr3 = new Integer[MONTH_LENGTH.length];
                int i10 = 0;
                while (true) {
                    int[] iArr4 = MONTH_LENGTH;
                    if (i10 >= iArr4.length) {
                        break;
                    }
                    numArr3[i10] = Integer.valueOf(iArr4[i10]);
                    i10++;
                }
            }
        }
        Integer[] numArr4 = new Integer[numArr3.length];
        for (int i11 = 0; i11 < 12; i11++) {
            if (i11 == i2) {
                numArr4[i11] = Integer.valueOf(numArr3[i11].intValue() - i5);
            } else {
                numArr4[i11] = Integer.valueOf(numArr3[i11].intValue());
            }
        }
        ADJUSTED_MONTH_LENGTHS.put(Integer.valueOf(i), numArr4);
        if (i != i3) {
            int i12 = i - 1;
            int i13 = i12 / 30;
            Integer[] numArr5 = ADJUSTED_CYCLE_YEARS.get(Integer.valueOf(i13));
            if (numArr5 == null) {
                int length = CYCLEYEAR_START_DATE.length;
                Integer[] numArr6 = new Integer[length];
                for (int i14 = 0; i14 < length; i14++) {
                    numArr6[i14] = Integer.valueOf(CYCLEYEAR_START_DATE[i14]);
                }
                numArr5 = numArr6;
            }
            int i15 = i12 % 30;
            while (true) {
                i15++;
                if (i15 >= CYCLEYEAR_START_DATE.length) {
                    break;
                } else {
                    numArr5[i15] = Integer.valueOf(numArr5[i15].intValue() - i5);
                }
            }
            ADJUSTED_CYCLE_YEARS.put(Integer.valueOf(i13), numArr5);
            int i16 = i3 - 1;
            int i17 = i16 / 30;
            if (i13 != i17) {
                while (true) {
                    i13++;
                    Long[] lArr = ADJUSTED_CYCLES;
                    if (i13 >= lArr.length) {
                        break;
                    } else {
                        lArr[i13] = Long.valueOf(lArr[i13].longValue() - i5);
                    }
                }
                int i18 = i17 + 1;
                while (true) {
                    Long[] lArr2 = ADJUSTED_CYCLES;
                    if (i18 >= lArr2.length) {
                        break;
                    }
                    lArr2[i18] = Long.valueOf(lArr2[i18].longValue() + i5);
                    i18++;
                }
            }
            Integer[] numArr7 = ADJUSTED_CYCLE_YEARS.get(Integer.valueOf(i17));
            if (numArr7 == null) {
                int length2 = CYCLEYEAR_START_DATE.length;
                Integer[] numArr8 = new Integer[length2];
                for (int i19 = 0; i19 < length2; i19++) {
                    numArr8[i19] = Integer.valueOf(CYCLEYEAR_START_DATE[i19]);
                }
                numArr7 = numArr8;
            }
            int i20 = i16 % 30;
            while (true) {
                i20++;
                if (i20 >= CYCLEYEAR_START_DATE.length) {
                    break;
                } else {
                    numArr7[i20] = Integer.valueOf(numArr7[i20].intValue() + i5);
                }
            }
            ADJUSTED_CYCLE_YEARS.put(Integer.valueOf(i17), numArr7);
        }
        boolean isLeapYear2 = isLeapYear(i3);
        Integer[] numArr9 = ADJUSTED_MONTH_DAYS.get(Integer.valueOf(i3));
        if (numArr9 == null) {
            if (isLeapYear2) {
                numArr9 = new Integer[LEAP_NUM_DAYS.length];
                int i21 = 0;
                while (true) {
                    int[] iArr5 = LEAP_NUM_DAYS;
                    if (i21 >= iArr5.length) {
                        break;
                    }
                    numArr9[i21] = Integer.valueOf(iArr5[i21]);
                    i21++;
                }
            } else {
                numArr9 = new Integer[NUM_DAYS.length];
                int i22 = 0;
                while (true) {
                    int[] iArr6 = NUM_DAYS;
                    if (i22 >= iArr6.length) {
                        break;
                    }
                    numArr9[i22] = Integer.valueOf(iArr6[i22]);
                    i22++;
                }
            }
        }
        Integer[] numArr10 = new Integer[numArr9.length];
        for (int i23 = 0; i23 < 12; i23++) {
            if (i23 > i4) {
                numArr10[i23] = Integer.valueOf(numArr9[i23].intValue() + i5);
            } else {
                numArr10[i23] = Integer.valueOf(numArr9[i23].intValue());
            }
        }
        ADJUSTED_MONTH_DAYS.put(Integer.valueOf(i3), numArr10);
        Integer[] numArr11 = ADJUSTED_MONTH_LENGTHS.get(Integer.valueOf(i3));
        if (numArr11 == null) {
            if (isLeapYear2) {
                numArr11 = new Integer[LEAP_MONTH_LENGTH.length];
                int i24 = 0;
                while (true) {
                    int[] iArr7 = LEAP_MONTH_LENGTH;
                    if (i24 >= iArr7.length) {
                        break;
                    }
                    numArr11[i24] = Integer.valueOf(iArr7[i24]);
                    i24++;
                }
            } else {
                numArr11 = new Integer[MONTH_LENGTH.length];
                int i25 = 0;
                while (true) {
                    int[] iArr8 = MONTH_LENGTH;
                    if (i25 >= iArr8.length) {
                        break;
                    }
                    numArr11[i25] = Integer.valueOf(iArr8[i25]);
                    i25++;
                }
            }
        }
        Integer[] numArr12 = new Integer[numArr11.length];
        for (int i26 = 0; i26 < 12; i26++) {
            if (i26 == i4) {
                numArr12[i26] = Integer.valueOf(numArr11[i26].intValue() + i5);
            } else {
                numArr12[i26] = Integer.valueOf(numArr11[i26].intValue());
            }
        }
        HashMap<Integer, Integer[]> hashMap = ADJUSTED_MONTH_LENGTHS;
        hashMap.put(Integer.valueOf(i3), numArr12);
        Integer[] numArr13 = hashMap.get(Integer.valueOf(i));
        Integer[] numArr14 = hashMap.get(Integer.valueOf(i3));
        HashMap<Integer, Integer[]> hashMap2 = ADJUSTED_MONTH_DAYS;
        Integer[] numArr15 = hashMap2.get(Integer.valueOf(i));
        Integer[] numArr16 = hashMap2.get(Integer.valueOf(i3));
        int intValue = numArr13[i2].intValue();
        int intValue2 = numArr14[i4].intValue();
        int intValue3 = numArr15[11].intValue() + numArr13[11].intValue();
        int intValue4 = numArr16[11].intValue() + numArr14[11].intValue();
        Integer[] numArr17 = ADJUSTED_MAX_VALUES;
        int intValue5 = numArr17[5].intValue();
        Integer[] numArr18 = ADJUSTED_LEAST_MAX_VALUES;
        int intValue6 = numArr18[5].intValue();
        if (intValue5 < intValue) {
            intValue5 = intValue;
        }
        if (intValue5 < intValue2) {
            intValue5 = intValue2;
        }
        numArr17[5] = Integer.valueOf(intValue5);
        if (intValue6 <= intValue) {
            intValue = intValue6;
        }
        if (intValue <= intValue2) {
            intValue2 = intValue;
        }
        numArr18[5] = Integer.valueOf(intValue2);
        int intValue7 = numArr17[6].intValue();
        int intValue8 = numArr18[6].intValue();
        if (intValue7 < intValue3) {
            intValue7 = intValue3;
        }
        if (intValue7 < intValue4) {
            intValue7 = intValue4;
        }
        numArr17[6] = Integer.valueOf(intValue7);
        if (intValue8 <= intValue3) {
            intValue3 = intValue8;
        }
        if (intValue3 <= intValue4) {
            intValue4 = intValue3;
        }
        numArr18[6] = Integer.valueOf(intValue4);
    }

    private static void readDeviationConfig() throws IOException, ParseException {
        BufferedReader bufferedReader;
        InputStream configFileInputStream = getConfigFileInputStream();
        if (configFileInputStream == null) {
            return;
        }
        try {
            bufferedReader = new BufferedReader(new InputStreamReader(configFileInputStream));
            int i = 0;
            while (true) {
                try {
                    String readLine = bufferedReader.readLine();
                    if (readLine != null) {
                        i++;
                        parseLine(readLine.trim(), i);
                    } else {
                        bufferedReader.close();
                        return;
                    }
                } catch (Throwable th) {
                    th = th;
                    if (bufferedReader != null) {
                        bufferedReader.close();
                    }
                    throw th;
                }
            }
        } catch (Throwable th2) {
            th = th2;
            bufferedReader = null;
        }
    }

    private static void parseLine(String str, int i) throws ParseException {
        StringTokenizer stringTokenizer = new StringTokenizer(str, ";");
        while (stringTokenizer.hasMoreTokens()) {
            String nextToken = stringTokenizer.nextToken();
            int indexOf = nextToken.indexOf(58);
            if (indexOf != -1) {
                try {
                    int parseInt = Integer.parseInt(nextToken.substring(indexOf + 1, nextToken.length()));
                    int indexOf2 = nextToken.indexOf(45);
                    if (indexOf2 != -1) {
                        String substring = nextToken.substring(0, indexOf2);
                        String substring2 = nextToken.substring(indexOf2 + 1, indexOf);
                        int indexOf3 = substring.indexOf(47);
                        int indexOf4 = substring2.indexOf(47);
                        if (indexOf3 != -1) {
                            String substring3 = substring.substring(0, indexOf3);
                            String substring4 = substring.substring(indexOf3 + 1, substring.length());
                            try {
                                int parseInt2 = Integer.parseInt(substring3);
                                try {
                                    int parseInt3 = Integer.parseInt(substring4);
                                    if (indexOf4 != -1) {
                                        String substring5 = substring2.substring(0, indexOf4);
                                        String substring6 = substring2.substring(indexOf4 + 1, substring2.length());
                                        try {
                                            int parseInt4 = Integer.parseInt(substring5);
                                            try {
                                                int parseInt5 = Integer.parseInt(substring6);
                                                if (parseInt2 != -1 && parseInt3 != -1 && parseInt4 != -1 && parseInt5 != -1) {
                                                    addDeviationAsHijrah(parseInt2, parseInt3, parseInt4, parseInt5, parseInt);
                                                } else {
                                                    StringBuilder sb = new StringBuilder("Unknown error at line ");
                                                    sb.append(i);
                                                    sb.append(".");
                                                    throw new ParseException(sb.toString(), i);
                                                }
                                            } catch (NumberFormatException unused) {
                                                StringBuilder sb2 = new StringBuilder("End month is not properly set at line ");
                                                sb2.append(i);
                                                sb2.append(".");
                                                throw new ParseException(sb2.toString(), i);
                                            }
                                        } catch (NumberFormatException unused2) {
                                            StringBuilder sb3 = new StringBuilder("End year is not properly set at line ");
                                            sb3.append(i);
                                            sb3.append(".");
                                            throw new ParseException(sb3.toString(), i);
                                        }
                                    } else {
                                        StringBuilder sb4 = new StringBuilder("End year/month has incorrect format at line ");
                                        sb4.append(i);
                                        sb4.append(".");
                                        throw new ParseException(sb4.toString(), i);
                                    }
                                } catch (NumberFormatException unused3) {
                                    StringBuilder sb5 = new StringBuilder("Start month is not properly set at line ");
                                    sb5.append(i);
                                    sb5.append(".");
                                    throw new ParseException(sb5.toString(), i);
                                }
                            } catch (NumberFormatException unused4) {
                                StringBuilder sb6 = new StringBuilder("Start year is not properly set at line ");
                                sb6.append(i);
                                sb6.append(".");
                                throw new ParseException(sb6.toString(), i);
                            }
                        } else {
                            StringBuilder sb7 = new StringBuilder("Start year/month has incorrect format at line ");
                            sb7.append(i);
                            sb7.append(".");
                            throw new ParseException(sb7.toString(), i);
                        }
                    } else {
                        StringBuilder sb8 = new StringBuilder("Start and end year/month has incorrect format at line ");
                        sb8.append(i);
                        sb8.append(".");
                        throw new ParseException(sb8.toString(), i);
                    }
                } catch (NumberFormatException unused5) {
                    StringBuilder sb9 = new StringBuilder("Offset is not properly set at line ");
                    sb9.append(i);
                    sb9.append(".");
                    throw new ParseException(sb9.toString(), i);
                }
            } else {
                StringBuilder sb10 = new StringBuilder("Offset has incorrect format at line ");
                sb10.append(i);
                sb10.append(".");
                throw new ParseException(sb10.toString(), i);
            }
        }
    }

    private static InputStream getConfigFileInputStream() throws IOException {
        ZipFile zipFile;
        String property = System.getProperty("org.threeten.bp.i18n.HijrahDate.deviationConfigFile");
        if (property == null) {
            property = DEFAULT_CONFIG_FILENAME;
        }
        String property2 = System.getProperty("org.threeten.bp.i18n.HijrahDate.deviationConfigDir");
        if (property2 != null) {
            if (property2.length() != 0 || !property2.endsWith(System.getProperty("file.separator"))) {
                StringBuilder sb = new StringBuilder();
                sb.append(property2);
                sb.append(System.getProperty("file.separator"));
                property2 = sb.toString();
            }
            StringBuilder sb2 = new StringBuilder();
            sb2.append(property2);
            sb2.append(FILE_SEP);
            sb2.append(property);
            File file = new File(sb2.toString());
            if (file.exists()) {
                return new FileInputStream(file);
            }
            return null;
        }
        StringTokenizer stringTokenizer = new StringTokenizer(System.getProperty("java.class.path"), PATH_SEP);
        while (stringTokenizer.hasMoreTokens()) {
            String nextToken = stringTokenizer.nextToken();
            File file2 = new File(nextToken);
            if (file2.exists()) {
                if (file2.isDirectory()) {
                    StringBuilder sb3 = new StringBuilder();
                    sb3.append(nextToken);
                    char c = FILE_SEP;
                    sb3.append(c);
                    String str = DEFAULT_CONFIG_PATH;
                    sb3.append(str);
                    if (new File(sb3.toString(), property).exists()) {
                        StringBuilder sb4 = new StringBuilder();
                        sb4.append(nextToken);
                        sb4.append(c);
                        sb4.append(str);
                        sb4.append(c);
                        sb4.append(property);
                        return new FileInputStream(sb4.toString());
                    }
                } else {
                    try {
                        zipFile = new ZipFile(file2);
                    } catch (IOException unused) {
                        zipFile = null;
                    }
                    if (zipFile != null) {
                        StringBuilder sb5 = new StringBuilder();
                        sb5.append(DEFAULT_CONFIG_PATH);
                        char c2 = FILE_SEP;
                        sb5.append(c2);
                        sb5.append(property);
                        String obj = sb5.toString();
                        ZipEntry entry = zipFile.getEntry(obj);
                        if (entry == null) {
                            if (c2 == '/') {
                                obj = obj.replace('/', '\\');
                            } else if (c2 == '\\') {
                                obj = obj.replace('\\', '/');
                            }
                            entry = zipFile.getEntry(obj);
                        }
                        if (entry != null) {
                            return zipFile.getInputStream(entry);
                        }
                    } else {
                        continue;
                    }
                }
            }
        }
        return null;
    }

    private Object writeReplace() {
        return new C15548gti((byte) 3, this);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public final void writeExternal(DataOutput dataOutput) throws IOException {
        dataOutput.writeInt(get(EnumC15534gtD.YEAR));
        dataOutput.writeByte(get(EnumC15534gtD.MONTH_OF_YEAR));
        dataOutput.writeByte(get(EnumC15534gtD.DAY_OF_MONTH));
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public static gsJ readExternal(DataInput dataInput) throws IOException {
        return C15540gta.INSTANCE.date(dataInput.readInt(), (int) dataInput.readByte(), (int) dataInput.readByte());
    }

    @Override // o.gsJ
    public final boolean isLeapYear() {
        return this.isLeapYear;
    }

    @Override // o.gsJ
    public final EnumC15504gsZ getEra() {
        return this.era;
    }
}