// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: RemoteProtocol.proto

package akka.remote.protocol;

public final class RemoteProtocol {
  private RemoteProtocol() {}
  public static void registerAllExtensions(
      com.google.protobuf.ExtensionRegistry registry) {
  }
  public enum CommandType
      implements com.google.protobuf.ProtocolMessageEnum {
    CONNECT(0, 1),
    SHUTDOWN(1, 2),
    ;
    
    
    public final int getNumber() { return value; }
    
    public static CommandType valueOf(int value) {
      switch (value) {
        case 1: return CONNECT;
        case 2: return SHUTDOWN;
        default: return null;
      }
    }
    
    public static com.google.protobuf.Internal.EnumLiteMap<CommandType>
        internalGetValueMap() {
      return internalValueMap;
    }
    private static com.google.protobuf.Internal.EnumLiteMap<CommandType>
        internalValueMap =
          new com.google.protobuf.Internal.EnumLiteMap<CommandType>() {
            public CommandType findValueByNumber(int number) {
              return CommandType.valueOf(number)
    ;        }
          };
    
    public final com.google.protobuf.Descriptors.EnumValueDescriptor
        getValueDescriptor() {
      return getDescriptor().getValues().get(index);
    }
    public final com.google.protobuf.Descriptors.EnumDescriptor
        getDescriptorForType() {
      return getDescriptor();
    }
    public static final com.google.protobuf.Descriptors.EnumDescriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.getDescriptor().getEnumTypes().get(0);
    }
    
    private static final CommandType[] VALUES = {
      CONNECT, SHUTDOWN, 
    };
    public static CommandType valueOf(
        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
      if (desc.getType() != getDescriptor()) {
        throw new java.lang.IllegalArgumentException(
          "EnumValueDescriptor is not for this type.");
      }
      return VALUES[desc.getIndex()];
    }
    private final int index;
    private final int value;
    private CommandType(int index, int value) {
      this.index = index;
      this.value = value;
    }
    
    static {
      akka.remote.protocol.RemoteProtocol.getDescriptor();
    }
    
    // @@protoc_insertion_point(enum_scope:CommandType)
  }
  
  public enum ReplicationStorageType
      implements com.google.protobuf.ProtocolMessageEnum {
    TRANSIENT(0, 1),
    TRANSACTION_LOG(1, 2),
    DATA_GRID(2, 3),
    ;
    
    
    public final int getNumber() { return value; }
    
    public static ReplicationStorageType valueOf(int value) {
      switch (value) {
        case 1: return TRANSIENT;
        case 2: return TRANSACTION_LOG;
        case 3: return DATA_GRID;
        default: return null;
      }
    }
    
    public static com.google.protobuf.Internal.EnumLiteMap<ReplicationStorageType>
        internalGetValueMap() {
      return internalValueMap;
    }
    private static com.google.protobuf.Internal.EnumLiteMap<ReplicationStorageType>
        internalValueMap =
          new com.google.protobuf.Internal.EnumLiteMap<ReplicationStorageType>() {
            public ReplicationStorageType findValueByNumber(int number) {
              return ReplicationStorageType.valueOf(number)
    ;        }
          };
    
    public final com.google.protobuf.Descriptors.EnumValueDescriptor
        getValueDescriptor() {
      return getDescriptor().getValues().get(index);
    }
    public final com.google.protobuf.Descriptors.EnumDescriptor
        getDescriptorForType() {
      return getDescriptor();
    }
    public static final com.google.protobuf.Descriptors.EnumDescriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.getDescriptor().getEnumTypes().get(1);
    }
    
    private static final ReplicationStorageType[] VALUES = {
      TRANSIENT, TRANSACTION_LOG, DATA_GRID, 
    };
    public static ReplicationStorageType valueOf(
        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
      if (desc.getType() != getDescriptor()) {
        throw new java.lang.IllegalArgumentException(
          "EnumValueDescriptor is not for this type.");
      }
      return VALUES[desc.getIndex()];
    }
    private final int index;
    private final int value;
    private ReplicationStorageType(int index, int value) {
      this.index = index;
      this.value = value;
    }
    
    static {
      akka.remote.protocol.RemoteProtocol.getDescriptor();
    }
    
    // @@protoc_insertion_point(enum_scope:ReplicationStorageType)
  }
  
  public enum ReplicationStrategyType
      implements com.google.protobuf.ProtocolMessageEnum {
    WRITE_THROUGH(0, 1),
    WRITE_BEHIND(1, 2),
    ;
    
    
    public final int getNumber() { return value; }
    
    public static ReplicationStrategyType valueOf(int value) {
      switch (value) {
        case 1: return WRITE_THROUGH;
        case 2: return WRITE_BEHIND;
        default: return null;
      }
    }
    
    public static com.google.protobuf.Internal.EnumLiteMap<ReplicationStrategyType>
        internalGetValueMap() {
      return internalValueMap;
    }
    private static com.google.protobuf.Internal.EnumLiteMap<ReplicationStrategyType>
        internalValueMap =
          new com.google.protobuf.Internal.EnumLiteMap<ReplicationStrategyType>() {
            public ReplicationStrategyType findValueByNumber(int number) {
              return ReplicationStrategyType.valueOf(number)
    ;        }
          };
    
    public final com.google.protobuf.Descriptors.EnumValueDescriptor
        getValueDescriptor() {
      return getDescriptor().getValues().get(index);
    }
    public final com.google.protobuf.Descriptors.EnumDescriptor
        getDescriptorForType() {
      return getDescriptor();
    }
    public static final com.google.protobuf.Descriptors.EnumDescriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.getDescriptor().getEnumTypes().get(2);
    }
    
    private static final ReplicationStrategyType[] VALUES = {
      WRITE_THROUGH, WRITE_BEHIND, 
    };
    public static ReplicationStrategyType valueOf(
        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
      if (desc.getType() != getDescriptor()) {
        throw new java.lang.IllegalArgumentException(
          "EnumValueDescriptor is not for this type.");
      }
      return VALUES[desc.getIndex()];
    }
    private final int index;
    private final int value;
    private ReplicationStrategyType(int index, int value) {
      this.index = index;
      this.value = value;
    }
    
    static {
      akka.remote.protocol.RemoteProtocol.getDescriptor();
    }
    
    // @@protoc_insertion_point(enum_scope:ReplicationStrategyType)
  }
  
  public enum SerializationSchemeType
      implements com.google.protobuf.ProtocolMessageEnum {
    JAVA(0, 1),
    SBINARY(1, 2),
    SCALA_JSON(2, 3),
    JAVA_JSON(3, 4),
    PROTOBUF(4, 5),
    ;
    
    
    public final int getNumber() { return value; }
    
    public static SerializationSchemeType valueOf(int value) {
      switch (value) {
        case 1: return JAVA;
        case 2: return SBINARY;
        case 3: return SCALA_JSON;
        case 4: return JAVA_JSON;
        case 5: return PROTOBUF;
        default: return null;
      }
    }
    
    public static com.google.protobuf.Internal.EnumLiteMap<SerializationSchemeType>
        internalGetValueMap() {
      return internalValueMap;
    }
    private static com.google.protobuf.Internal.EnumLiteMap<SerializationSchemeType>
        internalValueMap =
          new com.google.protobuf.Internal.EnumLiteMap<SerializationSchemeType>() {
            public SerializationSchemeType findValueByNumber(int number) {
              return SerializationSchemeType.valueOf(number)
    ;        }
          };
    
    public final com.google.protobuf.Descriptors.EnumValueDescriptor
        getValueDescriptor() {
      return getDescriptor().getValues().get(index);
    }
    public final com.google.protobuf.Descriptors.EnumDescriptor
        getDescriptorForType() {
      return getDescriptor();
    }
    public static final com.google.protobuf.Descriptors.EnumDescriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.getDescriptor().getEnumTypes().get(3);
    }
    
    private static final SerializationSchemeType[] VALUES = {
      JAVA, SBINARY, SCALA_JSON, JAVA_JSON, PROTOBUF, 
    };
    public static SerializationSchemeType valueOf(
        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
      if (desc.getType() != getDescriptor()) {
        throw new java.lang.IllegalArgumentException(
          "EnumValueDescriptor is not for this type.");
      }
      return VALUES[desc.getIndex()];
    }
    private final int index;
    private final int value;
    private SerializationSchemeType(int index, int value) {
      this.index = index;
      this.value = value;
    }
    
    static {
      akka.remote.protocol.RemoteProtocol.getDescriptor();
    }
    
    // @@protoc_insertion_point(enum_scope:SerializationSchemeType)
  }
  
  public enum LifeCycleType
      implements com.google.protobuf.ProtocolMessageEnum {
    PERMANENT(0, 1),
    TEMPORARY(1, 2),
    ;
    
    
    public final int getNumber() { return value; }
    
    public static LifeCycleType valueOf(int value) {
      switch (value) {
        case 1: return PERMANENT;
        case 2: return TEMPORARY;
        default: return null;
      }
    }
    
    public static com.google.protobuf.Internal.EnumLiteMap<LifeCycleType>
        internalGetValueMap() {
      return internalValueMap;
    }
    private static com.google.protobuf.Internal.EnumLiteMap<LifeCycleType>
        internalValueMap =
          new com.google.protobuf.Internal.EnumLiteMap<LifeCycleType>() {
            public LifeCycleType findValueByNumber(int number) {
              return LifeCycleType.valueOf(number)
    ;        }
          };
    
    public final com.google.protobuf.Descriptors.EnumValueDescriptor
        getValueDescriptor() {
      return getDescriptor().getValues().get(index);
    }
    public final com.google.protobuf.Descriptors.EnumDescriptor
        getDescriptorForType() {
      return getDescriptor();
    }
    public static final com.google.protobuf.Descriptors.EnumDescriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.getDescriptor().getEnumTypes().get(4);
    }
    
    private static final LifeCycleType[] VALUES = {
      PERMANENT, TEMPORARY, 
    };
    public static LifeCycleType valueOf(
        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
      if (desc.getType() != getDescriptor()) {
        throw new java.lang.IllegalArgumentException(
          "EnumValueDescriptor is not for this type.");
      }
      return VALUES[desc.getIndex()];
    }
    private final int index;
    private final int value;
    private LifeCycleType(int index, int value) {
      this.index = index;
      this.value = value;
    }
    
    static {
      akka.remote.protocol.RemoteProtocol.getDescriptor();
    }
    
    // @@protoc_insertion_point(enum_scope:LifeCycleType)
  }
  
  public static final class AkkaRemoteProtocol extends
      com.google.protobuf.GeneratedMessage {
    // Use AkkaRemoteProtocol.newBuilder() to construct.
    private AkkaRemoteProtocol() {
      initFields();
    }
    private AkkaRemoteProtocol(boolean noInit) {}
    
    private static final AkkaRemoteProtocol defaultInstance;
    public static AkkaRemoteProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public AkkaRemoteProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.internal_static_AkkaRemoteProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.protocol.RemoteProtocol.internal_static_AkkaRemoteProtocol_fieldAccessorTable;
    }
    
    // optional .RemoteMessageProtocol message = 1;
    public static final int MESSAGE_FIELD_NUMBER = 1;
    private boolean hasMessage;
    private akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol message_;
    public boolean hasMessage() { return hasMessage; }
    public akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol getMessage() { return message_; }
    
    // optional .RemoteControlProtocol instruction = 2;
    public static final int INSTRUCTION_FIELD_NUMBER = 2;
    private boolean hasInstruction;
    private akka.remote.protocol.RemoteProtocol.RemoteControlProtocol instruction_;
    public boolean hasInstruction() { return hasInstruction; }
    public akka.remote.protocol.RemoteProtocol.RemoteControlProtocol getInstruction() { return instruction_; }
    
    private void initFields() {
      message_ = akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
      instruction_ = akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
    }
    public final boolean isInitialized() {
      if (hasMessage()) {
        if (!getMessage().isInitialized()) return false;
      }
      if (hasInstruction()) {
        if (!getInstruction().isInitialized()) return false;
      }
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasMessage()) {
        output.writeMessage(1, getMessage());
      }
      if (hasInstruction()) {
        output.writeMessage(2, getInstruction());
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasMessage()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(1, getMessage());
      }
      if (hasInstruction()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(2, getInstruction());
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol result;
      
      // Construct using akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol();
        return builder;
      }
      
      protected akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol.getDescriptor();
      }
      
      public akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol getDefaultInstanceForType() {
        return akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol) {
          return mergeFrom((akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol other) {
        if (other == akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol.getDefaultInstance()) return this;
        if (other.hasMessage()) {
          mergeMessage(other.getMessage());
        }
        if (other.hasInstruction()) {
          mergeInstruction(other.getInstruction());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.newBuilder();
              if (hasMessage()) {
                subBuilder.mergeFrom(getMessage());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setMessage(subBuilder.buildPartial());
              break;
            }
            case 18: {
              akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.newBuilder();
              if (hasInstruction()) {
                subBuilder.mergeFrom(getInstruction());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setInstruction(subBuilder.buildPartial());
              break;
            }
          }
        }
      }
      
      
      // optional .RemoteMessageProtocol message = 1;
      public boolean hasMessage() {
        return result.hasMessage();
      }
      public akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol getMessage() {
        return result.getMessage();
      }
      public Builder setMessage(akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasMessage = true;
        result.message_ = value;
        return this;
      }
      public Builder setMessage(akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
        result.hasMessage = true;
        result.message_ = builderForValue.build();
        return this;
      }
      public Builder mergeMessage(akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol value) {
        if (result.hasMessage() &&
            result.message_ != akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance()) {
          result.message_ =
            akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.newBuilder(result.message_).mergeFrom(value).buildPartial();
        } else {
          result.message_ = value;
        }
        result.hasMessage = true;
        return this;
      }
      public Builder clearMessage() {
        result.hasMessage = false;
        result.message_ = akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
        return this;
      }
      
      // optional .RemoteControlProtocol instruction = 2;
      public boolean hasInstruction() {
        return result.hasInstruction();
      }
      public akka.remote.protocol.RemoteProtocol.RemoteControlProtocol getInstruction() {
        return result.getInstruction();
      }
      public Builder setInstruction(akka.remote.protocol.RemoteProtocol.RemoteControlProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasInstruction = true;
        result.instruction_ = value;
        return this;
      }
      public Builder setInstruction(akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.Builder builderForValue) {
        result.hasInstruction = true;
        result.instruction_ = builderForValue.build();
        return this;
      }
      public Builder mergeInstruction(akka.remote.protocol.RemoteProtocol.RemoteControlProtocol value) {
        if (result.hasInstruction() &&
            result.instruction_ != akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.getDefaultInstance()) {
          result.instruction_ =
            akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.newBuilder(result.instruction_).mergeFrom(value).buildPartial();
        } else {
          result.instruction_ = value;
        }
        result.hasInstruction = true;
        return this;
      }
      public Builder clearInstruction() {
        result.hasInstruction = false;
        result.instruction_ = akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:AkkaRemoteProtocol)
    }
    
    static {
      defaultInstance = new AkkaRemoteProtocol(true);
      akka.remote.protocol.RemoteProtocol.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:AkkaRemoteProtocol)
  }
  
  public static final class RemoteMessageProtocol extends
      com.google.protobuf.GeneratedMessage {
    // Use RemoteMessageProtocol.newBuilder() to construct.
    private RemoteMessageProtocol() {
      initFields();
    }
    private RemoteMessageProtocol(boolean noInit) {}
    
    private static final RemoteMessageProtocol defaultInstance;
    public static RemoteMessageProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public RemoteMessageProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.internal_static_RemoteMessageProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.protocol.RemoteProtocol.internal_static_RemoteMessageProtocol_fieldAccessorTable;
    }
    
    // required .UuidProtocol uuid = 1;
    public static final int UUID_FIELD_NUMBER = 1;
    private boolean hasUuid;
    private akka.remote.protocol.RemoteProtocol.UuidProtocol uuid_;
    public boolean hasUuid() { return hasUuid; }
    public akka.remote.protocol.RemoteProtocol.UuidProtocol getUuid() { return uuid_; }
    
    // required .ActorInfoProtocol actorInfo = 2;
    public static final int ACTORINFO_FIELD_NUMBER = 2;
    private boolean hasActorInfo;
    private akka.remote.protocol.RemoteProtocol.ActorInfoProtocol actorInfo_;
    public boolean hasActorInfo() { return hasActorInfo; }
    public akka.remote.protocol.RemoteProtocol.ActorInfoProtocol getActorInfo() { return actorInfo_; }
    
    // required bool oneWay = 3;
    public static final int ONEWAY_FIELD_NUMBER = 3;
    private boolean hasOneWay;
    private boolean oneWay_ = false;
    public boolean hasOneWay() { return hasOneWay; }
    public boolean getOneWay() { return oneWay_; }
    
    // optional .MessageProtocol message = 4;
    public static final int MESSAGE_FIELD_NUMBER = 4;
    private boolean hasMessage;
    private akka.remote.protocol.RemoteProtocol.MessageProtocol message_;
    public boolean hasMessage() { return hasMessage; }
    public akka.remote.protocol.RemoteProtocol.MessageProtocol getMessage() { return message_; }
    
    // optional .ExceptionProtocol exception = 5;
    public static final int EXCEPTION_FIELD_NUMBER = 5;
    private boolean hasException;
    private akka.remote.protocol.RemoteProtocol.ExceptionProtocol exception_;
    public boolean hasException() { return hasException; }
    public akka.remote.protocol.RemoteProtocol.ExceptionProtocol getException() { return exception_; }
    
    // optional .UuidProtocol supervisorUuid = 6;
    public static final int SUPERVISORUUID_FIELD_NUMBER = 6;
    private boolean hasSupervisorUuid;
    private akka.remote.protocol.RemoteProtocol.UuidProtocol supervisorUuid_;
    public boolean hasSupervisorUuid() { return hasSupervisorUuid; }
    public akka.remote.protocol.RemoteProtocol.UuidProtocol getSupervisorUuid() { return supervisorUuid_; }
    
    // optional .RemoteActorRefProtocol sender = 7;
    public static final int SENDER_FIELD_NUMBER = 7;
    private boolean hasSender;
    private akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol sender_;
    public boolean hasSender() { return hasSender; }
    public akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol getSender() { return sender_; }
    
    // repeated .MetadataEntryProtocol metadata = 8;
    public static final int METADATA_FIELD_NUMBER = 8;
    private java.util.List<akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol> metadata_ =
      java.util.Collections.emptyList();
    public java.util.List<akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol> getMetadataList() {
      return metadata_;
    }
    public int getMetadataCount() { return metadata_.size(); }
    public akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol getMetadata(int index) {
      return metadata_.get(index);
    }
    
    private void initFields() {
      uuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
      actorInfo_ = akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
      message_ = akka.remote.protocol.RemoteProtocol.MessageProtocol.getDefaultInstance();
      exception_ = akka.remote.protocol.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
      supervisorUuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
      sender_ = akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
    }
    public final boolean isInitialized() {
      if (!hasUuid) return false;
      if (!hasActorInfo) return false;
      if (!hasOneWay) return false;
      if (!getUuid().isInitialized()) return false;
      if (!getActorInfo().isInitialized()) return false;
      if (hasMessage()) {
        if (!getMessage().isInitialized()) return false;
      }
      if (hasException()) {
        if (!getException().isInitialized()) return false;
      }
      if (hasSupervisorUuid()) {
        if (!getSupervisorUuid().isInitialized()) return false;
      }
      if (hasSender()) {
        if (!getSender().isInitialized()) return false;
      }
      for (akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol element : getMetadataList()) {
        if (!element.isInitialized()) return false;
      }
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasUuid()) {
        output.writeMessage(1, getUuid());
      }
      if (hasActorInfo()) {
        output.writeMessage(2, getActorInfo());
      }
      if (hasOneWay()) {
        output.writeBool(3, getOneWay());
      }
      if (hasMessage()) {
        output.writeMessage(4, getMessage());
      }
      if (hasException()) {
        output.writeMessage(5, getException());
      }
      if (hasSupervisorUuid()) {
        output.writeMessage(6, getSupervisorUuid());
      }
      if (hasSender()) {
        output.writeMessage(7, getSender());
      }
      for (akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol element : getMetadataList()) {
        output.writeMessage(8, element);
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasUuid()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(1, getUuid());
      }
      if (hasActorInfo()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(2, getActorInfo());
      }
      if (hasOneWay()) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(3, getOneWay());
      }
      if (hasMessage()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(4, getMessage());
      }
      if (hasException()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(5, getException());
      }
      if (hasSupervisorUuid()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(6, getSupervisorUuid());
      }
      if (hasSender()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(7, getSender());
      }
      for (akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol element : getMetadataList()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(8, element);
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol result;
      
      // Construct using akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol();
        return builder;
      }
      
      protected akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.getDescriptor();
      }
      
      public akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol getDefaultInstanceForType() {
        return akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        if (result.metadata_ != java.util.Collections.EMPTY_LIST) {
          result.metadata_ =
            java.util.Collections.unmodifiableList(result.metadata_);
        }
        akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol) {
          return mergeFrom((akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol other) {
        if (other == akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance()) return this;
        if (other.hasUuid()) {
          mergeUuid(other.getUuid());
        }
        if (other.hasActorInfo()) {
          mergeActorInfo(other.getActorInfo());
        }
        if (other.hasOneWay()) {
          setOneWay(other.getOneWay());
        }
        if (other.hasMessage()) {
          mergeMessage(other.getMessage());
        }
        if (other.hasException()) {
          mergeException(other.getException());
        }
        if (other.hasSupervisorUuid()) {
          mergeSupervisorUuid(other.getSupervisorUuid());
        }
        if (other.hasSender()) {
          mergeSender(other.getSender());
        }
        if (!other.metadata_.isEmpty()) {
          if (result.metadata_.isEmpty()) {
            result.metadata_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol>();
          }
          result.metadata_.addAll(other.metadata_);
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder();
              if (hasUuid()) {
                subBuilder.mergeFrom(getUuid());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setUuid(subBuilder.buildPartial());
              break;
            }
            case 18: {
              akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.newBuilder();
              if (hasActorInfo()) {
                subBuilder.mergeFrom(getActorInfo());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setActorInfo(subBuilder.buildPartial());
              break;
            }
            case 24: {
              setOneWay(input.readBool());
              break;
            }
            case 34: {
              akka.remote.protocol.RemoteProtocol.MessageProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.MessageProtocol.newBuilder();
              if (hasMessage()) {
                subBuilder.mergeFrom(getMessage());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setMessage(subBuilder.buildPartial());
              break;
            }
            case 42: {
              akka.remote.protocol.RemoteProtocol.ExceptionProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.ExceptionProtocol.newBuilder();
              if (hasException()) {
                subBuilder.mergeFrom(getException());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setException(subBuilder.buildPartial());
              break;
            }
            case 50: {
              akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder();
              if (hasSupervisorUuid()) {
                subBuilder.mergeFrom(getSupervisorUuid());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setSupervisorUuid(subBuilder.buildPartial());
              break;
            }
            case 58: {
              akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.newBuilder();
              if (hasSender()) {
                subBuilder.mergeFrom(getSender());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setSender(subBuilder.buildPartial());
              break;
            }
            case 66: {
              akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.newBuilder();
              input.readMessage(subBuilder, extensionRegistry);
              addMetadata(subBuilder.buildPartial());
              break;
            }
          }
        }
      }
      
      
      // required .UuidProtocol uuid = 1;
      public boolean hasUuid() {
        return result.hasUuid();
      }
      public akka.remote.protocol.RemoteProtocol.UuidProtocol getUuid() {
        return result.getUuid();
      }
      public Builder setUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasUuid = true;
        result.uuid_ = value;
        return this;
      }
      public Builder setUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder builderForValue) {
        result.hasUuid = true;
        result.uuid_ = builderForValue.build();
        return this;
      }
      public Builder mergeUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
        if (result.hasUuid() &&
            result.uuid_ != akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
          result.uuid_ =
            akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder(result.uuid_).mergeFrom(value).buildPartial();
        } else {
          result.uuid_ = value;
        }
        result.hasUuid = true;
        return this;
      }
      public Builder clearUuid() {
        result.hasUuid = false;
        result.uuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
        return this;
      }
      
      // required .ActorInfoProtocol actorInfo = 2;
      public boolean hasActorInfo() {
        return result.hasActorInfo();
      }
      public akka.remote.protocol.RemoteProtocol.ActorInfoProtocol getActorInfo() {
        return result.getActorInfo();
      }
      public Builder setActorInfo(akka.remote.protocol.RemoteProtocol.ActorInfoProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasActorInfo = true;
        result.actorInfo_ = value;
        return this;
      }
      public Builder setActorInfo(akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.Builder builderForValue) {
        result.hasActorInfo = true;
        result.actorInfo_ = builderForValue.build();
        return this;
      }
      public Builder mergeActorInfo(akka.remote.protocol.RemoteProtocol.ActorInfoProtocol value) {
        if (result.hasActorInfo() &&
            result.actorInfo_ != akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.getDefaultInstance()) {
          result.actorInfo_ =
            akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.newBuilder(result.actorInfo_).mergeFrom(value).buildPartial();
        } else {
          result.actorInfo_ = value;
        }
        result.hasActorInfo = true;
        return this;
      }
      public Builder clearActorInfo() {
        result.hasActorInfo = false;
        result.actorInfo_ = akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
        return this;
      }
      
      // required bool oneWay = 3;
      public boolean hasOneWay() {
        return result.hasOneWay();
      }
      public boolean getOneWay() {
        return result.getOneWay();
      }
      public Builder setOneWay(boolean value) {
        result.hasOneWay = true;
        result.oneWay_ = value;
        return this;
      }
      public Builder clearOneWay() {
        result.hasOneWay = false;
        result.oneWay_ = false;
        return this;
      }
      
      // optional .MessageProtocol message = 4;
      public boolean hasMessage() {
        return result.hasMessage();
      }
      public akka.remote.protocol.RemoteProtocol.MessageProtocol getMessage() {
        return result.getMessage();
      }
      public Builder setMessage(akka.remote.protocol.RemoteProtocol.MessageProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasMessage = true;
        result.message_ = value;
        return this;
      }
      public Builder setMessage(akka.remote.protocol.RemoteProtocol.MessageProtocol.Builder builderForValue) {
        result.hasMessage = true;
        result.message_ = builderForValue.build();
        return this;
      }
      public Builder mergeMessage(akka.remote.protocol.RemoteProtocol.MessageProtocol value) {
        if (result.hasMessage() &&
            result.message_ != akka.remote.protocol.RemoteProtocol.MessageProtocol.getDefaultInstance()) {
          result.message_ =
            akka.remote.protocol.RemoteProtocol.MessageProtocol.newBuilder(result.message_).mergeFrom(value).buildPartial();
        } else {
          result.message_ = value;
        }
        result.hasMessage = true;
        return this;
      }
      public Builder clearMessage() {
        result.hasMessage = false;
        result.message_ = akka.remote.protocol.RemoteProtocol.MessageProtocol.getDefaultInstance();
        return this;
      }
      
      // optional .ExceptionProtocol exception = 5;
      public boolean hasException() {
        return result.hasException();
      }
      public akka.remote.protocol.RemoteProtocol.ExceptionProtocol getException() {
        return result.getException();
      }
      public Builder setException(akka.remote.protocol.RemoteProtocol.ExceptionProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasException = true;
        result.exception_ = value;
        return this;
      }
      public Builder setException(akka.remote.protocol.RemoteProtocol.ExceptionProtocol.Builder builderForValue) {
        result.hasException = true;
        result.exception_ = builderForValue.build();
        return this;
      }
      public Builder mergeException(akka.remote.protocol.RemoteProtocol.ExceptionProtocol value) {
        if (result.hasException() &&
            result.exception_ != akka.remote.protocol.RemoteProtocol.ExceptionProtocol.getDefaultInstance()) {
          result.exception_ =
            akka.remote.protocol.RemoteProtocol.ExceptionProtocol.newBuilder(result.exception_).mergeFrom(value).buildPartial();
        } else {
          result.exception_ = value;
        }
        result.hasException = true;
        return this;
      }
      public Builder clearException() {
        result.hasException = false;
        result.exception_ = akka.remote.protocol.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
        return this;
      }
      
      // optional .UuidProtocol supervisorUuid = 6;
      public boolean hasSupervisorUuid() {
        return result.hasSupervisorUuid();
      }
      public akka.remote.protocol.RemoteProtocol.UuidProtocol getSupervisorUuid() {
        return result.getSupervisorUuid();
      }
      public Builder setSupervisorUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasSupervisorUuid = true;
        result.supervisorUuid_ = value;
        return this;
      }
      public Builder setSupervisorUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder builderForValue) {
        result.hasSupervisorUuid = true;
        result.supervisorUuid_ = builderForValue.build();
        return this;
      }
      public Builder mergeSupervisorUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
        if (result.hasSupervisorUuid() &&
            result.supervisorUuid_ != akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
          result.supervisorUuid_ =
            akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder(result.supervisorUuid_).mergeFrom(value).buildPartial();
        } else {
          result.supervisorUuid_ = value;
        }
        result.hasSupervisorUuid = true;
        return this;
      }
      public Builder clearSupervisorUuid() {
        result.hasSupervisorUuid = false;
        result.supervisorUuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
        return this;
      }
      
      // optional .RemoteActorRefProtocol sender = 7;
      public boolean hasSender() {
        return result.hasSender();
      }
      public akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol getSender() {
        return result.getSender();
      }
      public Builder setSender(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasSender = true;
        result.sender_ = value;
        return this;
      }
      public Builder setSender(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.Builder builderForValue) {
        result.hasSender = true;
        result.sender_ = builderForValue.build();
        return this;
      }
      public Builder mergeSender(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol value) {
        if (result.hasSender() &&
            result.sender_ != akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance()) {
          result.sender_ =
            akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.newBuilder(result.sender_).mergeFrom(value).buildPartial();
        } else {
          result.sender_ = value;
        }
        result.hasSender = true;
        return this;
      }
      public Builder clearSender() {
        result.hasSender = false;
        result.sender_ = akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
        return this;
      }
      
      // repeated .MetadataEntryProtocol metadata = 8;
      public java.util.List<akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol> getMetadataList() {
        return java.util.Collections.unmodifiableList(result.metadata_);
      }
      public int getMetadataCount() {
        return result.getMetadataCount();
      }
      public akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol getMetadata(int index) {
        return result.getMetadata(index);
      }
      public Builder setMetadata(int index, akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.metadata_.set(index, value);
        return this;
      }
      public Builder setMetadata(int index, akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.Builder builderForValue) {
        result.metadata_.set(index, builderForValue.build());
        return this;
      }
      public Builder addMetadata(akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        if (result.metadata_.isEmpty()) {
          result.metadata_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol>();
        }
        result.metadata_.add(value);
        return this;
      }
      public Builder addMetadata(akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.Builder builderForValue) {
        if (result.metadata_.isEmpty()) {
          result.metadata_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol>();
        }
        result.metadata_.add(builderForValue.build());
        return this;
      }
      public Builder addAllMetadata(
          java.lang.Iterable<? extends akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol> values) {
        if (result.metadata_.isEmpty()) {
          result.metadata_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol>();
        }
        super.addAll(values, result.metadata_);
        return this;
      }
      public Builder clearMetadata() {
        result.metadata_ = java.util.Collections.emptyList();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:RemoteMessageProtocol)
    }
    
    static {
      defaultInstance = new RemoteMessageProtocol(true);
      akka.remote.protocol.RemoteProtocol.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:RemoteMessageProtocol)
  }
  
  public static final class RemoteControlProtocol extends
      com.google.protobuf.GeneratedMessage {
    // Use RemoteControlProtocol.newBuilder() to construct.
    private RemoteControlProtocol() {
      initFields();
    }
    private RemoteControlProtocol(boolean noInit) {}
    
    private static final RemoteControlProtocol defaultInstance;
    public static RemoteControlProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public RemoteControlProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.internal_static_RemoteControlProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.protocol.RemoteProtocol.internal_static_RemoteControlProtocol_fieldAccessorTable;
    }
    
    // optional string cookie = 1;
    public static final int COOKIE_FIELD_NUMBER = 1;
    private boolean hasCookie;
    private java.lang.String cookie_ = "";
    public boolean hasCookie() { return hasCookie; }
    public java.lang.String getCookie() { return cookie_; }
    
    // required .CommandType commandType = 2;
    public static final int COMMANDTYPE_FIELD_NUMBER = 2;
    private boolean hasCommandType;
    private akka.remote.protocol.RemoteProtocol.CommandType commandType_;
    public boolean hasCommandType() { return hasCommandType; }
    public akka.remote.protocol.RemoteProtocol.CommandType getCommandType() { return commandType_; }
    
    private void initFields() {
      commandType_ = akka.remote.protocol.RemoteProtocol.CommandType.CONNECT;
    }
    public final boolean isInitialized() {
      if (!hasCommandType) return false;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasCookie()) {
        output.writeString(1, getCookie());
      }
      if (hasCommandType()) {
        output.writeEnum(2, getCommandType().getNumber());
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasCookie()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(1, getCookie());
      }
      if (hasCommandType()) {
        size += com.google.protobuf.CodedOutputStream
          .computeEnumSize(2, getCommandType().getNumber());
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.RemoteControlProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private akka.remote.protocol.RemoteProtocol.RemoteControlProtocol result;
      
      // Construct using akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new akka.remote.protocol.RemoteProtocol.RemoteControlProtocol();
        return builder;
      }
      
      protected akka.remote.protocol.RemoteProtocol.RemoteControlProtocol internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new akka.remote.protocol.RemoteProtocol.RemoteControlProtocol();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.getDescriptor();
      }
      
      public akka.remote.protocol.RemoteProtocol.RemoteControlProtocol getDefaultInstanceForType() {
        return akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public akka.remote.protocol.RemoteProtocol.RemoteControlProtocol build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private akka.remote.protocol.RemoteProtocol.RemoteControlProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public akka.remote.protocol.RemoteProtocol.RemoteControlProtocol buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        akka.remote.protocol.RemoteProtocol.RemoteControlProtocol returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.protocol.RemoteProtocol.RemoteControlProtocol) {
          return mergeFrom((akka.remote.protocol.RemoteProtocol.RemoteControlProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.RemoteControlProtocol other) {
        if (other == akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.getDefaultInstance()) return this;
        if (other.hasCookie()) {
          setCookie(other.getCookie());
        }
        if (other.hasCommandType()) {
          setCommandType(other.getCommandType());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              setCookie(input.readString());
              break;
            }
            case 16: {
              int rawValue = input.readEnum();
              akka.remote.protocol.RemoteProtocol.CommandType value = akka.remote.protocol.RemoteProtocol.CommandType.valueOf(rawValue);
              if (value == null) {
                unknownFields.mergeVarintField(2, rawValue);
              } else {
                setCommandType(value);
              }
              break;
            }
          }
        }
      }
      
      
      // optional string cookie = 1;
      public boolean hasCookie() {
        return result.hasCookie();
      }
      public java.lang.String getCookie() {
        return result.getCookie();
      }
      public Builder setCookie(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasCookie = true;
        result.cookie_ = value;
        return this;
      }
      public Builder clearCookie() {
        result.hasCookie = false;
        result.cookie_ = getDefaultInstance().getCookie();
        return this;
      }
      
      // required .CommandType commandType = 2;
      public boolean hasCommandType() {
        return result.hasCommandType();
      }
      public akka.remote.protocol.RemoteProtocol.CommandType getCommandType() {
        return result.getCommandType();
      }
      public Builder setCommandType(akka.remote.protocol.RemoteProtocol.CommandType value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasCommandType = true;
        result.commandType_ = value;
        return this;
      }
      public Builder clearCommandType() {
        result.hasCommandType = false;
        result.commandType_ = akka.remote.protocol.RemoteProtocol.CommandType.CONNECT;
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:RemoteControlProtocol)
    }
    
    static {
      defaultInstance = new RemoteControlProtocol(true);
      akka.remote.protocol.RemoteProtocol.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:RemoteControlProtocol)
  }
  
  public static final class RemoteActorRefProtocol extends
      com.google.protobuf.GeneratedMessage {
    // Use RemoteActorRefProtocol.newBuilder() to construct.
    private RemoteActorRefProtocol() {
      initFields();
    }
    private RemoteActorRefProtocol(boolean noInit) {}
    
    private static final RemoteActorRefProtocol defaultInstance;
    public static RemoteActorRefProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public RemoteActorRefProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.internal_static_RemoteActorRefProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.protocol.RemoteProtocol.internal_static_RemoteActorRefProtocol_fieldAccessorTable;
    }
    
    // required string address = 1;
    public static final int ADDRESS_FIELD_NUMBER = 1;
    private boolean hasAddress;
    private java.lang.String address_ = "";
    public boolean hasAddress() { return hasAddress; }
    public java.lang.String getAddress() { return address_; }
    
    // required bytes inetSocketAddress = 2;
    public static final int INETSOCKETADDRESS_FIELD_NUMBER = 2;
    private boolean hasInetSocketAddress;
    private com.google.protobuf.ByteString inetSocketAddress_ = com.google.protobuf.ByteString.EMPTY;
    public boolean hasInetSocketAddress() { return hasInetSocketAddress; }
    public com.google.protobuf.ByteString getInetSocketAddress() { return inetSocketAddress_; }
    
    // optional uint64 timeout = 3;
    public static final int TIMEOUT_FIELD_NUMBER = 3;
    private boolean hasTimeout;
    private long timeout_ = 0L;
    public boolean hasTimeout() { return hasTimeout; }
    public long getTimeout() { return timeout_; }
    
    private void initFields() {
    }
    public final boolean isInitialized() {
      if (!hasAddress) return false;
      if (!hasInetSocketAddress) return false;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasAddress()) {
        output.writeString(1, getAddress());
      }
      if (hasInetSocketAddress()) {
        output.writeBytes(2, getInetSocketAddress());
      }
      if (hasTimeout()) {
        output.writeUInt64(3, getTimeout());
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasAddress()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(1, getAddress());
      }
      if (hasInetSocketAddress()) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(2, getInetSocketAddress());
      }
      if (hasTimeout()) {
        size += com.google.protobuf.CodedOutputStream
          .computeUInt64Size(3, getTimeout());
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol result;
      
      // Construct using akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol();
        return builder;
      }
      
      protected akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDescriptor();
      }
      
      public akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol getDefaultInstanceForType() {
        return akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol) {
          return mergeFrom((akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol other) {
        if (other == akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance()) return this;
        if (other.hasAddress()) {
          setAddress(other.getAddress());
        }
        if (other.hasInetSocketAddress()) {
          setInetSocketAddress(other.getInetSocketAddress());
        }
        if (other.hasTimeout()) {
          setTimeout(other.getTimeout());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              setAddress(input.readString());
              break;
            }
            case 18: {
              setInetSocketAddress(input.readBytes());
              break;
            }
            case 24: {
              setTimeout(input.readUInt64());
              break;
            }
          }
        }
      }
      
      
      // required string address = 1;
      public boolean hasAddress() {
        return result.hasAddress();
      }
      public java.lang.String getAddress() {
        return result.getAddress();
      }
      public Builder setAddress(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasAddress = true;
        result.address_ = value;
        return this;
      }
      public Builder clearAddress() {
        result.hasAddress = false;
        result.address_ = getDefaultInstance().getAddress();
        return this;
      }
      
      // required bytes inetSocketAddress = 2;
      public boolean hasInetSocketAddress() {
        return result.hasInetSocketAddress();
      }
      public com.google.protobuf.ByteString getInetSocketAddress() {
        return result.getInetSocketAddress();
      }
      public Builder setInetSocketAddress(com.google.protobuf.ByteString value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasInetSocketAddress = true;
        result.inetSocketAddress_ = value;
        return this;
      }
      public Builder clearInetSocketAddress() {
        result.hasInetSocketAddress = false;
        result.inetSocketAddress_ = getDefaultInstance().getInetSocketAddress();
        return this;
      }
      
      // optional uint64 timeout = 3;
      public boolean hasTimeout() {
        return result.hasTimeout();
      }
      public long getTimeout() {
        return result.getTimeout();
      }
      public Builder setTimeout(long value) {
        result.hasTimeout = true;
        result.timeout_ = value;
        return this;
      }
      public Builder clearTimeout() {
        result.hasTimeout = false;
        result.timeout_ = 0L;
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:RemoteActorRefProtocol)
    }
    
    static {
      defaultInstance = new RemoteActorRefProtocol(true);
      akka.remote.protocol.RemoteProtocol.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:RemoteActorRefProtocol)
  }
  
  public static final class SerializedActorRefProtocol extends
      com.google.protobuf.GeneratedMessage {
    // Use SerializedActorRefProtocol.newBuilder() to construct.
    private SerializedActorRefProtocol() {
      initFields();
    }
    private SerializedActorRefProtocol(boolean noInit) {}
    
    private static final SerializedActorRefProtocol defaultInstance;
    public static SerializedActorRefProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public SerializedActorRefProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.internal_static_SerializedActorRefProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.protocol.RemoteProtocol.internal_static_SerializedActorRefProtocol_fieldAccessorTable;
    }
    
    // required .UuidProtocol uuid = 1;
    public static final int UUID_FIELD_NUMBER = 1;
    private boolean hasUuid;
    private akka.remote.protocol.RemoteProtocol.UuidProtocol uuid_;
    public boolean hasUuid() { return hasUuid; }
    public akka.remote.protocol.RemoteProtocol.UuidProtocol getUuid() { return uuid_; }
    
    // required string address = 2;
    public static final int ADDRESS_FIELD_NUMBER = 2;
    private boolean hasAddress;
    private java.lang.String address_ = "";
    public boolean hasAddress() { return hasAddress; }
    public java.lang.String getAddress() { return address_; }
    
    // required string actorClassname = 3;
    public static final int ACTORCLASSNAME_FIELD_NUMBER = 3;
    private boolean hasActorClassname;
    private java.lang.String actorClassname_ = "";
    public boolean hasActorClassname() { return hasActorClassname; }
    public java.lang.String getActorClassname() { return actorClassname_; }
    
    // optional bytes actorInstance = 4;
    public static final int ACTORINSTANCE_FIELD_NUMBER = 4;
    private boolean hasActorInstance;
    private com.google.protobuf.ByteString actorInstance_ = com.google.protobuf.ByteString.EMPTY;
    public boolean hasActorInstance() { return hasActorInstance; }
    public com.google.protobuf.ByteString getActorInstance() { return actorInstance_; }
    
    // optional string serializerClassname = 5;
    public static final int SERIALIZERCLASSNAME_FIELD_NUMBER = 5;
    private boolean hasSerializerClassname;
    private java.lang.String serializerClassname_ = "";
    public boolean hasSerializerClassname() { return hasSerializerClassname; }
    public java.lang.String getSerializerClassname() { return serializerClassname_; }
    
    // optional uint64 timeout = 6;
    public static final int TIMEOUT_FIELD_NUMBER = 6;
    private boolean hasTimeout;
    private long timeout_ = 0L;
    public boolean hasTimeout() { return hasTimeout; }
    public long getTimeout() { return timeout_; }
    
    // optional uint64 receiveTimeout = 7;
    public static final int RECEIVETIMEOUT_FIELD_NUMBER = 7;
    private boolean hasReceiveTimeout;
    private long receiveTimeout_ = 0L;
    public boolean hasReceiveTimeout() { return hasReceiveTimeout; }
    public long getReceiveTimeout() { return receiveTimeout_; }
    
    // optional .LifeCycleProtocol lifeCycle = 8;
    public static final int LIFECYCLE_FIELD_NUMBER = 8;
    private boolean hasLifeCycle;
    private akka.remote.protocol.RemoteProtocol.LifeCycleProtocol lifeCycle_;
    public boolean hasLifeCycle() { return hasLifeCycle; }
    public akka.remote.protocol.RemoteProtocol.LifeCycleProtocol getLifeCycle() { return lifeCycle_; }
    
    // optional .RemoteActorRefProtocol supervisor = 9;
    public static final int SUPERVISOR_FIELD_NUMBER = 9;
    private boolean hasSupervisor;
    private akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol supervisor_;
    public boolean hasSupervisor() { return hasSupervisor; }
    public akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol getSupervisor() { return supervisor_; }
    
    // optional bytes hotswapStack = 10;
    public static final int HOTSWAPSTACK_FIELD_NUMBER = 10;
    private boolean hasHotswapStack;
    private com.google.protobuf.ByteString hotswapStack_ = com.google.protobuf.ByteString.EMPTY;
    public boolean hasHotswapStack() { return hasHotswapStack; }
    public com.google.protobuf.ByteString getHotswapStack() { return hotswapStack_; }
    
    // optional .ReplicationStorageType replicationStorage = 11;
    public static final int REPLICATIONSTORAGE_FIELD_NUMBER = 11;
    private boolean hasReplicationStorage;
    private akka.remote.protocol.RemoteProtocol.ReplicationStorageType replicationStorage_;
    public boolean hasReplicationStorage() { return hasReplicationStorage; }
    public akka.remote.protocol.RemoteProtocol.ReplicationStorageType getReplicationStorage() { return replicationStorage_; }
    
    // optional .ReplicationStrategyType replicationStrategy = 12;
    public static final int REPLICATIONSTRATEGY_FIELD_NUMBER = 12;
    private boolean hasReplicationStrategy;
    private akka.remote.protocol.RemoteProtocol.ReplicationStrategyType replicationStrategy_;
    public boolean hasReplicationStrategy() { return hasReplicationStrategy; }
    public akka.remote.protocol.RemoteProtocol.ReplicationStrategyType getReplicationStrategy() { return replicationStrategy_; }
    
    // repeated .RemoteMessageProtocol messages = 13;
    public static final int MESSAGES_FIELD_NUMBER = 13;
    private java.util.List<akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol> messages_ =
      java.util.Collections.emptyList();
    public java.util.List<akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol> getMessagesList() {
      return messages_;
    }
    public int getMessagesCount() { return messages_.size(); }
    public akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol getMessages(int index) {
      return messages_.get(index);
    }
    
    private void initFields() {
      uuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
      lifeCycle_ = akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
      supervisor_ = akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
      replicationStorage_ = akka.remote.protocol.RemoteProtocol.ReplicationStorageType.TRANSIENT;
      replicationStrategy_ = akka.remote.protocol.RemoteProtocol.ReplicationStrategyType.WRITE_THROUGH;
    }
    public final boolean isInitialized() {
      if (!hasUuid) return false;
      if (!hasAddress) return false;
      if (!hasActorClassname) return false;
      if (!getUuid().isInitialized()) return false;
      if (hasLifeCycle()) {
        if (!getLifeCycle().isInitialized()) return false;
      }
      if (hasSupervisor()) {
        if (!getSupervisor().isInitialized()) return false;
      }
      for (akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol element : getMessagesList()) {
        if (!element.isInitialized()) return false;
      }
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasUuid()) {
        output.writeMessage(1, getUuid());
      }
      if (hasAddress()) {
        output.writeString(2, getAddress());
      }
      if (hasActorClassname()) {
        output.writeString(3, getActorClassname());
      }
      if (hasActorInstance()) {
        output.writeBytes(4, getActorInstance());
      }
      if (hasSerializerClassname()) {
        output.writeString(5, getSerializerClassname());
      }
      if (hasTimeout()) {
        output.writeUInt64(6, getTimeout());
      }
      if (hasReceiveTimeout()) {
        output.writeUInt64(7, getReceiveTimeout());
      }
      if (hasLifeCycle()) {
        output.writeMessage(8, getLifeCycle());
      }
      if (hasSupervisor()) {
        output.writeMessage(9, getSupervisor());
      }
      if (hasHotswapStack()) {
        output.writeBytes(10, getHotswapStack());
      }
      if (hasReplicationStorage()) {
        output.writeEnum(11, getReplicationStorage().getNumber());
      }
      if (hasReplicationStrategy()) {
        output.writeEnum(12, getReplicationStrategy().getNumber());
      }
      for (akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol element : getMessagesList()) {
        output.writeMessage(13, element);
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasUuid()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(1, getUuid());
      }
      if (hasAddress()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(2, getAddress());
      }
      if (hasActorClassname()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(3, getActorClassname());
      }
      if (hasActorInstance()) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(4, getActorInstance());
      }
      if (hasSerializerClassname()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(5, getSerializerClassname());
      }
      if (hasTimeout()) {
        size += com.google.protobuf.CodedOutputStream
          .computeUInt64Size(6, getTimeout());
      }
      if (hasReceiveTimeout()) {
        size += com.google.protobuf.CodedOutputStream
          .computeUInt64Size(7, getReceiveTimeout());
      }
      if (hasLifeCycle()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(8, getLifeCycle());
      }
      if (hasSupervisor()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(9, getSupervisor());
      }
      if (hasHotswapStack()) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(10, getHotswapStack());
      }
      if (hasReplicationStorage()) {
        size += com.google.protobuf.CodedOutputStream
          .computeEnumSize(11, getReplicationStorage().getNumber());
      }
      if (hasReplicationStrategy()) {
        size += com.google.protobuf.CodedOutputStream
          .computeEnumSize(12, getReplicationStrategy().getNumber());
      }
      for (akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol element : getMessagesList()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(13, element);
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol result;
      
      // Construct using akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol();
        return builder;
      }
      
      protected akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDescriptor();
      }
      
      public akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol getDefaultInstanceForType() {
        return akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        if (result.messages_ != java.util.Collections.EMPTY_LIST) {
          result.messages_ =
            java.util.Collections.unmodifiableList(result.messages_);
        }
        akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol) {
          return mergeFrom((akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol other) {
        if (other == akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance()) return this;
        if (other.hasUuid()) {
          mergeUuid(other.getUuid());
        }
        if (other.hasAddress()) {
          setAddress(other.getAddress());
        }
        if (other.hasActorClassname()) {
          setActorClassname(other.getActorClassname());
        }
        if (other.hasActorInstance()) {
          setActorInstance(other.getActorInstance());
        }
        if (other.hasSerializerClassname()) {
          setSerializerClassname(other.getSerializerClassname());
        }
        if (other.hasTimeout()) {
          setTimeout(other.getTimeout());
        }
        if (other.hasReceiveTimeout()) {
          setReceiveTimeout(other.getReceiveTimeout());
        }
        if (other.hasLifeCycle()) {
          mergeLifeCycle(other.getLifeCycle());
        }
        if (other.hasSupervisor()) {
          mergeSupervisor(other.getSupervisor());
        }
        if (other.hasHotswapStack()) {
          setHotswapStack(other.getHotswapStack());
        }
        if (other.hasReplicationStorage()) {
          setReplicationStorage(other.getReplicationStorage());
        }
        if (other.hasReplicationStrategy()) {
          setReplicationStrategy(other.getReplicationStrategy());
        }
        if (!other.messages_.isEmpty()) {
          if (result.messages_.isEmpty()) {
            result.messages_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol>();
          }
          result.messages_.addAll(other.messages_);
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder();
              if (hasUuid()) {
                subBuilder.mergeFrom(getUuid());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setUuid(subBuilder.buildPartial());
              break;
            }
            case 18: {
              setAddress(input.readString());
              break;
            }
            case 26: {
              setActorClassname(input.readString());
              break;
            }
            case 34: {
              setActorInstance(input.readBytes());
              break;
            }
            case 42: {
              setSerializerClassname(input.readString());
              break;
            }
            case 48: {
              setTimeout(input.readUInt64());
              break;
            }
            case 56: {
              setReceiveTimeout(input.readUInt64());
              break;
            }
            case 66: {
              akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.newBuilder();
              if (hasLifeCycle()) {
                subBuilder.mergeFrom(getLifeCycle());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setLifeCycle(subBuilder.buildPartial());
              break;
            }
            case 74: {
              akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.newBuilder();
              if (hasSupervisor()) {
                subBuilder.mergeFrom(getSupervisor());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setSupervisor(subBuilder.buildPartial());
              break;
            }
            case 82: {
              setHotswapStack(input.readBytes());
              break;
            }
            case 88: {
              int rawValue = input.readEnum();
              akka.remote.protocol.RemoteProtocol.ReplicationStorageType value = akka.remote.protocol.RemoteProtocol.ReplicationStorageType.valueOf(rawValue);
              if (value == null) {
                unknownFields.mergeVarintField(11, rawValue);
              } else {
                setReplicationStorage(value);
              }
              break;
            }
            case 96: {
              int rawValue = input.readEnum();
              akka.remote.protocol.RemoteProtocol.ReplicationStrategyType value = akka.remote.protocol.RemoteProtocol.ReplicationStrategyType.valueOf(rawValue);
              if (value == null) {
                unknownFields.mergeVarintField(12, rawValue);
              } else {
                setReplicationStrategy(value);
              }
              break;
            }
            case 106: {
              akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.newBuilder();
              input.readMessage(subBuilder, extensionRegistry);
              addMessages(subBuilder.buildPartial());
              break;
            }
          }
        }
      }
      
      
      // required .UuidProtocol uuid = 1;
      public boolean hasUuid() {
        return result.hasUuid();
      }
      public akka.remote.protocol.RemoteProtocol.UuidProtocol getUuid() {
        return result.getUuid();
      }
      public Builder setUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasUuid = true;
        result.uuid_ = value;
        return this;
      }
      public Builder setUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder builderForValue) {
        result.hasUuid = true;
        result.uuid_ = builderForValue.build();
        return this;
      }
      public Builder mergeUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
        if (result.hasUuid() &&
            result.uuid_ != akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
          result.uuid_ =
            akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder(result.uuid_).mergeFrom(value).buildPartial();
        } else {
          result.uuid_ = value;
        }
        result.hasUuid = true;
        return this;
      }
      public Builder clearUuid() {
        result.hasUuid = false;
        result.uuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
        return this;
      }
      
      // required string address = 2;
      public boolean hasAddress() {
        return result.hasAddress();
      }
      public java.lang.String getAddress() {
        return result.getAddress();
      }
      public Builder setAddress(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasAddress = true;
        result.address_ = value;
        return this;
      }
      public Builder clearAddress() {
        result.hasAddress = false;
        result.address_ = getDefaultInstance().getAddress();
        return this;
      }
      
      // required string actorClassname = 3;
      public boolean hasActorClassname() {
        return result.hasActorClassname();
      }
      public java.lang.String getActorClassname() {
        return result.getActorClassname();
      }
      public Builder setActorClassname(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasActorClassname = true;
        result.actorClassname_ = value;
        return this;
      }
      public Builder clearActorClassname() {
        result.hasActorClassname = false;
        result.actorClassname_ = getDefaultInstance().getActorClassname();
        return this;
      }
      
      // optional bytes actorInstance = 4;
      public boolean hasActorInstance() {
        return result.hasActorInstance();
      }
      public com.google.protobuf.ByteString getActorInstance() {
        return result.getActorInstance();
      }
      public Builder setActorInstance(com.google.protobuf.ByteString value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasActorInstance = true;
        result.actorInstance_ = value;
        return this;
      }
      public Builder clearActorInstance() {
        result.hasActorInstance = false;
        result.actorInstance_ = getDefaultInstance().getActorInstance();
        return this;
      }
      
      // optional string serializerClassname = 5;
      public boolean hasSerializerClassname() {
        return result.hasSerializerClassname();
      }
      public java.lang.String getSerializerClassname() {
        return result.getSerializerClassname();
      }
      public Builder setSerializerClassname(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasSerializerClassname = true;
        result.serializerClassname_ = value;
        return this;
      }
      public Builder clearSerializerClassname() {
        result.hasSerializerClassname = false;
        result.serializerClassname_ = getDefaultInstance().getSerializerClassname();
        return this;
      }
      
      // optional uint64 timeout = 6;
      public boolean hasTimeout() {
        return result.hasTimeout();
      }
      public long getTimeout() {
        return result.getTimeout();
      }
      public Builder setTimeout(long value) {
        result.hasTimeout = true;
        result.timeout_ = value;
        return this;
      }
      public Builder clearTimeout() {
        result.hasTimeout = false;
        result.timeout_ = 0L;
        return this;
      }
      
      // optional uint64 receiveTimeout = 7;
      public boolean hasReceiveTimeout() {
        return result.hasReceiveTimeout();
      }
      public long getReceiveTimeout() {
        return result.getReceiveTimeout();
      }
      public Builder setReceiveTimeout(long value) {
        result.hasReceiveTimeout = true;
        result.receiveTimeout_ = value;
        return this;
      }
      public Builder clearReceiveTimeout() {
        result.hasReceiveTimeout = false;
        result.receiveTimeout_ = 0L;
        return this;
      }
      
      // optional .LifeCycleProtocol lifeCycle = 8;
      public boolean hasLifeCycle() {
        return result.hasLifeCycle();
      }
      public akka.remote.protocol.RemoteProtocol.LifeCycleProtocol getLifeCycle() {
        return result.getLifeCycle();
      }
      public Builder setLifeCycle(akka.remote.protocol.RemoteProtocol.LifeCycleProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasLifeCycle = true;
        result.lifeCycle_ = value;
        return this;
      }
      public Builder setLifeCycle(akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.Builder builderForValue) {
        result.hasLifeCycle = true;
        result.lifeCycle_ = builderForValue.build();
        return this;
      }
      public Builder mergeLifeCycle(akka.remote.protocol.RemoteProtocol.LifeCycleProtocol value) {
        if (result.hasLifeCycle() &&
            result.lifeCycle_ != akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.getDefaultInstance()) {
          result.lifeCycle_ =
            akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.newBuilder(result.lifeCycle_).mergeFrom(value).buildPartial();
        } else {
          result.lifeCycle_ = value;
        }
        result.hasLifeCycle = true;
        return this;
      }
      public Builder clearLifeCycle() {
        result.hasLifeCycle = false;
        result.lifeCycle_ = akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
        return this;
      }
      
      // optional .RemoteActorRefProtocol supervisor = 9;
      public boolean hasSupervisor() {
        return result.hasSupervisor();
      }
      public akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol getSupervisor() {
        return result.getSupervisor();
      }
      public Builder setSupervisor(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasSupervisor = true;
        result.supervisor_ = value;
        return this;
      }
      public Builder setSupervisor(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.Builder builderForValue) {
        result.hasSupervisor = true;
        result.supervisor_ = builderForValue.build();
        return this;
      }
      public Builder mergeSupervisor(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol value) {
        if (result.hasSupervisor() &&
            result.supervisor_ != akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance()) {
          result.supervisor_ =
            akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.newBuilder(result.supervisor_).mergeFrom(value).buildPartial();
        } else {
          result.supervisor_ = value;
        }
        result.hasSupervisor = true;
        return this;
      }
      public Builder clearSupervisor() {
        result.hasSupervisor = false;
        result.supervisor_ = akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
        return this;
      }
      
      // optional bytes hotswapStack = 10;
      public boolean hasHotswapStack() {
        return result.hasHotswapStack();
      }
      public com.google.protobuf.ByteString getHotswapStack() {
        return result.getHotswapStack();
      }
      public Builder setHotswapStack(com.google.protobuf.ByteString value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasHotswapStack = true;
        result.hotswapStack_ = value;
        return this;
      }
      public Builder clearHotswapStack() {
        result.hasHotswapStack = false;
        result.hotswapStack_ = getDefaultInstance().getHotswapStack();
        return this;
      }
      
      // optional .ReplicationStorageType replicationStorage = 11;
      public boolean hasReplicationStorage() {
        return result.hasReplicationStorage();
      }
      public akka.remote.protocol.RemoteProtocol.ReplicationStorageType getReplicationStorage() {
        return result.getReplicationStorage();
      }
      public Builder setReplicationStorage(akka.remote.protocol.RemoteProtocol.ReplicationStorageType value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasReplicationStorage = true;
        result.replicationStorage_ = value;
        return this;
      }
      public Builder clearReplicationStorage() {
        result.hasReplicationStorage = false;
        result.replicationStorage_ = akka.remote.protocol.RemoteProtocol.ReplicationStorageType.TRANSIENT;
        return this;
      }
      
      // optional .ReplicationStrategyType replicationStrategy = 12;
      public boolean hasReplicationStrategy() {
        return result.hasReplicationStrategy();
      }
      public akka.remote.protocol.RemoteProtocol.ReplicationStrategyType getReplicationStrategy() {
        return result.getReplicationStrategy();
      }
      public Builder setReplicationStrategy(akka.remote.protocol.RemoteProtocol.ReplicationStrategyType value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasReplicationStrategy = true;
        result.replicationStrategy_ = value;
        return this;
      }
      public Builder clearReplicationStrategy() {
        result.hasReplicationStrategy = false;
        result.replicationStrategy_ = akka.remote.protocol.RemoteProtocol.ReplicationStrategyType.WRITE_THROUGH;
        return this;
      }
      
      // repeated .RemoteMessageProtocol messages = 13;
      public java.util.List<akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol> getMessagesList() {
        return java.util.Collections.unmodifiableList(result.messages_);
      }
      public int getMessagesCount() {
        return result.getMessagesCount();
      }
      public akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol getMessages(int index) {
        return result.getMessages(index);
      }
      public Builder setMessages(int index, akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.messages_.set(index, value);
        return this;
      }
      public Builder setMessages(int index, akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
        result.messages_.set(index, builderForValue.build());
        return this;
      }
      public Builder addMessages(akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        if (result.messages_.isEmpty()) {
          result.messages_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol>();
        }
        result.messages_.add(value);
        return this;
      }
      public Builder addMessages(akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
        if (result.messages_.isEmpty()) {
          result.messages_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol>();
        }
        result.messages_.add(builderForValue.build());
        return this;
      }
      public Builder addAllMessages(
          java.lang.Iterable<? extends akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol> values) {
        if (result.messages_.isEmpty()) {
          result.messages_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol>();
        }
        super.addAll(values, result.messages_);
        return this;
      }
      public Builder clearMessages() {
        result.messages_ = java.util.Collections.emptyList();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:SerializedActorRefProtocol)
    }
    
    static {
      defaultInstance = new SerializedActorRefProtocol(true);
      akka.remote.protocol.RemoteProtocol.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:SerializedActorRefProtocol)
  }
  
  public static final class SerializedTypedActorRefProtocol extends
      com.google.protobuf.GeneratedMessage {
    // Use SerializedTypedActorRefProtocol.newBuilder() to construct.
    private SerializedTypedActorRefProtocol() {
      initFields();
    }
    private SerializedTypedActorRefProtocol(boolean noInit) {}
    
    private static final SerializedTypedActorRefProtocol defaultInstance;
    public static SerializedTypedActorRefProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public SerializedTypedActorRefProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.internal_static_SerializedTypedActorRefProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.protocol.RemoteProtocol.internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable;
    }
    
    // required .SerializedActorRefProtocol actorRef = 1;
    public static final int ACTORREF_FIELD_NUMBER = 1;
    private boolean hasActorRef;
    private akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol actorRef_;
    public boolean hasActorRef() { return hasActorRef; }
    public akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol getActorRef() { return actorRef_; }
    
    // required string interfaceName = 2;
    public static final int INTERFACENAME_FIELD_NUMBER = 2;
    private boolean hasInterfaceName;
    private java.lang.String interfaceName_ = "";
    public boolean hasInterfaceName() { return hasInterfaceName; }
    public java.lang.String getInterfaceName() { return interfaceName_; }
    
    private void initFields() {
      actorRef_ = akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
    }
    public final boolean isInitialized() {
      if (!hasActorRef) return false;
      if (!hasInterfaceName) return false;
      if (!getActorRef().isInitialized()) return false;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasActorRef()) {
        output.writeMessage(1, getActorRef());
      }
      if (hasInterfaceName()) {
        output.writeString(2, getInterfaceName());
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasActorRef()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(1, getActorRef());
      }
      if (hasInterfaceName()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(2, getInterfaceName());
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol result;
      
      // Construct using akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol();
        return builder;
      }
      
      protected akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.getDescriptor();
      }
      
      public akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol getDefaultInstanceForType() {
        return akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol) {
          return mergeFrom((akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol other) {
        if (other == akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.getDefaultInstance()) return this;
        if (other.hasActorRef()) {
          mergeActorRef(other.getActorRef());
        }
        if (other.hasInterfaceName()) {
          setInterfaceName(other.getInterfaceName());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.newBuilder();
              if (hasActorRef()) {
                subBuilder.mergeFrom(getActorRef());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setActorRef(subBuilder.buildPartial());
              break;
            }
            case 18: {
              setInterfaceName(input.readString());
              break;
            }
          }
        }
      }
      
      
      // required .SerializedActorRefProtocol actorRef = 1;
      public boolean hasActorRef() {
        return result.hasActorRef();
      }
      public akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol getActorRef() {
        return result.getActorRef();
      }
      public Builder setActorRef(akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasActorRef = true;
        result.actorRef_ = value;
        return this;
      }
      public Builder setActorRef(akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.Builder builderForValue) {
        result.hasActorRef = true;
        result.actorRef_ = builderForValue.build();
        return this;
      }
      public Builder mergeActorRef(akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol value) {
        if (result.hasActorRef() &&
            result.actorRef_ != akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance()) {
          result.actorRef_ =
            akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.newBuilder(result.actorRef_).mergeFrom(value).buildPartial();
        } else {
          result.actorRef_ = value;
        }
        result.hasActorRef = true;
        return this;
      }
      public Builder clearActorRef() {
        result.hasActorRef = false;
        result.actorRef_ = akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
        return this;
      }
      
      // required string interfaceName = 2;
      public boolean hasInterfaceName() {
        return result.hasInterfaceName();
      }
      public java.lang.String getInterfaceName() {
        return result.getInterfaceName();
      }
      public Builder setInterfaceName(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasInterfaceName = true;
        result.interfaceName_ = value;
        return this;
      }
      public Builder clearInterfaceName() {
        result.hasInterfaceName = false;
        result.interfaceName_ = getDefaultInstance().getInterfaceName();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:SerializedTypedActorRefProtocol)
    }
    
    static {
      defaultInstance = new SerializedTypedActorRefProtocol(true);
      akka.remote.protocol.RemoteProtocol.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:SerializedTypedActorRefProtocol)
  }
  
  public static final class MessageProtocol extends
      com.google.protobuf.GeneratedMessage {
    // Use MessageProtocol.newBuilder() to construct.
    private MessageProtocol() {
      initFields();
    }
    private MessageProtocol(boolean noInit) {}
    
    private static final MessageProtocol defaultInstance;
    public static MessageProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public MessageProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.internal_static_MessageProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.protocol.RemoteProtocol.internal_static_MessageProtocol_fieldAccessorTable;
    }
    
    // required bytes message = 1;
    public static final int MESSAGE_FIELD_NUMBER = 1;
    private boolean hasMessage;
    private com.google.protobuf.ByteString message_ = com.google.protobuf.ByteString.EMPTY;
    public boolean hasMessage() { return hasMessage; }
    public com.google.protobuf.ByteString getMessage() { return message_; }
    
    // optional bytes messageManifest = 2;
    public static final int MESSAGEMANIFEST_FIELD_NUMBER = 2;
    private boolean hasMessageManifest;
    private com.google.protobuf.ByteString messageManifest_ = com.google.protobuf.ByteString.EMPTY;
    public boolean hasMessageManifest() { return hasMessageManifest; }
    public com.google.protobuf.ByteString getMessageManifest() { return messageManifest_; }
    
    private void initFields() {
    }
    public final boolean isInitialized() {
      if (!hasMessage) return false;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasMessage()) {
        output.writeBytes(1, getMessage());
      }
      if (hasMessageManifest()) {
        output.writeBytes(2, getMessageManifest());
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasMessage()) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(1, getMessage());
      }
      if (hasMessageManifest()) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(2, getMessageManifest());
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.MessageProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private akka.remote.protocol.RemoteProtocol.MessageProtocol result;
      
      // Construct using akka.remote.protocol.RemoteProtocol.MessageProtocol.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new akka.remote.protocol.RemoteProtocol.MessageProtocol();
        return builder;
      }
      
      protected akka.remote.protocol.RemoteProtocol.MessageProtocol internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new akka.remote.protocol.RemoteProtocol.MessageProtocol();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.protocol.RemoteProtocol.MessageProtocol.getDescriptor();
      }
      
      public akka.remote.protocol.RemoteProtocol.MessageProtocol getDefaultInstanceForType() {
        return akka.remote.protocol.RemoteProtocol.MessageProtocol.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public akka.remote.protocol.RemoteProtocol.MessageProtocol build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private akka.remote.protocol.RemoteProtocol.MessageProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public akka.remote.protocol.RemoteProtocol.MessageProtocol buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        akka.remote.protocol.RemoteProtocol.MessageProtocol returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.protocol.RemoteProtocol.MessageProtocol) {
          return mergeFrom((akka.remote.protocol.RemoteProtocol.MessageProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.MessageProtocol other) {
        if (other == akka.remote.protocol.RemoteProtocol.MessageProtocol.getDefaultInstance()) return this;
        if (other.hasMessage()) {
          setMessage(other.getMessage());
        }
        if (other.hasMessageManifest()) {
          setMessageManifest(other.getMessageManifest());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              setMessage(input.readBytes());
              break;
            }
            case 18: {
              setMessageManifest(input.readBytes());
              break;
            }
          }
        }
      }
      
      
      // required bytes message = 1;
      public boolean hasMessage() {
        return result.hasMessage();
      }
      public com.google.protobuf.ByteString getMessage() {
        return result.getMessage();
      }
      public Builder setMessage(com.google.protobuf.ByteString value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasMessage = true;
        result.message_ = value;
        return this;
      }
      public Builder clearMessage() {
        result.hasMessage = false;
        result.message_ = getDefaultInstance().getMessage();
        return this;
      }
      
      // optional bytes messageManifest = 2;
      public boolean hasMessageManifest() {
        return result.hasMessageManifest();
      }
      public com.google.protobuf.ByteString getMessageManifest() {
        return result.getMessageManifest();
      }
      public Builder setMessageManifest(com.google.protobuf.ByteString value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasMessageManifest = true;
        result.messageManifest_ = value;
        return this;
      }
      public Builder clearMessageManifest() {
        result.hasMessageManifest = false;
        result.messageManifest_ = getDefaultInstance().getMessageManifest();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:MessageProtocol)
    }
    
    static {
      defaultInstance = new MessageProtocol(true);
      akka.remote.protocol.RemoteProtocol.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:MessageProtocol)
  }
  
  public static final class ActorInfoProtocol extends
      com.google.protobuf.GeneratedMessage {
    // Use ActorInfoProtocol.newBuilder() to construct.
    private ActorInfoProtocol() {
      initFields();
    }
    private ActorInfoProtocol(boolean noInit) {}
    
    private static final ActorInfoProtocol defaultInstance;
    public static ActorInfoProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public ActorInfoProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.internal_static_ActorInfoProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.protocol.RemoteProtocol.internal_static_ActorInfoProtocol_fieldAccessorTable;
    }
    
    // required .UuidProtocol uuid = 1;
    public static final int UUID_FIELD_NUMBER = 1;
    private boolean hasUuid;
    private akka.remote.protocol.RemoteProtocol.UuidProtocol uuid_;
    public boolean hasUuid() { return hasUuid; }
    public akka.remote.protocol.RemoteProtocol.UuidProtocol getUuid() { return uuid_; }
    
    // required uint64 timeout = 2;
    public static final int TIMEOUT_FIELD_NUMBER = 2;
    private boolean hasTimeout;
    private long timeout_ = 0L;
    public boolean hasTimeout() { return hasTimeout; }
    public long getTimeout() { return timeout_; }
    
    // optional string address = 3;
    public static final int ADDRESS_FIELD_NUMBER = 3;
    private boolean hasAddress;
    private java.lang.String address_ = "";
    public boolean hasAddress() { return hasAddress; }
    public java.lang.String getAddress() { return address_; }
    
    private void initFields() {
      uuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
    }
    public final boolean isInitialized() {
      if (!hasUuid) return false;
      if (!hasTimeout) return false;
      if (!getUuid().isInitialized()) return false;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasUuid()) {
        output.writeMessage(1, getUuid());
      }
      if (hasTimeout()) {
        output.writeUInt64(2, getTimeout());
      }
      if (hasAddress()) {
        output.writeString(3, getAddress());
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasUuid()) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(1, getUuid());
      }
      if (hasTimeout()) {
        size += com.google.protobuf.CodedOutputStream
          .computeUInt64Size(2, getTimeout());
      }
      if (hasAddress()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(3, getAddress());
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.ActorInfoProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private akka.remote.protocol.RemoteProtocol.ActorInfoProtocol result;
      
      // Construct using akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new akka.remote.protocol.RemoteProtocol.ActorInfoProtocol();
        return builder;
      }
      
      protected akka.remote.protocol.RemoteProtocol.ActorInfoProtocol internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new akka.remote.protocol.RemoteProtocol.ActorInfoProtocol();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.getDescriptor();
      }
      
      public akka.remote.protocol.RemoteProtocol.ActorInfoProtocol getDefaultInstanceForType() {
        return akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public akka.remote.protocol.RemoteProtocol.ActorInfoProtocol build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private akka.remote.protocol.RemoteProtocol.ActorInfoProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public akka.remote.protocol.RemoteProtocol.ActorInfoProtocol buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        akka.remote.protocol.RemoteProtocol.ActorInfoProtocol returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.protocol.RemoteProtocol.ActorInfoProtocol) {
          return mergeFrom((akka.remote.protocol.RemoteProtocol.ActorInfoProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.ActorInfoProtocol other) {
        if (other == akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.getDefaultInstance()) return this;
        if (other.hasUuid()) {
          mergeUuid(other.getUuid());
        }
        if (other.hasTimeout()) {
          setTimeout(other.getTimeout());
        }
        if (other.hasAddress()) {
          setAddress(other.getAddress());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder();
              if (hasUuid()) {
                subBuilder.mergeFrom(getUuid());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setUuid(subBuilder.buildPartial());
              break;
            }
            case 16: {
              setTimeout(input.readUInt64());
              break;
            }
            case 26: {
              setAddress(input.readString());
              break;
            }
          }
        }
      }
      
      
      // required .UuidProtocol uuid = 1;
      public boolean hasUuid() {
        return result.hasUuid();
      }
      public akka.remote.protocol.RemoteProtocol.UuidProtocol getUuid() {
        return result.getUuid();
      }
      public Builder setUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasUuid = true;
        result.uuid_ = value;
        return this;
      }
      public Builder setUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder builderForValue) {
        result.hasUuid = true;
        result.uuid_ = builderForValue.build();
        return this;
      }
      public Builder mergeUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
        if (result.hasUuid() &&
            result.uuid_ != akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
          result.uuid_ =
            akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder(result.uuid_).mergeFrom(value).buildPartial();
        } else {
          result.uuid_ = value;
        }
        result.hasUuid = true;
        return this;
      }
      public Builder clearUuid() {
        result.hasUuid = false;
        result.uuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
        return this;
      }
      
      // required uint64 timeout = 2;
      public boolean hasTimeout() {
        return result.hasTimeout();
      }
      public long getTimeout() {
        return result.getTimeout();
      }
      public Builder setTimeout(long value) {
        result.hasTimeout = true;
        result.timeout_ = value;
        return this;
      }
      public Builder clearTimeout() {
        result.hasTimeout = false;
        result.timeout_ = 0L;
        return this;
      }
      
      // optional string address = 3;
      public boolean hasAddress() {
        return result.hasAddress();
      }
      public java.lang.String getAddress() {
        return result.getAddress();
      }
      public Builder setAddress(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasAddress = true;
        result.address_ = value;
        return this;
      }
      public Builder clearAddress() {
        result.hasAddress = false;
        result.address_ = getDefaultInstance().getAddress();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:ActorInfoProtocol)
    }
    
    static {
      defaultInstance = new ActorInfoProtocol(true);
      akka.remote.protocol.RemoteProtocol.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:ActorInfoProtocol)
  }
  
  public static final class UuidProtocol extends
      com.google.protobuf.GeneratedMessage {
    // Use UuidProtocol.newBuilder() to construct.
    private UuidProtocol() {
      initFields();
    }
    private UuidProtocol(boolean noInit) {}
    
    private static final UuidProtocol defaultInstance;
    public static UuidProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public UuidProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.internal_static_UuidProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.protocol.RemoteProtocol.internal_static_UuidProtocol_fieldAccessorTable;
    }
    
    // required uint64 high = 1;
    public static final int HIGH_FIELD_NUMBER = 1;
    private boolean hasHigh;
    private long high_ = 0L;
    public boolean hasHigh() { return hasHigh; }
    public long getHigh() { return high_; }
    
    // required uint64 low = 2;
    public static final int LOW_FIELD_NUMBER = 2;
    private boolean hasLow;
    private long low_ = 0L;
    public boolean hasLow() { return hasLow; }
    public long getLow() { return low_; }
    
    private void initFields() {
    }
    public final boolean isInitialized() {
      if (!hasHigh) return false;
      if (!hasLow) return false;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasHigh()) {
        output.writeUInt64(1, getHigh());
      }
      if (hasLow()) {
        output.writeUInt64(2, getLow());
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasHigh()) {
        size += com.google.protobuf.CodedOutputStream
          .computeUInt64Size(1, getHigh());
      }
      if (hasLow()) {
        size += com.google.protobuf.CodedOutputStream
          .computeUInt64Size(2, getLow());
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.UuidProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private akka.remote.protocol.RemoteProtocol.UuidProtocol result;
      
      // Construct using akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new akka.remote.protocol.RemoteProtocol.UuidProtocol();
        return builder;
      }
      
      protected akka.remote.protocol.RemoteProtocol.UuidProtocol internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new akka.remote.protocol.RemoteProtocol.UuidProtocol();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.protocol.RemoteProtocol.UuidProtocol.getDescriptor();
      }
      
      public akka.remote.protocol.RemoteProtocol.UuidProtocol getDefaultInstanceForType() {
        return akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public akka.remote.protocol.RemoteProtocol.UuidProtocol build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private akka.remote.protocol.RemoteProtocol.UuidProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public akka.remote.protocol.RemoteProtocol.UuidProtocol buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        akka.remote.protocol.RemoteProtocol.UuidProtocol returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.protocol.RemoteProtocol.UuidProtocol) {
          return mergeFrom((akka.remote.protocol.RemoteProtocol.UuidProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.UuidProtocol other) {
        if (other == akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance()) return this;
        if (other.hasHigh()) {
          setHigh(other.getHigh());
        }
        if (other.hasLow()) {
          setLow(other.getLow());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 8: {
              setHigh(input.readUInt64());
              break;
            }
            case 16: {
              setLow(input.readUInt64());
              break;
            }
          }
        }
      }
      
      
      // required uint64 high = 1;
      public boolean hasHigh() {
        return result.hasHigh();
      }
      public long getHigh() {
        return result.getHigh();
      }
      public Builder setHigh(long value) {
        result.hasHigh = true;
        result.high_ = value;
        return this;
      }
      public Builder clearHigh() {
        result.hasHigh = false;
        result.high_ = 0L;
        return this;
      }
      
      // required uint64 low = 2;
      public boolean hasLow() {
        return result.hasLow();
      }
      public long getLow() {
        return result.getLow();
      }
      public Builder setLow(long value) {
        result.hasLow = true;
        result.low_ = value;
        return this;
      }
      public Builder clearLow() {
        result.hasLow = false;
        result.low_ = 0L;
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:UuidProtocol)
    }
    
    static {
      defaultInstance = new UuidProtocol(true);
      akka.remote.protocol.RemoteProtocol.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:UuidProtocol)
  }
  
  public static final class MetadataEntryProtocol extends
      com.google.protobuf.GeneratedMessage {
    // Use MetadataEntryProtocol.newBuilder() to construct.
    private MetadataEntryProtocol() {
      initFields();
    }
    private MetadataEntryProtocol(boolean noInit) {}
    
    private static final MetadataEntryProtocol defaultInstance;
    public static MetadataEntryProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public MetadataEntryProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.internal_static_MetadataEntryProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.protocol.RemoteProtocol.internal_static_MetadataEntryProtocol_fieldAccessorTable;
    }
    
    // required string key = 1;
    public static final int KEY_FIELD_NUMBER = 1;
    private boolean hasKey;
    private java.lang.String key_ = "";
    public boolean hasKey() { return hasKey; }
    public java.lang.String getKey() { return key_; }
    
    // required bytes value = 2;
    public static final int VALUE_FIELD_NUMBER = 2;
    private boolean hasValue;
    private com.google.protobuf.ByteString value_ = com.google.protobuf.ByteString.EMPTY;
    public boolean hasValue() { return hasValue; }
    public com.google.protobuf.ByteString getValue() { return value_; }
    
    private void initFields() {
    }
    public final boolean isInitialized() {
      if (!hasKey) return false;
      if (!hasValue) return false;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasKey()) {
        output.writeString(1, getKey());
      }
      if (hasValue()) {
        output.writeBytes(2, getValue());
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasKey()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(1, getKey());
      }
      if (hasValue()) {
        size += com.google.protobuf.CodedOutputStream
          .computeBytesSize(2, getValue());
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol result;
      
      // Construct using akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol();
        return builder;
      }
      
      protected akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.getDescriptor();
      }
      
      public akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol getDefaultInstanceForType() {
        return akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol) {
          return mergeFrom((akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol other) {
        if (other == akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance()) return this;
        if (other.hasKey()) {
          setKey(other.getKey());
        }
        if (other.hasValue()) {
          setValue(other.getValue());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              setKey(input.readString());
              break;
            }
            case 18: {
              setValue(input.readBytes());
              break;
            }
          }
        }
      }
      
      
      // required string key = 1;
      public boolean hasKey() {
        return result.hasKey();
      }
      public java.lang.String getKey() {
        return result.getKey();
      }
      public Builder setKey(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasKey = true;
        result.key_ = value;
        return this;
      }
      public Builder clearKey() {
        result.hasKey = false;
        result.key_ = getDefaultInstance().getKey();
        return this;
      }
      
      // required bytes value = 2;
      public boolean hasValue() {
        return result.hasValue();
      }
      public com.google.protobuf.ByteString getValue() {
        return result.getValue();
      }
      public Builder setValue(com.google.protobuf.ByteString value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasValue = true;
        result.value_ = value;
        return this;
      }
      public Builder clearValue() {
        result.hasValue = false;
        result.value_ = getDefaultInstance().getValue();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:MetadataEntryProtocol)
    }
    
    static {
      defaultInstance = new MetadataEntryProtocol(true);
      akka.remote.protocol.RemoteProtocol.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:MetadataEntryProtocol)
  }
  
  public static final class LifeCycleProtocol extends
      com.google.protobuf.GeneratedMessage {
    // Use LifeCycleProtocol.newBuilder() to construct.
    private LifeCycleProtocol() {
      initFields();
    }
    private LifeCycleProtocol(boolean noInit) {}
    
    private static final LifeCycleProtocol defaultInstance;
    public static LifeCycleProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public LifeCycleProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.internal_static_LifeCycleProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.protocol.RemoteProtocol.internal_static_LifeCycleProtocol_fieldAccessorTable;
    }
    
    // required .LifeCycleType lifeCycle = 1;
    public static final int LIFECYCLE_FIELD_NUMBER = 1;
    private boolean hasLifeCycle;
    private akka.remote.protocol.RemoteProtocol.LifeCycleType lifeCycle_;
    public boolean hasLifeCycle() { return hasLifeCycle; }
    public akka.remote.protocol.RemoteProtocol.LifeCycleType getLifeCycle() { return lifeCycle_; }
    
    private void initFields() {
      lifeCycle_ = akka.remote.protocol.RemoteProtocol.LifeCycleType.PERMANENT;
    }
    public final boolean isInitialized() {
      if (!hasLifeCycle) return false;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasLifeCycle()) {
        output.writeEnum(1, getLifeCycle().getNumber());
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasLifeCycle()) {
        size += com.google.protobuf.CodedOutputStream
          .computeEnumSize(1, getLifeCycle().getNumber());
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.LifeCycleProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private akka.remote.protocol.RemoteProtocol.LifeCycleProtocol result;
      
      // Construct using akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new akka.remote.protocol.RemoteProtocol.LifeCycleProtocol();
        return builder;
      }
      
      protected akka.remote.protocol.RemoteProtocol.LifeCycleProtocol internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new akka.remote.protocol.RemoteProtocol.LifeCycleProtocol();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.getDescriptor();
      }
      
      public akka.remote.protocol.RemoteProtocol.LifeCycleProtocol getDefaultInstanceForType() {
        return akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public akka.remote.protocol.RemoteProtocol.LifeCycleProtocol build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private akka.remote.protocol.RemoteProtocol.LifeCycleProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public akka.remote.protocol.RemoteProtocol.LifeCycleProtocol buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        akka.remote.protocol.RemoteProtocol.LifeCycleProtocol returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.protocol.RemoteProtocol.LifeCycleProtocol) {
          return mergeFrom((akka.remote.protocol.RemoteProtocol.LifeCycleProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.LifeCycleProtocol other) {
        if (other == akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.getDefaultInstance()) return this;
        if (other.hasLifeCycle()) {
          setLifeCycle(other.getLifeCycle());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 8: {
              int rawValue = input.readEnum();
              akka.remote.protocol.RemoteProtocol.LifeCycleType value = akka.remote.protocol.RemoteProtocol.LifeCycleType.valueOf(rawValue);
              if (value == null) {
                unknownFields.mergeVarintField(1, rawValue);
              } else {
                setLifeCycle(value);
              }
              break;
            }
          }
        }
      }
      
      
      // required .LifeCycleType lifeCycle = 1;
      public boolean hasLifeCycle() {
        return result.hasLifeCycle();
      }
      public akka.remote.protocol.RemoteProtocol.LifeCycleType getLifeCycle() {
        return result.getLifeCycle();
      }
      public Builder setLifeCycle(akka.remote.protocol.RemoteProtocol.LifeCycleType value) {
        if (value == null) {
          throw new NullPointerException();
        }
        result.hasLifeCycle = true;
        result.lifeCycle_ = value;
        return this;
      }
      public Builder clearLifeCycle() {
        result.hasLifeCycle = false;
        result.lifeCycle_ = akka.remote.protocol.RemoteProtocol.LifeCycleType.PERMANENT;
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:LifeCycleProtocol)
    }
    
    static {
      defaultInstance = new LifeCycleProtocol(true);
      akka.remote.protocol.RemoteProtocol.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:LifeCycleProtocol)
  }
  
  public static final class AddressProtocol extends
      com.google.protobuf.GeneratedMessage {
    // Use AddressProtocol.newBuilder() to construct.
    private AddressProtocol() {
      initFields();
    }
    private AddressProtocol(boolean noInit) {}
    
    private static final AddressProtocol defaultInstance;
    public static AddressProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public AddressProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.internal_static_AddressProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.protocol.RemoteProtocol.internal_static_AddressProtocol_fieldAccessorTable;
    }
    
    // required string hostname = 1;
    public static final int HOSTNAME_FIELD_NUMBER = 1;
    private boolean hasHostname;
    private java.lang.String hostname_ = "";
    public boolean hasHostname() { return hasHostname; }
    public java.lang.String getHostname() { return hostname_; }
    
    // required uint32 port = 2;
    public static final int PORT_FIELD_NUMBER = 2;
    private boolean hasPort;
    private int port_ = 0;
    public boolean hasPort() { return hasPort; }
    public int getPort() { return port_; }
    
    private void initFields() {
    }
    public final boolean isInitialized() {
      if (!hasHostname) return false;
      if (!hasPort) return false;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasHostname()) {
        output.writeString(1, getHostname());
      }
      if (hasPort()) {
        output.writeUInt32(2, getPort());
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasHostname()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(1, getHostname());
      }
      if (hasPort()) {
        size += com.google.protobuf.CodedOutputStream
          .computeUInt32Size(2, getPort());
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.AddressProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private akka.remote.protocol.RemoteProtocol.AddressProtocol result;
      
      // Construct using akka.remote.protocol.RemoteProtocol.AddressProtocol.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new akka.remote.protocol.RemoteProtocol.AddressProtocol();
        return builder;
      }
      
      protected akka.remote.protocol.RemoteProtocol.AddressProtocol internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new akka.remote.protocol.RemoteProtocol.AddressProtocol();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.protocol.RemoteProtocol.AddressProtocol.getDescriptor();
      }
      
      public akka.remote.protocol.RemoteProtocol.AddressProtocol getDefaultInstanceForType() {
        return akka.remote.protocol.RemoteProtocol.AddressProtocol.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public akka.remote.protocol.RemoteProtocol.AddressProtocol build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private akka.remote.protocol.RemoteProtocol.AddressProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public akka.remote.protocol.RemoteProtocol.AddressProtocol buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        akka.remote.protocol.RemoteProtocol.AddressProtocol returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.protocol.RemoteProtocol.AddressProtocol) {
          return mergeFrom((akka.remote.protocol.RemoteProtocol.AddressProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.AddressProtocol other) {
        if (other == akka.remote.protocol.RemoteProtocol.AddressProtocol.getDefaultInstance()) return this;
        if (other.hasHostname()) {
          setHostname(other.getHostname());
        }
        if (other.hasPort()) {
          setPort(other.getPort());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              setHostname(input.readString());
              break;
            }
            case 16: {
              setPort(input.readUInt32());
              break;
            }
          }
        }
      }
      
      
      // required string hostname = 1;
      public boolean hasHostname() {
        return result.hasHostname();
      }
      public java.lang.String getHostname() {
        return result.getHostname();
      }
      public Builder setHostname(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasHostname = true;
        result.hostname_ = value;
        return this;
      }
      public Builder clearHostname() {
        result.hasHostname = false;
        result.hostname_ = getDefaultInstance().getHostname();
        return this;
      }
      
      // required uint32 port = 2;
      public boolean hasPort() {
        return result.hasPort();
      }
      public int getPort() {
        return result.getPort();
      }
      public Builder setPort(int value) {
        result.hasPort = true;
        result.port_ = value;
        return this;
      }
      public Builder clearPort() {
        result.hasPort = false;
        result.port_ = 0;
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:AddressProtocol)
    }
    
    static {
      defaultInstance = new AddressProtocol(true);
      akka.remote.protocol.RemoteProtocol.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:AddressProtocol)
  }
  
  public static final class ExceptionProtocol extends
      com.google.protobuf.GeneratedMessage {
    // Use ExceptionProtocol.newBuilder() to construct.
    private ExceptionProtocol() {
      initFields();
    }
    private ExceptionProtocol(boolean noInit) {}
    
    private static final ExceptionProtocol defaultInstance;
    public static ExceptionProtocol getDefaultInstance() {
      return defaultInstance;
    }
    
    public ExceptionProtocol getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return akka.remote.protocol.RemoteProtocol.internal_static_ExceptionProtocol_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return akka.remote.protocol.RemoteProtocol.internal_static_ExceptionProtocol_fieldAccessorTable;
    }
    
    // required string classname = 1;
    public static final int CLASSNAME_FIELD_NUMBER = 1;
    private boolean hasClassname;
    private java.lang.String classname_ = "";
    public boolean hasClassname() { return hasClassname; }
    public java.lang.String getClassname() { return classname_; }
    
    // required string message = 2;
    public static final int MESSAGE_FIELD_NUMBER = 2;
    private boolean hasMessage;
    private java.lang.String message_ = "";
    public boolean hasMessage() { return hasMessage; }
    public java.lang.String getMessage() { return message_; }
    
    private void initFields() {
    }
    public final boolean isInitialized() {
      if (!hasClassname) return false;
      if (!hasMessage) return false;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (hasClassname()) {
        output.writeString(1, getClassname());
      }
      if (hasMessage()) {
        output.writeString(2, getMessage());
      }
      getUnknownFields().writeTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public int getSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
    
      size = 0;
      if (hasClassname()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(1, getClassname());
      }
      if (hasMessage()) {
        size += com.google.protobuf.CodedOutputStream
          .computeStringSize(2, getMessage());
      }
      size += getUnknownFields().getSerializedSize();
      memoizedSerializedSize = size;
      return size;
    }
    
    public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.ExceptionProtocol prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder> {
      private akka.remote.protocol.RemoteProtocol.ExceptionProtocol result;
      
      // Construct using akka.remote.protocol.RemoteProtocol.ExceptionProtocol.newBuilder()
      private Builder() {}
      
      private static Builder create() {
        Builder builder = new Builder();
        builder.result = new akka.remote.protocol.RemoteProtocol.ExceptionProtocol();
        return builder;
      }
      
      protected akka.remote.protocol.RemoteProtocol.ExceptionProtocol internalGetResult() {
        return result;
      }
      
      public Builder clear() {
        if (result == null) {
          throw new IllegalStateException(
            "Cannot call clear() after build().");
        }
        result = new akka.remote.protocol.RemoteProtocol.ExceptionProtocol();
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(result);
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return akka.remote.protocol.RemoteProtocol.ExceptionProtocol.getDescriptor();
      }
      
      public akka.remote.protocol.RemoteProtocol.ExceptionProtocol getDefaultInstanceForType() {
        return akka.remote.protocol.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
      }
      
      public boolean isInitialized() {
        return result.isInitialized();
      }
      public akka.remote.protocol.RemoteProtocol.ExceptionProtocol build() {
        if (result != null && !isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return buildPartial();
      }
      
      private akka.remote.protocol.RemoteProtocol.ExceptionProtocol buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        if (!isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return buildPartial();
      }
      
      public akka.remote.protocol.RemoteProtocol.ExceptionProtocol buildPartial() {
        if (result == null) {
          throw new IllegalStateException(
            "build() has already been called on this Builder.");
        }
        akka.remote.protocol.RemoteProtocol.ExceptionProtocol returnMe = result;
        result = null;
        return returnMe;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof akka.remote.protocol.RemoteProtocol.ExceptionProtocol) {
          return mergeFrom((akka.remote.protocol.RemoteProtocol.ExceptionProtocol)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.ExceptionProtocol other) {
        if (other == akka.remote.protocol.RemoteProtocol.ExceptionProtocol.getDefaultInstance()) return this;
        if (other.hasClassname()) {
          setClassname(other.getClassname());
        }
        if (other.hasMessage()) {
          setMessage(other.getMessage());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                return this;
              }
              break;
            }
            case 10: {
              setClassname(input.readString());
              break;
            }
            case 18: {
              setMessage(input.readString());
              break;
            }
          }
        }
      }
      
      
      // required string classname = 1;
      public boolean hasClassname() {
        return result.hasClassname();
      }
      public java.lang.String getClassname() {
        return result.getClassname();
      }
      public Builder setClassname(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasClassname = true;
        result.classname_ = value;
        return this;
      }
      public Builder clearClassname() {
        result.hasClassname = false;
        result.classname_ = getDefaultInstance().getClassname();
        return this;
      }
      
      // required string message = 2;
      public boolean hasMessage() {
        return result.hasMessage();
      }
      public java.lang.String getMessage() {
        return result.getMessage();
      }
      public Builder setMessage(java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  result.hasMessage = true;
        result.message_ = value;
        return this;
      }
      public Builder clearMessage() {
        result.hasMessage = false;
        result.message_ = getDefaultInstance().getMessage();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:ExceptionProtocol)
    }
    
    static {
      defaultInstance = new ExceptionProtocol(true);
      akka.remote.protocol.RemoteProtocol.internalForceInit();
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:ExceptionProtocol)
  }
  
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_AkkaRemoteProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_AkkaRemoteProtocol_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_RemoteMessageProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_RemoteMessageProtocol_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_RemoteControlProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_RemoteControlProtocol_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_RemoteActorRefProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_RemoteActorRefProtocol_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_SerializedActorRefProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_SerializedActorRefProtocol_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_SerializedTypedActorRefProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_MessageProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_MessageProtocol_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_ActorInfoProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_ActorInfoProtocol_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_UuidProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_UuidProtocol_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_MetadataEntryProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_MetadataEntryProtocol_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_LifeCycleProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_LifeCycleProtocol_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_AddressProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_AddressProtocol_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_ExceptionProtocol_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_ExceptionProtocol_fieldAccessorTable;
  
  public static com.google.protobuf.Descriptors.FileDescriptor
      getDescriptor() {
    return descriptor;
  }
  private static com.google.protobuf.Descriptors.FileDescriptor
      descriptor;
  static {
    java.lang.String[] descriptorData = {
      "\n\024RemoteProtocol.proto\"j\n\022AkkaRemoteProt" +
      "ocol\022\'\n\007message\030\001 \001(\0132\026.RemoteMessagePro" +
      "tocol\022+\n\013instruction\030\002 \001(\0132\026.RemoteContr" +
      "olProtocol\"\257\002\n\025RemoteMessageProtocol\022\033\n\004" +
      "uuid\030\001 \002(\0132\r.UuidProtocol\022%\n\tactorInfo\030\002" +
      " \002(\0132\022.ActorInfoProtocol\022\016\n\006oneWay\030\003 \002(\010" +
      "\022!\n\007message\030\004 \001(\0132\020.MessageProtocol\022%\n\te" +
      "xception\030\005 \001(\0132\022.ExceptionProtocol\022%\n\016su" +
      "pervisorUuid\030\006 \001(\0132\r.UuidProtocol\022\'\n\006sen" +
      "der\030\007 \001(\0132\027.RemoteActorRefProtocol\022(\n\010me",
      "tadata\030\010 \003(\0132\026.MetadataEntryProtocol\"J\n\025" +
      "RemoteControlProtocol\022\016\n\006cookie\030\001 \001(\t\022!\n" +
      "\013commandType\030\002 \002(\0162\014.CommandType\"U\n\026Remo" +
      "teActorRefProtocol\022\017\n\007address\030\001 \002(\t\022\031\n\021i" +
      "netSocketAddress\030\002 \002(\014\022\017\n\007timeout\030\003 \001(\004\"" +
      "\277\003\n\032SerializedActorRefProtocol\022\033\n\004uuid\030\001" +
      " \002(\0132\r.UuidProtocol\022\017\n\007address\030\002 \002(\t\022\026\n\016" +
      "actorClassname\030\003 \002(\t\022\025\n\ractorInstance\030\004 " +
      "\001(\014\022\033\n\023serializerClassname\030\005 \001(\t\022\017\n\007time" +
      "out\030\006 \001(\004\022\026\n\016receiveTimeout\030\007 \001(\004\022%\n\tlif",
      "eCycle\030\010 \001(\0132\022.LifeCycleProtocol\022+\n\nsupe" +
      "rvisor\030\t \001(\0132\027.RemoteActorRefProtocol\022\024\n" +
      "\014hotswapStack\030\n \001(\014\0223\n\022replicationStorag" +
      "e\030\013 \001(\0162\027.ReplicationStorageType\0225\n\023repl" +
      "icationStrategy\030\014 \001(\0162\030.ReplicationStrat" +
      "egyType\022(\n\010messages\030\r \003(\0132\026.RemoteMessag" +
      "eProtocol\"g\n\037SerializedTypedActorRefProt" +
      "ocol\022-\n\010actorRef\030\001 \002(\0132\033.SerializedActor" +
      "RefProtocol\022\025\n\rinterfaceName\030\002 \002(\t\";\n\017Me" +
      "ssageProtocol\022\017\n\007message\030\001 \002(\014\022\027\n\017messag",
      "eManifest\030\002 \001(\014\"R\n\021ActorInfoProtocol\022\033\n\004" +
      "uuid\030\001 \002(\0132\r.UuidProtocol\022\017\n\007timeout\030\002 \002" +
      "(\004\022\017\n\007address\030\003 \001(\t\")\n\014UuidProtocol\022\014\n\004h" +
      "igh\030\001 \002(\004\022\013\n\003low\030\002 \002(\004\"3\n\025MetadataEntryP" +
      "rotocol\022\013\n\003key\030\001 \002(\t\022\r\n\005value\030\002 \002(\014\"6\n\021L" +
      "ifeCycleProtocol\022!\n\tlifeCycle\030\001 \002(\0162\016.Li" +
      "feCycleType\"1\n\017AddressProtocol\022\020\n\010hostna" +
      "me\030\001 \002(\t\022\014\n\004port\030\002 \002(\r\"7\n\021ExceptionProto" +
      "col\022\021\n\tclassname\030\001 \002(\t\022\017\n\007message\030\002 \002(\t*" +
      "(\n\013CommandType\022\013\n\007CONNECT\020\001\022\014\n\010SHUTDOWN\020",
      "\002*K\n\026ReplicationStorageType\022\r\n\tTRANSIENT" +
      "\020\001\022\023\n\017TRANSACTION_LOG\020\002\022\r\n\tDATA_GRID\020\003*>" +
      "\n\027ReplicationStrategyType\022\021\n\rWRITE_THROU" +
      "GH\020\001\022\020\n\014WRITE_BEHIND\020\002*]\n\027SerializationS" +
      "chemeType\022\010\n\004JAVA\020\001\022\013\n\007SBINARY\020\002\022\016\n\nSCAL" +
      "A_JSON\020\003\022\r\n\tJAVA_JSON\020\004\022\014\n\010PROTOBUF\020\005*-\n" +
      "\rLifeCycleType\022\r\n\tPERMANENT\020\001\022\r\n\tTEMPORA" +
      "RY\020\002B\030\n\024akka.remote.protocolH\001"
    };
    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
      new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
        public com.google.protobuf.ExtensionRegistry assignDescriptors(
            com.google.protobuf.Descriptors.FileDescriptor root) {
          descriptor = root;
          internal_static_AkkaRemoteProtocol_descriptor =
            getDescriptor().getMessageTypes().get(0);
          internal_static_AkkaRemoteProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_AkkaRemoteProtocol_descriptor,
              new java.lang.String[] { "Message", "Instruction", },
              akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol.class,
              akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol.Builder.class);
          internal_static_RemoteMessageProtocol_descriptor =
            getDescriptor().getMessageTypes().get(1);
          internal_static_RemoteMessageProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_RemoteMessageProtocol_descriptor,
              new java.lang.String[] { "Uuid", "ActorInfo", "OneWay", "Message", "Exception", "SupervisorUuid", "Sender", "Metadata", },
              akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.class,
              akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.Builder.class);
          internal_static_RemoteControlProtocol_descriptor =
            getDescriptor().getMessageTypes().get(2);
          internal_static_RemoteControlProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_RemoteControlProtocol_descriptor,
              new java.lang.String[] { "Cookie", "CommandType", },
              akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.class,
              akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.Builder.class);
          internal_static_RemoteActorRefProtocol_descriptor =
            getDescriptor().getMessageTypes().get(3);
          internal_static_RemoteActorRefProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_RemoteActorRefProtocol_descriptor,
              new java.lang.String[] { "Address", "InetSocketAddress", "Timeout", },
              akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.class,
              akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.Builder.class);
          internal_static_SerializedActorRefProtocol_descriptor =
            getDescriptor().getMessageTypes().get(4);
          internal_static_SerializedActorRefProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_SerializedActorRefProtocol_descriptor,
              new java.lang.String[] { "Uuid", "Address", "ActorClassname", "ActorInstance", "SerializerClassname", "Timeout", "ReceiveTimeout", "LifeCycle", "Supervisor", "HotswapStack", "ReplicationStorage", "ReplicationStrategy", "Messages", },
              akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.class,
              akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.Builder.class);
          internal_static_SerializedTypedActorRefProtocol_descriptor =
            getDescriptor().getMessageTypes().get(5);
          internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_SerializedTypedActorRefProtocol_descriptor,
              new java.lang.String[] { "ActorRef", "InterfaceName", },
              akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.class,
              akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.Builder.class);
          internal_static_MessageProtocol_descriptor =
            getDescriptor().getMessageTypes().get(6);
          internal_static_MessageProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_MessageProtocol_descriptor,
              new java.lang.String[] { "Message", "MessageManifest", },
              akka.remote.protocol.RemoteProtocol.MessageProtocol.class,
              akka.remote.protocol.RemoteProtocol.MessageProtocol.Builder.class);
          internal_static_ActorInfoProtocol_descriptor =
            getDescriptor().getMessageTypes().get(7);
          internal_static_ActorInfoProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_ActorInfoProtocol_descriptor,
              new java.lang.String[] { "Uuid", "Timeout", "Address", },
              akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.class,
              akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.Builder.class);
          internal_static_UuidProtocol_descriptor =
            getDescriptor().getMessageTypes().get(8);
          internal_static_UuidProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_UuidProtocol_descriptor,
              new java.lang.String[] { "High", "Low", },
              akka.remote.protocol.RemoteProtocol.UuidProtocol.class,
              akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder.class);
          internal_static_MetadataEntryProtocol_descriptor =
            getDescriptor().getMessageTypes().get(9);
          internal_static_MetadataEntryProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_MetadataEntryProtocol_descriptor,
              new java.lang.String[] { "Key", "Value", },
              akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.class,
              akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.Builder.class);
          internal_static_LifeCycleProtocol_descriptor =
            getDescriptor().getMessageTypes().get(10);
          internal_static_LifeCycleProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_LifeCycleProtocol_descriptor,
              new java.lang.String[] { "LifeCycle", },
              akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.class,
              akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.Builder.class);
          internal_static_AddressProtocol_descriptor =
            getDescriptor().getMessageTypes().get(11);
          internal_static_AddressProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_AddressProtocol_descriptor,
              new java.lang.String[] { "Hostname", "Port", },
              akka.remote.protocol.RemoteProtocol.AddressProtocol.class,
              akka.remote.protocol.RemoteProtocol.AddressProtocol.Builder.class);
          internal_static_ExceptionProtocol_descriptor =
            getDescriptor().getMessageTypes().get(12);
          internal_static_ExceptionProtocol_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_ExceptionProtocol_descriptor,
              new java.lang.String[] { "Classname", "Message", },
              akka.remote.protocol.RemoteProtocol.ExceptionProtocol.class,
              akka.remote.protocol.RemoteProtocol.ExceptionProtocol.Builder.class);
          return null;
        }
      };
    com.google.protobuf.Descriptors.FileDescriptor
      .internalBuildGeneratedFileFrom(descriptorData,
        new com.google.protobuf.Descriptors.FileDescriptor[] {
        }, assigner);
  }
  
  public static void internalForceInit() {}
  
  // @@protoc_insertion_point(outer_class_scope)
}