imToken v3.28.8 - PeerSeedProtos.java 源代码

package org.bitcoin.crawler;

import com.google.protobuf.AbstractMessageLite;
import com.google.protobuf.AbstractParser;
import com.google.protobuf.ByteString;
import com.google.protobuf.CodedInputStream;
import com.google.protobuf.CodedOutputStream;
import com.google.protobuf.Descriptors;
import com.google.protobuf.ExtensionRegistry;
import com.google.protobuf.ExtensionRegistryLite;
import com.google.protobuf.GeneratedMessage;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.Message;
import com.google.protobuf.MessageOrBuilder;
import com.google.protobuf.Parser;
import com.google.protobuf.RepeatedFieldBuilder;
import com.google.protobuf.UnknownFieldSet;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectStreamException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public final class PeerSeedProtos {
    private static Descriptors.FileDescriptor descriptor;
    private static final Descriptors.Descriptor internal_static_org_bitcoin_crawler_PeerSeedData_descriptor;
    private static GeneratedMessage.FieldAccessorTable internal_static_org_bitcoin_crawler_PeerSeedData_fieldAccessorTable;
    private static final Descriptors.Descriptor internal_static_org_bitcoin_crawler_PeerSeeds_descriptor;
    private static GeneratedMessage.FieldAccessorTable internal_static_org_bitcoin_crawler_PeerSeeds_fieldAccessorTable;
    private static final Descriptors.Descriptor internal_static_org_bitcoin_crawler_SignedPeerSeeds_descriptor;
    private static GeneratedMessage.FieldAccessorTable internal_static_org_bitcoin_crawler_SignedPeerSeeds_fieldAccessorTable;

    public interface PeerSeedDataOrBuilder extends MessageOrBuilder {
        String getIpAddress();

        ByteString getIpAddressBytes();

        int getPort();

        int getServices();

        boolean hasIpAddress();

        boolean hasPort();

        boolean hasServices();
    }

    public interface PeerSeedsOrBuilder extends MessageOrBuilder {
        String getNet();

        ByteString getNetBytes();

        PeerSeedData getSeed(int i);

        int getSeedCount();

        List<PeerSeedData> getSeedList();

        PeerSeedDataOrBuilder getSeedOrBuilder(int i);

        List<? extends PeerSeedDataOrBuilder> getSeedOrBuilderList();

        long getTimestamp();

        boolean hasNet();

        boolean hasTimestamp();
    }

    public interface SignedPeerSeedsOrBuilder extends MessageOrBuilder {
        ByteString getPeerSeeds();

        ByteString getPubkey();

        ByteString getSignature();

        boolean hasPeerSeeds();

        boolean hasPubkey();

        boolean hasSignature();
    }

    public static void registerAllExtensions(ExtensionRegistry extensionRegistry) {
    }

    private PeerSeedProtos() {
    }

    public static final class PeerSeedData extends GeneratedMessage implements PeerSeedDataOrBuilder {
        public static final int IP_ADDRESS_FIELD_NUMBER = 1;
        public static Parser<PeerSeedData> PARSER = new AbstractParser<PeerSeedData>() {
            public PeerSeedData parsePartialFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
                return new PeerSeedData(codedInputStream, extensionRegistryLite);
            }
        };
        public static final int PORT_FIELD_NUMBER = 2;
        public static final int SERVICES_FIELD_NUMBER = 3;
        private static final PeerSeedData defaultInstance;
        private static final long serialVersionUID = 0;
        private int bitField0_;
        private Object ipAddress_;
        private byte memoizedIsInitialized;
        private int memoizedSerializedSize;
        private int port_;
        private int services_;
        private final UnknownFieldSet unknownFields;

        private PeerSeedData(GeneratedMessage.Builder<?> builder) {
            super(builder);
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = builder.getUnknownFields();
        }

        private PeerSeedData(boolean z) {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = UnknownFieldSet.getDefaultInstance();
        }

        public static PeerSeedData getDefaultInstance() {
            return defaultInstance;
        }

        public PeerSeedData m1440getDefaultInstanceForType() {
            return defaultInstance;
        }

        public final UnknownFieldSet getUnknownFields() {
            return this.unknownFields;
        }

        private PeerSeedData(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            initFields();
            UnknownFieldSet.Builder newBuilder = UnknownFieldSet.newBuilder();
            boolean z = false;
            while (!z) {
                try {
                    try {
                        int readTag = codedInputStream.readTag();
                        if (readTag != 0) {
                            if (readTag == 10) {
                                ByteString readBytes = codedInputStream.readBytes();
                                this.bitField0_ = 1 | this.bitField0_;
                                this.ipAddress_ = readBytes;
                            } else if (readTag == 16) {
                                this.bitField0_ |= 2;
                                this.port_ = codedInputStream.readUInt32();
                            } else if (readTag != 24) {
                                if (!parseUnknownField(codedInputStream, newBuilder, extensionRegistryLite, readTag)) {
                                }
                            } else {
                                this.bitField0_ |= 4;
                                this.services_ = codedInputStream.readUInt32();
                            }
                        }
                        z = true;
                    } catch (InvalidProtocolBufferException e) {
                        throw e.setUnfinishedMessage(this);
                    } catch (IOException e2) {
                        throw new InvalidProtocolBufferException(e2.getMessage()).setUnfinishedMessage(this);
                    }
                } finally {
                    this.unknownFields = newBuilder.build();
                    makeExtensionsImmutable();
                }
            }
        }

        public static final Descriptors.Descriptor getDescriptor() {
            return PeerSeedProtos.internal_static_org_bitcoin_crawler_PeerSeedData_descriptor;
        }

        protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
            return PeerSeedProtos.internal_static_org_bitcoin_crawler_PeerSeedData_fieldAccessorTable.ensureFieldAccessorsInitialized(PeerSeedData.class, Builder.class);
        }

        static {
            PeerSeedData peerSeedData = new PeerSeedData(true);
            defaultInstance = peerSeedData;
            peerSeedData.initFields();
        }

        public Parser<PeerSeedData> getParserForType() {
            return PARSER;
        }

        @Override
        public boolean hasIpAddress() {
            return (this.bitField0_ & 1) == 1;
        }

        @Override
        public String getIpAddress() {
            Object obj = this.ipAddress_;
            if (obj instanceof String) {
                return (String) obj;
            }
            ByteString byteString = (ByteString) obj;
            String stringUtf8 = byteString.toStringUtf8();
            if (byteString.isValidUtf8()) {
                this.ipAddress_ = stringUtf8;
            }
            return stringUtf8;
        }

        @Override
        public ByteString getIpAddressBytes() {
            Object obj = this.ipAddress_;
            if (obj instanceof String) {
                ByteString copyFromUtf8 = ByteString.copyFromUtf8((String) obj);
                this.ipAddress_ = copyFromUtf8;
                return copyFromUtf8;
            }
            return (ByteString) obj;
        }

        @Override
        public boolean hasPort() {
            return (this.bitField0_ & 2) == 2;
        }

        @Override
        public int getPort() {
            return this.port_;
        }

        @Override
        public boolean hasServices() {
            return (this.bitField0_ & 4) == 4;
        }

        @Override
        public int getServices() {
            return this.services_;
        }

        private void initFields() {
            this.ipAddress_ = "";
            this.port_ = 0;
            this.services_ = 0;
        }

        public final boolean isInitialized() {
            byte b = this.memoizedIsInitialized;
            if (b == 1) {
                return true;
            }
            if (b == 0) {
                return false;
            }
            if (!hasIpAddress()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (!hasPort()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (!hasServices()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            this.memoizedIsInitialized = (byte) 1;
            return true;
        }

        public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
            getSerializedSize();
            if ((this.bitField0_ & 1) == 1) {
                codedOutputStream.writeBytes(1, getIpAddressBytes());
            }
            if ((this.bitField0_ & 2) == 2) {
                codedOutputStream.writeUInt32(2, this.port_);
            }
            if ((this.bitField0_ & 4) == 4) {
                codedOutputStream.writeUInt32(3, this.services_);
            }
            getUnknownFields().writeTo(codedOutputStream);
        }

        public int getSerializedSize() {
            int i = this.memoizedSerializedSize;
            if (i != -1) {
                return i;
            }
            int computeBytesSize = (this.bitField0_ & 1) == 1 ? 0 + CodedOutputStream.computeBytesSize(1, getIpAddressBytes()) : 0;
            if ((this.bitField0_ & 2) == 2) {
                computeBytesSize += CodedOutputStream.computeUInt32Size(2, this.port_);
            }
            if ((this.bitField0_ & 4) == 4) {
                computeBytesSize += CodedOutputStream.computeUInt32Size(3, this.services_);
            }
            int serializedSize = computeBytesSize + getUnknownFields().getSerializedSize();
            this.memoizedSerializedSize = serializedSize;
            return serializedSize;
        }

        protected Object writeReplace() throws ObjectStreamException {
            return super.writeReplace();
        }

        public static PeerSeedData parseFrom(ByteString byteString) throws InvalidProtocolBufferException {
            return (PeerSeedData) PARSER.parseFrom(byteString);
        }

        public static PeerSeedData parseFrom(ByteString byteString, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (PeerSeedData) PARSER.parseFrom(byteString, extensionRegistryLite);
        }

        public static PeerSeedData parseFrom(byte[] bArr) throws InvalidProtocolBufferException {
            return (PeerSeedData) PARSER.parseFrom(bArr);
        }

        public static PeerSeedData parseFrom(byte[] bArr, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (PeerSeedData) PARSER.parseFrom(bArr, extensionRegistryLite);
        }

        public static PeerSeedData parseFrom(InputStream inputStream) throws IOException {
            return (PeerSeedData) PARSER.parseFrom(inputStream);
        }

        public static PeerSeedData parseFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (PeerSeedData) PARSER.parseFrom(inputStream, extensionRegistryLite);
        }

        public static PeerSeedData parseDelimitedFrom(InputStream inputStream) throws IOException {
            return (PeerSeedData) PARSER.parseDelimitedFrom(inputStream);
        }

        public static PeerSeedData parseDelimitedFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (PeerSeedData) PARSER.parseDelimitedFrom(inputStream, extensionRegistryLite);
        }

        public static PeerSeedData parseFrom(CodedInputStream codedInputStream) throws IOException {
            return (PeerSeedData) PARSER.parseFrom(codedInputStream);
        }

        public static PeerSeedData parseFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (PeerSeedData) PARSER.parseFrom(codedInputStream, extensionRegistryLite);
        }

        public static Builder newBuilder() {
            return Builder.create();
        }

        public Builder m1442newBuilderForType() {
            return newBuilder();
        }

        public static Builder newBuilder(PeerSeedData peerSeedData) {
            return newBuilder().mergeFrom(peerSeedData);
        }

        public Builder m1445toBuilder() {
            return newBuilder(this);
        }

        public Builder newBuilderForType(GeneratedMessage.BuilderParent builderParent) {
            return new Builder(builderParent);
        }

        public static final class Builder extends GeneratedMessage.Builder<Builder> implements PeerSeedDataOrBuilder {
            private int bitField0_;
            private Object ipAddress_;
            private int port_;
            private int services_;

            public static final Descriptors.Descriptor getDescriptor() {
                return PeerSeedProtos.internal_static_org_bitcoin_crawler_PeerSeedData_descriptor;
            }

            protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
                return PeerSeedProtos.internal_static_org_bitcoin_crawler_PeerSeedData_fieldAccessorTable.ensureFieldAccessorsInitialized(PeerSeedData.class, Builder.class);
            }

            private Builder() {
                this.ipAddress_ = "";
                maybeForceBuilderInitialization();
            }

            private Builder(GeneratedMessage.BuilderParent builderParent) {
                super(builderParent);
                this.ipAddress_ = "";
                maybeForceBuilderInitialization();
            }

            private void maybeForceBuilderInitialization() {
                boolean unused = PeerSeedData.alwaysUseFieldBuilders;
            }

            public static Builder create() {
                return new Builder();
            }

            public Builder m1454clear() {
                super.clear();
                this.ipAddress_ = "";
                int i = this.bitField0_ & (-2);
                this.bitField0_ = i;
                this.port_ = 0;
                int i2 = i & (-3);
                this.bitField0_ = i2;
                this.services_ = 0;
                this.bitField0_ = i2 & (-5);
                return this;
            }

            public Builder m1460clone() {
                return create().mergeFrom(m1450buildPartial());
            }

            public Descriptors.Descriptor getDescriptorForType() {
                return PeerSeedProtos.internal_static_org_bitcoin_crawler_PeerSeedData_descriptor;
            }

            public PeerSeedData m1462getDefaultInstanceForType() {
                return PeerSeedData.getDefaultInstance();
            }

            public PeerSeedData m1448build() {
                PeerSeedData m1450buildPartial = m1450buildPartial();
                if (m1450buildPartial.isInitialized()) {
                    return m1450buildPartial;
                }
                throw newUninitializedMessageException(m1450buildPartial);
            }

            public PeerSeedData m1450buildPartial() {
                PeerSeedData peerSeedData = new PeerSeedData(this);
                int i = this.bitField0_;
                int i2 = (i & 1) != 1 ? 0 : 1;
                peerSeedData.ipAddress_ = this.ipAddress_;
                if ((i & 2) == 2) {
                    i2 |= 2;
                }
                peerSeedData.port_ = this.port_;
                if ((i & 4) == 4) {
                    i2 |= 4;
                }
                peerSeedData.services_ = this.services_;
                peerSeedData.bitField0_ = i2;
                onBuilt();
                return peerSeedData;
            }

            public Builder m1466mergeFrom(Message message) {
                if (message instanceof PeerSeedData) {
                    return mergeFrom((PeerSeedData) message);
                }
                super.mergeFrom(message);
                return this;
            }

            public Builder mergeFrom(PeerSeedData peerSeedData) {
                if (peerSeedData == PeerSeedData.getDefaultInstance()) {
                    return this;
                }
                if (peerSeedData.hasIpAddress()) {
                    this.bitField0_ |= 1;
                    this.ipAddress_ = peerSeedData.ipAddress_;
                    onChanged();
                }
                if (peerSeedData.hasPort()) {
                    setPort(peerSeedData.getPort());
                }
                if (peerSeedData.hasServices()) {
                    setServices(peerSeedData.getServices());
                }
                mergeUnknownFields(peerSeedData.getUnknownFields());
                return this;
            }

            public final boolean isInitialized() {
                return hasIpAddress() && hasPort() && hasServices();
            }

            public org.bitcoin.crawler.PeerSeedProtos.PeerSeedData.Builder m1467mergeFrom(com.google.protobuf.CodedInputStream r3, com.google.protobuf.ExtensionRegistryLite r4) throws java.io.IOException {
                throw new UnsupportedOperationException("Method not decompiled: org.bitcoin.crawler.PeerSeedProtos.PeerSeedData.Builder.m1467mergeFrom(com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite):org.bitcoin.crawler.PeerSeedProtos$PeerSeedData$Builder");
            }

            @Override
            public boolean hasIpAddress() {
                return (this.bitField0_ & 1) == 1;
            }

            @Override
            public String getIpAddress() {
                Object obj = this.ipAddress_;
                if (!(obj instanceof String)) {
                    ByteString byteString = (ByteString) obj;
                    String stringUtf8 = byteString.toStringUtf8();
                    if (byteString.isValidUtf8()) {
                        this.ipAddress_ = stringUtf8;
                    }
                    return stringUtf8;
                }
                return (String) obj;
            }

            @Override
            public ByteString getIpAddressBytes() {
                Object obj = this.ipAddress_;
                if (obj instanceof String) {
                    ByteString copyFromUtf8 = ByteString.copyFromUtf8((String) obj);
                    this.ipAddress_ = copyFromUtf8;
                    return copyFromUtf8;
                }
                return (ByteString) obj;
            }

            public Builder setIpAddress(String str) {
                if (str == null) {
                    throw null;
                }
                this.bitField0_ |= 1;
                this.ipAddress_ = str;
                onChanged();
                return this;
            }

            public Builder clearIpAddress() {
                this.bitField0_ &= -2;
                this.ipAddress_ = PeerSeedData.getDefaultInstance().getIpAddress();
                onChanged();
                return this;
            }

            public Builder setIpAddressBytes(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 1;
                this.ipAddress_ = byteString;
                onChanged();
                return this;
            }

            @Override
            public boolean hasPort() {
                return (this.bitField0_ & 2) == 2;
            }

            @Override
            public int getPort() {
                return this.port_;
            }

            public Builder setPort(int i) {
                this.bitField0_ |= 2;
                this.port_ = i;
                onChanged();
                return this;
            }

            public Builder clearPort() {
                this.bitField0_ &= -3;
                this.port_ = 0;
                onChanged();
                return this;
            }

            @Override
            public boolean hasServices() {
                return (this.bitField0_ & 4) == 4;
            }

            @Override
            public int getServices() {
                return this.services_;
            }

            public Builder setServices(int i) {
                this.bitField0_ |= 4;
                this.services_ = i;
                onChanged();
                return this;
            }

            public Builder clearServices() {
                this.bitField0_ &= -5;
                this.services_ = 0;
                onChanged();
                return this;
            }
        }
    }

    public static final class PeerSeeds extends GeneratedMessage implements PeerSeedsOrBuilder {
        public static final int NET_FIELD_NUMBER = 3;
        public static Parser<PeerSeeds> PARSER = new AbstractParser<PeerSeeds>() {
            public PeerSeeds parsePartialFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
                return new PeerSeeds(codedInputStream, extensionRegistryLite);
            }
        };
        public static final int SEED_FIELD_NUMBER = 1;
        public static final int TIMESTAMP_FIELD_NUMBER = 2;
        private static final PeerSeeds defaultInstance;
        private static final long serialVersionUID = 0;
        private int bitField0_;
        private byte memoizedIsInitialized;
        private int memoizedSerializedSize;
        private Object net_;
        private List<PeerSeedData> seed_;
        private long timestamp_;
        private final UnknownFieldSet unknownFields;

        private PeerSeeds(GeneratedMessage.Builder<?> builder) {
            super(builder);
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = builder.getUnknownFields();
        }

        private PeerSeeds(boolean z) {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = UnknownFieldSet.getDefaultInstance();
        }

        public static PeerSeeds getDefaultInstance() {
            return defaultInstance;
        }

        public PeerSeeds m1470getDefaultInstanceForType() {
            return defaultInstance;
        }

        public final UnknownFieldSet getUnknownFields() {
            return this.unknownFields;
        }

        private PeerSeeds(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            initFields();
            UnknownFieldSet.Builder newBuilder = UnknownFieldSet.newBuilder();
            boolean z = false;
            boolean z2 = false;
            while (true) {
                if (z) {
                    break;
                }
                try {
                    try {
                        try {
                            int readTag = codedInputStream.readTag();
                            if (readTag != 0) {
                                if (readTag == 10) {
                                    if (!(z2 & true)) {
                                        this.seed_ = new ArrayList();
                                        z2 |= true;
                                    }
                                    this.seed_.add(codedInputStream.readMessage(PeerSeedData.PARSER, extensionRegistryLite));
                                } else if (readTag == 16) {
                                    this.bitField0_ |= 1;
                                    this.timestamp_ = codedInputStream.readUInt64();
                                } else if (readTag != 26) {
                                    if (!parseUnknownField(codedInputStream, newBuilder, extensionRegistryLite, readTag)) {
                                    }
                                } else {
                                    ByteString readBytes = codedInputStream.readBytes();
                                    this.bitField0_ |= 2;
                                    this.net_ = readBytes;
                                }
                            }
                            z = true;
                        } catch (InvalidProtocolBufferException e) {
                            throw e.setUnfinishedMessage(this);
                        }
                    } catch (IOException e2) {
                        throw new InvalidProtocolBufferException(e2.getMessage()).setUnfinishedMessage(this);
                    }
                } finally {
                    if (z2 & true) {
                        this.seed_ = Collections.unmodifiableList(this.seed_);
                    }
                    this.unknownFields = newBuilder.build();
                    makeExtensionsImmutable();
                }
            }
        }

        public static final Descriptors.Descriptor getDescriptor() {
            return PeerSeedProtos.internal_static_org_bitcoin_crawler_PeerSeeds_descriptor;
        }

        protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
            return PeerSeedProtos.internal_static_org_bitcoin_crawler_PeerSeeds_fieldAccessorTable.ensureFieldAccessorsInitialized(PeerSeeds.class, Builder.class);
        }

        static {
            PeerSeeds peerSeeds = new PeerSeeds(true);
            defaultInstance = peerSeeds;
            peerSeeds.initFields();
        }

        public Parser<PeerSeeds> getParserForType() {
            return PARSER;
        }

        @Override
        public List<PeerSeedData> getSeedList() {
            return this.seed_;
        }

        @Override
        public List<? extends PeerSeedDataOrBuilder> getSeedOrBuilderList() {
            return this.seed_;
        }

        @Override
        public int getSeedCount() {
            return this.seed_.size();
        }

        @Override
        public PeerSeedData getSeed(int i) {
            return this.seed_.get(i);
        }

        @Override
        public PeerSeedDataOrBuilder getSeedOrBuilder(int i) {
            return this.seed_.get(i);
        }

        @Override
        public boolean hasTimestamp() {
            return (this.bitField0_ & 1) == 1;
        }

        @Override
        public long getTimestamp() {
            return this.timestamp_;
        }

        @Override
        public boolean hasNet() {
            return (this.bitField0_ & 2) == 2;
        }

        @Override
        public String getNet() {
            Object obj = this.net_;
            if (obj instanceof String) {
                return (String) obj;
            }
            ByteString byteString = (ByteString) obj;
            String stringUtf8 = byteString.toStringUtf8();
            if (byteString.isValidUtf8()) {
                this.net_ = stringUtf8;
            }
            return stringUtf8;
        }

        @Override
        public ByteString getNetBytes() {
            Object obj = this.net_;
            if (obj instanceof String) {
                ByteString copyFromUtf8 = ByteString.copyFromUtf8((String) obj);
                this.net_ = copyFromUtf8;
                return copyFromUtf8;
            }
            return (ByteString) obj;
        }

        private void initFields() {
            this.seed_ = Collections.emptyList();
            this.timestamp_ = 0L;
            this.net_ = "";
        }

        public final boolean isInitialized() {
            byte b = this.memoizedIsInitialized;
            if (b == 1) {
                return true;
            }
            if (b == 0) {
                return false;
            }
            if (!hasTimestamp()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (!hasNet()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            for (int i = 0; i < getSeedCount(); i++) {
                if (!getSeed(i).isInitialized()) {
                    this.memoizedIsInitialized = (byte) 0;
                    return false;
                }
            }
            this.memoizedIsInitialized = (byte) 1;
            return true;
        }

        public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
            getSerializedSize();
            for (int i = 0; i < this.seed_.size(); i++) {
                codedOutputStream.writeMessage(1, this.seed_.get(i));
            }
            if ((this.bitField0_ & 1) == 1) {
                codedOutputStream.writeUInt64(2, this.timestamp_);
            }
            if ((this.bitField0_ & 2) == 2) {
                codedOutputStream.writeBytes(3, getNetBytes());
            }
            getUnknownFields().writeTo(codedOutputStream);
        }

        public int getSerializedSize() {
            int i = this.memoizedSerializedSize;
            if (i != -1) {
                return i;
            }
            int i2 = 0;
            for (int i3 = 0; i3 < this.seed_.size(); i3++) {
                i2 += CodedOutputStream.computeMessageSize(1, this.seed_.get(i3));
            }
            if ((this.bitField0_ & 1) == 1) {
                i2 += CodedOutputStream.computeUInt64Size(2, this.timestamp_);
            }
            if ((this.bitField0_ & 2) == 2) {
                i2 += CodedOutputStream.computeBytesSize(3, getNetBytes());
            }
            int serializedSize = i2 + getUnknownFields().getSerializedSize();
            this.memoizedSerializedSize = serializedSize;
            return serializedSize;
        }

        protected Object writeReplace() throws ObjectStreamException {
            return super.writeReplace();
        }

        public static PeerSeeds parseFrom(ByteString byteString) throws InvalidProtocolBufferException {
            return (PeerSeeds) PARSER.parseFrom(byteString);
        }

        public static PeerSeeds parseFrom(ByteString byteString, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (PeerSeeds) PARSER.parseFrom(byteString, extensionRegistryLite);
        }

        public static PeerSeeds parseFrom(byte[] bArr) throws InvalidProtocolBufferException {
            return (PeerSeeds) PARSER.parseFrom(bArr);
        }

        public static PeerSeeds parseFrom(byte[] bArr, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (PeerSeeds) PARSER.parseFrom(bArr, extensionRegistryLite);
        }

        public static PeerSeeds parseFrom(InputStream inputStream) throws IOException {
            return (PeerSeeds) PARSER.parseFrom(inputStream);
        }

        public static PeerSeeds parseFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (PeerSeeds) PARSER.parseFrom(inputStream, extensionRegistryLite);
        }

        public static PeerSeeds parseDelimitedFrom(InputStream inputStream) throws IOException {
            return (PeerSeeds) PARSER.parseDelimitedFrom(inputStream);
        }

        public static PeerSeeds parseDelimitedFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (PeerSeeds) PARSER.parseDelimitedFrom(inputStream, extensionRegistryLite);
        }

        public static PeerSeeds parseFrom(CodedInputStream codedInputStream) throws IOException {
            return (PeerSeeds) PARSER.parseFrom(codedInputStream);
        }

        public static PeerSeeds parseFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (PeerSeeds) PARSER.parseFrom(codedInputStream, extensionRegistryLite);
        }

        public static Builder newBuilder() {
            return Builder.create();
        }

        public Builder m1472newBuilderForType() {
            return newBuilder();
        }

        public static Builder newBuilder(PeerSeeds peerSeeds) {
            return newBuilder().mergeFrom(peerSeeds);
        }

        public Builder m1475toBuilder() {
            return newBuilder(this);
        }

        public Builder newBuilderForType(GeneratedMessage.BuilderParent builderParent) {
            return new Builder(builderParent);
        }

        public static final class Builder extends GeneratedMessage.Builder<Builder> implements PeerSeedsOrBuilder {
            private int bitField0_;
            private Object net_;
            private RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> seedBuilder_;
            private List<PeerSeedData> seed_;
            private long timestamp_;

            public static final Descriptors.Descriptor getDescriptor() {
                return PeerSeedProtos.internal_static_org_bitcoin_crawler_PeerSeeds_descriptor;
            }

            protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
                return PeerSeedProtos.internal_static_org_bitcoin_crawler_PeerSeeds_fieldAccessorTable.ensureFieldAccessorsInitialized(PeerSeeds.class, Builder.class);
            }

            private Builder() {
                this.seed_ = Collections.emptyList();
                this.net_ = "";
                maybeForceBuilderInitialization();
            }

            private Builder(GeneratedMessage.BuilderParent builderParent) {
                super(builderParent);
                this.seed_ = Collections.emptyList();
                this.net_ = "";
                maybeForceBuilderInitialization();
            }

            private void maybeForceBuilderInitialization() {
                if (PeerSeeds.alwaysUseFieldBuilders) {
                    getSeedFieldBuilder();
                }
            }

            public static Builder create() {
                return new Builder();
            }

            public Builder m1484clear() {
                super.clear();
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder == null) {
                    this.seed_ = Collections.emptyList();
                    this.bitField0_ &= -2;
                } else {
                    repeatedFieldBuilder.clear();
                }
                this.timestamp_ = 0L;
                int i = this.bitField0_ & (-3);
                this.bitField0_ = i;
                this.net_ = "";
                this.bitField0_ = i & (-5);
                return this;
            }

            public Builder m1490clone() {
                return create().mergeFrom(m1480buildPartial());
            }

            public Descriptors.Descriptor getDescriptorForType() {
                return PeerSeedProtos.internal_static_org_bitcoin_crawler_PeerSeeds_descriptor;
            }

            public PeerSeeds m1492getDefaultInstanceForType() {
                return PeerSeeds.getDefaultInstance();
            }

            public PeerSeeds m1478build() {
                PeerSeeds m1480buildPartial = m1480buildPartial();
                if (m1480buildPartial.isInitialized()) {
                    return m1480buildPartial;
                }
                throw newUninitializedMessageException(m1480buildPartial);
            }

            public PeerSeeds m1480buildPartial() {
                PeerSeeds peerSeeds = new PeerSeeds(this);
                int i = this.bitField0_;
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder == null) {
                    if ((i & 1) == 1) {
                        this.seed_ = Collections.unmodifiableList(this.seed_);
                        this.bitField0_ &= -2;
                    }
                    peerSeeds.seed_ = this.seed_;
                } else {
                    peerSeeds.seed_ = repeatedFieldBuilder.build();
                }
                int i2 = (i & 2) != 2 ? 0 : 1;
                peerSeeds.timestamp_ = this.timestamp_;
                if ((i & 4) == 4) {
                    i2 |= 2;
                }
                peerSeeds.net_ = this.net_;
                peerSeeds.bitField0_ = i2;
                onBuilt();
                return peerSeeds;
            }

            public Builder m1496mergeFrom(Message message) {
                if (message instanceof PeerSeeds) {
                    return mergeFrom((PeerSeeds) message);
                }
                super.mergeFrom(message);
                return this;
            }

            public Builder mergeFrom(PeerSeeds peerSeeds) {
                if (peerSeeds == PeerSeeds.getDefaultInstance()) {
                    return this;
                }
                if (this.seedBuilder_ == null) {
                    if (!peerSeeds.seed_.isEmpty()) {
                        if (this.seed_.isEmpty()) {
                            this.seed_ = peerSeeds.seed_;
                            this.bitField0_ &= -2;
                        } else {
                            ensureSeedIsMutable();
                            this.seed_.addAll(peerSeeds.seed_);
                        }
                        onChanged();
                    }
                } else if (!peerSeeds.seed_.isEmpty()) {
                    if (!this.seedBuilder_.isEmpty()) {
                        this.seedBuilder_.addAllMessages(peerSeeds.seed_);
                    } else {
                        this.seedBuilder_.dispose();
                        this.seedBuilder_ = null;
                        this.seed_ = peerSeeds.seed_;
                        this.bitField0_ &= -2;
                        this.seedBuilder_ = PeerSeeds.alwaysUseFieldBuilders ? getSeedFieldBuilder() : null;
                    }
                }
                if (peerSeeds.hasTimestamp()) {
                    setTimestamp(peerSeeds.getTimestamp());
                }
                if (peerSeeds.hasNet()) {
                    this.bitField0_ |= 4;
                    this.net_ = peerSeeds.net_;
                    onChanged();
                }
                mergeUnknownFields(peerSeeds.getUnknownFields());
                return this;
            }

            public final boolean isInitialized() {
                if (!hasTimestamp() || !hasNet()) {
                    return false;
                }
                for (int i = 0; i < getSeedCount(); i++) {
                    if (!getSeed(i).isInitialized()) {
                        return false;
                    }
                }
                return true;
            }

            public org.bitcoin.crawler.PeerSeedProtos.PeerSeeds.Builder m1497mergeFrom(com.google.protobuf.CodedInputStream r3, com.google.protobuf.ExtensionRegistryLite r4) throws java.io.IOException {
                throw new UnsupportedOperationException("Method not decompiled: org.bitcoin.crawler.PeerSeedProtos.PeerSeeds.Builder.m1497mergeFrom(com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite):org.bitcoin.crawler.PeerSeedProtos$PeerSeeds$Builder");
            }

            private void ensureSeedIsMutable() {
                if ((this.bitField0_ & 1) != 1) {
                    this.seed_ = new ArrayList(this.seed_);
                    this.bitField0_ |= 1;
                }
            }

            @Override
            public List<PeerSeedData> getSeedList() {
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder == null) {
                    return Collections.unmodifiableList(this.seed_);
                }
                return repeatedFieldBuilder.getMessageList();
            }

            @Override
            public int getSeedCount() {
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder == null) {
                    return this.seed_.size();
                }
                return repeatedFieldBuilder.getCount();
            }

            @Override
            public PeerSeedData getSeed(int i) {
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder == null) {
                    return this.seed_.get(i);
                }
                return (PeerSeedData) repeatedFieldBuilder.getMessage(i);
            }

            public Builder setSeed(int i, PeerSeedData peerSeedData) {
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder != null) {
                    repeatedFieldBuilder.setMessage(i, peerSeedData);
                } else {
                    if (peerSeedData == null) {
                        throw null;
                    }
                    ensureSeedIsMutable();
                    this.seed_.set(i, peerSeedData);
                    onChanged();
                }
                return this;
            }

            public Builder setSeed(int i, PeerSeedData.Builder builder) {
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder == null) {
                    ensureSeedIsMutable();
                    this.seed_.set(i, builder.m1448build());
                    onChanged();
                } else {
                    repeatedFieldBuilder.setMessage(i, builder.m1448build());
                }
                return this;
            }

            public Builder addSeed(PeerSeedData peerSeedData) {
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder != null) {
                    repeatedFieldBuilder.addMessage(peerSeedData);
                } else {
                    if (peerSeedData == null) {
                        throw null;
                    }
                    ensureSeedIsMutable();
                    this.seed_.add(peerSeedData);
                    onChanged();
                }
                return this;
            }

            public Builder addSeed(int i, PeerSeedData peerSeedData) {
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder != null) {
                    repeatedFieldBuilder.addMessage(i, peerSeedData);
                } else {
                    if (peerSeedData == null) {
                        throw null;
                    }
                    ensureSeedIsMutable();
                    this.seed_.add(i, peerSeedData);
                    onChanged();
                }
                return this;
            }

            public Builder addSeed(PeerSeedData.Builder builder) {
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder == null) {
                    ensureSeedIsMutable();
                    this.seed_.add(builder.m1448build());
                    onChanged();
                } else {
                    repeatedFieldBuilder.addMessage(builder.m1448build());
                }
                return this;
            }

            public Builder addSeed(int i, PeerSeedData.Builder builder) {
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder == null) {
                    ensureSeedIsMutable();
                    this.seed_.add(i, builder.m1448build());
                    onChanged();
                } else {
                    repeatedFieldBuilder.addMessage(i, builder.m1448build());
                }
                return this;
            }

            public Builder addAllSeed(Iterable<? extends PeerSeedData> iterable) {
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder == null) {
                    ensureSeedIsMutable();
                    AbstractMessageLite.Builder.addAll(iterable, this.seed_);
                    onChanged();
                } else {
                    repeatedFieldBuilder.addAllMessages(iterable);
                }
                return this;
            }

            public Builder clearSeed() {
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder == null) {
                    this.seed_ = Collections.emptyList();
                    this.bitField0_ &= -2;
                    onChanged();
                } else {
                    repeatedFieldBuilder.clear();
                }
                return this;
            }

            public Builder removeSeed(int i) {
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder == null) {
                    ensureSeedIsMutable();
                    this.seed_.remove(i);
                    onChanged();
                } else {
                    repeatedFieldBuilder.remove(i);
                }
                return this;
            }

            public PeerSeedData.Builder getSeedBuilder(int i) {
                return (PeerSeedData.Builder) getSeedFieldBuilder().getBuilder(i);
            }

            @Override
            public PeerSeedDataOrBuilder getSeedOrBuilder(int i) {
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder == null) {
                    return this.seed_.get(i);
                }
                return (PeerSeedDataOrBuilder) repeatedFieldBuilder.getMessageOrBuilder(i);
            }

            @Override
            public List<? extends PeerSeedDataOrBuilder> getSeedOrBuilderList() {
                RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> repeatedFieldBuilder = this.seedBuilder_;
                if (repeatedFieldBuilder != null) {
                    return repeatedFieldBuilder.getMessageOrBuilderList();
                }
                return Collections.unmodifiableList(this.seed_);
            }

            public PeerSeedData.Builder addSeedBuilder() {
                return (PeerSeedData.Builder) getSeedFieldBuilder().addBuilder(PeerSeedData.getDefaultInstance());
            }

            public PeerSeedData.Builder addSeedBuilder(int i) {
                return (PeerSeedData.Builder) getSeedFieldBuilder().addBuilder(i, PeerSeedData.getDefaultInstance());
            }

            public List<PeerSeedData.Builder> getSeedBuilderList() {
                return getSeedFieldBuilder().getBuilderList();
            }

            private RepeatedFieldBuilder<PeerSeedData, PeerSeedData.Builder, PeerSeedDataOrBuilder> getSeedFieldBuilder() {
                if (this.seedBuilder_ == null) {
                    this.seedBuilder_ = new RepeatedFieldBuilder<>(this.seed_, (this.bitField0_ & 1) == 1, getParentForChildren(), isClean());
                    this.seed_ = null;
                }
                return this.seedBuilder_;
            }

            @Override
            public boolean hasTimestamp() {
                return (this.bitField0_ & 2) == 2;
            }

            @Override
            public long getTimestamp() {
                return this.timestamp_;
            }

            public Builder setTimestamp(long j) {
                this.bitField0_ |= 2;
                this.timestamp_ = j;
                onChanged();
                return this;
            }

            public Builder clearTimestamp() {
                this.bitField0_ &= -3;
                this.timestamp_ = 0L;
                onChanged();
                return this;
            }

            @Override
            public boolean hasNet() {
                return (this.bitField0_ & 4) == 4;
            }

            @Override
            public String getNet() {
                Object obj = this.net_;
                if (!(obj instanceof String)) {
                    ByteString byteString = (ByteString) obj;
                    String stringUtf8 = byteString.toStringUtf8();
                    if (byteString.isValidUtf8()) {
                        this.net_ = stringUtf8;
                    }
                    return stringUtf8;
                }
                return (String) obj;
            }

            @Override
            public ByteString getNetBytes() {
                Object obj = this.net_;
                if (obj instanceof String) {
                    ByteString copyFromUtf8 = ByteString.copyFromUtf8((String) obj);
                    this.net_ = copyFromUtf8;
                    return copyFromUtf8;
                }
                return (ByteString) obj;
            }

            public Builder setNet(String str) {
                if (str == null) {
                    throw null;
                }
                this.bitField0_ |= 4;
                this.net_ = str;
                onChanged();
                return this;
            }

            public Builder clearNet() {
                this.bitField0_ &= -5;
                this.net_ = PeerSeeds.getDefaultInstance().getNet();
                onChanged();
                return this;
            }

            public Builder setNetBytes(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 4;
                this.net_ = byteString;
                onChanged();
                return this;
            }
        }
    }

    public static final class SignedPeerSeeds extends GeneratedMessage implements SignedPeerSeedsOrBuilder {
        public static Parser<SignedPeerSeeds> PARSER = new AbstractParser<SignedPeerSeeds>() {
            public SignedPeerSeeds parsePartialFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
                return new SignedPeerSeeds(codedInputStream, extensionRegistryLite);
            }
        };
        public static final int PEER_SEEDS_FIELD_NUMBER = 1;
        public static final int PUBKEY_FIELD_NUMBER = 3;
        public static final int SIGNATURE_FIELD_NUMBER = 2;
        private static final SignedPeerSeeds defaultInstance;
        private static final long serialVersionUID = 0;
        private int bitField0_;
        private byte memoizedIsInitialized;
        private int memoizedSerializedSize;
        private ByteString peerSeeds_;
        private ByteString pubkey_;
        private ByteString signature_;
        private final UnknownFieldSet unknownFields;

        private SignedPeerSeeds(GeneratedMessage.Builder<?> builder) {
            super(builder);
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = builder.getUnknownFields();
        }

        private SignedPeerSeeds(boolean z) {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = UnknownFieldSet.getDefaultInstance();
        }

        public static SignedPeerSeeds getDefaultInstance() {
            return defaultInstance;
        }

        public SignedPeerSeeds m1500getDefaultInstanceForType() {
            return defaultInstance;
        }

        public final UnknownFieldSet getUnknownFields() {
            return this.unknownFields;
        }

        private SignedPeerSeeds(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            initFields();
            UnknownFieldSet.Builder newBuilder = UnknownFieldSet.newBuilder();
            boolean z = false;
            while (!z) {
                try {
                    try {
                        int readTag = codedInputStream.readTag();
                        if (readTag != 0) {
                            if (readTag == 10) {
                                this.bitField0_ |= 1;
                                this.peerSeeds_ = codedInputStream.readBytes();
                            } else if (readTag == 18) {
                                this.bitField0_ |= 2;
                                this.signature_ = codedInputStream.readBytes();
                            } else if (readTag != 26) {
                                if (!parseUnknownField(codedInputStream, newBuilder, extensionRegistryLite, readTag)) {
                                }
                            } else {
                                this.bitField0_ |= 4;
                                this.pubkey_ = codedInputStream.readBytes();
                            }
                        }
                        z = true;
                    } catch (InvalidProtocolBufferException e) {
                        throw e.setUnfinishedMessage(this);
                    } catch (IOException e2) {
                        throw new InvalidProtocolBufferException(e2.getMessage()).setUnfinishedMessage(this);
                    }
                } finally {
                    this.unknownFields = newBuilder.build();
                    makeExtensionsImmutable();
                }
            }
        }

        public static final Descriptors.Descriptor getDescriptor() {
            return PeerSeedProtos.internal_static_org_bitcoin_crawler_SignedPeerSeeds_descriptor;
        }

        protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
            return PeerSeedProtos.internal_static_org_bitcoin_crawler_SignedPeerSeeds_fieldAccessorTable.ensureFieldAccessorsInitialized(SignedPeerSeeds.class, Builder.class);
        }

        static {
            SignedPeerSeeds signedPeerSeeds = new SignedPeerSeeds(true);
            defaultInstance = signedPeerSeeds;
            signedPeerSeeds.initFields();
        }

        public Parser<SignedPeerSeeds> getParserForType() {
            return PARSER;
        }

        @Override
        public boolean hasPeerSeeds() {
            return (this.bitField0_ & 1) == 1;
        }

        @Override
        public ByteString getPeerSeeds() {
            return this.peerSeeds_;
        }

        @Override
        public boolean hasSignature() {
            return (this.bitField0_ & 2) == 2;
        }

        @Override
        public ByteString getSignature() {
            return this.signature_;
        }

        @Override
        public boolean hasPubkey() {
            return (this.bitField0_ & 4) == 4;
        }

        @Override
        public ByteString getPubkey() {
            return this.pubkey_;
        }

        private void initFields() {
            this.peerSeeds_ = ByteString.EMPTY;
            this.signature_ = ByteString.EMPTY;
            this.pubkey_ = ByteString.EMPTY;
        }

        public final boolean isInitialized() {
            byte b = this.memoizedIsInitialized;
            if (b == 1) {
                return true;
            }
            if (b == 0) {
                return false;
            }
            if (!hasPeerSeeds()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (!hasSignature()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (!hasPubkey()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            this.memoizedIsInitialized = (byte) 1;
            return true;
        }

        public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
            getSerializedSize();
            if ((this.bitField0_ & 1) == 1) {
                codedOutputStream.writeBytes(1, this.peerSeeds_);
            }
            if ((this.bitField0_ & 2) == 2) {
                codedOutputStream.writeBytes(2, this.signature_);
            }
            if ((this.bitField0_ & 4) == 4) {
                codedOutputStream.writeBytes(3, this.pubkey_);
            }
            getUnknownFields().writeTo(codedOutputStream);
        }

        public int getSerializedSize() {
            int i = this.memoizedSerializedSize;
            if (i != -1) {
                return i;
            }
            int computeBytesSize = (this.bitField0_ & 1) == 1 ? 0 + CodedOutputStream.computeBytesSize(1, this.peerSeeds_) : 0;
            if ((this.bitField0_ & 2) == 2) {
                computeBytesSize += CodedOutputStream.computeBytesSize(2, this.signature_);
            }
            if ((this.bitField0_ & 4) == 4) {
                computeBytesSize += CodedOutputStream.computeBytesSize(3, this.pubkey_);
            }
            int serializedSize = computeBytesSize + getUnknownFields().getSerializedSize();
            this.memoizedSerializedSize = serializedSize;
            return serializedSize;
        }

        protected Object writeReplace() throws ObjectStreamException {
            return super.writeReplace();
        }

        public static SignedPeerSeeds parseFrom(ByteString byteString) throws InvalidProtocolBufferException {
            return (SignedPeerSeeds) PARSER.parseFrom(byteString);
        }

        public static SignedPeerSeeds parseFrom(ByteString byteString, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (SignedPeerSeeds) PARSER.parseFrom(byteString, extensionRegistryLite);
        }

        public static SignedPeerSeeds parseFrom(byte[] bArr) throws InvalidProtocolBufferException {
            return (SignedPeerSeeds) PARSER.parseFrom(bArr);
        }

        public static SignedPeerSeeds parseFrom(byte[] bArr, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (SignedPeerSeeds) PARSER.parseFrom(bArr, extensionRegistryLite);
        }

        public static SignedPeerSeeds parseFrom(InputStream inputStream) throws IOException {
            return (SignedPeerSeeds) PARSER.parseFrom(inputStream);
        }

        public static SignedPeerSeeds parseFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (SignedPeerSeeds) PARSER.parseFrom(inputStream, extensionRegistryLite);
        }

        public static SignedPeerSeeds parseDelimitedFrom(InputStream inputStream) throws IOException {
            return (SignedPeerSeeds) PARSER.parseDelimitedFrom(inputStream);
        }

        public static SignedPeerSeeds parseDelimitedFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (SignedPeerSeeds) PARSER.parseDelimitedFrom(inputStream, extensionRegistryLite);
        }

        public static SignedPeerSeeds parseFrom(CodedInputStream codedInputStream) throws IOException {
            return (SignedPeerSeeds) PARSER.parseFrom(codedInputStream);
        }

        public static SignedPeerSeeds parseFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (SignedPeerSeeds) PARSER.parseFrom(codedInputStream, extensionRegistryLite);
        }

        public static Builder newBuilder() {
            return Builder.create();
        }

        public Builder m1502newBuilderForType() {
            return newBuilder();
        }

        public static Builder newBuilder(SignedPeerSeeds signedPeerSeeds) {
            return newBuilder().mergeFrom(signedPeerSeeds);
        }

        public Builder m1505toBuilder() {
            return newBuilder(this);
        }

        public Builder newBuilderForType(GeneratedMessage.BuilderParent builderParent) {
            return new Builder(builderParent);
        }

        public static final class Builder extends GeneratedMessage.Builder<Builder> implements SignedPeerSeedsOrBuilder {
            private int bitField0_;
            private ByteString peerSeeds_;
            private ByteString pubkey_;
            private ByteString signature_;

            public static final Descriptors.Descriptor getDescriptor() {
                return PeerSeedProtos.internal_static_org_bitcoin_crawler_SignedPeerSeeds_descriptor;
            }

            protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
                return PeerSeedProtos.internal_static_org_bitcoin_crawler_SignedPeerSeeds_fieldAccessorTable.ensureFieldAccessorsInitialized(SignedPeerSeeds.class, Builder.class);
            }

            private Builder() {
                this.peerSeeds_ = ByteString.EMPTY;
                this.signature_ = ByteString.EMPTY;
                this.pubkey_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private Builder(GeneratedMessage.BuilderParent builderParent) {
                super(builderParent);
                this.peerSeeds_ = ByteString.EMPTY;
                this.signature_ = ByteString.EMPTY;
                this.pubkey_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private void maybeForceBuilderInitialization() {
                boolean unused = SignedPeerSeeds.alwaysUseFieldBuilders;
            }

            public static Builder create() {
                return new Builder();
            }

            public Builder m1514clear() {
                super.clear();
                this.peerSeeds_ = ByteString.EMPTY;
                this.bitField0_ &= -2;
                this.signature_ = ByteString.EMPTY;
                this.bitField0_ &= -3;
                this.pubkey_ = ByteString.EMPTY;
                this.bitField0_ &= -5;
                return this;
            }

            public Builder m1520clone() {
                return create().mergeFrom(m1510buildPartial());
            }

            public Descriptors.Descriptor getDescriptorForType() {
                return PeerSeedProtos.internal_static_org_bitcoin_crawler_SignedPeerSeeds_descriptor;
            }

            public SignedPeerSeeds m1522getDefaultInstanceForType() {
                return SignedPeerSeeds.getDefaultInstance();
            }

            public SignedPeerSeeds m1508build() {
                SignedPeerSeeds m1510buildPartial = m1510buildPartial();
                if (m1510buildPartial.isInitialized()) {
                    return m1510buildPartial;
                }
                throw newUninitializedMessageException(m1510buildPartial);
            }

            public SignedPeerSeeds m1510buildPartial() {
                SignedPeerSeeds signedPeerSeeds = new SignedPeerSeeds(this);
                int i = this.bitField0_;
                int i2 = (i & 1) != 1 ? 0 : 1;
                signedPeerSeeds.peerSeeds_ = this.peerSeeds_;
                if ((i & 2) == 2) {
                    i2 |= 2;
                }
                signedPeerSeeds.signature_ = this.signature_;
                if ((i & 4) == 4) {
                    i2 |= 4;
                }
                signedPeerSeeds.pubkey_ = this.pubkey_;
                signedPeerSeeds.bitField0_ = i2;
                onBuilt();
                return signedPeerSeeds;
            }

            public Builder m1526mergeFrom(Message message) {
                if (message instanceof SignedPeerSeeds) {
                    return mergeFrom((SignedPeerSeeds) message);
                }
                super.mergeFrom(message);
                return this;
            }

            public Builder mergeFrom(SignedPeerSeeds signedPeerSeeds) {
                if (signedPeerSeeds == SignedPeerSeeds.getDefaultInstance()) {
                    return this;
                }
                if (signedPeerSeeds.hasPeerSeeds()) {
                    setPeerSeeds(signedPeerSeeds.getPeerSeeds());
                }
                if (signedPeerSeeds.hasSignature()) {
                    setSignature(signedPeerSeeds.getSignature());
                }
                if (signedPeerSeeds.hasPubkey()) {
                    setPubkey(signedPeerSeeds.getPubkey());
                }
                mergeUnknownFields(signedPeerSeeds.getUnknownFields());
                return this;
            }

            public final boolean isInitialized() {
                return hasPeerSeeds() && hasSignature() && hasPubkey();
            }

            public org.bitcoin.crawler.PeerSeedProtos.SignedPeerSeeds.Builder m1527mergeFrom(com.google.protobuf.CodedInputStream r3, com.google.protobuf.ExtensionRegistryLite r4) throws java.io.IOException {
                throw new UnsupportedOperationException("Method not decompiled: org.bitcoin.crawler.PeerSeedProtos.SignedPeerSeeds.Builder.m1527mergeFrom(com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite):org.bitcoin.crawler.PeerSeedProtos$SignedPeerSeeds$Builder");
            }

            @Override
            public boolean hasPeerSeeds() {
                return (this.bitField0_ & 1) == 1;
            }

            @Override
            public ByteString getPeerSeeds() {
                return this.peerSeeds_;
            }

            public Builder setPeerSeeds(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 1;
                this.peerSeeds_ = byteString;
                onChanged();
                return this;
            }

            public Builder clearPeerSeeds() {
                this.bitField0_ &= -2;
                this.peerSeeds_ = SignedPeerSeeds.getDefaultInstance().getPeerSeeds();
                onChanged();
                return this;
            }

            @Override
            public boolean hasSignature() {
                return (this.bitField0_ & 2) == 2;
            }

            @Override
            public ByteString getSignature() {
                return this.signature_;
            }

            public Builder setSignature(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 2;
                this.signature_ = byteString;
                onChanged();
                return this;
            }

            public Builder clearSignature() {
                this.bitField0_ &= -3;
                this.signature_ = SignedPeerSeeds.getDefaultInstance().getSignature();
                onChanged();
                return this;
            }

            @Override
            public boolean hasPubkey() {
                return (this.bitField0_ & 4) == 4;
            }

            @Override
            public ByteString getPubkey() {
                return this.pubkey_;
            }

            public Builder setPubkey(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 4;
                this.pubkey_ = byteString;
                onChanged();
                return this;
            }

            public Builder clearPubkey() {
                this.bitField0_ &= -5;
                this.pubkey_ = SignedPeerSeeds.getDefaultInstance().getPubkey();
                onChanged();
                return this;
            }
        }
    }

    public static Descriptors.FileDescriptor getDescriptor() {
        return descriptor;
    }

    static {
        Descriptors.FileDescriptor.internalBuildGeneratedFileFrom(new String[]{"\n\u000fpeerseeds.proto\u0012\u0013org.bitcoin.crawler\"B\n\fPeerSeedData\u0012\u0012\n\nip_address\u0018\u0001 \u0002(\t\u0012\f\n\u0004port\u0018\u0002 \u0002(\r\u0012\u0010\n\bservices\u0018\u0003 \u0002(\r\"\\\n\tPeerSeeds\u0012/\n\u0004seed\u0018\u0001 \u0003(\u000b2!.org.bitcoin.crawler.PeerSeedData\u0012\u0011\n\ttimestamp\u0018\u0002 \u0002(\u0004\u0012\u000b\n\u0003net\u0018\u0003 \u0002(\t\"H\n\u000fSignedPeerSeeds\u0012\u0012\n\npeer_seeds\u0018\u0001 \u0002(\f\u0012\u0011\n\tsignature\u0018\u0002 \u0002(\f\u0012\u000e\n\u0006pubkey\u0018\u0003 \u0002(\fB%\n\u0013org.bitcoin.crawlerB\u000ePeerSeedProtos"}, new Descriptors.FileDescriptor[0], new Descriptors.FileDescriptor.InternalDescriptorAssigner() {
            public ExtensionRegistry assignDescriptors(Descriptors.FileDescriptor fileDescriptor) {
                Descriptors.FileDescriptor unused = PeerSeedProtos.descriptor = fileDescriptor;
                return null;
            }
        });
        Descriptors.Descriptor descriptor2 = (Descriptors.Descriptor) getDescriptor().getMessageTypes().get(0);
        internal_static_org_bitcoin_crawler_PeerSeedData_descriptor = descriptor2;
        internal_static_org_bitcoin_crawler_PeerSeedData_fieldAccessorTable = new GeneratedMessage.FieldAccessorTable(descriptor2, new String[]{"IpAddress", "Port", "Services"});
        Descriptors.Descriptor descriptor3 = (Descriptors.Descriptor) getDescriptor().getMessageTypes().get(1);
        internal_static_org_bitcoin_crawler_PeerSeeds_descriptor = descriptor3;
        internal_static_org_bitcoin_crawler_PeerSeeds_fieldAccessorTable = new GeneratedMessage.FieldAccessorTable(descriptor3, new String[]{"Seed", "Timestamp", "Net"});
        Descriptors.Descriptor descriptor4 = (Descriptors.Descriptor) getDescriptor().getMessageTypes().get(2);
        internal_static_org_bitcoin_crawler_SignedPeerSeeds_descriptor = descriptor4;
        internal_static_org_bitcoin_crawler_SignedPeerSeeds_fieldAccessorTable = new GeneratedMessage.FieldAccessorTable(descriptor4, new String[]{"PeerSeeds", "Signature", "Pubkey"});
    }
}