package com.tencent.utils;

import g.a.a.a.a;
import io.netty.handler.codec.dns.DnsRecord;
import io.netty.handler.codec.memcache.binary.BinaryMemcacheOpcodes;
import java.nio.charset.Charset;
import java.util.Arrays;

/* JADX INFO: loaded from: classes.dex */
public class ByteUtil {
    private ByteUtil() {
    }

    public static String byte2Hex(byte b2) {
        return value2Hex(Byte.valueOf(b2));
    }

    public static String bytes2HexStr(byte[] bArr) {
        StringBuilder sb = new StringBuilder();
        if (bArr == null || bArr.length <= 0) {
            return "";
        }
        char[] cArr = new char[2];
        for (int i2 = 0; i2 < bArr.length; i2++) {
            cArr[0] = forDigit((bArr[i2] >>> 4) & 15, 16);
            cArr[1] = forDigit(bArr[i2] & BinaryMemcacheOpcodes.PREPEND, 16);
            sb.append(cArr);
        }
        return sb.toString();
    }

    public static String bytes2HexStr(byte[] bArr, int i2, int i3) {
        byte[] bArr2 = new byte[i3];
        System.arraycopy(bArr, i2, bArr2, 0, i3);
        return bytes2HexStr(bArr2);
    }

    public static long bytes2long(byte[] bArr) {
        return bytes2long(bArr, 0, bArr.length);
    }

    public static long bytes2long(byte[] bArr, int i2, int i3) {
        long j2 = 0;
        for (int i4 = 0; i4 < i3; i4++) {
            j2 |= (((long) bArr[i2 + i4]) & 255) << (((i3 - 1) - i4) * 8);
        }
        return j2;
    }

    public static int countOnes(int i2) {
        int i3 = 0;
        while (i2 != 0) {
            i3++;
            i2 &= i2 - 1;
        }
        return i3;
    }

    public static String decimal2fitHex(long j2) {
        String upperCase = Long.toHexString(j2).toUpperCase();
        return upperCase.length() % 2 != 0 ? a.t("0", upperCase) : upperCase.toUpperCase();
    }

    public static String decimal2fitHex(long j2, int i2) {
        StringBuilder sb = new StringBuilder(decimal2fitHex(j2));
        while (sb.length() < i2) {
            sb.insert(0, '0');
        }
        return sb.toString();
    }

    public static void encrypt(byte[] bArr, int i2) {
        int length = bArr.length;
        byte b2 = (byte) (i2 & DnsRecord.CLASS_ANY);
        byte b3 = (byte) ((i2 >> 8) & DnsRecord.CLASS_ANY);
        for (int i3 = 0; i3 < (length >> 1); i3++) {
            int i4 = i3 * 2;
            bArr[i4] = (byte) (bArr[i4] ^ b2);
            int i5 = i4 + 1;
            bArr[i5] = (byte) (bArr[i5] ^ b3);
        }
    }

    public static String fitDecimalStr(int i2, int i3) {
        StringBuilder sb = new StringBuilder(String.valueOf(i2));
        while (sb.length() < i3) {
            sb.insert(0, "0");
        }
        return sb.toString();
    }

    private static char forDigit(int i2, int i3) {
        if (i2 >= i3 || i2 < 0 || i3 < 2 || i3 > 36) {
            return (char) 0;
        }
        return (char) (i2 < 10 ? i2 + 48 : i2 + 55);
    }

    public static int getBitFromLeft(byte[] bArr, int i2, int i3) {
        int i4 = i3 - 1;
        return (bArr[i2 + (i4 / 8)] & (1 << (i4 % 8))) != 0 ? 1 : 0;
    }

    public static byte getXOR(byte[] bArr, int i2, int i3) {
        byte b2 = 0;
        for (int i4 = 0; i4 < i3; i4++) {
            b2 = (byte) (b2 ^ bArr[i4 + i2]);
        }
        return b2;
    }

    private static int hexChar2byte(char c2) {
        switch (c2) {
            case '0':
                return 0;
            case '1':
                return 1;
            case '2':
                return 2;
            case '3':
                return 3;
            case '4':
                return 4;
            case '5':
                return 5;
            case '6':
                return 6;
            case '7':
                return 7;
            case '8':
                return 8;
            case '9':
                return 9;
            default:
                switch (c2) {
                    case 'A':
                        return 10;
                    case 'B':
                        return 11;
                    case 'C':
                        return 12;
                    case 'D':
                        return 13;
                    case 'E':
                        return 14;
                    case 'F':
                        return 15;
                    default:
                        switch (c2) {
                            case 'a':
                                return 10;
                            case 'b':
                                return 11;
                            case 'c':
                                return 12;
                            case 'd':
                                return 13;
                            case 'e':
                                return 14;
                            case 'f':
                                return 15;
                            default:
                                return -1;
                        }
                }
        }
    }

    public static byte[] hexStr2bytes(String str) {
        int length = str.length() / 2;
        byte[] bArr = new byte[length];
        char[] charArray = str.toUpperCase().toCharArray();
        for (int i2 = 0; i2 < length; i2++) {
            int i3 = i2 * 2;
            bArr[i2] = (byte) (hexChar2byte(charArray[i3 + 1]) | (hexChar2byte(charArray[i3]) << 4));
        }
        return bArr;
    }

    public static long hexStr2decimal(String str) {
        return Long.parseLong(str, 16);
    }

    public static String int2Hex(int i2) {
        return value2Hex(Integer.valueOf(i2));
    }

    public static String long2Hex(long j2) {
        return value2Hex(Long.valueOf(j2));
    }

    public static byte[] long2bytes(long j2, int i2) {
        byte[] bArr = new byte[i2];
        for (int i3 = 0; i3 < i2; i3++) {
            bArr[i3] = (byte) ((j2 >>> (((i2 - i3) - 1) * 8)) & 255);
        }
        return bArr;
    }

    public static byte[] long2bytes(long j2, byte[] bArr, int i2, int i3) {
        for (int i4 = 0; i4 < i3; i4++) {
            bArr[i2 + i4] = (byte) ((j2 >>> (((i3 - i4) - 1) * 8)) & 255);
        }
        return bArr;
    }

    public static String short2Hex(short s2) {
        return value2Hex(Short.valueOf(s2));
    }

    public static String str2HexString(String str) {
        byte[] bytes;
        char[] charArray = "0123456789ABCDEF".toCharArray();
        StringBuilder sb = new StringBuilder();
        try {
            bytes = str.getBytes(Charset.forName("utf8"));
        } catch (Exception e2) {
            e2.printStackTrace();
            bytes = null;
        }
        for (int i2 = 0; i2 < bytes.length; i2++) {
            sb.append(charArray[(bytes[i2] & 240) >> 4]);
            sb.append(charArray[bytes[i2] & BinaryMemcacheOpcodes.PREPEND]);
        }
        return sb.toString();
    }

    public static String toBinString(long j2, int i2) {
        return toBinString(j2, i2, true);
    }

    public static String toBinString(long j2, int i2, boolean z2) {
        int i3 = i2 * 8;
        char[] cArr = new char[i3];
        Arrays.fill(cArr, '0');
        do {
            i3--;
            if ((1 & j2) > 0) {
                cArr[i3] = '1';
            }
            j2 >>>= 1;
            if (j2 == 0) {
                break;
            }
        } while (i3 > 0);
        if (!z2 || i2 <= 1) {
            return new String(cArr);
        }
        StringBuilder sb = new StringBuilder();
        boolean z3 = false;
        for (int i4 = 0; i4 < i2; i4++) {
            if (z3) {
                sb.append(' ');
            } else {
                z3 = true;
            }
            sb.append(cArr, i4 * 8, 8);
        }
        return sb.toString();
    }

    public static float[] toFloatArray(byte[] bArr) {
        int length = bArr.length >> 1;
        float[] fArr = new float[length];
        for (int i2 = 0; i2 < length; i2++) {
            int i3 = i2 * 2;
            fArr[i2] = ((bArr[i3 + 1] << 8) | (bArr[i3] & 255)) / 32768.0f;
        }
        return fArr;
    }

    public static Number[] toNumberArray(float[] fArr) {
        int length = fArr.length;
        Number[] numberArr = new Number[length];
        for (int i2 = 0; i2 < length; i2++) {
            numberArr[i2] = Float.valueOf(fArr[i2]);
        }
        return numberArr;
    }

    public static short[] toShortArray(byte[] bArr) {
        int length = bArr.length >> 1;
        short[] sArr = new short[length];
        for (int i2 = 0; i2 < length; i2++) {
            int i3 = i2 * 2;
            sArr[i2] = (short) ((bArr[i3 + 1] << 8) | (bArr[i3] & 255));
        }
        return sArr;
    }

    /* JADX WARN: Removed duplicated region for block: B:17:0x0033 A[RETURN] */
    /* JADX WARN: Removed duplicated region for block: B:19:0x0036  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public static java.lang.String value2Hex(java.lang.Number r2) {
        /*
            boolean r0 = r2 instanceof java.lang.Byte
            if (r0 == 0) goto Lf
            byte r2 = r2.byteValue()
            long r0 = (long) r2
            r2 = 1
        La:
            byte[] r2 = long2bytes(r0, r2)
            goto L31
        Lf:
            boolean r0 = r2 instanceof java.lang.Short
            if (r0 == 0) goto L1a
            short r2 = r2.shortValue()
            long r0 = (long) r2
            r2 = 2
            goto La
        L1a:
            boolean r0 = r2 instanceof java.lang.Integer
            if (r0 == 0) goto L25
            int r2 = r2.intValue()
            long r0 = (long) r2
            r2 = 4
            goto La
        L25:
            boolean r0 = r2 instanceof java.lang.Long
            if (r0 == 0) goto L30
            long r0 = r2.longValue()
            r2 = 8
            goto La
        L30:
            r2 = 0
        L31:
            if (r2 != 0) goto L36
            java.lang.String r2 = "00"
            return r2
        L36:
            java.lang.String r2 = bytes2HexStr(r2)
            return r2
        */
        throw new UnsupportedOperationException("Method not decompiled: com.tencent.utils.ByteUtil.value2Hex(java.lang.Number):java.lang.String");
    }
}