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

package o;

import java.math.BigInteger;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Locale;
import java.util.Objects;

@eraseTypedefault
public final class renderrenderArguments {
    private static final int setLabel = 4;
    private static final int write = 8;
    private static final char setBackground = '.';
    private static final child setOptions = child.setOptions(setBackground);
    private static final char setError = ':';
    private static final child setElement = child.setOptions(setError);
    private static final Inet4Address read = (Inet4Address) setError("127.0.0.1");
    private static final Inet4Address setFieldValue = (Inet4Address) setError("0.0.0.0");

    private renderrenderArguments() {
    }

    private static Inet4Address setOptions(byte[] bArr) {
        JavaClassFinderUtil.setFieldValue(bArr.length == 4, "Byte array has invalid length for an IPv4 address: %s != 4.", bArr.length);
        return (Inet4Address) setOptions(bArr, (String) null);
    }

    public static InetAddress setError(String str) {
        setOptions setoptions = new setOptions();
        byte[] options = setOptions(str, setoptions);
        if (options == null) {
            throw setBackground("'%s' is not an IP string literal.", str);
        }
        return setOptions(options, setoptions.setFieldValue);
    }

    public static boolean setOptions(String str) {
        return setOptions(str, (setOptions) null) != null;
    }

    static final class setOptions {
        private String setFieldValue;

        private setOptions() {
        }
    }

    @o.isVisibilityMoreSpecific
    private static byte[] setOptions(java.lang.String r9, o.renderrenderArguments.setOptions r10) {
        throw new UnsupportedOperationException("Method not decompiled: o.renderrenderArguments.setOptions(java.lang.String, o.renderrenderArguments$setOptions):byte[]");
    }

    @isVisibilityMoreSpecific
    private static byte[] read(String str) {
        if (setOptions.setBackground(str) + 1 != 4) {
            return null;
        }
        byte[] bArr = new byte[4];
        int i = 0;
        for (int i2 = 0; i2 < 4; i2++) {
            int indexOf = str.indexOf(46, i);
            if (indexOf == -1) {
                indexOf = str.length();
            }
            try {
                bArr[i2] = setBackground(str, i, indexOf);
                i = indexOf + 1;
            } catch (NumberFormatException unused) {
                return null;
            }
        }
        return bArr;
    }

    @isVisibilityMoreSpecific
    private static byte[] write(String str) {
        int background = setElement.setBackground(str);
        if (background >= 2 && background <= 8) {
            int i = 1;
            int i2 = background + 1;
            int i3 = 8 - i2;
            boolean z = false;
            for (int i4 = 0; i4 < str.length() - 1; i4++) {
                if (str.charAt(i4) == ':' && str.charAt(i4 + 1) == ':') {
                    if (z) {
                        return null;
                    }
                    int i5 = i3 + 1;
                    if (i4 == 0) {
                        i5 = i3 + 2;
                    }
                    if (i4 == str.length() - 2) {
                        i5++;
                    }
                    i3 = i5;
                    z = true;
                }
            }
            if (str.charAt(0) == ':' && str.charAt(1) != ':') {
                return null;
            }
            if (str.charAt(str.length() - 1) == ':' && str.charAt(str.length() - 2) != ':') {
                return null;
            }
            if (z && i3 <= 0) {
                return null;
            }
            if (!z && i2 != 8) {
                return null;
            }
            ByteBuffer allocate = ByteBuffer.allocate(16);
            try {
                if (str.charAt(0) != ':') {
                    i = 0;
                }
                while (i < str.length()) {
                    int indexOf = str.indexOf(58, i);
                    if (indexOf == -1) {
                        indexOf = str.length();
                    }
                    if (str.charAt(i) == ':') {
                        for (int i6 = 0; i6 < i3; i6++) {
                            allocate.putShort((short) 0);
                        }
                    } else {
                        allocate.putShort(setFieldValue(str, i, indexOf));
                    }
                    i = indexOf + 1;
                }
                return allocate.array();
            } catch (NumberFormatException unused) {
            }
        }
        return null;
    }

    @isVisibilityMoreSpecific
    private static String RemoteActionCompatParcelizer(String str) {
        int lastIndexOf = str.lastIndexOf(58) + 1;
        String substring = str.substring(0, lastIndexOf);
        byte[] read2 = read(str.substring(lastIndexOf));
        if (read2 == null) {
            return null;
        }
        return substring + Integer.toHexString(((read2[0] & 255) << 8) | (read2[1] & 255)) + ":" + Integer.toHexString((read2[3] & 255) | ((read2[2] & 255) << 8));
    }

    private static byte setBackground(String str, int i, int i2) {
        int i3 = i2 - i;
        if (i3 <= 0 || i3 > 3) {
            throw new NumberFormatException();
        }
        if (i3 > 1 && str.charAt(i) == '0') {
            throw new NumberFormatException();
        }
        int i4 = 0;
        while (i < i2) {
            int digit = Character.digit(str.charAt(i), 10);
            if (digit < 0) {
                throw new NumberFormatException();
            }
            i4 = (i4 * 10) + digit;
            i++;
        }
        if (i4 <= 255) {
            return (byte) i4;
        }
        throw new NumberFormatException();
    }

    private static int setLabel(String str, int i, int i2) {
        int digit;
        int i3 = 0;
        while (i < i2) {
            if (i3 > 214748364 || (digit = Character.digit(str.charAt(i), 10)) < 0) {
                return -1;
            }
            i3 = (i3 * 10) + digit;
            i++;
        }
        return i3;
    }

    private static short setFieldValue(String str, int i, int i2) {
        int i3 = i2 - i;
        if (i3 <= 0 || i3 > 4) {
            throw new NumberFormatException();
        }
        int i4 = 0;
        while (i < i2) {
            i4 = (i4 << 4) | Character.digit(str.charAt(i), 16);
            i++;
        }
        return (short) i4;
    }

    private static InetAddress setOptions(byte[] bArr, String str) {
        try {
            InetAddress byAddress = InetAddress.getByAddress(bArr);
            if (str == null) {
                return byAddress;
            }
            JavaClassFinderUtil.setError(byAddress instanceof Inet6Address, "Unexpected state, scope should only appear for ipv6");
            Inet6Address inet6Address = (Inet6Address) byAddress;
            int label = setLabel(str, 0, str.length());
            if (label != -1) {
                return Inet6Address.getByAddress(inet6Address.getHostAddress(), inet6Address.getAddress(), label);
            }
            try {
                NetworkInterface byName = NetworkInterface.getByName(str);
                if (byName == null) {
                    throw setBackground("No such interface: '%s'", str);
                }
                return Inet6Address.getByAddress(inet6Address.getHostAddress(), inet6Address.getAddress(), byName);
            } catch (SocketException | UnknownHostException e) {
                throw new IllegalArgumentException("No such interface: " + str, e);
            }
        } catch (UnknownHostException e2) {
            throw new AssertionError(e2);
        }
    }

    public static String write(InetAddress inetAddress) {
        JavaClassFinderUtil.setFieldValue(inetAddress);
        if (inetAddress instanceof Inet4Address) {
            String hostAddress = inetAddress.getHostAddress();
            Objects.requireNonNull(hostAddress);
            return hostAddress;
        }
        byte[] address = inetAddress.getAddress();
        int[] iArr = new int[8];
        for (int i = 0; i < 8; i++) {
            int i2 = i * 2;
            iArr[i] = JavaClassifierType.setOptions((byte) 0, (byte) 0, address[i2], address[i2 + 1]);
        }
        setLabel(iArr);
        return setError(iArr) + AudioAttributesImplApi26Parcelizer((Inet6Address) inetAddress);
    }

    private static String AudioAttributesImplApi26Parcelizer(Inet6Address inet6Address) {
        NetworkInterface scopedInterface = inet6Address.getScopedInterface();
        if (scopedInterface != null) {
            return "%" + scopedInterface.getName();
        }
        int scopeId = inet6Address.getScopeId();
        if (scopeId != 0) {
            return "%" + scopeId;
        }
        return "";
    }

    private static void setLabel(int[] iArr) {
        int i = -1;
        int i2 = -1;
        int i3 = -1;
        for (int i4 = 0; i4 < iArr.length + 1; i4++) {
            if (i4 >= iArr.length || iArr[i4] != 0) {
                if (i3 >= 0) {
                    int i5 = i4 - i3;
                    if (i5 > i) {
                        i2 = i3;
                        i = i5;
                    }
                    i3 = -1;
                }
            } else if (i3 < 0) {
                i3 = i4;
            }
        }
        if (i >= 2) {
            Arrays.fill(iArr, i2, i + i2, -1);
        }
    }

    private static String setError(int[] iArr) {
        StringBuilder sb = new StringBuilder(39);
        int i = 0;
        boolean z = false;
        while (i < iArr.length) {
            boolean z2 = iArr[i] >= 0;
            if (z2) {
                if (z) {
                    sb.append(setError);
                }
                sb.append(Integer.toHexString(iArr[i]));
            } else if (i == 0 || z) {
                sb.append("::");
            }
            i++;
            z = z2;
        }
        return sb.toString();
    }

    public static String IconCompatParcelizer(InetAddress inetAddress) {
        if (inetAddress instanceof Inet6Address) {
            return "[" + write(inetAddress) + "]";
        }
        return write(inetAddress);
    }

    public static InetAddress setLabel(String str) {
        InetAddress error = setError(str, true);
        if (error != null) {
            return error;
        }
        throw setBackground("Not a valid URI IP literal: '%s'", str);
    }

    @isVisibilityMoreSpecific
    private static InetAddress setError(String str, boolean z) {
        int i;
        setOptions setoptions;
        JavaClassFinderUtil.setFieldValue(str);
        if (str.startsWith("[") && str.endsWith("]")) {
            str = str.substring(1, str.length() - 1);
            i = 16;
        } else {
            i = 4;
        }
        Object[] objArr = 0;
        if (z) {
            setoptions = new setOptions();
        } else {
            setoptions = null;
        }
        byte[] options = setOptions(str, setoptions);
        if (options == null || options.length != i) {
            return null;
        }
        return setOptions(options, setoptions != null ? setoptions.setFieldValue : null);
    }

    public static boolean setFieldValue(String str) {
        return setError(str, false) != null;
    }

    public static boolean IconCompatParcelizer(Inet6Address inet6Address) {
        byte b;
        if (!inet6Address.isIPv4CompatibleAddress()) {
            return false;
        }
        byte[] address = inet6Address.getAddress();
        return (address[12] == 0 && address[13] == 0 && address[14] == 0 && ((b = address[15]) == 0 || b == 1)) ? false : true;
    }

    public static Inet4Address setOptions(Inet6Address inet6Address) {
        JavaClassFinderUtil.setOptions(IconCompatParcelizer(inet6Address), "Address '%s' is not IPv4-compatible.", write((InetAddress) inet6Address));
        return setOptions(Arrays.copyOfRange(inet6Address.getAddress(), 12, 16));
    }

    public static boolean setElement(Inet6Address inet6Address) {
        byte[] address = inet6Address.getAddress();
        return address[0] == 32 && address[1] == 2;
    }

    public static Inet4Address setLabel(Inet6Address inet6Address) {
        JavaClassFinderUtil.setOptions(setElement(inet6Address), "Address '%s' is not a 6to4 address.", write((InetAddress) inet6Address));
        return setOptions(Arrays.copyOfRange(inet6Address.getAddress(), 2, 6));
    }

    public static final class setLabel {
        private final Inet4Address setBackground;
        private final Inet4Address setError;
        private final int setFieldValue;
        private final int setOptions;

        public setLabel(@isVisibilityMoreSpecific Inet4Address inet4Address, @isVisibilityMoreSpecific Inet4Address inet4Address2, int i, int i2) {
            JavaClassFinderUtil.setFieldValue(i >= 0 && i <= 65535, "port '%s' is out of range (0 <= port <= 0xffff)", i);
            JavaClassFinderUtil.setFieldValue(i2 >= 0 && i2 <= 65535, "flags '%s' is out of range (0 <= flags <= 0xffff)", i2);
            this.setError = (Inet4Address) FakePureImplementationsProvider.setLabel(inet4Address, renderrenderArguments.setFieldValue);
            this.setBackground = (Inet4Address) FakePureImplementationsProvider.setLabel(inet4Address2, renderrenderArguments.setFieldValue);
            this.setOptions = i;
            this.setFieldValue = i2;
        }

        public Inet4Address setFieldValue() {
            return this.setError;
        }

        public Inet4Address setOptions() {
            return this.setBackground;
        }

        public int setBackground() {
            return this.setOptions;
        }

        public int setError() {
            return this.setFieldValue;
        }
    }

    public static boolean read(Inet6Address inet6Address) {
        byte[] address = inet6Address.getAddress();
        return address[0] == 32 && address[1] == 1 && address[2] == 0 && address[3] == 0;
    }

    public static setLabel setFieldValue(Inet6Address inet6Address) {
        JavaClassFinderUtil.setOptions(read(inet6Address), "Address '%s' is not a Teredo address.", write((InetAddress) inet6Address));
        byte[] address = inet6Address.getAddress();
        Inet4Address options = setOptions(Arrays.copyOfRange(address, 4, 8));
        short readShort = LazyJavaStaticClassScopeLambda1.setError(address, 8).readShort();
        short readShort2 = LazyJavaStaticClassScopeLambda1.setError(address, 10).readShort();
        byte[] copyOfRange = Arrays.copyOfRange(address, 12, 16);
        for (int i = 0; i < copyOfRange.length; i++) {
            copyOfRange[i] = (byte) (~copyOfRange[i]);
        }
        return new setLabel(options, setOptions(copyOfRange), (~readShort2) & 65535, readShort & 65535);
    }

    public static boolean write(Inet6Address inet6Address) {
        if (read(inet6Address)) {
            return false;
        }
        byte[] address = inet6Address.getAddress();
        return (address[8] | 3) == 3 && address[9] == 0 && address[10] == 94 && address[11] == -2;
    }

    public static Inet4Address setBackground(Inet6Address inet6Address) {
        JavaClassFinderUtil.setOptions(write(inet6Address), "Address '%s' is not an ISATAP address.", write((InetAddress) inet6Address));
        return setOptions(Arrays.copyOfRange(inet6Address.getAddress(), 12, 16));
    }

    public static boolean RemoteActionCompatParcelizer(Inet6Address inet6Address) {
        return IconCompatParcelizer(inet6Address) || setElement(inet6Address) || read(inet6Address);
    }

    public static Inet4Address setError(Inet6Address inet6Address) {
        if (IconCompatParcelizer(inet6Address)) {
            return setOptions(inet6Address);
        }
        if (setElement(inet6Address)) {
            return setLabel(inet6Address);
        }
        if (read(inet6Address)) {
            return setFieldValue(inet6Address).setOptions();
        }
        throw setBackground("'%s' has no embedded IPv4 address.", write((InetAddress) inet6Address));
    }

    public static boolean setBackground(String str) {
        byte[] options = setOptions(str, (setOptions) null);
        if (options == null || options.length != 16) {
            return false;
        }
        int i = 0;
        while (true) {
            if (i >= 10) {
                for (int i2 = 10; i2 < 12; i2++) {
                    if (options[i2] != -1) {
                        return false;
                    }
                }
                return true;
            }
            if (options[i] != 0) {
                return false;
            }
            i++;
        }
    }

    public static Inet4Address setError(InetAddress inetAddress) {
        boolean z;
        long j;
        if (inetAddress instanceof Inet4Address) {
            return (Inet4Address) inetAddress;
        }
        byte[] address = inetAddress.getAddress();
        int i = 0;
        while (true) {
            if (i >= 15) {
                z = true;
                break;
            }
            if (address[i] != 0) {
                z = false;
                break;
            }
            i++;
        }
        if (z && address[15] == 1) {
            return read;
        }
        if (z && address[15] == 0) {
            return setFieldValue;
        }
        Inet6Address inet6Address = (Inet6Address) inetAddress;
        if (RemoteActionCompatParcelizer(inet6Address)) {
            j = setError(inet6Address).hashCode();
        } else {
            j = ByteBuffer.wrap(inet6Address.getAddress(), 0, 8).getLong();
        }
        int fieldValue = LazyJavaScopeLambda1.write().setFieldValue(j).setFieldValue() | (-536870912);
        if (fieldValue == -1) {
            fieldValue = -2;
        }
        return setOptions(JavaClassifierType.setBackground(fieldValue));
    }

    public static int setBackground(InetAddress inetAddress) {
        return LazyJavaStaticClassScopeLambda1.setFieldValue(setError(inetAddress).getAddress()).readInt();
    }

    public static BigInteger setElement(InetAddress inetAddress) {
        return new BigInteger(1, inetAddress.getAddress());
    }

    public static Inet4Address setBackground(int i) {
        return setOptions(JavaClassifierType.setBackground(i));
    }

    public static Inet4Address setLabel(BigInteger bigInteger) {
        return (Inet4Address) setBackground(bigInteger, false);
    }

    public static Inet6Address setOptions(BigInteger bigInteger) {
        return (Inet6Address) setBackground(bigInteger, true);
    }

    private static InetAddress setBackground(BigInteger bigInteger, boolean z) {
        JavaClassFinderUtil.setError(bigInteger.signum() >= 0, "BigInteger must be greater than or equal to 0");
        int i = z ? 16 : 4;
        byte[] byteArray = bigInteger.toByteArray();
        byte[] bArr = new byte[i];
        int max = Math.max(0, byteArray.length - i);
        int length = byteArray.length - max;
        for (int i2 = 0; i2 < max; i2++) {
            if (byteArray[i2] != 0) {
                throw setBackground("BigInteger cannot be converted to InetAddress because it has more than %d bytes: %s", Integer.valueOf(i), bigInteger);
            }
        }
        System.arraycopy(byteArray, max, bArr, i - length, length);
        try {
            return InetAddress.getByAddress(bArr);
        } catch (UnknownHostException e) {
            throw new AssertionError(e);
        }
    }

    public static InetAddress setError(byte[] bArr) throws UnknownHostException {
        byte[] bArr2 = new byte[bArr.length];
        for (int i = 0; i < bArr.length; i++) {
            bArr2[i] = bArr[(bArr.length - i) - 1];
        }
        return InetAddress.getByAddress(bArr2);
    }

    public static InetAddress setOptions(InetAddress inetAddress) {
        byte[] address = inetAddress.getAddress();
        int length = address.length - 1;
        while (length >= 0 && address[length] == 0) {
            address[length] = -1;
            length--;
        }
        JavaClassFinderUtil.setOptions(length >= 0, "Decrementing %s would wrap.", inetAddress);
        address[length] = (byte) (address[length] - 1);
        return setOptions(address, (String) null);
    }

    public static InetAddress setLabel(InetAddress inetAddress) {
        byte[] address = inetAddress.getAddress();
        int length = address.length - 1;
        while (true) {
            if (length < 0 || address[length] != -1) {
                break;
            }
            address[length] = 0;
            length--;
        }
        JavaClassFinderUtil.setOptions(length >= 0, "Incrementing %s would wrap.", inetAddress);
        address[length] = (byte) (address[length] + 1);
        return setOptions(address, (String) null);
    }

    public static boolean setFieldValue(InetAddress inetAddress) {
        for (byte b : inetAddress.getAddress()) {
            if (b != -1) {
                return false;
            }
        }
        return true;
    }

    private static IllegalArgumentException setBackground(String str, Object... objArr) {
        return new IllegalArgumentException(String.format(Locale.ROOT, str, objArr));
    }
}