package p037.p087.p088;

import android.content.res.AssetManager;
import android.util.Log;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
import java.util.TimeZone;
import java.util.regex.Pattern;
import p138.p139.p143.p144.C2803;

/* JADX INFO: renamed from: މ.އ.֏.֏, reason: contains not printable characters */
/* JADX INFO: loaded from: classes.dex */
public class C1980 {

    /* JADX INFO: renamed from: ފ, reason: contains not printable characters */
    public static final int[] f6478;

    /* JADX INFO: renamed from: ދ, reason: contains not printable characters */
    public static final int[] f6479;

    /* JADX INFO: renamed from: ތ, reason: contains not printable characters */
    public static final byte[] f6480;

    /* JADX INFO: renamed from: ލ, reason: contains not printable characters */
    public static final byte[] f6481;

    /* JADX INFO: renamed from: ގ, reason: contains not printable characters */
    public static final byte[] f6482;

    /* JADX INFO: renamed from: ޏ, reason: contains not printable characters */
    public static SimpleDateFormat f6483;

    /* JADX INFO: renamed from: ސ, reason: contains not printable characters */
    public static final String[] f6484;

    /* JADX INFO: renamed from: ޑ, reason: contains not printable characters */
    public static final int[] f6485;

    /* JADX INFO: renamed from: ޒ, reason: contains not printable characters */
    public static final byte[] f6486;

    /* JADX INFO: renamed from: ޓ, reason: contains not printable characters */
    public static final C1983[] f6487;

    /* JADX INFO: renamed from: ޔ, reason: contains not printable characters */
    public static final C1983[] f6488;

    /* JADX INFO: renamed from: ޕ, reason: contains not printable characters */
    public static final C1983[] f6489;

    /* JADX INFO: renamed from: ޖ, reason: contains not printable characters */
    public static final C1983[] f6490;

    /* JADX INFO: renamed from: ޗ, reason: contains not printable characters */
    public static final C1983[] f6491;

    /* JADX INFO: renamed from: ޘ, reason: contains not printable characters */
    public static final C1983 f6492;

    /* JADX INFO: renamed from: ޙ, reason: contains not printable characters */
    public static final C1983[] f6493;

    /* JADX INFO: renamed from: ޚ, reason: contains not printable characters */
    public static final C1983[] f6494;

    /* JADX INFO: renamed from: ޛ, reason: contains not printable characters */
    public static final C1983[] f6495;

    /* JADX INFO: renamed from: ޜ, reason: contains not printable characters */
    public static final C1983[] f6496;

    /* JADX INFO: renamed from: ޝ, reason: contains not printable characters */
    public static final C1983[][] f6497;

    /* JADX INFO: renamed from: ޞ, reason: contains not printable characters */
    public static final C1983[] f6498;

    /* JADX INFO: renamed from: ޟ, reason: contains not printable characters */
    public static final HashMap<Integer, C1983>[] f6499;

    /* JADX INFO: renamed from: ޠ, reason: contains not printable characters */
    public static final HashMap<String, C1983>[] f6500;

    /* JADX INFO: renamed from: ޡ, reason: contains not printable characters */
    public static final HashSet<String> f6501;

    /* JADX INFO: renamed from: ޢ, reason: contains not printable characters */
    public static final HashMap<Integer, Integer> f6502;

    /* JADX INFO: renamed from: ޣ, reason: contains not printable characters */
    public static final Charset f6503;

    /* JADX INFO: renamed from: ޤ, reason: contains not printable characters */
    public static final byte[] f6504;

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final String f6505;

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public final AssetManager.AssetInputStream f6506;

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public int f6507;

    /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
    public final HashMap<String, C1982>[] f6508 = new HashMap[f6497.length];

    /* JADX INFO: renamed from: ނ, reason: contains not printable characters */
    public Set<Integer> f6509 = new HashSet(f6497.length);

    /* JADX INFO: renamed from: ރ, reason: contains not printable characters */
    public ByteOrder f6510 = ByteOrder.BIG_ENDIAN;

    /* JADX INFO: renamed from: ބ, reason: contains not printable characters */
    public int f6511;

    /* JADX INFO: renamed from: ޅ, reason: contains not printable characters */
    public int f6512;

    /* JADX INFO: renamed from: ކ, reason: contains not printable characters */
    public int f6513;

    /* JADX INFO: renamed from: އ, reason: contains not printable characters */
    public int f6514;

    /* JADX INFO: renamed from: ވ, reason: contains not printable characters */
    public int f6515;

    /* JADX INFO: renamed from: މ, reason: contains not printable characters */
    public int f6516;

    /* JADX INFO: renamed from: މ.އ.֏.֏$֏, reason: contains not printable characters */
    public static class C1981 extends InputStream implements DataInput {

        /* JADX INFO: renamed from: އ, reason: contains not printable characters */
        public static final ByteOrder f6517 = ByteOrder.LITTLE_ENDIAN;

        /* JADX INFO: renamed from: ވ, reason: contains not printable characters */
        public static final ByteOrder f6518 = ByteOrder.BIG_ENDIAN;

        /* JADX INFO: renamed from: ރ, reason: contains not printable characters */
        public DataInputStream f6519;

        /* JADX INFO: renamed from: ބ, reason: contains not printable characters */
        public ByteOrder f6520;

        /* JADX INFO: renamed from: ޅ, reason: contains not printable characters */
        public final int f6521;

        /* JADX INFO: renamed from: ކ, reason: contains not printable characters */
        public int f6522;

        public C1981(InputStream inputStream) {
            this.f6520 = ByteOrder.BIG_ENDIAN;
            DataInputStream dataInputStream = new DataInputStream(inputStream);
            this.f6519 = dataInputStream;
            int iAvailable = dataInputStream.available();
            this.f6521 = iAvailable;
            this.f6522 = 0;
            this.f6519.mark(iAvailable);
        }

        public C1981(byte[] bArr) {
            this(new ByteArrayInputStream(bArr));
        }

        @Override // java.io.InputStream
        public int available() {
            return this.f6519.available();
        }

        @Override // java.io.InputStream
        public int read() {
            this.f6522++;
            return this.f6519.read();
        }

        @Override // java.io.InputStream
        public int read(byte[] bArr, int i, int i2) throws IOException {
            int i3 = this.f6519.read(bArr, i, i2);
            this.f6522 += i3;
            return i3;
        }

        @Override // java.io.DataInput
        public boolean readBoolean() {
            this.f6522++;
            return this.f6519.readBoolean();
        }

        @Override // java.io.DataInput
        public byte readByte() throws EOFException {
            int i = this.f6522 + 1;
            this.f6522 = i;
            if (i > this.f6521) {
                throw new EOFException();
            }
            int i2 = this.f6519.read();
            if (i2 >= 0) {
                return (byte) i2;
            }
            throw new EOFException();
        }

        @Override // java.io.DataInput
        public char readChar() {
            this.f6522 += 2;
            return this.f6519.readChar();
        }

        @Override // java.io.DataInput
        public double readDouble() {
            return Double.longBitsToDouble(readLong());
        }

        @Override // java.io.DataInput
        public float readFloat() {
            return Float.intBitsToFloat(readInt());
        }

        @Override // java.io.DataInput
        public void readFully(byte[] bArr) throws IOException {
            int length = this.f6522 + bArr.length;
            this.f6522 = length;
            if (length > this.f6521) {
                throw new EOFException();
            }
            if (this.f6519.read(bArr, 0, bArr.length) != bArr.length) {
                throw new IOException("Couldn't read up to the length of buffer");
            }
        }

        @Override // java.io.DataInput
        public void readFully(byte[] bArr, int i, int i2) throws IOException {
            int i3 = this.f6522 + i2;
            this.f6522 = i3;
            if (i3 > this.f6521) {
                throw new EOFException();
            }
            if (this.f6519.read(bArr, i, i2) != i2) {
                throw new IOException("Couldn't read up to the length of buffer");
            }
        }

        @Override // java.io.DataInput
        public int readInt() throws IOException {
            int i = this.f6522 + 4;
            this.f6522 = i;
            if (i > this.f6521) {
                throw new EOFException();
            }
            int i2 = this.f6519.read();
            int i3 = this.f6519.read();
            int i4 = this.f6519.read();
            int i5 = this.f6519.read();
            if ((i2 | i3 | i4 | i5) < 0) {
                throw new EOFException();
            }
            ByteOrder byteOrder = this.f6520;
            if (byteOrder == f6517) {
                return (i5 << 24) + (i4 << 16) + (i3 << 8) + i2;
            }
            if (byteOrder == f6518) {
                return (i2 << 24) + (i3 << 16) + (i4 << 8) + i5;
            }
            StringBuilder sbM4889 = C2803.m4889("Invalid byte order: ");
            sbM4889.append(this.f6520);
            throw new IOException(sbM4889.toString());
        }

        @Override // java.io.DataInput
        public String readLine() {
            Log.d("ExifInterface", "Currently unsupported");
            return null;
        }

        @Override // java.io.DataInput
        public long readLong() throws IOException {
            int i = this.f6522 + 8;
            this.f6522 = i;
            if (i > this.f6521) {
                throw new EOFException();
            }
            int i2 = this.f6519.read();
            int i3 = this.f6519.read();
            int i4 = this.f6519.read();
            int i5 = this.f6519.read();
            int i6 = this.f6519.read();
            int i7 = this.f6519.read();
            int i8 = this.f6519.read();
            int i9 = this.f6519.read();
            if ((i2 | i3 | i4 | i5 | i6 | i7 | i8 | i9) < 0) {
                throw new EOFException();
            }
            ByteOrder byteOrder = this.f6520;
            if (byteOrder == f6517) {
                return (((long) i9) << 56) + (((long) i8) << 48) + (((long) i7) << 40) + (((long) i6) << 32) + (((long) i5) << 24) + (((long) i4) << 16) + (((long) i3) << 8) + ((long) i2);
            }
            if (byteOrder == f6518) {
                return (((long) i2) << 56) + (((long) i3) << 48) + (((long) i4) << 40) + (((long) i5) << 32) + (((long) i6) << 24) + (((long) i7) << 16) + (((long) i8) << 8) + ((long) i9);
            }
            StringBuilder sbM4889 = C2803.m4889("Invalid byte order: ");
            sbM4889.append(this.f6520);
            throw new IOException(sbM4889.toString());
        }

        @Override // java.io.DataInput
        public short readShort() throws IOException {
            int i = this.f6522 + 2;
            this.f6522 = i;
            if (i > this.f6521) {
                throw new EOFException();
            }
            int i2 = this.f6519.read();
            int i3 = this.f6519.read();
            if ((i2 | i3) < 0) {
                throw new EOFException();
            }
            ByteOrder byteOrder = this.f6520;
            if (byteOrder == f6517) {
                return (short) ((i3 << 8) + i2);
            }
            if (byteOrder == f6518) {
                return (short) ((i2 << 8) + i3);
            }
            StringBuilder sbM4889 = C2803.m4889("Invalid byte order: ");
            sbM4889.append(this.f6520);
            throw new IOException(sbM4889.toString());
        }

        @Override // java.io.DataInput
        public String readUTF() {
            this.f6522 += 2;
            return this.f6519.readUTF();
        }

        @Override // java.io.DataInput
        public int readUnsignedByte() {
            this.f6522++;
            return this.f6519.readUnsignedByte();
        }

        @Override // java.io.DataInput
        public int readUnsignedShort() throws IOException {
            int i = this.f6522 + 2;
            this.f6522 = i;
            if (i > this.f6521) {
                throw new EOFException();
            }
            int i2 = this.f6519.read();
            int i3 = this.f6519.read();
            if ((i2 | i3) < 0) {
                throw new EOFException();
            }
            ByteOrder byteOrder = this.f6520;
            if (byteOrder == f6517) {
                return (i3 << 8) + i2;
            }
            if (byteOrder == f6518) {
                return (i2 << 8) + i3;
            }
            StringBuilder sbM4889 = C2803.m4889("Invalid byte order: ");
            sbM4889.append(this.f6520);
            throw new IOException(sbM4889.toString());
        }

        @Override // java.io.DataInput
        public int skipBytes(int i) {
            int iMin = Math.min(i, this.f6521 - this.f6522);
            int iSkipBytes = 0;
            while (iSkipBytes < iMin) {
                iSkipBytes += this.f6519.skipBytes(iMin - iSkipBytes);
            }
            this.f6522 += iSkipBytes;
            return iSkipBytes;
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public long m3850() {
            return ((long) readInt()) & 4294967295L;
        }

        /* JADX INFO: renamed from: ކ, reason: contains not printable characters */
        public void m3851(long j) throws IOException {
            int i = this.f6522;
            if (i > j) {
                this.f6522 = 0;
                this.f6519.reset();
                this.f6519.mark(this.f6521);
            } else {
                j -= (long) i;
            }
            int i2 = (int) j;
            if (skipBytes(i2) != i2) {
                throw new IOException("Couldn't seek up to the byteCount");
            }
        }
    }

    /* JADX INFO: renamed from: މ.އ.֏.֏$ؠ, reason: contains not printable characters */
    public static class C1982 {

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final int f6523;

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public final int f6524;

        /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
        public final byte[] f6525;

        public C1982(int i, int i2, byte[] bArr) {
            this.f6523 = i;
            this.f6524 = i2;
            this.f6525 = bArr;
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public static C1982 m3852(int i, ByteOrder byteOrder) {
            int[] iArr = {i};
            ByteBuffer byteBufferWrap = ByteBuffer.wrap(new byte[C1980.f6485[3] * 1]);
            byteBufferWrap.order(byteOrder);
            for (int i2 = 0; i2 < 1; i2++) {
                byteBufferWrap.putShort((short) iArr[i2]);
            }
            return new C1982(3, 1, byteBufferWrap.array());
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public static C1982 m3853(long j, ByteOrder byteOrder) {
            long[] jArr = {j};
            ByteBuffer byteBufferWrap = ByteBuffer.wrap(new byte[C1980.f6485[4] * 1]);
            byteBufferWrap.order(byteOrder);
            for (int i = 0; i < 1; i++) {
                byteBufferWrap.putInt((int) jArr[i]);
            }
            return new C1982(4, 1, byteBufferWrap.array());
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public static C1982 m3854(String str) {
            byte[] bytes = C2803.m4870(str, (char) 0).getBytes(C1980.f6503);
            return new C1982(2, bytes.length, bytes);
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public static C1982 m3855(C1984 c1984, ByteOrder byteOrder) {
            C1984[] c1984Arr = {c1984};
            ByteBuffer byteBufferWrap = ByteBuffer.wrap(new byte[C1980.f6485[5] * 1]);
            byteBufferWrap.order(byteOrder);
            for (int i = 0; i < 1; i++) {
                C1984 c19842 = c1984Arr[i];
                byteBufferWrap.putInt((int) c19842.f6530);
                byteBufferWrap.putInt((int) c19842.f6531);
            }
            return new C1982(5, 1, byteBufferWrap.array());
        }

        public String toString() {
            StringBuilder sbM4889 = C2803.m4889("(");
            sbM4889.append(C1980.f6484[this.f6523]);
            sbM4889.append(", data length:");
            return C2803.m4882(sbM4889, this.f6525.length, ")");
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public double m3856(ByteOrder byteOrder) throws Throwable {
            Object objM3859 = m3859(byteOrder);
            if (objM3859 == null) {
                throw new NumberFormatException("NULL can't be converted to a double value");
            }
            if (objM3859 instanceof String) {
                return Double.parseDouble((String) objM3859);
            }
            if (objM3859 instanceof long[]) {
                if (((long[]) objM3859).length == 1) {
                    return r5[0];
                }
                throw new NumberFormatException("There are more than one component");
            }
            if (objM3859 instanceof int[]) {
                if (((int[]) objM3859).length == 1) {
                    return r5[0];
                }
                throw new NumberFormatException("There are more than one component");
            }
            if (objM3859 instanceof double[]) {
                double[] dArr = (double[]) objM3859;
                if (dArr.length == 1) {
                    return dArr[0];
                }
                throw new NumberFormatException("There are more than one component");
            }
            if (!(objM3859 instanceof C1984[])) {
                throw new NumberFormatException("Couldn't find a double value");
            }
            C1984[] c1984Arr = (C1984[]) objM3859;
            if (c1984Arr.length != 1) {
                throw new NumberFormatException("There are more than one component");
            }
            C1984 c1984 = c1984Arr[0];
            return c1984.f6530 / c1984.f6531;
        }

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public int m3857(ByteOrder byteOrder) throws Throwable {
            Object objM3859 = m3859(byteOrder);
            if (objM3859 == null) {
                throw new NumberFormatException("NULL can't be converted to a integer value");
            }
            if (objM3859 instanceof String) {
                return Integer.parseInt((String) objM3859);
            }
            if (objM3859 instanceof long[]) {
                long[] jArr = (long[]) objM3859;
                if (jArr.length == 1) {
                    return (int) jArr[0];
                }
                throw new NumberFormatException("There are more than one component");
            }
            if (!(objM3859 instanceof int[])) {
                throw new NumberFormatException("Couldn't find a integer value");
            }
            int[] iArr = (int[]) objM3859;
            if (iArr.length == 1) {
                return iArr[0];
            }
            throw new NumberFormatException("There are more than one component");
        }

        /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
        public String m3858(ByteOrder byteOrder) throws Throwable {
            Object objM3859 = m3859(byteOrder);
            if (objM3859 == null) {
                return null;
            }
            if (objM3859 instanceof String) {
                return (String) objM3859;
            }
            StringBuilder sb = new StringBuilder();
            int i = 0;
            if (objM3859 instanceof long[]) {
                long[] jArr = (long[]) objM3859;
                while (i < jArr.length) {
                    sb.append(jArr[i]);
                    i++;
                    if (i != jArr.length) {
                        sb.append(",");
                    }
                }
                return sb.toString();
            }
            if (objM3859 instanceof int[]) {
                int[] iArr = (int[]) objM3859;
                while (i < iArr.length) {
                    sb.append(iArr[i]);
                    i++;
                    if (i != iArr.length) {
                        sb.append(",");
                    }
                }
                return sb.toString();
            }
            if (objM3859 instanceof double[]) {
                double[] dArr = (double[]) objM3859;
                while (i < dArr.length) {
                    sb.append(dArr[i]);
                    i++;
                    if (i != dArr.length) {
                        sb.append(",");
                    }
                }
                return sb.toString();
            }
            if (!(objM3859 instanceof C1984[])) {
                return null;
            }
            C1984[] c1984Arr = (C1984[]) objM3859;
            while (i < c1984Arr.length) {
                sb.append(c1984Arr[i].f6530);
                sb.append('/');
                sb.append(c1984Arr[i].f6531);
                i++;
                if (i != c1984Arr.length) {
                    sb.append(",");
                }
            }
            return sb.toString();
        }

        /* JADX WARN: Not initialized variable reg: 3, insn: 0x01a7: MOVE (r2 I:??[OBJECT, ARRAY]) = (r3 I:??[OBJECT, ARRAY]), block:B:152:0x01a7 */
        /* JADX WARN: Removed duplicated region for block: B:165:0x01aa A[EXC_TOP_SPLITTER, SYNTHETIC] */
        /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
        /*
            Code decompiled incorrectly, please refer to instructions dump.
        */
        public Object m3859(ByteOrder byteOrder) throws Throwable {
            C1981 c1981;
            InputStream inputStream;
            byte b;
            InputStream inputStream2 = null;
            try {
                try {
                    c1981 = new C1981(this.f6525);
                    try {
                        c1981.f6520 = byteOrder;
                        boolean z = true;
                        int length = 0;
                        switch (this.f6523) {
                            case 1:
                            case 6:
                                if (this.f6525.length != 1 || this.f6525[0] < 0 || this.f6525[0] > 1) {
                                    String str = new String(this.f6525, C1980.f6503);
                                    try {
                                        c1981.close();
                                        break;
                                    } catch (IOException e) {
                                        Log.e("ExifInterface", "IOException occurred while closing InputStream", e);
                                    }
                                    return str;
                                }
                                String str2 = new String(new char[]{(char) (this.f6525[0] + 48)});
                                try {
                                    c1981.close();
                                    break;
                                } catch (IOException e2) {
                                    Log.e("ExifInterface", "IOException occurred while closing InputStream", e2);
                                }
                                return str2;
                            case 2:
                            case 7:
                                if (this.f6524 >= C1980.f6486.length) {
                                    int i = 0;
                                    while (true) {
                                        if (i < C1980.f6486.length) {
                                            if (this.f6525[i] != C1980.f6486[i]) {
                                                z = false;
                                            } else {
                                                i++;
                                            }
                                        }
                                    }
                                    if (z) {
                                        length = C1980.f6486.length;
                                    }
                                }
                                StringBuilder sb = new StringBuilder();
                                while (length < this.f6524 && (b = this.f6525[length]) != 0) {
                                    if (b >= 32) {
                                        sb.append((char) b);
                                    } else {
                                        sb.append('?');
                                    }
                                    length++;
                                }
                                String string = sb.toString();
                                try {
                                    c1981.close();
                                    break;
                                } catch (IOException e3) {
                                    Log.e("ExifInterface", "IOException occurred while closing InputStream", e3);
                                }
                                return string;
                            case 3:
                                int[] iArr = new int[this.f6524];
                                while (length < this.f6524) {
                                    iArr[length] = c1981.readUnsignedShort();
                                    length++;
                                }
                                try {
                                    c1981.close();
                                    break;
                                } catch (IOException e4) {
                                    Log.e("ExifInterface", "IOException occurred while closing InputStream", e4);
                                }
                                return iArr;
                            case 4:
                                long[] jArr = new long[this.f6524];
                                while (length < this.f6524) {
                                    jArr[length] = c1981.m3850();
                                    length++;
                                }
                                try {
                                    c1981.close();
                                    break;
                                } catch (IOException e5) {
                                    Log.e("ExifInterface", "IOException occurred while closing InputStream", e5);
                                }
                                return jArr;
                            case 5:
                                C1984[] c1984Arr = new C1984[this.f6524];
                                while (length < this.f6524) {
                                    c1984Arr[length] = new C1984(c1981.m3850(), c1981.m3850());
                                    length++;
                                }
                                try {
                                    c1981.close();
                                    break;
                                } catch (IOException e6) {
                                    Log.e("ExifInterface", "IOException occurred while closing InputStream", e6);
                                }
                                return c1984Arr;
                            case 8:
                                int[] iArr2 = new int[this.f6524];
                                while (length < this.f6524) {
                                    iArr2[length] = c1981.readShort();
                                    length++;
                                }
                                try {
                                    c1981.close();
                                    break;
                                } catch (IOException e7) {
                                    Log.e("ExifInterface", "IOException occurred while closing InputStream", e7);
                                }
                                return iArr2;
                            case 9:
                                int[] iArr3 = new int[this.f6524];
                                while (length < this.f6524) {
                                    iArr3[length] = c1981.readInt();
                                    length++;
                                }
                                try {
                                    c1981.close();
                                    break;
                                } catch (IOException e8) {
                                    Log.e("ExifInterface", "IOException occurred while closing InputStream", e8);
                                }
                                return iArr3;
                            case 10:
                                C1984[] c1984Arr2 = new C1984[this.f6524];
                                while (length < this.f6524) {
                                    c1984Arr2[length] = new C1984(c1981.readInt(), c1981.readInt());
                                    length++;
                                }
                                try {
                                    c1981.close();
                                    break;
                                } catch (IOException e9) {
                                    Log.e("ExifInterface", "IOException occurred while closing InputStream", e9);
                                }
                                return c1984Arr2;
                            case 11:
                                double[] dArr = new double[this.f6524];
                                while (length < this.f6524) {
                                    dArr[length] = c1981.readFloat();
                                    length++;
                                }
                                try {
                                    c1981.close();
                                    break;
                                } catch (IOException e10) {
                                    Log.e("ExifInterface", "IOException occurred while closing InputStream", e10);
                                }
                                return dArr;
                            case 12:
                                double[] dArr2 = new double[this.f6524];
                                while (length < this.f6524) {
                                    dArr2[length] = c1981.readDouble();
                                    length++;
                                }
                                try {
                                    c1981.close();
                                    break;
                                } catch (IOException e11) {
                                    Log.e("ExifInterface", "IOException occurred while closing InputStream", e11);
                                }
                                return dArr2;
                            default:
                                try {
                                    c1981.close();
                                    break;
                                } catch (IOException e12) {
                                    Log.e("ExifInterface", "IOException occurred while closing InputStream", e12);
                                }
                                return null;
                        }
                    } catch (IOException e13) {
                        e = e13;
                        Log.w("ExifInterface", "IOException occurred during reading a value", e);
                        if (c1981 != null) {
                            try {
                                c1981.close();
                            } catch (IOException e14) {
                                Log.e("ExifInterface", "IOException occurred while closing InputStream", e14);
                            }
                        }
                        return null;
                    }
                } catch (Throwable th) {
                    th = th;
                    inputStream2 = inputStream;
                    if (inputStream2 != null) {
                        try {
                            inputStream2.close();
                        } catch (IOException e15) {
                            Log.e("ExifInterface", "IOException occurred while closing InputStream", e15);
                        }
                    }
                    throw th;
                }
            } catch (IOException e16) {
                e = e16;
                c1981 = null;
            } catch (Throwable th2) {
                th = th2;
                if (inputStream2 != null) {
                }
                throw th;
            }
        }
    }

    /* JADX INFO: renamed from: މ.އ.֏.֏$ހ, reason: contains not printable characters */
    public static class C1983 {

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final int f6526;

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public final String f6527;

        /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
        public final int f6528;

        /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
        public final int f6529;

        public C1983(String str, int i, int i2) {
            this.f6527 = str;
            this.f6526 = i;
            this.f6528 = i2;
            this.f6529 = -1;
        }

        public C1983(String str, int i, int i2, int i3) {
            this.f6527 = str;
            this.f6526 = i;
            this.f6528 = i2;
            this.f6529 = i3;
        }
    }

    /* JADX INFO: renamed from: މ.އ.֏.֏$ށ, reason: contains not printable characters */
    public static class C1984 {

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final long f6530;

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public final long f6531;

        public C1984(long j, long j2) {
            if (j2 == 0) {
                this.f6530 = 0L;
                this.f6531 = 1L;
            } else {
                this.f6530 = j;
                this.f6531 = j2;
            }
        }

        public String toString() {
            return this.f6530 + "/" + this.f6531;
        }
    }

    static {
        Arrays.asList(1, 6, 3, 8);
        Arrays.asList(2, 7, 4, 5);
        f6478 = new int[]{8, 8, 8};
        f6479 = new int[]{8};
        f6480 = new byte[]{-1, -40, -1};
        f6481 = new byte[]{79, 76, 89, 77, 80, 0};
        f6482 = new byte[]{79, 76, 89, 77, 80, 85, 83, 0, 73, 73};
        f6484 = new String[]{"", "BYTE", "STRING", "USHORT", "ULONG", "URATIONAL", "SBYTE", "UNDEFINED", "SSHORT", "SLONG", "SRATIONAL", "SINGLE", "DOUBLE"};
        f6485 = new int[]{0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8, 1};
        f6486 = new byte[]{65, 83, 67, 73, 73, 0, 0, 0};
        f6487 = new C1983[]{new C1983("NewSubfileType", 254, 4), new C1983("SubfileType", 255, 4), new C1983("ImageWidth", 256, 3, 4), new C1983("ImageLength", 257, 3, 4), new C1983("BitsPerSample", 258, 3), new C1983("Compression", 259, 3), new C1983("PhotometricInterpretation", 262, 3), new C1983("ImageDescription", 270, 2), new C1983("Make", 271, 2), new C1983("Model", 272, 2), new C1983("StripOffsets", 273, 3, 4), new C1983("Orientation", 274, 3), new C1983("SamplesPerPixel", 277, 3), new C1983("RowsPerStrip", 278, 3, 4), new C1983("StripByteCounts", 279, 3, 4), new C1983("XResolution", 282, 5), new C1983("YResolution", 283, 5), new C1983("PlanarConfiguration", 284, 3), new C1983("ResolutionUnit", 296, 3), new C1983("TransferFunction", 301, 3), new C1983("Software", 305, 2), new C1983("DateTime", 306, 2), new C1983("Artist", 315, 2), new C1983("WhitePoint", 318, 5), new C1983("PrimaryChromaticities", 319, 5), new C1983("SubIFDPointer", 330, 4), new C1983("JPEGInterchangeFormat", 513, 4), new C1983("JPEGInterchangeFormatLength", 514, 4), new C1983("YCbCrCoefficients", 529, 5), new C1983("YCbCrSubSampling", 530, 3), new C1983("YCbCrPositioning", 531, 3), new C1983("ReferenceBlackWhite", 532, 5), new C1983("Copyright", 33432, 2), new C1983("ExifIFDPointer", 34665, 4), new C1983("GPSInfoIFDPointer", 34853, 4), new C1983("SensorTopBorder", 4, 4), new C1983("SensorLeftBorder", 5, 4), new C1983("SensorBottomBorder", 6, 4), new C1983("SensorRightBorder", 7, 4), new C1983("ISO", 23, 3), new C1983("JpgFromRaw", 46, 7)};
        f6488 = new C1983[]{new C1983("ExposureTime", 33434, 5), new C1983("FNumber", 33437, 5), new C1983("ExposureProgram", 34850, 3), new C1983("SpectralSensitivity", 34852, 2), new C1983("PhotographicSensitivity", 34855, 3), new C1983("OECF", 34856, 7), new C1983("ExifVersion", 36864, 2), new C1983("DateTimeOriginal", 36867, 2), new C1983("DateTimeDigitized", 36868, 2), new C1983("ComponentsConfiguration", 37121, 7), new C1983("CompressedBitsPerPixel", 37122, 5), new C1983("ShutterSpeedValue", 37377, 10), new C1983("ApertureValue", 37378, 5), new C1983("BrightnessValue", 37379, 10), new C1983("ExposureBiasValue", 37380, 10), new C1983("MaxApertureValue", 37381, 5), new C1983("SubjectDistance", 37382, 5), new C1983("MeteringMode", 37383, 3), new C1983("LightSource", 37384, 3), new C1983("Flash", 37385, 3), new C1983("FocalLength", 37386, 5), new C1983("SubjectArea", 37396, 3), new C1983("MakerNote", 37500, 7), new C1983("UserComment", 37510, 7), new C1983("SubSecTime", 37520, 2), new C1983("SubSecTimeOriginal", 37521, 2), new C1983("SubSecTimeDigitized", 37522, 2), new C1983("FlashpixVersion", 40960, 7), new C1983("ColorSpace", 40961, 3), new C1983("PixelXDimension", 40962, 3, 4), new C1983("PixelYDimension", 40963, 3, 4), new C1983("RelatedSoundFile", 40964, 2), new C1983("InteroperabilityIFDPointer", 40965, 4), new C1983("FlashEnergy", 41483, 5), new C1983("SpatialFrequencyResponse", 41484, 7), new C1983("FocalPlaneXResolution", 41486, 5), new C1983("FocalPlaneYResolution", 41487, 5), new C1983("FocalPlaneResolutionUnit", 41488, 3), new C1983("SubjectLocation", 41492, 3), new C1983("ExposureIndex", 41493, 5), new C1983("SensingMethod", 41495, 3), new C1983("FileSource", 41728, 7), new C1983("SceneType", 41729, 7), new C1983("CFAPattern", 41730, 7), new C1983("CustomRendered", 41985, 3), new C1983("ExposureMode", 41986, 3), new C1983("WhiteBalance", 41987, 3), new C1983("DigitalZoomRatio", 41988, 5), new C1983("FocalLengthIn35mmFilm", 41989, 3), new C1983("SceneCaptureType", 41990, 3), new C1983("GainControl", 41991, 3), new C1983("Contrast", 41992, 3), new C1983("Saturation", 41993, 3), new C1983("Sharpness", 41994, 3), new C1983("DeviceSettingDescription", 41995, 7), new C1983("SubjectDistanceRange", 41996, 3), new C1983("ImageUniqueID", 42016, 2), new C1983("DNGVersion", 50706, 1), new C1983("DefaultCropSize", 50720, 3, 4)};
        f6489 = new C1983[]{new C1983("GPSVersionID", 0, 1), new C1983("GPSLatitudeRef", 1, 2), new C1983("GPSLatitude", 2, 5), new C1983("GPSLongitudeRef", 3, 2), new C1983("GPSLongitude", 4, 5), new C1983("GPSAltitudeRef", 5, 1), new C1983("GPSAltitude", 6, 5), new C1983("GPSTimeStamp", 7, 5), new C1983("GPSSatellites", 8, 2), new C1983("GPSStatus", 9, 2), new C1983("GPSMeasureMode", 10, 2), new C1983("GPSDOP", 11, 5), new C1983("GPSSpeedRef", 12, 2), new C1983("GPSSpeed", 13, 5), new C1983("GPSTrackRef", 14, 2), new C1983("GPSTrack", 15, 5), new C1983("GPSImgDirectionRef", 16, 2), new C1983("GPSImgDirection", 17, 5), new C1983("GPSMapDatum", 18, 2), new C1983("GPSDestLatitudeRef", 19, 2), new C1983("GPSDestLatitude", 20, 5), new C1983("GPSDestLongitudeRef", 21, 2), new C1983("GPSDestLongitude", 22, 5), new C1983("GPSDestBearingRef", 23, 2), new C1983("GPSDestBearing", 24, 5), new C1983("GPSDestDistanceRef", 25, 2), new C1983("GPSDestDistance", 26, 5), new C1983("GPSProcessingMethod", 27, 7), new C1983("GPSAreaInformation", 28, 7), new C1983("GPSDateStamp", 29, 2), new C1983("GPSDifferential", 30, 3)};
        f6490 = new C1983[]{new C1983("InteroperabilityIndex", 1, 2)};
        f6491 = new C1983[]{new C1983("NewSubfileType", 254, 4), new C1983("SubfileType", 255, 4), new C1983("ThumbnailImageWidth", 256, 3, 4), new C1983("ThumbnailImageLength", 257, 3, 4), new C1983("BitsPerSample", 258, 3), new C1983("Compression", 259, 3), new C1983("PhotometricInterpretation", 262, 3), new C1983("ImageDescription", 270, 2), new C1983("Make", 271, 2), new C1983("Model", 272, 2), new C1983("StripOffsets", 273, 3, 4), new C1983("Orientation", 274, 3), new C1983("SamplesPerPixel", 277, 3), new C1983("RowsPerStrip", 278, 3, 4), new C1983("StripByteCounts", 279, 3, 4), new C1983("XResolution", 282, 5), new C1983("YResolution", 283, 5), new C1983("PlanarConfiguration", 284, 3), new C1983("ResolutionUnit", 296, 3), new C1983("TransferFunction", 301, 3), new C1983("Software", 305, 2), new C1983("DateTime", 306, 2), new C1983("Artist", 315, 2), new C1983("WhitePoint", 318, 5), new C1983("PrimaryChromaticities", 319, 5), new C1983("SubIFDPointer", 330, 4), new C1983("JPEGInterchangeFormat", 513, 4), new C1983("JPEGInterchangeFormatLength", 514, 4), new C1983("YCbCrCoefficients", 529, 5), new C1983("YCbCrSubSampling", 530, 3), new C1983("YCbCrPositioning", 531, 3), new C1983("ReferenceBlackWhite", 532, 5), new C1983("Copyright", 33432, 2), new C1983("ExifIFDPointer", 34665, 4), new C1983("GPSInfoIFDPointer", 34853, 4), new C1983("DNGVersion", 50706, 1), new C1983("DefaultCropSize", 50720, 3, 4)};
        f6492 = new C1983("StripOffsets", 273, 3);
        f6493 = new C1983[]{new C1983("ThumbnailImage", 256, 7), new C1983("CameraSettingsIFDPointer", 8224, 4), new C1983("ImageProcessingIFDPointer", 8256, 4)};
        f6494 = new C1983[]{new C1983("PreviewImageStart", 257, 4), new C1983("PreviewImageLength", 258, 4)};
        f6495 = new C1983[]{new C1983("AspectFrame", 4371, 3)};
        C1983[] c1983Arr = {new C1983("ColorSpace", 55, 3)};
        f6496 = c1983Arr;
        C1983[] c1983Arr2 = f6487;
        f6497 = new C1983[][]{c1983Arr2, f6488, f6489, f6490, f6491, c1983Arr2, f6493, f6494, f6495, c1983Arr};
        f6498 = new C1983[]{new C1983("SubIFDPointer", 330, 4), new C1983("ExifIFDPointer", 34665, 4), new C1983("GPSInfoIFDPointer", 34853, 4), new C1983("InteroperabilityIFDPointer", 40965, 4), new C1983("CameraSettingsIFDPointer", 8224, 1), new C1983("ImageProcessingIFDPointer", 8256, 1)};
        C1983[][] c1983Arr3 = f6497;
        f6499 = new HashMap[c1983Arr3.length];
        f6500 = new HashMap[c1983Arr3.length];
        f6501 = new HashSet<>(Arrays.asList("FNumber", "DigitalZoomRatio", "ExposureTime", "SubjectDistance", "GPSTimeStamp"));
        f6502 = new HashMap<>();
        Charset charsetForName = Charset.forName("US-ASCII");
        f6503 = charsetForName;
        f6504 = "Exif\u0000\u0000".getBytes(charsetForName);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy:MM:dd HH:mm:ss");
        f6483 = simpleDateFormat;
        simpleDateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
        for (int i = 0; i < f6497.length; i++) {
            f6499[i] = new HashMap<>();
            f6500[i] = new HashMap<>();
            for (C1983 c1983 : f6497[i]) {
                f6499[i].put(Integer.valueOf(c1983.f6526), c1983);
                f6500[i].put(c1983.f6527, c1983);
            }
        }
        f6502.put(Integer.valueOf(f6498[0].f6526), 5);
        f6502.put(Integer.valueOf(f6498[1].f6526), 1);
        f6502.put(Integer.valueOf(f6498[2].f6526), 2);
        f6502.put(Integer.valueOf(f6498[3].f6526), 3);
        f6502.put(Integer.valueOf(f6498[4].f6526), 7);
        f6502.put(Integer.valueOf(f6498[5].f6526), 8);
        Pattern.compile(".*[1-9].*");
        Pattern.compile("^([0-9][0-9]):([0-9][0-9]):([0-9][0-9])$");
    }

    public C1980(InputStream inputStream) {
        if (inputStream == null) {
            throw new IllegalArgumentException("inputStream cannot be null");
        }
        this.f6505 = null;
        if (inputStream instanceof AssetManager.AssetInputStream) {
            this.f6506 = (AssetManager.AssetInputStream) inputStream;
        } else {
            this.f6506 = null;
        }
        for (int i = 0; i < f6497.length; i++) {
            try {
                this.f6508[i] = new HashMap<>();
            } catch (IOException unused) {
            } catch (Throwable th) {
                m3835();
                throw th;
            }
        }
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream, 5000);
        this.f6507 = m3833(bufferedInputStream);
        C1981 c1981 = new C1981(bufferedInputStream);
        switch (this.f6507) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 5:
            case 6:
            case 8:
            case 11:
                m3845(c1981);
                break;
            case 4:
                m3839(c1981, 0, 0);
                break;
            case 7:
                m3837(c1981);
                break;
            case 9:
                m3843(c1981);
                break;
            case 10:
                m3847(c1981);
                break;
        }
        m3849(c1981);
        m3835();
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static long[] m3832(Object obj) {
        if (!(obj instanceof int[])) {
            if (obj instanceof long[]) {
                return (long[]) obj;
            }
            return null;
        }
        int[] iArr = (int[]) obj;
        long[] jArr = new long[iArr.length];
        for (int i = 0; i < iArr.length; i++) {
            jArr[i] = iArr[i];
        }
        return jArr;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final int m3833(BufferedInputStream bufferedInputStream) throws IOException {
        boolean z;
        boolean z2;
        bufferedInputStream.mark(5000);
        byte[] bArr = new byte[5000];
        bufferedInputStream.read(bArr);
        bufferedInputStream.reset();
        int i = 0;
        while (true) {
            byte[] bArr2 = f6480;
            if (i >= bArr2.length) {
                z = true;
                break;
            }
            if (bArr[i] != bArr2[i]) {
                z = false;
                break;
            }
            i++;
        }
        if (z) {
            return 4;
        }
        byte[] bytes = "FUJIFILMCCD-RAW".getBytes(Charset.defaultCharset());
        int i2 = 0;
        while (true) {
            if (i2 >= bytes.length) {
                z2 = true;
                break;
            }
            if (bArr[i2] != bytes[i2]) {
                z2 = false;
                break;
            }
            i2++;
        }
        if (z2) {
            return 9;
        }
        C1981 c1981 = new C1981(bArr);
        ByteOrder byteOrderM3848 = m3848(c1981);
        this.f6510 = byteOrderM3848;
        c1981.f6520 = byteOrderM3848;
        short s = c1981.readShort();
        c1981.close();
        if (s == 20306 || s == 21330) {
            return 7;
        }
        C1981 c19812 = new C1981(bArr);
        ByteOrder byteOrderM38482 = m3848(c19812);
        this.f6510 = byteOrderM38482;
        c19812.f6520 = byteOrderM38482;
        short s2 = c19812.readShort();
        c19812.close();
        return s2 == 85 ? 10 : 0;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public String m3834(String str) {
        C1982 c1982M3842 = m3842(str);
        if (c1982M3842 != null) {
            if (!f6501.contains(str)) {
                return c1982M3842.m3858(this.f6510);
            }
            if (str.equals("GPSTimeStamp")) {
                int i = c1982M3842.f6523;
                if (i != 5 && i != 10) {
                    StringBuilder sbM4889 = C2803.m4889("GPS Timestamp format is not rational. format=");
                    sbM4889.append(c1982M3842.f6523);
                    Log.w("ExifInterface", sbM4889.toString());
                    return null;
                }
                C1984[] c1984Arr = (C1984[]) c1982M3842.m3859(this.f6510);
                if (c1984Arr != null && c1984Arr.length == 3) {
                    return String.format("%02d:%02d:%02d", Integer.valueOf((int) (c1984Arr[0].f6530 / c1984Arr[0].f6531)), Integer.valueOf((int) (c1984Arr[1].f6530 / c1984Arr[1].f6531)), Integer.valueOf((int) (c1984Arr[2].f6530 / c1984Arr[2].f6531)));
                }
                StringBuilder sbM48892 = C2803.m4889("Invalid GPS Timestamp array. array=");
                sbM48892.append(Arrays.toString(c1984Arr));
                Log.w("ExifInterface", sbM48892.toString());
                return null;
            }
            try {
                return Double.toString(c1982M3842.m3856(this.f6510));
            } catch (NumberFormatException unused) {
            }
        }
        return null;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final void m3835() {
        String strM3834 = m3834("DateTimeOriginal");
        if (strM3834 != null && m3834("DateTime") == null) {
            this.f6508[0].put("DateTime", C1982.m3854(strM3834));
        }
        if (m3834("ImageWidth") == null) {
            this.f6508[0].put("ImageWidth", C1982.m3853(0L, this.f6510));
        }
        if (m3834("ImageLength") == null) {
            this.f6508[0].put("ImageLength", C1982.m3853(0L, this.f6510));
        }
        if (m3834("Orientation") == null) {
            this.f6508[0].put("Orientation", C1982.m3853(0L, this.f6510));
        }
        if (m3834("LightSource") == null) {
            this.f6508[1].put("LightSource", C1982.m3853(0L, this.f6510));
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final void m3836(int i, int i2) throws Throwable {
        if (this.f6508[i].isEmpty() || this.f6508[i2].isEmpty()) {
            return;
        }
        C1982 c1982 = this.f6508[i].get("ImageLength");
        C1982 c19822 = this.f6508[i].get("ImageWidth");
        C1982 c19823 = this.f6508[i2].get("ImageLength");
        C1982 c19824 = this.f6508[i2].get("ImageWidth");
        if (c1982 == null || c19822 == null || c19823 == null || c19824 == null) {
            return;
        }
        int iM3857 = c1982.m3857(this.f6510);
        int iM38572 = c19822.m3857(this.f6510);
        int iM38573 = c19823.m3857(this.f6510);
        int iM38574 = c19824.m3857(this.f6510);
        if (iM3857 >= iM38573 || iM38572 >= iM38574) {
            return;
        }
        HashMap<String, C1982>[] mapArr = this.f6508;
        HashMap<String, C1982> map = mapArr[i];
        mapArr[i] = mapArr[i2];
        mapArr[i2] = map;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final void m3837(C1981 c1981) throws Throwable {
        m3845(c1981);
        C1982 c1982 = this.f6508[1].get("MakerNote");
        if (c1982 != null) {
            C1981 c19812 = new C1981(c1982.f6525);
            c19812.f6520 = this.f6510;
            byte[] bArr = new byte[f6481.length];
            c19812.readFully(bArr);
            c19812.m3851(0L);
            byte[] bArr2 = new byte[f6482.length];
            c19812.readFully(bArr2);
            if (Arrays.equals(bArr, f6481)) {
                c19812.m3851(8L);
            } else if (Arrays.equals(bArr2, f6482)) {
                c19812.m3851(12L);
            }
            m3844(c19812, 6);
            C1982 c19822 = this.f6508[7].get("PreviewImageStart");
            C1982 c19823 = this.f6508[7].get("PreviewImageLength");
            if (c19822 != null && c19823 != null) {
                this.f6508[5].put("JPEGInterchangeFormat", c19822);
                this.f6508[5].put("JPEGInterchangeFormatLength", c19823);
            }
            C1982 c19824 = this.f6508[8].get("AspectFrame");
            if (c19824 != null) {
                int[] iArr = (int[]) c19824.m3859(this.f6510);
                if (iArr == null || iArr.length != 4) {
                    StringBuilder sbM4889 = C2803.m4889("Invalid aspect frame values. frame=");
                    sbM4889.append(Arrays.toString(iArr));
                    Log.w("ExifInterface", sbM4889.toString());
                } else {
                    if (iArr[2] <= iArr[0] || iArr[3] <= iArr[1]) {
                        return;
                    }
                    int i = (iArr[2] - iArr[0]) + 1;
                    int i2 = (iArr[3] - iArr[1]) + 1;
                    if (i < i2) {
                        int i3 = i + i2;
                        i2 = i3 - i2;
                        i = i3 - i2;
                    }
                    C1982 c1982M3852 = C1982.m3852(i, this.f6510);
                    C1982 c1982M38522 = C1982.m3852(i2, this.f6510);
                    this.f6508[0].put("ImageWidth", c1982M3852);
                    this.f6508[0].put("ImageLength", c1982M38522);
                }
            }
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final void m3838(C1981 c1981, int i) throws IOException {
        ByteOrder byteOrderM3848 = m3848(c1981);
        this.f6510 = byteOrderM3848;
        c1981.f6520 = byteOrderM3848;
        int unsignedShort = c1981.readUnsignedShort();
        int i2 = this.f6507;
        if (i2 != 7 && i2 != 10 && unsignedShort != 42) {
            StringBuilder sbM4889 = C2803.m4889("Invalid start code: ");
            sbM4889.append(Integer.toHexString(unsignedShort));
            throw new IOException(sbM4889.toString());
        }
        int i3 = c1981.readInt();
        if (i3 < 8 || i3 >= i) {
            throw new IOException(C2803.m4871("Invalid first Ifd offset: ", i3));
        }
        int i4 = i3 - 8;
        if (i4 > 0 && c1981.skipBytes(i4) != i4) {
            throw new IOException(C2803.m4871("Couldn't jump to first Ifd: ", i4));
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:25:0x0055 A[FALL_THROUGH] */
    /*  JADX ERROR: UnsupportedOperationException in pass: RegionMakerVisitor
        java.lang.UnsupportedOperationException
        	at java.base/java.util.Collections$UnmodifiableCollection.add(Collections.java:1092)
        	at jadx.core.dex.visitors.regions.maker.SwitchRegionMaker$1.leaveRegion(SwitchRegionMaker.java:390)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:70)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverse(DepthRegionTraversal.java:23)
        	at jadx.core.dex.visitors.regions.maker.SwitchRegionMaker.insertBreaksForCase(SwitchRegionMaker.java:370)
        	at jadx.core.dex.visitors.regions.maker.SwitchRegionMaker.insertBreaks(SwitchRegionMaker.java:85)
        	at jadx.core.dex.visitors.regions.PostProcessRegions.leaveRegion(PostProcessRegions.java:33)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:70)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at java.base/java.util.Collections$UnmodifiableCollection.forEach(Collections.java:1117)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at java.base/java.util.Collections$UnmodifiableCollection.forEach(Collections.java:1117)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at java.base/java.util.Collections$UnmodifiableCollection.forEach(Collections.java:1117)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at java.base/java.util.Collections$UnmodifiableCollection.forEach(Collections.java:1117)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at java.base/java.util.Collections$UnmodifiableCollection.forEach(Collections.java:1117)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at java.base/java.util.Collections$UnmodifiableCollection.forEach(Collections.java:1117)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at java.base/java.util.Collections$UnmodifiableCollection.forEach(Collections.java:1117)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at java.base/java.util.Collections$UnmodifiableCollection.forEach(Collections.java:1117)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at java.base/java.util.Collections$UnmodifiableCollection.forEach(Collections.java:1117)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.lambda$traverseInternal$0(DepthRegionTraversal.java:68)
        	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverseInternal(DepthRegionTraversal.java:68)
        	at jadx.core.dex.visitors.regions.DepthRegionTraversal.traverse(DepthRegionTraversal.java:19)
        	at jadx.core.dex.visitors.regions.PostProcessRegions.process(PostProcessRegions.java:23)
        	at jadx.core.dex.visitors.regions.RegionMakerVisitor.visit(RegionMakerVisitor.java:31)
        */
    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final void m3839(p037.p087.p088.C1980.C1981 r9, int r10, int r11) throws java.io.IOException {
        /*
            Method dump skipped, instruction units count: 400
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: p037.p087.p088.C1980.m3839(މ.އ.֏.֏$֏, int, int):void");
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final void m3840(C1981 c1981, HashMap map) throws Throwable {
        int i;
        C1982 c1982 = (C1982) map.get("JPEGInterchangeFormat");
        C1982 c19822 = (C1982) map.get("JPEGInterchangeFormatLength");
        if (c1982 == null || c19822 == null) {
            return;
        }
        int iM3857 = c1982.m3857(this.f6510);
        int iMin = Math.min(c19822.m3857(this.f6510), c1981.available() - iM3857);
        int i2 = this.f6507;
        if (i2 != 4 && i2 != 9 && i2 != 10) {
            if (i2 == 7) {
                i = this.f6513;
            }
            if (iM3857 > 0 || iMin <= 0 || this.f6505 != null || this.f6506 != null) {
                return;
            }
            c1981.m3851(iM3857);
            c1981.readFully(new byte[iMin]);
            return;
        }
        i = this.f6512;
        iM3857 += i;
        if (iM3857 > 0) {
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final boolean m3841(HashMap map) {
        C1982 c1982 = (C1982) map.get("ImageLength");
        C1982 c19822 = (C1982) map.get("ImageWidth");
        if (c1982 == null || c19822 == null) {
            return false;
        }
        return c1982.m3857(this.f6510) <= 512 && c19822.m3857(this.f6510) <= 512;
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public final C1982 m3842(String str) {
        if ("ISOSpeedRatings".equals(str)) {
            str = "PhotographicSensitivity";
        }
        for (int i = 0; i < f6497.length; i++) {
            C1982 c1982 = this.f6508[i].get(str);
            if (c1982 != null) {
                return c1982;
            }
        }
        return null;
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public final void m3843(C1981 c1981) throws IOException {
        c1981.skipBytes(84);
        byte[] bArr = new byte[4];
        byte[] bArr2 = new byte[4];
        c1981.read(bArr);
        c1981.skipBytes(4);
        c1981.read(bArr2);
        int i = ByteBuffer.wrap(bArr).getInt();
        int i2 = ByteBuffer.wrap(bArr2).getInt();
        m3839(c1981, i, 5);
        c1981.m3851(i2);
        c1981.f6520 = ByteOrder.BIG_ENDIAN;
        int i3 = c1981.readInt();
        for (int i4 = 0; i4 < i3; i4++) {
            int unsignedShort = c1981.readUnsignedShort();
            int unsignedShort2 = c1981.readUnsignedShort();
            if (unsignedShort == f6492.f6526) {
                short s = c1981.readShort();
                short s2 = c1981.readShort();
                C1982 c1982M3852 = C1982.m3852((int) s, this.f6510);
                C1982 c1982M38522 = C1982.m3852((int) s2, this.f6510);
                this.f6508[0].put("ImageLength", c1982M3852);
                this.f6508[0].put("ImageWidth", c1982M38522);
                return;
            }
            c1981.skipBytes(unsignedShort2);
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:114:0x0227  */
    /* JADX WARN: Removed duplicated region for block: B:64:0x00ee  */
    /* JADX WARN: Removed duplicated region for block: B:65:0x00f5  */
    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final void m3844(C1981 c1981, int i) throws IOException {
        short s;
        short s2;
        long j;
        long j2;
        boolean z;
        int i2;
        int i3;
        int i4;
        short s3;
        int unsignedShort;
        long j3;
        this.f6509.add(Integer.valueOf(c1981.f6522));
        if (c1981.f6522 + 2 > c1981.f6521) {
            return;
        }
        short s4 = c1981.readShort();
        if ((s4 * 12) + c1981.f6522 > c1981.f6521 || s4 <= 0) {
            return;
        }
        short s5 = 0;
        while (s5 < s4) {
            int unsignedShort2 = c1981.readUnsignedShort();
            int unsignedShort3 = c1981.readUnsignedShort();
            int i5 = c1981.readInt();
            long j4 = ((long) c1981.f6522) + 4;
            C1983 c1983 = f6499[i].get(Integer.valueOf(unsignedShort2));
            if (c1983 == null) {
                C2803.m4900("Skip the tag entry since tag number is not defined: ", unsignedShort2, "ExifInterface");
            } else if (unsignedShort3 <= 0 || unsignedShort3 >= f6485.length) {
                s = s4;
                s2 = s5;
                C2803.m4900("Skip the tag entry since data format is invalid: ", unsignedShort3, "ExifInterface");
                j = 0;
                j2 = j;
                z = false;
                if (z) {
                    c1981.m3851(j4);
                    s3 = s;
                } else {
                    if (j2 > 4) {
                        int i6 = c1981.readInt();
                        int i7 = this.f6507;
                        s3 = s;
                        if (i7 == 7) {
                            if ("MakerNote".equals(c1983.f6527)) {
                                this.f6513 = i6;
                            } else if (i == 6 && "ThumbnailImage".equals(c1983.f6527)) {
                                this.f6514 = i6;
                                this.f6515 = i5;
                                C1982 c1982M3852 = C1982.m3852(6, this.f6510);
                                i3 = unsignedShort3;
                                i4 = i5;
                                C1982 c1982M3853 = C1982.m3853(this.f6514, this.f6510);
                                j3 = j4;
                                C1982 c1982M38532 = C1982.m3853(this.f6515, this.f6510);
                                this.f6508[4].put("Compression", c1982M3852);
                                this.f6508[4].put("JPEGInterchangeFormat", c1982M3853);
                                this.f6508[4].put("JPEGInterchangeFormatLength", c1982M38532);
                            }
                            i3 = unsignedShort3;
                            i4 = i5;
                            j3 = j4;
                        } else {
                            i3 = unsignedShort3;
                            i4 = i5;
                            j3 = j4;
                            if (i7 == 10 && "JpgFromRaw".equals(c1983.f6527)) {
                                this.f6516 = i6;
                            }
                        }
                        long j5 = i6;
                        if (j5 + j2 <= c1981.f6521) {
                            c1981.m3851(j5);
                            j4 = j3;
                        } else {
                            Log.w("ExifInterface", "Skip the tag entry since data offset is invalid: " + i6);
                            c1981.m3851(j3);
                        }
                    } else {
                        i3 = unsignedShort3;
                        i4 = i5;
                        s3 = s;
                    }
                    Integer num = f6502.get(Integer.valueOf(unsignedShort2));
                    if (num != null) {
                        long jM3850 = -1;
                        int i8 = i3;
                        if (i8 != 3) {
                            if (i8 == 4) {
                                jM3850 = c1981.m3850();
                            } else if (i8 == 8) {
                                unsignedShort = c1981.readShort();
                            } else if (i8 == 9 || i8 == 13) {
                                unsignedShort = c1981.readInt();
                            }
                            if (jM3850 > 0 || jM3850 >= c1981.f6521) {
                                Log.w("ExifInterface", "Skip jump into the IFD since its offset is invalid: " + jM3850);
                            } else if (this.f6509.contains(Integer.valueOf((int) jM3850))) {
                                StringBuilder sb = new StringBuilder();
                                sb.append("Skip jump into the IFD since it has already been read: IfdType ");
                                sb.append(num);
                                sb.append(" (at ");
                                sb.append(jM3850);
                                C2803.m4899(sb, ")", "ExifInterface");
                            } else {
                                c1981.m3851(jM3850);
                                m3844(c1981, num.intValue());
                            }
                            c1981.m3851(j4);
                        } else {
                            unsignedShort = c1981.readUnsignedShort();
                        }
                        jM3850 = unsignedShort;
                        if (jM3850 > 0) {
                            Log.w("ExifInterface", "Skip jump into the IFD since its offset is invalid: " + jM3850);
                            c1981.m3851(j4);
                        }
                    } else {
                        byte[] bArr = new byte[(int) j2];
                        c1981.readFully(bArr);
                        C1982 c1982 = new C1982(i3, i4, bArr);
                        this.f6508[i].put(c1983.f6527, c1982);
                        if ("DNGVersion".equals(c1983.f6527)) {
                            this.f6507 = 3;
                        }
                        if ((("Make".equals(c1983.f6527) || "Model".equals(c1983.f6527)) && c1982.m3858(this.f6510).contains("PENTAX")) || ("Compression".equals(c1983.f6527) && c1982.m3857(this.f6510) == 65535)) {
                            this.f6507 = 8;
                        }
                        if (c1981.f6522 != j4) {
                            c1981.m3851(j4);
                        }
                    }
                }
                s5 = (short) (s2 + 1);
                s4 = s3;
            } else {
                int i9 = c1983.f6528;
                if (i9 == 7 || unsignedShort3 == 7 || i9 == unsignedShort3 || (i2 = c1983.f6529) == unsignedShort3 || ((i9 == 4 || i2 == 4) && unsignedShort3 == 3) || (((c1983.f6528 == 9 || c1983.f6529 == 9) && unsignedShort3 == 8) || ((c1983.f6528 == 12 || c1983.f6529 == 12) && unsignedShort3 == 11))) {
                    if (unsignedShort3 == 7) {
                        unsignedShort3 = c1983.f6528;
                    }
                    s = s4;
                    s2 = s5;
                    j = ((long) i5) * ((long) f6485[unsignedShort3]);
                    if (j < 0 || j > 2147483647L) {
                        C2803.m4900("Skip the tag entry since the number of components is invalid: ", i5, "ExifInterface");
                        j2 = j;
                        z = false;
                        if (z) {
                        }
                        s5 = (short) (s2 + 1);
                        s4 = s3;
                    } else {
                        j2 = j;
                        z = true;
                        if (z) {
                        }
                        s5 = (short) (s2 + 1);
                        s4 = s3;
                    }
                } else {
                    StringBuilder sbM4889 = C2803.m4889("Skip the tag entry since data format (");
                    sbM4889.append(f6484[unsignedShort3]);
                    sbM4889.append(") is unexpected for tag: ");
                    C2803.m4899(sbM4889, c1983.f6527, "ExifInterface");
                }
            }
            s = s4;
            s2 = s5;
            j = 0;
            j2 = j;
            z = false;
            if (z) {
            }
            s5 = (short) (s2 + 1);
            s4 = s3;
        }
        if (c1981.f6522 + 4 <= c1981.f6521) {
            int i10 = c1981.readInt();
            long j6 = i10;
            if (j6 <= 0 || i10 >= c1981.f6521) {
                C2803.m4900("Stop reading file since a wrong offset may cause an infinite loop: ", i10, "ExifInterface");
                return;
            }
            if (this.f6509.contains(Integer.valueOf(i10))) {
                C2803.m4900("Stop reading file since re-reading an IFD may cause an infinite loop: ", i10, "ExifInterface");
                return;
            }
            c1981.m3851(j6);
            if (this.f6508[4].isEmpty()) {
                m3844(c1981, 4);
            } else if (this.f6508[5].isEmpty()) {
                m3844(c1981, 5);
            }
        }
    }

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public final void m3845(C1981 c1981) throws Throwable {
        C1982 c1982;
        m3838(c1981, c1981.available());
        m3844(c1981, 0);
        m3846(c1981, 0);
        m3846(c1981, 5);
        m3846(c1981, 4);
        m3836(0, 5);
        m3836(0, 4);
        m3836(5, 4);
        C1982 c19822 = this.f6508[1].get("PixelXDimension");
        C1982 c19823 = this.f6508[1].get("PixelYDimension");
        if (c19822 != null && c19823 != null) {
            this.f6508[0].put("ImageWidth", c19822);
            this.f6508[0].put("ImageLength", c19823);
        }
        if (this.f6508[4].isEmpty() && m3841((HashMap) this.f6508[5])) {
            HashMap<String, C1982>[] mapArr = this.f6508;
            mapArr[4] = mapArr[5];
            mapArr[5] = new HashMap<>();
        }
        if (!m3841((HashMap) this.f6508[4])) {
            Log.d("ExifInterface", "No image meets the size requirements of a thumbnail image.");
        }
        if (this.f6507 != 8 || (c1982 = this.f6508[1].get("MakerNote")) == null) {
            return;
        }
        C1981 c19812 = new C1981(c1982.f6525);
        c19812.f6520 = this.f6510;
        c19812.m3851(6L);
        m3844(c19812, 9);
        C1982 c19824 = this.f6508[9].get("ColorSpace");
        if (c19824 != null) {
            this.f6508[1].put("ColorSpace", c19824);
        }
    }

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public final void m3846(C1981 c1981, int i) throws Throwable {
        C1982 c1982;
        C1982 c1982M3852;
        C1982 c1982M38522;
        C1982 c19822 = this.f6508[i].get("DefaultCropSize");
        C1982 c19823 = this.f6508[i].get("SensorTopBorder");
        C1982 c19824 = this.f6508[i].get("SensorLeftBorder");
        C1982 c19825 = this.f6508[i].get("SensorBottomBorder");
        C1982 c19826 = this.f6508[i].get("SensorRightBorder");
        if (c19822 != null) {
            if (c19822.f6523 == 5) {
                C1984[] c1984Arr = (C1984[]) c19822.m3859(this.f6510);
                if (c1984Arr == null || c1984Arr.length != 2) {
                    StringBuilder sbM4889 = C2803.m4889("Invalid crop size values. cropSize=");
                    sbM4889.append(Arrays.toString(c1984Arr));
                    Log.w("ExifInterface", sbM4889.toString());
                    return;
                }
                c1982M3852 = C1982.m3855(c1984Arr[0], this.f6510);
                c1982M38522 = C1982.m3855(c1984Arr[1], this.f6510);
            } else {
                int[] iArr = (int[]) c19822.m3859(this.f6510);
                if (iArr == null || iArr.length != 2) {
                    StringBuilder sbM48892 = C2803.m4889("Invalid crop size values. cropSize=");
                    sbM48892.append(Arrays.toString(iArr));
                    Log.w("ExifInterface", sbM48892.toString());
                    return;
                }
                c1982M3852 = C1982.m3852(iArr[0], this.f6510);
                c1982M38522 = C1982.m3852(iArr[1], this.f6510);
            }
            this.f6508[i].put("ImageWidth", c1982M3852);
            this.f6508[i].put("ImageLength", c1982M38522);
            return;
        }
        if (c19823 == null || c19824 == null || c19825 == null || c19826 == null) {
            C1982 c19827 = this.f6508[i].get("ImageLength");
            C1982 c19828 = this.f6508[i].get("ImageWidth");
            if ((c19827 == null || c19828 == null) && (c1982 = this.f6508[i].get("JPEGInterchangeFormat")) != null) {
                m3839(c1981, c1982.m3857(this.f6510), i);
                return;
            }
            return;
        }
        int iM3857 = c19823.m3857(this.f6510);
        int iM38572 = c19825.m3857(this.f6510);
        int iM38573 = c19826.m3857(this.f6510);
        int iM38574 = c19824.m3857(this.f6510);
        if (iM38572 <= iM3857 || iM38573 <= iM38574) {
            return;
        }
        C1982 c1982M38523 = C1982.m3852(iM38572 - iM3857, this.f6510);
        C1982 c1982M38524 = C1982.m3852(iM38573 - iM38574, this.f6510);
        this.f6508[i].put("ImageLength", c1982M38523);
        this.f6508[i].put("ImageWidth", c1982M38524);
    }

    /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
    public final void m3847(C1981 c1981) throws Throwable {
        m3845(c1981);
        if (this.f6508[0].get("JpgFromRaw") != null) {
            m3839(c1981, this.f6516, 5);
        }
        C1982 c1982 = this.f6508[0].get("ISO");
        C1982 c19822 = this.f6508[1].get("PhotographicSensitivity");
        if (c1982 == null || c19822 != null) {
            return;
        }
        this.f6508[1].put("PhotographicSensitivity", c1982);
    }

    /* JADX INFO: renamed from: ނ, reason: contains not printable characters */
    public final ByteOrder m3848(C1981 c1981) throws IOException {
        short s = c1981.readShort();
        if (s == 18761) {
            return ByteOrder.LITTLE_ENDIAN;
        }
        if (s == 19789) {
            return ByteOrder.BIG_ENDIAN;
        }
        StringBuilder sbM4889 = C2803.m4889("Invalid byte order: ");
        sbM4889.append(Integer.toHexString(s));
        throw new IOException(sbM4889.toString());
    }

    /* JADX WARN: Removed duplicated region for block: B:28:0x006d  */
    /* JADX INFO: renamed from: ރ, reason: contains not printable characters */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final void m3849(C1981 c1981) throws Throwable {
        C1982 c1982;
        int iM3857;
        HashMap<String, C1982> map = this.f6508[4];
        C1982 c19822 = map.get("Compression");
        if (c19822 == null) {
            this.f6511 = 6;
            m3840(c1981, map);
            return;
        }
        int iM38572 = c19822.m3857(this.f6510);
        this.f6511 = iM38572;
        boolean z = true;
        if (iM38572 != 1) {
            if (iM38572 == 6) {
                m3840(c1981, map);
                return;
            } else if (iM38572 != 7) {
                return;
            }
        }
        C1982 c19823 = map.get("BitsPerSample");
        if (c19823 != null) {
            int[] iArr = (int[]) c19823.m3859(this.f6510);
            if (!Arrays.equals(f6478, iArr) && (this.f6507 != 3 || (c1982 = map.get("PhotometricInterpretation")) == null || (((iM3857 = c1982.m3857(this.f6510)) != 1 || !Arrays.equals(iArr, f6479)) && (iM3857 != 6 || !Arrays.equals(iArr, f6478))))) {
                z = false;
            }
        }
        if (z) {
            C1982 c19824 = map.get("StripOffsets");
            C1982 c19825 = map.get("StripByteCounts");
            if (c19824 == null || c19825 == null) {
                return;
            }
            long[] jArrM3832 = m3832(c19824.m3859(this.f6510));
            long[] jArrM38322 = m3832(c19825.m3859(this.f6510));
            if (jArrM3832 == null) {
                Log.w("ExifInterface", "stripOffsets should not be null.");
                return;
            }
            if (jArrM38322 == null) {
                Log.w("ExifInterface", "stripByteCounts should not be null.");
                return;
            }
            long j = 0;
            for (long j2 : jArrM38322) {
                j += j2;
            }
            byte[] bArr = new byte[(int) j];
            int i = 0;
            int i2 = 0;
            for (int i3 = 0; i3 < jArrM3832.length; i3++) {
                int i4 = (int) jArrM3832[i3];
                int i5 = (int) jArrM38322[i3];
                int i6 = i4 - i;
                if (i6 < 0) {
                    Log.d("ExifInterface", "Invalid strip offset value");
                }
                c1981.m3851(i6);
                int i7 = i + i6;
                byte[] bArr2 = new byte[i5];
                c1981.read(bArr2);
                i = i7 + i5;
                System.arraycopy(bArr2, 0, bArr, i2, i5);
                i2 += i5;
            }
        }
    }
}