package nano;

import com.google.protobuf.nano.CodedInputByteBufferNano;
import com.google.protobuf.nano.CodedOutputByteBufferNano;
import com.google.protobuf.nano.InternalNano;
import com.google.protobuf.nano.InvalidProtocolBufferNanoException;
import com.google.protobuf.nano.MessageNano;
import com.google.protobuf.nano.WireFormatNano;
import java.io.IOException;
import nano.LimitComparisonRequest;

/* compiled from: TbsSdkJava */
public interface LimitComparisonResponse {

    /* compiled from: TbsSdkJava */
    public static final class LimitComparison_Response extends MessageNano {

        private static volatile LimitComparison_Response[] _emptyArray;

        public LimitComparisonRequest.LimitComparison_Request inputParam;

        public Comparison_Lines outputParam;

        /* compiled from: TbsSdkJava */
        public static final class Comparison_Lines extends MessageNano {

            private static volatile Comparison_Lines[] _emptyArray;

            private int bitField0_;

            public LinePoint[] lineData;

            private int tradeDate_;

            /* compiled from: TbsSdkJava */
            public static final class LinePoint extends MessageNano {

                private static volatile LinePoint[] _emptyArray;

                private int bitField0_;

                public Point[] line;

                private int type_;

                public LinePoint() {
                    clear();
                }

                public static LinePoint[] emptyArray() {
                    if (_emptyArray == null) {
                        synchronized (InternalNano.LAZY_INIT_LOCK) {
                            try {
                                if (_emptyArray == null) {
                                    _emptyArray = new LinePoint[0];
                                }
                            } catch (Throwable th) {
                                throw th;
                            }
                        }
                    }
                    return _emptyArray;
                }

                public static LinePoint parseFrom(byte[] bArr) throws InvalidProtocolBufferNanoException {
                    return (LinePoint) MessageNano.mergeFrom(new LinePoint(), bArr);
                }

                public LinePoint clear() {
                    this.bitField0_ = 0;
                    this.line = Point.emptyArray();
                    this.type_ = 0;
                    this.cachedSize = -1;
                    return this;
                }

                public LinePoint clearType() {
                    this.type_ = 0;
                    this.bitField0_ &= -2;
                    return this;
                }

                /* access modifiers changed from: protected */
                public int computeSerializedSize() {
                    int computeSerializedSize = super.computeSerializedSize();
                    Point[] pointArr = this.line;
                    if (pointArr != null && pointArr.length > 0) {
                        int i10 = 0;
                        while (true) {
                            Point[] pointArr2 = this.line;
                            if (i10 >= pointArr2.length) {
                                break;
                            }
                            Point point = pointArr2[i10];
                            if (point != null) {
                                computeSerializedSize += CodedOutputByteBufferNano.computeMessageSize(1, point);
                            }
                            i10++;
                        }
                    }
                    if ((this.bitField0_ & 1) != 0) {
                        return computeSerializedSize + CodedOutputByteBufferNano.computeSInt32Size(2, this.type_);
                    }
                    return computeSerializedSize;
                }

                public int getType() {
                    return this.type_;
                }

                public boolean hasType() {
                    if ((this.bitField0_ & 1) != 0) {
                        return true;
                    }
                    return false;
                }

                public LinePoint setType(int i10) {
                    this.type_ = i10;
                    this.bitField0_ |= 1;
                    return this;
                }

                public void writeTo(CodedOutputByteBufferNano codedOutputByteBufferNano) throws IOException {
                    Point[] pointArr = this.line;
                    if (pointArr != null && pointArr.length > 0) {
                        int i10 = 0;
                        while (true) {
                            Point[] pointArr2 = this.line;
                            if (i10 >= pointArr2.length) {
                                break;
                            }
                            Point point = pointArr2[i10];
                            if (point != null) {
                                codedOutputByteBufferNano.writeMessage(1, point);
                            }
                            i10++;
                        }
                    }
                    if ((this.bitField0_ & 1) != 0) {
                        codedOutputByteBufferNano.writeSInt32(2, this.type_);
                    }
                    super.writeTo(codedOutputByteBufferNano);
                }

                public static LinePoint parseFrom(CodedInputByteBufferNano codedInputByteBufferNano) throws IOException {
                    return new LinePoint().mergeFrom(codedInputByteBufferNano);
                }

                public LinePoint mergeFrom(CodedInputByteBufferNano codedInputByteBufferNano) throws IOException {
                    while (true) {
                        int readTag = codedInputByteBufferNano.readTag();
                        if (readTag == 0) {
                            return this;
                        }
                        if (readTag == 10) {
                            int repeatedFieldArrayLength = WireFormatNano.getRepeatedFieldArrayLength(codedInputByteBufferNano, 10);
                            Point[] pointArr = this.line;
                            int length = pointArr == null ? 0 : pointArr.length;
                            int i10 = repeatedFieldArrayLength + length;
                            Point[] pointArr2 = new Point[i10];
                            if (length != 0) {
                                System.arraycopy(pointArr, 0, pointArr2, 0, length);
                            }
                            while (length < i10 - 1) {
                                Point point = new Point();
                                pointArr2[length] = point;
                                codedInputByteBufferNano.readMessage(point);
                                codedInputByteBufferNano.readTag();
                                length++;
                            }
                            Point point2 = new Point();
                            pointArr2[length] = point2;
                            codedInputByteBufferNano.readMessage(point2);
                            this.line = pointArr2;
                        } else if (readTag == 16) {
                            this.type_ = codedInputByteBufferNano.readSInt32();
                            this.bitField0_ |= 1;
                        } else if (!WireFormatNano.parseUnknownField(codedInputByteBufferNano, readTag)) {
                            return this;
                        }
                    }
                }
            }

            /* compiled from: TbsSdkJava */
            public static final class Point extends MessageNano {

                private static volatile Point[] _emptyArray;

                private int bitField0_;

                private int number_;

                private int time_;

                public Point() {
                    clear();
                }

                public static Point[] emptyArray() {
                    if (_emptyArray == null) {
                        synchronized (InternalNano.LAZY_INIT_LOCK) {
                            try {
                                if (_emptyArray == null) {
                                    _emptyArray = new Point[0];
                                }
                            } catch (Throwable th) {
                                throw th;
                            }
                        }
                    }
                    return _emptyArray;
                }

                public static Point parseFrom(byte[] bArr) throws InvalidProtocolBufferNanoException {
                    return (Point) MessageNano.mergeFrom(new Point(), bArr);
                }

                public Point clear() {
                    this.bitField0_ = 0;
                    this.time_ = 0;
                    this.number_ = 0;
                    this.cachedSize = -1;
                    return this;
                }

                public Point clearNumber() {
                    this.number_ = 0;
                    this.bitField0_ &= -3;
                    return this;
                }

                public Point clearTime() {
                    this.time_ = 0;
                    this.bitField0_ &= -2;
                    return this;
                }

                /* access modifiers changed from: protected */
                public int computeSerializedSize() {
                    int computeSerializedSize = super.computeSerializedSize();
                    if ((this.bitField0_ & 1) != 0) {
                        computeSerializedSize += CodedOutputByteBufferNano.computeUInt32Size(1, this.time_);
                    }
                    if ((this.bitField0_ & 2) != 0) {
                        return computeSerializedSize + CodedOutputByteBufferNano.computeUInt32Size(2, this.number_);
                    }
                    return computeSerializedSize;
                }

                public int getNumber() {
                    return this.number_;
                }

                public int getTime() {
                    return this.time_;
                }

                public boolean hasNumber() {
                    if ((this.bitField0_ & 2) != 0) {
                        return true;
                    }
                    return false;
                }

                public boolean hasTime() {
                    if ((this.bitField0_ & 1) != 0) {
                        return true;
                    }
                    return false;
                }

                public Point setNumber(int i10) {
                    this.number_ = i10;
                    this.bitField0_ |= 2;
                    return this;
                }

                public Point setTime(int i10) {
                    this.time_ = i10;
                    this.bitField0_ |= 1;
                    return this;
                }

                public void writeTo(CodedOutputByteBufferNano codedOutputByteBufferNano) throws IOException {
                    if ((this.bitField0_ & 1) != 0) {
                        codedOutputByteBufferNano.writeUInt32(1, this.time_);
                    }
                    if ((this.bitField0_ & 2) != 0) {
                        codedOutputByteBufferNano.writeUInt32(2, this.number_);
                    }
                    super.writeTo(codedOutputByteBufferNano);
                }

                public static Point parseFrom(CodedInputByteBufferNano codedInputByteBufferNano) throws IOException {
                    return new Point().mergeFrom(codedInputByteBufferNano);
                }

                public Point mergeFrom(CodedInputByteBufferNano codedInputByteBufferNano) throws IOException {
                    while (true) {
                        int readTag = codedInputByteBufferNano.readTag();
                        if (readTag == 0) {
                            return this;
                        }
                        if (readTag == 8) {
                            this.time_ = codedInputByteBufferNano.readUInt32();
                            this.bitField0_ |= 1;
                        } else if (readTag == 16) {
                            this.number_ = codedInputByteBufferNano.readUInt32();
                            this.bitField0_ |= 2;
                        } else if (!WireFormatNano.parseUnknownField(codedInputByteBufferNano, readTag)) {
                            return this;
                        }
                    }
                }
            }

            public Comparison_Lines() {
                clear();
            }

            public static Comparison_Lines[] emptyArray() {
                if (_emptyArray == null) {
                    synchronized (InternalNano.LAZY_INIT_LOCK) {
                        try {
                            if (_emptyArray == null) {
                                _emptyArray = new Comparison_Lines[0];
                            }
                        } catch (Throwable th) {
                            throw th;
                        }
                    }
                }
                return _emptyArray;
            }

            public static Comparison_Lines parseFrom(byte[] bArr) throws InvalidProtocolBufferNanoException {
                return (Comparison_Lines) MessageNano.mergeFrom(new Comparison_Lines(), bArr);
            }

            public Comparison_Lines clear() {
                this.bitField0_ = 0;
                this.lineData = LinePoint.emptyArray();
                this.tradeDate_ = 0;
                this.cachedSize = -1;
                return this;
            }

            public Comparison_Lines clearTradeDate() {
                this.tradeDate_ = 0;
                this.bitField0_ &= -2;
                return this;
            }

            /* access modifiers changed from: protected */
            public int computeSerializedSize() {
                int computeSerializedSize = super.computeSerializedSize();
                LinePoint[] linePointArr = this.lineData;
                if (linePointArr != null && linePointArr.length > 0) {
                    int i10 = 0;
                    while (true) {
                        LinePoint[] linePointArr2 = this.lineData;
                        if (i10 >= linePointArr2.length) {
                            break;
                        }
                        LinePoint linePoint = linePointArr2[i10];
                        if (linePoint != null) {
                            computeSerializedSize += CodedOutputByteBufferNano.computeMessageSize(1, linePoint);
                        }
                        i10++;
                    }
                }
                if ((this.bitField0_ & 1) != 0) {
                    return computeSerializedSize + CodedOutputByteBufferNano.computeUInt32Size(2, this.tradeDate_);
                }
                return computeSerializedSize;
            }

            public int getTradeDate() {
                return this.tradeDate_;
            }

            public boolean hasTradeDate() {
                if ((this.bitField0_ & 1) != 0) {
                    return true;
                }
                return false;
            }

            public Comparison_Lines setTradeDate(int i10) {
                this.tradeDate_ = i10;
                this.bitField0_ |= 1;
                return this;
            }

            public void writeTo(CodedOutputByteBufferNano codedOutputByteBufferNano) throws IOException {
                LinePoint[] linePointArr = this.lineData;
                if (linePointArr != null && linePointArr.length > 0) {
                    int i10 = 0;
                    while (true) {
                        LinePoint[] linePointArr2 = this.lineData;
                        if (i10 >= linePointArr2.length) {
                            break;
                        }
                        LinePoint linePoint = linePointArr2[i10];
                        if (linePoint != null) {
                            codedOutputByteBufferNano.writeMessage(1, linePoint);
                        }
                        i10++;
                    }
                }
                if ((this.bitField0_ & 1) != 0) {
                    codedOutputByteBufferNano.writeUInt32(2, this.tradeDate_);
                }
                super.writeTo(codedOutputByteBufferNano);
            }

            public static Comparison_Lines parseFrom(CodedInputByteBufferNano codedInputByteBufferNano) throws IOException {
                return new Comparison_Lines().mergeFrom(codedInputByteBufferNano);
            }

            public Comparison_Lines mergeFrom(CodedInputByteBufferNano codedInputByteBufferNano) throws IOException {
                while (true) {
                    int readTag = codedInputByteBufferNano.readTag();
                    if (readTag == 0) {
                        return this;
                    }
                    if (readTag == 10) {
                        int repeatedFieldArrayLength = WireFormatNano.getRepeatedFieldArrayLength(codedInputByteBufferNano, 10);
                        LinePoint[] linePointArr = this.lineData;
                        int length = linePointArr == null ? 0 : linePointArr.length;
                        int i10 = repeatedFieldArrayLength + length;
                        LinePoint[] linePointArr2 = new LinePoint[i10];
                        if (length != 0) {
                            System.arraycopy(linePointArr, 0, linePointArr2, 0, length);
                        }
                        while (length < i10 - 1) {
                            LinePoint linePoint = new LinePoint();
                            linePointArr2[length] = linePoint;
                            codedInputByteBufferNano.readMessage(linePoint);
                            codedInputByteBufferNano.readTag();
                            length++;
                        }
                        LinePoint linePoint2 = new LinePoint();
                        linePointArr2[length] = linePoint2;
                        codedInputByteBufferNano.readMessage(linePoint2);
                        this.lineData = linePointArr2;
                    } else if (readTag == 16) {
                        this.tradeDate_ = codedInputByteBufferNano.readUInt32();
                        this.bitField0_ |= 1;
                    } else if (!WireFormatNano.parseUnknownField(codedInputByteBufferNano, readTag)) {
                        return this;
                    }
                }
            }
        }

        public LimitComparison_Response() {
            clear();
        }

        public static LimitComparison_Response[] emptyArray() {
            if (_emptyArray == null) {
                synchronized (InternalNano.LAZY_INIT_LOCK) {
                    try {
                        if (_emptyArray == null) {
                            _emptyArray = new LimitComparison_Response[0];
                        }
                    } catch (Throwable th) {
                        throw th;
                    }
                }
            }
            return _emptyArray;
        }

        public static LimitComparison_Response parseFrom(byte[] bArr) throws InvalidProtocolBufferNanoException {
            return (LimitComparison_Response) MessageNano.mergeFrom(new LimitComparison_Response(), bArr);
        }

        public LimitComparison_Response clear() {
            this.inputParam = null;
            this.outputParam = null;
            this.cachedSize = -1;
            return this;
        }

        /* access modifiers changed from: protected */
        public int computeSerializedSize() {
            int computeSerializedSize = super.computeSerializedSize();
            LimitComparisonRequest.LimitComparison_Request limitComparison_Request = this.inputParam;
            if (limitComparison_Request != null) {
                computeSerializedSize += CodedOutputByteBufferNano.computeMessageSize(1, limitComparison_Request);
            }
            Comparison_Lines comparison_Lines = this.outputParam;
            if (comparison_Lines != null) {
                return computeSerializedSize + CodedOutputByteBufferNano.computeMessageSize(2, comparison_Lines);
            }
            return computeSerializedSize;
        }

        public void writeTo(CodedOutputByteBufferNano codedOutputByteBufferNano) throws IOException {
            LimitComparisonRequest.LimitComparison_Request limitComparison_Request = this.inputParam;
            if (limitComparison_Request != null) {
                codedOutputByteBufferNano.writeMessage(1, limitComparison_Request);
            }
            Comparison_Lines comparison_Lines = this.outputParam;
            if (comparison_Lines != null) {
                codedOutputByteBufferNano.writeMessage(2, comparison_Lines);
            }
            super.writeTo(codedOutputByteBufferNano);
        }

        public static LimitComparison_Response parseFrom(CodedInputByteBufferNano codedInputByteBufferNano) throws IOException {
            return new LimitComparison_Response().mergeFrom(codedInputByteBufferNano);
        }

        public LimitComparison_Response mergeFrom(CodedInputByteBufferNano codedInputByteBufferNano) throws IOException {
            while (true) {
                int readTag = codedInputByteBufferNano.readTag();
                if (readTag == 0) {
                    return this;
                }
                if (readTag == 10) {
                    if (this.inputParam == null) {
                        this.inputParam = new LimitComparisonRequest.LimitComparison_Request();
                    }
                    codedInputByteBufferNano.readMessage(this.inputParam);
                } else if (readTag == 18) {
                    if (this.outputParam == null) {
                        this.outputParam = new Comparison_Lines();
                    }
                    codedInputByteBufferNano.readMessage(this.outputParam);
                } else if (!WireFormatNano.parseUnknownField(codedInputByteBufferNano, readTag)) {
                    return this;
                }
            }
        }
    }
}
